deepline 0.1.243 → 0.1.244

package/dist/bundling-sources/apps/play-runner-workers/src/runtime/README.md

@@ -1,21 +0,0 @@
-# Per-play Worker Runtime
-
-These modules are bundled into every `esm_workers` play artifact. Keep them:
-
-- dependency-free, except for type-only imports
-- small enough to understand in one sitting
-- specific to the Cloudflare Worker execution path
-
-Do not import broad `shared_libs/play-runtime/*` modules here. Shared runtime
-modules are optimized for the Node runner and often bring along code
-that is correct but expensive in a per-graphHash Worker isolate.
-
-If a helper needs zod, Neon, runtime API transport, validation registries, or
-other heavy leaves, put it behind the `env.HARNESS` service binding in
-`apps/play-harness-worker` and call it through `sdk/src/plays/harness-stub.ts`.
-
-The intended split is:
-
-- `entry.ts`: request/workflow orchestration and ctx construction
-- `runtime/*`: tiny per-play primitives that must execute in the isolate
-- `apps/play-harness-worker`: heavy shared leaves kept warm behind RPC

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

@@ -1,251 +0,0 @@
-/**
- * Tiny batching helpers for the per-play Worker runtime.
- *
- * This mirrors the small subset of shared_libs/play-runtime batching that the
- * Workers harness needs without importing the broader shared runtime graph.
- */
-
-import type { AnyBatchOperationStrategy } from '../../../../shared_libs/play-runtime/batching-types';
-
-export type ChunkExecutionResult<TRequest, TResult> = {
-  request: TRequest;
-  result: TResult | null;
-  /**
-   * Present when this request's execution rejected. The request failed but
-   * its siblings in the chunk kept their results — one provider hiccup must
-   * stay a per-request failure, not a chunk-level abort that discards
-   * completed sibling work.
-   */
-  error?: unknown;
-};
-
-function planExecutionChunks<TRequest>(
-  requests: TRequest[],
-  batchSize: number,
-  maxChunkWeight: number | undefined,
-  weightOf: ((request: TRequest) => number) | undefined,
-): TRequest[][] {
-  const maxUnits = Math.max(1, Math.floor(batchSize));
-  const weightCap =
-    maxChunkWeight != null && weightOf != null
-      ? Math.max(1, Math.floor(maxChunkWeight))
-      : null;
-  const chunks: TRequest[][] = [];
-  let current: TRequest[] = [];
-  let weight = 0;
-  for (const request of requests) {
-    if (
-      current.length > 0 &&
-      (current.length >= maxUnits ||
-        (weightCap != null && weight >= weightCap))
-    ) {
-      chunks.push(current);
-      current = [];
-      weight = 0;
-    }
-    current.push(request);
-    if (weightCap != null && weightOf != null) {
-      weight += Math.max(1, Math.floor(weightOf(request)));
-    }
-  }
-  if (current.length > 0) chunks.push(current);
-  return chunks;
-}
-
-export async function executeChunkedRequests<TRequest, TResult>(input: {
-  requests: TRequest[];
-  batchSize: number;
-  maxChunkWeight?: number;
-  weightOf?: (request: TRequest) => number;
-  execute: (request: TRequest) => Promise<TResult>;
-  onChunkComplete?: (
-    results: Array<ChunkExecutionResult<TRequest, TResult>>,
-  ) => void | Promise<void>;
-}): Promise<Array<ChunkExecutionResult<TRequest, TResult>>> {
-  const results: Array<ChunkExecutionResult<TRequest, TResult>> = [];
-  const chunks = planExecutionChunks(
-    input.requests,
-    input.batchSize,
-    input.maxChunkWeight,
-    input.weightOf,
-  );
-  for (const chunk of chunks) {
-    let notifyChain: Promise<void> = Promise.resolve();
-    const notify = async (
-      entry: ChunkExecutionResult<TRequest, TResult>,
-    ): Promise<void> => {
-      results.push(entry);
-      notifyChain = notifyChain.then(
-        async () => await input.onChunkComplete?.([entry]),
-      );
-      await notifyChain;
-    };
-
-    await Promise.all(
-      chunk.map(async (request) => {
-        let entry: ChunkExecutionResult<TRequest, TResult>;
-        try {
-          entry = { request, result: await input.execute(request) };
-        } catch (error) {
-          entry = { request, result: null, error };
-        }
-        await notify(entry);
-      }),
-    );
-    await notifyChain;
-  }
-  return results;
-}
-
-export function compileRequestsWithStrategy<TRequest>(input: {
-  requests: TRequest[];
-  strategy: AnyBatchOperationStrategy;
-  getPayload: (request: TRequest) => Record<string, unknown>;
-}): Array<{
-  batchOperation: string;
-  memberRequests: TRequest[];
-  batchPayload: Record<string, unknown>;
-  splitResults: (value: unknown) => Array<unknown | null>;
-}> {
-  const compiledBatches: Array<{
-    batchOperation: string;
-    memberRequests: TRequest[];
-    batchPayload: Record<string, unknown>;
-    splitResults: (value: unknown) => Array<unknown | null>;
-  }> = [];
-  const bucketedRequests = new Map<string, TRequest[]>();
-  for (const request of input.requests) {
-    const payload = input.getPayload(request);
-    const bucketKey = String(input.strategy.toBucketKey(payload));
-    const bucket = bucketedRequests.get(bucketKey);
-    if (bucket) bucket.push(request);
-    else bucketedRequests.set(bucketKey, [request]);
-  }
-  for (const bucketRequests of bucketedRequests.values()) {
-    let currentBatch: TRequest[] = [];
-    const flushBatch = () => {
-      if (currentBatch.length === 0) return;
-      const memberRequests = [...currentBatch];
-      const compiled = input.strategy.compile(
-        memberRequests.map((request) => input.getPayload(request)),
-      );
-      compiledBatches.push({
-        batchOperation: compiled.batchOperation,
-        memberRequests,
-        batchPayload: compiled.batchPayload,
-        splitResults: (value: unknown) => {
-          const splitResults = input.strategy.splitResult(value, compiled);
-          return memberRequests.map(
-            (_, index) => splitResults[index]?.result ?? null,
-          );
-        },
-      });
-      currentBatch = [];
-    };
-    for (const request of bucketRequests) {
-      const payload = input.getPayload(request);
-      const canAppend =
-        currentBatch.length > 0 &&
-        currentBatch.length < input.strategy.maxBatchSize &&
-        currentBatch.every((existing) =>
-          input.strategy.canBatchWith(input.getPayload(existing), payload),
-        );
-      if (!canAppend && currentBatch.length > 0) flushBatch();
-      currentBatch.push(request);
-    }
-    flushBatch();
-  }
-  return compiledBatches;
-}
-
-function testRateLimitBatchItems(
-  value: unknown,
-): Array<{ itemKey?: string; result?: unknown }> {
-  if (!value || typeof value !== 'object' || Array.isArray(value)) {
-    return [];
-  }
-  const record = value as Record<string, unknown>;
-  if (Array.isArray(record.items)) {
-    return record.items as Array<{ itemKey?: string; result?: unknown }>;
-  }
-  const candidates = [
-    record.data,
-    record.result,
-    record.output,
-    record.toolResponse &&
-    typeof record.toolResponse === 'object' &&
-    !Array.isArray(record.toolResponse)
-      ? (record.toolResponse as Record<string, unknown>).raw
-      : undefined,
-    record.toolOutput &&
-    typeof record.toolOutput === 'object' &&
-    !Array.isArray(record.toolOutput)
-      ? (record.toolOutput as Record<string, unknown>).raw
-      : undefined,
-  ];
-  for (const candidate of candidates) {
-    const items = testRateLimitBatchItems(candidate);
-    if (items.length > 0) return items;
-  }
-  return [];
-}
-
-export function getDefaultPlayRuntimeBatchStrategy(
-  operation: string | null | undefined,
-): AnyBatchOperationStrategy | null {
-  if (operation !== 'test_rate_limit') return null;
-  return {
-    sourceOperation: 'test_rate_limit',
-    batchOperation: 'test_batch_rate_limit',
-    kind: 'identifier_batch',
-    maxBatchSize: 200,
-    canBatchWith(left, right) {
-      return String(left.stage || '') === String(right.stage || '');
-    },
-    toBucketKey(payload) {
-      return `test_batch_rate_limit:${String(payload.stage || '')}`;
-    },
-    toItemKey(payload) {
-      return String(payload.lead_id || payload.row_number || payload.key || '');
-    },
-    compile(payloads) {
-      const stage = String(payloads[0]?.stage || '');
-      const simulatedDelayMs =
-        typeof payloads[0]?.simulated_delay_ms === 'number'
-          ? payloads[0].simulated_delay_ms
-          : undefined;
-      const items = payloads.map((payload, index) => ({
-        itemKey: String(
-          payload.lead_id || payload.row_number || payload.key || `row_${index}`,
-        ),
-        payload,
-      }));
-      return {
-        batchOperation: 'test_batch_rate_limit',
-        batchPayload: {
-          key: 'batch',
-          ...(stage ? { stage } : {}),
-          ...(simulatedDelayMs !== undefined
-            ? { simulated_delay_ms: simulatedDelayMs }
-            : {}),
-          items,
-        },
-        items,
-      };
-    },
-    splitResult(fullResult, compiled) {
-      const resultItems = testRateLimitBatchItems(fullResult);
-      return compiled.items.map((item, index) => ({
-        itemKey: item.itemKey,
-        result:
-          index < resultItems.length
-            ? (resultItems[index]?.result ?? null)
-            : null,
-        rawResult:
-          index < resultItems.length
-            ? (resultItems[index]?.result ?? null)
-            : null,
-      }));
-    },
-  };
-}

package/dist/bundling-sources/apps/play-runner-workers/src/runtime/coordinator-progress.ts

@@ -1,289 +0,0 @@
-import { coordinatorRequestHeaders } from '../../../../shared_libs/play-runtime/coordinator-headers';
-import type {
-  LiveNodeProgressMap,
-  LiveNodeProgressSnapshot,
-} from './live-progress';
-
-type CoordinatorProgressTraceExtra = {
-  status: 'ok' | 'failed' | 'skipped_no_url';
-  httpStatus?: number;
-  activeNodeId?: string | null;
-  activeArtifactTableNamespace?: string | null;
-  activeCompleted?: number | null;
-  activeTotal?: number | null;
-  activeMessage?: string | null;
-};
-
-type CoordinatorProgressTrace = {
-  phase: 'runner.coordinator_progress_publish';
-  ms: number;
-  extra: CoordinatorProgressTraceExtra;
-};
-
-export class CoordinatorProgressAuthorizationError extends Error {
-  constructor(
-    message: string,
-    readonly status: number,
-  ) {
-    super(message);
-    this.name = 'CoordinatorProgressAuthorizationError';
-  }
-}
-
-export function isCoordinatorProgressAuthorizationError(
-  error: unknown,
-): error is CoordinatorProgressAuthorizationError {
-  return (
-    error instanceof CoordinatorProgressAuthorizationError ||
-    (typeof error === 'object' &&
-      error !== null &&
-      'name' in error &&
-      'status' in error &&
-      (error as { name?: unknown }).name ===
-        'CoordinatorProgressAuthorizationError' &&
-      typeof (error as { status?: unknown }).status === 'number')
-  );
-}
-
-function activeProgressFields(liveNodeProgress: LiveNodeProgressMap): {
-  activeNodeId: string | null;
-  activeProgress: LiveNodeProgressSnapshot | null;
-  activeArtifactTableNamespace: string | null;
-  activeCompleted: number | null;
-  activeTotal: number | null;
-  activeMessage: string | null;
-} {
-  const activeEntry =
-    Object.entries(liveNodeProgress).find(
-      ([, progress]) => typeof progress.completedAt !== 'number',
-    ) ?? Object.entries(liveNodeProgress).at(-1);
-  const activeNodeId = activeEntry?.[0] ?? null;
-  const activeProgress = activeEntry?.[1] ?? null;
-  const activeArtifactTableNamespace =
-    typeof activeProgress?.artifactTableNamespace === 'string'
-      ? activeProgress.artifactTableNamespace
-      : null;
-  const activeCompleted =
-    typeof activeProgress?.completed === 'number'
-      ? activeProgress.completed
-      : null;
-  const activeTotal =
-    typeof activeProgress?.total === 'number' ? activeProgress.total : null;
-  const activeMessage =
-    typeof activeProgress?.message === 'string' ? activeProgress.message : null;
-  return {
-    activeNodeId,
-    activeProgress,
-    activeArtifactTableNamespace,
-    activeCompleted,
-    activeTotal,
-    activeMessage,
-  };
-}
-
-async function publishCoordinatorProgressEvent(input: {
-  runId: string;
-  coordinatorUrl?: string | null;
-  coordinatorInternalToken?: string | null;
-  occurredAt: number;
-  runLogBuffer: string[];
-  liveNodeProgress: LiveNodeProgressMap;
-  fetchFn: typeof fetch;
-  makeRequestId: () => string;
-  nowMs: () => number;
-  recordTrace: (trace: CoordinatorProgressTrace) => void;
-}): Promise<void> {
-  const coordinatorUrl = input.coordinatorUrl?.trim();
-  if (!coordinatorUrl) {
-    input.recordTrace({
-      phase: 'runner.coordinator_progress_publish',
-      ms: 0,
-      extra: { status: 'skipped_no_url' },
-    });
-    return;
-  }
-
-  const publishStartedAt = input.nowMs();
-  const {
-    activeNodeId,
-    activeArtifactTableNamespace,
-    activeCompleted,
-    activeTotal,
-    activeMessage,
-  } = activeProgressFields(input.liveNodeProgress);
-
-  const response = await input.fetchFn(
-    `${coordinatorUrl.replace(/\/$/, '')}/dedup/${encodeURIComponent(
-      input.runId,
-    )}/event-add`,
-    {
-      method: 'POST',
-      headers: {
-        'x-deepline-request-id': input.makeRequestId(),
-        ...coordinatorRequestHeaders({
-          runId: input.runId,
-          contentType: 'application/json',
-          internalToken: input.coordinatorInternalToken,
-        }),
-      },
-      body: JSON.stringify({
-        runId: input.runId,
-        type: 'progress',
-        status: 'running',
-        ts: input.occurredAt,
-        logs: input.runLogBuffer,
-        activeNodeId,
-        activeArtifactTableNamespace,
-        updatedAt: input.occurredAt,
-        liveNodeProgress: input.liveNodeProgress,
-      }),
-    },
-  );
-
-  if (response.status === 401 || response.status === 403) {
-    input.recordTrace({
-      phase: 'runner.coordinator_progress_publish',
-      ms: input.nowMs() - publishStartedAt,
-      extra: {
-        status: 'failed',
-        httpStatus: response.status,
-        activeNodeId,
-        activeArtifactTableNamespace,
-        activeCompleted,
-        activeTotal,
-        activeMessage,
-      },
-    });
-    throw new CoordinatorProgressAuthorizationError(
-      `Coordinator progress publish was rejected with ${response.status}; ` +
-        'the play runner no longer has authority to update its coordinator state. ' +
-        'Stopping before more provider work can execute with stale coordinator authority.',
-      response.status,
-    );
-  }
-
-  if (!response.ok) {
-    input.recordTrace({
-      phase: 'runner.coordinator_progress_publish',
-      ms: input.nowMs() - publishStartedAt,
-      extra: {
-        status: 'failed',
-        httpStatus: response.status,
-        activeNodeId,
-        activeArtifactTableNamespace,
-        activeCompleted,
-        activeTotal,
-        activeMessage,
-      },
-    });
-    throw new Error(`coordinator progress event failed ${response.status}`);
-  }
-
-  input.recordTrace({
-    phase: 'runner.coordinator_progress_publish',
-    ms: input.nowMs() - publishStartedAt,
-    extra: {
-      status: 'ok',
-      activeNodeId,
-      activeArtifactTableNamespace,
-      activeCompleted,
-      activeTotal,
-      activeMessage,
-    },
-  });
-}
-
-export function createCoordinatorProgressPublisher(input: {
-  runId: string;
-  coordinatorUrl?: string | null;
-  coordinatorInternalToken?: string | null;
-  abortController: AbortController;
-  getRunLogBuffer: () => string[];
-  getLiveNodeProgress: () => LiveNodeProgressMap;
-  recordTrace: (trace: CoordinatorProgressTrace) => void;
-  fetchFn?: typeof fetch;
-  makeRequestId: () => string;
-  nowMs: () => number;
-  heartbeatIntervalMs: number;
-}): {
-  assertHealthy: () => void;
-  flush: (force: boolean) => Promise<void>;
-  fatalError: () => Error | null;
-} {
-  let lastPublishAt = 0;
-  let publishInFlight: Promise<void> = Promise.resolve();
-  let publishQueueDepth = 0;
-  let fatalError: Error | null = null;
-  const abortSignal = input.abortController.signal;
-  const fetchFn = input.fetchFn ?? fetch;
-
-  const markFatal = (error: Error): void => {
-    fatalError ??= error;
-    if (!abortSignal.aborted) {
-      input.abortController.abort(error);
-    }
-  };
-
-  const assertHealthy = (): void => {
-    if (fatalError) {
-      throw fatalError;
-    }
-  };
-
-  const publish = async (occurredAt: number): Promise<void> => {
-    assertHealthy();
-    await publishCoordinatorProgressEvent({
-      runId: input.runId,
-      coordinatorUrl: input.coordinatorUrl,
-      coordinatorInternalToken: input.coordinatorInternalToken,
-      occurredAt,
-      runLogBuffer: input.getRunLogBuffer(),
-      liveNodeProgress: input.getLiveNodeProgress(),
-      fetchFn,
-      makeRequestId: input.makeRequestId,
-      nowMs: input.nowMs,
-      recordTrace: input.recordTrace,
-    });
-  };
-
-  const flush = (force: boolean): Promise<void> => {
-    if (fatalError) {
-      return force ? Promise.reject(fatalError) : Promise.resolve();
-    }
-
-    const now = input.nowMs();
-    if (!force && now - lastPublishAt < input.heartbeatIntervalMs) {
-      return Promise.resolve();
-    }
-    if (!force && publishQueueDepth > 0) {
-      return Promise.resolve();
-    }
-
-    lastPublishAt = now;
-    publishQueueDepth += 1;
-    const publishTask = publishInFlight
-      .catch(() => undefined)
-      .then(async () => {
-        try {
-          await publish(now);
-        } finally {
-          publishQueueDepth = Math.max(0, publishQueueDepth - 1);
-        }
-      });
-
-    const handledPublishTask = publishTask.catch((error) => {
-      if (isCoordinatorProgressAuthorizationError(error)) {
-        markFatal(error);
-        throw error;
-      }
-    });
-    publishInFlight = handledPublishTask.catch(() => undefined);
-    return force ? handledPublishTask : Promise.resolve();
-  };
-
-  return {
-    assertHealthy,
-    flush,
-    fatalError: () => fatalError,
-  };
-}

package/dist/bundling-sources/apps/play-runner-workers/src/runtime/csv-rows.ts

@@ -1,85 +0,0 @@
-import {
-  cloneCsvAliasedRow,
-  stripCsvProjectionMetadata,
-} from '../../../../shared_libs/play-runtime/csv-rename';
-import { copyMapRowOutcomeRuntimeFields } from '../../../../shared_libs/play-runtime/map-row-outcome';
-
-const CSV_TEMPLATE_CONTEXT = '__deeplineCsvProjectedValues';
-
-export type CsvRuntimeRow = Record<string, unknown>;
-
-function copyVisibleFields(
-  row: CsvRuntimeRow,
-  keepTemplateContext: boolean,
-): CsvRuntimeRow {
-  const publicRow: CsvRuntimeRow = {};
-  for (const fieldName of Reflect.ownKeys(row)) {
-    if (
-      typeof fieldName === 'string' &&
-      fieldName.startsWith('__deepline') &&
-      (!keepTemplateContext || fieldName !== CSV_TEMPLATE_CONTEXT)
-    ) {
-      continue;
-    }
-    const descriptor = Object.getOwnPropertyDescriptor(row, fieldName);
-    if (!descriptor) continue;
-    Object.defineProperty(publicRow, fieldName, descriptor);
-  }
-  return publicRow;
-}
-
-function withCtx(
-  row: CsvRuntimeRow,
-  contextSource: CsvRuntimeRow = row,
-): CsvRuntimeRow {
-  const ctx = contextSource[CSV_TEMPLATE_CONTEXT];
-  if (ctx) {
-    const values = ctx as CsvRuntimeRow;
-    for (const fieldName in values) {
-      delete row[fieldName];
-      row[fieldName] = values[fieldName];
-    }
-  }
-  return row;
-}
-
-export function publicCsvInputRow<T extends CsvRuntimeRow>(row: T): T {
-  return copyVisibleFields(stripCsvProjectionMetadata(row), false) as T;
-}
-
-export function runtimeCsvInputRow<T extends CsvRuntimeRow>(row: T): T {
-  return withCtx(copyVisibleFields(cloneCsvAliasedRow(row), true)) as T;
-}
-
-export function runtimeCsvExecutionRow<T extends CsvRuntimeRow>(
-  sourceRow: T,
-  pendingRow?: CsvRuntimeRow | null,
-): T {
-  const source = runtimeCsvInputRow(sourceRow) as CsvRuntimeRow;
-  if (!pendingRow) return source as T;
-  const pending = runtimeCsvInputRow(pendingRow);
-  const executionRow = { ...pending, ...source };
-  if ('__deeplineCellMeta' in pendingRow) {
-    executionRow.__deeplineCellMeta = pendingRow.__deeplineCellMeta;
-  }
-  return withCtx(executionRow) as T;
-}
-
-export function publicCsvOutputRow<T extends CsvRuntimeRow>(row: T): T {
-  return publicCsvInputRow(row);
-}
-
-export function publicCsvStorageRow<T extends CsvRuntimeRow>(row: T): T {
-  const publicRow = publicCsvInputRow(row) as CsvRuntimeRow;
-  const storageRow: CsvRuntimeRow = {};
-  for (const fieldName of Reflect.ownKeys(publicRow)) {
-    if (typeof fieldName !== 'string') continue;
-    storageRow[fieldName] = publicRow[fieldName];
-  }
-  return copyMapRowOutcomeRuntimeFields(storageRow, row) as T;
-}
-
-export function runtimeCsvStorageRow<T extends CsvRuntimeRow>(row: T): T {
-  const storageRow = publicCsvStorageRow(row) as CsvRuntimeRow;
-  return withCtx(storageRow, row) as T;
-}

package/dist/bundling-sources/apps/play-runner-workers/src/runtime/customer-console.ts

@@ -1,23 +0,0 @@
-export function formatCustomerConsoleValue(value: unknown): string {
-  if (typeof value === 'string') return value;
-  try {
-    if (value instanceof Error) return value.stack ?? value.message;
-    if (value && typeof value === 'object') {
-      const seen = new WeakSet<object>();
-      const serialized = JSON.stringify(value, (_key, nested) => {
-        if (typeof nested === 'symbol' || typeof nested === 'bigint') {
-          return nested.toString();
-        }
-        if (nested && typeof nested === 'object') {
-          if (seen.has(nested)) return '[Circular]';
-          seen.add(nested);
-        }
-        return nested;
-      });
-      if (serialized !== undefined) return serialized;
-    }
-    return String(value);
-  } catch {
-    return '[Unprintable]';
-  }
-}