@synergenius/flow-weaver 0.33.2 → 0.44.0

package/dist/agent/mcp-tool-server.d.ts

@@ -13,11 +13,11 @@
  *   Request:  {"name":"fw_run_command","args":{"command":"ls"}}
  *   Response: {"result":"...","isError":false}
  *
- * IMPORTANT — Transport compatibility:
+ * IMPORTANT (transport compatibility):
  *   Claude Code CLI v2.1.76+ uses NDJSON (newline-delimited JSON) for MCP
  *   stdio, NOT the Content-Length framing from the MCP SDK spec. This server
  *   auto-detects the transport on the first stdin chunk: if the first
- *   non-whitespace character is '{', it uses NDJSON; otherwise Content-Length.
+ *   non-whitespace character is '{', it uses NDJSON. Otherwise Content-Length.
  *   Responses match the detected format.
  *
  *   The CLI also sends protocolVersion "2025-11-25" (not the spec's

package/dist/agent/mcp-tool-server.js

@@ -1,210 +1,168 @@
 #!/usr/bin/env node
-/**
- * Minimal MCP stdio server that bridges tool calls to a parent process.
- *
- * Spawned by the Claude CLI via --mcp-config. Advertises tool definitions
- * and delegates execution to the parent process through a Unix domain socket.
- *
- * Environment:
- *   FW_TOOL_SOCKET - Unix socket path for tool execution RPC
- *   FW_TOOL_DEFS   - Path to JSON file with tool definitions
- *
- * Protocol over Unix socket (newline-delimited JSON):
- *   Request:  {"name":"fw_run_command","args":{"command":"ls"}}
- *   Response: {"result":"...","isError":false}
- *
- * IMPORTANT — Transport compatibility:
- *   Claude Code CLI v2.1.76+ uses NDJSON (newline-delimited JSON) for MCP
- *   stdio, NOT the Content-Length framing from the MCP SDK spec. This server
- *   auto-detects the transport on the first stdin chunk: if the first
- *   non-whitespace character is '{', it uses NDJSON; otherwise Content-Length.
- *   Responses match the detected format.
- *
- *   The CLI also sends protocolVersion "2025-11-25" (not the spec's
- *   "2024-11-05"). We echo back whatever version the client requests.
- *
- *   If these behaviors change in a future CLI version, the auto-detect
- *   and version echo should adapt automatically.
- */
-import * as net from 'node:net';
-import * as fs from 'node:fs';
-const SOCKET_PATH = process.env.FW_TOOL_SOCKET;
-const DEFS_PATH = process.env.FW_TOOL_DEFS;
+import {
+  getErrorMessage
+} from "../chunks/chunk-DUO6H5PR.js";
+import "../chunks/chunk-SEWDMQ6Q.js";
+
+// src/agent/mcp-tool-server.ts
+import * as net from "node:net";
+import * as fs from "node:fs";
+var SOCKET_PATH = process.env.FW_TOOL_SOCKET;
+var DEFS_PATH = process.env.FW_TOOL_DEFS;
 if (!SOCKET_PATH || !DEFS_PATH) {
-    process.stderr.write('mcp-tool-server: FW_TOOL_SOCKET and FW_TOOL_DEFS are required\n');
-    process.exit(1);
+  process.stderr.write("mcp-tool-server: FW_TOOL_SOCKET and FW_TOOL_DEFS are required\n");
+  process.exit(1);
 }
-// Load tool definitions (written by the bridge before spawning the CLI)
-const toolDefs = JSON.parse(fs.readFileSync(DEFS_PATH, 'utf-8'));
-// ---------------------------------------------------------------------------
-// Unix socket RPC: send tool call, receive result
-// ---------------------------------------------------------------------------
+var toolDefs = JSON.parse(fs.readFileSync(DEFS_PATH, "utf-8"));
 function callTool(name, args) {
-    return new Promise((resolve, reject) => {
-        const client = net.createConnection(SOCKET_PATH, () => {
-            client.write(JSON.stringify({ name, args }) + '\n');
-        });
-        let buf = '';
-        client.on('data', (chunk) => {
-            buf += chunk.toString();
-        });
-        client.on('end', () => {
-            try {
-                resolve(JSON.parse(buf.trim()));
-            }
-            catch {
-                reject(new Error(`Invalid response from tool bridge: ${buf}`));
-            }
-        });
-        client.on('error', (err) => reject(err));
-        // Safety timeout
-        setTimeout(() => {
-            client.destroy();
-            reject(new Error('Tool execution timed out'));
-        }, 130_000);
+  return new Promise((resolve, reject) => {
+    const client = net.createConnection(SOCKET_PATH, () => {
+      client.write(JSON.stringify({ name, args }) + "\n");
     });
+    let buf = "";
+    client.on("data", (chunk) => {
+      buf += chunk.toString();
+    });
+    client.on("end", () => {
+      try {
+        resolve(JSON.parse(buf.trim()));
+      } catch {
+        reject(new Error(`Invalid response from tool bridge: ${buf}`));
+      }
+    });
+    client.on("error", (err) => reject(err));
+    setTimeout(() => {
+      client.destroy();
+      reject(new Error("Tool execution timed out"));
+    }, 13e4);
+  });
 }
-// ---------------------------------------------------------------------------
-// MCP stdio protocol (JSON-RPC over stdin/stdout)
-// ---------------------------------------------------------------------------
-// Auto-detect transport: NDJSON (newline-delimited) or Content-Length framed.
-// Claude Code CLI uses NDJSON; standard MCP SDK uses Content-Length.
-let useNdjson = false;
-let transportDetected = false;
+var useNdjson = false;
+var transportDetected = false;
 function send(msg) {
-    const json = JSON.stringify(msg);
-    if (useNdjson) {
-        process.stdout.write(json + '\n');
-    }
-    else {
-        const header = `Content-Length: ${Buffer.byteLength(json)}\r\n\r\n`;
-        process.stdout.write(header + json);
-    }
+  const json = JSON.stringify(msg);
+  if (useNdjson) {
+    process.stdout.write(json + "\n");
+  } else {
+    const header = `Content-Length: ${Buffer.byteLength(json)}\r
+\r
+`;
+    process.stdout.write(header + json);
+  }
 }
 async function handleMessage(msg) {
-    const { method, id, params } = msg;
-    if (method === 'initialize') {
-        // Echo back the client's protocol version for compatibility
-        const clientVersion = params?.protocolVersion || '2024-11-05';
-        send({
-            jsonrpc: '2.0',
-            id,
-            result: {
-                protocolVersion: clientVersion,
-                capabilities: { tools: {} },
-                serverInfo: { name: 'fw-agent-tools', version: '1.0.0' },
-            },
-        });
-        return;
-    }
-    if (method === 'notifications/initialized') {
-        // No response needed for notifications
-        return;
-    }
-    if (method === 'tools/list') {
-        send({
-            jsonrpc: '2.0',
-            id,
-            result: { tools: toolDefs },
-        });
-        return;
-    }
-    if (method === 'tools/call') {
-        const toolName = params?.name;
-        const toolArgs = params?.arguments ?? {};
-        try {
-            const { result, isError } = await callTool(toolName, toolArgs);
-            send({
-                jsonrpc: '2.0',
-                id,
-                result: {
-                    content: [{ type: 'text', text: result }],
-                    isError,
-                },
-            });
+  const { method, id, params } = msg;
+  if (method === "initialize") {
+    const clientVersion = params?.protocolVersion || "2024-11-05";
+    send({
+      jsonrpc: "2.0",
+      id,
+      result: {
+        protocolVersion: clientVersion,
+        capabilities: { tools: {} },
+        serverInfo: { name: "fw-agent-tools", version: "1.0.0" }
+      }
+    });
+    return;
+  }
+  if (method === "notifications/initialized") {
+    return;
+  }
+  if (method === "tools/list") {
+    send({
+      jsonrpc: "2.0",
+      id,
+      result: { tools: toolDefs }
+    });
+    return;
+  }
+  if (method === "tools/call") {
+    const toolName = params?.name;
+    const toolArgs = params?.arguments ?? {};
+    try {
+      const { result, isError } = await callTool(toolName, toolArgs);
+      send({
+        jsonrpc: "2.0",
+        id,
+        result: {
+          content: [{ type: "text", text: result }],
+          isError
         }
-        catch (err) {
-            send({
-                jsonrpc: '2.0',
-                id,
-                result: {
-                    content: [{ type: 'text', text: err instanceof Error ? err.message : String(err) }],
-                    isError: true,
-                },
-            });
+      });
+    } catch (err) {
+      send({
+        jsonrpc: "2.0",
+        id,
+        result: {
+          content: [{ type: "text", text: getErrorMessage(err) }],
+          isError: true
         }
-        return;
-    }
-    // Unknown method — return empty result for requests, ignore notifications
-    if (id !== undefined) {
-        send({ jsonrpc: '2.0', id, result: {} });
+      });
     }
+    return;
+  }
+  if (id !== void 0) {
+    send({ jsonrpc: "2.0", id, result: {} });
+  }
 }
-// ---------------------------------------------------------------------------
-// Read JSON-RPC messages from stdin (auto-detect NDJSON vs Content-Length)
-// ---------------------------------------------------------------------------
-let inputBuf = '';
-process.stdin.on('data', (chunk) => {
-    inputBuf += chunk.toString();
-    // Auto-detect transport on first data: if it starts with '{', it's NDJSON
-    if (!transportDetected) {
-        const trimmed = inputBuf.trimStart();
-        if (trimmed.startsWith('{')) {
-            useNdjson = true;
-        }
-        transportDetected = true;
-    }
-    if (useNdjson) {
-        processNdjson();
-    }
-    else {
-        processContentLength();
+var inputBuf = "";
+process.stdin.on("data", (chunk) => {
+  inputBuf += chunk.toString();
+  if (!transportDetected) {
+    const trimmed = inputBuf.trimStart();
+    if (trimmed.startsWith("{")) {
+      useNdjson = true;
     }
+    transportDetected = true;
+  }
+  if (useNdjson) {
+    processNdjson();
+  } else {
+    processContentLength();
+  }
 });
 function processNdjson() {
-    const lines = inputBuf.split('\n');
-    inputBuf = lines.pop() || '';
-    for (const line of lines) {
-        if (!line.trim())
-            continue;
-        try {
-            const msg = JSON.parse(line);
-            handleMessage(msg).catch((err) => {
-                process.stderr.write(`mcp-tool-server error: ${err}\n`);
-            });
-        }
-        catch {
-            process.stderr.write(`mcp-tool-server: failed to parse line: ${line.slice(0, 200)}\n`);
-        }
+  const lines = inputBuf.split("\n");
+  inputBuf = lines.pop() || "";
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    try {
+      const msg = JSON.parse(line);
+      handleMessage(msg).catch((err) => {
+        process.stderr.write(`mcp-tool-server error: ${err}
+`);
+      });
+    } catch {
+      process.stderr.write(`mcp-tool-server: failed to parse line: ${line.slice(0, 200)}
+`);
     }
+  }
 }
 function processContentLength() {
-    while (true) {
-        const headerEnd = inputBuf.indexOf('\r\n\r\n');
-        if (headerEnd === -1)
-            break;
-        const header = inputBuf.slice(0, headerEnd);
-        const match = header.match(/Content-Length:\s*(\d+)/i);
-        if (!match) {
-            inputBuf = inputBuf.slice(headerEnd + 4);
-            continue;
-        }
-        const contentLength = parseInt(match[1], 10);
-        const bodyStart = headerEnd + 4;
-        if (inputBuf.length < bodyStart + contentLength)
-            break;
-        const body = inputBuf.slice(bodyStart, bodyStart + contentLength);
-        inputBuf = inputBuf.slice(bodyStart + contentLength);
-        try {
-            const msg = JSON.parse(body);
-            handleMessage(msg).catch((err) => {
-                process.stderr.write(`mcp-tool-server error: ${err}\n`);
-            });
-        }
-        catch {
-            process.stderr.write(`mcp-tool-server: failed to parse message: ${body}\n`);
-        }
+  while (true) {
+    const headerEnd = inputBuf.indexOf("\r\n\r\n");
+    if (headerEnd === -1) break;
+    const header = inputBuf.slice(0, headerEnd);
+    const match = header.match(/Content-Length:\s*(\d+)/i);
+    if (!match) {
+      inputBuf = inputBuf.slice(headerEnd + 4);
+      continue;
+    }
+    const contentLength = parseInt(match[1], 10);
+    const bodyStart = headerEnd + 4;
+    if (inputBuf.length < bodyStart + contentLength) break;
+    const body = inputBuf.slice(bodyStart, bodyStart + contentLength);
+    inputBuf = inputBuf.slice(bodyStart + contentLength);
+    try {
+      const msg = JSON.parse(body);
+      handleMessage(msg).catch((err) => {
+        process.stderr.write(`mcp-tool-server error: ${err}
+`);
+      });
+    } catch {
+      process.stderr.write(`mcp-tool-server: failed to parse message: ${body}
+`);
     }
+  }
 }
-process.stdin.on('end', () => process.exit(0));
-//# sourceMappingURL=mcp-tool-server.js.map
+process.stdin.on("end", () => process.exit(0));

package/dist/agent/profiles.d.ts

@@ -0,0 +1,69 @@
+export type AgentProviderKind = 'anthropic' | 'openai' | 'claude-cli';
+export interface AgentProfile {
+    name: string;
+    provider: AgentProviderKind;
+    /** Model id. Each provider has a default. */
+    model?: string;
+    /** Name of the environment variable holding the API key. */
+    apiKeyEnv?: string;
+    /** OpenAI-compatible endpoints (Ollama, Groq, vLLM…) and Anthropic proxies. */
+    baseUrl?: string;
+    /** What the model is told about itself, before the gate's own instructions. */
+    system?: string;
+    /** Model turns before the attempt is given up. Default 8. */
+    maxIterations?: number;
+    maxTokens?: number;
+    /** `claude-cli` only: the binary, when it is not `claude` on PATH. */
+    bin?: string;
+    /** Free text shown beside the profile. */
+    description?: string;
+}
+export interface AgentProfiles {
+    /** Where the profiles were looked for. */
+    file: string;
+    exists: boolean;
+    agents: Record<string, AgentProfile>;
+    default?: string;
+    /** `agentId` or `workflow/node` → profile name. */
+    gates: Record<string, string>;
+    /** What was wrong with the file, if anything. A bad file yields no profiles. */
+    errors: string[];
+}
+export interface Readiness {
+    ready: boolean;
+    /** Why it is not ready, in a sentence. */
+    reason?: string;
+    /** The environment variable that would make it ready. */
+    keyEnv?: string;
+}
+export declare const DEFAULT_MODEL: Record<AgentProviderKind, string>;
+export declare const DEFAULT_MAX_ITERATIONS = 8;
+/** The starter file the console offers when a project has none. */
+export declare const STARTER_AGENTS_YAML = "# Agent profiles: what answers a waitForAgent gate when nobody is watching.\n# Keys are read from the environment variable named here, never stored.\ndefault: assistant\nagents:\n  assistant:\n    provider: anthropic          # anthropic | openai | claude-cli\n    model: claude-sonnet-5\n    apiKeyEnv: ANTHROPIC_API_KEY\n    system: |\n      You are a careful assistant answering one step of a workflow.\n      Do exactly the task described and return only what is asked for.\n    maxIterations: 8\ngates: {}                        # agentId or workflow/node -> profile name\n";
+export declare function agentsFile(projectDir: string): string;
+/** Read the project's profiles. Never throws: a missing or broken file is reported in `errors`. */
+export declare function loadAgentProfiles(projectDir: string): AgentProfiles;
+/** The profile a paused gate should be answered by, or undefined to leave it to a person. */
+export declare function profileForGate(profiles: AgentProfiles, gate: {
+    workflow: string;
+    node: string;
+    agentId?: unknown;
+}): AgentProfile | undefined;
+/** The environment variable a profile's key comes from, if it needs one. */
+export declare function keyEnvOf(profile: AgentProfile): string | undefined;
+/** The models a provider is most likely wanted with, for a form's suggestions. */
+export declare const SUGGESTED_MODELS: Record<AgentProviderKind, string[]>;
+/** What is wrong with a profile someone typed, in sentences; empty when nothing is. */
+export declare function validateProfile(p: Partial<AgentProfile>): string[];
+/**
+ * Write the profiles back. The file is regenerated from its structure, so
+ * a comment someone wrote in it does not survive; the console says so
+ * where it offers to edit.
+ */
+export declare function saveAgentProfiles(projectDir: string, profiles: Pick<AgentProfiles, 'agents' | 'default' | 'gates'>): string;
+/**
+ * Whether a profile can run here, now: its key is in the environment, or
+ * its binary is on PATH. Checked without touching the network.
+ */
+export declare function readiness(profile: AgentProfile, env?: NodeJS.ProcessEnv): Readiness;
+//# sourceMappingURL=profiles.d.ts.map

package/dist/agent/providers/anthropic.d.ts

@@ -1,8 +1,6 @@
 /**
- * Anthropic API provider — streams messages via raw fetch + SSE parsing.
- * No SDK dependency. Uses only Node.js native fetch (available since Node 18).
- *
- * Adapted from pack-weaver's streamAnthropicWithTools.
+ * Anthropic API provider: streams messages via raw fetch + SSE parsing.
+ * No SDK dependency. Uses only Node.js native fetch.
  */
 import type { AgentProvider, AgentMessage, ToolDefinition, StreamEvent, StreamOptions } from '../types.js';
 export interface AnthropicProviderOptions {

package/dist/agent/providers/claude-cli.d.ts

@@ -1,9 +1,7 @@
 /**
- * Claude CLI provider — spawns the Claude Code CLI with stream-json output
- * and MCP bridge for tool execution.
- *
- * Adapted from platform's streamClaudeCliChat. Platform-specific dependencies
- * (spawnSandboxed, getBinPath, config) are replaced with injectable options.
+ * Claude CLI provider: spawns the Claude Code CLI with stream-json output
+ * and MCP bridge for tool execution. How the process is spawned and where
+ * the binary is found are injectable options.
  */
 import { type AgentProvider, type AgentMessage, type ToolDefinition, type StreamEvent, type StreamOptions, type ClaudeCliProviderOptions } from '../types.js';
 export declare class ClaudeCliProvider implements AgentProvider {
@@ -15,6 +13,7 @@ export declare class ClaudeCliProvider implements AgentProvider {
     private spawnFn;
     private timeout;
     private disallowedTools;
+    private allowedTools;
     constructor(options?: ClaudeCliProviderOptions);
     stream(messages: AgentMessage[], tools: ToolDefinition[], options?: StreamOptions): AsyncGenerator<StreamEvent>;
 }

package/dist/agent/providers/openai-compat.d.ts

@@ -1,5 +1,5 @@
 /**
- * OpenAI-compatible API provider — works with any service that speaks
+ * OpenAI-compatible API provider: works with any service that speaks
  * the OpenAI chat completions API: OpenAI, Groq, Together, Ollama, etc.
  *
  * No SDK dependency. Uses only Node.js native fetch + SSE parsing.
@@ -21,5 +21,12 @@ export declare class OpenAICompatProvider implements AgentProvider {
     constructor(options: OpenAICompatProviderOptions);
     stream(messages: AgentMessage[], tools: ToolDefinition[], options?: StreamOptions): AsyncGenerator<StreamEvent>;
 }
+/**
+ * The chat completions endpoint for a base URL. Servers differ in where the
+ * version lives: OpenAI is `https://api.openai.com` (+ `/v1`), Groq is
+ * `https://api.groq.com/openai/v1`, Ollama is `http://localhost:11434/v1`.
+ * A base that already ends in `/v1` gets the path appended as is.
+ */
+export declare function completionsUrl(baseUrl: string): string;
 export declare function createOpenAICompatProvider(options: OpenAICompatProviderOptions): OpenAICompatProvider;
 //# sourceMappingURL=openai-compat.d.ts.map

package/dist/agent/streaming.d.ts

@@ -1,5 +1,5 @@
 /**
- * StreamJsonParser — parses Claude CLI stream-json NDJSON output into
+ * StreamJsonParser: parses Claude CLI stream-json NDJSON output into
  * typed StreamEvent values.
  *
  * Extracted from the duplicated parsing logic in platform's claude.ts
@@ -11,7 +11,7 @@
  * - Usage tracking from message_start, message_delta, and result
  * - result event as text fallback and turn boundary
  *
- * The parser does NOT decide turn boundaries — consumers (one-shot vs
+ * The parser does NOT decide turn boundaries. Consumers (one-shot vs
  * persistent session) handle that differently.
  */
 import type { StreamEvent } from './types.js';

package/dist/agent/types.d.ts

@@ -1,7 +1,7 @@
 /**
  * Shared types for the agent loop, providers, and MCP bridge.
  *
- * All types are pure — no runtime imports, no side effects.
+ * All types are pure, with no runtime imports and no side effects.
  */
 import type { ChildProcess } from 'node:child_process';
 export type StreamEvent = {
@@ -75,12 +75,12 @@ export interface ToolEvent {
  * The suffix (per-task context) varies per call but rides on the cached prefix.
  *
  * Providers that support structured system blocks (Anthropic) use both parts.
- * Providers that only accept strings (CLI, OpenAI, platform) concatenate them.
+ * Providers that only accept strings (CLI, OpenAI-compatible) concatenate them.
  */
 export interface SplitPrompt {
-    /** Stable prefix — identical across calls. Cacheable. */
+    /** Stable prefix, identical across calls. Cacheable. */
     prefix: string;
-    /** Dynamic suffix — varies per task/call. Not cached. */
+    /** Dynamic suffix, varies per task/call. Not cached. */
     suffix: string;
 }
 /** Convert a SplitPrompt to a single string (for providers that don't support blocks). */
@@ -107,7 +107,7 @@ export interface AgentProvider {
     stream(messages: AgentMessage[], tools: ToolDefinition[], options?: StreamOptions): AsyncGenerator<StreamEvent>;
 }
 export interface McpBridge {
-    /** Path to the MCP config JSON file — pass to --mcp-config */
+    /** Path to the MCP config JSON file, passed to --mcp-config */
     configPath: string;
     /** Update the executor and event callback for a new request */
     setHandlers: (executor: ToolExecutor, onToolEvent?: (event: ToolEvent) => void) => void;
@@ -189,6 +189,12 @@ export interface ClaudeCliProviderOptions {
     timeout?: number;
     /** Disable specific built-in tools (e.g. ['Read', 'Edit', 'Write', 'Bash'] to force MCP tools). */
     disallowedTools?: string[];
+    /**
+     * The only tools the CLI may use, as `--allowed-tools`. An empty list
+     * switches every built-in tool off, leaving just the bridged ones -- the
+     * lockdown an unattended run needs (see `cli-spawn-config.ts`).
+     */
+    allowedTools?: string[];
 }
 export interface CliSessionOptions {
     /** Absolute path to the claude binary. */
@@ -201,16 +207,16 @@ export interface CliSessionOptions {
     model: string;
     /** Pre-configured MCP config path. */
     mcpConfigPath?: string;
-    /** When true, ignore user/project MCP servers — only use --mcp-config if provided. */
+    /** When true, ignore user/project MCP servers and only use --mcp-config if provided. */
     strictMcpConfig?: boolean;
     /** Disable specific built-in tools (e.g. ['Read', 'Edit', 'Write', 'Bash'] to force MCP tools). */
     disallowedTools?: string[];
     /**
-     * Restrict built-in tools via --tools. Empty string "" disables all. Comma-separated PascalCase names.
-     * Case-sensitive — use exact names: "Read", "Bash", "Edit" (not "read", "bash").
-     * MCP tools are unaffected by this flag.
+     * Built-in tools permitted through the Claude CLI's --allowed-tools option.
+     * An empty array disables every built-in tool. MCP tools remain governed by
+     * the explicit --mcp-config and --strict-mcp-config boundary.
      */
-    tools?: string;
+    allowedTools?: string[];
     /** System prompt passed to the CLI via --system-prompt. Overrides the default Claude Code prompt. */
     systemPrompt?: string;
     /**

package/dist/api/builder.d.ts

@@ -2,7 +2,7 @@
  * Builder API for fluent workflow construction
  * Provides chainable methods for creating workflows programmatically
  */
-import type { TWorkflowAST, TNodeTypeAST, TNodeInstanceAST, TPortDefinition, TPortReference } from "../ast/types.js";
+import type { TWorkflowAST, TNodeTypeAST, TNodeInstanceAST, TPortDefinition, TPortReference } from "../ast/types";
 /**
  * Fluent builder for constructing workflows programmatically
  *
@@ -94,7 +94,7 @@ export declare class WorkflowBuilder {
      * @example
      * ```typescript
      * builder.addNode('processor1', 'process');
-     * builder.addNode('processor2', 'process', { x: 100, y: 200, label: 'Main' });
+     * builder.addNode('processor2', 'process', { label: 'Main' });
      * ```
      */
     addNode(id: string, nodeType: string, config?: TNodeInstanceAST["config"]): this;
@@ -154,7 +154,7 @@ export declare class WorkflowBuilder {
      * }
      * ```
      */
-    validate(): import("./validate.js").ValidationResult;
+    validate(): import("./validate").ValidationResult;
     /**
      * Build and return the final workflow
      *

package/dist/api/compile.d.ts

@@ -1,7 +1,8 @@
-import type { TCompileResult as ASTCompileResult } from '../ast/types.js';
-import { type GenerateOptions } from './generate.js';
-import { type InPlaceGenerateOptions } from './generate-in-place.js';
-import { type ParseOptions } from './parse.js';
+import type { TCompileResult as ASTCompileResult } from '../ast/types';
+import { type GenerateOptions } from './generate';
+import { type InPlaceGenerateOptions } from './generate-in-place';
+import { type ParseOptions } from './parse';
+import { type DurableSourceProof } from '../compiler/durable-source-proof.js';
 /**
  * Options for compiling a workflow file
  */
@@ -23,6 +24,10 @@ export interface CompileOptions {
     saveAST?: boolean;
     /** Validation mode: 'draft' suppresses STUB_NODE errors */
     validationMode?: 'strict' | 'draft';
+    /** @internal Compiler-issued typed-source proof for a flattened artifact. */
+    durableSourceProof?: DurableSourceProof;
+    /** @internal Flattened source bound by durableSourceProof. */
+    durableFlattenedSource?: string;
 }
 /**
  * Result of workflow compilation

package/dist/api/durable-validation.d.ts

@@ -0,0 +1,15 @@
+import type { TWorkflowAST } from '../ast/types.js';
+export interface DurableBranchRequirement {
+    readonly nodeId: string;
+    readonly arm: 'success' | 'failure';
+}
+export interface DurableClosureAnalysis {
+    readonly hasDurableGate: boolean;
+    readonly hasDurableEffect: boolean;
+    readonly reachable: readonly TWorkflowAST[];
+}
+export declare function durableBranchPaths(workflow: TWorkflowAST): ReadonlyMap<string, readonly DurableBranchRequirement[]>;
+export declare function validateDurableClosure(root: TWorkflowAST, allWorkflows?: readonly TWorkflowAST[], options?: {
+    readonly enforce?: boolean;
+}): DurableClosureAnalysis;
+//# sourceMappingURL=durable-validation.d.ts.map