deepline 0.1.12 → 0.1.20

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

@@ -1,114 +0,0 @@
-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);
-    if (input.completedRowKey?.trim()) {
-      completedRowKeys.add(input.completedRowKey.trim());
-      pendingRowKeys.delete(input.completedRowKey.trim());
-    }
-    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);
-    if (input.emitEventType) {
-      this.emitExecutionEvent({
-        type: input.emitEventType,
-        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/shared_libs/play-runtime/map-row-identity.ts

@@ -1,158 +0,0 @@
-import {
-  derivePlayRowIdentity,
-  derivePlayRowIdentityFromKey,
-} from '@shared_libs/plays/row-identity';
-import type { MapExecutionScope } from './ctx-types';
-
-export type ExplicitMapKeyResolver = (
-  row: Record<string, unknown>,
-  index: number,
-) => string;
-
-export type ExplicitMapKeyInput =
-  | string
-  | readonly string[]
-  | ((row: Record<string, unknown>, index: number) => unknown);
-
-export function stripMapFieldOutputs(
-  row: Record<string, unknown>,
-  fieldNames: readonly string[],
-): Record<string, unknown> {
-  return Object.fromEntries(
-    Object.entries(row).filter(
-      ([fieldName]) => !fieldNames.includes(fieldName),
-    ),
-  );
-}
-
-export function createExplicitMapKeyResolver(input: {
-  mapNamespace: string;
-  fieldNames: readonly string[];
-  key: ExplicitMapKeyInput | null | undefined;
-}): ExplicitMapKeyResolver | null {
-  if (!input.key) {
-    return null;
-  }
-  const key = input.key;
-  return (row, index) => {
-    const stableRow = stripMapFieldOutputs(row, input.fieldNames);
-    let raw: unknown;
-    if (typeof key === 'function') {
-      raw = key(stableRow, index);
-    } else if (typeof key === 'string') {
-      raw = stableRow[key];
-    } else {
-      raw = key.map((fieldName) => stableRow[fieldName]);
-    }
-    if (raw === null || raw === undefined) {
-      throw new Error(
-        `ctx.map("${input.mapNamespace}") key function returned ${raw === null ? 'null' : 'undefined'} for row ${index}. ` +
-          'Use a non-empty stable input column (e.g. { key: "email" }) or return a non-empty string, number, or tuple.',
-      );
-    }
-    const asString = normalizeExplicitMapKey(raw);
-    if (!asString) {
-      throw new Error(
-        `ctx.map("${input.mapNamespace}") key function returned an empty value for row ${index}. ` +
-          'Use non-empty stable input columns or return a non-empty string, number, or tuple.',
-      );
-    }
-    return asString;
-  };
-}
-
-function normalizeExplicitMapKey(value: unknown): string {
-  if (Array.isArray(value)) {
-    const parts = value.map((entry) => normalizeExplicitMapKeyPart(entry));
-    return parts.every(Boolean) ? JSON.stringify(parts) : '';
-  }
-  return normalizeExplicitMapKeyPart(value);
-}
-
-function normalizeExplicitMapKeyPart(value: unknown): string {
-  if (typeof value === 'number') {
-    return Number.isFinite(value) ? String(value) : '';
-  }
-  return String(value ?? '').trim();
-}
-
-export function assertUniqueExplicitMapKeys(input: {
-  mapNamespace: string;
-  rows: readonly Record<string, unknown>[];
-  resolver: ExplicitMapKeyResolver | null;
-}): void {
-  if (!input.resolver) {
-    return;
-  }
-  const seenKeys = new Map<string, number>();
-  for (let index = 0; index < input.rows.length; index += 1) {
-    const keyValue = input.resolver(input.rows[index]!, index);
-    const previousIndex = seenKeys.get(keyValue);
-    if (previousIndex !== undefined) {
-      throw new Error(
-        `ctx.map("${input.mapNamespace}") key function produced duplicate value "${keyValue}" for rows ${previousIndex} and ${index}. ` +
-          'Each row must produce a unique key. Combine columns (e.g. `${row.email}|${row.company}`) or pick a column that is unique per row.',
-      );
-    }
-    seenKeys.set(keyValue, index);
-  }
-}
-
-export function deriveMapRowIdentity(input: {
-  row: Record<string, unknown>;
-  index?: number;
-  artifactTableNamespace: string;
-  fieldNames?: readonly string[];
-  explicitKey?: ExplicitMapKeyResolver | null;
-}): string {
-  const stableRow = stripMapFieldOutputs(input.row, input.fieldNames ?? []);
-  return input.explicitKey
-    ? derivePlayRowIdentityFromKey(
-        input.explicitKey(stableRow, input.index ?? 0),
-        input.artifactTableNamespace,
-      )
-    : derivePlayRowIdentity(stableRow, input.artifactTableNamespace);
-}
-
-export class MapRowIdentity {
-  private nextInvocationIndex: number;
-
-  constructor(startInvocationIndex = 0) {
-    this.nextInvocationIndex = startInvocationIndex;
-  }
-
-  get invocationIndex(): number {
-    return this.nextInvocationIndex;
-  }
-
-  set invocationIndex(value: number) {
-    this.nextInvocationIndex = value;
-  }
-
-  createScope(input: {
-    logicalNamespace: string;
-    artifactTableNamespace: string;
-    mapNodeId?: string | null;
-    fieldNames?: readonly string[];
-    explicitKey?: ExplicitMapKeyResolver | null;
-  }): MapExecutionScope {
-    const mapInvocationId = `${input.logicalNamespace}:${this.nextInvocationIndex}`;
-    this.nextInvocationIndex += 1;
-    const explicitKey = input.explicitKey ?? null;
-    const fieldNames = input.fieldNames ?? [];
-    return {
-      mapInvocationId,
-      mapNodeId: input.mapNodeId ?? null,
-      logicalNamespace: input.logicalNamespace,
-      artifactTableNamespace: input.artifactTableNamespace,
-      rowIdentity: (row, index) =>
-        deriveMapRowIdentity({
-          row,
-          index,
-          artifactTableNamespace: input.artifactTableNamespace,
-          fieldNames,
-          explicitKey,
-        }),
-    };
-  }
-}

package/dist/repo/shared_libs/play-runtime/progress-emitter.ts

@@ -1,172 +0,0 @@
-import { sqlSafePlayColumnName } from '@shared_libs/plays/static-pipeline';
-import type {
-  InlineWaterfallSpec,
-  MapExecutionScope,
-  PlayExecutionEvent,
-  PlayRowUpdate,
-} from './ctx-types';
-
-type RowContextSnapshot = {
-  fieldName?: string;
-  mapScope?: MapExecutionScope;
-} | null;
-
-type CellStatus =
-  | 'queued'
-  | 'running'
-  | 'completed'
-  | 'failed'
-  | 'cached'
-  | 'missed'
-  | 'skipped';
-
-export class PlayProgressEmitter {
-  constructor(
-    private readonly onRowUpdate:
-      | ((update: PlayRowUpdate) => void | Promise<void>)
-      | undefined,
-    private readonly onExecutionEvent:
-      | ((event: PlayExecutionEvent) => void | Promise<void>)
-      | undefined,
-    private readonly getRowContext: () => RowContextSnapshot,
-    private readonly isInlineWaterfallToolStep: (
-      step: InlineWaterfallSpec['steps'][number],
-    ) => boolean,
-  ) {}
-
-  executionEvent(event: PlayExecutionEvent): void {
-    if (!this.onExecutionEvent) {
-      return;
-    }
-    void this.onExecutionEvent(event);
-  }
-
-  rowUpdate(
-    key: string | null,
-    tableNamespace: string | null,
-    update: Omit<PlayRowUpdate, 'key'>,
-  ): void {
-    const rowContext = this.getRowContext();
-    const rowScope = rowContext?.mapScope;
-    if (rowScope && key) {
-      this.executionEvent({
-        type: 'map.row.updated',
-        mapInvocationId: rowScope.mapInvocationId,
-        mapNodeId: rowScope.mapNodeId ?? null,
-        logicalNamespace: rowScope.logicalNamespace,
-        artifactTableNamespace: rowScope.artifactTableNamespace,
-        rowKey: key,
-        rowStatus: update.status,
-        fieldName: rowContext?.fieldName ?? null,
-        stage: update.stage ?? null,
-        provider: update.provider ?? null,
-        at: Date.now(),
-      });
-    }
-    if (!key || !this.onRowUpdate) {
-      return;
-    }
-    void this.onRowUpdate({
-      ...update,
-      key,
-      tableNamespace,
-    });
-  }
-
-  fieldMetaUpdate(input: {
-    rowId: number;
-    key: string | null;
-    tableNamespace: string | null;
-    fieldName?: string | null;
-    status: CellStatus;
-    rowStatus?: PlayRowUpdate['status'];
-    stage?: string | null;
-    provider?: string | null;
-    error?: string | null;
-    reused?: boolean;
-    dataPatch?: Record<string, unknown>;
-  }): void {
-    if (!input.fieldName) {
-      this.rowUpdate(input.key, input.tableNamespace, {
-        rowId: input.rowId,
-        status: input.rowStatus,
-        stage: input.stage ?? null,
-        provider: input.provider ?? null,
-        error: input.error ?? null,
-        dataPatch: input.dataPatch ?? {},
-      });
-      return;
-    }
-
-    this.rowUpdate(input.key, input.tableNamespace, {
-      rowId: input.rowId,
-      status: input.rowStatus,
-      stage: input.stage ?? null,
-      provider: input.provider ?? null,
-      error: input.error ?? null,
-      dataPatch: input.dataPatch ?? {},
-      cellMetaPatch: {
-        [input.fieldName]: {
-          status: input.status,
-          stage: input.stage ?? null,
-          provider: input.provider ?? null,
-          error: input.error ?? null,
-          ...(input.reused !== undefined ? { reused: input.reused } : {}),
-        },
-      },
-    });
-  }
-
-  cellUpdate(input: {
-    rowId: number;
-    key: string | null;
-    tableNamespace: string | null;
-    columnName: string;
-    status: CellStatus;
-    rowStatus?: PlayRowUpdate['status'];
-    stage?: string | null;
-    provider?: string | null;
-    error?: string | null;
-    value?: unknown;
-  }): void {
-    this.rowUpdate(input.key, input.tableNamespace, {
-      rowId: input.rowId,
-      status: input.rowStatus,
-      stage: input.stage ?? null,
-      provider: input.provider ?? null,
-      error: input.error ?? null,
-      dataPatch:
-        input.value === undefined ? {} : { [input.columnName]: input.value },
-      cellMetaPatch: {
-        [input.columnName]: {
-          status: input.status,
-          stage: input.stage ?? null,
-          provider: input.provider ?? null,
-          error: input.error ?? null,
-        },
-      },
-    });
-  }
-
-  queuedInlineWaterfallSteps(input: {
-    rowId: number;
-    key: string | null;
-    tableNamespace: string | null;
-    spec: InlineWaterfallSpec;
-  }): void {
-    for (const step of input.spec.steps) {
-      this.cellUpdate({
-        rowId: input.rowId,
-        key: input.key,
-        tableNamespace: input.tableNamespace,
-        columnName: sqlSafePlayColumnName(`${input.spec.id}.${step.id}`),
-        status: 'queued',
-        stage: step.id,
-        provider: this.isInlineWaterfallToolStep(step)
-          ? (step as Extract<InlineWaterfallSpec['steps'][number], { toolId: string }>).toolId
-          : 'code',
-        value: null,
-      });
-    }
-  }
-}

package/dist/repo/shared_libs/play-runtime/protocol.ts

@@ -1,121 +0,0 @@
-import type { PlayBundleArtifact } from '../plays/artifact-types';
-import type {
-  PlayCheckpoint,
-  PlayExecutionEvent,
-  PlayRowUpdate,
-  PlayStep,
-} from './ctx-types';
-import type { PlayExecutionSuspension } from './suspension';
-import type { PlayStaticPipeline } from '../plays/static-pipeline';
-import type { PlayLiveEventSource } from './live-events';
-import type { PreloadedRuntimeDbSession } from './db-session';
-
-export interface PlayRunnerContextConfig {
-  executorToken?: string;
-  baseUrl?: string;
-  orgId?: string;
-  workflowId?: string;
-  playId?: string;
-  runId?: string;
-  playName?: string;
-  userEmail?: string;
-  convexUrl?: string;
-  staticPipeline?: PlayStaticPipeline | null;
-  /**
-   * Short-lived scoped Postgres sessions minted by the worker before the runner
-   * starts. They are only an initial fast path: the runner still renews through
-   * the app runtime API when a session is absent, too close to expiry, or not an
-   * exact-enough match for the requested play/table/operation scope.
-   */
-  preloadedDbSessions?: PreloadedRuntimeDbSession[];
-}
-
-export interface PlayRunnerExecutionConfig {
-  artifact: PlayBundleArtifact;
-  input: Record<string, unknown>;
-  checkpoint?: PlayCheckpoint | null;
-  csvSourcePath?: string | null;
-  csvSourceUrl?: string | null;
-  csvSourceContentBase64?: string | null;
-  runtimeInputAlias?: string | null;
-  materializedFiles: Record<string, string>;
-  workspaceRoot: string;
-  context: PlayRunnerContextConfig;
-}
-
-export type PlayRunnerLogEvent = {
-  type: 'log';
-  at: string;
-  source: PlayLiveEventSource;
-  line: string;
-};
-
-export type PlayRunnerEvent =
-  | PlayRunnerLogEvent
-  | {
-      type: 'checkpoint';
-      checkpoint: PlayCheckpoint;
-    }
-  | {
-      type: 'row_update';
-      update: PlayRowUpdate;
-    }
-  | {
-      type: 'execution_event';
-      event: PlayExecutionEvent;
-    }
-  | {
-      type: 'result';
-      result: PlayRunnerResult;
-    };
-
-export type PlayRunnerDeferredRuntimeTask = {
-  kind: 'daytona_sandbox_cleanup';
-  sandboxId: string;
-  billingStartedAt: number;
-  cpu: number;
-  memoryGiB: number;
-  diskGiB: number;
-};
-
-export type PlayRunnerResult =
-  | {
-      status: 'completed';
-      output: unknown;
-      outputRowCount?: number;
-      logs: string[];
-      stats: Record<string, unknown>;
-      steps: PlayStep[];
-      checkpoint: PlayCheckpoint;
-      tableNamespace?: string | null;
-      totalRows?: number;
-      inserted?: number;
-      skipped?: number;
-      deferredRuntimeTasks?: PlayRunnerDeferredRuntimeTask[];
-    }
-  | {
-      status: 'suspended';
-      suspension: PlayExecutionSuspension;
-      logs: string[];
-      stats: Record<string, unknown>;
-      steps: PlayStep[];
-      checkpoint: PlayCheckpoint;
-      tableNamespace?: string | null;
-      totalRows?: number;
-      inserted?: number;
-      skipped?: number;
-      deferredRuntimeTasks?: PlayRunnerDeferredRuntimeTask[];
-    }
-  | {
-      status: 'failed';
-      error: string;
-      logs: string[];
-      stats: Record<string, unknown>;
-      steps: PlayStep[];
-      checkpoint?: PlayCheckpoint | null;
-      tableNamespace?: string | null;
-      totalRows?: number;
-      inserted?: number;
-      skipped?: number;
-      deferredRuntimeTasks?: PlayRunnerDeferredRuntimeTask[];
-    };

package/dist/repo/shared_libs/play-runtime/public-play-contract.ts

@@ -1,42 +0,0 @@
-export type PublicPlayRunStatus =
-  | 'queued'
-  | 'running'
-  | 'waiting'
-  | 'completed'
-  | 'failed'
-  | 'cancelled';
-
-export interface PublicPlayRunResult {
-  success: boolean;
-  runId: string;
-  result?: unknown;
-  logs: string[];
-  durationMs: number;
-  error?: string;
-}
-
-export interface PublicPlayProgressStatus {
-  status: string;
-  totalRows?: number;
-  logs: string[];
-  error?: string;
-}
-
-export interface PublicPlayWaitState {
-  kind: 'integration_event' | 'sleep';
-  boundaryId?: string;
-  eventKey?: string;
-  until?: number;
-}
-
-export interface PublicPlayStatus {
-  runId: string;
-  apiVersion?: number;
-  status: PublicPlayRunStatus;
-  error?: string;
-  progress?: PublicPlayProgressStatus;
-  result?: unknown;
-  resultView?: unknown;
-  contract?: Record<string, unknown> | null;
-  wait?: PublicPlayWaitState | null;
-}

package/dist/repo/shared_libs/play-runtime/result-normalization.ts

@@ -1,33 +0,0 @@
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return value != null && typeof value === 'object' && !Array.isArray(value);
-}
-
-/**
- * Normalize integration responses into the higher-level SDK/play shape.
- *
- * Examples:
- * - `{ data: {...} }` => `{...}`
- * - `{ provider, operation, result: { data: {...}, meta } }`
- *   => `{ provider, operation, result: {...} }`
- */
-export function normalizePlayToolResult(value: unknown): unknown {
-  if (!isRecord(value)) {
-    return value;
-  }
-
-  if ('data' in value) {
-    return normalizePlayToolResult(value.data);
-  }
-
-  if ('result' in value) {
-    const normalizedResult = normalizePlayToolResult(value.result);
-    if (normalizedResult !== value.result) {
-      return {
-        ...value,
-        result: normalizedResult,
-      };
-    }
-  }
-
-  return value;
-}