deepline 0.3.44 → 0.3.46

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

@@ -2,13 +2,13 @@ import { type Daytona } from '@daytonaio/sdk';
 import type {
   PlayRunnerExecutionConfig,
   PlayRunnerResult,
-} from '@shared_libs/play-runtime/protocol';
-import { isIsolatedRuntimeSchedulerSchema } from '@shared_libs/play-runtime/runtime-scheduler-topology';
-import { PLAY_RUNNER_TIMEOUT_SECONDS } from '@shared_libs/play-runtime/runtime-constants';
+} from '../../protocol';
+import { isIsolatedRuntimeSchedulerSchema } from '../../runtime-scheduler-topology';
+import { PLAY_RUNNER_TIMEOUT_SECONDS } from '../../runtime-constants';
 import {
   STANDARD_PLAY_SANDBOX_RUNTIME_LIMITS,
   validatePlaySandboxRuntimeLimits,
-} from '@shared_libs/play-runtime/sandbox-runtime-limits';
+} from '../../../plays/sandbox-runtime-limits';
 import type { PlayRunnerRuntimeLifecycleEvent } from '../types';
 import { DAYTONA_PLAY_RUNNER_LABEL_SOURCE } from './daytona-labels';
 

package/dist/bundling-sources/shared_libs/play-runtime/runner-backends/backends/daytona-modal-fallback.ts

@@ -7,11 +7,11 @@ import type {
 import type {
   PlayRunnerExecutionConfig,
   PlayRunnerResult,
-} from '@shared_libs/play-runtime/protocol';
+} from '../../protocol';
 import { daytonaPlayRunnerBackend } from './daytona';
 import { DaytonaSandboxAcquisitionUnavailableError } from './daytona-lifecycle';
 import { modalPlayRunnerBackend } from './modal';
-import { isPlayRunRecoveryError } from '@shared_libs/play-runtime/play-run-recovery-policy';
+import { isPlayRunRecoveryError } from '../../play-run-recovery-policy';
 import {
   canTransitionRuntimeSandboxPlacement,
   isRuntimeSandboxCanaryProduction,
@@ -23,7 +23,7 @@ import {
   type RuntimeSandboxPlacementFailureReason,
   type RuntimeSandboxPlacementPolicy,
   type RuntimeSandboxProvider,
-} from '@shared_libs/play-runtime/runtime-sandbox-placement-policy';
+} from '../../runtime-sandbox-placement-policy';
 
 type DaytonaFallbackPreparedExecution = PlayRunnerPreparedExecution & {
   kind: 'runtime_sandbox_placement';

package/dist/bundling-sources/shared_libs/play-runtime/runner-backends/backends/daytona-payload-transport.ts

@@ -4,33 +4,33 @@ import { gzipSync } from 'node:zlib';
 import {
   RUNNER_TERMINAL_CHECKPOINT_DISPOSITION,
   type PlayRunnerExecutionConfig,
-} from '@shared_libs/play-runtime/protocol';
+} from '../../protocol';
 import {
   PLAY_RUNTIME_CONTRACT,
   PLAY_RUNTIME_CONTRACT_HEADER,
-} from '@shared_libs/play-runtime/runtime-contract';
+} from '../../runtime-contract';
 import {
   PLAY_RUNNER_TERMINAL_GRACE_SECONDS,
   PLAY_RUNNER_STARTUP_GRACE_SECONDS,
   STANDARD_PLAY_RUNTIME_LIMIT_SECONDS,
-} from '@shared_libs/play-runtime/runtime-constants';
+} from '../../runtime-constants';
 import {
   RUNTIME_RELIABILITY_ENV,
   RUNTIME_RELIABILITY_SEV_OVERRIDE_ENV,
-} from '@shared_libs/play-runtime/runtime-reliability-policy';
+} from '../../runtime-reliability-policy';
 import {
   STANDARD_PLAY_SANDBOX_RUNTIME_LIMITS,
   validatePlaySandboxRuntimeLimits,
-} from '@shared_libs/play-runtime/sandbox-runtime-limits';
+} from '../../../plays/sandbox-runtime-limits';
 import {
   RUNNER_POST_TERMINAL_DIAGNOSTIC_MAX_BYTES,
   RUNNER_TERMINAL_PUSH_MAX_BODY_BYTES,
-} from '@shared_libs/play-runtime/output-size-limits';
+} from '../../output-size-limits';
 import {
   RUNTIME_SANDBOX_KILLED_MESSAGE,
   RUNTIME_SANDBOX_OOM_MESSAGE,
-} from '@shared_libs/play-runtime/run-failure';
-import { compactPlayArtifactForRuntimeTransport } from '@shared_libs/plays/artifact-transport';
+} from '../../run-failure';
+import { compactPlayArtifactForRuntimeTransport } from '../../../plays/artifact-transport';
 import type {
   DaytonaExecutionContext,
   DaytonaSandbox,

package/dist/bundling-sources/shared_libs/play-runtime/runner-backends/backends/daytona-session-execution.ts

@@ -1,5 +1,5 @@
 import type { DaytonaSandbox } from './daytona-lifecycle';
-import { RUNTIME_RELIABILITY_POLICY } from '@shared_libs/play-runtime/runtime-reliability-policy';
+import { RUNTIME_RELIABILITY_POLICY } from '../../runtime-reliability-policy';
 
 export type DetachedDaytonaStartupDiagnostic = {
   schedulerReadinessObserved: boolean;
@@ -358,6 +358,14 @@ export function prepareDetachedDaytonaRunner(input: {
   sessionId: string;
   readiness: DetachedRunnerReadinessPort;
   cancellation?: Promise<never>;
+  /** Invoked immediately after Daytona accepts the detached command. */
+  onCommandAccepted?: (
+    state: Extract<DetachedDaytonaRunnerState, { phase: 'command_accepted' }>,
+  ) => Promise<void> | void;
+  /** Invoked after scheduler-owned liveness is confirmed. */
+  onReady?: (
+    state: Extract<DetachedDaytonaRunnerState, { phase: 'ready' }>,
+  ) => Promise<void> | void;
 }): DetachedDaytonaRunnerSupervisor {
   const cancellation = input.cancellation ?? new Promise<never>(() => {});
   const sessionCreation = input.sandbox.process
@@ -409,6 +417,7 @@ export function prepareDetachedDaytonaRunner(input: {
         cmdId,
         baselineHeartbeatAt: baseline.heartbeatAt,
       };
+      await input.onCommandAccepted?.(state);
       await Promise.race([
         confirmDetachedDaytonaRunnerReady({
           sandbox: input.sandbox,
@@ -422,6 +431,7 @@ export function prepareDetachedDaytonaRunner(input: {
         cancellation,
       ]);
       state = { ...state, phase: 'ready' };
+      await input.onReady?.(state);
       return state;
     },
   };

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

@@ -8,6 +8,7 @@ import type {
 import {
   isRuntimeSandboxCapacityLimitError,
   RuntimeResourceFenceLostError,
+  SandboxRunnerPreCodeDeferralError,
 } from '../types';
 import { buildPlayRunnerBundle } from '../bundle';
 import { findPlayRunnerResult, parsePlayRunnerEvents } from '../runner-events';
@@ -15,15 +16,15 @@ import type {
   PlayRunnerExecutionConfig,
   PlayRunnerRuntimeTiming,
   PlayRunnerResult,
-} from '@shared_libs/play-runtime/protocol';
+} from '../../protocol';
 import {
   PLAY_RUNNER_TERMINAL_GRACE_SECONDS,
   STANDARD_PLAY_RUNTIME_LIMIT_SECONDS,
-} from '@shared_libs/play-runtime/runtime-constants';
+} from '../../runtime-constants';
 import {
   loadDaytonaRequiredConfig,
   loadDaytonaRunnerPathsConfig,
-} from '@shared_libs/play-runtime/daytona-runtime-config';
+} from '../../daytona-runtime-config';
 import {
   DAYTONA_CANCELLED_ERROR,
   DaytonaSandboxAcquisitionUnavailableError,
@@ -41,7 +42,7 @@ import {
   DaytonaRunnerInitializationError,
   prepareDetachedDaytonaRunner,
 } from './daytona-session-execution';
-import { RUNTIME_RELIABILITY_POLICY } from '@shared_libs/play-runtime/runtime-reliability-policy';
+import { RUNTIME_RELIABILITY_POLICY } from '../../runtime-reliability-policy';
 
 const DAYTONA_COMMAND_RECOVERY_TIMEOUT_MS =
   RUNTIME_RELIABILITY_POLICY.sandbox.daytonaCommandRecoveryTimeoutMs;
@@ -1197,11 +1198,29 @@ export const daytonaPlayRunnerBackend: PlayRunnerBackend = {
           // Session allocation is independent of payload staging. Start it
           // now so Daytona control-plane latency overlaps compression/upload.
           const sessionId = `deepline-play-${randomUUID()}`;
+          const runnerAttempt = Math.max(
+            0,
+            Math.floor(config.context.runAttempt ?? 0),
+          );
           const detachedRunner = prepareDetachedDaytonaRunner({
             sandbox,
             sessionId,
             readiness: readRunnerReadiness,
             cancellation: cancellationPromise,
+            onCommandAccepted: async () => {
+              await callbacks?.onRunnerCommandAccepted?.({
+                provider: 'daytona',
+                sandboxId: sandbox.id,
+              });
+            },
+            onReady: async (ready) => {
+              await callbacks?.onDetachedRunnerReady?.({
+                provider: 'daytona',
+                sandboxId: sandbox.id,
+                boundaryId: `detached-runner:${push.runId}:${runnerAttempt}`,
+                baselineHeartbeatAt: ready.baselineHeartbeatAt,
+              });
+            },
           });
 
           const uploadStartedAt = Date.now();
@@ -1310,10 +1329,6 @@ export const daytonaPlayRunnerBackend: PlayRunnerBackend = {
             // classification below decide fresh-sandbox retry vs loud failure.
             throw error;
           }
-          const runnerAttempt = Math.max(
-            0,
-            Math.floor(config.context.runAttempt ?? 0),
-          );
           emitDaytonaStage(callbacks, config.context, 'execute:detached', {
             sandboxId: sandbox.id,
             sessionId: start.sessionId,
@@ -1435,6 +1450,9 @@ export const daytonaPlayRunnerBackend: PlayRunnerBackend = {
       if (isRuntimeSandboxCapacityLimitError(error)) {
         throw error;
       }
+      if (error instanceof SandboxRunnerPreCodeDeferralError) {
+        throw error;
+      }
       if (error instanceof DaytonaSandboxAcquisitionUnavailableError) {
         throw error;
       }

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

@@ -6,7 +6,7 @@ import type { SpawnOptionsWithoutStdio } from 'node:child_process';
 import {
   setSpanAttributes,
   withActiveSpan,
-} from '@shared_libs/observability/tracing';
+} from '../../../observability/tracing';
 import type { PlayRunnerBackend } from '../types';
 import { buildPlayRunnerBundle } from '../bundle';
 import {
@@ -14,25 +14,25 @@ import {
   parsePlayRunnerEventLine,
   parsePlayRunnerEvents,
 } from '../runner-events';
-import type { PlayRunnerExecutionConfig } from '@shared_libs/play-runtime/protocol';
-import { resolveDaytonaSandboxComputeItem } from '@shared_libs/play-runtime/worker-api-types';
+import type { PlayRunnerExecutionConfig } from '../../protocol';
+import { resolveDaytonaSandboxComputeItem } from '../../worker-api-types';
 import {
   recordComputeBillingItemViaAppRuntime,
   upsertComputeBillingSessionViaAppRuntime,
   type WorkerRuntimeApiContext,
-} from '@shared_libs/play-runtime/app-runtime-api';
+} from '../../app-runtime-api';
 import {
   PLAY_RUNNER_STARTUP_GRACE_SECONDS,
   PLAY_RUNNER_TERMINAL_GRACE_SECONDS,
-} from '@shared_libs/play-runtime/runtime-constants';
+} from '../../runtime-constants';
 import {
   STANDARD_PLAY_SANDBOX_RUNTIME_LIMITS,
   validatePlaySandboxRuntimeLimits,
-} from '@shared_libs/play-runtime/sandbox-runtime-limits';
+} from '../../../plays/sandbox-runtime-limits';
 import {
   runtimeLimitExceededCause,
   runtimeLimitExceededFailure,
-} from '@shared_libs/play-runtime/run-failure';
+} from '../../run-failure';
 import {
   buildDaytonaRuntimeWatchdogSource,
   DAYTONA_RUNTIME_WATCHDOG_EXIT_CODE,

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

@@ -3,24 +3,25 @@ import type { PlayRunnerBackend, PlayRunnerCallbacks } from '../types';
 import {
   isRuntimeSandboxCapacityLimitError,
   RuntimeResourceFenceLostError,
+  SandboxRunnerPreCodeDeferralError,
 } from '../types';
 import { buildPlayRunnerBundle } from '../bundle';
 import type {
   PlayRunnerExecutionConfig,
   PlayRunnerResult,
   PlayRunnerRuntimeTiming,
-} from '@shared_libs/play-runtime/protocol';
+} from '../../protocol';
 import {
   PLAY_RUNNER_STARTUP_GRACE_SECONDS,
   PLAY_RUNNER_TERMINAL_GRACE_SECONDS,
-} from '@shared_libs/play-runtime/runtime-constants';
+} from '../../runtime-constants';
 import {
   MODAL_SANDBOX_CPU_CORES,
   MODAL_SANDBOX_MEMORY_MIB,
   loadModalClientConfig,
   loadModalRequiredConfig,
-} from '@shared_libs/play-runtime/modal-runtime-config';
-import type { PlaySandboxRuntimeLimits } from '@shared_libs/play-runtime/sandbox-runtime-limits';
+} from '../../modal-runtime-config';
+import type { PlaySandboxRuntimeLimits } from '../../../plays/sandbox-runtime-limits';
 import { validateDaytonaExecutionContext } from './daytona-lifecycle';
 import { stageRunnerPayload } from './daytona-payload-transport';
 import { captureDetachedDaytonaRunnerReadinessBaseline } from './daytona-session-execution';
@@ -28,9 +29,9 @@ import {
   isPlayRunRecoveryError,
   recoveryForOpenModalCircuit,
   recoveryForModalSandboxCreateFailure,
-} from '@shared_libs/play-runtime/play-run-recovery-policy';
-import { shouldInjectModalSandboxCreateResourceExhausted } from '@shared_libs/play-runtime/test-runtime-seams';
-import { RUNTIME_RELIABILITY_POLICY } from '@shared_libs/play-runtime/runtime-reliability-policy';
+} from '../../play-run-recovery-policy';
+import { shouldInjectModalSandboxCreateResourceExhausted } from '../../test-runtime-seams';
+import { RUNTIME_RELIABILITY_POLICY } from '../../runtime-reliability-policy';
 
 const MODAL_RUNNER_READY_TIMEOUT_MS =
   RUNTIME_RELIABILITY_POLICY.sandbox.runnerReadyTimeoutMs;
@@ -618,6 +619,10 @@ export const modalPlayRunnerBackend: PlayRunnerBackend = {
           cancellationPromise,
         ]);
         runtimeTiming.modalExecuteMs = Date.now() - executeStartedAt;
+        await callbacks?.onRunnerCommandAccepted?.({
+          provider: 'modal',
+          sandboxId: sandbox.sandboxId,
+        });
         // A readiness observation after the command is accepted is ambiguous:
         // the detached runner may already have received its durable park and
         // started customer code while this worker cannot read the scheduler.
@@ -627,16 +632,22 @@ export const modalPlayRunnerBackend: PlayRunnerBackend = {
           baselineHeartbeatAt,
           cancellation: cancellationPromise,
         });
+        const runnerAttempt = Math.max(
+          0,
+          Math.floor(config.context.runAttempt ?? 0),
+        );
+        await callbacks?.onDetachedRunnerReady?.({
+          provider: 'modal',
+          sandboxId: sandbox.sandboxId,
+          boundaryId: `detached-runner:${push.runId}:${runnerAttempt}`,
+          baselineHeartbeatAt,
+        });
         if (callbacks?.cancellationSignal?.aborted) {
           throw new Error('Modal play runner cancelled');
         }
 
         detached = true;
         sandbox.detach();
-        const runnerAttempt = Math.max(
-          0,
-          Math.floor(config.context.runAttempt ?? 0),
-        );
         emitModalStage(config.context, 'execute:detached', {
           sandboxId: sandbox.sandboxId,
           runnerAttempt,
@@ -716,6 +727,7 @@ export const modalPlayRunnerBackend: PlayRunnerBackend = {
       if (
         error === runtimeResourceRegistrationError ||
         error instanceof RuntimeResourceFenceLostError ||
+        error instanceof SandboxRunnerPreCodeDeferralError ||
         isRuntimeSandboxCapacityLimitError(error) ||
         isPlayRunRecoveryError(error)
       ) {

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

@@ -5,7 +5,7 @@ import { createRequire } from 'node:module';
 import {
   setSpanAttributes,
   withActiveSpan,
-} from '@shared_libs/observability/tracing';
+} from '../../observability/tracing';
 
 const runtimeRequire = createRequire(import.meta.url);
 const esbuild = runtimeRequire('esbuild') as {
@@ -71,6 +71,12 @@ async function listFiles(dir: string): Promise<string[]> {
   const entries = await readdir(dir, { withFileTypes: true });
   const values = await Promise.all(
     entries.map(async (entry) => {
+      if (
+        entry.isDirectory() &&
+        ['.turbo', 'dist', 'node_modules'].includes(entry.name)
+      ) {
+        return [];
+      }
       const fullPath = join(dir, entry.name);
       if (entry.isDirectory()) {
         return await listFiles(fullPath);
@@ -112,7 +118,7 @@ function createRunnerBoundaryPlugin(projectRoot: string) {
 
   function rejectionForImport(args: EsbuildOnResolveArgs): string | null {
     if (args.path.startsWith('@/') || args.path.startsWith('@convex/')) {
-      return `play-runner bundle cannot import ${args.path}; move shared runtime code to shared_libs or call the app over the runtime API`;
+      return `play-runner bundle cannot import ${args.path}; move shared runtime code to a package or call the app over the runtime API`;
     }
 
     if (!args.path.startsWith('.') || !args.importer) {
@@ -195,6 +201,11 @@ export async function buildPlayRunnerBundle(): Promise<string> {
 
       const sourceRoots = [
         resolve(process.cwd(), 'apps', 'play-runner', 'src'),
+        resolve(process.cwd(), 'packages', 'observability'),
+        resolve(process.cwd(), 'packages', 'play-data-plane'),
+        resolve(process.cwd(), 'packages', 'play-runtime'),
+        resolve(process.cwd(), 'packages', 'plays'),
+        resolve(process.cwd(), 'packages', 'security'),
         resolve(process.cwd(), 'shared_libs'),
       ];
       const sourceHash = await hashRunnerSources(sourceRoots);

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

@@ -13,13 +13,13 @@ import {
   PLAY_RUNTIME_BACKENDS,
   normalizePlayRuntimeBackend,
   type PlayRuntimeBackendId,
-} from '@shared_libs/play-runtime/backend';
+} from '../backend';
 import {
   isRuntimeSandboxCanaryProduction,
   RUNTIME_SANDBOX_PLACEMENT_POLICIES,
   runtimeSandboxPlacementPolicyForBackend,
   type RuntimeSandboxPlacementPolicyId,
-} from '@shared_libs/play-runtime/runtime-sandbox-placement-policy';
+} from '../runtime-sandbox-placement-policy';
 
 export function resolveRuntimeSandboxPlacementBackend(
   policyId: RuntimeSandboxPlacementPolicyId | string,

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

@@ -1,7 +1,7 @@
 import type {
   PlayRunnerEvent,
   PlayRunnerResult,
-} from '@shared_libs/play-runtime/protocol';
+} from '../protocol';
 
 export function parsePlayRunnerEvents(stdout: string): PlayRunnerEvent[] {
   return stdout

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

@@ -6,7 +6,7 @@ import {
   deleteModalSandboxById,
   readDetachedModalRuntimeCompletion,
 } from './backends/modal';
-import type { DetachedRunnerSuspension } from '@shared_libs/play-runtime/suspension';
+import type { DetachedRunnerSuspension } from '../suspension';
 
 export type RuntimeSandboxProviderId = 'daytona' | 'modal';
 

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

@@ -2,12 +2,12 @@ import type {
   PlayCheckpoint,
   PlayExecutionEvent,
   PlayRowUpdate,
-} from '@shared_libs/play-runtime/ctx-types';
+} from '../ctx-types';
 import type {
   PlayRunnerExecutionConfig,
   PlayRunnerLogEvent,
   PlayRunnerResult,
-} from '@shared_libs/play-runtime/protocol';
+} from '../protocol';
 
 export type PlayRunnerRuntimeResource = {
   kind: 'daytona_sandbox' | 'modal_sandbox';
@@ -79,6 +79,26 @@ export type PlayRunnerRuntimeLifecycleEvent = {
   errorClass?: 'timeout' | 'capacity' | 'rate_limit' | 'other';
 };
 
+/**
+ * The provider has accepted the detached runner command. This is deliberately
+ * smaller than a runner payload: the scheduler needs only the physical
+ * resource identity to cross the no-replay boundary.
+ */
+export type PlayRunnerCommandAcceptance = {
+  provider: 'daytona' | 'modal';
+  sandboxId: string;
+};
+
+/**
+ * Scheduler-owned liveness was observed after a detached command was
+ * accepted. A backend must emit this only immediately before it returns a
+ * detached suspension.
+ */
+export type PlayRunnerDetachedRunnerReady = PlayRunnerCommandAcceptance & {
+  boundaryId: string;
+  baselineHeartbeatAt: string | null;
+};
+
 export class RuntimeResourceFenceLostError extends Error {
   constructor(message: string) {
     super(message);
@@ -94,6 +114,27 @@ export class RuntimeResourceFenceLostError extends Error {
 export const RUNTIME_SANDBOX_CAPACITY_LIMIT_ERROR_NAME =
   'RuntimeSandboxCapacityLimitError';
 
+/**
+ * A scheduler admission decision reached the legacy runner protocol before a
+ * provider create. Backends rethrow it verbatim so the Sandbox Runs Adapter can
+ * preserve a retry-safe `pre_code_deferred` outcome instead of manufacturing a
+ * runner failure.
+ */
+export class SandboxRunnerPreCodeDeferralError extends Error {
+  constructor(
+    readonly reason:
+      | 'capacity'
+      | 'provider_unavailable'
+      | 'rate_limited'
+      | 'startup_timeout',
+  ) {
+    super(
+      `Sandbox Runs deferred fresh execution before provider create: ${reason}.`,
+    );
+    this.name = 'SandboxRunnerPreCodeDeferralError';
+  }
+}
+
 export function isRuntimeSandboxCapacityLimitError(
   error: unknown,
 ): error is Error {
@@ -155,6 +196,21 @@ export interface PlayRunnerCallbacks {
   onRuntimeLifecycleEvent?: (
     event: PlayRunnerRuntimeLifecycleEvent,
   ) => Promise<void>;
+  /**
+   * Marks the command acceptance no-replay boundary. This is separate from a
+   * resource acquisition because a recorded sandbox can still fail staging
+   * before customer code is accepted.
+   */
+  onRunnerCommandAccepted?: (
+    acceptance: PlayRunnerCommandAcceptance,
+  ) => void | Promise<void>;
+  /**
+   * Marks the scheduler-owned readiness that makes a detached suspension safe
+   * to park. It is never a provider heartbeat or a runner payload callback.
+   */
+  onDetachedRunnerReady?: (
+    readiness: PlayRunnerDetachedRunnerReady,
+  ) => void | Promise<void>;
   /**
    * Scheduler-owned readiness read for a detached runner attempt. Daytona uses
    * this direct control-plane port before parking; it is never serialized into

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

@@ -4,7 +4,7 @@ import type { PlayRowUpdate } from './ctx-types';
 import type { PlaySheetContract } from '../plays/static-pipeline';
 import type { PlayRunLedgerEvent } from './run-ledger';
 import type { WorkReceiptFailureKind } from './work-receipts';
-import type { ToolExecutionFailureV1 } from '../tool-execution-error';
+import type { ToolExecutionFailureV1 } from '../plays/tool-execution-error';
 import type { DocflowObservationUpsert } from './docflow-observation';
 
 export type RuntimeAppendRunEventsAction = {

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

@@ -8,7 +8,10 @@ import {
   type RuntimePoolClient,
   type RuntimeOneShotQueryClient,
 } from './runtime-pg-driver';
-import { createDeferredPlayDataset, type PlayDataset } from '../plays/dataset';
+import {
+  createDeferredPlayDataset,
+  type PlayDataset,
+} from '../plays/dataset';
 import type {
   PlayStaticPipeline,
   PlaySheetContract,
@@ -59,7 +62,7 @@ import {
   workReceiptFailureKindFromCode,
   type WorkReceiptFailureKind,
 } from './work-receipts';
-import type { ToolExecutionFailureV1 } from '../tool-execution-error';
+import type { ToolExecutionFailureV1 } from '../plays/tool-execution-error';
 import {
   sanitizePostgresJsonValue,
   stringifyPostgresJson,
@@ -92,7 +95,7 @@ import {
   mapRowOutcomeRuntimeFields,
   resolveMapRowOutcomeKey,
 } from './map-row-outcome';
-import { DEEPLINE_CELL_META_FIELD } from './cell-staleness';
+import { DEEPLINE_CELL_META_FIELD } from '../plays/cell-staleness';
 import {
   PLAY_RUNTIME_CONTRACT,
   PLAY_RUNTIME_CONTRACT_HEADER,

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

@@ -1,4 +1,4 @@
-import { MAX_PLAY_SANDBOX_RUNTIME_LIMITS } from './sandbox-runtime-limits';
+import { MAX_PLAY_SANDBOX_RUNTIME_LIMITS } from '../plays/sandbox-runtime-limits';
 
 /** Maximum active user-code runtime for a standard play, in seconds. */
 export const STANDARD_PLAY_RUNTIME_LIMIT_SECONDS = 30 * 60;

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

@@ -1,2 +1 @@
-export const DISALLOWED_RUN_JAVASCRIPT_TOOL_MESSAGE =
-  'No run_javascript tool in plays. Just write regular code.';
+export * from '../plays/runtime-constraints';

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

@@ -0,0 +1,55 @@
+export type DeeplineRuntimeEnv = 'prod' | 'dev';
+
+function normalizeEnvToken(value: string): DeeplineRuntimeEnv | null {
+  const token = value.trim().toLowerCase();
+  if (!token) return null;
+
+  if (
+    token === 'prod' ||
+    token === 'production' ||
+    token === 'live' ||
+    token.startsWith('prod-')
+  ) {
+    return 'prod';
+  }
+
+  if (
+    token === 'dev' ||
+    token === 'development' ||
+    token === 'local' ||
+    token === 'preview' ||
+    token === 'staging' ||
+    token === 'stage' ||
+    token === 'test' ||
+    token.startsWith('dev-')
+  ) {
+    return 'dev';
+  }
+
+  return null;
+}
+
+export function getRuntimeEnv(): DeeplineRuntimeEnv {
+  const explicit = normalizeEnvToken(process.env.DEEPLINE_ENV ?? '');
+  if (explicit) return explicit;
+
+  const convexDeployment = String(process.env.CONVEX_DEPLOYMENT ?? '')
+    .trim()
+    .toLowerCase();
+  if (convexDeployment.startsWith('prod:')) return 'prod';
+  if (convexDeployment.startsWith('dev:')) return 'dev';
+
+  const vercelEnv = normalizeEnvToken(process.env.VERCEL_ENV ?? '');
+  if (vercelEnv) return vercelEnv;
+
+  return process.env.NODE_ENV === 'production' ? 'prod' : 'dev';
+}
+
+export function getRuntimeEnvInfo() {
+  return {
+    env: getRuntimeEnv(),
+    deepline_env: process.env.DEEPLINE_ENV ?? null,
+    convex_deployment: process.env.CONVEX_DEPLOYMENT ?? null,
+    node_env: process.env.NODE_ENV ?? null,
+  };
+}