deepline 0.3.45 → 0.3.47

package/dist/{compiler-manifest-DwYe2C2S.d.ts → compiler-manifest-BuoqasqI.d.ts}

@@ -2,336 +2,250 @@
 import * as _sinclair_typebox from '@sinclair/typebox';
 import { Static } from '@sinclair/typebox';
 
-declare const PLAY_RUNTIME_BACKENDS: {
-    readonly localProcess: "local_process";
-    readonly daytona: "daytona";
-    readonly modal: "modal";
-};
-type PlayRuntimeBackendId = (typeof PLAY_RUNTIME_BACKENDS)[keyof typeof PLAY_RUNTIME_BACKENDS];
+declare const TOOL_EXECUTION_ERROR_SCHEMA_VERSION: 1;
+declare const SUPPORTED_TOOL_EXECUTION_ERROR_SCHEMA_VERSIONS: readonly [0, 1];
+type ToolExecutionErrorSchemaVersion = (typeof SUPPORTED_TOOL_EXECUTION_ERROR_SCHEMA_VERSIONS)[number];
 /**
- * The one executable Play artifact contract. Daytona and local-process both
- * load CommonJS under Node 20.
+ * The boundary responsible for a failed tool call.
+ *
+ * Use `provider` to distinguish a provider answer from caller input and
+ * Deepline infrastructure. `unknown` fails closed and must not trigger a
+ * waterfall fallback.
+ *
+ * @sdkReference errors 020
  */
-declare const PLAY_ARTIFACT_KINDS: {
-    readonly cjsNode20: "cjs_node20";
+type ToolExecutionErrorOrigin = 'caller' | 'provider' | 'deepline' | 'unknown';
+/**
+ * The stable reason family for a failed tool call.
+ *
+ * Branch on this field only after narrowing to `ToolExecutionError`. Catch
+ * `ProviderTransientError` when the policy is simply “try the next read
+ * provider”; it is the safer and shorter waterfall contract.
+ *
+ * @sdkReference errors 030
+ */
+type ToolExecutionErrorCategory = 'validation' | 'authentication' | 'authorization' | 'rate_limit' | 'network' | 'upstream' | 'billing' | 'conflict' | 'internal' | 'unknown';
+/**
+ * The transport failure observed when `category` is `network`.
+ *
+ * This is `null` for failures that are not network failures.
+ *
+ * @sdkReference errors 040
+ */
+type ToolExecutionNetworkKind = 'timeout' | 'dns' | 'connect' | 'reset' | 'unavailable' | 'unknown';
+/**
+ * The request boundary on which a network failure occurred.
+ *
+ * `deepline_to_provider` is provider-side. Client and runtime scopes are
+ * Deepline transport failures and never qualify as provider fallthrough.
+ *
+ * @sdkReference errors 050
+ */
+type ToolExecutionNetworkScope = 'client_to_deepline' | 'runtime_to_deepline' | 'deepline_to_provider';
+/**
+ * Portable version-1 `tool_error` payload.
+ *
+ * This allowlisted shape crosses the API, runtime, and SDK boundaries.
+ * `message` remains on the Error object and is deliberately not a policy
+ * field.
+ *
+ * @sdkReference errors 064
+ */
+type ToolExecutionFailureV1 = {
+    /** Payload version. */
+    schemaVersion: typeof TOOL_EXECUTION_ERROR_SCHEMA_VERSION;
+    /** Public tool id passed to `tools.execute`. */
+    toolId: string;
+    /** Provider responsible for the operation, or `null`. */
+    provider: string | null;
+    /** Provider operation name, or `null`. */
+    operation: string | null;
+    /** Stable machine-readable failure code, or `null`. */
+    code: string | null;
+    /** Boundary responsible for the failure. */
+    origin: ToolExecutionErrorOrigin;
+    /** Stable reason family. */
+    category: ToolExecutionErrorCategory;
+    /** Whether repeating the same semantic call is delivery-safe. */
+    retryable: boolean;
+    /** HTTP status when one exists, or `null`. */
+    statusCode: number | null;
+    /** Provider or Deepline request id, or `null`. */
+    requestId: string | null;
+    /** Suggested same-call retry delay in milliseconds, or `null`. */
+    retryAfterMs: number | null;
+    /** Network failure kind, or `null`. */
+    networkKind: ToolExecutionNetworkKind | null;
+    /** Network boundary that failed, or `null`. */
+    networkScope: ToolExecutionNetworkScope | null;
 };
-type PlayArtifactKind = (typeof PLAY_ARTIFACT_KINDS)[keyof typeof PLAY_ARTIFACT_KINDS];
-
-type PlayDocflowNodeKind = 'action' | 'decision' | 'dataset' | 'play' | 'conceptual';
-type PlayDocflowNode = {
-    id: string;
-    label: string;
-    kind: PlayDocflowNodeKind;
+/**
+ * Constructor input for a structured tool failure.
+ *
+ * Deepline creates these values while decoding the versioned wire payload.
+ * Customer code normally reads `ToolExecutionError` fields instead of
+ * constructing an error.
+ *
+ * @sdkReference errors 065
+ */
+type ToolExecutionErrorOptions = Omit<ToolExecutionFailureV1, 'schemaVersion'> & {
     /**
-     * No statement in this play runs this box — the author said so with
-     * `class <id> sketch`. See {@link SKETCH_CLASS}.
-     *
-     * Deliberately NOT a `kind`. What a box IS (an action, a decision, a dataset)
-     * and whether code binds it are two different questions, and folding the
-     * second into the first was wrong in a way the tests caught immediately: a
-     * sketched diamond stopped being a decision, so it lost its shape on the
-     * canvas and the branch-label lint stopped checking its arms. Absent rather
-     * than `false` when bound, so the JSON a bound diagram hashes to is byte for
-     * byte what it was before sketches existed.
+     * Local diagnostic context inherited from DeeplineError. This is not part of
+     * the portable failure payload and is intentionally omitted by serialization.
      */
-    sketch?: true;
+    details?: Record<string, unknown>;
 };
 /**
- * Which arm of a conditional a drawn decision edge IS.
+ * Provider-owned failure categories that may fall through to another read
+ * provider.
  *
- * The runtime's own two-valued vocabulary for a `runIf` (ADR 0019): the cell
- * record says `branch: 'run' | 'else'`, and this is the same token on the
- * diagram's side of the join. Deliberately NOT the arm's label — a label is the
- * author's prose ("fit 65 or better", "nicht gefunden") and says nothing about
- * polarity in any language.
+ * @sdkReference errors 060
  */
-type PlayDocflowArm = 'run' | 'else';
-type PlayDocflowEdge = {
-    from: string;
-    to: string;
-    label?: string;
+type ProviderTransientErrorCategory = 'rate_limit' | 'network' | 'upstream';
+/**
+ * Base error class shared by the SDK and play runtime.
+ *
+ * The global brand preserves `instanceof DeeplineError` when a bundled play
+ * and the runtime load separate physical copies of this module.
+ *
+ * @sdkReference errors 010
+ */
+declare class DeeplineError extends Error {
+    /** HTTP status when the failure crossed an HTTP boundary. */
+    statusCode?: number;
+    /** Stable machine-readable error code when one exists. */
+    code?: string;
+    /** Local diagnostic context; not a portable error contract. */
+    details?: Record<string, unknown>;
     /**
-     * The conditional arm this edge is, when the author recorded it.
+     * Construct a Deepline error.
      *
-     * ABSENT — never `null` — when unrecorded, and that is load-bearing rather
-     * than stylistic. `docflow` is whole-object serialized into
-     * `playStaticPipelineContractHash` (`src/lib/plays/artifact-storage.ts`),
-     * which is part of the immutable artifact storage key, and the canonicalizer
-     * there drops `undefined` but HASHES `null`. Emitting `arm: null` on an
-     * unannotated edge would change the contract hash of every diagrammed play
-     * ever published and force a republish. Omission is what keeps this additive.
+     * SDK and runtime code construct these errors. Application and Play code
+     * normally catches the public subclasses instead.
+     *
+     * @param message Human-readable failure summary.
+     * @param statusCode HTTP status when one exists.
+     * @param code Stable machine-readable code when one exists.
+     * @param details Local diagnostic context; never a portable error contract.
      */
-    arm?: PlayDocflowArm;
-};
+    constructor(message: string, statusCode?: number, code?: string, details?: Record<string, unknown>);
+    static [Symbol.hasInstance](value: unknown): boolean;
+}
 /**
- * A Mermaid `subgraph … end` region. When an edge connects it to a dataset
- * node, it models that dataset's per-row loop; its members represent the
- * per-row column work. See `docs/play-syntax-spec.md`. `memberIds` records the
- * innermost subgraph for nested regions.
+ * A failed `tools.execute` call with stable, allowlisted provenance.
+ *
+ * `retryable` means Deepline's delivery/idempotency contract says it is safe
+ * to repeat the same semantic call. It does not describe durable receipt
+ * repairability and does not make arbitrary side-effecting fallbacks safe.
+ *
+ * In a Play, catch `ProviderTransientError` to continue a read waterfall and
+ * let every other `ToolExecutionError` remain loud. In an SDK client, catch
+ * this base class when you need structured diagnostics for every tool failure.
+ *
+ * @sdkReference errors 070
  */
-type PlayDocflowSubgraph = {
-    id: string;
-    label: string;
-    memberIds: string[];
-};
-type PlayDocflowBinding = {
-    nodeId: string;
-    line: number;
-    label?: string;
-    kind?: PlayDocflowNodeKind;
-    /** Symbolic values read by this business node. Never an arbitrary JS expression. */
-    inputs?: string[];
-    /** Symbolic values produced or changed by this business node. */
-    outputs?: string[];
-    /** Whether the contract was authored, safely inferred, or still needs help. */
-    ioConfidence?: 'explicit' | 'inferred' | 'ambiguous';
+declare class ToolExecutionError extends DeeplineError {
+    /** Public tool id passed to `tools.execute`. */
+    readonly toolId: string;
+    /** Provider responsible for the operation, or `null` when unattributed. */
+    readonly provider: string | null;
+    /** Provider operation name, or `null` when unavailable. */
+    readonly operation: string | null;
+    /** Boundary responsible for the failure. */
+    readonly origin: ToolExecutionErrorOrigin;
+    /** Stable reason family for policy and diagnostics. */
+    readonly category: ToolExecutionErrorCategory;
     /**
-     * `arm:"run"` / `arm:"else"` — this node is that arm of the decision above it.
+     * Whether repeating the same semantic call is delivery-safe.
      *
-     * Recorded on the annotation because the annotation is the only place the two
-     * halves of the join meet: a `@mermaid-node` binds a DIAGRAM id to the SOURCE
-     * statement directly beneath it, so the author writing it is the one person
-     * who knows both which drawn arm this is and which side of the `runIf` the
-     * code under it implements. Projected onto the incoming decision edge by
-     * {@link attachBindingsToBlocks}; the edge is what readers resolve against.
+     * This does not mean the error may be ignored. Waterfall fallthrough is
+     * represented by `ProviderTransientError`.
      */
-    arm?: PlayDocflowArm;
-};
-type PlayDocflow = {
-    direction: 'LR' | 'RL' | 'TB' | 'TD' | 'BT';
-    nodes: PlayDocflowNode[];
-    edges: PlayDocflowEdge[];
-    bindings: PlayDocflowBinding[];
-    /** Authoring syntax used by the source file. */
-    syntax?: 'mermaid';
-    /** Normalized Mermaid text, ready to pass directly to a Mermaid renderer. */
-    mermaidSource?: string;
+    readonly retryable: boolean;
+    /** Provider or Deepline request id, or `null` when unavailable. */
+    readonly requestId: string | null;
+    /** Suggested same-call retry delay in milliseconds, or `null`. */
+    readonly retryAfterMs: number | null;
+    /** Network failure kind, or `null` for non-network failures. */
+    readonly networkKind: ToolExecutionNetworkKind | null;
+    /** Network boundary that failed, or `null` for non-network failures. */
+    readonly networkScope: ToolExecutionNetworkScope | null;
     /**
-     * Mermaid `subgraph` loop regions. Optional for persisted graphs that have
-     * no authored regions.
+     * Construct a structured tool error.
+     *
+     * Deepline constructs this from the versioned `tool_error` payload.
+     * Application and Play code should catch it rather than create it.
      */
-    subgraphs?: PlayDocflowSubgraph[];
-    /** Mermaid directives accepted by the parser but not applied by React Flow. */
-    ignoredDirectives?: string[];
-};
-
+    constructor(message: string, options: ToolExecutionErrorOptions);
+    static [Symbol.hasInstance](value: unknown): boolean;
+}
 /**
- * A top-level key the play's function literally `return`s. Derived from the
- * `return { ... }` object literal — NOT from dataset `.withColumn(...)` names —
- * so the "Returns" graph node mirrors the function's real output shape.
- * `isDataset` is true when the key's value is a `PlayDataset` handle (a table).
- */
-interface PlayStaticReturnField {
-    name: string;
-    isDataset: boolean;
-    /**
-     * For a dataset-valued field, the `ctx.dataset(KEY, ...)` key backing it
-     * (e.g. `job_change_checks`) — so the UI can label the return by the dataset
-     * it actually produces instead of the bland object key (`rows`). Undefined
-     * for non-dataset fields, `ctx.csv(...)` (no durable name), or when the key
-     * isn't a static string literal.
-     */
-    datasetName?: string;
-}
-interface PlayStaticPipeline {
-    /** Authored business flow. Static analysis is used only when this is absent. */
-    docflow?: PlayDocflow;
-    tableNamespace?: string;
-    inputFields?: string[];
-    rowKeyFields?: string[];
-    csvArg?: string;
-    hasInlineData?: boolean;
-    csvDescription?: string;
-    datasetDescription?: string;
-    fields: string[];
-    /**
-     * Top-level keys of the play's `return { ... }` object literal, in source
-     * order. Undefined when the terminal return isn't a statically-known object
-     * literal (bare value, dataset handle, conditional returns, etc.).
-     */
-    returnFields?: PlayStaticReturnField[];
-    stages?: PlayStaticSubstep[];
-    substeps: PlayStaticSubstep[];
-    sheetContract?: PlaySheetContract | null;
-    sheetContractErrors?: string[];
-}
-type PlaySheetColumnSource = 'input' | 'datasetColumn' | 'waterfallStep' | 'childPlayColumn';
-interface PlaySheetColumnContract {
-    id: string;
-    sqlName: string;
-    source: PlaySheetColumnSource;
-    field?: string;
-    parentField?: string;
-    playId?: string;
-    waterfallId?: string;
-    outputField?: string;
-    outputSqlName?: string;
-    stepId?: string;
-    toolId?: string;
-    isRowKey?: boolean;
-}
-interface PlaySheetContract {
-    tableNamespace: string;
-    columns: PlaySheetColumnContract[];
-}
-type PlayStaticColumnProducerKind = 'tool' | 'waterfall' | 'stepProgram' | 'playCall' | 'controlFlow' | 'transform';
-interface PlayStaticColumnProducer {
-    id: string;
-    kind: PlayStaticColumnProducerKind;
-    field: string;
-    toolId?: string;
-    playId?: string;
-    conditional?: boolean;
-    sourceRange?: PlayStaticSourceRange;
-    steps?: PlayStaticColumnProducer[];
-    substep: PlayStaticSubstep;
-}
-interface PlayStaticDatasetColumn {
-    id: string;
-    source: PlaySheetColumnSource;
-    sqlName?: string;
-    producers: PlayStaticColumnProducer[];
-}
-interface PlayStaticSourceRange {
-    sourcePath?: string;
-    startLine: number;
-    endLine: number;
-    startColumn: number;
-    endColumn: number;
+ * A provider-owned transient failure that is safe to handle as an empty
+ * waterfall leg. Validation, auth, billing, Deepline, and unknown failures
+ * never satisfy this type.
+ *
+ * `retryable` remains independent: it says whether the same semantic call may
+ * be repeated safely. Falling through to a different read provider depends on
+ * this class, not on `retryable`.
+ *
+ * @sdkReference errors 080
+ */
+declare class ProviderTransientError extends ToolExecutionError {
+    /** Provider attribution is guaranteed for this subtype. */
+    readonly origin: "provider";
+    /** Provider failure category that made this error eligible for fallthrough. */
+    readonly category: ProviderTransientErrorCategory;
+    /** Constructed by Deepline when a provider-owned transient failure arrives. */
+    constructor(message: string, options: Omit<ToolExecutionErrorOptions, 'origin' | 'category'> & {
+        category: ProviderTransientErrorCategory;
+    });
+    static [Symbol.hasInstance](value: unknown): boolean;
 }
-type PlayStaticSubstepMetadata = {
-    conditional?: boolean;
-    disabled?: boolean;
-};
+/** Why a provider cannot serve the current read request. */
+type ProviderUnavailableReason = ProviderTransientErrorCategory | 'account_capacity' | 'credentials_missing';
 /**
- * One arm of a conditional `control_flow` substep — an `if`/`else if`/`else`
- * leg, a `switch` case, or a ternary branch. Carries its own steps so the graph
- * can render the conditional as a real fork instead of a flat strip.
+ * A provider failure that permits a read waterfall to try its next provider.
+ * A missing provider connection is included because another provider may still
+ * serve the read. Invalid credentials, caller input, and Deepline billing
+ * failures remain loud.
  */
-type PlayStaticControlFlowBranch = {
-    /** Short arm label, e.g. `if`, `else if`, `else`, `case 'x'`, `default`. */
-    label: string;
-    /** The arm's condition source text, when it has one (omitted for `else`). */
-    condition?: string;
-    /** Static work in this arm. Empty for log/throw/return-only arms. */
-    steps: PlayStaticSubstep[];
-};
-type PlayStaticSubstep = PlayStaticSubstepMetadata & ({
-    type: 'csv';
-    field: string;
-    path?: string;
-    description?: string;
-    sourceRange?: PlayStaticSourceRange;
-    callDepth?: number;
-    callPath?: string[];
-} | {
-    type: 'dataset';
-    field: string;
-    name?: string;
-    tableNamespace?: string;
-    inputFields?: string[];
-    rowKeyFields?: string[];
-    outputFields?: string[];
-    columns?: PlayStaticDatasetColumn[];
-    waterfallIds?: string[];
-    steps?: PlayStaticSubstep[];
-    sheetContract?: PlaySheetContract | null;
-    /**
-     * Columns the author declared as deliberately absent from the `@mermaid`
-     * diagram via `.run({ undrawnColumns: [...] })`. The docflow column
-     * coverage gate reads this; nothing about execution does.
-     */
-    undrawnColumns?: string[];
-    description?: string;
-    sourceRange?: PlayStaticSourceRange;
-    callDepth?: number;
-    callPath?: string[];
-} | {
-    type: 'tool';
-    toolId: string;
-    field: string;
-    paramsSource?: string;
-    sourceText?: 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;
-    execution?: 'inline' | 'child-workflow';
-    timeoutMs?: number;
-    hasExplicitTimeout?: boolean;
-    field: string;
-    inLoop?: boolean;
-    pipeline?: PlayStaticPipeline | null;
-    cycleDetected?: boolean;
-    resolutionError?: string;
-    description?: string;
-    sourceRange?: PlayStaticSourceRange;
-    callDepth?: number;
-    callPath?: string[];
-} | {
-    type: 'control_flow';
-    kind: 'conditional' | 'loop';
-    field: string;
-    /** Flattened steps across every arm, in source order (back-compat). */
-    steps: PlayStaticSubstep[];
-    /** Discriminant source text (the `if`/ternary test, `switch` subject). */
-    condition?: string;
-    /** Per-arm breakdown for conditionals; omitted for loops. */
-    branches?: PlayStaticControlFlowBranch[];
-    description?: string;
-    sourceRange?: PlayStaticSourceRange;
-    callDepth?: number;
-    callPath?: string[];
-} | {
-    type: 'run_javascript';
-    alias: string;
-    sourceText?: string;
-    description?: string;
-    sourceRange?: PlayStaticSourceRange;
-    callDepth?: number;
-    callPath?: string[];
-} | {
-    type: 'code';
-    field: string;
-    sourceText?: string;
-    description?: string;
-    sourceRange?: PlayStaticSourceRange;
-    callDepth?: number;
-    callPath?: string[];
+type ProviderUnavailableError = ProviderTransientError | (ToolExecutionError & {
+    readonly origin: 'provider';
+    readonly code: 'PROVIDER_ACCOUNT_CAPACITY';
+}) | (ToolExecutionError & {
+    readonly origin: 'caller';
+    readonly code: 'INTEGRATION_CREDENTIALS_MISSING';
 });
+/**
+ * Return the provider-specific reason a read cannot run right now.
+ *
+ * `null` means this error must stay loud: it is caller input, an invalid
+ * customer credential, Deepline billing, or an internal failure. A missing
+ * provider connection is different: an explicit read waterfall may continue
+ * to a configured fallback and record the unavailable leg.
+ */
+declare function getProviderUnavailableReason(error: unknown): ProviderUnavailableReason | null;
+/**
+ * Whether a provider cannot serve this read right now.
+ *
+ * Use this in an explicit `catch` to advance a read-only waterfall. For
+ * diagnostics, use `getProviderUnavailableReason(error)`.
+ */
+declare function isProviderUnavailable(error: unknown): error is ProviderUnavailableError;
+/** @deprecated Use isProviderUnavailable. */
+declare const isProviderWaterfallUnavailableError: typeof isProviderUnavailable;
+
+/**
+ * Public tool-response contracts shared by the API, SDK, Play bundler, and
+ * runtime. This is a versioned response transformation contract: a change to
+ * the persisted public tool-result shape must introduce a new value here and
+ * have newly built Play artifacts select it. Receipt-cache revisions are
+ * intentionally separate: ordinary response-contract changes do not refresh
+ * durable receipts unless the response transformation changed as well.
+ */
+declare const V2_TOOL_RESPONSE_CONTRACT: "v2-tool-response";
+declare const RAW_V2_TOOL_RESPONSE_CONTRACT: "raw-v2";
+type ToolResponseContract = typeof V2_TOOL_RESPONSE_CONTRACT | typeof RAW_V2_TOOL_RESPONSE_CONTRACT;
 
 /**
  * Previous durable cell value passed to object-column resolvers.
@@ -785,239 +699,6 @@ type ToolExecuteResultAccessors<TExtracted extends Record<string, unknown> = Par
  */
 type ToolExecuteResult<TResult = unknown, TMeta = Record<string, unknown>, TExtracted extends Record<string, unknown> = Partial<DeeplineGetterValueMap>, TLists extends Record<string, Record<string, unknown>> = Record<string, Record<string, unknown>>> = ToolExecuteResultBase<TResult, TMeta> & ToolExecuteResultAccessors<TExtracted, TLists>;
 
-declare const TOOL_EXECUTION_ERROR_SCHEMA_VERSION: 1;
-declare const SUPPORTED_TOOL_EXECUTION_ERROR_SCHEMA_VERSIONS: readonly [0, 1];
-type ToolExecutionErrorSchemaVersion = (typeof SUPPORTED_TOOL_EXECUTION_ERROR_SCHEMA_VERSIONS)[number];
-/**
- * The boundary responsible for a failed tool call.
- *
- * Use `provider` to distinguish a provider answer from caller input and
- * Deepline infrastructure. `unknown` fails closed and must not trigger a
- * waterfall fallback.
- *
- * @sdkReference errors 020
- */
-type ToolExecutionErrorOrigin = 'caller' | 'provider' | 'deepline' | 'unknown';
-/**
- * The stable reason family for a failed tool call.
- *
- * Branch on this field only after narrowing to `ToolExecutionError`. Catch
- * `ProviderTransientError` when the policy is simply “try the next read
- * provider”; it is the safer and shorter waterfall contract.
- *
- * @sdkReference errors 030
- */
-type ToolExecutionErrorCategory = 'validation' | 'authentication' | 'authorization' | 'rate_limit' | 'network' | 'upstream' | 'billing' | 'conflict' | 'internal' | 'unknown';
-/**
- * The transport failure observed when `category` is `network`.
- *
- * This is `null` for failures that are not network failures.
- *
- * @sdkReference errors 040
- */
-type ToolExecutionNetworkKind = 'timeout' | 'dns' | 'connect' | 'reset' | 'unavailable' | 'unknown';
-/**
- * The request boundary on which a network failure occurred.
- *
- * `deepline_to_provider` is provider-side. Client and runtime scopes are
- * Deepline transport failures and never qualify as provider fallthrough.
- *
- * @sdkReference errors 050
- */
-type ToolExecutionNetworkScope = 'client_to_deepline' | 'runtime_to_deepline' | 'deepline_to_provider';
-/**
- * Portable version-1 `tool_error` payload.
- *
- * This allowlisted shape crosses the API, runtime, and SDK boundaries.
- * `message` remains on the Error object and is deliberately not a policy
- * field.
- *
- * @sdkReference errors 064
- */
-type ToolExecutionFailureV1 = {
-    /** Payload version. */
-    schemaVersion: typeof TOOL_EXECUTION_ERROR_SCHEMA_VERSION;
-    /** Public tool id passed to `tools.execute`. */
-    toolId: string;
-    /** Provider responsible for the operation, or `null`. */
-    provider: string | null;
-    /** Provider operation name, or `null`. */
-    operation: string | null;
-    /** Stable machine-readable failure code, or `null`. */
-    code: string | null;
-    /** Boundary responsible for the failure. */
-    origin: ToolExecutionErrorOrigin;
-    /** Stable reason family. */
-    category: ToolExecutionErrorCategory;
-    /** Whether repeating the same semantic call is delivery-safe. */
-    retryable: boolean;
-    /** HTTP status when one exists, or `null`. */
-    statusCode: number | null;
-    /** Provider or Deepline request id, or `null`. */
-    requestId: string | null;
-    /** Suggested same-call retry delay in milliseconds, or `null`. */
-    retryAfterMs: number | null;
-    /** Network failure kind, or `null`. */
-    networkKind: ToolExecutionNetworkKind | null;
-    /** Network boundary that failed, or `null`. */
-    networkScope: ToolExecutionNetworkScope | null;
-};
-/**
- * Constructor input for a structured tool failure.
- *
- * Deepline creates these values while decoding the versioned wire payload.
- * Customer code normally reads `ToolExecutionError` fields instead of
- * constructing an error.
- *
- * @sdkReference errors 065
- */
-type ToolExecutionErrorOptions = Omit<ToolExecutionFailureV1, 'schemaVersion'> & {
-    /**
-     * Local diagnostic context inherited from DeeplineError. This is not part of
-     * the portable failure payload and is intentionally omitted by serialization.
-     */
-    details?: Record<string, unknown>;
-};
-/**
- * Provider-owned failure categories that may fall through to another read
- * provider.
- *
- * @sdkReference errors 060
- */
-type ProviderTransientErrorCategory = 'rate_limit' | 'network' | 'upstream';
-/**
- * Base error class shared by the SDK and play runtime.
- *
- * The global brand preserves `instanceof DeeplineError` when a bundled play
- * and the runtime load separate physical copies of this module.
- *
- * @sdkReference errors 010
- */
-declare class DeeplineError extends Error {
-    /** HTTP status when the failure crossed an HTTP boundary. */
-    statusCode?: number;
-    /** Stable machine-readable error code when one exists. */
-    code?: string;
-    /** Local diagnostic context; not a portable error contract. */
-    details?: Record<string, unknown>;
-    /**
-     * Construct a Deepline error.
-     *
-     * SDK and runtime code construct these errors. Application and Play code
-     * normally catches the public subclasses instead.
-     *
-     * @param message Human-readable failure summary.
-     * @param statusCode HTTP status when one exists.
-     * @param code Stable machine-readable code when one exists.
-     * @param details Local diagnostic context; never a portable error contract.
-     */
-    constructor(message: string, statusCode?: number, code?: string, details?: Record<string, unknown>);
-    static [Symbol.hasInstance](value: unknown): boolean;
-}
-/**
- * A failed `tools.execute` call with stable, allowlisted provenance.
- *
- * `retryable` means Deepline's delivery/idempotency contract says it is safe
- * to repeat the same semantic call. It does not describe durable receipt
- * repairability and does not make arbitrary side-effecting fallbacks safe.
- *
- * In a Play, catch `ProviderTransientError` to continue a read waterfall and
- * let every other `ToolExecutionError` remain loud. In an SDK client, catch
- * this base class when you need structured diagnostics for every tool failure.
- *
- * @sdkReference errors 070
- */
-declare class ToolExecutionError extends DeeplineError {
-    /** Public tool id passed to `tools.execute`. */
-    readonly toolId: string;
-    /** Provider responsible for the operation, or `null` when unattributed. */
-    readonly provider: string | null;
-    /** Provider operation name, or `null` when unavailable. */
-    readonly operation: string | null;
-    /** Boundary responsible for the failure. */
-    readonly origin: ToolExecutionErrorOrigin;
-    /** Stable reason family for policy and diagnostics. */
-    readonly category: ToolExecutionErrorCategory;
-    /**
-     * Whether repeating the same semantic call is delivery-safe.
-     *
-     * This does not mean the error may be ignored. Waterfall fallthrough is
-     * represented by `ProviderTransientError`.
-     */
-    readonly retryable: boolean;
-    /** Provider or Deepline request id, or `null` when unavailable. */
-    readonly requestId: string | null;
-    /** Suggested same-call retry delay in milliseconds, or `null`. */
-    readonly retryAfterMs: number | null;
-    /** Network failure kind, or `null` for non-network failures. */
-    readonly networkKind: ToolExecutionNetworkKind | null;
-    /** Network boundary that failed, or `null` for non-network failures. */
-    readonly networkScope: ToolExecutionNetworkScope | null;
-    /**
-     * Construct a structured tool error.
-     *
-     * Deepline constructs this from the versioned `tool_error` payload.
-     * Application and Play code should catch it rather than create it.
-     */
-    constructor(message: string, options: ToolExecutionErrorOptions);
-    static [Symbol.hasInstance](value: unknown): boolean;
-}
-/**
- * A provider-owned transient failure that is safe to handle as an empty
- * waterfall leg. Validation, auth, billing, Deepline, and unknown failures
- * never satisfy this type.
- *
- * `retryable` remains independent: it says whether the same semantic call may
- * be repeated safely. Falling through to a different read provider depends on
- * this class, not on `retryable`.
- *
- * @sdkReference errors 080
- */
-declare class ProviderTransientError extends ToolExecutionError {
-    /** Provider attribution is guaranteed for this subtype. */
-    readonly origin: "provider";
-    /** Provider failure category that made this error eligible for fallthrough. */
-    readonly category: ProviderTransientErrorCategory;
-    /** Constructed by Deepline when a provider-owned transient failure arrives. */
-    constructor(message: string, options: Omit<ToolExecutionErrorOptions, 'origin' | 'category'> & {
-        category: ProviderTransientErrorCategory;
-    });
-    static [Symbol.hasInstance](value: unknown): boolean;
-}
-/** Why a provider cannot serve the current read request. */
-type ProviderUnavailableReason = ProviderTransientErrorCategory | 'account_capacity' | 'credentials_missing';
-/**
- * A provider failure that permits a read waterfall to try its next provider.
- * A missing provider connection is included because another provider may still
- * serve the read. Invalid credentials, caller input, and Deepline billing
- * failures remain loud.
- */
-type ProviderUnavailableError = ProviderTransientError | (ToolExecutionError & {
-    readonly origin: 'provider';
-    readonly code: 'PROVIDER_ACCOUNT_CAPACITY';
-}) | (ToolExecutionError & {
-    readonly origin: 'caller';
-    readonly code: 'INTEGRATION_CREDENTIALS_MISSING';
-});
-/**
- * Return the provider-specific reason a read cannot run right now.
- *
- * `null` means this error must stay loud: it is caller input, an invalid
- * customer credential, Deepline billing, or an internal failure. A missing
- * provider connection is different: an explicit read waterfall may continue
- * to a configured fallback and record the unavailable leg.
- */
-declare function getProviderUnavailableReason(error: unknown): ProviderUnavailableReason | null;
-/**
- * Whether a provider cannot serve this read right now.
- *
- * Use this in an explicit `catch` to advance a read-only waterfall. For
- * diagnostics, use `getProviderUnavailableReason(error)`.
- */
-declare function isProviderUnavailable(error: unknown): error is ProviderUnavailableError;
-/** @deprecated Use isProviderUnavailable. */
-declare const isProviderWaterfallUnavailableError: typeof isProviderUnavailable;
-
 declare const SUPPORTED_PLAY_AUTHORING_CONTRACT_EDITIONS: readonly [1, 2, 3, 4];
 type PlayAuthoringContractEdition = (typeof SUPPORTED_PLAY_AUTHORING_CONTRACT_EDITIONS)[number];
 type PlaySqlListenerOperation = 'INSERT' | 'UPDATE' | 'DELETE';
@@ -2863,6 +2544,370 @@ type DurableCallStaleAfterSeconds = Static<(typeof PLAY_AUTHORING_FIELD_REGISTRY
 type PlayRuntimeTimeoutMs = number;
 type PlayReceiptWaitMs = number;
 
+type PlayPackageImport = {
+    name: string;
+    version: string | null;
+};
+type PlayImportPolicy = {
+    localFiles: string[];
+    nodeBuiltins: string[];
+    packages: PlayPackageImport[];
+};
+type PlayRuntimeFeature = 'artifact_storage' | 'checkpoint_resume' | 'durable_sleep' | 'packaged_files';
+type PlayArtifactCompatibility = {
+    apiVersion: number;
+    artifactVersion: number;
+    minRunnerVersion: number;
+    runtimeFeatures: PlayRuntimeFeature[];
+    runtimeBackend?: string | null;
+    /** Missing preserves the legacy schema used before this field existed. */
+    toolErrorSchemaVersion?: ToolExecutionErrorSchemaVersion;
+    /** Missing preserves edition 1 for artifacts created before authoring contracts were pinned. */
+    authoringContractEdition?: PlayAuthoringContractEdition;
+    /** Missing preserves the raw-only V2 execute response contract. */
+    toolResponseContract?: ToolResponseContract;
+    /** Missing preserves the receipt namespace of artifacts created before this revision existed. */
+    toolResponseReceiptRevision?: string;
+};
+/** The only executable Play artifact contract. */
+declare const PLAY_ARTIFACT_KINDS: {
+    readonly cjsNode20: "cjs_node20";
+};
+type PlayArtifactKind = (typeof PLAY_ARTIFACT_KINDS)[keyof typeof PLAY_ARTIFACT_KINDS];
+type PlayBundleArtifact = {
+    codeFormat: 'cjs_module';
+    /** Defaults to cjs_node20 when not present on legacy Node artifacts. */
+    artifactKind?: PlayArtifactKind;
+    entryFile: string;
+    virtualFilename: string;
+    sourceHash: string;
+    graphHash: string;
+    artifactHash: string;
+    sourceMapHash: string;
+    bundledCode: string;
+    sourceMap: string;
+    importPolicy: PlayImportPolicy;
+    compatibility: PlayArtifactCompatibility;
+    generatedAt: number;
+    cacheHit: boolean;
+};
+
+type PlayDocflowNodeKind = 'action' | 'decision' | 'dataset' | 'play' | 'conceptual';
+type PlayDocflowNode = {
+    id: string;
+    label: string;
+    kind: PlayDocflowNodeKind;
+    /**
+     * No statement in this play runs this box — the author said so with
+     * `class <id> sketch`. See {@link SKETCH_CLASS}.
+     *
+     * Deliberately NOT a `kind`. What a box IS (an action, a decision, a dataset)
+     * and whether code binds it are two different questions, and folding the
+     * second into the first was wrong in a way the tests caught immediately: a
+     * sketched diamond stopped being a decision, so it lost its shape on the
+     * canvas and the branch-label lint stopped checking its arms. Absent rather
+     * than `false` when bound, so the JSON a bound diagram hashes to is byte for
+     * byte what it was before sketches existed.
+     */
+    sketch?: true;
+};
+/**
+ * Which arm of a conditional a drawn decision edge IS.
+ *
+ * The runtime's own two-valued vocabulary for a `runIf` (ADR 0019): the cell
+ * record says `branch: 'run' | 'else'`, and this is the same token on the
+ * diagram's side of the join. Deliberately NOT the arm's label — a label is the
+ * author's prose ("fit 65 or better", "nicht gefunden") and says nothing about
+ * polarity in any language.
+ */
+type PlayDocflowArm = 'run' | 'else';
+type PlayDocflowEdge = {
+    from: string;
+    to: string;
+    label?: string;
+    /**
+     * The conditional arm this edge is, when the author recorded it.
+     *
+     * ABSENT — never `null` — when unrecorded, and that is load-bearing rather
+     * than stylistic. `docflow` is whole-object serialized into
+     * `playStaticPipelineContractHash` (`src/lib/plays/artifact-storage.ts`),
+     * which is part of the immutable artifact storage key, and the canonicalizer
+     * there drops `undefined` but HASHES `null`. Emitting `arm: null` on an
+     * unannotated edge would change the contract hash of every diagrammed play
+     * ever published and force a republish. Omission is what keeps this additive.
+     */
+    arm?: PlayDocflowArm;
+};
+/**
+ * A Mermaid `subgraph … end` region. When an edge connects it to a dataset
+ * node, it models that dataset's per-row loop; its members represent the
+ * per-row column work. See `docs/play-syntax-spec.md`. `memberIds` records the
+ * innermost subgraph for nested regions.
+ */
+type PlayDocflowSubgraph = {
+    id: string;
+    label: string;
+    memberIds: string[];
+};
+type PlayDocflowBinding = {
+    nodeId: string;
+    line: number;
+    label?: string;
+    kind?: PlayDocflowNodeKind;
+    /** Symbolic values read by this business node. Never an arbitrary JS expression. */
+    inputs?: string[];
+    /** Symbolic values produced or changed by this business node. */
+    outputs?: string[];
+    /** Whether the contract was authored, safely inferred, or still needs help. */
+    ioConfidence?: 'explicit' | 'inferred' | 'ambiguous';
+    /**
+     * `arm:"run"` / `arm:"else"` — this node is that arm of the decision above it.
+     *
+     * Recorded on the annotation because the annotation is the only place the two
+     * halves of the join meet: a `@mermaid-node` binds a DIAGRAM id to the SOURCE
+     * statement directly beneath it, so the author writing it is the one person
+     * who knows both which drawn arm this is and which side of the `runIf` the
+     * code under it implements. Projected onto the incoming decision edge by
+     * {@link attachBindingsToBlocks}; the edge is what readers resolve against.
+     */
+    arm?: PlayDocflowArm;
+};
+type PlayDocflow = {
+    direction: 'LR' | 'RL' | 'TB' | 'TD' | 'BT';
+    nodes: PlayDocflowNode[];
+    edges: PlayDocflowEdge[];
+    bindings: PlayDocflowBinding[];
+    /** Authoring syntax used by the source file. */
+    syntax?: 'mermaid';
+    /** Normalized Mermaid text, ready to pass directly to a Mermaid renderer. */
+    mermaidSource?: string;
+    /**
+     * Mermaid `subgraph` loop regions. Optional for persisted graphs that have
+     * no authored regions.
+     */
+    subgraphs?: PlayDocflowSubgraph[];
+    /** Mermaid directives accepted by the parser but not applied by React Flow. */
+    ignoredDirectives?: string[];
+};
+
+/**
+ * A top-level key the play's function literally `return`s. Derived from the
+ * `return { ... }` object literal — NOT from dataset `.withColumn(...)` names —
+ * so the "Returns" graph node mirrors the function's real output shape.
+ * `isDataset` is true when the key's value is a `PlayDataset` handle (a table).
+ */
+interface PlayStaticReturnField {
+    name: string;
+    isDataset: boolean;
+    /**
+     * For a dataset-valued field, the `ctx.dataset(KEY, ...)` key backing it
+     * (e.g. `job_change_checks`) — so the UI can label the return by the dataset
+     * it actually produces instead of the bland object key (`rows`). Undefined
+     * for non-dataset fields, `ctx.csv(...)` (no durable name), or when the key
+     * isn't a static string literal.
+     */
+    datasetName?: string;
+}
+interface PlayStaticPipeline {
+    /** Authored business flow. Static analysis is used only when this is absent. */
+    docflow?: PlayDocflow;
+    tableNamespace?: string;
+    inputFields?: string[];
+    rowKeyFields?: string[];
+    csvArg?: string;
+    hasInlineData?: boolean;
+    csvDescription?: string;
+    datasetDescription?: string;
+    fields: string[];
+    /**
+     * Top-level keys of the play's `return { ... }` object literal, in source
+     * order. Undefined when the terminal return isn't a statically-known object
+     * literal (bare value, dataset handle, conditional returns, etc.).
+     */
+    returnFields?: PlayStaticReturnField[];
+    stages?: PlayStaticSubstep[];
+    substeps: PlayStaticSubstep[];
+    sheetContract?: PlaySheetContract | null;
+    sheetContractErrors?: string[];
+}
+type PlaySheetColumnSource = 'input' | 'datasetColumn' | 'waterfallStep' | 'childPlayColumn';
+interface PlaySheetColumnContract {
+    id: string;
+    sqlName: string;
+    source: PlaySheetColumnSource;
+    field?: string;
+    parentField?: string;
+    playId?: string;
+    waterfallId?: string;
+    outputField?: string;
+    outputSqlName?: string;
+    stepId?: string;
+    toolId?: string;
+    isRowKey?: boolean;
+}
+interface PlaySheetContract {
+    tableNamespace: string;
+    columns: PlaySheetColumnContract[];
+}
+type PlayStaticColumnProducerKind = 'tool' | 'waterfall' | 'stepProgram' | 'playCall' | 'controlFlow' | 'transform';
+interface PlayStaticColumnProducer {
+    id: string;
+    kind: PlayStaticColumnProducerKind;
+    field: string;
+    toolId?: string;
+    playId?: string;
+    conditional?: boolean;
+    sourceRange?: PlayStaticSourceRange;
+    steps?: PlayStaticColumnProducer[];
+    substep: PlayStaticSubstep;
+}
+interface PlayStaticDatasetColumn {
+    id: string;
+    source: PlaySheetColumnSource;
+    sqlName?: string;
+    producers: PlayStaticColumnProducer[];
+}
+interface PlayStaticSourceRange {
+    sourcePath?: string;
+    startLine: number;
+    endLine: number;
+    startColumn: number;
+    endColumn: number;
+}
+type PlayStaticSubstepMetadata = {
+    conditional?: boolean;
+    disabled?: boolean;
+};
+/**
+ * One arm of a conditional `control_flow` substep — an `if`/`else if`/`else`
+ * leg, a `switch` case, or a ternary branch. Carries its own steps so the graph
+ * can render the conditional as a real fork instead of a flat strip.
+ */
+type PlayStaticControlFlowBranch = {
+    /** Short arm label, e.g. `if`, `else if`, `else`, `case 'x'`, `default`. */
+    label: string;
+    /** The arm's condition source text, when it has one (omitted for `else`). */
+    condition?: string;
+    /** Static work in this arm. Empty for log/throw/return-only arms. */
+    steps: PlayStaticSubstep[];
+};
+type PlayStaticSubstep = PlayStaticSubstepMetadata & ({
+    type: 'csv';
+    field: string;
+    path?: string;
+    description?: string;
+    sourceRange?: PlayStaticSourceRange;
+    callDepth?: number;
+    callPath?: string[];
+} | {
+    type: 'dataset';
+    field: string;
+    name?: string;
+    tableNamespace?: string;
+    inputFields?: string[];
+    rowKeyFields?: string[];
+    outputFields?: string[];
+    columns?: PlayStaticDatasetColumn[];
+    waterfallIds?: string[];
+    steps?: PlayStaticSubstep[];
+    sheetContract?: PlaySheetContract | null;
+    /**
+     * Columns the author declared as deliberately absent from the `@mermaid`
+     * diagram via `.run({ undrawnColumns: [...] })`. The docflow column
+     * coverage gate reads this; nothing about execution does.
+     */
+    undrawnColumns?: string[];
+    description?: string;
+    sourceRange?: PlayStaticSourceRange;
+    callDepth?: number;
+    callPath?: string[];
+} | {
+    type: 'tool';
+    toolId: string;
+    field: string;
+    paramsSource?: string;
+    sourceText?: 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;
+    execution?: 'inline' | 'child-workflow';
+    timeoutMs?: number;
+    hasExplicitTimeout?: boolean;
+    field: string;
+    inLoop?: boolean;
+    pipeline?: PlayStaticPipeline | null;
+    cycleDetected?: boolean;
+    resolutionError?: string;
+    description?: string;
+    sourceRange?: PlayStaticSourceRange;
+    callDepth?: number;
+    callPath?: string[];
+} | {
+    type: 'control_flow';
+    kind: 'conditional' | 'loop';
+    field: string;
+    /** Flattened steps across every arm, in source order (back-compat). */
+    steps: PlayStaticSubstep[];
+    /** Discriminant source text (the `if`/ternary test, `switch` subject). */
+    condition?: string;
+    /** Per-arm breakdown for conditionals; omitted for loops. */
+    branches?: PlayStaticControlFlowBranch[];
+    description?: string;
+    sourceRange?: PlayStaticSourceRange;
+    callDepth?: number;
+    callPath?: string[];
+} | {
+    type: 'run_javascript';
+    alias: string;
+    sourceText?: string;
+    description?: string;
+    sourceRange?: PlayStaticSourceRange;
+    callDepth?: number;
+    callPath?: string[];
+} | {
+    type: 'code';
+    field: string;
+    sourceText?: string;
+    description?: string;
+    sourceRange?: PlayStaticSourceRange;
+    callDepth?: number;
+    callPath?: string[];
+});
+
 type PlayCompilerDependencyManifest = {
     playName: string;
     /** Original source path for direct imported definePlay dependencies. */
@@ -2896,4 +2941,4 @@ type PlayCompilerManifest = {
     authoringContract?: AdmittedPlayAuthoringContract;
 };
 
-export { type PlayDataset as $, type PlayAuthoringFetchResponse as A, type PlayAuthoringInputContract as B, type PlayAuthoringStepProgramStep as C, DeeplineError as D, type PlayAuthoringRuntimeStepOptions as E, type PlaySqlListenerDeclaration as F, type PlaySqlListenerEvent as G, type PlaySqlListenerOperation as H, type PlaySqlQuery as I, type PlayAuthoringStepOptions as J, type PlayAuthoringStepProgram as K, type PlayAuthoringStepProgramResolver as L, type PlayAuthoringStepResolver as M, type PlayToolExecutionRequest as N, type PlayAuthoringStepProgramOptions as O, type PlayAuthoringContractEdition as P, DEEPLINE_EXTRACTOR_TARGETS as Q, DEEPLINE_EXTRACTOR_TARGET_DEFINITIONS as R, type DeeplineEmailStatusGetterValue as S, type ToolExecutionErrorSchemaVersion as T, type DeeplineExtractorTarget as U, type DeeplineGetterValue as V, type DeeplineGetterValueMap as W, JOB_CHANGE_STATUS_VALUES as X, type JobChangeStatus as Y, PHONE_STATUS_VALUES as Z, type PhoneStatus as _, type PlayArtifactKind as a, type PlayDatasetInput as a0, type PreviousCell as a1, ProviderTransientError as a2, type ProviderTransientErrorCategory as a3, type ProviderUnavailableError as a4, type ProviderUnavailableReason as a5, type ToolExecutionErrorCategory as a6, type ToolExecutionErrorOrigin as a7, type ToolExecutionFailureV1 as a8, type ToolExecutionNetworkKind as a9, type ToolExecutionNetworkScope as aa, getProviderUnavailableReason as ab, isDeeplineExtractorTarget as ac, isProviderUnavailable as ad, isProviderWaterfallUnavailableError as ae, type PlaySandboxRuntimeDeclaration as b, type PlayCompilerManifest as c, PLAY_ARTIFACT_KINDS as d, type PlayRuntimeBackendId as e, ToolExecutionError as f, type ToolExecutionErrorOptions as g, type PlayAuthoringColumnMap as h, type PlayAuthoringColumnResolver as i, type PlayAuthoringRuntimeContext as j, type PlayAuthoringConditionalStepResolver as k, type PlayAuthoringCsvInput as l, type PlayAuthoringCsvOptions as m, type PlayAuthoringDatasetBuilder as n, type PlayAuthoringDatasetColumnDefinition as o, type PlayAuthoringDatasetColumnRunInput as p, type ToolExecuteResult as q, type PlayAuthoringReferenceLike as r, type PlayReturnObject as s, type PlayAuthoringDefineConfig as t, type PlayAuthoringDefinedPlay as u, type PlayAuthoringFetchOptions as v, type PlayAuthoringFileInput as w, type PlayAuthoringBindings as x, type PlayAuthoringCallExecution as y, type PlayAuthoringCallOptions as z };
+export { PHONE_STATUS_VALUES as $, type PlayAuthoringCallExecution as A, type PlayAuthoringCallOptions as B, type PlayAuthoringFetchResponse as C, DeeplineError as D, type PlayAuthoringInputContract as E, type PlayAuthoringStepProgramStep as F, type PlayAuthoringRuntimeStepOptions as G, type PlaySqlListenerDeclaration as H, type PlaySqlListenerEvent as I, type PlaySqlListenerOperation as J, type PlaySqlQuery as K, type PlayAuthoringStepOptions as L, type PlayAuthoringStepProgram as M, type PlayAuthoringStepProgramResolver as N, type PlayAuthoringStepResolver as O, type PlayArtifactKind as P, type PlayToolExecutionRequest as Q, type PlayAuthoringStepProgramOptions as R, DEEPLINE_EXTRACTOR_TARGETS as S, ToolExecutionError as T, DEEPLINE_EXTRACTOR_TARGET_DEFINITIONS as U, type DeeplineEmailStatusGetterValue as V, type DeeplineExtractorTarget as W, type DeeplineGetterValue as X, type DeeplineGetterValueMap as Y, JOB_CHANGE_STATUS_VALUES as Z, type JobChangeStatus as _, type PlayBundleArtifact as a, type PhoneStatus as a0, type PlayDataset as a1, type PlayDatasetInput as a2, type PreviousCell as a3, ProviderTransientError as a4, type ProviderTransientErrorCategory as a5, type ProviderUnavailableError as a6, type ProviderUnavailableReason as a7, type ToolExecutionErrorCategory as a8, type ToolExecutionErrorOrigin as a9, type ToolExecutionFailureV1 as aa, type ToolExecutionNetworkKind as ab, type ToolExecutionNetworkScope as ac, getProviderUnavailableReason as ad, isDeeplineExtractorTarget as ae, isProviderUnavailable as af, isProviderWaterfallUnavailableError as ag, type PlaySandboxRuntimeDeclaration as b, type PlayCompilerManifest as c, PLAY_ARTIFACT_KINDS as d, type PlayArtifactCompatibility as e, type PlayImportPolicy as f, type PlayPackageImport as g, type PlayRuntimeFeature as h, type ToolExecutionErrorOptions as i, type PlayAuthoringColumnMap as j, type PlayAuthoringColumnResolver as k, type PlayAuthoringRuntimeContext as l, type PlayAuthoringConditionalStepResolver as m, type PlayAuthoringCsvInput as n, type PlayAuthoringCsvOptions as o, type PlayAuthoringDatasetBuilder as p, type PlayAuthoringDatasetColumnDefinition as q, type PlayAuthoringDatasetColumnRunInput as r, type ToolExecuteResult as s, type PlayAuthoringReferenceLike as t, type PlayReturnObject as u, type PlayAuthoringDefineConfig as v, type PlayAuthoringDefinedPlay as w, type PlayAuthoringFetchOptions as x, type PlayAuthoringFileInput as y, type PlayAuthoringBindings as z };