deepline 0.1.119 → 0.1.121

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

@@ -0,0 +1,158 @@
+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/play-runtime/internal-step-ids.ts

@@ -0,0 +1,34 @@
+/**
+ * Internal Step Id Contract.
+ *
+ * Static analysis turns top-level play statements it cannot attribute to a
+ * structured step into `run_javascript` glue substeps whose alias is a
+ * machine-generated source line range (`lines_<startLine>_<endLine>`, built in
+ * `src/lib/plays/static-analysis.ts` → `createCodeStageForStatements`). The
+ * execution plan / runtime node ids namespace every substep by its type
+ * (`getStaticSubstepNodeId` in `src/lib/plays/step-progress.ts` and
+ * `apps/play-runner-workers/src/entry.ts`), so glue nodes are ALWAYS
+ * `run_javascript:<alias>` on the wire (ledger stepsById, snapshot
+ * nodeStates, `play.step.*` stream events).
+ *
+ * These nodes are internal bookkeeping, not user-level play steps: surfacing
+ * them produced the `step lines_687_687: completed` garbage in the CLI run
+ * summary (SDK 0.1.93 regression). This module is the single structural
+ * marker both the app package builder and the SDK CLI renderer use to keep
+ * them out of user-facing output. Do NOT re-implement this check with ad-hoc
+ * string matching elsewhere — import the predicate.
+ */
+
+/** Node-id namespace stamped on machine-generated glue-code substeps. */
+export const INTERNAL_GLUE_NODE_ID_PREFIX = 'run_javascript:';
+
+/**
+ * True when a ledger/snapshot/stream step id refers to an internal
+ * glue-code node rather than a user-level play step.
+ */
+export function isInternalGlueStepId(stepId: unknown): boolean {
+  return (
+    typeof stepId === 'string' &&
+    stepId.startsWith(INTERNAL_GLUE_NODE_ID_PREFIX)
+  );
+}

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

@@ -0,0 +1,34 @@
+import { createSecretRedactionContext } from './secret-redaction';
+
+export const MAX_LEDGER_RESULT_PAYLOAD_BYTES = 2_500_000;
+export const MAX_LEDGER_LOG_LINES_PER_EVENT = 500;
+export const MAX_LEDGER_LOG_LINE_LENGTH = 2_000;
+
+const ledgerIngressRedactor = createSecretRedactionContext();
+
+export function redactLedgerString(value: unknown): string | null {
+  if (typeof value !== 'string' || !value.trim()) return null;
+  return ledgerIngressRedactor.redactString(value.trim());
+}
+
+export function sanitizeLedgerPayload(value: unknown): unknown {
+  if (value === undefined) return undefined;
+  const serialized = JSON.stringify(value);
+  if (serialized && serialized.length > MAX_LEDGER_RESULT_PAYLOAD_BYTES) {
+    throw new Error('run event result payload is too large');
+  }
+  return ledgerIngressRedactor.redact(value);
+}
+
+export function sanitizeLedgerLogLines(value: unknown): string[] {
+  if (!Array.isArray(value)) return [];
+  return value
+    .filter((line): line is string => typeof line === 'string')
+    .slice(0, MAX_LEDGER_LOG_LINES_PER_EVENT)
+    .map((line) =>
+      ledgerIngressRedactor
+        .redactString(line.trim())
+        .slice(0, MAX_LEDGER_LOG_LINE_LENGTH),
+    )
+    .filter(Boolean);
+}

package/dist/bundling-sources/shared_libs/play-runtime/live-state-contract.ts

@@ -0,0 +1,50 @@
+export type PlayRunLiveStatus =
+  | 'queued'
+  | 'running'
+  | 'completed'
+  | 'failed'
+  | 'cancelled'
+  | 'terminated'
+  | 'timed_out'
+  | 'unknown';
+
+export type PlayVisualNodeStatus =
+  | 'idle'
+  | 'running'
+  | 'completed'
+  | 'failed'
+  | 'skipped';
+
+export type PlayStepLiveStatus = Exclude<PlayVisualNodeStatus, 'idle'>;
+
+export type PlayVisualNodeProgressSnapshot = {
+  completed?: number;
+  total?: number;
+  failed?: number;
+  message?: string;
+  updatedAt?: number | null;
+  startedAt?: number | null;
+  completedAt?: number | null;
+  artifactTableNamespace?: string | null;
+};
+
+export type PlayVisualNodeStateSnapshot = {
+  nodeId: string;
+  status: PlayVisualNodeStatus;
+  artifactTableNamespace?: string | null;
+  progress?: PlayVisualNodeProgressSnapshot | null;
+  startedAt?: number | null;
+  completedAt?: number | null;
+  updatedAt?: number | null;
+};
+
+export type PlayRunLiveSnapshot = {
+  runId: string;
+  status: PlayRunLiveStatus;
+  updatedAt: number | null;
+  logs: string[];
+  activeArtifactTableNamespace: string | null;
+  resultTableNamespace: string | null;
+  nodeStates: PlayVisualNodeStateSnapshot[];
+  activeNodeId: string | null;
+};

package/dist/bundling-sources/shared_libs/play-runtime/map-execution-frame.ts

@@ -0,0 +1,119 @@
+import type {
+  MapExecutionFrame,
+  MapExecutionScope,
+  PlayCheckpoint,
+  PlayExecutionEvent,
+} from './ctx-types';
+
+export function cloneMapFrame(frame: MapExecutionFrame): MapExecutionFrame {
+  return {
+    ...frame,
+    completedRowKeys: [...frame.completedRowKeys],
+    pendingRowKeys: [...frame.pendingRowKeys],
+  };
+}
+
+export class MapExecutionFrameStore {
+  constructor(
+    private readonly checkpoint: PlayCheckpoint,
+    private readonly emitExecutionEvent: (event: PlayExecutionEvent) => void,
+  ) {}
+
+  set(frame: MapExecutionFrame): void {
+    this.checkpoint.mapFrames = {
+      ...(this.checkpoint.mapFrames ?? {}),
+      [frame.mapInvocationId]: cloneMapFrame(frame),
+    };
+  }
+
+  start(input: {
+    scope: MapExecutionScope;
+    totalRows: number;
+    completedRowKeys: readonly string[];
+    pendingRowKeys: readonly string[];
+  }): void {
+    const now = Date.now();
+    this.set({
+      mapInvocationId: input.scope.mapInvocationId,
+      mapNodeId: input.scope.mapNodeId ?? null,
+      logicalNamespace: input.scope.logicalNamespace,
+      artifactTableNamespace: input.scope.artifactTableNamespace,
+      status: 'running',
+      totalRows: input.totalRows,
+      completedRowKeys: [...input.completedRowKeys],
+      pendingRowKeys: [...input.pendingRowKeys],
+      startedAt: now,
+      updatedAt: now,
+    });
+    this.emitExecutionEvent({
+      type: 'map.started',
+      mapInvocationId: input.scope.mapInvocationId,
+      mapNodeId: input.scope.mapNodeId ?? null,
+      logicalNamespace: input.scope.logicalNamespace,
+      artifactTableNamespace: input.scope.artifactTableNamespace,
+      totalRows: input.totalRows,
+      completedRows: input.completedRowKeys.length,
+      pendingRows: input.pendingRowKeys.length,
+      at: Date.now(),
+    });
+  }
+
+  updateProgress(input: {
+    scope: MapExecutionScope;
+    totalRows: number;
+    status?: MapExecutionFrame['status'];
+    completedRowKey?: string | null;
+    pendingRowKey?: string | null;
+    activeBoundaryId?: string | null;
+    emitEventType?: PlayExecutionEvent['type'];
+  }): void {
+    const existing =
+      this.checkpoint.mapFrames?.[input.scope.mapInvocationId] ?? null;
+    if (!existing) {
+      return;
+    }
+    const completedRowKeys = new Set(existing.completedRowKeys);
+    const pendingRowKeys = new Set(existing.pendingRowKeys);
+    const completedBefore = completedRowKeys.size;
+    if (input.completedRowKey?.trim()) {
+      const completedRowKey = input.completedRowKey.trim();
+      completedRowKeys.add(completedRowKey);
+      pendingRowKeys.delete(completedRowKey);
+    }
+    if (input.pendingRowKey?.trim()) {
+      pendingRowKeys.add(input.pendingRowKey.trim());
+    }
+    const nextFrame: MapExecutionFrame = {
+      ...existing,
+      status: input.status ?? existing.status,
+      completedRowKeys: [...completedRowKeys],
+      pendingRowKeys: [...pendingRowKeys],
+      ...(input.activeBoundaryId !== undefined
+        ? { activeBoundaryId: input.activeBoundaryId }
+        : {}),
+      updatedAt: Date.now(),
+    };
+    this.set(nextFrame);
+    const progressEventType =
+      input.emitEventType ??
+      (completedRowKeys.size > completedBefore ? 'map.progress' : null);
+    if (progressEventType) {
+      this.emitExecutionEvent({
+        type: progressEventType,
+        mapInvocationId: input.scope.mapInvocationId,
+        mapNodeId: input.scope.mapNodeId ?? null,
+        logicalNamespace: input.scope.logicalNamespace,
+        artifactTableNamespace: input.scope.artifactTableNamespace,
+        completedRows: nextFrame.completedRowKeys.length,
+        failedRows: Math.max(
+          0,
+          input.totalRows -
+            nextFrame.completedRowKeys.length -
+            nextFrame.pendingRowKeys.length,
+        ),
+        totalRows: input.totalRows,
+        at: Date.now(),
+      } as PlayExecutionEvent);
+    }
+  }
+}

package/dist/{repo → bundling-sources}/shared_libs/play-runtime/map-row-identity.ts

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