@synergenius/flow-weaver 0.20.7 → 0.21.0

package/dist/mcp/server.js

@@ -2,10 +2,6 @@
 import '../extensions/index.js';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { DEFAULT_SERVER_URL } from '../defaults.js';
-import { EventBuffer } from './event-buffer.js';
-import { EditorConnection } from './editor-connection.js';
-import { registerEditorTools } from './tools-editor.js';
 import { registerQueryTools } from './tools-query.js';
 import { registerTemplateTools } from './tools-template.js';
 import { registerPatternTools } from './tools-pattern.js';
@@ -16,61 +12,15 @@ import { registerDocsTools } from './tools-docs.js';
 import { registerModelTools } from './tools-model.js';
 import { registerDebugTools } from './tools-debug.js';
 import { registerContextTools } from './tools-context.js';
-import { registerResources } from './resources.js';
 import { registerPrompts } from './prompts.js';
 import { registerPackMcpTools } from './pack-tools.js';
-function parseEventFilterFromEnv() {
-    const filter = {};
-    const include = process.env.FW_EVENT_INCLUDE;
-    if (include) {
-        filter.include = include
-            .split(',')
-            .map((s) => s.trim())
-            .filter(Boolean);
-    }
-    const exclude = process.env.FW_EVENT_EXCLUDE;
-    if (exclude) {
-        filter.exclude = exclude
-            .split(',')
-            .map((s) => s.trim())
-            .filter(Boolean);
-    }
-    const dedupeMs = process.env.FW_EVENT_DEDUPE_MS;
-    if (dedupeMs) {
-        const parsed = parseInt(dedupeMs, 10);
-        if (!isNaN(parsed))
-            filter.dedupeWindowMs = parsed;
-    }
-    const maxBuf = process.env.FW_EVENT_MAX;
-    if (maxBuf) {
-        const parsed = parseInt(maxBuf, 10);
-        if (!isNaN(parsed))
-            filter.maxBufferSize = parsed;
-    }
-    return filter;
-}
 export async function startMcpServer(options) {
-    const serverUrl = options.server || DEFAULT_SERVER_URL;
-    // Parse event filter config from environment variables
-    const filterFromEnv = parseEventFilterFromEnv();
-    // Use injected deps for testing, or create real ones
-    const buffer = options._testDeps?.buffer ?? new EventBuffer(undefined, undefined, filterFromEnv);
-    const connection = options._testDeps?.connection ?? new EditorConnection(serverUrl, buffer);
-    // Connect to Studio (non-blocking)
-    if (!options._testDeps) {
-        const log = options.stdio
-            ? (msg) => process.stderr.write(msg + '\n')
-            : // eslint-disable-next-line no-console
-                (msg) => console.log(msg);
-        connection.connect(log);
-    }
     // Create MCP server
     const mcp = new McpServer({
         name: 'flow-weaver',
         version: '1.0.0',
     });
-    // Register all tools and resources
-    registerEditorTools(mcp, connection, buffer);
+    // Register all tools
     registerQueryTools(mcp);
     registerTemplateTools(mcp);
     registerPatternTools(mcp);
@@ -81,17 +31,15 @@ export async function startMcpServer(options) {
     registerModelTools(mcp);
     registerDebugTools(mcp);
     registerContextTools(mcp);
-    registerResources(mcp, connection, buffer);
     registerPrompts(mcp);
     await registerPackMcpTools(mcp);
     // Connect transport (only in stdio MCP mode)
-    if (!options._testDeps && options.stdio) {
+    if (options.stdio) {
         const transport = new StdioServerTransport();
         await mcp.connect(transport);
     }
 }
 export async function mcpServerCommand(options) {
-    const serverUrl = options.server || DEFAULT_SERVER_URL;
     // In stdio mode, stdout is reserved for JSON-RPC — log to stderr.
     // In interactive mode, log to stdout (write + flush to survive SIGTERM).
     const log = options.stdio
@@ -99,7 +47,7 @@ export async function mcpServerCommand(options) {
         : (msg) => process.stdout.write(msg + '\n');
     if (!options.stdio) {
         log('Tip: run "flow-weaver mcp-setup" to register with your AI tools.');
-        log(`Starting MCP server (Studio: ${serverUrl})...`);
+        log('Starting MCP server...');
     }
     await startMcpServer(options);
     if (!options.stdio) {

package/dist/mcp/types.d.ts

@@ -1,17 +1,7 @@
-import type { io as socketIO } from 'socket.io-client';
-import type { EventBuffer } from './event-buffer.js';
-import type { EditorConnection } from './editor-connection.js';
 /** Options for initializing the MCP server. */
 export interface McpServerOptions {
-    /** WebSocket server URL for Studio connection. */
-    server?: string;
     /** Whether to use stdio transport instead of SSE. */
     stdio?: boolean;
-    /** Internal: injected deps for testing */
-    _testDeps?: {
-        buffer?: EventBuffer;
-        connection?: EditorConnection;
-    };
 }
 /** Dependencies injected into tool registration functions for CLI interaction and logging. */
 export interface RegistrationDeps {
@@ -27,44 +17,4 @@ export interface RegistrationDeps {
     /** Resolve the path to the Flow Weaver CLI executable. */
     resolveCliPath: () => string;
 }
-/** Acknowledgement response returned by Studio after processing a command. */
-export interface AckResponse {
-    /** Unique identifier correlating the response to its originating request. */
-    requestId: string;
-    /** Whether the command executed successfully. */
-    success: boolean;
-    /** The command result payload, present on success. */
-    result?: unknown;
-    /** Error message, present on failure. */
-    error?: string;
-}
-/** A timestamped event stored in the event buffer. */
-export interface BufferedEvent {
-    /** The event name (e.g. "fw:node-added", "mcp:status"). */
-    event: string;
-    /** The event payload. */
-    data: unknown;
-    /** ISO 8601 timestamp of when the event was buffered. */
-    timestamp: string;
-}
-/** Options for configuring the Studio WebSocket connection. */
-export interface EditorConnectionOptions {
-    /** Custom socket.io factory, primarily used for injecting mocks in tests. */
-    ioFactory?: typeof socketIO;
-    /** Timeout in milliseconds for awaiting command acknowledgements. Defaults to 10000. */
-    ackTimeout?: number;
-}
-/** Configuration for filtering and deduplicating events in the event buffer. */
-export interface EventFilterConfig {
-    /** Event name patterns to include. Empty array means all events are included. Supports trailing `*` for prefix matching. */
-    include: string[];
-    /** Event name patterns to exclude (applied after include). Supports trailing `*` for prefix matching. */
-    exclude: string[];
-    /** Collapse duplicate events of the same type within this window in milliseconds. 0 disables deduplication. */
-    dedupeWindowMs: number;
-    /** Maximum number of events to retain before evicting the oldest. */
-    maxBufferSize: number;
-}
-/** Default event filter configuration. Excludes `fw:ack` events, dedupes within 200ms, and retains up to 500 events. */
-export declare const DEFAULT_EVENT_FILTER: EventFilterConfig;
 //# sourceMappingURL=types.d.ts.map

package/dist/mcp/types.js

@@ -1,8 +1,2 @@
-/** Default event filter configuration. Excludes `fw:ack` events, dedupes within 200ms, and retains up to 500 events. */
-export const DEFAULT_EVENT_FILTER = {
-    include: [],
-    exclude: ['fw:ack'],
-    dedupeWindowMs: 200,
-    maxBufferSize: 500,
-};
+export {};
 //# sourceMappingURL=types.js.map

package/dist/mcp/workflow-executor.js

@@ -71,7 +71,29 @@ export async function executeWorkflowFromFile(filePath, params, options) {
                 esModuleInterop: true,
             },
         });
-        fs.writeFileSync(tmpFile, jsOutput.outputText, 'utf8');
+        // When source lives under src/, rewrite relative imports to point to
+        // dist/ equivalents so Node.js ESM resolver finds the compiled JS files.
+        // This happens with marketplace packs that ship TS source for parsing
+        // but only have compiled JS in dist/.
+        let transpiledOutput = jsOutput.outputText;
+        const srcDir = path.dirname(tmpTsFile);
+        if (srcDir.includes(`${path.sep}src${path.sep}`)) {
+            const distDir = srcDir.replace(`${path.sep}src${path.sep}`, `${path.sep}dist${path.sep}`);
+            transpiledOutput = transpiledOutput.replace(/from\s+['"](\.[^'"]+)['"]/g, (_match, specifier) => {
+                const resolvedSrc = path.resolve(srcDir, specifier);
+                // Only rewrite if the source .js file doesn't exist but the dist equivalent does
+                if (!fs.existsSync(resolvedSrc)) {
+                    const distEquivalent = resolvedSrc.replace(`${path.sep}src${path.sep}`, `${path.sep}dist${path.sep}`);
+                    if (fs.existsSync(distEquivalent)) {
+                        const relative = path.relative(srcDir, distEquivalent);
+                        const normalized = relative.startsWith('.') ? relative : `./${relative}`;
+                        return `from '${normalized}'`;
+                    }
+                }
+                return _match;
+            });
+        }
+        fs.writeFileSync(tmpFile, transpiledOutput, 'utf8');
         // Create debugger to capture trace events
         const trace = [];
         const debugger_ = includeTrace

package/dist/parser.js

@@ -1873,7 +1873,11 @@ export class AnnotationParser {
         const firstParamName = firstParam.getName();
         const firstParamType = firstParam.getType();
         const firstParamTypeText = firstParamType.getText();
-        if (firstParamName === 'execute' && firstParamTypeText === 'boolean') {
+        // Accept "execute: any" (from compiled .js files where types are stripped)
+        // when JSDoc @param confirms it as a step port.
+        const isExecutePort = firstParamName === 'execute' &&
+            (firstParamTypeText === 'boolean' || (firstParamTypeText === 'any' && config?.startPorts?.['execute']));
+        if (isExecutePort) {
             // Correct new format: first param is execute
             // Check if JSDoc has explicit metadata override for execute port (from @param annotation)
             if (config?.startPorts && config.startPorts['execute']) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@synergenius/flow-weaver",
-  "version": "0.20.7",
+  "version": "0.21.0",
   "description": "Deterministic workflow compiler for AI agents. Compiles to standalone TypeScript, no runtime dependencies.",
   "private": false,
   "type": "module",
@@ -159,7 +159,6 @@
     "immer": "^10.2.0",
     "js-yaml": "^4.1.0",
     "picocolors": "^1.1.1",
-    "socket.io-client": "^4.8.0",
     "source-map": "^0.7.6",
     "ts-morph": "^21.0.1",
     "ws": "^8.19.0",

package/dist/cli/commands/listen.d.ts

@@ -1,16 +0,0 @@
-import { io as socketIO } from 'socket.io-client';
-export interface AckResponse {
-    requestId: string;
-    success: boolean;
-    result?: unknown;
-    error?: string;
-}
-export interface ListenOptions {
-    server?: string;
-    /** Override the socket.io-client `io` factory (for testing) */
-    ioFactory?: typeof socketIO;
-    /** Override stdout (for testing) */
-    output?: NodeJS.WritableStream;
-}
-export declare function listenCommand(options: ListenOptions): Promise<void>;
-//# sourceMappingURL=listen.d.ts.map

package/dist/cli/commands/listen.js

@@ -1,39 +0,0 @@
-import { io as socketIO } from 'socket.io-client';
-import { logger } from '../utils/logger.js';
-import { DEFAULT_SERVER_URL } from '../../defaults.js';
-export async function listenCommand(options) {
-    const serverUrl = options.server || DEFAULT_SERVER_URL;
-    const ioFactory = options.ioFactory ?? socketIO;
-    const output = options.output ?? process.stdout;
-    const socket = ioFactory(`${serverUrl}/integrations`, {
-        query: { clientType: 'cli' },
-        transports: ['websocket', 'polling'],
-        reconnection: true,
-        reconnectionDelay: 1000,
-        reconnectionAttempts: Infinity,
-    });
-    socket.on('connect', () => {
-        logger.info(`Connected to ${serverUrl}/integrations`);
-        socket.emit('integration:getContext', (ctx) => {
-            if (ctx) {
-                output.write(JSON.stringify({ event: 'integration:context', data: ctx }) + '\n');
-            }
-        });
-    });
-    socket.on('disconnect', (reason) => {
-        logger.warn(`Disconnected: ${reason}`);
-    });
-    socket.onAny((event, data) => {
-        if (event.startsWith('fw:') || event.startsWith('integration:')) {
-            output.write(JSON.stringify({ event, data }) + '\n');
-        }
-    });
-    process.on('SIGINT', () => {
-        logger.info('Disconnecting...');
-        socket.disconnect();
-        process.exit(0);
-    });
-    // Keep alive until SIGINT
-    await new Promise(() => { });
-}
-//# sourceMappingURL=listen.js.map

package/dist/cli/commands/tunnel.d.ts

@@ -1,19 +0,0 @@
-/**
- * tunnel command — Self-contained tunnel for cloud Studio.
- *
- * Handles all RPC methods locally using Node.js fs and the
- * @synergenius/flow-weaver AST API.  No local server required.
- *
- * 1. Opens a WebSocket to the cloud server's /api/tunnel endpoint.
- * 2. Dispatches RPC calls directly to local handler functions.
- */
-import WebSocket from 'ws';
-export interface TunnelOptions {
-    key: string;
-    cloud?: string;
-    dir?: string;
-    /** Override WebSocket factory (for testing) */
-    createWs?: (url: string) => WebSocket;
-}
-export declare function tunnelCommand(options: TunnelOptions): Promise<void>;
-//# sourceMappingURL=tunnel.d.ts.map

package/dist/cli/commands/tunnel.js

@@ -1,119 +0,0 @@
-/**
- * tunnel command — Self-contained tunnel for cloud Studio.
- *
- * Handles all RPC methods locally using Node.js fs and the
- * @synergenius/flow-weaver AST API.  No local server required.
- *
- * 1. Opens a WebSocket to the cloud server's /api/tunnel endpoint.
- * 2. Dispatches RPC calls directly to local handler functions.
- */
-import * as path from 'node:path';
-import WebSocket from 'ws';
-import { logger } from '../utils/logger.js';
-import { dispatch } from '../tunnel/dispatch.js';
-export async function tunnelCommand(options) {
-    const cloudUrl = options.cloud || 'https://flowweaver.dev';
-    const workspaceRoot = path.resolve(options.dir || process.cwd());
-    const createWs = options.createWs ?? ((url) => new WebSocket(url));
-    logger.section('Flow Weaver Tunnel');
-    logger.info(`Cloud:     ${cloudUrl}`);
-    logger.info(`Workspace: ${workspaceRoot}`);
-    logger.newline();
-    // -----------------------------------------------------------------------
-    // 1. Connect to cloud server via WebSocket
-    // -----------------------------------------------------------------------
-    logger.info('Connecting to cloud server...');
-    const wsProtocol = cloudUrl.startsWith('https') ? 'wss' : 'ws';
-    const wsHost = cloudUrl.replace(/^https?:\/\//, '');
-    const wsUrl = `${wsProtocol}://${wsHost}/api/tunnel?token=${encodeURIComponent(options.key)}`;
-    const cloudWs = createWs(wsUrl);
-    await new Promise((resolve, reject) => {
-        const timeout = setTimeout(() => {
-            cloudWs.close();
-            reject(new Error('Cloud server connection timeout (10s)'));
-        }, 10_000);
-        cloudWs.on('open', () => {
-            clearTimeout(timeout);
-        });
-        cloudWs.on('message', (raw) => {
-            try {
-                const msg = JSON.parse(raw.toString());
-                if (msg.type === 'tunnel:hello') {
-                    logger.success('Connected to cloud server');
-                    resolve();
-                }
-                else if (msg.type === 'error') {
-                    clearTimeout(timeout);
-                    cloudWs.close();
-                    reject(new Error(`Cloud server rejected connection: ${msg.message}`));
-                }
-            }
-            catch {
-                // Ignore parse errors during handshake
-            }
-        });
-        cloudWs.on('error', (err) => {
-            clearTimeout(timeout);
-            reject(new Error(`Cannot connect to cloud server: ${err.message}`));
-        });
-    });
-    logger.newline();
-    logger.success('Tunnel active — local development mode enabled');
-    logger.info('Press Ctrl+C to disconnect');
-    logger.newline();
-    let requestCount = 0;
-    const ctx = { workspaceRoot };
-    // -----------------------------------------------------------------------
-    // 2. Handle RPC: cloud → local dispatch → cloud
-    // -----------------------------------------------------------------------
-    cloudWs.on('message', async (raw) => {
-        let msg;
-        try {
-            msg = JSON.parse(raw.toString());
-        }
-        catch {
-            return;
-        }
-        if (msg.type === 'ping') {
-            cloudWs.send(JSON.stringify({ type: 'pong' }));
-            return;
-        }
-        if (msg.type === 'tunnel:request') {
-            const req = msg;
-            requestCount++;
-            logger.debug(`[${requestCount}] → ${req.method}`);
-            const response = await dispatch(req.method, req.params || {}, ctx);
-            cloudWs.send(JSON.stringify({
-                type: 'tunnel:response',
-                requestId: req.requestId,
-                id: req.id,
-                success: response.success,
-                result: response.result,
-                error: response.error,
-            }));
-        }
-    });
-    // -----------------------------------------------------------------------
-    // 3. Handle disconnections
-    // -----------------------------------------------------------------------
-    cloudWs.on('close', (code, reason) => {
-        logger.warn(`Cloud server disconnected: ${code} ${reason.toString()}`);
-        logger.info('Shutting down tunnel...');
-        process.exit(code === 4001 ? 1 : 0);
-    });
-    cloudWs.on('error', (err) => {
-        logger.error(`Cloud WebSocket error: ${err.message}`);
-    });
-    // -----------------------------------------------------------------------
-    // 4. Graceful shutdown
-    // -----------------------------------------------------------------------
-    process.on('SIGINT', () => {
-        logger.newline();
-        logger.info(`Shutting down tunnel (${requestCount} requests handled)...`);
-        cloudWs.close();
-        process.exit(0);
-    });
-    // Keep alive until SIGINT or cloud disconnect
-    await new Promise(() => { });
-}
-//# sourceMappingURL=tunnel.js.map

package/dist/cli/commands/ui.d.ts

@@ -1,16 +0,0 @@
-export declare function uiFocusNode(nodeId: string, options: {
-    server?: string;
-}): Promise<void>;
-export declare function uiAddNode(nodeTypeName: string, options: {
-    server?: string;
-}): Promise<void>;
-export declare function uiOpenWorkflow(filePath: string, options: {
-    server?: string;
-}): Promise<void>;
-export declare function uiGetState(options: {
-    server?: string;
-}): Promise<void>;
-export declare function uiBatch(json: string, options: {
-    server?: string;
-}): Promise<void>;
-//# sourceMappingURL=ui.d.ts.map

package/dist/cli/commands/ui.js

@@ -1,130 +0,0 @@
-import { io as socketIO } from 'socket.io-client';
-import { logger } from '../utils/logger.js';
-import { DEFAULT_SERVER_URL } from '../../defaults.js';
-const DEFAULT_SERVER = DEFAULT_SERVER_URL;
-const ACK_TIMEOUT = 10_000;
-const VERBOSE_OUTPUT = !!(process.env.DEBUG || process.argv.includes('--verbose'));
-async function sendCommand(serverUrl, action, params) {
-    const socket = socketIO(`${serverUrl}/integrations`, {
-        query: { clientType: 'cli' },
-        transports: ['websocket', 'polling'],
-    });
-    try {
-        await new Promise((resolve, reject) => {
-            socket.on('connect', () => resolve());
-            socket.on('connect_error', (err) => reject(err));
-            setTimeout(() => reject(new Error('Connection timeout')), ACK_TIMEOUT);
-        });
-        const requestId = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-        const result = await new Promise((resolve) => {
-            const timeout = setTimeout(() => {
-                resolve({ requestId, success: false, error: 'Timeout' });
-            }, ACK_TIMEOUT);
-            socket.on('fw:ack', (data) => {
-                if (data.requestId === requestId) {
-                    clearTimeout(timeout);
-                    resolve(data);
-                }
-            });
-            socket.emit('integration:command', { requestId, action, params });
-        });
-        if (result.success) {
-            if (VERBOSE_OUTPUT) {
-                logger.success(JSON.stringify(result, null, 2));
-            }
-            else {
-                logger.success(`Command "${action}" executed successfully`);
-            }
-        }
-        else {
-            logger.error(VERBOSE_OUTPUT
-                ? JSON.stringify(result, null, 2)
-                : `Command "${action}" failed: ${result.error || 'unknown error'}`);
-            process.exitCode = 1;
-        }
-    }
-    catch (err) {
-        logger.error(String(err instanceof Error ? err.message : err));
-        process.exitCode = 1;
-    }
-    finally {
-        socket.disconnect();
-    }
-}
-async function sendBatch(serverUrl, commands) {
-    const socket = socketIO(`${serverUrl}/integrations`, {
-        query: { clientType: 'cli' },
-        transports: ['websocket', 'polling'],
-    });
-    try {
-        await new Promise((resolve, reject) => {
-            socket.on('connect', () => resolve());
-            socket.on('connect_error', (err) => reject(err));
-            setTimeout(() => reject(new Error('Connection timeout')), ACK_TIMEOUT);
-        });
-        const requestId = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-        const result = await new Promise((resolve) => {
-            const timeout = setTimeout(() => {
-                resolve({ requestId, success: false, error: 'Timeout' });
-            }, ACK_TIMEOUT);
-            socket.on('fw:ack', (data) => {
-                if (data.requestId === requestId) {
-                    clearTimeout(timeout);
-                    resolve(data);
-                }
-            });
-            socket.emit('integration:batch', { requestId, commands });
-        });
-        if (result.success) {
-            if (VERBOSE_OUTPUT) {
-                logger.success(JSON.stringify(result, null, 2));
-            }
-            else {
-                logger.success('Batch executed successfully');
-            }
-        }
-        else {
-            logger.error(VERBOSE_OUTPUT
-                ? JSON.stringify(result, null, 2)
-                : `Batch failed: ${result.error || 'unknown error'}`);
-            process.exitCode = 1;
-        }
-    }
-    catch (err) {
-        logger.error(String(err instanceof Error ? err.message : err));
-        process.exitCode = 1;
-    }
-    finally {
-        socket.disconnect();
-    }
-}
-export async function uiFocusNode(nodeId, options) {
-    const server = options.server || DEFAULT_SERVER;
-    await sendCommand(server, 'focus-node', { nodeId });
-}
-export async function uiAddNode(nodeTypeName, options) {
-    const server = options.server || DEFAULT_SERVER;
-    await sendCommand(server, 'add-node', { nodeTypeName });
-}
-export async function uiOpenWorkflow(filePath, options) {
-    const server = options.server || DEFAULT_SERVER;
-    await sendCommand(server, 'open-workflow', { filePath });
-}
-export async function uiGetState(options) {
-    const server = options.server || DEFAULT_SERVER;
-    await sendCommand(server, 'get-state', {});
-}
-export async function uiBatch(json, options) {
-    let commands;
-    try {
-        commands = JSON.parse(json);
-    }
-    catch {
-        logger.error('Invalid JSON. Provide an array of {action, params} objects.');
-        process.exitCode = 1;
-        return;
-    }
-    const server = options.server || DEFAULT_SERVER;
-    await sendBatch(server, commands);
-}
-//# sourceMappingURL=ui.js.map

package/dist/cli/tunnel/dispatch.d.ts

@@ -1,18 +0,0 @@
-/**
- * Method dispatcher for the self-contained tunnel.
- *
- * Maps RPC method names to handler functions and wraps them
- * in a standard try/catch envelope.
- */
-export interface TunnelContext {
-    workspaceRoot: string;
-}
-export type HandlerFn = (params: Record<string, unknown>, ctx: TunnelContext) => Promise<unknown>;
-export declare function dispatch(method: string, params: Record<string, unknown>, ctx: TunnelContext): Promise<{
-    success: boolean;
-    result?: unknown;
-    error?: {
-        message: string;
-    };
-}>;
-//# sourceMappingURL=dispatch.d.ts.map

package/dist/cli/tunnel/dispatch.js

@@ -1,36 +0,0 @@
-/**
- * Method dispatcher for the self-contained tunnel.
- *
- * Maps RPC method names to handler functions and wraps them
- * in a standard try/catch envelope.
- */
-import { fileOpsHandlers } from './handlers/file-ops.js';
-import { astOpsHandlers } from './handlers/ast-ops.js';
-import { mutationHandlers } from './handlers/mutations.js';
-import { templateHandlers } from './handlers/templates.js';
-import { executionHandlers } from './handlers/execution.js';
-import { stubHandlers } from './handlers/stubs.js';
-const handlers = {
-    ...stubHandlers,
-    ...fileOpsHandlers,
-    ...astOpsHandlers,
-    ...mutationHandlers,
-    ...templateHandlers,
-    ...executionHandlers,
-};
-export async function dispatch(method, params, ctx) {
-    const handler = handlers[method];
-    if (!handler) {
-        // Unknown methods return undefined — matches platform behaviour
-        return { success: true, result: undefined };
-    }
-    try {
-        const result = await handler(params, ctx);
-        return { success: true, result };
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        return { success: false, error: { message } };
-    }
-}
-//# sourceMappingURL=dispatch.js.map

package/dist/cli/tunnel/file-lock.d.ts

@@ -1,9 +0,0 @@
-/**
- * File mutation lock — serializes concurrent mutations to the same file.
- *
- * Ported from flow-weaver-platform/src/services/ast-helpers.ts:54-85.
- * Prevents file corruption when rapid Studio mutations (e.g. dragging nodes)
- * trigger concurrent write operations.
- */
-export declare function withFileLock<T>(filePath: string, operation: () => Promise<T>): Promise<T>;
-//# sourceMappingURL=file-lock.d.ts.map