@fluidgrids/workflows 2026.1027.0 → 2026.1028.1

package/dist/types-DV-HX_Gt.d.ts

@@ -0,0 +1,380 @@
+import { J as JsonObject, E as ErrorType, a as Json } from './types-BGoPzgcl.js';
+
+/**
+ * The durable-function history contract (PLAN-B C-HIST, C-CMD, C-ABI):
+ * event types, command types, workflow-task failure causes, failures and the
+ * records the service stores in `workflow_run_events`.
+ *
+ * This module is pure data and types. It has no imports with side effects, so
+ * the runtime that runs inside the isolate can bundle it, and the service, the
+ * workers and the Python SDK read the same lists through the JSON Schemas in
+ * `schema/` (generated from `schema.ts`).
+ */
+
+/** Version of the runtime ABI and of the history file format. */
+declare const HISTORY_PROTOCOL = 1;
+/** Every value of the `type` column of `workflow_run_events`, UPPER_SNAKE (DB4). */
+declare const EVENT_TYPES: readonly ["WORKFLOW_STARTED", "WORKFLOW_TASK_SCHEDULED", "WORKFLOW_TASK_STARTED", "WORKFLOW_TASK_COMPLETED", "WORKFLOW_TASK_FAILED", "WORKFLOW_TASK_TIMED_OUT", "ACTIVITY_SCHEDULED", "ACTIVITY_STARTED", "ACTIVITY_HEARTBEAT", "ACTIVITY_COMPLETED", "ACTIVITY_FAILED", "ACTIVITY_TIMED_OUT", "ACTIVITY_CANCEL_REQUESTED", "ACTIVITY_CANCELLED", "ACTIVITY_PAUSED", "ACTIVITY_UNPAUSED", "ACTIVITY_RESET", "ACTIVITY_OPTIONS_UPDATED", "TIMER_STARTED", "TIMER_FIRED", "TIMER_CANCELLED", "SIGNAL_RECEIVED", "UPDATE_ADMITTED", "UPDATE_ACCEPTED", "UPDATE_COMPLETED", "CHILD_RUN_INITIATED", "CHILD_RUN_STARTED", "CHILD_RUN_COMPLETED", "CHILD_RUN_FAILED", "CHILD_RUN_CANCELLED", "CHILD_RUN_TERMINATED", "CHILD_RUN_TIMED_OUT", "EXTERNAL_RUN_CANCEL_REQUESTED", "EXTERNAL_RUN_CANCEL_RESOLVED", "EXTERNAL_RUN_SIGNALED", "SIDE_EFFECT_RECORDED", "LOCAL_ACTIVITY_COMPLETED", "LOCAL_ACTIVITY_FAILED", "SEARCH_ATTRIBUTES_UPSERTED", "CONTEXT_UPSERTED", "MARKER_RECORDED", "WORKFLOW_CANCEL_REQUESTED", "WORKFLOW_RESET", "VERSIONING_OVERRIDE_SET", "WORKFLOW_COMPLETED", "WORKFLOW_FAILED", "WORKFLOW_CANCELLED", "WORKFLOW_TERMINATED", "WORKFLOW_TIMED_OUT", "WORKFLOW_CONTINUED_AS_NEW"];
+type RunEventType = (typeof EVENT_TYPES)[number];
+/** Every command a workflow task may return (C-CMD), UPPER_SNAKE. */
+declare const COMMAND_TYPES: readonly ["SCHEDULE_ACTIVITY", "REQUEST_CANCEL_ACTIVITY", "START_TIMER", "CANCEL_TIMER", "START_CHILD_RUN", "SIGNAL_RUN", "RECORD_SIDE_EFFECT", "RECORD_MARKER", "COMPLETE_WORKFLOW", "FAIL_WORKFLOW", "CANCEL_WORKFLOW", "UPSERT_CONTEXT", "RECORD_LOCAL_ACTIVITY", "CONTINUE_AS_NEW", "REQUEST_CANCEL_EXTERNAL_RUN", "UPSERT_SEARCH_ATTRIBUTES", "ACCEPT_UPDATE", "REJECT_UPDATE", "COMPLETE_UPDATE"];
+type CommandType = (typeof COMMAND_TYPES)[number];
+/** Commands of the Phase B core release. */
+declare const PHASE_B_CORE_COMMANDS: ReadonlySet<CommandType>;
+/** Commands of the Phase B parity releases (defined now, enabled by the service per release). */
+declare const PHASE_B_PARITY_COMMANDS: ReadonlySet<CommandType>;
+/** Commands that are defined but refused in Phase B (`UNSUPPORTED_COMMAND`). */
+declare const PHASE_C_COMMANDS: ReadonlySet<CommandType>;
+/** Commands that end the run; one may appear, and only last in a batch. */
+declare const TERMINAL_COMMANDS: ReadonlySet<CommandType>;
+/** Why a workflow task failed (`WorkflowTaskFailureCause`). A task failure never fails the run. */
+declare const TASK_FAILURE_CAUSES: readonly ["NON_DETERMINISM", "TASK_TIMEOUT", "ISOLATE_MEMORY", "PROTOCOL_MISMATCH", "BUNDLE_UNAVAILABLE", "BUNDLE_INTEGRITY", "WORKFLOW_CODE_ERROR", "HISTORY_LIMIT", "UNSUPPORTED_COMMAND", "INVALID_REQUEST", "INTERNAL"];
+type WorkflowTaskFailureCause = (typeof TASK_FAILURE_CAUSES)[number];
+/** The shared `ErrorType` enum, as a list. */
+declare const ERROR_TYPES: readonly ErrorType[];
+/** `ExecutionKind`. */
+declare const EXECUTION_KINDS: readonly ["GRAPH", "DURABLE_FN"];
+type ExecutionKind = (typeof EXECUTION_KINDS)[number];
+/** `ParentClosePolicy`. */
+declare const PARENT_CLOSE_POLICIES: readonly ["TERMINATE", "ABANDON", "REQUEST_CANCEL"];
+type ParentClosePolicy = (typeof PARENT_CLOSE_POLICIES)[number];
+/** Activity cancellation types (11 §2.5). */
+declare const ACTIVITY_CANCELLATION_TYPES: readonly ["WAIT_CANCELLATION_COMPLETED", "TRY_CANCEL", "ABANDON"];
+type ActivityCancellationType = (typeof ACTIVITY_CANCELLATION_TYPES)[number];
+/** Child cancellation types (11 §2.5). */
+declare const CHILD_CANCELLATION_TYPES: readonly ["WAIT_CANCELLATION_COMPLETED", "WAIT_CANCELLATION_REQUESTED", "TRY_CANCEL", "ABANDON"];
+type ChildCancellationType = (typeof CHILD_CANCELLATION_TYPES)[number];
+/** Where a failure came from (11 §2.25). */
+type FailureSource = 'sdk-ts' | 'sdk-py' | 'engine' | `node:${string}`;
+/**
+ * A failure as it is stored in history and passed between the SDK, the
+ * service and the workers (11 §2.25). `type` is the free-form application
+ * type; `errorType` is always one value of the shared enum.
+ */
+interface Failure {
+    errorType: ErrorType;
+    message: string;
+    type?: string;
+    details?: Json;
+    nonRetryable?: boolean;
+    /** Overrides the retry policy's delay for the next attempt only. */
+    nextRetryDelayMs?: number;
+    category?: 'BENIGN';
+    /** For timeouts: `START_TO_CLOSE`, `SCHEDULE_TO_START`, `SCHEDULE_TO_CLOSE`, `HEARTBEAT`, `WORKFLOW_RUN`, `WORKFLOW_EXECUTION`. */
+    timeoutType?: string;
+    cause?: Failure;
+    stackTrace?: string;
+    source?: string;
+}
+/**
+ * The retry policy an activity carries (`retryConfig` plus Temporal's
+ * deny-list). `maxRetries` absent means unlimited attempts, bounded by
+ * `scheduleToCloseTimeout`.
+ */
+interface RetryPolicy {
+    maxRetries?: number;
+    /** Delay before the first retry, in milliseconds. */
+    retryDelay: number;
+    backoffMultiplier?: number;
+    /** Largest delay, in milliseconds. */
+    maxDelay?: number;
+    /** Allow-list on `errorType`. */
+    retryOnErrorTypes?: ErrorType[];
+    /** Deny-list on the free-form `Failure.type`; wins over the allow-list. */
+    nonRetryableErrorTypes?: string[];
+}
+/** One stored history event, as the service returns it (offloaded payloads already inlined). */
+interface RunEventRecord {
+    /** 1-based, gapless. */
+    seq: number;
+    type: RunEventType;
+    /** The workflow task that produced the event, for command events and task events. */
+    taskId?: string | null;
+    payload: JsonObject;
+    /** ISO 8601 timestamp. */
+    createdAt: string;
+    dedupeKey?: string | null;
+}
+/** An event the service is to append (no `seq` or timestamp yet). */
+interface RunEventDraft {
+    type: RunEventType;
+    taskId?: string;
+    payload: JsonObject;
+}
+/** Headers carried on commands and events (interceptors, Phase C). */
+type Headers = Record<string, string>;
+interface CommandBase {
+    headers?: Headers;
+}
+/** Signal and cancel targets. `workflowKey`/`workflowId` addressing is parity (11 §2.1). */
+type RunTarget = {
+    runId: string;
+} | {
+    parent: true;
+} | {
+    childId: string;
+} | {
+    workflowKey: string;
+    workflowId: string;
+};
+interface ScheduleActivityCommand extends CommandBase {
+    type: 'SCHEDULE_ACTIVITY';
+    activityId: string;
+    kind: 'node';
+    nodeType: string;
+    nodeVersion?: string;
+    operation: string;
+    args: Json;
+    connection?: string;
+    retry: RetryPolicy;
+    startToCloseTimeout?: number;
+    scheduleToCloseTimeout?: number;
+    scheduleToStartTimeout?: number;
+    heartbeatTimeout?: number;
+    cancellationType?: ActivityCancellationType;
+    priority?: number;
+    summary?: string;
+    runOn?: string;
+}
+interface RequestCancelActivityCommand extends CommandBase {
+    type: 'REQUEST_CANCEL_ACTIVITY';
+    activityId: string;
+}
+interface StartTimerCommand extends CommandBase {
+    type: 'START_TIMER';
+    timerId: string;
+    durationMs: number;
+    summary?: string;
+}
+interface CancelTimerCommand extends CommandBase {
+    type: 'CANCEL_TIMER';
+    timerId: string;
+}
+/** Child start options (11 §2.35); everything but `parentClosePolicy` is optional. */
+interface ChildRunOptions {
+    parentClosePolicy: ParentClosePolicy;
+    cancellationType?: ChildCancellationType;
+    taskQueue?: string;
+    workflowId?: string;
+    priority?: number;
+    summary?: string;
+    details?: string;
+    context?: JsonObject;
+    executionTimeout?: number;
+    runTimeout?: number;
+    workflowTaskTimeout?: number;
+    startDelay?: number;
+    [key: string]: Json | undefined;
+}
+interface StartChildRunCommand extends CommandBase {
+    type: 'START_CHILD_RUN';
+    childId: string;
+    /** Another workflow (graph or durable) by key. */
+    workflowKey?: string;
+    /** A function of the same bundle, by export name. */
+    workflowFn?: string;
+    /** `active`, `vN` or `@alias`; default `active`. */
+    version?: string;
+    input: Json;
+    options: ChildRunOptions;
+}
+interface SignalRunCommand extends CommandBase {
+    type: 'SIGNAL_RUN';
+    externalId: string;
+    target: RunTarget;
+    name: string;
+    payload: Json;
+}
+interface RecordSideEffectCommand extends CommandBase {
+    type: 'RECORD_SIDE_EFFECT';
+    sideEffectId: string;
+    value: Json;
+}
+interface RecordMarkerCommand extends CommandBase {
+    type: 'RECORD_MARKER';
+    markerId: string;
+    data: Json;
+}
+interface CompleteWorkflowCommand extends CommandBase {
+    type: 'COMPLETE_WORKFLOW';
+    output: Json;
+}
+interface FailWorkflowCommand extends CommandBase {
+    type: 'FAIL_WORKFLOW';
+    failure: Failure;
+}
+interface CancelWorkflowCommand extends CommandBase {
+    type: 'CANCEL_WORKFLOW';
+}
+interface UpsertContextCommand extends CommandBase {
+    type: 'UPSERT_CONTEXT';
+    entries: JsonObject;
+}
+interface RecordLocalActivityCommand extends CommandBase {
+    type: 'RECORD_LOCAL_ACTIVITY';
+    localActivityId: string;
+    result?: Json;
+    failure?: Failure;
+    attempts: number;
+}
+interface ContinueAsNewCommand extends CommandBase {
+    type: 'CONTINUE_AS_NEW';
+    input: Json;
+    options: JsonObject;
+}
+interface RequestCancelExternalRunCommand extends CommandBase {
+    type: 'REQUEST_CANCEL_EXTERNAL_RUN';
+    externalId: string;
+    target: RunTarget;
+}
+interface UpsertSearchAttributesCommand extends CommandBase {
+    type: 'UPSERT_SEARCH_ATTRIBUTES';
+    attributes: JsonObject;
+}
+interface AcceptUpdateCommand extends CommandBase {
+    type: 'ACCEPT_UPDATE';
+    updateId: string;
+}
+interface RejectUpdateCommand extends CommandBase {
+    type: 'REJECT_UPDATE';
+    updateId: string;
+    failure: Failure;
+}
+interface CompleteUpdateCommand extends CommandBase {
+    type: 'COMPLETE_UPDATE';
+    updateId: string;
+    result?: Json;
+    failure?: Failure;
+}
+/** One command, a flat object discriminated by `type` (DB4). */
+type WorkflowCommand = ScheduleActivityCommand | RequestCancelActivityCommand | StartTimerCommand | CancelTimerCommand | StartChildRunCommand | SignalRunCommand | RecordSideEffectCommand | RecordMarkerCommand | CompleteWorkflowCommand | FailWorkflowCommand | CancelWorkflowCommand | UpsertContextCommand | RecordLocalActivityCommand | ContinueAsNewCommand | RequestCancelExternalRunCommand | UpsertSearchAttributesCommand | AcceptUpdateCommand | RejectUpdateCommand | CompleteUpdateCommand;
+/** History caps (C-HIST). */
+interface HistoryLimit {
+    events: number;
+    bytes: number;
+}
+declare const DEFAULT_HISTORY_LIMIT: HistoryLimit;
+/** Fraction of the cap at which `continueAsNewSuggested` turns true. */
+declare const CONTINUE_AS_NEW_SUGGESTED_RATIO = 0.8;
+/** Fraction of the cap at which the next command throws `HistoryLimitExceeded`. */
+declare const HISTORY_LIMIT_EXCEEDED_RATIO = 0.95;
+/** What a task knows about its run (C-ABI `WorkflowInfoSnapshot`). */
+interface WorkflowInfoSnapshot {
+    runId: string;
+    workspaceId: string;
+    workflowKey?: string;
+    version?: number | string;
+    buildId?: string;
+    businessId?: string;
+    attempt?: number;
+    taskQueue?: string;
+    parentRunId?: string | null;
+    rootRunId?: string | null;
+    firstRunId?: string | null;
+    continuedFromRunId?: string | null;
+    lastResult?: Json;
+    lastFailure?: Failure | null;
+    startedAt?: string;
+    runStartedAt?: string;
+    historyLimit?: HistoryLimit;
+    timeouts?: {
+        executionTimeout?: number;
+        runTimeout?: number;
+        workflowTaskTimeout?: number;
+    };
+    headers?: Headers;
+    priority?: number;
+    summary?: string;
+    details?: string;
+    context?: JsonObject;
+}
+/** A built-in query (11 §2.21). Custom queries are Phase C. */
+type BuiltInQueryName = '__stack_trace' | '__enhanced_stack_trace' | '__metadata';
+declare const BUILT_IN_QUERIES: readonly BuiltInQueryName[];
+/** The input of one workflow task (C-ABI). */
+interface WorkflowTaskRequest {
+    protocol: number;
+    kind: 'task' | 'query' | 'verify';
+    workflowFn: string;
+    info: WorkflowInfoSnapshot;
+    history: RunEventRecord[];
+    /** The task's start time; the clock for new side effects only. */
+    nowMs: number;
+    localActivityResults?: Array<{
+        localActivityId: string;
+        result?: Json;
+        failure?: Failure;
+        attempts: number;
+    }>;
+    queries?: Array<{
+        queryId: string;
+        name: BuiltInQueryName;
+        args?: Json;
+    }>;
+}
+/** A local activity the task wants run before it can continue (parity). */
+interface LocalActivityRequest {
+    localActivityId: string;
+    nodeType: string;
+    operation: string;
+    args: Json;
+    connection?: string;
+    retry?: RetryPolicy;
+    startToCloseTimeout?: number;
+}
+interface TaskLogLine {
+    level: 'debug' | 'info' | 'warn' | 'error';
+    message: string;
+    data?: Json;
+}
+/** The output of one workflow task (C-ABI). */
+interface WorkflowTaskResult {
+    protocol: number;
+    outcome: 'commands' | 'failed' | 'localActivityRequested';
+    commands: WorkflowCommand[];
+    localActivityRequests?: LocalActivityRequest[];
+    queryResults?: Array<{
+        queryId: string;
+        value?: Json;
+        error?: string;
+    }>;
+    failure?: {
+        cause: WorkflowTaskFailureCause;
+        message: string;
+        stackTrace?: string;
+        seq?: number;
+        errorType?: string;
+    };
+    logs: TaskLogLine[];
+    stackTrace?: string;
+}
+/**
+ * The event each command appends (C-CMD). `REJECT_UPDATE` appends nothing: a
+ * rejected update leaves no history (11 §2.39). `RECORD_LOCAL_ACTIVITY`
+ * appends `LOCAL_ACTIVITY_COMPLETED` or `LOCAL_ACTIVITY_FAILED` by outcome.
+ */
+declare const COMMAND_EVENT_TYPES: Readonly<Record<CommandType, RunEventType | null>>;
+/**
+ * Events a command appends. During replay each one is matched against the
+ * command the code issues at the same position (spec 04 §4).
+ * `EXTERNAL_RUN_SIGNALED` is a command event only in its initiated form (no
+ * `resolved`); the service's delivery outcome is an input event of the same
+ * type with `resolved: true`.
+ */
+declare const COMMAND_EVENTS: ReadonlySet<RunEventType>;
+/** Events that deliver something to the workflow code (resolve an awaitable or run a handler). */
+declare const INPUT_EVENTS: ReadonlySet<RunEventType>;
+/** Events that end the run. */
+declare const TERMINAL_EVENTS: ReadonlySet<RunEventType>;
+/** True when the event delivers something to the code (see {@link INPUT_EVENTS}). */
+declare function isInputEvent(event: {
+    type: RunEventType;
+    payload: JsonObject;
+}): boolean;
+/** True when the event was appended for a command (see {@link COMMAND_EVENTS}). */
+declare function isCommandEvent(event: {
+    type: RunEventType;
+    payload: JsonObject;
+}): boolean;
+
+export { type StartTimerCommand as $, ACTIVITY_CANCELLATION_TYPES as A, BUILT_IN_QUERIES as B, type ChildCancellationType as C, DEFAULT_HISTORY_LIMIT as D, ERROR_TYPES as E, type Failure as F, PHASE_B_PARITY_COMMANDS as G, HISTORY_LIMIT_EXCEEDED_RATIO as H, INPUT_EVENTS as I, PHASE_C_COMMANDS as J, type RecordLocalActivityCommand as K, type LocalActivityRequest as L, type RecordMarkerCommand as M, type RecordSideEffectCommand as N, type RejectUpdateCommand as O, type ParentClosePolicy as P, type RequestCancelActivityCommand as Q, type RetryPolicy as R, type RequestCancelExternalRunCommand as S, type RunEventDraft as T, type RunEventRecord as U, type RunEventType as V, type WorkflowCommand as W, type RunTarget as X, type ScheduleActivityCommand as Y, type SignalRunCommand as Z, type StartChildRunCommand as _, type WorkflowTaskFailureCause as a, TASK_FAILURE_CAUSES as a0, TERMINAL_COMMANDS as a1, TERMINAL_EVENTS as a2, type TaskLogLine as a3, type UpsertContextCommand as a4, type UpsertSearchAttributesCommand as a5, type WorkflowInfoSnapshot as a6, type WorkflowTaskRequest as a7, type WorkflowTaskResult as a8, isCommandEvent as a9, isInputEvent as aa, type AcceptUpdateCommand as b, type ActivityCancellationType as c, type BuiltInQueryName as d, CHILD_CANCELLATION_TYPES as e, COMMAND_EVENTS as f, COMMAND_EVENT_TYPES as g, COMMAND_TYPES as h, CONTINUE_AS_NEW_SUGGESTED_RATIO as i, type CancelTimerCommand as j, type CancelWorkflowCommand as k, type ChildRunOptions as l, type CommandType as m, type CompleteUpdateCommand as n, type CompleteWorkflowCommand as o, type ContinueAsNewCommand as p, EVENT_TYPES as q, EXECUTION_KINDS as r, type ExecutionKind as s, type FailWorkflowCommand as t, type FailureSource as u, HISTORY_PROTOCOL as v, type Headers as w, type HistoryLimit as x, PARENT_CLOSE_POLICIES as y, PHASE_B_CORE_COMMANDS as z };

package/dist/{assemble-DMOuaxRI.d.ts → workflow-Bpr3vnA_.d.ts}

@@ -1,127 +1,5 @@
-import { J as Json, a as JsonObject, m as WorkflowNode, l as WorkflowEdge, d as ConnectionRef, L as LegacyCredentialRef, R as RetryConfig, g as NodeTimeout, f as NodeErrorConfig, e as ExecutionSettings, k as WorkflowConfig, b as WorkflowInterface, j as WorkflowCode, P as Position, i as WorkflowAuthoring, W as WorkflowDefinition } from './types-Dr2Fn1Ax.js';
-
-/**
- * Node operation descriptors: what a builder call needs to know about the node
- * it emits. Generated clients (`.fluidgrids/nodes.ts`) are lists of these;
- * the built-in internal nodes and triggers ship here so `nodes.internal.*` and
- * `triggers.*` work without a registry.
- */
-
-/** A file reference in node inputs and outputs. */
-interface FileRef {
-    fileId: string;
-    name?: string;
-    mimeType?: string;
-    size?: number;
-}
-declare const OPERATION_TYPES: unique symbol;
-/** One node operation. `In` and `Out` type the arguments and the output. */
-interface Operation<In = Record<string, Json>, Out = Json> {
-    readonly kind: 'operation';
-    readonly nodeType: string;
-    /** Written as the node's `version` unless the call overrides it. */
-    readonly version?: string;
-    /** Written as the node's `operation_name` unless the call overrides it. */
-    readonly operation?: string;
-    readonly role?: 'trigger';
-    /** Type-level only; never present at run time. */
-    readonly [OPERATION_TYPES]?: {
-        input: In;
-        output: Out;
-    };
-}
-/** A trigger operation. */
-type TriggerOperation<In = Record<string, Json>, Out = Json> = Operation<In, Out> & {
-    readonly role: 'trigger';
-};
-/** Describe a node operation (generated clients call this). */
-declare function op<In = Record<string, Json>, Out = Json>(nodeType: string, version?: string, operation?: string): Operation<In, Out>;
-/** Describe a trigger operation (generated clients call this). */
-declare function trigger<In = Record<string, Json>, Out = Json>(nodeType: string, version?: string, operation?: string): TriggerOperation<In, Out>;
-/** True for a value made by {@link op} or {@link trigger}. */
-declare function isOperation(value: unknown): value is Operation<unknown, unknown>;
-/** Built-in trigger nodes (`wspace-workflow-svc` `triggers/manifests`). */
-declare const triggers: {
-    readonly api: TriggerOperation<Record<string, Json>, Json>;
-    readonly manual: TriggerOperation<Record<string, Json>, Json>;
-    readonly schedule: TriggerOperation<Record<string, Json>, Json>;
-    readonly webhook: TriggerOperation<Record<string, Json>, Json>;
-    readonly form: TriggerOperation<Record<string, Json>, Json>;
-    readonly errorTrigger: TriggerOperation<Record<string, Json>, Json>;
-    readonly workflowCall: TriggerOperation<Record<string, Json>, Json>;
-    readonly rssFeed: TriggerOperation<Record<string, Json>, Json>;
-    readonly httpPoll: TriggerOperation<Record<string, Json>, Json>;
-    readonly databasePoll: TriggerOperation<Record<string, Json>, Json>;
-    readonly emailImap: TriggerOperation<Record<string, Json>, Json>;
-    readonly fileUpload: TriggerOperation<Record<string, Json>, Json>;
-    readonly recordChange: TriggerOperation<Record<string, Json>, Json>;
-    readonly stateChange: TriggerOperation<Record<string, Json>, Json>;
-};
-/** Built-in internal nodes (`wspace-workflow-svc` `internalnodes/manifests`, plus the two IR v2 nodes). */
-declare const internalNodes: {
-    readonly merge: Operation<Record<string, Json>, Json>;
-    readonly if: Operation<Record<string, Json>, Json>;
-    readonly switch: Operation<Record<string, Json>, Json>;
-    readonly loop: Operation<Record<string, Json>, Json>;
-    readonly set: Operation<Record<string, Json>, Json>;
-    readonly filter: Operation<Record<string, Json>, Json>;
-    readonly aggregate: Operation<Record<string, Json>, Json>;
-    readonly wait: Operation<Record<string, Json>, Json>;
-    readonly noop: Operation<Record<string, Json>, Json>;
-    readonly code: Operation<Record<string, Json>, Json>;
-    readonly http: Operation<Record<string, Json>, Json>;
-    readonly transform: Operation<Record<string, Json>, Json>;
-    readonly validate: Operation<Record<string, Json>, Json>;
-    readonly log: Operation<Record<string, Json>, Json>;
-    readonly error: Operation<Record<string, Json>, Json>;
-    readonly subworkflow: Operation<Record<string, Json>, Json>;
-    readonly compareDatasets: Operation<Record<string, Json>, Json>;
-    readonly splitOut: Operation<Record<string, Json>, Json>;
-    readonly limit: Operation<Record<string, Json>, Json>;
-    readonly dedupe: Operation<Record<string, Json>, Json>;
-    readonly sort: Operation<Record<string, Json>, Json>;
-    readonly dataTable: Operation<Record<string, Json>, Json>;
-    readonly respondToWebhook: Operation<Record<string, Json>, Json>;
-    readonly sendAndWait: Operation<Record<string, Json>, Json>;
-    readonly codeWorkflow: Operation<Record<string, Json>, Json>;
-    readonly waitForSignal: Operation<Record<string, Json>, Json>;
-};
-/** Node clients that need no registry: the internal nodes and `custom()`. */
-declare const nodes: {
-    readonly internal: {
-        readonly merge: Operation<Record<string, Json>, Json>;
-        readonly if: Operation<Record<string, Json>, Json>;
-        readonly switch: Operation<Record<string, Json>, Json>;
-        readonly loop: Operation<Record<string, Json>, Json>;
-        readonly set: Operation<Record<string, Json>, Json>;
-        readonly filter: Operation<Record<string, Json>, Json>;
-        readonly aggregate: Operation<Record<string, Json>, Json>;
-        readonly wait: Operation<Record<string, Json>, Json>;
-        readonly noop: Operation<Record<string, Json>, Json>;
-        readonly code: Operation<Record<string, Json>, Json>;
-        readonly http: Operation<Record<string, Json>, Json>;
-        readonly transform: Operation<Record<string, Json>, Json>;
-        readonly validate: Operation<Record<string, Json>, Json>;
-        readonly log: Operation<Record<string, Json>, Json>;
-        readonly error: Operation<Record<string, Json>, Json>;
-        readonly subworkflow: Operation<Record<string, Json>, Json>;
-        readonly compareDatasets: Operation<Record<string, Json>, Json>;
-        readonly splitOut: Operation<Record<string, Json>, Json>;
-        readonly limit: Operation<Record<string, Json>, Json>;
-        readonly dedupe: Operation<Record<string, Json>, Json>;
-        readonly sort: Operation<Record<string, Json>, Json>;
-        readonly dataTable: Operation<Record<string, Json>, Json>;
-        readonly respondToWebhook: Operation<Record<string, Json>, Json>;
-        readonly sendAndWait: Operation<Record<string, Json>, Json>;
-        readonly codeWorkflow: Operation<Record<string, Json>, Json>;
-        readonly waitForSignal: Operation<Record<string, Json>, Json>;
-    };
-    /**
-     * Any node type, including ones the registry snapshot does not know. Typed
-     * as JSON in and out.
-     */
-    readonly custom: (nodeType: string, operation?: string, version?: string) => Operation<Record<string, Json>, Json>;
-};
+import { a as Json, J as JsonObject, d as ConnectionRef, L as LegacyCredentialRef, R as RetryConfig, g as NodeTimeout, f as NodeErrorConfig, e as ExecutionSettings, m as WorkflowNode, l as WorkflowEdge, k as WorkflowConfig, W as WorkflowInterface, j as WorkflowCode } from './types-BGoPzgcl.js';
+import { h as DurableWorkflow, O as Operation } from './workflow-C2a05WUJ.js';
 
 /**
  * Typed references and predicates for the tier-1 builder (spec 02 §3).
@@ -270,7 +148,11 @@ interface CompareRef extends NodeRef {
 }
 /** Options of an explicit edge, made with {@link edge}. */
 interface EdgeOptions {
-    /** Edge id. Default: `e-<source>-<target>[-<sourceHandle>][-<targetHandle>]`; `false` writes none. */
+    /**
+     * Edge id. Default: `e-<source>-<target>[-<sourceHandle>][-<targetHandle>]`, with
+     * `-2`, `-3`, … added in declaration order when that id is already taken;
+     * `false` writes none.
+     */
     id?: string | false;
     /** Edge type. Default `deletable` (what the canvas writes); `false` writes none. */
     type?: string | false;
@@ -379,15 +261,26 @@ interface Tier1Recording {
     edgeOrder?: Array<string | number>;
     notes: RecordedNote[];
 }
+/** A `wf.codeWorkflow` node whose `workflowFn` is resolved to an export name at collection. */
+interface DurableRef {
+    nodeId: string;
+    definition: DurableWorkflow<never, unknown>;
+}
 /** The value `defineWorkflow` returns. */
 interface Tier1Workflow {
     readonly __fluidgrids: typeof WORKFLOW_MARKER;
     readonly key: string;
     readonly recording: Tier1Recording;
+    /** `wf.codeWorkflow` calls given a function; not part of the recording JSON. */
+    readonly durableRefs?: readonly DurableRef[];
 }
 /** True for a value returned by {@link defineWorkflow}. */
 declare function isTier1Workflow(value: unknown): value is Tier1Workflow;
-/** Default edge id, the scheme the AI draft generator uses. */
+/**
+ * Default edge id, the scheme the AI draft generator uses. Ids may contain `-`,
+ * so two edges can share a default id (`a` to `b-c` and `a-b` to `c`); the
+ * builder then gives the later edges `-2`, `-3`, … in declaration order.
+ */
 declare function defaultEdgeId(source: string, target: string, sourceHandle?: string, targetHandle?: string): string;
 /** Options of `wf.if`. */
 interface IfOptions extends NodeOptions {
@@ -422,6 +315,27 @@ interface WaitForSignalOptions extends NodeOptions {
         amount: number;
         unit: string;
     };
+    /** `limitWaitUntil`: an absolute deadline (ISO 8601). Give `limit` or `until`, not both. */
+    until?: string | Date;
+    /** `first` (default) resumes with one signal; `all` collects every buffered one. */
+    consume?: 'first' | 'all';
+}
+/** Options of `wf.codeWorkflow`. */
+interface CodeWorkflowOptions extends NodeOptions {
+    /** `inputMapping`; default passthrough. */
+    input?: ArgValue;
+    /** Default `managed` (the only queue in Phase B). */
+    taskQueue?: string;
+    /** Default true. */
+    waitForCompletion?: boolean;
+    /** Node-level timeout in seconds; 0 or absent means none. */
+    timeoutSeconds?: number;
+    failOnError?: boolean;
+    /**
+     * Default (DB13, applied by the service when absent): `TERMINATE` when the
+     * node waits for completion, `ABANDON` when it does not.
+     */
+    parentClosePolicy?: 'TERMINATE' | 'ABANDON' | 'REQUEST_CANCEL';
 }
 /** Options of `wf.subworkflow`. */
 interface SubworkflowOptions extends NodeOptions {
@@ -447,8 +361,12 @@ declare class WorkflowBuilder {
     private readonly edges;
     private readonly notes;
     private readonly ids;
+    /** Ids given explicitly; a second edge with the same explicit id is an error. */
     private readonly edgeIds;
+    /** Edges whose id is the default, as indices into `edges`, with the unsuffixed default id. */
+    private readonly defaultIds;
     private edgeOrder;
+    private readonly durableRefs;
     constructor(autoIds: boolean);
     /** A reference to a node by id, for nodes declared later in the source. */
     ref(id: string): NodeRef;
@@ -476,6 +394,14 @@ declare class WorkflowBuilder {
     sendAndWait(options: NodeOptions): ApprovalRef;
     /** `internal:subworkflow`. */
     subworkflow(options: SubworkflowOptions): NodeRef;
+    /**
+     * `internal:code-workflow`: run a tier-2 function of this project as a
+     * durable child run. `fn` is a `workflow()` value (its export name is
+     * resolved when the bundle is collected) or an export name.
+     */
+    codeWorkflow(fn: DurableWorkflow<never, unknown> | string, options?: CodeWorkflowOptions): NodeRef;
+    /** The `wf.codeWorkflow` calls that named a function. */
+    durableReferences(): DurableRef[];
     /** `internal:validate`. */
     validate(options: NodeOptions): ValidateRef;
     /** `internal:compare-datasets`. */
@@ -525,45 +451,17 @@ declare class WorkflowBuilder {
     finish(key: string, document: JsonObject): Tier1Recording;
     private claimId;
     private resolveId;
+    /**
+     * Give every edge declared without an id its default id. Explicit ids are
+     * claimed first, so a default never takes an id the code names; a default that
+     * is taken gets `-2`, `-3`, … in declaration order. The result depends only on
+     * the builder calls.
+     */
+    private assignDefaultEdgeIds;
     private addEdge;
     private add;
 }
 /** Define a tier-1 workflow. The callback runs once, immediately. */
 declare function defineWorkflow(options: WorkflowOptions, build: (wf: WorkflowBuilder) => void): Tier1Workflow;
 
-declare const LAYOUT_FORMAT = "fluidgrids.layout";
-declare const LAYOUT_FORMAT_VERSION = 1;
-/**
- * The layout sidecar (`workflows/<key>.layout.json`): canvas positions, sticky
- * notes and `meta.layout`, kept out of the code so it stays readable.
- */
-interface LayoutSidecar {
-    format: typeof LAYOUT_FORMAT;
-    formatVersion: typeof LAYOUT_FORMAT_VERSION;
-    positions: Record<string, Position>;
-    stickyNotes?: JsonObject[];
-    metaLayout?: JsonObject;
-}
-/** How connection names in code resolve to connection references. */
-type ConnectionResolver = Readonly<Record<string, ConnectionRef>> | ((name: string) => ConnectionRef | undefined);
-interface AssembleOptions {
-    layout?: LayoutSidecar;
-    connections?: ConnectionResolver;
-    /** TEST-only pinned data (`workflows/<key>.pinned.json`). */
-    pinnedData?: JsonObject;
-    /** Provenance; defaults to `{ mode: 'canvas', generator: 'sdk-ts', generatorVersion }`. */
-    authoring?: WorkflowAuthoring;
-}
-/** Connection names used in code that the target workspace does not have. */
-declare class UnresolvedConnectionsError extends Error {
-    readonly names: string[];
-    constructor(names: string[]);
-}
-/** Validate a parsed layout sidecar. */
-declare function parseLayoutSidecar(value: unknown): LayoutSidecar;
-/** Assemble IR v2 from a recording. */
-declare function assembleRecording(recording: Tier1Recording, options?: AssembleOptions): WorkflowDefinition;
-/** Lower a tier-1 workflow to IR v2 (spec 10 §1 `toIR`). */
-declare function toIR(workflow: Tier1Workflow, options?: AssembleOptions): WorkflowDefinition;
-
-export { defineWorkflow as $, type AfterInput as A, BuilderError as B, type CompareRef as C, type SwitchOptions as D, type EdgeOptions as E, type FileRef as F, type SwitchRef as G, type HandleRef as H, type IfOptions as I, type Tier1Workflow as J, type TriggerOperation as K, LAYOUT_FORMAT as L, type MergeOptions as M, type NodeOptions as N, type OnErrorOption as O, PREDICATE_OPERATORS as P, WorkflowBuilder as Q, RECORDING_FORMAT as R, type SignalWaitRef as S, type Tier1Recording as T, UnresolvedConnectionsError as U, type ValidateRef as V, type WaitForSignalOptions as W, type WorkflowOptions as X, and as Y, assembleRecording as Z, defaultEdgeId as _, type AnyRef as a, edge as a0, expr as a1, internalNodes as a2, isOperation as a3, isTier1Workflow as a4, nodes as a5, op as a6, or as a7, parseLayoutSidecar as a8, toIR as a9, trigger as aa, triggers as ab, type ApprovalRef as b, type ArgValue as c, type ArgsOf as d, type AssembleOptions as e, type ConditionGroup as f, type ConditionRule as g, type ConnectionResolver as h, type EdgeSource as i, type EdgeSpec as j, type IfRef as k, LAYOUT_FORMAT_VERSION as l, type LayoutSidecar as m, type LoopOptions as n, type LoopRef as o, type NodeRef as p, type NoteOptions as q, type Operation as r, type OutputRef as s, type Predicate as t, type PredicateMethods as u, RECORDING_FORMAT_VERSION as v, type RecordedNode as w, type RecordedNote as x, type RuleValue as y, type SubworkflowOptions as z };
+export { type AfterInput as A, BuilderError as B, type CodeWorkflowOptions as C, type DurableRef as D, type EdgeOptions as E, and as F, defaultEdgeId as G, type HandleRef as H, type IfOptions as I, defineWorkflow as J, edge as K, type LoopOptions as L, type MergeOptions as M, type NodeOptions as N, type OnErrorOption as O, PREDICATE_OPERATORS as P, expr as Q, RECORDING_FORMAT as R, type SignalWaitRef as S, type Tier1Recording as T, isTier1Workflow as U, type ValidateRef as V, type WaitForSignalOptions as W, or as X, type AnyRef as a, type ApprovalRef as b, type ArgValue as c, type ArgsOf as d, type CompareRef as e, type ConditionGroup as f, type ConditionRule as g, type EdgeSource as h, type EdgeSpec as i, type IfRef as j, type LoopRef as k, type NodeRef as l, type NoteOptions as m, type OutputRef as n, type Predicate as o, type PredicateMethods as p, RECORDING_FORMAT_VERSION as q, type RecordedNode as r, type RecordedNote as s, type RuleValue as t, type SubworkflowOptions as u, type SwitchOptions as v, type SwitchRef as w, type Tier1Workflow as x, WorkflowBuilder as y, type WorkflowOptions as z };