deepline 0.3.45 → 0.3.46

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

@@ -16,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,
@@ -42,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;

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

@@ -10,18 +10,18 @@ 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';
@@ -29,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;

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

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,
+  };
+}

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

@@ -1,109 +1 @@
-export type PlaySandboxRuntimeLimits = {
-  timeoutSeconds: number;
-  memoryGiB: number;
-  cpu: number;
-  diskGiB: number;
-};
-
-export type PlaySandboxSize = 'standard';
-
-export const PLAY_SANDBOX_SIZE_LIMITS = {
-  standard: {
-    memoryGiB: 1,
-    cpu: 1,
-    diskGiB: 3,
-  },
-} as const satisfies Record<
-  PlaySandboxSize,
-  Omit<PlaySandboxRuntimeLimits, 'timeoutSeconds'>
->;
-
-export const STANDARD_PLAY_SANDBOX_RUNTIME_LIMITS: PlaySandboxRuntimeLimits = {
-  timeoutSeconds: 30 * 60,
-  ...PLAY_SANDBOX_SIZE_LIMITS.standard,
-};
-
-// Product-wide ceilings. Organisation entitlements may lower these, but a
-// customer-authored Play can never ask Daytona for an unbounded resource.
-export const MAX_PLAY_SANDBOX_RUNTIME_LIMITS: PlaySandboxRuntimeLimits = {
-  timeoutSeconds: 4 * 60 * 60,
-  memoryGiB: STANDARD_PLAY_SANDBOX_RUNTIME_LIMITS.memoryGiB,
-  cpu: STANDARD_PLAY_SANDBOX_RUNTIME_LIMITS.cpu,
-  diskGiB: STANDARD_PLAY_SANDBOX_RUNTIME_LIMITS.diskGiB,
-};
-
-export type PlaySandboxRuntimeDeclaration = {
-  timeout?: string;
-  size?: PlaySandboxSize;
-};
-
-function parseTimeout(value: string): number | null {
-  const match = /^(\d+)\s*([mh])$/i.exec(value.trim());
-  if (!match) return null;
-  const amount = Number(match[1]);
-  if (!Number.isSafeInteger(amount) || amount <= 0) return null;
-  return amount * (match[2].toLowerCase() === 'h' ? 3600 : 60);
-}
-
-export function validatePlaySandboxRuntimeLimits(
-  value: PlaySandboxRuntimeLimits,
-): PlaySandboxRuntimeLimits {
-  const base = STANDARD_PLAY_SANDBOX_RUNTIME_LIMITS;
-  for (const key of ['memoryGiB', 'cpu', 'diskGiB'] as const) {
-    if (value[key] !== base[key]) {
-      throw new Error(
-        `Unsupported runtime sandbox resources: ${key}=${value[key]}. ` +
-          `Use runtime.size with a Deepline prebuilt sandbox. Supported sizes: "standard" ` +
-          `(${base.cpu} CPU, ${base.memoryGiB}GiB memory, ${base.diskGiB}GiB disk).`,
-      );
-    }
-  }
-  if (
-    !Number.isSafeInteger(value.timeoutSeconds) ||
-    value.timeoutSeconds <= 0
-  ) {
-    throw new Error(
-      'Invalid runtime sandbox timeout. Use timeout like "90m" or "2h".',
-    );
-  }
-  if (value.timeoutSeconds > MAX_PLAY_SANDBOX_RUNTIME_LIMITS.timeoutSeconds) {
-    throw new Error(
-      `Requested runtime timeoutSeconds=${value.timeoutSeconds} exceeds this organisation's maximum ${MAX_PLAY_SANDBOX_RUNTIME_LIMITS.timeoutSeconds}.`,
-    );
-  }
-  return { ...value };
-}
-
-export function resolvePlaySandboxRuntimeLimits(
-  declaration: PlaySandboxRuntimeDeclaration | null | undefined,
-): PlaySandboxRuntimeLimits {
-  const base = STANDARD_PLAY_SANDBOX_RUNTIME_LIMITS;
-  if (!declaration) return { ...base };
-  const unsupportedProperties = Object.keys(declaration).filter(
-    (key) => key !== 'timeout' && key !== 'size',
-  );
-  if (unsupportedProperties.length > 0) {
-    throw new Error(
-      `Unsupported runtime sandbox option${unsupportedProperties.length === 1 ? '' : 's'}: ${unsupportedProperties.join(', ')}. ` +
-        'Use runtime.size with a Deepline prebuilt sandbox. Supported sizes: "standard".',
-    );
-  }
-  if (declaration.size !== undefined && declaration.size !== 'standard') {
-    throw new Error(
-      `Unsupported runtime sandbox size "${String(declaration.size)}". Supported sizes: "standard".`,
-    );
-  }
-  const timeoutSeconds = declaration.timeout
-    ? parseTimeout(declaration.timeout)
-    : base.timeoutSeconds;
-  if (timeoutSeconds === null) {
-    throw new Error(
-      'Invalid runtime sandbox timeout. Use timeout like "90m" or "2h".',
-    );
-  }
-  const size = declaration.size ?? 'standard';
-  return validatePlaySandboxRuntimeLimits({
-    timeoutSeconds,
-    ...PLAY_SANDBOX_SIZE_LIMITS[size],
-  });
-}
+export * from '../plays/sandbox-runtime-limits';

package/dist/bundling-sources/shared_libs/play-runtime/step-program-dataset-builder.ts

@@ -1,4 +1,4 @@
-import type { PreviousCell } from './cell-staleness';
+import type { PreviousCell } from '../plays/cell-staleness';
 
 export type StepProgramDatasetOptions = {
   runIf?: (

package/dist/bundling-sources/shared_libs/play-runtime/test-runtime-seams.ts

@@ -1,4 +1,4 @@
-import { getRuntimeEnv } from '../runtime-env';
+import { getRuntimeEnv } from './runtime-env';
 import type { PlayRunnerEvent } from './protocol';
 import {
   runtimeTestFaultDrills,

package/dist/bundling-sources/shared_libs/play-runtime/tool-execute-retry-policy.ts

@@ -3,7 +3,7 @@ import {
   normalizeToolHttpErrorMessage,
   type ToolHttpError,
 } from './tool-http-errors';
-import type { ToolExecutionErrorSchemaVersion } from '../tool-execution-error';
+import type { ToolExecutionErrorSchemaVersion } from '../plays/tool-execution-error';
 
 export const TOOL_EXECUTE_TRANSIENT_HTTP_MAX_ATTEMPTS = 2;
 // A provider may need to finish the original request before it can replay the

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

@@ -37,10 +37,9 @@ function trimmed(value: OptionalKey): string | null {
   return normalized ? normalized : null;
 }
 
-function optionalCacheKey(value: OptionalKey): Pick<
-  ToolResultExecutionMetadata,
-  'cacheKey'
-> {
+function optionalCacheKey(
+  value: OptionalKey,
+): Pick<ToolResultExecutionMetadata, 'cacheKey'> {
   const cacheKey = trimmed(value);
   return cacheKey ? { cacheKey } : {};
 }
@@ -97,7 +96,9 @@ export function toolExecutionMetadataForOutcome(
     case 'in_flight': {
       const receiptKey = trimmed(outcome.receiptKey);
       if (!receiptKey) {
-        throw new Error('In-flight durable tool results require a receipt key.');
+        throw new Error(
+          'In-flight durable tool results require a receipt key.',
+        );
       }
       return {
         idempotent: true,

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

@@ -9,7 +9,7 @@ import {
   normalizeToolExecutionOrigin,
   type ToolExecutionErrorSchemaVersion,
   type ToolExecutionErrorOptions,
-} from '../tool-execution-error';
+} from '../plays/tool-execution-error';
 
 const TOOL_HTTP_ERROR_BRAND = Symbol.for('deepline.tool-http-error.v1');