@synergenius/flow-weaver 0.2.0

package/dist/sugar-optimizer.js

@@ -0,0 +1,387 @@
+/**
+ * Sugar Optimizer - Auto-detect @path routes from connections.
+ *
+ * Analyzes control-flow connections and identifies routes through the graph
+ * that can be expressed as @path macros. @connect is the escape hatch for
+ * connections that @path can't cover.
+ */
+import { isControlFlowPort } from './constants.js';
+// =============================================================================
+// Path Validation (for stale macro detection during round-trip)
+// =============================================================================
+/**
+ * Validate that a @path macro's control-flow connections still exist
+ * in the actual connection set. Also checks that all step nodes exist
+ * as instances (or are Start/Exit).
+ *
+ * Returns true if the path is still valid, false if it should be dropped.
+ */
+export function validatePathMacro(path, connections, instances) {
+    const instanceIds = new Set(instances.map(inst => inst.id));
+    // Check all step nodes exist as instances (or are Start/Exit)
+    for (const step of path.steps) {
+        if (step.node === 'Start' || step.node === 'Exit')
+            continue;
+        if (!instanceIds.has(step.node))
+            return false;
+    }
+    // Build a quick lookup set for unscoped connections
+    const connKeys = new Set();
+    for (const conn of connections) {
+        if (!conn.from.scope && !conn.to.scope) {
+            connKeys.add(`${conn.from.node}.${conn.from.port}->${conn.to.node}.${conn.to.port}`);
+        }
+    }
+    // For each consecutive pair, compute expected control-flow connection
+    for (let i = 0; i < path.steps.length - 1; i++) {
+        const current = path.steps[i];
+        const next = path.steps[i + 1];
+        const route = current.route || 'ok';
+        let expectedKey;
+        if (current.node === 'Start') {
+            expectedKey = `Start.execute->${next.node}.execute`;
+        }
+        else if (next.node === 'Exit') {
+            if (route === 'fail') {
+                expectedKey = `${current.node}.onFailure->Exit.onFailure`;
+            }
+            else {
+                expectedKey = `${current.node}.onSuccess->Exit.onSuccess`;
+            }
+        }
+        else {
+            if (route === 'fail') {
+                expectedKey = `${current.node}.onFailure->${next.node}.execute`;
+            }
+            else {
+                expectedKey = `${current.node}.onSuccess->${next.node}.execute`;
+            }
+        }
+        if (!connKeys.has(expectedKey)) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Filter existing macros, removing any @path macros whose control-flow
+ * connections no longer exist in the connection set.
+ * Non-path macros are passed through unchanged.
+ */
+export function filterStaleMacros(macros, connections, instances) {
+    return macros.filter(macro => {
+        if (macro.type !== 'path')
+            return true;
+        return validatePathMacro(macro, connections, instances);
+    });
+}
+/**
+ * Detect @path routes from a set of connections.
+ *
+ * Algorithm:
+ * 1. Build control-flow adjacency from unscoped connections
+ * 2. DFS from Start to enumerate all Start-to-Exit routes
+ * 3. Validate data connections for each candidate (scope walking safety)
+ * 4. Greedy route selection to cover all control-flow edges
+ */
+export function detectSugarPatterns(connections, instances, existingMacros, nodeTypes, startPorts, exitPorts) {
+    const coveredByExistingMacro = buildExistingMacroCoverage(existingMacros);
+    // Filter out scoped connections — never optimize those
+    const unscopedConns = connections.filter((c) => !c.from.scope && !c.to.scope);
+    // Build lookup helpers
+    const instanceMap = new Map(instances.map((inst) => [inst.id, inst]));
+    const nodeTypeMap = new Map();
+    for (const nt of nodeTypes) {
+        nodeTypeMap.set(nt.name, nt);
+        if (nt.functionName !== nt.name) {
+            nodeTypeMap.set(nt.functionName, nt);
+        }
+    }
+    const getNodeType = (nodeId) => {
+        const inst = instanceMap.get(nodeId);
+        if (!inst)
+            return undefined;
+        return nodeTypeMap.get(inst.nodeType);
+    };
+    const getOutputPorts = (nodeId) => {
+        if (nodeId === 'Start')
+            return startPorts;
+        const nt = getNodeType(nodeId);
+        return nt?.outputs || {};
+    };
+    const getInputPorts = (nodeId) => {
+        if (nodeId === 'Exit')
+            return exitPorts;
+        const nt = getNodeType(nodeId);
+        return nt?.inputs || {};
+    };
+    // ---- Step 1: Build control-flow adjacency ----
+    // adj[node] = { ok?: targetNode, fail?: targetNode }
+    // Only single-target edges are pathable (multi-target needs @connect)
+    const adj = new Map();
+    const multiTargetPorts = new Set(); // "node.port" keys with multiple targets
+    for (const conn of unscopedConns) {
+        const { from, to } = conn;
+        let edgeNode;
+        let edgeRoute;
+        // Start.execute -> X.execute
+        if (from.node === 'Start' && from.port === 'execute' && to.port === 'execute') {
+            edgeNode = 'Start';
+            edgeRoute = 'ok';
+        }
+        // X.onSuccess -> Exit.onSuccess
+        else if (to.node === 'Exit' && from.port === 'onSuccess' && to.port === 'onSuccess') {
+            edgeNode = from.node;
+            edgeRoute = 'ok';
+        }
+        // X.onFailure -> Exit.onFailure
+        else if (to.node === 'Exit' && from.port === 'onFailure' && to.port === 'onFailure') {
+            edgeNode = from.node;
+            edgeRoute = 'fail';
+        }
+        // X.onSuccess -> Y.execute
+        else if (from.port === 'onSuccess' && to.port === 'execute') {
+            edgeNode = from.node;
+            edgeRoute = 'ok';
+        }
+        // X.onFailure -> Y.execute
+        else if (from.port === 'onFailure' && to.port === 'execute') {
+            edgeNode = from.node;
+            edgeRoute = 'fail';
+        }
+        if (edgeNode === undefined || edgeRoute === undefined)
+            continue;
+        const portKey = `${edgeNode}.${edgeRoute}`;
+        if (!adj.has(edgeNode)) {
+            adj.set(edgeNode, {});
+        }
+        const entry = adj.get(edgeNode);
+        if (entry[edgeRoute] !== undefined && entry[edgeRoute] !== to.node) {
+            // Multiple targets for same port — not pathable
+            multiTargetPorts.add(portKey);
+            delete entry[edgeRoute];
+        }
+        else if (!multiTargetPorts.has(portKey)) {
+            entry[edgeRoute] = to.node;
+        }
+    }
+    // ---- Step 2: DFS to enumerate Start-to-Exit routes ----
+    const candidateRoutes = [];
+    const MAX_ROUTES = 20; // Sanity limit for complex graphs
+    function dfs(node, path, visited) {
+        if (candidateRoutes.length >= MAX_ROUTES)
+            return;
+        if (node === 'Exit') {
+            path.push({ node: 'Exit' });
+            candidateRoutes.push([...path]);
+            path.pop();
+            return;
+        }
+        if (visited.has(node))
+            return; // Cycle protection
+        visited.add(node);
+        const edges = adj.get(node);
+        if (!edges) {
+            visited.delete(node);
+            return;
+        }
+        // Try ok edge
+        if (edges.ok && !coveredByExistingMacro.has(edges.ok === 'Exit' ? '' : edges.ok)) {
+            const step = node === 'Start' ? { node: 'Start' } : { node };
+            path.push(step);
+            dfs(edges.ok, path, visited);
+            path.pop();
+        }
+        // Try fail edge
+        if (edges.fail && !coveredByExistingMacro.has(edges.fail === 'Exit' ? '' : edges.fail)) {
+            const step = { node, route: 'fail' };
+            path.push(step);
+            dfs(edges.fail, path, visited);
+            path.pop();
+        }
+        visited.delete(node);
+    }
+    // Only start DFS if Start is not covered by existing macros
+    if (!coveredByExistingMacro.has('Start')) {
+        dfs('Start', [], new Set());
+    }
+    // ---- Step 3: Validate data connections for each candidate ----
+    // Simulate scope walking and verify expected data connections exist
+    const connKeySet = new Set();
+    for (const conn of unscopedConns) {
+        connKeySet.add(`${conn.from.node}.${conn.from.port}->${conn.to.node}.${conn.to.port}`);
+    }
+    const validRoutes = candidateRoutes.filter(route => {
+        // Path needs at least 2 steps
+        if (route.length < 2)
+            return false;
+        // Simulate scope walking for data ports
+        for (let i = 0; i < route.length - 1; i++) {
+            const nextId = route[i + 1].node;
+            if (nextId === 'Exit')
+                continue;
+            const nextInputs = getInputPorts(nextId);
+            for (const [inputName] of Object.entries(nextInputs)) {
+                if (isControlFlowPort(inputName))
+                    continue;
+                // Walk backward through route steps to find nearest ancestor with same-name output
+                for (let j = i; j >= 0; j--) {
+                    const ancestorId = route[j].node;
+                    const ancestorOutputs = getOutputPorts(ancestorId);
+                    if (inputName in ancestorOutputs && !isControlFlowPort(inputName)) {
+                        // Scope walking would create this connection — verify it exists
+                        const key = `${ancestorId}.${inputName}->${nextId}.${inputName}`;
+                        if (!connKeySet.has(key)) {
+                            return false; // Path would create a connection that doesn't exist
+                        }
+                        break;
+                    }
+                }
+            }
+        }
+        return true;
+    });
+    const allCFEdges = new Set();
+    for (const conn of unscopedConns) {
+        if (isControlFlowPort(conn.from.port) || conn.from.port === 'execute') {
+            if (isControlFlowPort(conn.to.port) || conn.to.port === 'execute') {
+                // Only include edges that are pathable (single target)
+                const portKey = conn.from.node === 'Start' ? 'Start.ok'
+                    : conn.from.port === 'onSuccess' ? `${conn.from.node}.ok`
+                        : conn.from.port === 'onFailure' ? `${conn.from.node}.fail`
+                            : null;
+                if (portKey && !multiTargetPorts.has(portKey)) {
+                    allCFEdges.add(`${conn.from.node}.${conn.from.port}->${conn.to.node}.${conn.to.port}`);
+                }
+            }
+        }
+    }
+    // Remove edges already covered by existing macros
+    for (const macro of existingMacros) {
+        if (macro.type === 'path') {
+            for (let i = 0; i < macro.steps.length - 1; i++) {
+                const current = macro.steps[i];
+                const next = macro.steps[i + 1];
+                const route = current.route || 'ok';
+                let key;
+                if (current.node === 'Start') {
+                    key = `Start.execute->${next.node}.execute`;
+                }
+                else if (next.node === 'Exit') {
+                    const fromPort = route === 'fail' ? 'onFailure' : 'onSuccess';
+                    const toPort = route === 'fail' ? 'onFailure' : 'onSuccess';
+                    key = `${current.node}.${fromPort}->Exit.${toPort}`;
+                }
+                else {
+                    const fromPort = route === 'fail' ? 'onFailure' : 'onSuccess';
+                    key = `${current.node}.${fromPort}->${next.node}.execute`;
+                }
+                allCFEdges.delete(key);
+            }
+        }
+    }
+    // Compute edges covered by each candidate route
+    function getRouteEdges(route) {
+        const edges = [];
+        for (let i = 0; i < route.length - 1; i++) {
+            const current = route[i];
+            const next = route[i + 1];
+            const routeVal = current.route || 'ok';
+            let key;
+            if (current.node === 'Start') {
+                key = `Start.execute->${next.node}.execute`;
+            }
+            else if (next.node === 'Exit') {
+                const fromPort = routeVal === 'fail' ? 'onFailure' : 'onSuccess';
+                const toPort = routeVal === 'fail' ? 'onFailure' : 'onSuccess';
+                key = `${current.node}.${fromPort}->Exit.${toPort}`;
+            }
+            else {
+                const fromPort = routeVal === 'fail' ? 'onFailure' : 'onSuccess';
+                key = `${current.node}.${fromPort}->${next.node}.execute`;
+            }
+            edges.push(key);
+        }
+        return edges;
+    }
+    // Sort by length (longest first) for greedy selection
+    const sortedRoutes = [...validRoutes].sort((a, b) => b.length - a.length);
+    const selectedPaths = [];
+    const coveredEdges = new Set();
+    for (const route of sortedRoutes) {
+        const routeEdges = getRouteEdges(route);
+        const newEdges = routeEdges.filter(e => allCFEdges.has(e) && !coveredEdges.has(e));
+        if (newEdges.length > 0) {
+            selectedPaths.push({
+                type: 'path',
+                steps: route.map(s => s.route ? { node: s.node, route: s.route } : { node: s.node }),
+            });
+            for (const e of routeEdges) {
+                coveredEdges.add(e);
+            }
+        }
+    }
+    return { paths: selectedPaths };
+}
+/**
+ * Check if a connection is covered by detected sugar and should be omitted from @connect output.
+ */
+export function isConnectionCoveredBySugar(conn, sugar) {
+    // Scoped connections are never covered
+    if (conn.from.scope || conn.to.scope)
+        return false;
+    for (const path of sugar.paths) {
+        const steps = path.steps;
+        const fromIdx = steps.findIndex(s => s.node === conn.from.node);
+        const toIdx = steps.findIndex(s => s.node === conn.to.node);
+        if (fromIdx === -1 || toIdx === -1 || fromIdx >= toIdx)
+            continue;
+        // Control flow: check consecutive pairs
+        if (toIdx === fromIdx + 1) {
+            const route = steps[fromIdx].route || 'ok';
+            // Start.execute -> next.execute
+            if (conn.from.node === 'Start' && conn.from.port === 'execute' && conn.to.port === 'execute')
+                return true;
+            // To Exit: route determines which Exit port
+            if (conn.to.node === 'Exit') {
+                if (route === 'fail' && conn.from.port === 'onFailure' && conn.to.port === 'onFailure')
+                    return true;
+                if (route === 'ok' && conn.from.port === 'onSuccess' && conn.to.port === 'onSuccess')
+                    return true;
+            }
+            // Normal: onSuccess/onFailure -> execute
+            if (route === 'fail' && conn.from.port === 'onFailure' && conn.to.port === 'execute')
+                return true;
+            if (route === 'ok' && conn.from.port === 'onSuccess' && conn.to.port === 'execute')
+                return true;
+        }
+        // Data: same-name non-control-flow, from before to, to is not Exit
+        if (conn.to.node !== 'Exit' &&
+            !isControlFlowPort(conn.from.port) &&
+            !isControlFlowPort(conn.to.port) &&
+            conn.from.port === conn.to.port) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Build a set of node IDs that are already covered by user-written macros.
+ * These nodes should not be included in auto-detected patterns.
+ */
+function buildExistingMacroCoverage(macros) {
+    const covered = new Set();
+    for (const macro of macros) {
+        if (macro.type === 'map') {
+            covered.add(macro.instanceId);
+            covered.add(macro.childId);
+        }
+        else if (macro.type === 'path') {
+            for (const step of macro.steps) {
+                covered.add(step.node);
+            }
+        }
+    }
+    return covered;
+}
+//# sourceMappingURL=sugar-optimizer.js.map

package/dist/testing/assertions.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Fluent assertion helpers for agent workflow test results.
+ *
+ * Usage:
+ * ```typescript
+ * import { expectAgentResult } from 'flow-weaver/testing';
+ *
+ * const result = await myAgentWorkflow(true, { query: 'hello' });
+ *
+ * expectAgentResult(result)
+ *   .toHaveSucceeded()
+ *   .toHaveOutput('answer', 'hello world')
+ *   .toNotHaveOutput('error');
+ * ```
+ */
+import type { MockLlmProvider } from './mock-llm.js';
+export interface AgentResultAssertions {
+    /** Assert the workflow completed successfully (onSuccess === true) */
+    toHaveSucceeded(): AgentResultAssertions;
+    /** Assert the workflow failed (onFailure === true) */
+    toHaveFailed(): AgentResultAssertions;
+    /** Assert a specific output port has a value */
+    toHaveOutput(portName: string, expectedValue?: unknown): AgentResultAssertions;
+    /** Assert a specific output port is absent, null, or undefined */
+    toNotHaveOutput(portName: string): AgentResultAssertions;
+}
+/**
+ * Create fluent assertions for an agent workflow result.
+ *
+ * @param result - The workflow result object (record of output port values)
+ */
+export declare function expectAgentResult(result: Record<string, unknown>): AgentResultAssertions;
+export interface MockLlmAssertions {
+    /** Assert the LLM was called exactly N times */
+    toHaveBeenCalledTimes(n: number): MockLlmAssertions;
+    /** Assert at least one call included a tool call with the given name */
+    toHaveUsedTool(toolName: string): MockLlmAssertions;
+    /** Assert no call included a tool call with the given name */
+    toNotHaveUsedTool(toolName: string): MockLlmAssertions;
+    /** Assert total tokens are below a budget */
+    toHaveTokenUsageBelow(maxTokens: number): MockLlmAssertions;
+    /** Assert a specific call's messages contain a message matching a pattern */
+    toHaveReceivedMessage(pattern: string | RegExp, callIndex?: number): MockLlmAssertions;
+}
+/**
+ * Create fluent assertions for a mock LLM provider's recorded calls.
+ *
+ * @param mockLlm - The mock provider to assert against
+ */
+export declare function expectMockLlm(mockLlm: MockLlmProvider): MockLlmAssertions;
+//# sourceMappingURL=assertions.d.ts.map

package/dist/testing/assertions.js

@@ -0,0 +1,127 @@
+/**
+ * Fluent assertion helpers for agent workflow test results.
+ *
+ * Usage:
+ * ```typescript
+ * import { expectAgentResult } from 'flow-weaver/testing';
+ *
+ * const result = await myAgentWorkflow(true, { query: 'hello' });
+ *
+ * expectAgentResult(result)
+ *   .toHaveSucceeded()
+ *   .toHaveOutput('answer', 'hello world')
+ *   .toNotHaveOutput('error');
+ * ```
+ */
+/**
+ * Create fluent assertions for an agent workflow result.
+ *
+ * @param result - The workflow result object (record of output port values)
+ */
+export function expectAgentResult(result) {
+    const assertions = {
+        toHaveSucceeded() {
+            if (result.onSuccess !== true) {
+                throw new Error(`Expected workflow to succeed (onSuccess === true), but got onSuccess=${result.onSuccess}, onFailure=${result.onFailure}`);
+            }
+            return assertions;
+        },
+        toHaveFailed() {
+            if (result.onFailure !== true) {
+                throw new Error(`Expected workflow to fail (onFailure === true), but got onSuccess=${result.onSuccess}, onFailure=${result.onFailure}`);
+            }
+            return assertions;
+        },
+        toHaveOutput(portName, expectedValue) {
+            if (!(portName in result)) {
+                throw new Error(`Expected output port '${portName}' to exist, but result only has: ${Object.keys(result).join(', ')}`);
+            }
+            if (result[portName] === null || result[portName] === undefined) {
+                throw new Error(`Expected output port '${portName}' to have a value, but got ${result[portName]}`);
+            }
+            if (expectedValue !== undefined) {
+                const actual = result[portName];
+                const expected = expectedValue;
+                if (typeof expected === 'object' && expected !== null) {
+                    // Deep comparison for objects
+                    if (JSON.stringify(actual) !== JSON.stringify(expected)) {
+                        throw new Error(`Expected output '${portName}' to equal ${JSON.stringify(expected)}, but got ${JSON.stringify(actual)}`);
+                    }
+                }
+                else if (actual !== expected) {
+                    throw new Error(`Expected output '${portName}' to equal ${JSON.stringify(expected)}, but got ${JSON.stringify(actual)}`);
+                }
+            }
+            return assertions;
+        },
+        toNotHaveOutput(portName) {
+            if (portName in result && result[portName] !== null && result[portName] !== undefined) {
+                throw new Error(`Expected output port '${portName}' to be absent or null, but got ${JSON.stringify(result[portName])}`);
+            }
+            return assertions;
+        },
+    };
+    return assertions;
+}
+/**
+ * Create fluent assertions for a mock LLM provider's recorded calls.
+ *
+ * @param mockLlm - The mock provider to assert against
+ */
+export function expectMockLlm(mockLlm) {
+    const assertions = {
+        toHaveBeenCalledTimes(n) {
+            const actual = mockLlm.getCallCount();
+            if (actual !== n) {
+                throw new Error(`Expected LLM to be called ${n} time(s), but was called ${actual} time(s)`);
+            }
+            return assertions;
+        },
+        toHaveUsedTool(toolName) {
+            const calls = mockLlm.getCalls();
+            const found = calls.some((call) => call.response.toolCalls.some((tc) => tc.name === toolName));
+            if (!found) {
+                const usedTools = [
+                    ...new Set(calls.flatMap((c) => c.response.toolCalls.map((tc) => tc.name))),
+                ];
+                throw new Error(`Expected tool '${toolName}' to have been used, but only these tools were used: ${usedTools.length > 0 ? usedTools.join(', ') : '(none)'}`);
+            }
+            return assertions;
+        },
+        toNotHaveUsedTool(toolName) {
+            const calls = mockLlm.getCalls();
+            const found = calls.some((call) => call.response.toolCalls.some((tc) => tc.name === toolName));
+            if (found) {
+                throw new Error(`Expected tool '${toolName}' to NOT have been used, but it was`);
+            }
+            return assertions;
+        },
+        toHaveTokenUsageBelow(maxTokens) {
+            const total = mockLlm.getTotalTokens();
+            if (total > maxTokens) {
+                throw new Error(`Expected token usage below ${maxTokens}, but total was ${total}`);
+            }
+            return assertions;
+        },
+        toHaveReceivedMessage(pattern, callIndex) {
+            const calls = mockLlm.getCalls();
+            const targetCalls = callIndex !== undefined ? [calls[callIndex]] : calls;
+            if (callIndex !== undefined && !calls[callIndex]) {
+                throw new Error(`Expected call at index ${callIndex}, but only ${calls.length} calls were recorded`);
+            }
+            const found = targetCalls.some((call) => call?.messages.some((msg) => {
+                if (typeof pattern === 'string') {
+                    return msg.content.includes(pattern);
+                }
+                return pattern.test(msg.content);
+            }));
+            if (!found) {
+                const scope = callIndex !== undefined ? `call #${callIndex}` : 'any call';
+                throw new Error(`Expected ${scope} to contain a message matching ${pattern}, but none matched`);
+            }
+            return assertions;
+        },
+    };
+    return assertions;
+}
+//# sourceMappingURL=assertions.js.map

package/dist/testing/index.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Flow Weaver Testing Utilities
+ *
+ * Deterministic testing for agent workflows.
+ *
+ * ```typescript
+ * import {
+ *   createMockLlmProvider,
+ *   createRecordingProvider,
+ *   createReplayProvider,
+ *   loadRecording,
+ *   expectAgentResult,
+ *   expectMockLlm,
+ *   TokenTracker,
+ * } from 'flow-weaver/testing';
+ * ```
+ */
+export { createMockLlmProvider } from './mock-llm.js';
+export type { MockLlmProvider, MockLlmResponse, MockLlmCall, LLMProvider, LLMMessage, LLMResponse, LLMToolCall, LLMTool, LLMTokenUsage, } from './mock-llm.js';
+export { expectAgentResult, expectMockLlm } from './assertions.js';
+export type { AgentResultAssertions, MockLlmAssertions } from './assertions.js';
+export { TokenTracker } from './token-tracker.js';
+export type { TrackedStep } from './token-tracker.js';
+export { createRecordingProvider } from './recorder.js';
+export type { RecordingLlmProvider, LlmRecording, LlmRecordingStep } from './recorder.js';
+export { createReplayProvider, loadRecording } from './replayer.js';
+export type { ReplayOptions } from './replayer.js';
+export { createMockApprovalProvider } from './mock-approval.js';
+export type { MockApprovalProvider, MockApprovalResponse, MockApprovalCall, ApprovalProvider, ApprovalRequest, ApprovalResult, } from './mock-approval.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/testing/index.js

@@ -0,0 +1,24 @@
+/**
+ * Flow Weaver Testing Utilities
+ *
+ * Deterministic testing for agent workflows.
+ *
+ * ```typescript
+ * import {
+ *   createMockLlmProvider,
+ *   createRecordingProvider,
+ *   createReplayProvider,
+ *   loadRecording,
+ *   expectAgentResult,
+ *   expectMockLlm,
+ *   TokenTracker,
+ * } from 'flow-weaver/testing';
+ * ```
+ */
+export { createMockLlmProvider } from './mock-llm.js';
+export { expectAgentResult, expectMockLlm } from './assertions.js';
+export { TokenTracker } from './token-tracker.js';
+export { createRecordingProvider } from './recorder.js';
+export { createReplayProvider, loadRecording } from './replayer.js';
+export { createMockApprovalProvider } from './mock-approval.js';
+//# sourceMappingURL=index.js.map