deepline 0.3.228 → 0.3.230

package/dist/bundling-sources/shared_libs/play-runtime/scheduler-backends/postgres.ts

@@ -79,12 +79,17 @@ import {
 import type { PlayStaticPipeline } from '../../plays/static-pipeline';
 import {
   LOG_TAIL_LIMIT,
+  normalizePlayRunLedgerTerminalWorkCounterSegment,
   type AcceptedPlayRunLedgerEvent,
   type PlayRunLedgerEvent,
   type PlayRunLedgerIngressEvent,
+  type PlayRunLedgerTerminalWorkCounterSegment,
 } from '../run-ledger';
 import { stableStringify } from '../../plays/row-identity';
-import { runtimeWorkCountersFromResources } from '../runtime-work-counters';
+import {
+  runtimeWorkCountersFromResources,
+  runtimeWorkCountersFromStats,
+} from '../runtime-work-counters';
 import {
   isCtxFetchHttpFailureDiagnostic,
   parseCtxFetchHttpFailureDiagnostic,
@@ -9456,6 +9461,28 @@ export type PostgresSchedulerDirectRunnerTerminalOutcome =
   | 'wake_required'
   | 'not_found';
 
+function terminalWorkCounterSegmentFromRunnerResult(
+  result: unknown,
+  attempt: number,
+): PlayRunLedgerTerminalWorkCounterSegment | undefined {
+  if (!result || typeof result !== 'object' || Array.isArray(result)) {
+    return undefined;
+  }
+  const stats = (result as { stats?: unknown }).stats;
+  if (!stats || typeof stats !== 'object' || Array.isArray(stats)) {
+    return undefined;
+  }
+  const segment = (stats as { runtimeWorkCounterSegment?: unknown })
+    .runtimeWorkCounterSegment;
+  if (!segment || typeof segment !== 'object' || Array.isArray(segment)) {
+    return undefined;
+  }
+  return normalizePlayRunLedgerTerminalWorkCounterSegment({
+    ...segment,
+    attempt,
+  });
+}
+
 /**
  * Reduce an ordinary detached-runner completion at terminal ingress.
  *
@@ -9522,6 +9549,10 @@ export async function directCompletePostgresSchedulerRunnerTerminal(
     input.terminalLogOutbox,
   );
   const runtimeTiming = extractRunnerRuntimeTiming(input.result);
+  const terminalWorkCounterSegment = terminalWorkCounterSegmentFromRunnerResult(
+    input.result,
+    input.attempt,
+  );
   // `workCompletedAtMs` is useful lifecycle telemetry, but it comes from the
   // sandbox process where play code can alter Date.now. Billing must stop on
   // the first database receipt, whose clock and first-write semantics are
@@ -9767,7 +9798,8 @@ export async function directCompletePostgresSchedulerRunnerTerminal(
             'output', $6::jsonb,
             'terminalLogLines', $7::jsonb,
             'terminalProgressEvents', $8::jsonb,
-            'resultSummary', $16::jsonb
+            'resultSummary', $16::jsonb,
+            'terminalWorkCounterSegment', $17::jsonb
           ),
           ${causalOutboxCreatedAt('run_terminal.run_id', options)}
         FROM run_terminal
@@ -9802,6 +9834,7 @@ export async function directCompletePostgresSchedulerRunnerTerminal(
       input.engineWake.wakeChannel,
       input.allowCappedCompletion === true,
       stringifyPostgresJson(resultSummary),
+      stringifyPostgresJson(terminalWorkCounterSegment ?? null),
     ],
   );
   if (completed.rows.length > 0) return 'completed';
@@ -11815,6 +11848,7 @@ export async function completePostgresSchedulerAttempt(
     rowOutcomes?: unknown;
     runtimeTiming?: PlayRunnerRuntimeTiming | null;
     terminalLogLines?: readonly string[] | null;
+    terminalWorkCounterSegment?: PlayRunLedgerTerminalWorkCounterSegment;
   },
   options?: Pick<PostgresSchedulerOptions, 'schema'>,
 ): Promise<boolean> {
@@ -12002,7 +12036,8 @@ export async function completePostgresSchedulerAttempt(
           jsonb_build_object(
             'output', $9::jsonb,
             'terminalLogLines', $8::jsonb,
-            'resultSummary', $10::jsonb
+            'resultSummary', $10::jsonb,
+            'terminalWorkCounterSegment', $11::jsonb
           ),
           ${causalOutboxCreatedAt('run_terminal.run_id', options)}
         FROM run_terminal
@@ -12024,6 +12059,7 @@ export async function completePostgresSchedulerAttempt(
       JSON.stringify(terminalLogLines),
       stringifyPostgresJson(ledgerTerminalResult ?? null),
       stringifyPostgresJson(resultSummary),
+      stringifyPostgresJson(input.terminalWorkCounterSegment ?? null),
     ],
   );
   if (completed.rows.length === 0) {
@@ -12070,6 +12106,10 @@ export async function failPostgresSchedulerAttempt(
   const resultSummary = terminalRowOutcomesSummary(
     (input.result as { rowOutcomes?: unknown } | null)?.rowOutcomes,
   );
+  const terminalWorkCounterSegment = terminalWorkCounterSegmentFromRunnerResult(
+    input.result,
+    input.attempt,
+  );
   // Keep the recovery tail separate from result: large failures are represented
   // by a result reference, but their customer guidance must still be logged.
   const terminalLogLines = (input.terminalLogLines ?? [])
@@ -12311,7 +12351,8 @@ export async function failPostgresSchedulerAttempt(
             'error', $4::jsonb ->> 'message',
             'result', $8::jsonb,
             'terminalLogLines', $12::jsonb,
-            'resultSummary', $13::jsonb
+            'resultSummary', $13::jsonb,
+            'terminalWorkCounterSegment', $14::jsonb
           ),
           ${causalOutboxCreatedAt('run_terminal.run_id', options)}
         FROM run_terminal
@@ -12336,6 +12377,7 @@ export async function failPostgresSchedulerAttempt(
       input.preserveRunnerTerminal === true,
       JSON.stringify(terminalLogLines),
       stringifyPostgresJson(resultSummary),
+      stringifyPostgresJson(terminalWorkCounterSegment ?? null),
     ],
   );
   return failed.rows.length > 0;
@@ -13111,10 +13153,11 @@ export function attachRunnerWorkProgressMetadata(
   // Keep the two scalar counts when the detailed runtimeResources record
   // exceeds its metadata budget. Compact status must not scan a call log to
   // reconstruct physical work.
-  const runtimeCounters = runtimeWorkCountersFromResources(
-    (runnerResult as { stats?: { runtimeResources?: unknown } }).stats
-      ?.runtimeResources,
-  );
+  const stats = (runnerResult as { stats?: { runtimeResources?: unknown } })
+    .stats;
+  const runtimeCounters =
+    runtimeWorkCountersFromStats(stats) ??
+    runtimeWorkCountersFromResources(stats?.runtimeResources);
   const outputWarnings = Array.isArray(
     (runnerResult as { outputWarnings?: unknown }).outputWarnings,
   )
@@ -13294,6 +13337,10 @@ export async function executePostgresSchedulerClaim(
         output: terminalOutput,
         rowOutcomes: (output as { rowOutcomes?: unknown } | null)?.rowOutcomes,
         runtimeTiming: extractRunnerRuntimeTiming(output),
+        terminalWorkCounterSegment: terminalWorkCounterSegmentFromRunnerResult(
+          output,
+          claim.attempt,
+        ),
         terminalLogLines: terminalLogLinesForOutbox(
           output,
           options.terminalLogOutbox,
@@ -16928,6 +16975,10 @@ export function buildRunLedgerEventsFromPostgresSchedulerOutbox(
     ];
   }
   if (event.eventType === 'run.completed') {
+    const terminalWorkCounterSegment =
+      normalizePlayRunLedgerTerminalWorkCounterSegment(
+        payloadField(event.payload, 'terminalWorkCounterSegment'),
+      );
     const progressEvents = ledgerEventsPayloadField(
       event.payload,
       'terminalProgressEvents',
@@ -16953,6 +17004,7 @@ export function buildRunLedgerEventsFromPostgresSchedulerOutbox(
         runId: event.runId,
         occurredAt,
         source: 'system',
+        ...(terminalWorkCounterSegment ? { terminalWorkCounterSegment } : {}),
         result: terminalRunResultForLedger(
           payloadField(event.payload, 'output'),
         ),
@@ -16963,6 +17015,10 @@ export function buildRunLedgerEventsFromPostgresSchedulerOutbox(
     ];
   }
   if (event.eventType === 'run.failed') {
+    const terminalWorkCounterSegment =
+      normalizePlayRunLedgerTerminalWorkCounterSegment(
+        payloadField(event.payload, 'terminalWorkCounterSegment'),
+      );
     const progressEvents = ledgerEventsPayloadField(
       event.payload,
       'terminalProgressEvents',
@@ -16991,6 +17047,7 @@ export function buildRunLedgerEventsFromPostgresSchedulerOutbox(
         runId: event.runId,
         occurredAt,
         source: 'system',
+        ...(terminalWorkCounterSegment ? { terminalWorkCounterSegment } : {}),
         error: stringPayloadField(event.payload, 'error'),
         ...(result === null || result === undefined ? {} : { result }),
         ...(resultSummary === undefined || resultSummary === null
@@ -17210,17 +17267,18 @@ export async function listPostgresSchedulerOutboxMaterializationPlans(
 }
 
 /**
- * Where the projector gets its runtime-API executor token when one is not
- * supplied per-event via `runtimeApi`.
+ * Where the projector gets its runtime-API executor token.
  *
  * - `local_mint`: sign the token in-process with `BETTER_AUTH_SECRET`. ONLY the
  *   app (Vercel) legitimately holds the signing key, so this is app-side only
  *   (read-model heal path). It is the AUTHORITATIVE projector.
- * - `gateway`: prove the active outbox lease to the launch-pinned deployment and
- *   receive a short-lived executor JWT (`requestRunLedgerDispatchToken`). The
- *   Fly worker has no signing key and MUST
- *   use this. Delivery failures use the same structured retry-or-block policy
- *   as the app-side projector.
+ * - `gateway`: always prove the active outbox lease to the launch-pinned
+ *   deployment and receive a short-lived executor JWT
+ *   (`requestRunLedgerDispatchToken`), even if the caller supplied a
+ *   `runtimeApi`. The Fly worker has no signing key and MUST use this. A
+ *   supplied context contributes transport options only; its executor token
+ *   cannot bypass the lease-scoped gateway hop. Delivery failures use the same
+ *   structured retry-or-block policy as the app-side projector.
  *
  * Explicit by design: the old code sniffed `process.env.BETTER_AUTH_SECRET` to
  * pick the branch, so the worker's projection silently depended on the secret
@@ -17262,15 +17320,20 @@ export function postgresSchedulerCancellationOutboxLease(runId: string): {
 }
 
 export type RunLedgerOutboxDispatchInput = {
+  /**
+   * Optional runtime context. `gateway` authority always replaces its
+   * credentials with a fresh lease-scoped token and keeps only supported
+   * transport options; `local_mint` and the default authority preserve the
+   * explicit context as before.
+   */
   runtimeApi?: WorkerRuntimeApiContext | null;
   limit?: number;
   runId?: string | null;
   leaseOwner?: string | null;
   leaseSeconds?: number;
   /**
-   * Token authority for events without a per-event `runtimeApi`. Defaults to
-   * `local_mint` for the app-side authoritative projector. The Fly worker MUST
-   * pass `gateway`.
+   * Token authority for the outbox dispatch. Defaults to `local_mint` for the
+   * app-side authoritative projector. The Fly worker MUST pass `gateway`.
    */
   tokenAuthority?: RunLedgerOutboxTokenAuthority;
 };
@@ -17568,7 +17631,24 @@ export async function dispatchRunLedgerOutboxToLedgerBatchOnceWithClientScope(
 
   try {
     const first = events[0]!;
+    const tokenAuthority = input.tokenAuthority ?? 'local_mint';
+    const gatewayRuntimeApi =
+      tokenAuthority === 'gateway'
+        ? await withClient((client) =>
+            loadPostgresSchedulerRuntimeApiForRun(
+              client,
+              first.runId,
+              first.leaseOwner
+                ? { eventId: first.eventId, leaseOwner: first.leaseOwner }
+                : null,
+              tokenAuthority,
+              options,
+              input.runtimeApi?.signal,
+            ),
+          )
+        : null;
     const resolvedRuntimeApi =
+      gatewayRuntimeApi ??
       input.runtimeApi ??
       (await withClient((client) =>
         loadPostgresSchedulerRuntimeApiForRun(
@@ -17577,11 +17657,36 @@ export async function dispatchRunLedgerOutboxToLedgerBatchOnceWithClientScope(
           first.leaseOwner
             ? { eventId: first.eventId, leaseOwner: first.leaseOwner }
             : null,
-          input.tokenAuthority ?? 'local_mint',
+          tokenAuthority,
           options,
         ),
       ));
-    const runtimeApi = { ...resolvedRuntimeApi, retryPolicy: 'none' as const };
+    const runtimeApi = {
+      ...resolvedRuntimeApi,
+      ...(gatewayRuntimeApi && input.runtimeApi
+        ? {
+            ...(input.runtimeApi.fetch
+              ? { fetch: input.runtimeApi.fetch }
+              : {}),
+            ...(input.runtimeApi.requestTimeoutMs !== undefined
+              ? { requestTimeoutMs: input.runtimeApi.requestTimeoutMs }
+              : {}),
+            ...(input.runtimeApi.onResponseMeta
+              ? { onResponseMeta: input.runtimeApi.onResponseMeta }
+              : {}),
+            ...(input.runtimeApi.runtimeTestFaultHeader !== undefined
+              ? {
+                  runtimeTestFaultHeader:
+                    input.runtimeApi.runtimeTestFaultHeader,
+                }
+              : {}),
+            ...(input.runtimeApi.signal
+              ? { signal: input.runtimeApi.signal }
+              : {}),
+          }
+        : {}),
+      retryPolicy: 'none' as const,
+    };
     const renewDelivery = () =>
       withClient((client) =>
         renewPostgresRunLedgerDelivery(
@@ -17839,6 +17944,7 @@ async function loadPostgresSchedulerRuntimeApiForRun(
   dispatchLease: { eventId: string; leaseOwner: string } | null,
   tokenAuthority: RunLedgerOutboxTokenAuthority,
   options?: Pick<PostgresSchedulerOptions, 'schema'>,
+  signal?: AbortSignal,
 ): Promise<WorkerRuntimeApiContext> {
   const result = await client.query<{ launch_json: unknown }>(
     `
@@ -17879,6 +17985,7 @@ async function loadPostgresSchedulerRuntimeApiForRun(
       eventId: dispatchLease.eventId,
       leaseOwner: dispatchLease.leaseOwner,
       schedulerSchema: options?.schema ?? null,
+      signal,
     });
   }
   return {
@@ -17893,6 +18000,7 @@ async function requestRunLedgerDispatchToken(input: {
   eventId: string;
   leaseOwner: string;
   schedulerSchema: string | null;
+  signal?: AbortSignal;
 }): Promise<string> {
   const internalToken = process.env.DEEPLINE_INTERNAL_TOKEN?.trim();
   if (!internalToken || !input.eventId || !input.leaseOwner) {
@@ -17904,10 +18012,16 @@ async function requestRunLedgerDispatchToken(input: {
   const vercelProtectionHeaders = await vercelProtectionBypassHeaders({
     baseUrl: runtimeApiBaseUrlFromLaunch(input.launch),
     token: input.launch.vercelProtectionBypassToken,
+    signal: input.signal,
   });
   const response = await fetch(url, {
     method: 'POST',
-    signal: AbortSignal.timeout(RUN_LEDGER_DISPATCH_TOKEN_TIMEOUT_MS),
+    signal: input.signal
+      ? AbortSignal.any([
+          input.signal,
+          AbortSignal.timeout(RUN_LEDGER_DISPATCH_TOKEN_TIMEOUT_MS),
+        ])
+      : AbortSignal.timeout(RUN_LEDGER_DISPATCH_TOKEN_TIMEOUT_MS),
     headers: {
       'content-type': 'application/json',
       'x-deepline-internal-token': internalToken,

package/dist/bundling-sources/shared_libs/play-runtime/tool-result.ts

@@ -1767,6 +1767,7 @@ function createDatasetFromSerializedToolList(
     residentRows: isPartialPreview ? null : sourceRows,
     sourceLabel: serialized.sourceLabel ?? null,
     tableNamespace: serialized.tableNamespace ?? null,
+    columnTypes: serialized.columnTypes,
     workProgress: serialized._metadata?.workProgress,
     resolvers: {
       count: async () => serialized.count,

package/dist/bundling-sources/shared_libs/plays/dataset.ts

@@ -1,4 +1,5 @@
 import type { PlayExecutionFileRef } from './file-refs';
+import type { PlayDatasetColumnTypes } from '../play-data-plane/contracts';
 
 const PLAY_DATASET_BRAND = Symbol.for('deepline.play.dataset');
 const NODE_INSPECT_CUSTOM = Symbol.for('nodejs.util.inspect.custom');
@@ -47,6 +48,7 @@ export interface SerializedPlayDataset<T> {
   sourceLabel?: string | null;
   tableNamespace?: string | null;
   columns?: string[];
+  columnTypes?: PlayDatasetColumnTypes;
   _metadata?: {
     workProgress?: PlayDatasetWorkProgressSummary;
   };
@@ -107,8 +109,7 @@ export type PlayDatasetTransformOptions = {
  * `materialize(limit)` or async iteration only when the dataset is intentionally
  * small and bounded. `PlayDataset` intentionally does not expose `.rows`,
  * `.toArray()`, `.length`, numeric indexing, spread, or synchronous iteration;
- * those hide the runtime cost of loading persisted rows into memory or make
- * behavior depend on whether rows happen to be resident.
+ * these hide loading costs or make behavior depend on row residency.
  *
  * @sdkReference runtime 190
  */
@@ -124,6 +125,8 @@ export interface PlayDataset<T> extends AsyncIterable<T> {
   readonly sourceLabel?: string | null;
   /** Runtime table name. */
   readonly tableNamespace?: string | null;
+  /** Advisory source types; transformed fields must infer from their values. */
+  readonly columnTypes?: PlayDatasetColumnTypes;
   /** Row count. */
   count(): Promise<number>;
   /** Preview rows. */
@@ -161,6 +164,7 @@ export interface PlayDataset<T> extends AsyncIterable<T> {
     sourceLabel?: string | null;
     tableNamespace?: string | null;
     columns?: string[];
+    columnTypes?: PlayDatasetColumnTypes;
     _metadata?: {
       workProgress?: PlayDatasetWorkProgressSummary;
     };
@@ -335,6 +339,7 @@ export function deserializePlayDatasetCell<T>(
     residentRows: rows,
     sourceLabel: dataset.sourceLabel ?? null,
     tableNamespace: dataset.tableNamespace ?? null,
+    columnTypes: dataset.columnTypes,
     workProgress: dataset._metadata?.workProgress,
     resolvers: {
       count: async () => rows.length,
@@ -374,6 +379,7 @@ export function deserializeLegacyPlayDataset<T>(
     residentRows: complete ? rows : null,
     sourceLabel: dataset.sourceLabel ?? null,
     tableNamespace: dataset.tableNamespace ?? null,
+    columnTypes: dataset.columnTypes,
     workProgress: dataset._metadata?.workProgress,
     resolvers: {
       count: async () => dataset.count,
@@ -417,6 +423,7 @@ class DeferredPlayDataset<T> implements PlayDataset<T> {
   readonly backing?: PlayDatasetBacking;
   readonly sourceLabel?: string | null;
   readonly tableNamespace?: string | null;
+  readonly columnTypes?: PlayDatasetColumnTypes;
   private readonly previewRows: readonly T[];
   private readonly previewColumns?: string[];
   private readonly workProgress?: PlayDatasetWorkProgressSummary;
@@ -435,6 +442,7 @@ class DeferredPlayDataset<T> implements PlayDataset<T> {
     residentRows?: readonly T[] | null;
     sourceLabel?: string | null;
     tableNamespace?: string | null;
+    columnTypes?: PlayDatasetColumnTypes;
     workProgress?: PlayDatasetWorkProgressSummary;
     resolvers: PlayDatasetResolvers<T>;
   }) {
@@ -449,6 +457,7 @@ class DeferredPlayDataset<T> implements PlayDataset<T> {
     this.previewColumns = inferPreviewColumns(this.previewRows);
     this.sourceLabel = input.sourceLabel ?? null;
     this.tableNamespace = input.tableNamespace ?? null;
+    this.columnTypes = input.columnTypes;
     this.workProgress = input.workProgress;
     this.resolvers = input.resolvers;
   }
@@ -592,6 +601,7 @@ class DeferredPlayDataset<T> implements PlayDataset<T> {
       ...(this.sourceLabel ? { sourceLabel: this.sourceLabel } : {}),
       ...(this.tableNamespace ? { tableNamespace: this.tableNamespace } : {}),
       ...(this.previewColumns ? { columns: this.previewColumns } : {}),
+      ...(this.columnTypes ? { columnTypes: this.columnTypes } : {}),
       ...(this.workProgress
         ? { _metadata: { workProgress: this.workProgress } }
         : {}),
@@ -721,6 +731,7 @@ function createTransformedPlayDataset<T, U>(
     backing: source.backing,
     sourceLabel,
     tableNamespace: options?.key ?? null,
+    columnTypes: transform.kind === 'map' ? undefined : source.columnTypes,
     resolvers: {
       count,
       peek: async (limit) => collect(limit),
@@ -747,6 +758,7 @@ export function createDeferredPlayDataset<T>(input: {
   residentRows?: readonly T[] | null;
   sourceLabel?: string | null;
   tableNamespace?: string | null;
+  columnTypes?: PlayDatasetColumnTypes;
   workProgress?: PlayDatasetWorkProgressSummary;
   resolvers: PlayDatasetResolvers<T>;
 }): PlayDataset<T> {
@@ -835,6 +847,7 @@ export function createPlayDataset<T>(
     sourceLabel?: string | null;
     tableNamespace?: string | null;
     datasetId?: string;
+    columnTypes?: PlayDatasetColumnTypes;
   },
 ): PlayDataset<T> {
   // Test/dev helper only. Production play execution should construct
@@ -850,6 +863,7 @@ export function createPlayDataset<T>(
     residentRows: materializedRows,
     sourceLabel: metadata?.sourceLabel ?? null,
     tableNamespace: metadata?.tableNamespace ?? null,
+    columnTypes: metadata?.columnTypes,
     resolvers: {
       count: async () => materializedRows.length,
       peek: async (limit) => materializedRows.slice(0, Math.max(0, limit)),

package/dist/bundling-sources/shared_libs/plays/execution-pipeline.ts

@@ -0,0 +1,72 @@
+import type { PlayStaticPipeline } from './static-pipeline';
+import { staticPipelineStorageCodec } from './static-pipeline-storage-codec';
+
+/**
+ * An in-process execution snapshot, deliberately distinct from display graphs
+ * and Convex's bounded V1 mirror. Never serialize this wrapper: durable/wire
+ * contracts continue to carry the original pipeline fields.
+ */
+export class PlayExecutionPipeline {
+  readonly #pipeline: PlayStaticPipeline | null;
+
+  private constructor(pipeline: PlayStaticPipeline | null) {
+    this.#pipeline = pipeline;
+  }
+
+  /** Read the entire storage carrier, so an existing V2 can never be dropped. */
+  static fromStored(record: {
+    staticPipeline?: unknown;
+    staticPipelineV2?: unknown;
+  }): PlayExecutionPipeline {
+    return new PlayExecutionPipeline(staticPipelineStorageCodec.read(record));
+  }
+
+  /** Only for complete compiler/admitted-artifact graphs, never a stored field. */
+  static fromAdmitted(pipeline: unknown): PlayExecutionPipeline {
+    if (
+      pipeline != null &&
+      (typeof pipeline !== 'object' ||
+        !('fields' in pipeline) ||
+        !Array.isArray(pipeline.fields) ||
+        !('substeps' in pipeline) ||
+        !Array.isArray(pipeline.substeps))
+    ) {
+      throw new Error('Invalid Play execution pipeline snapshot.');
+    }
+    // Do not compile or normalize retained contracts under current authoring
+    // rules. In particular, preserve additive fields and historical contracts.
+    return new PlayExecutionPipeline(
+      (pipeline as PlayStaticPipeline | null | undefined) ?? null,
+    );
+  }
+
+  get pipeline(): PlayStaticPipeline | null {
+    return this.#pipeline;
+  }
+}
+
+/** Reject accidental raw/serialized inputs before launch has side effects. */
+export function readPlayExecutionPipeline(
+  snapshot: PlayExecutionPipeline | undefined,
+): PlayStaticPipeline | null {
+  if (snapshot === undefined) return null;
+  if (!(snapshot instanceof PlayExecutionPipeline)) {
+    throw new Error('Play launch requires a PlayExecutionPipeline snapshot.');
+  }
+  return snapshot.pipeline;
+}
+
+/** Execution readers cannot see (and accidentally forward) the stored mirror. */
+export function readStoredPlayExecutionSnapshot<
+  T extends { staticPipeline?: unknown; staticPipelineV2?: unknown },
+>(
+  record: T,
+): Omit<T, 'staticPipeline' | 'staticPipelineV2'> & {
+  executionPipeline: PlayExecutionPipeline;
+} {
+  const { staticPipeline: _v1, staticPipelineV2: _v2, ...metadata } = record;
+  return {
+    ...metadata,
+    executionPipeline: PlayExecutionPipeline.fromStored(record),
+  };
+}

package/dist/bundling-sources/shared_libs/plays/launch/prepare.ts

@@ -61,7 +61,6 @@ export function buildPlayRunContractSnapshot(input: {
   artifactStorageKey: string;
   artifact: Pick<PlayBundleArtifact, 'compatibility'>;
   validatedSnapshot: PlayRunLaunchValidationSnapshot;
-  transportStaticPipeline?: unknown;
 }): PreparedPlayRunContractSnapshot {
   // The runtime backend is launch infrastructure, not an artifact contract.
   // Copy the admitted artifact compatibility so resumed work cannot acquire
@@ -69,8 +68,7 @@ export function buildPlayRunContractSnapshot(input: {
   const compatibility = normalizePlayContractCompatibility(
     input.artifact.compatibility,
   );
-  const staticPipeline =
-    input.transportStaticPipeline ?? input.validatedSnapshot.staticPipeline;
+  const staticPipeline = input.validatedSnapshot.staticPipeline;
   return {
     source: input.source ?? 'published',
     revisionVersion: null,

package/dist/bundling-sources/shared_libs/plays/sheet-filter.ts

@@ -1,14 +1,13 @@
 // Full-table view basic filters. A tiny, deliberately closed predicate model
 // that compiles mechanically to a parameterized SQL WHERE clause against a
-// runtime sheet's physical (jsonb) user-data columns.
+// runtime sheet's physical user-data columns.
 //
 // This is NOT free-text SQL: operators come from a closed enum, columns must
 // be on a caller-supplied allowlist (the sheet's real columns), and every value
 // is bound as a query parameter. Multiple filters AND together. No OR groups.
 //
-// Sheet user-data columns are stored one-per-column as `jsonb` (a JSON scalar
-// like "completed", 19991, or an object). `col #>> '{}'` extracts the scalar as
-// text; numeric comparisons cast that text to numeric.
+// Sheet user-data columns may be native scalars or JSONB. Normalize each cell
+// through to_jsonb before applying the shared scalar and numeric predicates.
 
 // ── The operator set, and why it grew ────────────────────────────────────────
 //
@@ -204,7 +203,7 @@ function coerceFilterNumber(value: unknown, index: number): number {
 // → 19991, an object → its JSON text. The single-arg `#>> '{}'` path returns the
 // whole value as text (Postgres jsonb → text).
 function columnAsText(quotedColumn: string): string {
-  return `(${quotedColumn} #>> '{}')`;
+  return `(to_jsonb(${quotedColumn}) #>> '{}')`;
 }
 
 function quoteIdentifier(value: string): string {
@@ -302,9 +301,10 @@ export function compileSheetFilterWhere(input: {
         const num = coerceFilterNumber(filter.value, index);
         const sqlOp = NUMERIC_SQL_OPERATOR[filter.op];
         // Guard the numeric cast to jsonb numbers only, so a stray non-numeric
-        // cell can never abort the whole query with a cast error.
+        // cell can never abort the whole query with a cast error. CASE also
+        // prevents PostgreSQL from reordering a numeric cast before its guard.
         clauses.push(
-          `(jsonb_typeof(${quoted}) = 'number' AND ${asText}::numeric ${sqlOp} $${paramIdx})`,
+          `((CASE WHEN jsonb_typeof(to_jsonb(${quoted})) = 'number' THEN ${asText}::numeric END) ${sqlOp} $${paramIdx})`,
         );
         params.push(num);
         paramIdx += 1;
@@ -317,12 +317,8 @@ export function compileSheetFilterWhere(input: {
         // range control means by it. The guard is the same one the scalar
         // comparisons use: a non-numeric cell simply does not match, rather
         // than aborting the query on a cast.
-        const body = `${asText}::numeric BETWEEN $${paramIdx} AND $${paramIdx + 1}`;
-        clauses.push(
-          `(jsonb_typeof(${quoted}) = 'number' AND ${
-            filter.op === 'between' ? body : `NOT (${body})`
-          })`,
-        );
+        const body = `(CASE WHEN jsonb_typeof(to_jsonb(${quoted})) = 'number' THEN ${asText}::numeric END) BETWEEN $${paramIdx} AND $${paramIdx + 1}`;
+        clauses.push(`(${filter.op === 'between' ? body : `NOT (${body})`})`);
         params.push(min, max);
         paramIdx += 2;
         break;