deepline 0.1.12 → 0.1.19

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

@@ -1,2 +0,0 @@
-export const DISALLOWED_RUN_JAVASCRIPT_TOOL_MESSAGE =
-  'No run_javascript tool in plays. Just write regular code.';

package/dist/repo/shared_libs/play-runtime/runtime-pg-driver-neon-serverless.ts

@@ -1,201 +0,0 @@
-/**
- * `@neondatabase/serverless` Pool factory. Installed at boot by the
- * workers_edge dynamic Worker harness. The serverless driver speaks the
- * same Postgres wire protocol as `pg` but uses Neon's WebSocket proxy
- * (or HTTP endpoint) so it works inside the workerd V8 isolate where raw
- * TCP is unavailable.
- *
- * ## Lazy loading (the actual implementation)
- *
- * `@neondatabase/serverless` is ~143 KB minified — a non-trivial fraction
- * of every per-graphHash play Worker bundle. The harness's
- * `installNeonServerlessRuntimePoolDriver()` fires unconditionally at
- * isolate startup, but the heavy module is loaded ON FIRST `pool.connect()`
- * via dynamic `import('@neondatabase/serverless')`. Plays that never open
- * a Postgres pool (csv-only, computation-only, tool-only plays) skip the
- * import entirely, even though the driver registration ran at boot.
- *
- * Concretely:
- *   - Bundle still contains the dynamic-import path → `@neondatabase/serverless`
- *     is still in the per-play bundle (esbuild emits it as a deferred chunk
- *     in `format: 'esm'`, but workerd inlines all chunks for a Worker —
- *     so the bytes are still in the worker's compiled code).
- *   - V8 PARSE / COMPILE for those bytes is also deferred until the first
- *     `import()` call resolves; modern V8 does parse-on-demand for ESM
- *     dynamic imports. So plays that never connect skip the parse cost.
- *   - Plays that DO connect pay the import cost once per isolate, then
- *     reuse the cached module + pool for the rest of the run.
- *
- * If you change this file, double-check by:
- *   1. Bundling a play that doesn't use `ctx.dataset` / postgres ops
- *      (e.g. tests/v2-plays/plays/03-tool-basic.play.ts).
- *   2. Confirm the resulting bundle still references
- *      `@neondatabase/serverless` (the dynamic import path is preserved
- *      as a string), but no top-level `Pool` symbol is constructed.
- *   3. Confirm that creating an actual pool via `createRuntimePool` in
- *      a test still resolves and returns a working client.
- *
- * Why we don't just `external: ['@neondatabase/serverless']` in
- * bundle-play-file.ts:
- *   The `@neondatabase/serverless` package isn't provided by the
- *   workerd runtime — marking it external would crash the Worker on
- *   first import lookup. The lazy dynamic import is the right pattern:
- *   esbuild bundles the module, but its CODE STARTUP COST (parse +
- *   compile) is paid only when the import resolves.
- */
-
-import {
-  registerRuntimePoolFactory,
-  type RuntimePool,
-  type RuntimePoolClient,
-} from './runtime-pg-driver';
-
-/**
- * Minimal local types for the Neon module's runtime surface.
- *
- * We INTENTIONALLY don't `import type { Pool, PoolClient } from
- * '@neondatabase/serverless'` here — that would force tsc to read the
- * package's full type tree on every typecheck, slowing the build, and
- * the package's overloaded `connect()` resolves through types in a way
- * that surfaces as `void` in some TS configurations.
- *
- * The minimal shape is just:
- *   - Pool ctor takes a config bag
- *   - Pool instance has connect() / end()
- *   - PoolClient instance has query() / release()
- *
- * If Neon ever changes this surface, the runtime cast will fail loudly
- * the first time a play tries to use Postgres — which is exactly when
- * we want to find out.
- */
-interface NeonPoolClient {
-  query<R = Record<string, unknown>>(
-    text: string,
-    params?: unknown[],
-  ): Promise<{ rows: R[] }>;
-  release(): void;
-}
-
-interface NeonPoolInstance {
-  connect(): Promise<NeonPoolClient>;
-  end(): Promise<void>;
-}
-
-interface NeonPoolConfig {
-  connectionString: string;
-  max?: number;
-  idleTimeoutMillis?: number;
-  connectionTimeoutMillis?: number;
-}
-
-interface NeonModule {
-  Pool: new (config: NeonPoolConfig) => NeonPoolInstance;
-}
-
-/**
- * Cached promise of the loaded Neon module. Once the first connect()
- * resolves, every subsequent connect on the same isolate hits this
- * cache instead of re-importing.
- *
- * We cache the PROMISE rather than the resolved module so concurrent
- * first-connect calls coalesce onto a single import — V8's module
- * loader is already idempotent for the same specifier, but caching at
- * this layer makes the contract obvious to readers.
- */
-let neonModulePromise: Promise<NeonModule> | null = null;
-function loadNeonModule(): Promise<NeonModule> {
-  if (!neonModulePromise) {
-    neonModulePromise = import('@neondatabase/serverless') as unknown as Promise<NeonModule>;
-  }
-  return neonModulePromise;
-}
-
-function wrapNeonClient(client: NeonPoolClient): RuntimePoolClient {
-  return {
-    query: <R extends Record<string, unknown> = Record<string, unknown>>(
-      text: string,
-      params?: unknown[],
-    ) =>
-      (client.query as unknown as (
-        t: string,
-        p?: unknown[],
-      ) => Promise<{ rows: R[] }>)(text, params),
-    release: () => {
-      client.release();
-    },
-  };
-}
-
-/**
- * Wrap a Neon `Pool` instance as our internal `RuntimePool` shape.
- * `connect()` and `end()` are async on both sides, so this is a thin
- * adapter — no logic, just type marshaling.
- */
-function wrapNeonPool(pool: NeonPoolInstance): RuntimePool {
-  return {
-    connect: async () =>
-      wrapNeonClient((await pool.connect()) as unknown as NeonPoolClient),
-    end: async () => {
-      await pool.end();
-    },
-  };
-}
-
-/**
- * Install the Neon-backed pool factory. Called once at Worker isolate
- * boot — `registerRuntimePoolFactory` is idempotent and throws if a
- * different factory was already registered (build-config bug).
- *
- * The factory itself is SYNCHRONOUS (returns a `RuntimePool`) but the
- * underlying Neon Pool is created LAZILY: we capture the connection
- * config in a closure and instantiate the real `Pool` on first
- * `connect()`. Until then, no `@neondatabase/serverless` runtime code
- * runs in the isolate — V8 doesn't parse the dynamic-imported chunk
- * until the import() resolves.
- */
-export function installNeonServerlessRuntimePoolDriver(): void {
-  registerRuntimePoolFactory((input) => {
-    // Captured lazily so a Pool is only constructed if the play actually
-    // connects. Most plays that don't touch Postgres directly never even
-    // reach this branch — the factory is registered but never invoked.
-    let lazyPool: NeonPoolInstance | null = null;
-
-    /**
-     * Resolve the lazy Pool, creating it on first call.
-     *
-     * Race safety: workerd executes within a single JS event loop, so
-     * two concurrent `connect()` calls on the SAME wrapper run their
-     * "lazyPool == null" checks in turn — the first creates the Pool,
-     * the second sees it. No locking needed.
-     *
-     * If pool creation fails (e.g. DNS, bad connection string), the
-     * error propagates out of connect() to the caller. We don't cache
-     * a failed pool so retries can succeed on transient failures.
-     */
-    async function ensurePool(): Promise<NeonPoolInstance> {
-      if (lazyPool) return lazyPool;
-      const neon = await loadNeonModule();
-      const pool = new neon.Pool({
-        connectionString: input.connectionString,
-        max: input.maxConnections ?? 4,
-        idleTimeoutMillis: input.idleTimeoutMs ?? 15_000,
-        connectionTimeoutMillis: input.connectTimeoutMs ?? 10_000,
-      });
-      lazyPool = pool;
-      return pool;
-    }
-
-    return {
-      connect: async () => {
-        const pool = await ensurePool();
-        return wrapNeonClient(await pool.connect());
-      },
-      end: async () => {
-        if (lazyPool) {
-          await lazyPool.end();
-          lazyPool = null;
-        }
-      },
-    };
-  });
-}

package/dist/repo/shared_libs/play-runtime/runtime-pg-driver-pg.ts

@@ -1,48 +0,0 @@
-/**
- * pg-backed Pool factory. Installed at boot by the Node-runtime
- * play-runner (Daytona/local). NOT used by the workers_edge harness — pg's
- * raw TCP socket usage is banned in workerd.
- */
-import { Pool, type PoolClient } from 'pg';
-import {
-  registerRuntimePoolFactory,
-  type RuntimePool,
-  type RuntimePoolClient,
-} from './runtime-pg-driver';
-
-function wrapPgClient(client: PoolClient): RuntimePoolClient {
-  return {
-    query: <R extends Record<string, unknown> = Record<string, unknown>>(
-      text: string,
-      params?: unknown[],
-    ) =>
-      (client.query as unknown as (
-        t: string,
-        p?: unknown[],
-      ) => Promise<{ rows: R[] }>)(text, params).then((result) => ({
-        rows: result.rows,
-      })),
-    release: () => {
-      client.release();
-    },
-  };
-}
-
-function wrapPgPool(pool: Pool): RuntimePool {
-  return {
-    connect: async () => wrapPgClient(await pool.connect()),
-    end: () => pool.end(),
-  };
-}
-
-export function installPgRuntimePoolDriver(): void {
-  registerRuntimePoolFactory((input) => {
-    const pool = new Pool({
-      connectionString: input.connectionString,
-      max: input.maxConnections ?? 4,
-      idleTimeoutMillis: input.idleTimeoutMs ?? 15_000,
-      connectionTimeoutMillis: input.connectTimeoutMs ?? 10_000,
-    });
-    return wrapPgPool(pool);
-  });
-}

package/dist/repo/shared_libs/play-runtime/runtime-pg-driver.ts

@@ -1,84 +0,0 @@
-/**
- * Driver-agnostic Postgres pool/client surface used by the runtime data plane.
- *
- * The runtime data plane (`runtime-api.ts` direct-Neon writes) needs to run in
- * two very different environments:
- *
- *   - Node (Daytona/local play-runner) — uses the `pg` library, raw TCP to Neon.
- *   - Cloudflare Workers (workers_edge harness) — `pg` cannot bundle (raw TCP
- *     is banned at workerd boundary), so we use `@neondatabase/serverless`
- *     which speaks the same Postgres wire protocol over a WebSocket proxy.
- *
- * Rather than `if-platform` branches inside runtime-api.ts, each runtime
- * registers its driver once at boot and the rest of the code uses the
- * abstract `RuntimePool` / `RuntimePoolClient` types. Both `pg` and
- * `@neondatabase/serverless` already expose the relevant subset of the
- * `pg` API surface (`pool.connect()` → `client.query() / .release()`), so
- * the wrappers are thin.
- */
-
-export interface RuntimePoolClient {
-  query<R extends Record<string, unknown> = Record<string, unknown>>(
-    text: string,
-    params?: unknown[],
-  ): Promise<{ rows: R[] }>;
-  release(): void;
-}
-
-export interface RuntimePool {
-  connect(): Promise<RuntimePoolClient>;
-  end(): Promise<void>;
-}
-
-export type RuntimePoolFactory = (input: {
-  connectionString: string;
-  /** Soft cap on simultaneous connections; defaults to 4. */
-  maxConnections?: number;
-  /** Idle timeout in ms before pool tears down a connection; defaults to 15000. */
-  idleTimeoutMs?: number;
-  /** Connect timeout in ms; defaults to 10000. */
-  connectTimeoutMs?: number;
-}) => RuntimePool;
-
-let registeredFactory: RuntimePoolFactory | null = null;
-
-/**
- * Install a Pool factory at process / Worker boot. Idempotent — calling twice
- * with different factories will throw to prevent silent driver swaps that
- * would otherwise drop in-flight pooled connections.
- */
-export function registerRuntimePoolFactory(factory: RuntimePoolFactory): void {
-  if (registeredFactory && registeredFactory !== factory) {
-    throw new Error(
-      'A different runtime Postgres pool factory is already registered. ' +
-        'This is a build-config bug — only one driver should be installed per process.',
-    );
-  }
-  registeredFactory = factory;
-}
-
-export function isRuntimePoolFactoryRegistered(): boolean {
-  return registeredFactory !== null;
-}
-
-export function createRuntimePool(input: {
-  connectionString: string;
-  maxConnections?: number;
-  idleTimeoutMs?: number;
-  connectTimeoutMs?: number;
-}): RuntimePool {
-  if (!registeredFactory) {
-    throw new Error(
-      'No runtime Postgres pool factory registered. Call ' +
-        'installPgRuntimePoolDriver() (Node) or ' +
-        'installNeonServerlessRuntimePoolDriver() (Workers) at boot before ' +
-        'using runtime-api Postgres helpers.',
-    );
-  }
-  return registeredFactory(input);
-}
-
-/** Test seam — clears the registered factory so a test can swap drivers. */
-export function __resetRuntimePoolFactoryForTests(): void {
-  registeredFactory = null;
-}

package/dist/repo/shared_libs/play-runtime/static-pipeline-types.ts

@@ -1,147 +0,0 @@
-export interface PlayStaticPipeline {
-  tableNamespace?: string;
-  inputFields?: string[];
-  csvArg?: string;
-  hasInlineData?: boolean;
-  csvDescription?: string;
-  mapDescription?: string;
-  fields: string[];
-  stages?: PlayStaticSubstep[];
-  substeps: PlayStaticSubstep[];
-  sheetContract?: PlaySheetContract | null;
-  sheetContractErrors?: string[];
-}
-
-export type PlaySheetColumnSource =
-  | 'input'
-  | 'mapField'
-  | 'waterfallStep'
-  | 'childPlayColumn';
-
-export interface PlaySheetColumnContract {
-  id: string;
-  sqlName: string;
-  source: PlaySheetColumnSource;
-  field?: string;
-  parentField?: string;
-  playId?: string;
-  waterfallId?: string;
-  outputField?: string;
-  outputSqlName?: string;
-  stepId?: string;
-  toolId?: string;
-}
-
-export interface PlaySheetContract {
-  tableNamespace: string;
-  columns: PlaySheetColumnContract[];
-}
-
-export interface PlayStaticSourceRange {
-  sourcePath?: string;
-  startLine: number;
-  endLine: number;
-  startColumn: number;
-  endColumn: number;
-}
-
-type PlayStaticSubstepMetadata = {
-  conditional?: boolean;
-};
-
-export type PlayStaticSubstep = PlayStaticSubstepMetadata &
-  (
-    | {
-        type: 'csv';
-        field: string;
-        path?: string;
-        description?: string;
-        sourceRange?: PlayStaticSourceRange;
-        callDepth?: number;
-        callPath?: string[];
-      }
-    | {
-        type: 'map';
-        field: string;
-        name?: string;
-        tableNamespace?: string;
-        inputFields?: string[];
-        outputFields?: string[];
-        waterfallIds?: string[];
-        sheetContract?: PlaySheetContract | null;
-        description?: string;
-        sourceRange?: PlayStaticSourceRange;
-        callDepth?: number;
-        callPath?: string[];
-      }
-    | {
-        type: 'tool';
-        toolId: string;
-        field: string;
-        description?: string;
-        inLoop?: boolean;
-        isEventWait?: boolean;
-        sourceRange?: PlayStaticSourceRange;
-        callDepth?: number;
-        callPath?: string[];
-      }
-    | {
-        type: 'waterfall';
-        tool?: string;
-        field: string;
-        inLoop?: boolean;
-        id?: string;
-        output?: string;
-        minResults?: number;
-        sourceText?: string;
-        steps?: Array<{
-          id: string;
-          kind?: 'tool' | 'code';
-          toolId?: string;
-          paramsSource?: string;
-        }>;
-        description?: string;
-        sourceRange?: PlayStaticSourceRange;
-        callDepth?: number;
-        callPath?: string[];
-      }
-    | {
-        type: 'step_suite';
-        field: string;
-        steps: PlayStaticSubstep[];
-        returnSource?: string;
-        description?: string;
-        sourceRange?: PlayStaticSourceRange;
-        callDepth?: number;
-        callPath?: string[];
-      }
-    | {
-        type: 'play_call';
-        playId: string;
-        field: string;
-        inLoop?: boolean;
-        pipeline?: PlayStaticPipeline | null;
-        cycleDetected?: boolean;
-        resolutionError?: string;
-        description?: string;
-        sourceRange?: PlayStaticSourceRange;
-        callDepth?: number;
-        callPath?: string[];
-      }
-    | {
-        type: 'run_javascript';
-        alias: string;
-        description?: string;
-        sourceRange?: PlayStaticSourceRange;
-        callDepth?: number;
-        callPath?: string[];
-      }
-    | {
-        type: 'code';
-        field: string;
-        description?: string;
-        sourceRange?: PlayStaticSourceRange;
-        callDepth?: number;
-        callPath?: string[];
-      }
-  );

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

@@ -1,68 +0,0 @@
-export type PlayExecutionSuspension =
-  | {
-      kind: 'sleep';
-      boundaryId: string;
-      delayMs: number;
-    }
-  | {
-      kind: 'integration_event';
-      boundaryId: string;
-      eventKey: string;
-      timeoutMs: number;
-    }
-  | {
-      kind: 'integration_event_batch';
-      boundaries: Array<{
-        boundaryId: string;
-        eventKey: string;
-        timeoutMs: number;
-      }>;
-    };
-
-export class PlayExecutionSuspendedError extends Error {
-  readonly suspension: PlayExecutionSuspension;
-
-  constructor(suspension: PlayExecutionSuspension) {
-    super(
-      suspension.kind === 'sleep'
-        ? `Play execution suspended for durable sleep (${suspension.delayMs}ms).`
-        : suspension.kind === 'integration_event_batch'
-          ? `Play execution suspended waiting for ${suspension.boundaries.length} integration events.`
-        : `Play execution suspended waiting for integration event ${JSON.stringify(suspension.eventKey)}.`,
-    );
-    this.name = 'PlayExecutionSuspendedError';
-    this.suspension = suspension;
-  }
-}
-
-export class PlayRowExecutionSuspendedError extends Error {
-  readonly boundary: {
-    boundaryId: string;
-    eventKey: string;
-    timeoutMs: number;
-  };
-
-  constructor(boundary: {
-    boundaryId: string;
-    eventKey: string;
-    timeoutMs: number;
-  }) {
-    super(
-      `Play row execution suspended waiting for integration event ${JSON.stringify(boundary.eventKey)}.`,
-    );
-    this.name = 'PlayRowExecutionSuspendedError';
-    this.boundary = boundary;
-  }
-}
-
-export function isPlayRowExecutionSuspendedError(
-  value: unknown,
-): value is PlayRowExecutionSuspendedError {
-  return value instanceof PlayRowExecutionSuspendedError;
-}
-
-export function isPlayExecutionSuspendedError(
-  value: unknown,
-): value is PlayExecutionSuspendedError {
-  return value instanceof PlayExecutionSuspendedError;
-}

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

@@ -1,31 +0,0 @@
-type SpanLike = {
-  setAttribute: (key: string, value: unknown) => void;
-};
-
-type SpanOptions = {
-  tracer?: string;
-  attributes?: Record<string, unknown>;
-};
-
-export function setSpanAttributes(
-  span: SpanLike | null | undefined,
-  attributes: Record<string, unknown>,
-): void {
-  for (const [key, value] of Object.entries(attributes)) {
-    span?.setAttribute?.(key, value);
-  }
-}
-
-export async function withActiveSpan<T>(
-  _name: string,
-  options: SpanOptions,
-  fn: (span: SpanLike) => Promise<T>,
-): Promise<T> {
-  const attributes = new Map<string, unknown>(Object.entries(options.attributes ?? {}));
-  const span: SpanLike = {
-    setAttribute(key, value) {
-      attributes.set(key, value);
-    },
-  };
-  return await fn(span);
-}

package/dist/repo/shared_libs/play-runtime/waterfall-replay.ts

@@ -1,75 +0,0 @@
-import type { BatchResult, PlayCheckpoint, WaterfallRequest } from './ctx-types';
-
-export class WaterfallReplayStore {
-  constructor(private readonly checkpoint: PlayCheckpoint) {}
-
-  checkpointKey(input: { rowId: number; rowKey?: string | null }): string {
-    return input.rowKey?.trim() || String(input.rowId);
-  }
-
-  getResolved(
-    queueKey: string,
-    input: {
-      rowId: number;
-      rowKey?: string | null;
-    },
-  ): { found: boolean; value: unknown } {
-    const resolved = this.checkpoint.resolvedWaterfalls[queueKey];
-    if (!resolved) {
-      return { found: false, value: undefined };
-    }
-    const durableKey = this.checkpointKey(input);
-    if (Object.prototype.hasOwnProperty.call(resolved, durableKey)) {
-      return { found: true, value: resolved[durableKey] };
-    }
-    return { found: false, value: undefined };
-  }
-
-  setResolved(
-    queueKey: string,
-    input: {
-      rowId: number;
-      rowKey?: string | null;
-    },
-    value: unknown,
-  ): void {
-    this.checkpoint.resolvedWaterfalls[queueKey] ??= {};
-    this.checkpoint.resolvedWaterfalls[queueKey]![this.checkpointKey(input)] =
-      value;
-  }
-
-  readProviderBatch(input: {
-    batchKey: string;
-    requests: readonly WaterfallRequest[];
-  }): Array<{ request: WaterfallRequest; result: unknown | null }> | null {
-    const cached = this.checkpoint.completedBatches[input.batchKey];
-    if (!cached) {
-      return null;
-    }
-    const recovered = cached.flatMap((entry) => {
-      const request = input.requests.find((candidate) =>
-        entry.rowKey
-          ? candidate.rowKey === entry.rowKey
-          : candidate.rowId === entry.rowId,
-      );
-      return request ? [{ request, result: entry.result }] : [];
-    });
-    return recovered.length > 0 ? recovered : null;
-  }
-
-  writeProviderBatch(
-    batchKey: string,
-    results: ReadonlyArray<{
-      request: WaterfallRequest;
-      result: unknown | null;
-    }>,
-  ): void {
-    this.checkpoint.completedBatches[batchKey] = results.map(
-      (entry): BatchResult => ({
-        rowId: entry.request.rowId,
-        rowKey: entry.request.rowKey ?? null,
-        result: entry.result,
-      }),
-    );
-  }
-}