deepline 0.1.199 → 0.1.200

package/dist/bundling-sources/shared_libs/play-runtime/hatchet-cold-execution-diagnosis.ts

@@ -1,321 +0,0 @@
-import {
-  HATCHET_COLD_EXECUTION_PHASES,
-  HATCHET_COLD_EXECUTION_TARGET,
-  type HatchetColdExecutionPhaseId,
-  type HatchetColdExecutionPhaseSummary,
-} from './hatchet-cold-execution-target';
-
-export type HatchetColdExecutionPhaseSeverity =
-  | 'missing'
-  | 'ok'
-  | 'near_budget'
-  | 'over_budget';
-
-export type HatchetColdExecutionPhaseDiagnosis = {
-  id: HatchetColdExecutionPhaseId;
-  phase: string;
-  budgetMs: number;
-  p95: number | null;
-  overBudgetMs: number | null;
-  severity: HatchetColdExecutionPhaseSeverity;
-  ownerModule: string;
-  ownerFiles: readonly string[];
-  interpretation: string;
-  nextAction: string;
-};
-
-export type HatchetColdExecutionDiagnosis = {
-  ok: boolean;
-  targetName: string;
-  thresholdMs: number;
-  overallP95: number | null;
-  overallOverThresholdMs: number | null;
-  bottleneck: HatchetColdExecutionPhaseDiagnosis | null;
-  phases: HatchetColdExecutionPhaseDiagnosis[];
-  observations: string[];
-  nextActions: string[];
-  summary: string;
-};
-
-type DiagnoseInput = {
-  overallP95: number | null;
-  thresholdMs?: number;
-  phaseSummaries: readonly HatchetColdExecutionPhaseSummary[];
-};
-
-type PhaseOwnership = {
-  ownerModule: string;
-  ownerFiles: readonly string[];
-  interpretation: string;
-  nextAction: string;
-};
-
-const PHASE_OWNERSHIP: Record<HatchetColdExecutionPhaseId, PhaseOwnership> = {
-  submit: {
-    ownerModule: 'Play Run Launch Plan',
-    ownerFiles: [
-      'src/lib/plays/start-run.ts',
-      'src/lib/plays/launch/',
-      'scripts/check-hatchet-cold-execution-latency.ts',
-    ],
-    interpretation:
-      'Submit time is being spent before the worker can claim the run: app validation, authority minting, start-row persistence, scheduler-row creation, or Hatchet dispatch.',
-    nextAction:
-      'Inspect routeTimings plus schema_ready / scheduler_row_submitted / run_no_wait_done deltas, then move non-launch work out of the hot path or overlap insert and dispatch.',
-  },
-  hatchet_dispatch_claim: {
-    ownerModule: 'Play Scheduler Adapter',
-    ownerFiles: [
-      'src/lib/plays/scheduler-backends/hatchet-dispatch.ts',
-      'src/lib/plays/scheduler-backends/hatchet-runtime-worker.ts',
-      'deploy/fly/hatchet/',
-    ],
-    interpretation:
-      'Hatchet assignment or worker claim is slower than budget, so the run is waiting in orchestration before Daytona work begins.',
-    nextAction:
-      'Check Hatchet engine placement, worker replica health, worker slots, and dispatch mode before changing Daytona or payload transport.',
-  },
-  daytona_create: {
-    ownerModule: 'One-Shot Sandbox Runner',
-    ownerFiles: [
-      'apps/temporal-worker/src/runner-backends/backends/daytona.ts',
-      'apps/temporal-worker/src/runner-backends/backends/daytona-lifecycle.ts',
-    ],
-    interpretation:
-      'Fresh Daytona sandbox creation is consuming the cold-execution budget before runner files upload.',
-    nextAction:
-      'Compare default image versus configured snapshot startup, then verify create timing in Daytona lifecycle events before touching artifact upload.',
-  },
-  daytona_upload: {
-    ownerModule: 'Play Artifact Target',
-    ownerFiles: [
-      'apps/temporal-worker/src/runner-backends/backends/daytona-payload-transport.ts',
-      'shared_libs/plays/artifact-transport.ts',
-      'apps/play-runner/src/entry.ts',
-    ],
-    interpretation:
-      'Runner bundle, play artifact, config, or materialized-file staging is now the dominant transfer cost into the one-shot sandbox.',
-    nextAction:
-      'Measure uploaded bytes by label, then reduce runner/artifact/config bytes or move immutable runner material into the snapshot without changing the one-shot sandbox Interface.',
-  },
-  daytona_execute: {
-    ownerModule: 'One-Shot Sandbox Runner',
-    ownerFiles: [
-      'apps/temporal-worker/src/runner-backends/backends/daytona.ts',
-      'apps/play-runner/src/entry.ts',
-      'shared_libs/play-runtime/protocol.ts',
-    ],
-    interpretation:
-      'The sandbox command is slow after files are present, usually runner boot, artifact load/decode, module startup, or the hello-world execution path.',
-    nextAction:
-      'Inspect the captured runner output and runtimeTiming; shrink startup imports or shift decode/load work into upload/snapshot prep instead of adding pools.',
-  },
-  terminal_observation: {
-    ownerModule: 'Run Snapshot',
-    ownerFiles: [
-      'src/lib/plays/scheduler-backends/hatchet-completion-publisher.ts',
-      'src/lib/plays/scheduler-backends/postgres-progress.ts',
-      'convex/model/runLogStream.ts',
-    ],
-    interpretation:
-      'The worker has reached terminal state, but the customer-visible observer is seeing it late.',
-    nextAction:
-      'Check terminal write ordering, NOTIFY/direct observer connection, and polling fallback before changing execution or scheduler code.',
-  },
-};
-
-export function diagnoseHatchetColdExecution(
-  input: DiagnoseInput,
-): HatchetColdExecutionDiagnosis {
-  const thresholdMs =
-    input.thresholdMs ?? HATCHET_COLD_EXECUTION_TARGET.thresholdMs;
-  const summariesById = new Map(
-    input.phaseSummaries.map((summary) => [summary.id, summary]),
-  );
-  const phases = HATCHET_COLD_EXECUTION_PHASES.map((definition) => {
-    const summary = summariesById.get(definition.id);
-    const p95 = summary?.p95 ?? null;
-    const overBudgetMs =
-      p95 === null ? null : Math.max(0, p95 - definition.budgetMs);
-    const severity = phaseSeverity(p95, definition.budgetMs);
-    return {
-      id: definition.id,
-      phase: definition.phase,
-      budgetMs: definition.budgetMs,
-      p95,
-      overBudgetMs,
-      severity,
-      ...PHASE_OWNERSHIP[definition.id],
-    };
-  });
-
-  const overallOverThresholdMs =
-    input.overallP95 === null
-      ? null
-      : Math.max(0, input.overallP95 - thresholdMs);
-  const ok = input.overallP95 !== null && input.overallP95 <= thresholdMs;
-  const bottleneck = chooseBottleneck(phases);
-  const observations = buildObservations({
-    ok,
-    thresholdMs,
-    overallP95: input.overallP95,
-    overallOverThresholdMs,
-    phases,
-    bottleneck,
-  });
-  const nextActions = buildNextActions(bottleneck, phases);
-
-  return {
-    ok,
-    targetName: HATCHET_COLD_EXECUTION_TARGET.name,
-    thresholdMs,
-    overallP95: input.overallP95,
-    overallOverThresholdMs,
-    bottleneck,
-    phases,
-    observations,
-    nextActions,
-    summary: buildSummary({ ok, input, thresholdMs, bottleneck }),
-  };
-}
-
-export function formatHatchetColdExecutionDiagnosis(
-  diagnosis: HatchetColdExecutionDiagnosis,
-): string[] {
-  const lines = [
-    `[hatchet-cold-diagnosis] ${diagnosis.summary}`,
-    ...diagnosis.observations.map(
-      (observation) => `[hatchet-cold-diagnosis] ${observation}`,
-    ),
-  ];
-  if (diagnosis.bottleneck) {
-    lines.push(
-      `[hatchet-cold-diagnosis] owner=${diagnosis.bottleneck.ownerModule}`,
-      `[hatchet-cold-diagnosis] next=${diagnosis.bottleneck.nextAction}`,
-    );
-  }
-  return lines;
-}
-
-function phaseSeverity(
-  p95: number | null,
-  budgetMs: number,
-): HatchetColdExecutionPhaseSeverity {
-  if (p95 === null) return 'missing';
-  if (p95 > budgetMs) return 'over_budget';
-  if (p95 >= Math.floor(budgetMs * 0.85)) return 'near_budget';
-  return 'ok';
-}
-
-function chooseBottleneck(
-  phases: readonly HatchetColdExecutionPhaseDiagnosis[],
-): HatchetColdExecutionPhaseDiagnosis | null {
-  const overBudget = phases
-    .filter((phase) => phase.severity === 'over_budget')
-    .sort(
-      (left, right) =>
-        (right.overBudgetMs ?? 0) - (left.overBudgetMs ?? 0) ||
-        (right.p95 ?? 0) - (left.p95 ?? 0),
-    );
-  if (overBudget[0]) return overBudget[0];
-
-  const nearBudget = phases
-    .filter((phase) => phase.severity === 'near_budget')
-    .sort((left, right) => (right.p95 ?? 0) - (left.p95 ?? 0));
-  if (nearBudget[0]) return nearBudget[0];
-
-  const missing = phases.find((phase) => phase.severity === 'missing');
-  return missing ?? null;
-}
-
-function buildObservations(input: {
-  ok: boolean;
-  thresholdMs: number;
-  overallP95: number | null;
-  overallOverThresholdMs: number | null;
-  phases: readonly HatchetColdExecutionPhaseDiagnosis[];
-  bottleneck: HatchetColdExecutionPhaseDiagnosis | null;
-}): string[] {
-  const observations: string[] = [];
-  if (input.overallP95 === null) {
-    observations.push(
-      'No overall p95 was observed; latency target cannot be evaluated.',
-    );
-  } else if (input.ok) {
-    observations.push(
-      `Overall p95=${input.overallP95}ms is within threshold=${input.thresholdMs}ms.`,
-    );
-  } else {
-    observations.push(
-      `Overall p95=${input.overallP95}ms exceeds threshold=${input.thresholdMs}ms by ${input.overallOverThresholdMs}ms.`,
-    );
-  }
-
-  const overBudget = input.phases.filter(
-    (phase) => phase.severity === 'over_budget',
-  );
-  if (overBudget.length > 0) {
-    observations.push(
-      `Over-budget phases: ${overBudget
-        .map(
-          (phase) =>
-            `${phase.id} p95=${phase.p95}ms budget=${phase.budgetMs}ms (+${phase.overBudgetMs}ms)`,
-        )
-        .join(', ')}.`,
-    );
-  }
-
-  const missing = input.phases.filter((phase) => phase.severity === 'missing');
-  if (missing.length > 0) {
-    observations.push(
-      `Missing phase samples: ${missing.map((phase) => phase.id).join(', ')}.`,
-    );
-  }
-
-  if (input.bottleneck) {
-    observations.push(
-      `Primary bottleneck: ${input.bottleneck.id} owned by ${input.bottleneck.ownerModule}.`,
-    );
-  }
-  return observations;
-}
-
-function buildNextActions(
-  bottleneck: HatchetColdExecutionPhaseDiagnosis | null,
-  phases: readonly HatchetColdExecutionPhaseDiagnosis[],
-): string[] {
-  const actions: string[] = [];
-  if (bottleneck) {
-    actions.push(bottleneck.nextAction);
-  }
-  const missing = phases.find((phase) => phase.severity === 'missing');
-  if (missing) {
-    actions.push(
-      'Fix missing runtimeTiming/phase sample emission before trusting the latency diagnosis.',
-    );
-  }
-  if (actions.length === 0) {
-    actions.push(
-      'Keep the current phase budgets and rerun the same gate after the next runtime change.',
-    );
-  }
-  return [...new Set(actions)];
-}
-
-function buildSummary(input: {
-  ok: boolean;
-  input: DiagnoseInput;
-  thresholdMs: number;
-  bottleneck: HatchetColdExecutionPhaseDiagnosis | null;
-}): string {
-  if (input.input.overallP95 === null) {
-    return `${HATCHET_COLD_EXECUTION_TARGET.name}: inconclusive; no overall p95 sample.`;
-  }
-  if (input.ok) {
-    return `${HATCHET_COLD_EXECUTION_TARGET.name}: pass at p95=${input.input.overallP95}ms.`;
-  }
-  const owner = input.bottleneck
-    ? `; primary owner ${input.bottleneck.ownerModule}`
-    : '';
-  return `${HATCHET_COLD_EXECUTION_TARGET.name}: fail at p95=${input.input.overallP95}ms over threshold=${input.thresholdMs}ms${owner}.`;
-}

package/dist/bundling-sources/shared_libs/play-runtime/hatchet-cold-execution-target.ts

@@ -1,158 +0,0 @@
-export type HatchetColdExecutionPhaseId =
-  | 'submit'
-  | 'hatchet_dispatch_claim'
-  | 'daytona_create'
-  | 'daytona_upload'
-  | 'daytona_execute'
-  | 'terminal_observation';
-
-export type HatchetColdExecutionPhaseDefinition = {
-  id: HatchetColdExecutionPhaseId;
-  header: string;
-  phase: string;
-  budgetMs: number;
-  description: string;
-};
-
-export type HatchetColdExecutionSample = Partial<
-  Record<HatchetColdExecutionPhaseId, number | null>
->;
-
-export type HatchetColdExecutionPhaseSummary = {
-  phase: string;
-  id: HatchetColdExecutionPhaseId;
-  budgetMs: number;
-  p50: number | null;
-  p95: number | null;
-  max: number | null;
-  observed: number;
-  ok: boolean | null;
-};
-
-export const HATCHET_COLD_EXECUTION_TARGET = {
-  name: 'hatchet-cold-execution-under-2s',
-  description:
-    'Customer-observed cold execution from submit through terminal observation on the real Hatchet + Daytona path.',
-  thresholdMs: 2_000,
-  percentile: 95,
-} as const;
-
-export const HATCHET_COLD_EXECUTION_PHASES = [
-  {
-    id: 'submit',
-    header: 'hc_submit',
-    phase: 'hatchet_cold.submit',
-    budgetMs: 300,
-    description:
-      'Customer submit route response, including app validation, authority minting, scheduler row creation, and Hatchet dispatch.',
-  },
-  {
-    id: 'hatchet_dispatch_claim',
-    header: 'hc_hatchet',
-    phase: 'hatchet_cold.hatchet_dispatch_claim',
-    budgetMs: 250,
-    description:
-      'Hatchet dispatch and worker claim time from persisted scheduler row to claimed execution.',
-  },
-  {
-    id: 'daytona_create',
-    header: 'hc_create',
-    phase: 'hatchet_cold.daytona_create',
-    budgetMs: 300,
-    description: 'Fresh Daytona sandbox creation for the claimed run.',
-  },
-  {
-    id: 'daytona_upload',
-    header: 'hc_upload',
-    phase: 'hatchet_cold.daytona_upload',
-    budgetMs: 350,
-    description:
-      'Runner bundle, play artifact, config, and staged-file upload into the Daytona sandbox.',
-  },
-  {
-    id: 'daytona_execute',
-    header: 'hc_execute',
-    phase: 'hatchet_cold.daytona_execute',
-    budgetMs: 650,
-    description:
-      'Daytona command execution until the play runner returns its terminal result.',
-  },
-  {
-    id: 'terminal_observation',
-    header: 'hc_observe',
-    phase: 'hatchet_cold.terminal_observation',
-    budgetMs: 150,
-    description:
-      'Lag between scheduler terminal persistence and the customer-visible observer noticing terminal state.',
-  },
-] as const satisfies readonly HatchetColdExecutionPhaseDefinition[];
-
-export const HATCHET_COLD_EXECUTION_PHASE_DEFINITIONS =
-  HATCHET_COLD_EXECUTION_PHASES.map((definition) => ({
-    header: definition.header,
-    phase: definition.phase,
-    source: 'hatchet_cold',
-    description: `${definition.description} Budget: ${definition.budgetMs}ms.`,
-  }));
-
-export function validateHatchetColdExecutionTarget(): string[] {
-  const errors: string[] = [];
-  const phaseIds = new Set<string>();
-  const phaseNames = new Set<string>();
-  let budgetTotal = 0;
-  for (const phase of HATCHET_COLD_EXECUTION_PHASES) {
-    if (phaseIds.has(phase.id)) {
-      errors.push(`Duplicate phase id: ${phase.id}`);
-    }
-    phaseIds.add(phase.id);
-    if (phaseNames.has(phase.phase)) {
-      errors.push(`Duplicate phase name: ${phase.phase}`);
-    }
-    phaseNames.add(phase.phase);
-    if (!Number.isFinite(phase.budgetMs) || phase.budgetMs <= 0) {
-      errors.push(`Phase ${phase.id} must have a positive budget.`);
-    }
-    budgetTotal += phase.budgetMs;
-  }
-  if (budgetTotal !== HATCHET_COLD_EXECUTION_TARGET.thresholdMs) {
-    errors.push(
-      `Phase budgets sum to ${budgetTotal}ms, expected ${HATCHET_COLD_EXECUTION_TARGET.thresholdMs}ms.`,
-    );
-  }
-  return errors;
-}
-
-export function summarizeHatchetColdExecutionPhases(
-  samples: readonly HatchetColdExecutionSample[],
-): HatchetColdExecutionPhaseSummary[] {
-  return HATCHET_COLD_EXECUTION_PHASES.map((definition) => {
-    const values = samples
-      .map((sample) => sample[definition.id])
-      .filter(
-        (value): value is number =>
-          typeof value === 'number' && Number.isFinite(value),
-      )
-      .sort((left, right) => left - right);
-    const p50 = percentile(values, 50);
-    const p95 = percentile(values, HATCHET_COLD_EXECUTION_TARGET.percentile);
-    return {
-      phase: definition.phase,
-      id: definition.id,
-      budgetMs: definition.budgetMs,
-      p50,
-      p95,
-      max: values.at(-1) ?? null,
-      observed: values.length,
-      ok: p95 === null ? null : p95 <= definition.budgetMs,
-    };
-  });
-}
-
-function percentile(sortedValues: readonly number[], p: number): number | null {
-  if (sortedValues.length === 0) return null;
-  const index = Math.min(
-    sortedValues.length - 1,
-    Math.max(0, Math.ceil((p / 100) * sortedValues.length) - 1),
-  );
-  return sortedValues[index] ?? null;
-}

package/dist/bundling-sources/shared_libs/temporal/constants.ts

@@ -1,39 +0,0 @@
-/**
- * Shared Temporal execution constants.
- *
- * Keep values that both the API/auth surface and the worker need here so the
- * API never imports from worker-only modules.
- */
-
-/**
- * Local Temporal dev defaults.
- *
- * These match the host ports exposed by docker-compose.yml and the env files
- * used by the local dev flows (`.env.local`, `.env.worktree`).
- */
-export const LOCAL_TEMPORAL_FRONTEND_PORT = 17233;
-export const LOCAL_TEMPORAL_UI_PORT = 18233;
-export const LOCAL_TEMPORAL_NAMESPACE = 'default';
-export const LOCAL_TEMPORAL_ADDRESS = `127.0.0.1:${LOCAL_TEMPORAL_FRONTEND_PORT}`;
-export const LOCAL_TEMPORAL_UI_URL = `http://127.0.0.1:${LOCAL_TEMPORAL_UI_PORT}`;
-
-/** Maximum active user-code runtime for a standard play, in seconds. */
-export const STANDARD_PLAY_RUNTIME_LIMIT_SECONDS = 20 * 60; // 20 minutes
-export const STANDARD_PLAY_RUNTIME_LIMIT_LABEL = '20 minutes';
-
-/**
- * Activity timeout includes setup, cleanup, and billing headroom after the 20 minute
- * user-code runtime cap. Keep this higher than STANDARD_PLAY_RUNTIME_LIMIT_SECONDS.
- */
-export const PLAY_ACTIVITY_TIMEOUT_SECONDS = 30 * 60; // 30 minutes
-
-/** Heartbeat cadence for the long-running play execution activity. */
-export const PLAY_EXECUTE_ACTIVITY_HEARTBEAT_INTERVAL_SECONDS = 15;
-
-/**
- * TTL for workflow executor tokens, in seconds.
- * Matches the activity timeout so tokens expire when the activity would
- * time out anyway.
- */
-export const WORKFLOW_EXECUTOR_TOKEN_TTL_SECONDS =
-  PLAY_ACTIVITY_TIMEOUT_SECONDS;

package/dist/bundling-sources/shared_libs/temporal/preview-config.ts

@@ -1,150 +0,0 @@
-import { existsSync } from 'node:fs';
-import * as path from 'node:path';
-import * as dotenv from 'dotenv';
-import { LOCAL_TEMPORAL_ADDRESS, LOCAL_TEMPORAL_NAMESPACE } from './constants';
-
-export const PLAY_TASK_QUEUE = 'deepline-plays';
-// Internal process flag set by `bun run dev:v2 --preview`. Do not put this in
-// .env.local; the dev command owns the mode selection so local/preview runs are
-// obvious at the call site.
-export const DEEPLINE_V2_INFRA_MODE_ENV = 'DEEPLINE_V2_INFRA_MODE';
-export const PREVIEW_PLAYS_ENV_FILE = '.env.plays.preview';
-
-type TemporalTlsConfig = {
-  clientCertPair: {
-    crt: Uint8Array;
-    key: Uint8Array;
-  };
-};
-
-export type DeeplineTemporalConfig = {
-  address: string;
-  namespace: string;
-  taskQueue: string;
-  tls?: TemporalTlsConfig;
-  deployment: 'local' | 'preview';
-};
-
-let loadedPreviewEnv = false;
-
-function decodePemEnv(value: string): Uint8Array {
-  return Buffer.from(value.replace(/\\n/g, '\n'), 'utf-8');
-}
-
-export function isPreviewPlaysDeployment(): boolean {
-  const mode = process.env[DEEPLINE_V2_INFRA_MODE_ENV]?.trim().toLowerCase();
-  return mode === 'external' || mode === 'preview';
-}
-
-export function isCloudflarePlaysDeployment(): boolean {
-  const mode = process.env[DEEPLINE_V2_INFRA_MODE_ENV]?.trim().toLowerCase();
-  return mode === 'cloudflare';
-}
-
-/**
- * True when the play runtime callback baseUrl must be a public URL — i.e. when
- * the plays runner runs outside the local app process and can't reach
- * 127.0.0.1. Both `external` (Daytona) and `cloudflare` (Workers/DOs) need
- * this; only fully-local mode can keep baseUrl on localhost.
- */
-export function requiresPublicCallbackBaseUrl(): boolean {
-  return isPreviewPlaysDeployment() || isCloudflarePlaysDeployment();
-}
-
-export function loadPreviewPlaysEnv(cwd = process.cwd()): void {
-  if (loadedPreviewEnv || !isPreviewPlaysDeployment()) {
-    return;
-  }
-
-  const envPath = path.join(cwd, PREVIEW_PLAYS_ENV_FILE);
-  if (existsSync(envPath)) {
-    dotenv.config({ path: envPath, override: true });
-  }
-
-  loadedPreviewEnv = true;
-}
-
-function temporalTlsFromEnv(): TemporalTlsConfig | undefined {
-  const cert =
-    process.env.TEMPORAL_TLS_CERT_DATA ?? process.env.FAS_TEMPORAL_CERT_DATA;
-  const key =
-    process.env.TEMPORAL_TLS_KEY_DATA ?? process.env.FAS_TEMPORAL_KEY_DATA;
-
-  if (!cert && !key) {
-    return undefined;
-  }
-  if (!cert || !key) {
-    throw new Error(
-      'Temporal Cloud mTLS requires both TEMPORAL_TLS_CERT_DATA and TEMPORAL_TLS_KEY_DATA.',
-    );
-  }
-
-  return {
-    clientCertPair: {
-      crt: decodePemEnv(cert),
-      key: decodePemEnv(key),
-    },
-  };
-}
-
-function temporalAddressFromEnv(): string | undefined {
-  return (
-    process.env.TEMPORAL_ADDRESS?.trim() ||
-    process.env.FAS_TEMPORAL_ADDRESS?.trim() ||
-    undefined
-  );
-}
-
-function temporalNamespaceFromEnv(address: string): string | undefined {
-  const previewConfigured = process.env.FAS_TEMPORAL_NAMESPACE?.trim();
-  if (previewConfigured) {
-    return previewConfigured;
-  }
-
-  const host = address.split(':')[0] ?? '';
-  const temporalCloudNamespace = /^([^.]+\.[^.]+)\.tmprl\.cloud$/i.exec(host);
-  if (temporalCloudNamespace?.[1]) {
-    return temporalCloudNamespace[1];
-  }
-
-  const configured = process.env.TEMPORAL_NAMESPACE?.trim();
-  return configured || undefined;
-}
-
-export function getDeeplineTemporalConfig(options?: {
-  loadPreviewEnv?: boolean;
-}): DeeplineTemporalConfig {
-  if (options?.loadPreviewEnv !== false) {
-    loadPreviewPlaysEnv();
-  }
-
-  if (isPreviewPlaysDeployment()) {
-    const address = temporalAddressFromEnv();
-    const namespace = address ? temporalNamespaceFromEnv(address) : undefined;
-    if (!address) {
-      throw new Error(
-        'dev:v2 preview mode requires TEMPORAL_ADDRESS or FAS_TEMPORAL_ADDRESS.',
-      );
-    }
-    if (!namespace) {
-      throw new Error(
-        'dev:v2 preview mode requires TEMPORAL_NAMESPACE or FAS_TEMPORAL_NAMESPACE.',
-      );
-    }
-    return {
-      address,
-      namespace,
-      taskQueue: process.env.TEMPORAL_TASK_QUEUE?.trim() || PLAY_TASK_QUEUE,
-      tls: temporalTlsFromEnv(),
-      deployment: 'preview',
-    };
-  }
-
-  return {
-    address: process.env.TEMPORAL_ADDRESS ?? LOCAL_TEMPORAL_ADDRESS,
-    namespace: process.env.TEMPORAL_NAMESPACE ?? LOCAL_TEMPORAL_NAMESPACE,
-    taskQueue: process.env.TEMPORAL_TASK_QUEUE?.trim() || PLAY_TASK_QUEUE,
-    tls: temporalTlsFromEnv(),
-    deployment: 'local',
-  };
-}