deepline 0.1.243 → 0.1.244

package/dist/bundling-sources/apps/play-runner-workers/src/runtime/run-work-dispatcher.ts

@@ -1,519 +0,0 @@
-import {
-  shouldYieldWorkerWorkBudget,
-  type WorkerWorkBudgetMeter,
-  type WorkerWorkBudgetSnapshot,
-  type WorkerWorkBudgetYieldLimits,
-  type WorkerWorkBudgetYieldReason,
-} from './work-budget';
-
-export type WorkerMapWorkYield = {
-  kind: 'map_chunk';
-  mapName: string;
-  nextChunkIndex: number;
-  nextChunkStart: number;
-  reason: WorkerWorkBudgetYieldReason;
-  attempt: number;
-  budget: WorkerWorkBudgetSnapshot;
-};
-
-export type WorkerMapWorkYieldResult = {
-  // `freshBudget` means the yield crossed a real platform boundary that resets
-  // the per-invocation resource budget (subrequests/CPU). Under Cloudflare
-  // Workflows a completed `workflowStep.sleep` re-enters `run()` as a NEW
-  // Worker invocation with a fresh per-invocation subrequest budget (completed
-  // steps replay from the durable cache without re-issuing subrequests), so the
-  // native workflow yield reports `true`. It is NOT keyed on isolate identity:
-  // Cloudflare reuses warm isolates across invocations, so a fresh-budget
-  // resume commonly shares the pre-sleep isolate. When no durable step boundary
-  // is available (non-workflow execution), the yield cannot reset the platform
-  // budget and reports `false`, which the dispatcher escalates and then fails
-  // loudly instead of silently overflowing.
-  freshBudget: boolean;
-};
-
-export type WorkerMapWorkBatch<TRawRow, TExecutableRow> = {
-  rawRows: TRawRow[];
-  rows: TExecutableRow[];
-  chunkStart: number;
-  chunkIndex: number;
-};
-
-export type WorkerRunWorkDispatcherTrace = {
-  phase: string;
-  ms?: number;
-  extra?: Record<string, unknown>;
-};
-
-export type WorkerRunWorkDispatcherOptions = {
-  budgetMeter: WorkerWorkBudgetMeter;
-  nowMs: () => number;
-  yieldLimits?: WorkerWorkBudgetYieldLimits;
-  maxStaleYieldAttempts?: number;
-  recordTrace?: (trace: WorkerRunWorkDispatcherTrace) => void;
-  yieldBetweenChunks?: (
-    yieldPoint: WorkerMapWorkYield,
-  ) => Promise<WorkerMapWorkYieldResult>;
-};
-
-export type WorkerRunMapBatchesInput<TRawRow, TExecutableRow, TResult> = {
-  mapName: string;
-  chunks: AsyncIterable<TRawRow[]> | Iterable<TRawRow[]>;
-  maxConcurrentChunks?: number;
-  maxResidentBatchBytes?: number;
-  prepareBatch: (
-    rawRows: TRawRow[],
-    chunkStart: number,
-    chunkIndex: number,
-  ) => TExecutableRow[];
-  estimateRawBatchResidentBytes?: (
-    rawRows: TRawRow[],
-    chunkStart: number,
-    chunkIndex: number,
-  ) => number;
-  executeBatch: (
-    batch: WorkerMapWorkBatch<TRawRow, TExecutableRow>,
-  ) => Promise<TResult>;
-  estimateBatchSubrequests?: (
-    batch: WorkerMapWorkBatch<TRawRow, TExecutableRow>,
-  ) => number;
-  estimateBatchResidentBytes?: (
-    batch: WorkerMapWorkBatch<TRawRow, TExecutableRow>,
-  ) => number;
-  onBatchComplete: (
-    result: TResult,
-    batch: WorkerMapWorkBatch<TRawRow, TExecutableRow>,
-  ) => Promise<boolean | void> | boolean | void;
-};
-
-export type WorkerRunMapBatchesResult = {
-  chunksSeen: number;
-  chunksExecuted: number;
-  yieldPoints: WorkerMapWorkYield[];
-};
-
-export class WorkerBudgetExhaustedError extends Error {
-  readonly mapName: string;
-  readonly reason: WorkerWorkBudgetYieldReason;
-  readonly attempts: number;
-  readonly budget: WorkerWorkBudgetSnapshot;
-
-  constructor(input: {
-    mapName: string;
-    reason: WorkerWorkBudgetYieldReason;
-    attempts: number;
-    budget: WorkerWorkBudgetSnapshot;
-  }) {
-    super(
-      `Runtime dispatcher cannot continue ctx.dataset("${input.mapName}") after ${input.reason} budget pressure without a fresh platform budget.`,
-    );
-    this.name = 'WorkerBudgetExhaustedError';
-    this.mapName = input.mapName;
-    this.reason = input.reason;
-    this.attempts = input.attempts;
-    this.budget = input.budget;
-  }
-}
-
-const DEFAULT_STALE_YIELD_ATTEMPTS = 3;
-export const WORKER_RUN_DISPATCHER_DEFAULT_MAX_RESIDENT_ROW_BYTES =
-  32 * 1024 * 1024;
-
-export class WorkerRunWorkDispatcher {
-  constructor(private readonly options: WorkerRunWorkDispatcherOptions) {}
-
-  private async yieldForBudgetPressure(input: {
-    mapName: string;
-    chunkIndex: number;
-    chunkStart: number;
-    reason: WorkerWorkBudgetYieldReason;
-    snapshot: WorkerWorkBudgetSnapshot;
-    startedAt: number;
-    yieldPoints: WorkerMapWorkYield[];
-  }): Promise<void> {
-    const maxAttempts =
-      this.options.maxStaleYieldAttempts ?? DEFAULT_STALE_YIELD_ATTEMPTS;
-    for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
-      const yieldPoint: WorkerMapWorkYield = {
-        kind: 'map_chunk',
-        mapName: input.mapName,
-        nextChunkIndex: input.chunkIndex,
-        nextChunkStart: input.chunkStart,
-        reason: input.reason,
-        attempt,
-        budget: input.snapshot,
-      };
-      input.yieldPoints.push(yieldPoint);
-      this.options.recordTrace?.({
-        phase: 'runner.work_dispatcher.yield',
-        ms: this.options.nowMs() - input.startedAt,
-        extra: {
-          mapName: input.mapName,
-          nextChunkIndex: yieldPoint.nextChunkIndex,
-          nextChunkStart: yieldPoint.nextChunkStart,
-          reason: yieldPoint.reason,
-          attempt: yieldPoint.attempt,
-          budgetCounts: yieldPoint.budget.counts,
-          elapsedMs: yieldPoint.budget.elapsedMs,
-        },
-      });
-      const yieldResult = await this.options.yieldBetweenChunks?.(yieldPoint);
-      if (yieldResult?.freshBudget) {
-        this.options.budgetMeter.resetWindow();
-        return;
-      }
-      this.options.recordTrace?.({
-        phase: 'runner.work_dispatcher.stale_yield',
-        ms: this.options.nowMs() - input.startedAt,
-        extra: {
-          mapName: input.mapName,
-          nextChunkIndex: yieldPoint.nextChunkIndex,
-          nextChunkStart: yieldPoint.nextChunkStart,
-          reason: yieldPoint.reason,
-          attempt: yieldPoint.attempt,
-        },
-      });
-      if (attempt === maxAttempts - 1) {
-        throw new WorkerBudgetExhaustedError({
-          mapName: input.mapName,
-          reason: yieldPoint.reason,
-          attempts: maxAttempts,
-          budget: yieldPoint.budget,
-        });
-      }
-    }
-  }
-
-  async runMapBatches<TRawRow, TExecutableRow, TResult>(
-    input: WorkerRunMapBatchesInput<TRawRow, TExecutableRow, TResult>,
-  ): Promise<WorkerRunMapBatchesResult> {
-    const startedAt = this.options.nowMs();
-    const maxConcurrentChunks = Math.max(
-      1,
-      Math.floor(input.maxConcurrentChunks ?? 1),
-    );
-    let chunkStart = 0;
-    let chunkIndex = 0;
-    let chunksSeen = 0;
-    let chunksExecuted = 0;
-    const yieldPoints: WorkerMapWorkYield[] = [];
-    const iterator = toAsyncIterator(input.chunks);
-    let next: IteratorResult<TRawRow[]> | null = null;
-    const maxResidentBatchBytes =
-      input.maxResidentBatchBytes ??
-      WORKER_RUN_DISPATCHER_DEFAULT_MAX_RESIDENT_ROW_BYTES;
-    const peekNext = async (): Promise<IteratorResult<TRawRow[]>> => {
-      next ??= await iterator.next();
-      return next;
-    };
-    const consumeNext = () => {
-      next = null;
-    };
-    type InFlightChunk = {
-      batch: WorkerMapWorkBatch<TRawRow, TExecutableRow>;
-      projectedSubrequests: number;
-      residentBytes: number;
-      result: Promise<TResult>;
-    };
-    const inFlight: InFlightChunk[] = [];
-    let shouldStop = false;
-    const inFlightResidentBytes = () =>
-      inFlight.reduce((total, chunk) => total + chunk.residentBytes, 0);
-    const estimateResidentBytes = (
-      batch: WorkerMapWorkBatch<TRawRow, TExecutableRow>,
-    ): number =>
-      Math.max(0, Math.floor(input.estimateBatchResidentBytes?.(batch) ?? 0));
-    const estimateRawResidentBytes = (
-      rawRows: TRawRow[],
-      start: number,
-      index: number,
-    ): number =>
-      Math.max(
-        0,
-        Math.floor(
-          input.estimateRawBatchResidentBytes?.(rawRows, start, index) ?? 0,
-        ),
-      );
-
-    const launchAvailableChunks = async () => {
-      while (
-        maxConcurrentChunks > 1 &&
-        !shouldStop &&
-        inFlight.length < maxConcurrentChunks
-      ) {
-        const admissionYieldDecision = shouldYieldWorkerWorkBudget({
-          meter: this.options.budgetMeter,
-          limits: this.options.yieldLimits,
-        });
-        if (
-          admissionYieldDecision.shouldYield &&
-          admissionYieldDecision.reason
-        ) {
-          if (inFlight.length > 0) return;
-          await this.yieldForBudgetPressure({
-            mapName: input.mapName,
-            chunkIndex,
-            chunkStart,
-            reason: admissionYieldDecision.reason,
-            snapshot: admissionYieldDecision.snapshot,
-            startedAt,
-            yieldPoints,
-          });
-          continue;
-        }
-        const current = await peekNext();
-        if (current.done) return;
-        const rawRows = current.value;
-        if (rawRows.length === 0) {
-          chunksSeen += 1;
-          consumeNext();
-          continue;
-        }
-        const rawResidentBytes = estimateRawResidentBytes(
-          rawRows,
-          chunkStart,
-          chunkIndex,
-        );
-        if (
-          rawResidentBytes > 0 &&
-          inFlightResidentBytes() + rawResidentBytes > maxResidentBatchBytes
-        ) {
-          if (inFlight.length > 0) return;
-          throw new WorkerResidentRowBudgetExceededError({
-            mapName: input.mapName,
-            chunkIndex,
-            residentBytes: rawResidentBytes,
-            limitBytes: maxResidentBatchBytes,
-          });
-        }
-        const rows = input.prepareBatch(rawRows, chunkStart, chunkIndex);
-        if (rows.length === 0) {
-          chunksSeen += 1;
-          consumeNext();
-          chunkStart += rawRows.length;
-          continue;
-        }
-        const batch = {
-          rawRows,
-          rows,
-          chunkStart,
-          chunkIndex,
-        };
-        const residentBytes = estimateResidentBytes(batch);
-        const projectedResidentBytes = inFlightResidentBytes() + residentBytes;
-        if (projectedResidentBytes > maxResidentBatchBytes) {
-          if (inFlight.length > 0) return;
-          throw new WorkerResidentRowBudgetExceededError({
-            mapName: input.mapName,
-            chunkIndex,
-            residentBytes,
-            limitBytes: maxResidentBatchBytes,
-          });
-        }
-        const projectedSubrequests = Math.max(
-          0,
-          Math.floor(input.estimateBatchSubrequests?.(batch) ?? 0),
-        );
-        const alreadyProjected = inFlight.reduce(
-          (total, chunk) => total + chunk.projectedSubrequests,
-          0,
-        );
-        const preChunkYieldDecision = shouldYieldWorkerWorkBudget({
-          meter: this.options.budgetMeter,
-          limits: this.options.yieldLimits,
-          projectedSubrequests: alreadyProjected + projectedSubrequests,
-        });
-        if (preChunkYieldDecision.shouldYield && preChunkYieldDecision.reason) {
-          if (inFlight.length > 0) return;
-          await this.yieldForBudgetPressure({
-            mapName: input.mapName,
-            chunkIndex,
-            chunkStart,
-            reason: preChunkYieldDecision.reason,
-            snapshot: preChunkYieldDecision.snapshot,
-            startedAt,
-            yieldPoints,
-          });
-        }
-        const result = input.executeBatch(batch);
-        result.catch(() => undefined);
-        inFlight.push({
-          batch,
-          projectedSubrequests,
-          residentBytes,
-          result,
-        });
-        chunksSeen += 1;
-        consumeNext();
-        chunkStart += rawRows.length;
-        chunkIndex += 1;
-      }
-    };
-
-    if (maxConcurrentChunks <= 1) {
-      while (true) {
-        const current = await peekNext();
-        if (current.done) break;
-        const rawRows = current.value;
-        chunksSeen += 1;
-        consumeNext();
-        if (rawRows.length === 0) {
-          continue;
-        }
-        const rows = input.prepareBatch(rawRows, chunkStart, chunkIndex);
-        if (rows.length === 0) {
-          chunkStart += rawRows.length;
-          continue;
-        }
-        const batch = {
-          rawRows,
-          rows,
-          chunkStart,
-          chunkIndex,
-        };
-        const preChunkYieldDecision = shouldYieldWorkerWorkBudget({
-          meter: this.options.budgetMeter,
-          limits: this.options.yieldLimits,
-          projectedSubrequests: input.estimateBatchSubrequests?.(batch),
-        });
-        if (preChunkYieldDecision.shouldYield && preChunkYieldDecision.reason) {
-          await this.yieldForBudgetPressure({
-            mapName: input.mapName,
-            chunkIndex,
-            chunkStart,
-            reason: preChunkYieldDecision.reason,
-            snapshot: preChunkYieldDecision.snapshot,
-            startedAt,
-            yieldPoints,
-          });
-        }
-        const result = await input.executeBatch(batch);
-        chunksExecuted += 1;
-        const shouldStop = await input.onBatchComplete(result, batch);
-        chunkStart += rawRows.length;
-        chunkIndex += 1;
-        if (shouldStop === true) break;
-        const upcoming = await peekNext();
-
-        const yieldDecision = shouldYieldWorkerWorkBudget({
-          meter: this.options.budgetMeter,
-          limits: this.options.yieldLimits,
-        });
-        if (
-          !upcoming.done &&
-          yieldDecision.shouldYield &&
-          yieldDecision.reason
-        ) {
-          await this.yieldForBudgetPressure({
-            mapName: input.mapName,
-            chunkIndex,
-            chunkStart,
-            reason: yieldDecision.reason,
-            snapshot: yieldDecision.snapshot,
-            startedAt,
-            yieldPoints,
-          });
-        }
-      }
-    } else {
-      // Bounded worker pool: keep up to K `executeBatch` calls in flight, but
-      // funnel their results through a single serialized `onBatchComplete` chain
-      // in submission (FIFO) order so counter aggregation, preview/cache
-      // ordering, and progress ordering stay deterministic regardless of which
-      // chunk's provider work settles first.
-      let pendingError: unknown = null;
-      const drainInFlight = async () => {
-        if (inFlight.length > 0) {
-          await Promise.allSettled(inFlight.map((chunk) => chunk.result));
-        }
-      };
-      const launchOrAbort = async () => {
-        try {
-          await launchAvailableChunks();
-        } catch (error) {
-          pendingError = error;
-          shouldStop = true;
-          await drainInFlight();
-          throw error;
-        }
-      };
-      await launchOrAbort();
-      while (inFlight.length > 0) {
-        const nextChunk = inFlight.shift()!;
-        try {
-          const result = await nextChunk.result;
-          chunksExecuted += 1;
-          const batchShouldStop = await input.onBatchComplete(
-            result,
-            nextChunk.batch,
-          );
-          if (batchShouldStop === true) {
-            shouldStop = true;
-          }
-        } catch (error) {
-          // A chunk error aborts the map (matching the sequential path), but we
-          // fail loud only after the chunks already in flight settle so no
-          // detached executeBatch promise keeps writing behind our back.
-          pendingError = error;
-          shouldStop = true;
-          break;
-        }
-        if (!shouldStop) {
-          await launchOrAbort();
-        }
-      }
-      await drainInFlight();
-      if (pendingError) throw pendingError;
-    }
-
-    this.options.recordTrace?.({
-      phase: 'runner.work_dispatcher.total',
-      ms: this.options.nowMs() - startedAt,
-      extra: {
-        mapName: input.mapName,
-        chunksSeen,
-        chunksExecuted,
-        maxConcurrentChunks,
-        yieldPoints: yieldPoints.length,
-      },
-    });
-
-    return { chunksSeen, chunksExecuted, yieldPoints };
-  }
-}
-
-export class WorkerResidentRowBudgetExceededError extends Error {
-  readonly mapName: string;
-  readonly chunkIndex: number;
-  readonly residentBytes: number;
-  readonly limitBytes: number;
-
-  constructor(input: {
-    mapName: string;
-    chunkIndex: number;
-    residentBytes: number;
-    limitBytes: number;
-  }) {
-    super(
-      `Runtime dispatcher cannot admit ctx.dataset("${input.mapName}") chunk ${input.chunkIndex}: estimated resident row payload ${input.residentBytes} bytes exceeds the ${input.limitBytes} byte cap.`,
-    );
-    this.name = 'WorkerResidentRowBudgetExceededError';
-    this.mapName = input.mapName;
-    this.chunkIndex = input.chunkIndex;
-    this.residentBytes = input.residentBytes;
-    this.limitBytes = input.limitBytes;
-  }
-}
-
-function toAsyncIterator<T>(
-  input: AsyncIterable<T> | Iterable<T>,
-): AsyncIterator<T> {
-  if (Symbol.asyncIterator in input) {
-    return input[Symbol.asyncIterator]();
-  }
-  const iterator = input[Symbol.iterator]();
-  return {
-    async next() {
-      return iterator.next();
-    },
-  };
-}

package/dist/bundling-sources/apps/play-runner-workers/src/runtime/tool-batch.ts

@@ -1,107 +0,0 @@
-/**
- * Per-play Worker tool batch executor.
- *
- * This is intentionally local to the Worker bundle. Pulling the shared
- * executor module back in would widen the bundle graph for a tiny helper.
- */
-
-export type ToolBatchRequest = {
-  runId: string;
-  orgId: string;
-  toolId: string;
-  operation: string;
-  provider: string;
-  items: Array<{
-    itemKey: string;
-    payload: Record<string, unknown>;
-    inputHash?: string | null;
-  }>;
-  waterfallId?: string | null;
-  stageId?: string | null;
-  fieldName?: string | null;
-  mapName?: string | null;
-  chunkIndex?: number | null;
-  userProvidedRateLimitKey?: string | null;
-  providerBatchSize: number;
-};
-
-type ToolBatchItemResult = {
-  itemKey: string;
-  result: unknown;
-  cached?: boolean;
-};
-
-export function createToolBatchExecutor(input: {
-  executeProviderBatch(batch: {
-    request: ToolBatchRequest;
-    batchIndex: number;
-    idempotencyKeys: string[];
-    rateLimitKey: string;
-    items: ToolBatchRequest['items'];
-  }): Promise<ToolBatchItemResult[]>;
-}) {
-  return {
-    async executeToolBatch(request: ToolBatchRequest) {
-      const providerBatchSize = Math.max(
-        1,
-        Math.floor(request.providerBatchSize),
-      );
-      const batches: Array<ToolBatchRequest['items']> = [];
-      for (
-        let index = 0;
-        index < request.items.length;
-        index += providerBatchSize
-      ) {
-        batches.push(request.items.slice(index, index + providerBatchSize));
-      }
-      const results: ToolBatchItemResult[] = [];
-      for (let batchIndex = 0; batchIndex < batches.length; batchIndex += 1) {
-        const items = batches[batchIndex]!;
-        results.push(
-          ...(await input.executeProviderBatch({
-            request,
-            batchIndex,
-            items,
-            rateLimitKey: [
-              request.orgId,
-              request.provider,
-              request.operation,
-              request.userProvidedRateLimitKey ?? '',
-            ].join(':'),
-            idempotencyKeys: items.map((item) =>
-              [
-                request.runId,
-                request.mapName ?? '',
-                request.chunkIndex ?? '',
-                item.itemKey,
-                request.fieldName ?? '',
-                request.waterfallId ?? '',
-                request.stageId ?? '',
-                item.inputHash ?? stableStringify(item.payload),
-              ].join(':'),
-            ),
-          })),
-        );
-      }
-      return {
-        runId: request.runId,
-        toolId: request.toolId,
-        operation: request.operation,
-        provider: request.provider,
-        batchCount: batches.length,
-        itemCount: request.items.length,
-        results,
-      };
-    },
-  };
-}
-
-function stableStringify(value: unknown): string {
-  if (value === null || typeof value !== 'object') return JSON.stringify(value);
-  if (Array.isArray(value)) return `[${value.map(stableStringify).join(',')}]`;
-  const record = value as Record<string, unknown>;
-  return `{${Object.keys(record)
-    .sort()
-    .map((key) => `${JSON.stringify(key)}:${stableStringify(record[key])}`)
-    .join(',')}}`;
-}