deepline 0.1.243 → 0.1.245

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',

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

@@ -11,7 +11,6 @@ import {
 } from './scheduler-backend';
 
 export const PLAY_RUNTIME_PROVIDER_IDS = {
-  workersEdge: 'workers_edge',
   absurd: 'absurd',
 } as const;
 
@@ -27,34 +26,10 @@ export type PlayRuntimeProviderDescriptor = {
   label: string;
 };
 
-export const PLAY_RUNTIME_PROVIDER_DISABLED_CODE =
-  'PLAY_RUNTIME_PROVIDER_DISABLED' as const;
-
-export class PlayRuntimeProviderDisabledError extends Error {
-  readonly code = PLAY_RUNTIME_PROVIDER_DISABLED_CODE;
-  readonly profile: PlayRuntimeProviderId;
-
-  constructor(profile: PlayRuntimeProviderId) {
-    super(
-      `Play runtime profile "${profile}" is disabled. Deepline runs now execute on the "absurd" profile.`,
-    );
-    this.name = 'PlayRuntimeProviderDisabledError';
-    this.profile = profile;
-  }
-}
-
 export const PLAY_RUNTIME_PROVIDERS: Record<
   PlayRuntimeProviderId,
   PlayRuntimeProviderDescriptor
 > = {
-  workers_edge: {
-    id: PLAY_RUNTIME_PROVIDER_IDS.workersEdge,
-    scheduler: PLAY_SCHEDULER_BACKENDS.cfWorkflows,
-    runner: PLAY_RUNTIME_BACKENDS.cloudflareWorkers,
-    dedup: PLAY_DEDUP_BACKENDS.durableObject,
-    artifactKind: PLAY_ARTIFACT_KINDS.esmWorkers,
-    label: 'Cloudflare Dynamic Workflows + Dynamic Workers + DO dedup',
-  },
   absurd: {
     id: PLAY_RUNTIME_PROVIDER_IDS.absurd,
     scheduler: PLAY_SCHEDULER_BACKENDS.absurd,
@@ -73,14 +48,6 @@ export function defaultPlayRuntimeProvider(): PlayRuntimeProviderDescriptor {
   return PLAY_RUNTIME_PROVIDERS.absurd;
 }
 
-export function assertPlayRuntimeProviderEnabled(
-  provider: PlayRuntimeProviderDescriptor,
-): void {
-  if (provider.id === PLAY_RUNTIME_PROVIDER_IDS.workersEdge) {
-    throw new PlayRuntimeProviderDisabledError(provider.id);
-  }
-}
-
 export function resolvePlayRuntimeProvider(
   override?: string | null,
 ): PlayRuntimeProviderDescriptor {
@@ -101,7 +68,5 @@ export function resolvePlayRuntimeProvider(
 export function resolveEnabledPlayRuntimeProvider(
   override?: string | null,
 ): PlayRuntimeProviderDescriptor {
-  const provider = resolvePlayRuntimeProvider(override);
-  assertPlayRuntimeProviderEnabled(provider);
-  return provider;
+  return resolvePlayRuntimeProvider(override);
 }

package/dist/bundling-sources/shared_libs/play-runtime/run-ledger.ts

@@ -35,8 +35,7 @@ export type PlayRunLedgerEventSource =
 /**
  * Live progress for a single step/node.
  *
- * Verified producer semantics (workers_edge map executor —
- * `apps/play-runner-workers/src/entry.ts`):
+ * Verified map-executor producer semantics:
  *
  * - `completed` counts SUCCESSFULLY written rows ONLY, never failures/skips.
  *   In-flight it is `min(total, totalRowsWritten + completedExecutedRows)`
@@ -969,7 +968,7 @@ function retryablePlatformDeployFailureSnapshot(
 // failure isolation). Forcing `completed = total` here would fabricate
 // successes that never happened and falsify the persisted counts. The truthful
 // terminal counts are carried by the producer's final reconciled bump, which
-// the workers_edge finalize path now drains BEFORE emitting step.completed
+// the finalize path drains BEFORE emitting step.completed
 // (entry.ts finalize ordering invariant). This settle path is the last-resort
 // heal for the missing-final-bump case, where the honest thing is "we know it
 // stopped, we do not know it fully succeeded" — leave the last observed

package/dist/bundling-sources/shared_libs/play-runtime/runner-backends/index.ts

@@ -13,13 +13,6 @@ export function resolvePlayRunnerBackend(
   const backend = normalizePlayRuntimeBackend(
     backendId ?? process.env.DEEPLINE_PLAY_RUNNER_BACKEND,
   );
-  if (backend === PLAY_RUNTIME_BACKENDS.cloudflareWorkers) {
-    throw new Error(
-      'The Cloudflare runner-only backend has been retired. Pass ' +
-        '`body.profile=workers_edge` on POST /api/v2/plays/run to use the ' +
-        'Cloudflare scheduler/runner profile.',
-    );
-  }
   if (backend === PLAY_RUNTIME_BACKENDS.daytona) {
     return daytonaPlayRunnerBackend;
   }

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

@@ -91,7 +91,6 @@ import {
   resolveMapRowOutcomeKey,
 } from './map-row-outcome';
 import { DEEPLINE_CELL_META_FIELD } from './cell-staleness';
-import type { PlayArtifactKind } from './backend';
 import {
   PLAY_RUNTIME_CONTRACT,
   PLAY_RUNTIME_CONTRACT_HEADER,
@@ -439,14 +438,6 @@ type RuntimeApiActionRequest =
   | {
       action: 'resolve_play';
       playRef: string;
-      /**
-       * Artifact kind the caller can execute. Node runners (postgres
-       * scheduler inline executor, Daytona/local-process) request
-       * `cjs_node20` so a child published with an esm_workers artifact is
-       * re-bundled server-side into a `Module._compile`-loadable module.
-       * Omitted = the stored artifact is returned verbatim.
-       */
-      artifactKind?: PlayArtifactKind;
     }
   | {
       action: 'ensure_sheet';
@@ -2964,7 +2955,6 @@ async function writeRuntimeRows(
 export async function resolveRuntimeReferencedPlay(
   context: RuntimeApiContext,
   playRef: string,
-  options?: { artifactKind?: PlayArtifactKind },
 ): Promise<ResolvedRuntimePlay | null> {
   const response = await postRuntimeApi<{
     play: ResolvedRuntimePlay | null;
@@ -2972,7 +2962,6 @@ export async function resolveRuntimeReferencedPlay(
   }>(context, {
     action: 'resolve_play',
     playRef,
-    ...(options?.artifactKind ? { artifactKind: options.artifactKind } : {}),
   });
   if (!response.play) {
     return null;
@@ -7235,7 +7224,7 @@ async function failRuntimeMapRowChunks(
  * field values that completed before the error — see
  * `failRuntimeMapRowChunks` for the recovery contract.
  *
- * Used by the workers_edge harness's `persistCompletedMapRows` so map
+ * Used by `persistCompletedMapRows` so map
  * completion writes go through the shared runtime storage plane and skip the
  * per-chunk Vercel hop.
  */

package/dist/bundling-sources/shared_libs/play-runtime/runtime-pg-driver-pg.ts

@@ -1,7 +1,6 @@
 /**
- * pg-backed Pool factory. Installed at boot by the Node-runtime
- * play-runner (Daytona/local). NOT used by the workers_edge harness — pg's
- * raw TCP socket usage is banned in workerd.
+ * pg-backed Pool factory. Installed at boot by the Node play runner
+ * (Daytona/local).
  */
 import { Pool, type PoolClient } from 'pg';
 import {

package/dist/bundling-sources/shared_libs/play-runtime/runtime-pg-driver.ts

@@ -1,19 +1,10 @@
 /**
  * Driver-agnostic Postgres pool/client surface used by the runtime data plane.
  *
- * The runtime data plane (`runtime-api.ts` direct-Neon writes) needs to run in
- * two very different environments:
- *
- *   - Node (Daytona/local play-runner) — uses the `pg` library, raw TCP to Neon.
- *   - Cloudflare Workers (workers_edge harness) — `pg` cannot bundle (raw TCP
- *     is banned at workerd boundary), so we use `@neondatabase/serverless`
- *     which speaks the same Postgres wire protocol over a WebSocket proxy.
- *
- * Rather than `if-platform` branches inside runtime-api.ts, each runtime
- * registers its driver once at boot and the rest of the code uses the
- * abstract `RuntimePool` / `RuntimePoolClient` types. Both `pg` and
- * `@neondatabase/serverless` already expose the relevant subset of the
- * `pg` API surface (`pool.connect()` → `client.query() / .release()`), so
+ * The Node runtime registers its `pg` driver once at boot and the rest of the
+ * data plane uses the abstract `RuntimePool` / `RuntimePoolClient` types. `pg`
+ * exposes the relevant API surface (`pool.connect()` → `client.query() /
+ * .release()`), so
  * the wrappers are thin.
  */
 
@@ -143,8 +134,7 @@ export function createRuntimePool(input: {
   if (!poolFactory) {
     throw new Error(
       'No runtime Postgres pool factory registered. Call ' +
-        'installPgRuntimePoolDriver() (Node) or ' +
-        'installNeonServerlessRuntimePoolDriver() (Workers) at boot before ' +
+        'installPgRuntimePoolDriver() at boot before ' +
         'using runtime-api Postgres helpers.',
     );
   }

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

@@ -1,12 +1,11 @@
 /**
  * Scheduler-backend interface — owns play workflow lifecycle.
  *
- * One of three pluggable axes (alongside runner-backends and dedup-backends).
+ * One of two pluggable axes (alongside runner-backends and dedup-backends).
  * Selected per-run via PlayExecutionProfile.
  *
- * Absurd is the enabled production scheduler. The Cloudflare Workflows
- * adapter is retained for historical run interpretation while workers_edge
- * launch admission is disabled.
+ * Absurd is the only durable production scheduler. In-process exists only for
+ * focused local execution.
  *
  * Customer plays are unaffected — this is purely the orchestration layer.
  */
@@ -24,9 +23,6 @@ import type { RuntimeTestPolicyOverrides } from './test-runtime-seams';
 import type { PlayRunInputPayload } from './play-input';
 
 export const PLAY_SCHEDULER_BACKENDS = {
-  cfWorkflows: 'cf-workflows',
-  /** Private legacy id retained only so old persisted rows can be interpreted. */
-  postgres: 'postgres',
   /**
    * Postgres-native durable-execution scheduler (vendored Absurd engine). Runs
    * on the battle-tested run-state store without an external workflow engine.
@@ -47,10 +43,7 @@ export type PlaySchedulerSubmitInput = {
   playName: string;
   workflowFamilyKey?: string | null;
   artifactStorageKey: string;
-  /**
-   * Optional inline artifact for node-compatible schedulers. Workers-edge
-   * schedulers use artifactStorageKey plus dynamicWorkerCode instead.
-   */
+  /** Optional inline artifact for the Node scheduler. */
   runtimeArtifact?: unknown;
   artifactHash: string;
   graphHash: string;
@@ -99,8 +92,6 @@ export type PlaySchedulerSubmitInput = {
    * this field for DB-session unwrap and the re-minted `executorToken` for auth.
    */
   preloadedDbSessionUnwrapKey?: string | null;
-  /** Optional immutable Worker module source for local Dynamic Worker loading. */
-  dynamicWorkerCode?: string | null;
   executorToken: string;
   /** Immutable facts used by durable schedulers to mint a fresh leg token. */
   runtimeAuthority: RuntimeAuthorityDescriptor;
@@ -226,10 +217,7 @@ export function normalizePlaySchedulerBackend(
 ): PlaySchedulerBackendId {
   const normalized = value?.trim().toLowerCase();
   if (!normalized) {
-    return PLAY_SCHEDULER_BACKENDS.cfWorkflows;
-  }
-  if (normalized === 'cf-workflows' || normalized === 'cf_workflows') {
-    return PLAY_SCHEDULER_BACKENDS.cfWorkflows;
+    return PLAY_SCHEDULER_BACKENDS.absurd;
   }
   if (normalized === 'absurd' || normalized === 'absurd-scheduler') {
     return PLAY_SCHEDULER_BACKENDS.absurd;
@@ -238,9 +226,6 @@ export function normalizePlaySchedulerBackend(
     return PLAY_SCHEDULER_BACKENDS.inProcess;
   }
   throw new Error(
-    `Unsupported scheduler backend "${normalized}". Expected one of: ${[
-      PLAY_SCHEDULER_BACKENDS.cfWorkflows,
-      PLAY_SCHEDULER_BACKENDS.absurd,
-    ].join(', ')}.`,
+    `Unsupported scheduler backend "${normalized}". Expected one of: ${PLAY_SCHEDULER_BACKENDS.absurd}, ${PLAY_SCHEDULER_BACKENDS.inProcess}.`,
   );
 }

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

@@ -117,9 +117,7 @@ function adaptV2ExecuteResponseToToolResult(data: Record<string, unknown>): {
  * Parsed view of a raw `/api/v2/integrations/:toolId/execute` JSON body.
  *
  * This is the single runtime-side seam from a V2 execute response to the
- * inputs of {@link createToolExecuteResult}. Both runner substrates (the
- * in-process cjs runtime in `shared_libs/play-runtime/context.ts` and the
- * Workers runtime in `apps/play-runner-workers`) must go through
+ * inputs of {@link createToolExecuteResult}. The CJS runtime must go through
  * {@link parseToolExecuteResponse}; the intermediate envelope shapes
  * (`toolResponse` adaptation, `_metadata.tool` parsing, status derivation)
  * are private to this module.
@@ -1322,7 +1320,8 @@ function rememberLiveToolResultListDataset(
   liveToolResultListDatasets.delete(datasetId);
   liveToolResultListDatasets.set(datasetId, dataset);
   while (
-    liveToolResultListDatasets.size > LIVE_TOOL_RESULT_LIST_DATASET_REGISTRY_LIMIT
+    liveToolResultListDatasets.size >
+    LIVE_TOOL_RESULT_LIST_DATASET_REGISTRY_LIMIT
   ) {
     const oldest = liveToolResultListDatasets.keys().next().value;
     if (typeof oldest !== 'string') break;

package/dist/bundling-sources/shared_libs/plays/artifact-kind-guard.ts

@@ -1,18 +1,15 @@
 import type { PlayArtifactKind, PlayBundleArtifact } from './artifact-types';
 
 /**
- * Loud, directional guard that stops a Cloudflare-Workers (`esm_workers`)
- * bundle from reaching a Node/Daytona (`cjs_node20`) runner.
+ * Loud guard that stops a historical or malformed non-CJS bundle from
+ * reaching a Node/Daytona (`cjs_node20`) runner.
  *
  * The Node runner loads play code with `Module._compile`, which cannot resolve
  * `cloudflare:workers` scheme imports and dies with the opaque
  * `ERR_UNSUPPORTED_ESM_URL_SCHEME: Received protocol 'cloudflare:'`. Those
- * imports only exist in the Cloudflare Workers harness apps
- * (`apps/play-runner-workers/`, `apps/play-harness-worker/`) baked into
- * `esm_workers` artifacts. When the wrong artifact kind is targeted for a node
- * profile (e.g. the absurd/Daytona scheduler falling back to a verbatim stored
- * `esm_workers` bundle), this guard fires at the targeting/load seam with a
- * message that names the mismatch instead of surfacing the ESM scheme error.
+ * imports can remain in historical `esm_workers` artifacts. If one reaches an
+ * active launch seam, this guard names the mismatch instead of surfacing the
+ * opaque ESM scheme error.
  */
 
 /**
@@ -20,18 +17,17 @@ import type { PlayArtifactKind, PlayBundleArtifact } from './artifact-types';
  * `cjs_node20` (the only kind that existed before the workers split). Mirror the
  * default documented on `PlayBundleArtifact.artifactKind`.
  */
-export function artifactKindOf(artifact: PlayBundleArtifact): PlayArtifactKind {
-  return artifact.artifactKind ?? 'cjs_node20';
+export function artifactKindOf(artifact: PlayBundleArtifact): string {
+  const rawKind = (artifact as { artifactKind?: unknown }).artifactKind;
+  return typeof rawKind === 'string' && rawKind.trim() ? rawKind : 'cjs_node20';
 }
 
 /**
- * Detect `cloudflare:` scheme imports in bundled code. Matches both static
- * `import ... from 'cloudflare:workers'` and `require('cloudflare:...')` forms,
- * with single or double quotes. This is the exact shape the Node runner cannot
- * load.
+ * Detect `cloudflare:` scheme imports in bundled code. Matches static imports,
+ * dynamic imports, and require calls with single or double quotes.
  */
 const CLOUDFLARE_SCHEME_IMPORT =
-  /(?:\bfrom\s*|\bimport\s*|\brequire\s*\(\s*)['"]cloudflare:[^'"]*['"]/;
+  /(?:\bfrom\s*|\bimport\s*(?:\(\s*)?|\brequire\s*\(\s*)['"]cloudflare:[^'"]*['"]/;
 
 export function bundledCodeHasCloudflareSchemeImport(
   bundledCode: string,
@@ -41,7 +37,7 @@ export function bundledCodeHasCloudflareSchemeImport(
 
 export class PlayArtifactKindMismatchError extends Error {
   readonly expectedKind: PlayArtifactKind;
-  readonly actualKind: PlayArtifactKind;
+  readonly actualKind: string;
   readonly reason:
     | 'kind_mismatch'
     | 'code_format_mismatch'
@@ -49,7 +45,7 @@ export class PlayArtifactKindMismatchError extends Error {
 
   constructor(input: {
     expectedKind: PlayArtifactKind;
-    actualKind: PlayArtifactKind;
+    actualKind: string;
     reason:
       | 'kind_mismatch'
       | 'code_format_mismatch'
@@ -80,12 +76,6 @@ export function assertNodeRunnableArtifact(input: {
   context: string;
 }): void {
   const { artifact, expectedKind, context } = input;
-  if (expectedKind !== 'cjs_node20') {
-    // This helper only guards the node runner. A workers-edge target never
-    // reaches the Node/Daytona load path, so there is nothing to assert.
-    return;
-  }
-
   const actualKind = artifactKindOf(artifact);
   if (actualKind !== 'cjs_node20') {
     throw new PlayArtifactKindMismatchError({
@@ -93,12 +83,9 @@ export function assertNodeRunnableArtifact(input: {
       actualKind,
       reason: 'kind_mismatch',
       message:
-        `Node runner (${context}) received a "${actualKind}" play artifact but ` +
-        `requires "cjs_node20". An "esm_workers" bundle embeds the Cloudflare ` +
-        `Workers harness (cloudflare:workers imports) and cannot load under ` +
-        `Module._compile. Rebundle/republish the play for the node runner ` +
-        `(profile=absurd / backend=daytona|local_process) instead of serving ` +
-        `the stored workers artifact verbatim.`,
+        `Node runner (${context}) received unsupported play artifact kind ` +
+        `"${actualKind}"; only "cjs_node20" is executable. Rebuild and ` +
+        `republish the play with the current SDK.`,
     });
   }
 

package/dist/bundling-sources/shared_libs/plays/artifact-types.ts

@@ -23,16 +23,12 @@ export type PlayArtifactCompatibility = {
   runtimeBackend?: string | null;
 };
 
-/**
- * Identifies which runtime can consume this artifact:
- *   - cjs_node20: Daytona / local-process (Node.js)
- *   - esm_workers: Cloudflare Workers (V8 isolate)
- */
-export type PlayArtifactKind = 'cjs_node20' | 'esm_workers';
+/** The only executable Play artifact contract. */
+export type PlayArtifactKind = 'cjs_node20';
 
 export type PlayBundleArtifact = {
-  codeFormat: 'cjs_module' | 'esm_module';
-  /** Defaults to cjs_node20 when not present (legacy artifacts). */
+  codeFormat: 'cjs_module';
+  /** Defaults to cjs_node20 when not present on legacy Node artifacts. */
   artifactKind?: PlayArtifactKind;
   entryFile: string;
   virtualFilename: string;