deepline 0.1.242 → 0.1.244

package/README.md

@@ -326,7 +326,7 @@ V2 prebuilt play sources are authored directly in `src/lib/plays/v2/`. After
 editing them, regenerate the committed Workers and share-page artifacts:
 
 ```bash
-bun scripts/regen.ts workers-prebuilt prebuilt-share-pages
+bun scripts/regen.ts prebuilt-share-pages
 ```
 
 ## File structure

package/dist/bundling-sources/sdk/src/plays/bundle-play-file.ts

@@ -44,7 +44,7 @@ const MODULE_DIR = dirname(fileURLToPath(import.meta.url));
 const SDK_PACKAGE_ROOT = resolve(MODULE_DIR, '..', '..');
 const SOURCE_REPO_ROOT = resolve(SDK_PACKAGE_ROOT, '..');
 const HAS_SOURCE_BUNDLING_SOURCES = existsSync(
-  resolve(SOURCE_REPO_ROOT, 'apps', 'play-runner-workers', 'src', 'entry.ts'),
+  resolve(SOURCE_REPO_ROOT, 'shared_libs', 'plays', 'bundling', 'index.ts'),
 );
 const PACKAGED_BUNDLING_SOURCE_ROOT = resolve(
   SDK_PACKAGE_ROOT,
@@ -54,10 +54,10 @@ const PACKAGED_BUNDLING_SOURCE_ROOT = resolve(
 const HAS_PACKAGED_BUNDLING_SOURCES = existsSync(
   resolve(
     PACKAGED_BUNDLING_SOURCE_ROOT,
-    'apps',
-    'play-runner-workers',
-    'src',
-    'entry.ts',
+    'shared_libs',
+    'plays',
+    'bundling',
+    'index.ts',
   ),
 );
 const PROJECT_ROOT = HAS_SOURCE_BUNDLING_SOURCES
@@ -75,20 +75,6 @@ const SDK_ENTRY_FILE = resolve(SDK_SOURCE_ROOT, 'index.ts');
 const SDK_TYPES_ENTRY_FILE = HAS_SOURCE_BUNDLING_SOURCES
   ? SDK_ENTRY_FILE
   : resolve(SDK_PACKAGE_ROOT, 'dist', 'index.d.ts');
-const SDK_WORKERS_ENTRY_FILE = resolve(SDK_SOURCE_ROOT, 'worker-play-entry.ts');
-const WORKERS_HARNESS_ENTRY_FILE = resolve(
-  PROJECT_ROOT,
-  'apps',
-  'play-runner-workers',
-  'src',
-  'entry.ts',
-);
-const WORKERS_HARNESS_FILES_DIR = resolve(
-  PROJECT_ROOT,
-  'apps',
-  'play-runner-workers',
-  'src',
-);
 let hasWarnedAboutNonDevelopmentBundling = false;
 
 /**
@@ -150,12 +136,6 @@ export function createSdkPlayBundlingAdapter(): PlayBundlingAdapter {
       HAS_SOURCE_BUNDLING_SOURCES || !existsSync(SDK_TYPES_ENTRY_FILE)
         ? SDK_ENTRY_FILE
         : SDK_TYPES_ENTRY_FILE,
-    sdkWorkersEntryFile: SDK_WORKERS_ENTRY_FILE,
-    workersHarnessEntryFile: WORKERS_HARNESS_ENTRY_FILE,
-    workersHarnessFilesDir: WORKERS_HARNESS_FILES_DIR,
-    workersRuntimeFingerprintDirs: [
-      resolve(PROJECT_ROOT, 'shared_libs', 'play-runtime'),
-    ],
     discoverPackagedLocalFiles,
     warnAboutNonDevelopmentBundling,
   };

package/dist/bundling-sources/sdk/src/release.ts

@@ -113,10 +113,12 @@ export const SDK_RELEASE = {
   // 0.1.241 hard-cuts published and launched plays to immutable cjs_node20
   // artifacts. Older clients can submit esm_workers artifacts that the Absurd
   // runtime intentionally no longer compiles at publish or launch time.
-  version: '0.1.242',
-  apiContract: '2026-07-immutable-cjs-play-artifacts-hard-cutover',
+  // 0.1.242 removes the retired Workers/ESM compiler, generated bundles, and
+  // deploy-time artifact migration. Play authoring now has one CJS contract.
+  version: '0.1.244',
+  apiContract: '2026-07-cjs-absurd-only-play-runtime-hard-cutover',
   supportPolicy: {
-    latest: '0.1.242',
+    latest: '0.1.244',
     minimumSupported: '0.1.53',
     deprecatedBelow: '0.1.219',
     commandMinimumSupported: [
@@ -128,61 +130,61 @@ export const SDK_RELEASE = {
       },
       {
         command: 'plays',
-        minimumSupported: '0.1.111',
+        minimumSupported: '0.1.241',
         reason:
-          'Play file commands now use dataset-native list getters and result row datasets.',
+          'Older SDK CLI versions predate dataset-native Play results and can emit the retired esm_workers artifact contract. Update before checking, publishing, or running plays.',
       },
       {
         command: 'plays run',
-        minimumSupported: '0.1.111',
+        minimumSupported: '0.1.241',
         reason:
-          'Play run results now promote row-shaped outputs into dataset handles for safe export.',
+          'Older SDK CLI versions predate dataset-native Play results and can emit the retired esm_workers artifact contract.',
       },
       {
         command: 'run',
         displayCommand: 'plays run',
-        minimumSupported: '0.1.111',
+        minimumSupported: '0.1.241',
         reason:
-          'Play run results now promote row-shaped outputs into dataset handles for safe export.',
+          'Older SDK CLI versions predate dataset-native Play results and can emit the retired esm_workers artifact contract.',
       },
       {
         command: 'plays check',
-        minimumSupported: '0.1.111',
+        minimumSupported: '0.1.241',
         reason:
-          'Play file checks now validate dataset-native list getter authoring.',
+          'Older SDK CLI versions predate dataset-native Play authoring and validate against the retired esm_workers artifact contract.',
       },
       {
         command: 'check',
         displayCommand: 'plays check',
-        minimumSupported: '0.1.111',
+        minimumSupported: '0.1.241',
         reason:
-          'Play file checks now validate dataset-native list getter authoring.',
+          'Older SDK CLI versions predate dataset-native Play authoring and validate against the retired esm_workers artifact contract.',
       },
       {
         command: 'plays publish',
-        minimumSupported: '0.1.111',
+        minimumSupported: '0.1.241',
         reason:
-          'Published play artifacts now target dataset-native list getters and result row datasets.',
+          'Older SDK CLI versions predate dataset-native Play artifacts and can publish the retired esm_workers artifact contract.',
       },
       {
         command: 'publish',
         displayCommand: 'plays publish',
-        minimumSupported: '0.1.111',
+        minimumSupported: '0.1.241',
         reason:
-          'Published play artifacts now target dataset-native list getters and result row datasets.',
+          'Older SDK CLI versions predate dataset-native Play artifacts and can publish the retired esm_workers artifact contract.',
       },
       {
         command: 'plays set-live',
-        minimumSupported: '0.1.111',
+        minimumSupported: '0.1.241',
         reason:
-          'Published play artifacts now target dataset-native list getters and result row datasets.',
+          'Older SDK CLI versions predate dataset-native Play artifacts and can publish the retired esm_workers artifact contract.',
       },
       {
         command: 'set-live',
         displayCommand: 'plays set-live',
-        minimumSupported: '0.1.111',
+        minimumSupported: '0.1.241',
         reason:
-          'Published play artifacts now target dataset-native list getters and result row datasets.',
+          'Older SDK CLI versions predate dataset-native Play artifacts and can publish the retired esm_workers artifact contract.',
       },
       {
         command: 'runs',

package/dist/bundling-sources/sdk/src/types.ts

@@ -1221,7 +1221,7 @@ export interface StartPlayRunRequest {
   waitForCompletionMs?: number;
   /**
    * Per-run execution profile override. The server defaults to absurd. The
-   * workers_edge profile is disabled; most callers should leave this unset.
+   * Only `absurd` is accepted; most callers should leave this unset.
    */
   profile?: string;
   /** Optional per-run provider execution mode for eval/smoke runs. */

package/dist/bundling-sources/shared_libs/play-runtime/backend.ts

@@ -1,27 +1,17 @@
 export const PLAY_RUNTIME_BACKENDS = {
   localProcess: 'local_process',
   daytona: 'daytona',
-  // Artifact/runtime contract for Cloudflare Dynamic Workers. This is no
-  // longer a standalone runner backend; use profile=workers_edge so the
-  // cf-workflows scheduler owns loading and execution.
-  cloudflareWorkers: 'cloudflare_workers',
 } as const;
 
 export type PlayRuntimeBackendId =
   (typeof PLAY_RUNTIME_BACKENDS)[keyof typeof PLAY_RUNTIME_BACKENDS];
 
 /**
- * The runtime shape of a built play artifact. Different runner backends need
- * different bundle outputs:
- *   - cjs_node20: Daytona + local-process (full Node.js sandbox).
- *   - esm_workers: Cloudflare Workers (V8 isolate, no `fs`/`child_process`).
- *
- * The CLI selects which kind to build based on the target backend; the worker
- * validates the kind matches the backend it's about to dispatch to.
+ * The one executable Play artifact contract. Daytona and local-process both
+ * load CommonJS under Node 20.
  */
 export const PLAY_ARTIFACT_KINDS = {
   cjsNode20: 'cjs_node20',
-  esmWorkers: 'esm_workers',
 } as const;
 
 export type PlayArtifactKind =
@@ -49,11 +39,6 @@ export const PLAY_BACKEND_DESCRIPTORS: Record<
     artifactKind: PLAY_ARTIFACT_KINDS.cjsNode20,
     label: 'Daytona sandbox',
   },
-  [PLAY_RUNTIME_BACKENDS.cloudflareWorkers]: {
-    id: PLAY_RUNTIME_BACKENDS.cloudflareWorkers,
-    artifactKind: PLAY_ARTIFACT_KINDS.esmWorkers,
-    label: 'Cloudflare Dynamic Workers',
-  },
 };
 
 export function describePlayBackend(
@@ -84,10 +69,6 @@ export function normalizePlayRuntimeBackend(
     return PLAY_RUNTIME_BACKENDS.localProcess;
   }
 
-  if (normalized === PLAY_RUNTIME_BACKENDS.cloudflareWorkers) {
-    return PLAY_RUNTIME_BACKENDS.cloudflareWorkers;
-  }
-
   throw new Error(
     `Unsupported play runtime backend "${normalized}". Expected one of: ${Object.values(
       PLAY_RUNTIME_BACKENDS,

package/dist/bundling-sources/shared_libs/play-runtime/governor/governor.ts

@@ -1,11 +1,9 @@
 /**
  * Play Execution Governor — the deep module that owns execution policy.
  *
- * Both runner Adapters (`cjs_node20`, `esm_workers`) gate their work through one
- * Governor instance per run-attempt so the substrates cannot diverge on
- * concurrency, budgets, or pacing. Adapters keep only substrate mechanism (how
- * to resolve a row, batch a tool call, or submit a child); the Governor owns the
- * "may I, and how many at once" policy. See ADR 0007 + CONTEXT.md.
+ * The CJS runner gates work through one Governor instance per run-attempt. The
+ * runner owns execution mechanics; the Governor owns the "may I, and how many
+ * at once" policy. See ADR 0007 + CONTEXT.md.
  *
  * Surface (small, by design):
  *   - acquireRowSlot / acquireToolSlot                         → blocking leases
@@ -283,7 +281,8 @@ export function createPlayExecutionGovernor(
   }
 
   const scopeFor = (toolId: string | undefined, provider: string) =>
-    scopeByTool.get(toolId ?? '') ?? ([orgBucket(provider), ''] as [string, string]);
+    scopeByTool.get(toolId ?? '') ??
+    ([orgBucket(provider), ''] as [string, string]);
 
   async function resolveAdaptivePacing(toolId: string): Promise<{
     provider: string;

package/dist/bundling-sources/shared_libs/play-runtime/governor/policy.ts

@@ -2,10 +2,8 @@
  * Play Execution Governor — the single policy table.
  *
  * This is the ONE source of truth for every concurrency, budget, and pacing
- * number in the play runtime. Both runner Adapters (`cjs_node20` in-process and
- * `esm_workers` cloud) resolve their limits from here, so the two substrates
- * cannot drift. See ADR 0007 and the "Play Execution Governor" entry in
- * CONTEXT.md.
+ * number in the CJS/Node play runtime. See ADR 0007 and the "Play Execution
+ * Governor" entry in CONTEXT.md.
  *
  * Tuning philosophy (product decision):
  *  - Caps are explicit resource admission boundaries. A run should queue behind
@@ -51,13 +49,9 @@ export interface ExecutionBudgetPolicy {
 /**
  * Per-provider rate pacing — the real outbound throughput governor.
  *
- * SUBSTRATE NOTE: the per-provider request RATE (`requestsPerWindow`/`windowMs`
- * from a provider's `PacingRule`s) is enforced on BOTH substrates. A rule's
- * optional `maxConcurrency` (simultaneous-in-flight cap) is enforced only on
- * `cjs_node20`; on `esm_workers` it is intentionally excluded from the pacing
- * contract because a fanned-out run cannot guarantee the per-isolate release
- * signal an in-flight count needs, so only the org-wide tool-concurrency
- * backstop applies there. See PacingRule.maxConcurrency in rate-state-backend.ts.
+ * Per-provider request rate and optional in-flight concurrency are enforced by
+ * the same CJS/Node substrate. See PacingRule.maxConcurrency in
+ * rate-state-backend.ts.
  */
 export interface ExecutionPacingPolicy {
   /** RPS applied to a provider that declares no explicit rate limit. */
@@ -120,7 +114,7 @@ export const SHARED_EXECUTION_POLICY: ResolvedExecutionPolicy = {
   },
 };
 
-export type AdapterId = 'cjs_node20' | 'esm_workers';
+export type AdapterId = 'cjs_node20';
 
 /**
  * One level deep on purpose: each policy section is a flat record of numbers, so
@@ -141,7 +135,6 @@ type PolicyOverride = {
  */
 export const ADAPTER_POLICY_OVERRIDES: Record<AdapterId, PolicyOverride> = {
   cjs_node20: {},
-  esm_workers: {},
 };
 
 /** Merge the shared policy with any documented Adapter override. */

package/dist/bundling-sources/shared_libs/play-runtime/governor/rate-state-backend.ts

@@ -1,14 +1,9 @@
 /**
  * Rate State Backend — the one swappable seam of the Play Execution Governor.
  *
- * Per-`(org, provider)` rate windows are the only execution state that cannot be
- * process-local: on `esm_workers` a run fans child plays across isolates, so the
- * window must be shared. Everything else the Governor owns (budgets, concurrency
- * slots) stays Governor-local and threads down the lineage via the snapshot.
- *
- * Adapters: an in-memory backend for the single-process `cjs_node20` runner, and
- * a shared backend (Run Coordination Cache Durable Object, or server-side Redis)
- * for `esm_workers`. See ADR 0007 and CONTEXT.md (Rate State Backend).
+ * Per-`(org, provider)` rate windows are shared across CJS runner processes.
+ * Everything else the Governor owns stays local to one run attempt and threads
+ * down the lineage via the snapshot. See ADR 0007 and CONTEXT.md.
  */
 
 /** A single resolved rate rule for a bucket (from rate-limit-definitions). */
@@ -19,16 +14,8 @@ export interface PacingRule {
   /**
    * Optional simultaneous-in-flight cap for this rule.
    *
-   * SUBSTRATE NOTE: `maxConcurrency` is enforced ONLY on `cjs_node20` (the
-   * single-process {@link RateStateBackend} can hold a reliable in-flight count
-   * and release it on permit.release). On `esm_workers` it is intentionally NOT
-   * enforced: a run fans across V8 isolates and a dying isolate cannot guarantee
-   * the release signal a leased in-flight count would require, so the
-   * coordinator DO debits `requestsPerWindow` only. The Governor's global
-   * tool-concurrency semaphore is the cross-isolate in-flight backstop there.
-   * `requestsPerWindow`/`windowMs` (the request-RATE governor) ARE enforced on
-   * both substrates. See coordinator-rate-state-backend.ts and dedup-do.ts
-   * (computeRateAcquire) for the workers side.
+   * The CJS runtime holds a reliable in-flight count and releases it on
+   * permit.release. `requestsPerWindow`/`windowMs` enforce request rate.
    */
   readonly maxConcurrency: number | null;
 }
@@ -60,25 +47,21 @@ export interface PacingPermit {
  * Discriminates the backend so the Governor can adapt its policy to it. Only
  * `app_runtime_postgres` (the Absurd/Node substrate's DB-backed pacer) is
  * db-authoritative: it runs the whole token-bucket + AIMD in Postgres, so the
- * Governor's in-memory adaptive admission must become a passthrough and defer
- * pacing to the row. The in-memory and coordinator backends leave `kind`
- * undefined and keep the Governor's in-memory adaptive admission (byte-identical
- * to today).
+ * Governor's in-memory adaptive admission becomes a passthrough and defers
+ * pacing to the row. The in-memory backend leaves `kind` undefined.
  */
 export type RateStateBackendKind = 'app_runtime_postgres';
 
 export interface RateStateBackend {
   /**
    * When present, tells the Governor this backend owns pacing authoritatively.
-   * Absent on the in-memory and coordinator backends — those keep the Governor's
-   * in-memory adaptive admission.
+   * Absent on the in-memory backend.
    */
   readonly kind?: RateStateBackendKind;
 
   /**
    * Block until one outbound call is permitted for `bucketId` under all `rules`
-   * (request windows always; per-rule `maxConcurrency` only on the in-memory
-   * `cjs_node20` backend — see {@link PacingRule.maxConcurrency}), then debit and
+   * (request windows and per-rule `maxConcurrency`), then debit and
    * return a permit. `bucketId` is `${orgId}:${provider}` so the window is global
    * per (org, provider). Resolves immediately when `rules` is empty (provider has
    * no configured limit — pacing is a no-op, the global tool-concurrency backstop

package/dist/bundling-sources/shared_libs/play-runtime/internal-step-ids.ts

@@ -6,8 +6,7 @@
  * machine-generated source line range (`lines_<startLine>_<endLine>`, built in
  * `src/lib/plays/static-analysis.ts` → `createCodeStageForStatements`). The
  * execution plan / runtime node ids namespace every substep by its type
- * (`getStaticSubstepNodeId` in `src/lib/plays/step-progress.ts` and
- * `apps/play-runner-workers/src/entry.ts`), so glue nodes are ALWAYS
+ * (`getStaticSubstepNodeId` in `src/lib/plays/step-progress.ts`), so glue nodes are ALWAYS
  * `run_javascript:<alias>` on the wire (ledger stepsById, snapshot
  * nodeStates, `play.step.*` stream events).
  *

package/dist/bundling-sources/shared_libs/play-runtime/map-row-identity.ts

@@ -3,7 +3,7 @@ import {
   derivePlayRowIdentityFromKey,
   // Relative (not '@shared_libs/...') because this file ships inside the
   // packed SDK's dist/bundling-sources graph (reachable from the
-  // apps/play-runner-workers entry), where only relative imports resolve.
+  // packaged runner entry), where only relative imports resolve.
 } from '../plays/row-identity';
 import type { MapExecutionScope } from './ctx-types';
 

package/dist/bundling-sources/shared_libs/play-runtime/output-size-limits.ts

@@ -13,7 +13,16 @@ export const TERMINAL_RUN_RESULT_MAX_BYTES = 2_500_000;
  * of provider payload — which is durable in scheduler Postgres and never read
  * back from Convex, yet deterministically wedged the append.
  */
-export const LEDGER_TERMINAL_RESULT_MAX_BYTES = 768 * 1024;
+// The terminal projection is persisted twice on `playRuns` (top-level result
+// and runSnapshot.result), in addition to the event document. Keep one copy at
+// 256 KiB so ordinary snapshots retain headroom under Convex's 1 MiB document
+// ceiling. The runtime route has a reference-only fallback for an unusually
+// large pre-existing snapshot that still exceeds the aggregate document cap.
+export const LEDGER_TERMINAL_RESULT_MAX_BYTES = 256 * 1024;
+export const LEDGER_TERMINAL_RESULT_MAX_DEPTH = 10;
+export const CONVEX_LEDGER_ARRAY_MAX_ITEMS = 8_192;
+export const CONVEX_LEDGER_OBJECT_MAX_FIELDS = 1_024;
+export const CONVEX_LEDGER_FIELD_NAME_MAX_LENGTH = 1_024;
 export const CUSTOMER_OUTPUT_VALUE_MAX_BYTES = 1 * 1024 * 1024;
 export const CUSTOMER_OUTPUT_TOTAL_MAX_BYTES = 2 * 1024 * 1024;
 /** Inline Postgres receipt contract: one serialized output is at most 10 MiB. */
@@ -121,13 +130,183 @@ export type LedgerTerminalResultRef = {
   key: 'terminal_result_json';
   /** Serialized byte size of the result that was elided from the ledger. */
   bytes: number;
-  reason: 'terminal_result_exceeds_ledger_limit';
+  reason: LedgerTerminalResultRefReason;
+};
+
+export type LedgerTerminalResultRefReason =
+  | 'terminal_result_exceeds_ledger_limit'
+  | 'terminal_result_exceeds_ledger_depth'
+  | 'terminal_result_has_invalid_field_name'
+  | 'terminal_result_array_too_long'
+  | 'terminal_result_object_too_wide'
+  | 'terminal_result_not_json_serializable'
+  | 'terminal_result_rejected_by_convex';
+
+export type ConvexLedgerPayloadIssue = {
+  reason:
+    | 'size_limit'
+    | 'depth_limit'
+    | 'invalid_field_name'
+    | 'array_too_long'
+    | 'object_too_wide'
+    | 'not_json_serializable';
+  bytes?: number;
 };
 
 function isPlainObject(value: unknown): value is Record<string, unknown> {
   return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
 }
 
+function isConvexFieldName(value: string): boolean {
+  if (
+    value.length > CONVEX_LEDGER_FIELD_NAME_MAX_LENGTH ||
+    value.startsWith('$')
+  ) {
+    return false;
+  }
+  for (let index = 0; index < value.length; index += 1) {
+    const code = value.charCodeAt(index);
+    if (code < 32 || code >= 127) return false;
+  }
+  return true;
+}
+
+/**
+ * Validate the part of Convex's value contract that can permanently poison a
+ * durable run-ledger append. The walk is iterative and stops at the depth
+ * boundary, so adversarial nesting cannot overflow the JS stack while being
+ * classified. It intentionally returns no path or customer field name.
+ */
+export function inspectConvexLedgerPayload(
+  value: unknown,
+): ConvexLedgerPayloadIssue | null {
+  const stack: Array<{ value: unknown; depth: number }> = [
+    {
+      value,
+      depth: value !== null && typeof value === 'object' ? 1 : 0,
+    },
+  ];
+
+  while (stack.length > 0) {
+    const current = stack.pop()!;
+    if (current.depth > LEDGER_TERMINAL_RESULT_MAX_DEPTH) {
+      return { reason: 'depth_limit' };
+    }
+    if (Array.isArray(current.value)) {
+      if (current.value.length > CONVEX_LEDGER_ARRAY_MAX_ITEMS) {
+        return { reason: 'array_too_long' };
+      }
+      for (const item of current.value) {
+        stack.push({
+          value: item,
+          depth:
+            item !== null && typeof item === 'object'
+              ? current.depth + 1
+              : current.depth,
+        });
+      }
+      continue;
+    }
+    if (!current.value || typeof current.value !== 'object') continue;
+
+    const entries = Object.entries(current.value as Record<string, unknown>);
+    if (entries.length > CONVEX_LEDGER_OBJECT_MAX_FIELDS) {
+      return { reason: 'object_too_wide' };
+    }
+    for (const [key, entry] of entries) {
+      if (!isConvexFieldName(key)) {
+        return { reason: 'invalid_field_name' };
+      }
+      stack.push({
+        value: entry,
+        depth:
+          entry !== null && typeof entry === 'object'
+            ? current.depth + 1
+            : current.depth,
+      });
+    }
+  }
+
+  try {
+    const bytes = jsonByteLength(value);
+    return bytes > LEDGER_TERMINAL_RESULT_MAX_BYTES
+      ? { reason: 'size_limit', bytes }
+      : null;
+  } catch {
+    return { reason: 'not_json_serializable' };
+  }
+}
+
+export function isLedgerTerminalResultRef(
+  value: unknown,
+): value is LedgerTerminalResultRef {
+  return (
+    isPlainObject(value) &&
+    value.__kind === 'deepline.ledger_terminal_result_ref.v1' &&
+    value.store === 'scheduler_postgres' &&
+    value.key === 'terminal_result_json'
+  );
+}
+
+export function stripReplayOnlyTerminalResult(value: unknown): unknown {
+  if (!isPlainObject(value) || isLedgerTerminalResultRef(value)) return value;
+  const stripped: Record<string, unknown> = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (
+      (LEDGER_STRIPPED_TERMINAL_RESULT_KEYS as readonly string[]).includes(key)
+    ) {
+      continue;
+    }
+    stripped[key] = entry;
+  }
+  return stripped;
+}
+
+function refReasonForIssue(
+  issue: ConvexLedgerPayloadIssue['reason'],
+): LedgerTerminalResultRefReason {
+  switch (issue) {
+    case 'size_limit':
+      return 'terminal_result_exceeds_ledger_limit';
+    case 'depth_limit':
+      return 'terminal_result_exceeds_ledger_depth';
+    case 'invalid_field_name':
+      return 'terminal_result_has_invalid_field_name';
+    case 'array_too_long':
+      return 'terminal_result_array_too_long';
+    case 'object_too_wide':
+      return 'terminal_result_object_too_wide';
+    case 'not_json_serializable':
+      return 'terminal_result_not_json_serializable';
+  }
+}
+
+export function ledgerTerminalResultRefForValue(
+  value: unknown,
+  reason: LedgerTerminalResultRefReason,
+): LedgerTerminalResultRef {
+  let bytes = 0;
+  try {
+    bytes = jsonByteLength(value);
+  } catch {
+    // The bounded reason is the useful diagnostic. Never serialize the
+    // customer payload again merely to populate reference metadata.
+  }
+  return {
+    __kind: 'deepline.ledger_terminal_result_ref.v1',
+    store: 'scheduler_postgres',
+    key: 'terminal_result_json',
+    bytes,
+    reason,
+  };
+}
+
+/** Optional derived summaries must never block the terminal lifecycle event. */
+export function ledgerSummaryForLedger(value: unknown): unknown {
+  if (value === undefined || value === null) return value;
+  return inspectConvexLedgerPayload(value) ? undefined : value;
+}
+
 /**
  * Shape a terminal run result for the Convex run ledger. Control-plane only:
  *
@@ -138,40 +317,23 @@ function isPlainObject(value: unknown): value is Record<string, unknown> {
  *    the durable scheduler copy, so the ledger event stays small and the
  *    Convex append cannot wedge on an oversized/over-nested document.
  *
- * The full result (including its checkpoint) remains durable in scheduler
- * Postgres regardless; this only governs what the ledger embeds.
+ * Any result accepted by the existing terminal persistence contract remains
+ * durable in scheduler Postgres; this only governs what the ledger embeds.
  */
 export function terminalRunResultForLedger(value: unknown): unknown {
   if (value === undefined || value === null) {
     return value;
   }
-  let candidate = value;
-  if (isPlainObject(value)) {
-    const stripped: Record<string, unknown> = {};
-    for (const [key, entry] of Object.entries(value)) {
-      if (
-        (LEDGER_STRIPPED_TERMINAL_RESULT_KEYS as readonly string[]).includes(
-          key,
-        )
-      ) {
-        continue;
-      }
-      stripped[key] = entry;
-    }
-    candidate = stripped;
-  }
-  const bytes = jsonByteLength(candidate);
-  if (bytes <= LEDGER_TERMINAL_RESULT_MAX_BYTES) {
+  if (isLedgerTerminalResultRef(value)) return value;
+  const candidate = stripReplayOnlyTerminalResult(value);
+  const issue = inspectConvexLedgerPayload(candidate);
+  if (!issue) {
     return candidate;
   }
-  const ref: LedgerTerminalResultRef = {
-    __kind: 'deepline.ledger_terminal_result_ref.v1',
-    store: 'scheduler_postgres',
-    key: 'terminal_result_json',
-    bytes,
-    reason: 'terminal_result_exceeds_ledger_limit',
-  };
-  return ref;
+  return ledgerTerminalResultRefForValue(
+    candidate,
+    refReasonForIssue(issue.reason),
+  );
 }
 
 export function assertCustomerOutputValueWithinLimit(input: {

package/dist/bundling-sources/shared_libs/play-runtime/play-latency-trace.ts

@@ -107,7 +107,7 @@ export const PLAY_LATENCY_SUMMARY_COLUMNS: PlayLatencyPhaseDefinition[] = [
     header: 'route_child',
     phase: 'server.start_route_resolve_child_manifests',
     source: 'server',
-    description: 'Start route child play manifest resolution for workers_edge.',
+    description: 'Start route child play manifest resolution.',
   },
   {
     header: 'route_active',