@fluidgrids/workflows 0.0.0-stage → 2026.1027.0

package/dist/ir/index.d.ts

@@ -0,0 +1,828 @@
+import { W as WorkflowDefinition, b as WorkflowInterface, a as JsonObject, P as Position } from '../types-Dr2Fn1Ax.js';
+export { C as CodeBundleActivityExport, c as CodeBundleWorkflowExport, d as ConnectionRef, E as ErrorType, e as ExecutionSettings, J as Json, L as LegacyCredentialRef, N as NodeArgs, f as NodeErrorConfig, g as NodeTimeout, R as RetryConfig, h as RunOnSetting, i as WorkflowAuthoring, j as WorkflowCode, k as WorkflowConfig, l as WorkflowEdge, m as WorkflowNode } from '../types-Dr2Fn1Ax.js';
+export { S as SourceFile, b as buildIdOf, h as hashedProjection, i as irHash, s as sourceHash } from '../hash-CZkTXPCX.js';
+import { N as NodeManifest } from '../manifest-Bp9ZJlav.js';
+export { M as ManifestField, a as ManifestHandles, b as ManifestOperation, f as fieldSchema, c as fieldsSchema, d as findManifest, i as isTriggerOperation, o as operationsOf } from '../manifest-Bp9ZJlav.js';
+export { P as PathSegment, R as RefRoot, T as TemplatePart, V as ValueRefModel, f as formatRefExpression, a as formatRefTemplate, p as parseRefExpression, b as parseTemplate } from '../expressions-DhHaqyar.js';
+
+/**
+ * JSON Schema (draft 2020-12) of the workflow IR, schema version 2.
+ *
+ * The schema is deliberately open where stored version-1 definitions vary
+ * (builder UI fields, legacy mirrors, `config` on internal nodes): every
+ * definition the service accepts today must validate unchanged. It is closed
+ * where version 2 adds structure (`interface`, `code`, `authoring`, the two new
+ * node types). `schema/ir-v2.schema.json` is generated from this object by
+ * `bun run generate`; a test keeps the two equal.
+ */
+declare const IR_V2_SCHEMA_ID = "https://docs.fluidgrids.ai/schemas/workflow-ir-v2.schema.json";
+declare const IR_V2_SCHEMA: {
+    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+    readonly $id: "https://docs.fluidgrids.ai/schemas/workflow-ir-v2.schema.json";
+    readonly title: "FluidGrids workflow definition (IR schema version 2)";
+    readonly description: "The canonical workflow definition (definitionJson). Version 2 is a strict superset of version 1: a document without schemaVersion is version 1 and validates here unchanged.";
+    readonly type: "object";
+    readonly required: readonly ["data"];
+    readonly properties: {
+        readonly schemaVersion: {
+            readonly enum: readonly [1, 2];
+            readonly description: "Absent means 1.";
+        };
+        readonly key: {
+            readonly type: "string";
+        };
+        readonly name: {
+            readonly type: "string";
+        };
+        readonly description: {
+            readonly type: readonly ["string", "null"];
+        };
+        readonly interface: {
+            readonly $ref: "#/$defs/interface";
+        };
+        readonly code: {
+            readonly $ref: "#/$defs/code";
+        };
+        readonly authoring: {
+            readonly $ref: "#/$defs/authoring";
+        };
+        readonly data: {
+            readonly type: "object";
+            readonly required: readonly ["nodes", "edges"];
+            readonly properties: {
+                readonly nodes: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly $ref: "#/$defs/node";
+                    };
+                };
+                readonly edges: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly $ref: "#/$defs/edge";
+                    };
+                };
+                readonly stickyNotes: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "object";
+                    };
+                };
+            };
+        };
+        readonly config: {
+            readonly $ref: "#/$defs/config";
+        };
+        readonly pinnedData: {
+            readonly type: "object";
+        };
+        readonly meta: {
+            readonly type: "object";
+            readonly properties: {
+                readonly layout: {
+                    readonly type: "object";
+                    readonly description: "Positions and sizes keyed by node id, preserved verbatim by every code tool.";
+                };
+            };
+        };
+        readonly tags: {
+            readonly type: "array";
+        };
+    };
+    readonly $defs: {
+        readonly position: {
+            readonly type: "object";
+            readonly required: readonly ["x", "y"];
+            readonly properties: {
+                readonly x: {
+                    readonly type: "number";
+                };
+                readonly y: {
+                    readonly type: "number";
+                };
+            };
+        };
+        readonly connectionRef: {
+            readonly type: "object";
+            readonly required: readonly ["connectionId", "adapter"];
+            readonly properties: {
+                readonly connectionId: {
+                    readonly type: "string";
+                };
+                readonly adapter: {
+                    readonly type: "string";
+                };
+            };
+        };
+        readonly retryConfig: {
+            readonly type: "object";
+            readonly properties: {
+                readonly maxRetries: {
+                    readonly type: "number";
+                    readonly minimum: 0;
+                };
+                readonly retryDelay: {
+                    readonly type: "number";
+                    readonly minimum: 0;
+                };
+                readonly backoffMultiplier: {
+                    readonly type: "number";
+                };
+                readonly maxDelay: {
+                    readonly type: "number";
+                    readonly minimum: 0;
+                };
+                readonly retryOnErrorTypes: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                    };
+                };
+                readonly nonRetryableErrorTypes: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                    };
+                };
+            };
+        };
+        readonly errorConfig: {
+            readonly type: "object";
+            readonly properties: {
+                readonly onError: {
+                    readonly type: "string";
+                };
+                readonly errorBranchId: {
+                    readonly type: "string";
+                };
+                readonly retryConfig: {
+                    readonly $ref: "#/$defs/retryConfig";
+                };
+                readonly timeout: {
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly duration: {
+                            readonly type: "number";
+                            readonly minimum: 0;
+                        };
+                        readonly onTimeout: {
+                            readonly type: "string";
+                        };
+                        readonly timeoutBranchId: {
+                            readonly type: "string";
+                        };
+                    };
+                };
+            };
+        };
+        readonly executionSettings: {
+            readonly type: "object";
+            readonly properties: {
+                readonly alwaysOutputData: {
+                    readonly type: "boolean";
+                };
+                readonly executeOnce: {
+                    readonly type: "boolean";
+                };
+                readonly runOn: {
+                    readonly type: "object";
+                };
+            };
+        };
+        readonly node: {
+            readonly type: "object";
+            readonly required: readonly ["id", "type"];
+            readonly properties: {
+                readonly id: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+                readonly type: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+                readonly label: {
+                    readonly type: "string";
+                };
+                readonly position: {
+                    readonly $ref: "#/$defs/position";
+                };
+                readonly operation_name: {
+                    readonly type: "string";
+                };
+                readonly version: {
+                    readonly type: "string";
+                };
+                readonly args: {
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly state: {
+                            readonly type: "object";
+                        };
+                        readonly context: {
+                            readonly type: "object";
+                        };
+                        readonly connections: {
+                            readonly type: "array";
+                            readonly items: {
+                                readonly $ref: "#/$defs/connectionRef";
+                            };
+                        };
+                        readonly credentials: {
+                            readonly type: "array";
+                            readonly items: {
+                                readonly type: "object";
+                            };
+                        };
+                    };
+                };
+                readonly errorConfig: {
+                    readonly $ref: "#/$defs/errorConfig";
+                };
+                readonly executionSettings: {
+                    readonly $ref: "#/$defs/executionSettings";
+                };
+                readonly disabled: {
+                    readonly type: "boolean";
+                };
+                readonly data: {
+                    readonly type: "object";
+                };
+                readonly config: {
+                    readonly type: "object";
+                };
+            };
+            readonly allOf: readonly [{
+                readonly if: {
+                    readonly properties: {
+                        readonly type: {
+                            readonly const: "internal:code-workflow";
+                        };
+                    };
+                    readonly required: readonly ["type"];
+                };
+                readonly then: {
+                    readonly required: readonly ["args"];
+                    readonly properties: {
+                        readonly args: {
+                            readonly required: readonly ["state"];
+                            readonly properties: {
+                                readonly state: {
+                                    readonly type: "object";
+                                    readonly required: readonly ["workflowFn"];
+                                    readonly properties: {
+                                        readonly workflowFn: {
+                                            readonly type: "string";
+                                            readonly minLength: 1;
+                                        };
+                                        readonly inputMapping: {};
+                                        readonly taskQueue: {
+                                            readonly type: "string";
+                                            readonly minLength: 1;
+                                        };
+                                        readonly waitForCompletion: {
+                                            readonly type: "boolean";
+                                        };
+                                        readonly timeout: {
+                                            readonly type: "number";
+                                            readonly minimum: 0;
+                                        };
+                                        readonly failOnError: {
+                                            readonly type: "boolean";
+                                        };
+                                        readonly parentClosePolicy: {
+                                            readonly enum: readonly ["TERMINATE", "ABANDON", "REQUEST_CANCEL"];
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                readonly if: {
+                    readonly properties: {
+                        readonly type: {
+                            readonly const: "internal:wait-for-signal";
+                        };
+                    };
+                    readonly required: readonly ["type"];
+                };
+                readonly then: {
+                    readonly required: readonly ["args"];
+                    readonly properties: {
+                        readonly args: {
+                            readonly required: readonly ["state"];
+                            readonly properties: {
+                                readonly state: {
+                                    readonly type: "object";
+                                    readonly required: readonly ["signalName"];
+                                    readonly properties: {
+                                        readonly signalName: {
+                                            readonly type: "string";
+                                            readonly minLength: 1;
+                                        };
+                                        readonly limitWait: {
+                                            readonly type: "object";
+                                            readonly required: readonly ["amount", "unit"];
+                                            readonly properties: {
+                                                readonly amount: {
+                                                    readonly type: "number";
+                                                    readonly exclusiveMinimum: 0;
+                                                };
+                                                readonly unit: {
+                                                    readonly type: "string";
+                                                };
+                                            };
+                                        };
+                                        readonly payloadSchema: {
+                                            readonly type: "object";
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }];
+        };
+        readonly edge: {
+            readonly type: "object";
+            readonly required: readonly ["source", "target"];
+            readonly properties: {
+                readonly id: {
+                    readonly type: "string";
+                };
+                readonly source: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+                readonly target: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+                readonly sourceHandle: {
+                    readonly type: readonly ["string", "null"];
+                };
+                readonly targetHandle: {
+                    readonly type: readonly ["string", "null"];
+                };
+                readonly type: {
+                    readonly type: "string";
+                };
+                readonly label: {};
+                readonly data: {
+                    readonly type: "object";
+                };
+                readonly mapping: {
+                    readonly type: "object";
+                };
+            };
+        };
+        readonly config: {
+            readonly type: "object";
+            readonly properties: {
+                readonly maxParallelism: {
+                    readonly type: "number";
+                    readonly minimum: 1;
+                };
+                readonly timeout: {
+                    readonly type: "number";
+                    readonly minimum: 0;
+                    readonly description: "Run timeout in seconds.";
+                };
+                readonly executionTimeout: {
+                    readonly type: readonly ["number", "string"];
+                    readonly description: "Seconds or a duration string.";
+                };
+                readonly workflowTaskTimeout: {
+                    readonly type: readonly ["number", "string"];
+                    readonly description: "Seconds or a duration string.";
+                };
+                readonly versioningBehavior: {
+                    readonly enum: readonly ["PINNED", "AUTO_UPGRADE"];
+                };
+            };
+        };
+        readonly interface: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly properties: {
+                readonly input: {
+                    readonly type: "object";
+                };
+                readonly output: {
+                    readonly type: "object";
+                };
+                readonly signals: {
+                    readonly type: "object";
+                    readonly additionalProperties: {
+                        readonly type: "object";
+                        readonly additionalProperties: false;
+                        readonly properties: {
+                            readonly payload: {
+                                readonly type: "object";
+                            };
+                            readonly description: {
+                                readonly type: "string";
+                            };
+                        };
+                    };
+                };
+                readonly queries: {
+                    readonly type: "object";
+                    readonly additionalProperties: {
+                        readonly type: "object";
+                        readonly additionalProperties: false;
+                        readonly properties: {
+                            readonly args: {
+                                readonly type: "object";
+                            };
+                            readonly result: {
+                                readonly type: "object";
+                            };
+                            readonly description: {
+                                readonly type: "string";
+                            };
+                        };
+                    };
+                };
+                readonly updates: {
+                    readonly type: "object";
+                    readonly additionalProperties: {
+                        readonly type: "object";
+                        readonly additionalProperties: false;
+                        readonly properties: {
+                            readonly args: {
+                                readonly type: "object";
+                            };
+                            readonly result: {
+                                readonly type: "object";
+                            };
+                            readonly description: {
+                                readonly type: "string";
+                            };
+                        };
+                    };
+                };
+                readonly open: {
+                    readonly type: "object";
+                    readonly additionalProperties: false;
+                    readonly properties: {
+                        readonly signals: {
+                            readonly type: "boolean";
+                        };
+                        readonly queries: {
+                            readonly type: "boolean";
+                        };
+                        readonly updates: {
+                            readonly type: "boolean";
+                        };
+                    };
+                };
+            };
+        };
+        readonly code: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["language", "buildId"];
+            readonly properties: {
+                readonly language: {
+                    readonly enum: readonly ["typescript", "python"];
+                };
+                readonly sdk: {
+                    readonly type: "string";
+                };
+                readonly buildId: {
+                    readonly type: "string";
+                    readonly pattern: "^sha256:[0-9a-f]{64}$";
+                };
+                readonly bundleRef: {
+                    readonly type: "string";
+                };
+                readonly sourceRef: {
+                    readonly type: "string";
+                };
+                readonly entry: {
+                    readonly type: "string";
+                };
+                readonly exports: {
+                    readonly type: "object";
+                    readonly additionalProperties: false;
+                    readonly properties: {
+                        readonly workflows: {
+                            readonly type: "object";
+                            readonly additionalProperties: {
+                                readonly type: "object";
+                                readonly properties: {
+                                    readonly interface: {
+                                        readonly $ref: "#/$defs/interface";
+                                    };
+                                    readonly taskQueue: {
+                                        readonly type: "string";
+                                    };
+                                };
+                            };
+                        };
+                        readonly activities: {
+                            readonly type: "object";
+                            readonly additionalProperties: {
+                                readonly type: "object";
+                                readonly properties: {
+                                    readonly taskQueue: {
+                                        readonly type: "string";
+                                    };
+                                    readonly input: {
+                                        readonly type: "object";
+                                    };
+                                    readonly output: {
+                                        readonly type: "object";
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+                readonly determinism: {
+                    readonly enum: readonly ["isolate", "worker"];
+                };
+            };
+        };
+        readonly authoring: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly properties: {
+                readonly mode: {
+                    readonly enum: readonly ["canvas", "code", "hybrid"];
+                };
+                readonly generator: {
+                    readonly enum: readonly ["builder", "sdk-ts", "sdk-py", "ai", "import", "lift"];
+                };
+                readonly generatorVersion: {
+                    readonly type: "string";
+                };
+                readonly sourceHash: {
+                    readonly type: "string";
+                    readonly pattern: "^sha256:[0-9a-f]{64}$";
+                };
+                readonly liftedFrom: {
+                    readonly type: "object";
+                    readonly additionalProperties: false;
+                    readonly properties: {
+                        readonly workflowKey: {
+                            readonly type: "string";
+                        };
+                        readonly version: {
+                            readonly type: "string";
+                        };
+                        readonly fidelity: {
+                            readonly enum: readonly ["lossless", "lossy"];
+                        };
+                    };
+                };
+            };
+        };
+    };
+};
+
+/**
+ * Rewrite legacy mirrors into canonical positions (spec 01 §2). See the module
+ * comment for the exact rules. Anything that is not a definition object is
+ * returned unchanged.
+ */
+declare function normalizeDefinition(definition: WorkflowDefinition): WorkflowDefinition;
+declare function normalizeDefinition(definition: unknown): unknown;
+
+interface ExecutorNodeView {
+    id: unknown;
+    type: unknown;
+    /** `selectedOperationName`: root, `data.operation_name`, `data.operation`. */
+    operation: string;
+    /** The root/`data.operation_name` pair the trigger detection reads on its own. */
+    legacyOperation: string;
+    version: unknown;
+    parameters: unknown;
+    connections: unknown;
+    credentials: unknown;
+    errorConfig: unknown;
+    executeOnce: boolean;
+    runOn: unknown;
+    disabled: boolean;
+    nodeDataNodeType: unknown;
+    argsContextNodeType: unknown;
+}
+/** The executor-visible values of one node. */
+declare function executorNodeView(node: unknown): ExecutorNodeView;
+/** The executor view of every node of a definition, in node order. */
+declare function executorView(definition: unknown): ExecutorNodeView[];
+
+/** One finding. `code` is stable; `message` is English. */
+interface ValidationIssue {
+    code: string;
+    message: string;
+    nodeId?: string;
+    path?: string;
+}
+interface ValidationResult {
+    valid: boolean;
+    errors: ValidationIssue[];
+    warnings: ValidationIssue[];
+    /** Every task queue the definition names, for the caller's existence check. */
+    taskQueues: string[];
+}
+interface ValidateOptions {
+    /** Spec 01 §9 rule 7: no legacy mirrors, no `${…}` templates, slug node ids. */
+    strict?: boolean;
+    /** Accept a definition with no nodes (the builder saves a blank draft first). */
+    allowEmpty?: boolean;
+    /** Rule 5: true when the workspace has this task queue. `managed` always exists. */
+    isTaskQueueKnown?: (name: string) => boolean;
+    /** Clock for schedule evaluation (rule 8). */
+    now?: Date;
+}
+/** True for a value that is a valid JSON Schema 2020-12 document. */
+declare function isValidJsonSchema(schema: unknown): boolean;
+/** Validate a workflow definition. */
+declare function validate(definition: unknown, options?: ValidateOptions): ValidationResult;
+
+/**
+ * Canonical JSON (RFC 8785, JSON Canonicalization Scheme).
+ *
+ * Object keys are sorted by UTF-16 code units, numbers use the ECMAScript
+ * shortest round-trip form, strings use the ECMAScript escaping, and there is
+ * no insignificant whitespace. The Python SDK implements the same scheme, so a
+ * graph lowered by either SDK hashes to the same `irHash`.
+ */
+declare class CanonicalJsonError extends Error {
+    constructor(message: string);
+}
+/**
+ * Serialise a JSON value canonically. Keys whose value is `undefined` are
+ * omitted (as `JSON.stringify` does); anything JSON cannot represent throws.
+ */
+declare function canonicalJson(value: unknown): string;
+/**
+ * Pretty-print a JSON value with keys in canonical order and two-space
+ * indentation, ending with a newline. Used for fixtures and files written for
+ * people to read; hashing always uses {@link canonicalJson}.
+ */
+declare function stableStringify(value: unknown): string;
+
+/**
+ * SHA-256 (FIPS 180-4) over UTF-8 text, in plain TypeScript.
+ *
+ * The IR helpers run in the service, the CLI and the browser builder, so they
+ * cannot depend on `node:crypto`, and Web Crypto is asynchronous. Hashing a
+ * definition is small and infrequent, so a synchronous implementation is the
+ * simpler contract. The test suite checks it against `node:crypto`.
+ */
+/** Hex SHA-256 digest of the UTF-8 encoding of `text`. */
+declare function sha256Hex(text: string): string;
+/** `sha256:<hex>`, the digest form stored in IR fields (`irHash`, `buildId`, `sourceHash`). */
+declare function sha256Tagged(text: string): string;
+
+declare const WORKFLOW_DOCUMENT_FORMAT = "fluidgrids.workflow";
+/** True when the definition uses anything schema version 2 added. */
+declare function isV2Definition(definition: unknown): boolean;
+/** The envelope `schemaVersion` for a definition. */
+declare function envelopeSchemaVersion(definition: unknown): 1 | 2;
+/** The definition as an export carries it: verbatim for version 1, normalised for version 2. */
+declare function exportDefinition(definition: unknown): unknown;
+/** A node the import must find installed. */
+interface WorkflowNodeReference {
+    nodeType: string;
+    nodeVersion: string | null;
+    [key: string]: unknown;
+}
+/** Fields of the export envelope, in the order the service writes them. */
+interface WorkflowExportDocument {
+    format: typeof WORKFLOW_DOCUMENT_FORMAT;
+    schemaVersion: 1 | 2;
+    exportedAt: string | Date;
+    workflowKey: string;
+    version: string;
+    name: string;
+    description: string | null;
+    definitionJson: unknown;
+    context: unknown;
+    tags: string[];
+    tagsV2: unknown;
+    icon: string | null;
+    category: string | null;
+    nodeReferences: WorkflowNodeReference[];
+}
+/** What the service knows about the version being exported. */
+type WorkflowExportInput = Omit<WorkflowExportDocument, 'format' | 'schemaVersion'>;
+/**
+ * Build the envelope with the service's field order. `definitionJson` must
+ * already be masked (`maskDefinitionSecrets`); it is passed through
+ * {@link exportDefinition}.
+ */
+declare function buildExportDocument(input: WorkflowExportInput): WorkflowExportDocument;
+/**
+ * The text committed to Git for one version, identical to
+ * `git-sync-rules.ts` `serializeWorkflowDocument`: `exportedAt` pinned to the
+ * version's creation time so pushing the same version twice gives the same bytes.
+ */
+declare function serializeWorkflowDocument(document: WorkflowExportDocument, versionCreatedAt: Date): string;
+/** A parsed envelope or bare definition. */
+interface ParsedWorkflowDocument {
+    definitionJson: Record<string, unknown>;
+    workflowKey: string | null;
+    version: string | null;
+    schemaVersion: 1 | 2 | null;
+}
+/**
+ * Read an export envelope (`schemaVersion` 1 or 2) or a bare definition, as
+ * Git restore does today. Import uses the same reader so both accept the same
+ * inputs. Returns null when the value is not a usable document.
+ */
+declare function readWorkflowDocument(value: unknown): ParsedWorkflowDocument | null;
+/** {@link readWorkflowDocument} over JSON text; null when the text is not usable JSON. */
+declare function parseWorkflowDocument(text: string): ParsedWorkflowDocument | null;
+
+interface DefinitionChange {
+    kind: 'added' | 'removed' | 'changed' | 'reordered';
+    path: string;
+    before?: unknown;
+    after?: unknown;
+}
+/** Every difference between two definitions. Empty means equal `irHash`. */
+declare function diffDefinitions(before: unknown, after: unknown): DefinitionChange[];
+
+/**
+ * Parse `workflowInputs` (one field per line, `name` or `name:type`), as the
+ * trigger manifest documents it. Unknown types leave the field untyped.
+ */
+declare function workflowInputsSchema(workflowInputs: string): JsonObject;
+/** The declared interface, or the one derived from the graph. */
+declare function deriveInterface(definition: unknown, options?: {
+    manifests?: readonly NodeManifest[];
+}): WorkflowInterface;
+
+/**
+ * Automatic layout for nodes that carry no position.
+ *
+ * The algorithm is the one the AI draft generator uses
+ * (`wspace-workflow-svc/src/modules/ai/generation/draft.ts` `layoutNodes`), so
+ * a graph built in code lands on the canvas the same way a generated draft
+ * does: a left-to-right layered layout where each node sits one column after
+ * its deepest predecessor, nodes in a column are stacked and centred around
+ * y = 0, and unreachable nodes go in the first free column.
+ */
+
+declare const LAYOUT_COLUMN_WIDTH = 300;
+declare const LAYOUT_ROW_HEIGHT = 170;
+/** Compute a position for every node id, in the order the nodes are given. */
+declare function autoLayout(nodeIds: readonly string[], edges: ReadonlyArray<{
+    source: string;
+    target: string;
+}>): Map<string, Position>;
+
+/**
+ * Durations as the IR and the SDK accept them (spec 02 §5): a number in a
+ * caller-chosen unit, a short string (`'500ms'`, `'30s'`, `'2m'`, `'3h'`,
+ * `'1d'`, `'1w'`), or ISO 8601 (`'PT2H'`, `'P3D'`, `'P1DT2H30M'`).
+ */
+/**
+ * Milliseconds for a duration, or undefined when the value is not one. A bare
+ * number is read in `numberUnit` (seconds for run-level config, milliseconds
+ * for node timeouts).
+ */
+declare function durationMs(value: unknown, numberUnit: 'ms' | 's'): number | undefined;
+
+interface ScheduleCheck {
+    ok: boolean;
+    /** Why the spec is unusable, when it is. */
+    problem?: string;
+    /** The next fire times (at most ten), ISO 8601, when computable. */
+    nextFireTimes: string[];
+}
+/** Check a schedule trigger's `spec`. `timezone` is the trigger's own timezone field, used when the spec has none. */
+declare function checkScheduleSpec(spec: unknown, options?: {
+    now?: Date;
+    timezone?: unknown;
+}): ScheduleCheck;
+
+/**
+ * Node type knowledge shared by normalisation, validation and lifting.
+ *
+ * The executor-side list mirrors `fluidgrids-workers/src/executor/internal-node-type.ts`
+ * (`INTERNAL_NODE_MAPPINGS`): exactly these types run through the internal
+ * node executor, which merges parameters from four locations. Every other type
+ * (triggers included) takes the external path, which reads `args.state` alone.
+ */
+/** Node types added by IR version 2 (spec 01 §3). */
+declare const CODE_WORKFLOW_NODE_TYPE = "internal:code-workflow";
+declare const WAIT_FOR_SIGNAL_NODE_TYPE = "internal:wait-for-signal";
+/** Internal trigger node types seeded by wspace-workflow-svc (`triggers/manifests`). */
+declare const INTERNAL_TRIGGER_TYPES: ReadonlySet<string>;
+/**
+ * True when the node goes through the internal node executor and therefore
+ * sees the merged `data < config < data.args.state < args.state` parameters.
+ * The two version-2 node types are internal by design and are treated the
+ * same way.
+ */
+declare function usesMergedParameters(type: string): boolean;
+
+export { CODE_WORKFLOW_NODE_TYPE, CanonicalJsonError, type DefinitionChange, type ExecutorNodeView, INTERNAL_TRIGGER_TYPES, IR_V2_SCHEMA, IR_V2_SCHEMA_ID, JsonObject, LAYOUT_COLUMN_WIDTH, LAYOUT_ROW_HEIGHT, NodeManifest, type ParsedWorkflowDocument, Position, type ScheduleCheck, type ValidateOptions, type ValidationIssue, type ValidationResult, WAIT_FOR_SIGNAL_NODE_TYPE, WORKFLOW_DOCUMENT_FORMAT, WorkflowDefinition, type WorkflowExportDocument, type WorkflowExportInput, WorkflowInterface, type WorkflowNodeReference, autoLayout, buildExportDocument, canonicalJson, checkScheduleSpec, deriveInterface, diffDefinitions, durationMs, envelopeSchemaVersion, executorNodeView, executorView, exportDefinition, isV2Definition, isValidJsonSchema, normalizeDefinition, parseWorkflowDocument, readWorkflowDocument, serializeWorkflowDocument, sha256Hex, sha256Tagged, stableStringify, usesMergedParameters, validate, workflowInputsSchema };