Class RuntimeEvolveWorker

runtime/api-server/src/evolve-worker.ts:50–196

}

export class RuntimeEvolveWorker implements DurableMemoryWorkerLike {
  readonly #store: RuntimeStateStore;
  readonly #logger: RuntimeEvolveWorkerOptions["logger"];
  readonly #executeClaimedJob: (record: PostRunJobRecord) => Promise<void>;
  readonly #claimedBy: string;
  readonly #leaseSeconds: number;
  readonly #pollIntervalMs: number;
  readonly #maxConcurrency: number;
  readonly #maxAttempts: number;
  readonly #retryDelayMs: number;
  #stopped = false;
  #task: Promise<void> | null = null;
  #wakeResolver: (() => void) | null = null;

  constructor(options: RuntimeEvolveWorkerOptions) {
    this.#store = options.store;
    this.#logger = options.logger;
    this.#claimedBy = options.claimedBy ?? DEFAULT_CLAIMED_BY;
    this.#executeClaimedJob =
      options.executeClaimedJob ??
      ((record) =>
        processEvolveJob({
          store: this.#store,
          record,
          memoryService: options.memoryService,
        }));
    this.#leaseSeconds = options.leaseSeconds ?? DEFAULT_LEASE_SECONDS;
    this.#pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
    this.#maxConcurrency = options.maxConcurrency ?? workerMaxConcurrency();
    this.#maxAttempts = Math.max(1, options.maxAttempts ?? DEFAULT_MAX_ATTEMPTS);
    this.#retryDelayMs = Math.max(0, options.retryDelayMs ?? DEFAULT_RETRY_DELAY_MS);
  }

  async start(): Promise<void> {
    if (this.#task) {
      return;
    }
    this.#stopped = false;
    this.#task = this.#runLoop();
  }

  wake(): void {
    const resolve = this.#wakeResolver;
    this.#wakeResolver = null;
    resolve?.();
  }

  async close(): Promise<void> {
    this.#stopped = true;
    this.wake();
    const task = this.#task;
    this.#task = null;
    await task;
  }

  async processAvailableJobsOnce(): Promise<number> {
    const recovered = this.#recoverExpiredClaims();
    const claimed = this.#store.claimPostRunJobs({