deepline 0.1.243 → 0.1.244

package/dist/bundling-sources/apps/play-runner-workers/src/workflow-retry.ts

@@ -1,91 +0,0 @@
-import { normalizePlayRunFailure } from '../../../shared_libs/play-runtime/run-failure';
-
-export const PLATFORM_DEPLOY_WORKFLOW_RETRY_LIMIT = 5;
-
-export type WorkflowRetryDecision =
-  | {
-      action: 'retry';
-      reason: string;
-      nextAttempt: number;
-      message: string;
-    }
-  | {
-      action: 'fail';
-      reason: string | null;
-      message: string | null;
-    };
-
-function workflowRetryReasonForFailure(failure: {
-  code: string;
-  cause?: string;
-}): string {
-  if (failure.code === 'PLATFORM_WORKFLOW_ENDPOINT_INTERRUPTED') {
-    return 'cloudflare_workflow_endpoint_unavailable';
-  }
-  if (failure.code === 'PLATFORM_WORKER_SUBREQUEST_INTERRUPTED') {
-    return 'cloudflare_worker_subrequest_limit';
-  }
-  if (
-    failure.cause &&
-    /runtime API 404:[\s\S]*(?:DeploymentNotFound|DEPLOYMENT_NOT_FOUND|requested deployment .*exist|deployment could not be found on Vercel)/i.test(
-      failure.cause,
-    )
-  ) {
-    return 'vercel_runtime_api_deployment_missing';
-  }
-  return 'cloudflare_durable_object_reset';
-}
-
-function workflowRetryExhaustedReasonForFailure(failure: {
-  code: string;
-  cause?: string;
-}): string {
-  return `${workflowRetryReasonForFailure(failure)}_retry_exhausted`;
-}
-
-export function decideWorkflowPlatformRetry(input: {
-  workflowStatus: string;
-  error: string | null;
-  retryAttempts: number;
-}): WorkflowRetryDecision {
-  if (!input.error) {
-    return { action: 'fail', reason: null, message: null };
-  }
-  const failure = normalizePlayRunFailure(input.error);
-  const retryablePlatformReset =
-    failure.code === 'PLATFORM_DEPLOY_INTERRUPTED' ||
-    failure.code === 'PLATFORM_WORKFLOW_ENDPOINT_INTERRUPTED' ||
-    failure.code === 'PLATFORM_WORKER_SUBREQUEST_INTERRUPTED';
-  if (
-    retryablePlatformReset &&
-    input.retryAttempts < PLATFORM_DEPLOY_WORKFLOW_RETRY_LIMIT
-  ) {
-    return {
-      action: 'retry',
-      reason: workflowRetryReasonForFailure(failure),
-      nextAttempt: input.retryAttempts + 1,
-      message: failure.message,
-    };
-  }
-  return {
-    action: 'fail',
-    reason: retryablePlatformReset
-      ? workflowRetryExhaustedReasonForFailure(failure)
-      : null,
-    message: failure.message,
-  };
-}
-
-export function shouldPublishWorkflowRuntimeFailure(input: {
-  error: unknown;
-  retryAttempts: number;
-}): boolean {
-  const message =
-    input.error instanceof Error ? input.error.message : String(input.error);
-  const decision = decideWorkflowPlatformRetry({
-    workflowStatus: 'errored',
-    error: message,
-    retryAttempts: input.retryAttempts,
-  });
-  return decision.action !== 'retry';
-}

package/dist/bundling-sources/sdk/src/plays/harness-stub.ts

@@ -1,329 +0,0 @@
-/**
- * Per-play stub that calls into the long-lived Play Harness Worker via
- * `env.HARNESS`.
- *
- * This file is what ends up bundled into every per-play Worker. It MUST
- * stay tiny — every byte here is paid by every fresh-graphHash V8
- * compile in CF's WorkerLoader. Target: <2 KB minified.
- *
- * What it does:
- *   - Exposes thin functions that look like the in-bundle implementations
- *     they're replacing (runtime-api call, staged dataset IO, …).
- *   - Each function calls `env.HARNESS.<method>(...)` — the typed RPC
- *     stub provided by the Cloudflare service binding.
- *
- * What it does NOT do:
- *   - Does NOT import the harness Worker's `PlayHarness` class (that
- *     would re-bundle the whole harness; only TYPES are imported).
- *   - Does NOT cache RPC results across plays — caching belongs to
- *     callers if they want it. This file stays stateless so it composes
- *     cleanly under the per-play orchestrator's expectations.
- *
- * How the env binding reaches per-play code:
- *   The coordinator's `WorkerLoader` factory passes `HARNESS` in the
- *   per-play Worker's `env` map (see
- *   `apps/play-runner-workers/src/coordinator-entry.ts` near
- *   `loadDynamicPlayWorkerSync`). The per-play harness then reads it
- *   off `WorkerEnv` and stashes it via `setHarnessBinding`.
- *
- * @see {@link ../../../apps/play-harness-worker/README.md}
- */
-
-import type {
-  PlayHarnessRpc,
-  PreloadedRuntimeDbSessionInput,
-  CompleteRuntimeReceiptInput,
-  CompleteRuntimeReceiptsInput,
-  FailRuntimeReceiptInput,
-  FailRuntimeReceiptsInput,
-  HeartbeatRuntimeReceiptsInput,
-  MarkRuntimeReceiptsRunningInput,
-  ReleaseRuntimeReceiptInput,
-  RuntimeApiCallInput,
-  RuntimeApiCallResult,
-  RuntimeReceiptInput,
-  RuntimeReceiptsInput,
-  SheetAttemptHeartbeatInput,
-  SheetAttemptHeartbeatResult,
-  SheetAttemptReleaseInput,
-  SheetAttemptReleaseResult,
-  WorkReceiptReleaseInput,
-  WorkReceiptReleaseResult,
-  SheetDatasetRowKeysInput,
-  SheetDatasetRowKeysResult,
-  SheetDatasetRowsInput,
-  SheetDatasetRowsResult,
-  StagedFileChunkInput,
-  StagedFileChunkResult,
-} from '../../../apps/play-harness-worker/src/rpc-types';
-import type {
-  WorkReceipt,
-  WorkReceiptClaim,
-} from '../../../shared_libs/play-runtime/work-receipts';
-
-/**
- * Service-binding RPC stub shape — what `env.HARNESS` looks like inside
- * a per-play Worker. Cloudflare exposes WorkerEntrypoint methods as
- * promise-returning RPC stubs; the type matches `PlayHarnessRpc`.
- */
-export type HarnessBinding = PlayHarnessRpc;
-
-/**
- * Module-level holder for the binding. Set by the per-play harness on
- * worker init (see `apps/play-runner-workers/src/entry.ts → setHarnessBinding`).
- *
- * Why a module-level holder instead of threading the binding through
- * every call site: most leaf-call sites are deep inside SDK utilities
- * (`ctx.tools.execute`, `ctx.csv`, etc.) and threading a binding everywhere would
- * be a structural mess. A single set-once holder, set very early in the
- * worker's lifecycle, gives us clean call sites without sacrificing
- * isolation — each per-play Worker is its own isolate, so the holder is
- * never shared across plays.
- */
-let cachedBinding: HarnessBinding | null = null;
-
-/**
- * Install the harness binding for this worker. Called once on init from
- * the per-play harness. Subsequent calls overwrite — the last writer
- * wins. In practice the per-play harness sets this exactly once before
- * any user code runs, so overwrites should never happen in production.
- */
-export function setHarnessBinding(binding: HarnessBinding | null): void {
-  cachedBinding = binding;
-}
-
-/**
- * Read the installed binding or throw a loud error. We deliberately
- * throw rather than fall back to a HTTP-fetch path: fall-backs hide
- * misconfiguration and let perf regressions creep in silently. If
- * HARNESS is missing, the coordinator forgot to wire it in the
- * WorkerLoader factory — that's a deploy bug, not a runtime contingency.
- */
-function requireBinding(): HarnessBinding {
-  if (!cachedBinding) {
-    throw new Error(
-      '[harness-stub] env.HARNESS is not wired. The coordinator must pass HARNESS in the WorkerLoader factory env. ' +
-        'See apps/play-runner-workers/src/coordinator-entry.ts -> loadDynamicPlayWorkerSync.',
-    );
-  }
-  return cachedBinding;
-}
-
-// ---------------------------------------------------------------------------
-// Public stub functions — these are what call sites use instead of the
-// in-bundle implementations they replace.
-//
-// Each function MUST stay a one-line forwarder to keep the per-play
-// bundle minimal. If a stub starts growing logic, that logic belongs in
-// the harness Worker, not here.
-// ---------------------------------------------------------------------------
-
-/**
- * Liveness ping. Mostly used by tests + diagnostics that run inside a
- * play context; production code rarely calls this.
- */
-export async function harnessPing(): Promise<{ ok: true; ts: number }> {
-  return requireBinding().ping();
-}
-
-/**
- * Forward a runtime-API call through the harness.
- *
- * Replaces what was previously a direct `fetch(env.RUNTIME_API, ...)`
- * call in the per-play harness. The transport is identical (HTTPS to
- * the upstream), but the HTTP client lives in the harness Worker so
- * its retry/timeout/error code doesn't ride in every per-play bundle.
- */
-export async function harnessRuntimeApiCall(
-  input: RuntimeApiCallInput,
-): Promise<RuntimeApiCallResult> {
-  return requireBinding().runtimeApiCall(input);
-}
-
-export async function harnessClaimRuntimeReceipt(
-  input: RuntimeReceiptInput,
-): Promise<WorkReceiptClaim> {
-  return requireBinding().claimRuntimeReceipt(input);
-}
-
-export async function harnessClaimRuntimeReceipts(
-  input: RuntimeReceiptsInput,
-): Promise<WorkReceiptClaim[]> {
-  return requireBinding().claimRuntimeReceipts(input);
-}
-
-export async function harnessGetRuntimeReceipt(
-  input: RuntimeReceiptInput,
-): Promise<WorkReceipt | null> {
-  return requireBinding().getRuntimeReceipt(input);
-}
-
-export async function harnessMarkRuntimeReceiptsRunning(
-  input: MarkRuntimeReceiptsRunningInput,
-): Promise<Array<WorkReceipt | null>> {
-  return requireBinding().markRuntimeReceiptsRunning(input);
-}
-
-export async function harnessCompleteRuntimeReceipt(
-  input: CompleteRuntimeReceiptInput,
-): Promise<WorkReceipt | null> {
-  return requireBinding().completeRuntimeReceipt(input);
-}
-
-export async function harnessCompleteRuntimeReceipts(
-  input: CompleteRuntimeReceiptsInput,
-): Promise<Array<WorkReceipt | null>> {
-  return requireBinding().completeRuntimeReceipts(input);
-}
-
-export async function harnessFailRuntimeReceipt(
-  input: FailRuntimeReceiptInput,
-): Promise<WorkReceipt | null> {
-  return requireBinding().failRuntimeReceipt(input);
-}
-
-export async function harnessReleaseRuntimeReceipt(
-  input: ReleaseRuntimeReceiptInput,
-): Promise<WorkReceipt | null> {
-  return requireBinding().releaseRuntimeReceipt(input);
-}
-
-export async function harnessFailRuntimeReceipts(
-  input: FailRuntimeReceiptsInput,
-): Promise<Array<WorkReceipt | null>> {
-  return requireBinding().failRuntimeReceipts(input);
-}
-
-export async function harnessHeartbeatRuntimeReceipts(
-  input: HeartbeatRuntimeReceiptsInput,
-): Promise<Array<WorkReceipt | null>> {
-  return requireBinding().heartbeatRuntimeReceipts(input);
-}
-
-/**
- * Read a bounded staged-file byte range through typed harness RPC. This is the
- * only staged-file data path for per-play Workers; there is intentionally no
- * HTTP fetch fallback because stale parallel paths caused empty CSV streams in
- * preview.
- */
-export async function harnessReadStagedFileChunk(
-  input: StagedFileChunkInput,
-): Promise<StagedFileChunkResult> {
-  return requireBinding().readStagedFileChunk(input);
-}
-
-export async function harnessReadSheetDatasetRows(
-  input: SheetDatasetRowsInput,
-): Promise<SheetDatasetRowsResult> {
-  return requireBinding().readSheetDatasetRows(input);
-}
-
-export async function harnessReadSheetDatasetRowKeys(
-  input: SheetDatasetRowKeysInput,
-): Promise<SheetDatasetRowKeysResult> {
-  return requireBinding().readSheetDatasetRowKeys(input);
-}
-
-export async function harnessHeartbeatSheetAttempt(
-  input: SheetAttemptHeartbeatInput,
-): Promise<SheetAttemptHeartbeatResult> {
-  return requireBinding().heartbeatSheetAttempt(input);
-}
-
-export async function harnessReleaseSheetAttempt(
-  input: SheetAttemptReleaseInput,
-): Promise<SheetAttemptReleaseResult> {
-  return requireBinding().releaseSheetAttempt(input);
-}
-
-export async function harnessReleaseRuntimeReceipts(
-  input: WorkReceiptReleaseInput,
-): Promise<WorkReceiptReleaseResult> {
-  return requireBinding().releaseRuntimeReceipts(input);
-}
-
-/**
- * Warm Postgres sessions in the long-lived harness Worker. This preserves the
- * map fast path without bundling the Neon client into every dynamic play.
- */
-export async function harnessPrewarmPostgresSessions(input: {
-  executorToken: string;
-  orgId: string;
-  playName: string;
-  sessions: PreloadedRuntimeDbSessionInput[];
-}): Promise<{ ok: true; sessions: number }> {
-  return requireBinding().prewarmPostgresSessions(input);
-}
-
-/**
- * Start or continue a map dataset write inside the harness, so this call
- * skips per-play callback overhead for heavy Postgres writes.
- */
-export async function harnessStartSheetDataset(input: {
-  baseUrl: string;
-  executorToken: string;
-  orgId: string;
-  preloadedDbSessions?: PreloadedRuntimeDbSessionInput[] | null;
-  playName: string;
-  tableNamespace: string;
-  sheetContract: unknown;
-  rows: Array<Record<string, unknown>>;
-  runId: string;
-  attemptId?: string | null;
-  attemptOwnerRunId?: string | null;
-  attemptExpiresAt?: string | null;
-  attemptSeq?: number | null;
-  attemptLeaseTtlMs?: number | null;
-  writeVersion?: number | null;
-  inputOffset?: number;
-  force?: boolean;
-  userEmail?: string | null;
-}): Promise<{
-  inserted: number;
-  skipped: number;
-  pendingRows: Array<Record<string, unknown>>;
-  completedRows: Array<Record<string, unknown>>;
-  blockedRows: Array<Record<string, unknown>>;
-  tableNamespace: string;
-  attemptId?: string;
-  attemptOwnerRunId?: string;
-  attemptExpiresAt?: string;
-  attemptSeq?: number;
-  writeVersion?: number;
-  timings?: Array<Record<string, unknown>>;
-}> {
-  return requireBinding().startSheetDataset(input);
-}
-
-/**
- * Persist completed map rows inside the harness, directly through the
- * scoped Neon callback surface.
- */
-export async function harnessPersistCompletedSheetRows(input: {
-  baseUrl: string;
-  executorToken: string;
-  orgId: string;
-  preloadedDbSessions?: PreloadedRuntimeDbSessionInput[] | null;
-  playName: string;
-  tableNamespace: string;
-  sheetContract: unknown;
-  rows: Array<Record<string, unknown>>;
-  outputFields: string[];
-  runId: string;
-  attemptId?: string | null;
-  attemptOwnerRunId?: string | null;
-  attemptExpiresAt?: string | null;
-  attemptSeq?: number | null;
-  writeVersion?: number | null;
-  forceFailedRows?: boolean;
-  userEmail?: string | null;
-}): Promise<{
-  ok: true;
-  rowsWritten: number;
-  tableNamespace: string;
-  fencedKeys?: string[];
-  staleDropped?: number;
-  staleDroppedKeys?: string[];
-}> {
-  return requireBinding().persistCompletedMapRows(input);
-}

package/dist/bundling-sources/sdk/src/worker-play-entry.ts

@@ -1,240 +0,0 @@
-/**
- * Workers-only Deepline SDK entry.
- *
- * The normal `deepline` package entry exports the REST client, config loading,
- * file writers, and CLI-oriented helpers. Per-graphHash Workers only need the
- * tiny play-definition DSL at runtime. The esm_workers bundler aliases
- * `import { definePlay } from "deepline"` to this file so user plays do not
- * compile the full SDK client into every dynamic Worker isolate.
- */
-
-import type {
-  ConditionalStepResolver,
-  DefinePlayConfig,
-  DeeplinePlayRuntimeContext,
-  DefinedPlay,
-  PlayBindings,
-  PlayInputContract,
-  PlayReturnObject,
-  PlayStepProgramStep,
-  StepProgram,
-  StepProgramResolver,
-  StepOptions,
-  StepResolver,
-} from './play.js';
-
-export type {
-  ConditionalStepResolver,
-  DefinePlayConfig,
-  DeeplineNamedPlay,
-  DeeplinePlayRuntimeContext,
-  DefinedPlay,
-  ColumnMap,
-  CsvInput,
-  FileInput,
-  ColumnResolver,
-  DatasetBuilder,
-  PlayBindings,
-  PlayDataset,
-  PlayDatasetInput,
-  PlayInputContract,
-  PlayJob,
-  PlayReturnObject,
-  PlayStepProgramStep,
-  PrebuiltPlayRef,
-  StepProgram,
-  StepProgramResolver,
-  StepOptions,
-  StepResolver,
-  ToolExecuteResult,
-} from './play.js';
-
-const PLAY_METADATA_SYMBOL = Symbol.for('deepline.play.metadata');
-
-type PlayMetadata = {
-  name: string;
-  description?: string;
-  bindings?: PlayBindings;
-  inputSchema?: Record<string, unknown>;
-  billing?: PlayBindings['billing'];
-};
-
-class WorkerConditionalStepResolver<
-  Row,
-  Value,
-  ElseValue,
-> implements ConditionalStepResolver<Row, Value, ElseValue> {
-  readonly kind = 'conditional' as const;
-
-  constructor(
-    readonly when: (row: Row, index: number) => boolean | Promise<boolean>,
-    readonly run: StepResolver<Row, Value>,
-    readonly elseValue: ElseValue,
-  ) {}
-
-  else<ValueElse>(
-    value: ValueElse,
-  ): ConditionalStepResolver<Row, Value, ValueElse> {
-    return new WorkerConditionalStepResolver(this.when, this.run, value);
-  }
-}
-
-class WorkerStepProgram<Input, Output, ReturnValue> implements StepProgram<
-  Input,
-  Output,
-  ReturnValue
-> {
-  readonly kind = 'steps' as const;
-  declare readonly __inputType?: (input: Input) => void;
-
-  constructor(
-    readonly steps: readonly PlayStepProgramStep[],
-    readonly returnResolver?: StepResolver<Output, ReturnValue>,
-  ) {}
-
-  step<Name extends string, Value>(
-    name: Name,
-    resolver:
-      | StepResolver<Output, Value>
-      | ConditionalStepResolver<Output, Value>
-      | StepProgramResolver<Output, Value>,
-  ): StepProgram<Input, Output & Record<Name, Value>, ReturnValue>;
-  step<Name extends string, Value>(
-    name: Name,
-    resolver: StepResolver<Output, Value> | StepProgramResolver<Output, Value>,
-    options: StepOptions<Output, Value>,
-  ): StepProgram<Input, Output & Record<Name, Value | null>, ReturnValue>;
-  step<Name extends string, Value>(
-    name: Name,
-    resolver:
-      | StepResolver<Output, Value>
-      | ConditionalStepResolver<Output, Value>
-      | StepProgramResolver<Output, Value>,
-    options?: StepOptions<Output, Value>,
-  ): StepProgram<Input, Output & Record<Name, Value | null>, ReturnValue> {
-    const stepResolver =
-      options?.runIf && !isConditionalStepResolver(resolver)
-        ? new WorkerConditionalStepResolver(
-            options.runIf,
-            resolver as StepResolver<Output, Value>,
-            null,
-          )
-        : resolver;
-    return new WorkerStepProgram(
-      [
-        ...this.steps,
-        {
-          name,
-          ...(options?.recompute === true ? { recompute: true } : {}),
-          ...(options?.recomputeOnError === true
-            ? { recomputeOnError: true }
-            : {}),
-          ...(typeof options?.staleAfterSeconds === 'number'
-            ? { staleAfterSeconds: options.staleAfterSeconds }
-            : {}),
-          resolver: stepResolver as PlayStepProgramStep['resolver'],
-        },
-      ],
-      this.returnResolver as StepResolver<
-        Output & Record<Name, Value | null>,
-        ReturnValue
-      >,
-    );
-  }
-
-  return<Value>(
-    resolver: StepResolver<Output, Value>,
-  ): StepProgram<Input, Output, Value> {
-    return new WorkerStepProgram(this.steps, resolver);
-  }
-}
-
-function isConditionalStepResolver(
-  value: unknown,
-): value is ConditionalStepResolver<unknown, unknown> {
-  return (value as { kind?: unknown } | null)?.kind === 'conditional';
-}
-
-export function steps<TInput>(): StepProgram<TInput, TInput, TInput> {
-  return new WorkerStepProgram<TInput, TInput, TInput>([]);
-}
-
-export function runIf<Row, Value>(
-  predicate: (row: Row, index: number) => boolean | Promise<boolean>,
-  resolver: StepResolver<Row, Value>,
-): ConditionalStepResolver<Row, Value, null> {
-  return new WorkerConditionalStepResolver(predicate, resolver, null);
-}
-
-export function defineInput<TInput>(
-  schema: Record<string, unknown>,
-): PlayInputContract<TInput> {
-  return { schema };
-}
-
-export function definePlay<TInput, TOutput extends PlayReturnObject>(
-  config: DefinePlayConfig<TInput, TOutput>,
-): DefinedPlay<TInput, TOutput>;
-export function definePlay<TInput, TOutput extends PlayReturnObject>(
-  name: string,
-  fn: (ctx: DeeplinePlayRuntimeContext, input: TInput) => Promise<TOutput>,
-  bindings?: PlayBindings,
-): DefinedPlay<TInput, TOutput>;
-export function definePlay<TInput, TOutput extends PlayReturnObject>(
-  nameOrConfig: string | DefinePlayConfig<TInput, TOutput>,
-  maybeFn?: (
-    ctx: DeeplinePlayRuntimeContext,
-    input: TInput,
-  ) => Promise<TOutput>,
-  maybeBindings?: PlayBindings,
-): DefinedPlay<TInput, TOutput> {
-  const config =
-    typeof nameOrConfig === 'string'
-      ? {
-          name: nameOrConfig,
-          fn: maybeFn,
-          bindings: maybeBindings,
-          description: maybeBindings?.description,
-          inputSchema: undefined,
-          billing: maybeBindings?.billing,
-        }
-      : {
-          name: nameOrConfig.id,
-          fn: nameOrConfig.run,
-          bindings: nameOrConfig.bindings,
-          description: nameOrConfig.description,
-          inputSchema: nameOrConfig.input.schema,
-          billing: nameOrConfig.billing,
-        };
-
-  const name = config.name;
-  const fn = config.fn;
-  const description = config.description?.trim();
-
-  const metadata: PlayMetadata = {
-    name,
-    ...(description ? { description } : {}),
-    ...(config.bindings ? { bindings: config.bindings } : {}),
-    ...(config.inputSchema ? { inputSchema: config.inputSchema } : {}),
-    ...(config.billing ? { billing: config.billing } : {}),
-  };
-  const play = fn as DefinedPlay<TInput, TOutput>;
-
-  Object.defineProperties(play, {
-    [PLAY_METADATA_SYMBOL]: { value: metadata },
-    playName: { value: name, enumerable: true },
-    bindings: { value: config.bindings, enumerable: true },
-    name: { value: name },
-  });
-  return play;
-}
-
-export const defineWorkflow = definePlay;
-
-export function getDefinedPlayMetadata(value: unknown): PlayMetadata | null {
-  return typeof value === 'function'
-    ? (((value as unknown as Record<PropertyKey, unknown>)[
-        PLAY_METADATA_SYMBOL
-      ] as PlayMetadata | undefined) ?? null)
-    : null;
-}