@synergenius/flow-weaver 0.33.1 → 0.44.0

package/dist/plugin/PluginPanel.d.ts

@@ -1,12 +0,0 @@
-/**
- * PluginPanel — standalone component for external plugins.
- *
- * At runtime, `evaluateClientCode()` in pluginClientManager intercepts
- * `require('@synergenius/flow-weaver/plugin')` and provides the real
- * component from src/plugin-system/external/components.tsx. This file
- * exists for TypeScript compile-time resolution only.
- */
-import React from 'react';
-import type { TPluginComponentProps } from './types.js';
-export declare const PluginPanel: React.FC<TPluginComponentProps>;
-//# sourceMappingURL=PluginPanel.d.ts.map

package/dist/plugin/PluginPanel.js

@@ -1,5 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-export const PluginPanel = ({ children }) => {
-    return _jsx("div", { className: "plugin-panel", children: children });
-};
-//# sourceMappingURL=PluginPanel.js.map

package/dist/plugin/index.d.ts

@@ -1,13 +0,0 @@
-/**
- * @synergenius/flow-weaver/plugin
- *
- * Public API for external plugin development.
- */
-export type { TPluginComponentArea, TPluginComponentConfig, TPluginComponentApi, TPluginComponentProps, TPluginUI, TPluginInitializer, TPluginInitializerResult, TPluginSystemModule, TPluginCapabilities, TPluginDefinition, } from './types.js';
-export { PluginPanel } from './PluginPanel.js';
-/**
- * Convenience wrapper — marks a function as a plugin initializer.
- * At runtime this is a passthrough; it exists for discoverability and typing.
- */
-export declare function createPlugin(fn: () => import('./types.js').TPluginInitializerResult): () => import("./types.js").TPluginInitializerResult;
-//# sourceMappingURL=index.d.ts.map

package/dist/plugin/index.js

@@ -1,14 +0,0 @@
-/**
- * @synergenius/flow-weaver/plugin
- *
- * Public API for external plugin development.
- */
-export { PluginPanel } from './PluginPanel.js';
-/**
- * Convenience wrapper — marks a function as a plugin initializer.
- * At runtime this is a passthrough; it exists for discoverability and typing.
- */
-export function createPlugin(fn) {
-    return fn;
-}
-//# sourceMappingURL=index.js.map

package/dist/plugin/types.d.ts

@@ -1,75 +0,0 @@
-/**
- * External plugin types — pure TypeScript interfaces (no zod).
- *
- * These mirror the zod schemas in src/plugin-system/externalTypes.ts
- * but are dependency-free so external plugin authors only need this package.
- */
-import type { ReactNode } from 'react';
-export type TPluginComponentArea = 'sidebar' | 'main' | 'toolbar' | 'modal' | 'panel';
-export interface TPluginComponentConfig {
-    name: string;
-    displayName: string;
-    description?: string;
-    icon?: string;
-    area: TPluginComponentArea;
-}
-export interface TPluginComponentApi {
-    call: (pluginName: string, method: string, payload?: unknown) => Promise<unknown>;
-}
-export interface TPluginComponentProps {
-    pluginName: string;
-    componentName: string;
-    config: TPluginComponentConfig;
-    children?: ReactNode;
-    api: TPluginComponentApi;
-}
-export interface TPluginUI {
-    components: Record<string, React.ComponentType<TPluginComponentProps>>;
-    config: Record<string, TPluginComponentConfig>;
-}
-export interface TPluginInitializerResult {
-    initialize?: () => Promise<void>;
-    ui?: TPluginUI;
-}
-export type TPluginInitializer = () => TPluginInitializerResult;
-export interface TPluginSystemModule {
-    initialize?: () => Promise<void> | void;
-    methods: Record<string, (...args: unknown[]) => unknown>;
-    cleanup?: () => Promise<void> | void;
-}
-export interface TPluginCapabilities {
-    filesystem?: {
-        allowed: boolean;
-        paths?: string[];
-        operations?: Array<'read' | 'write' | 'delete'>;
-    };
-    network?: {
-        allowed: boolean;
-        domains?: string[];
-        protocols?: Array<'http' | 'https' | 'ws' | 'wss'>;
-    };
-    process?: {
-        allowed: boolean;
-        maxMemory?: number;
-        timeout?: number;
-    };
-    interop?: {
-        allowed: boolean;
-        plugins?: string[];
-    };
-}
-export interface TPluginDefinition {
-    name: string;
-    version: string;
-    description: string;
-    entry: {
-        client: string;
-        system?: string;
-    };
-    dependencies?: {
-        plugins?: string[];
-        system?: string[];
-    };
-    capabilities: TPluginCapabilities;
-}
-//# sourceMappingURL=types.d.ts.map

package/dist/plugin/types.js

@@ -1,8 +0,0 @@
-/**
- * External plugin types — pure TypeScript interfaces (no zod).
- *
- * These mirror the zod schemas in src/plugin-system/externalTypes.ts
- * but are dependency-free so external plugin authors only need this package.
- */
-export {};
-//# sourceMappingURL=types.js.map

package/dist/resolve-package-types.js

@@ -1,123 +0,0 @@
-import * as path from 'node:path';
-import * as fs from 'node:fs';
-/**
- * Resolve a package specifier to the absolute path of its `.d.ts` type declarations.
- *
- * Resolution order:
- * 1. Find `node_modules/<pkg>/package.json` and read `types` or `typings` field
- * 2. Check `exports` field for types (modern packages use conditional exports)
- * 3. Fall back to `@types/<pkg>/index.d.ts`
- * 4. Fall back to `<pkg>/index.d.ts`
- * 5. Return `null` if nothing found
- *
- * @param packageSpecifier - The npm package name (e.g., 'date-fns', '@scope/pkg')
- * @param fromDir - Directory to start searching from (walks up to find node_modules)
- * @param nodeModulesOverride - Optional explicit node_modules path (for testing)
- * @returns Absolute path to the `.d.ts` file, or null
- */
-export function resolvePackageTypesPath(packageSpecifier, fromDir, nodeModulesOverride) {
-    const nodeModulesDirs = nodeModulesOverride
-        ? [nodeModulesOverride]
-        : findNodeModulesDirs(fromDir);
-    for (const nmDir of nodeModulesDirs) {
-        const result = resolveInNodeModules(packageSpecifier, nmDir);
-        if (result)
-            return result;
-    }
-    return null;
-}
-/**
- * Walk up from `fromDir` collecting all `node_modules` directories.
- */
-function findNodeModulesDirs(fromDir) {
-    const dirs = [];
-    let current = path.resolve(fromDir);
-    const root = path.parse(current).root;
-    while (current !== root) {
-        const candidate = path.join(current, 'node_modules');
-        if (fs.existsSync(candidate) && fs.statSync(candidate).isDirectory()) {
-            dirs.push(candidate);
-        }
-        const parent = path.dirname(current);
-        if (parent === current)
-            break;
-        current = parent;
-    }
-    return dirs;
-}
-/**
- * Resolve types path from the exports field in package.json.
- * Handles conditional exports like: { ".": { "types": "./lib/index.d.ts" } }
- */
-function resolveExportsTypes(exports, pkgDir) {
-    if (typeof exports !== 'object' || exports === null)
-        return null;
-    const exportsObj = exports;
-    // Check root export "."
-    const root = exportsObj['.'];
-    if (root && typeof root === 'object' && root !== null) {
-        const rootObj = root;
-        if (typeof rootObj.types === 'string') {
-            const typesPath = path.resolve(pkgDir, rootObj.types);
-            if (fs.existsSync(typesPath)) {
-                return typesPath;
-            }
-        }
-    }
-    // Check direct types field in exports (less common but valid)
-    if (typeof exportsObj.types === 'string') {
-        const typesPath = path.resolve(pkgDir, exportsObj.types);
-        if (fs.existsSync(typesPath)) {
-            return typesPath;
-        }
-    }
-    return null;
-}
-/**
- * Try to resolve a package's .d.ts within a single node_modules directory.
- */
-function resolveInNodeModules(packageSpecifier, nmDir) {
-    // Extract the bare package name (without sub-path) for scoped packages
-    const pkgDir = path.join(nmDir, packageSpecifier);
-    // 1. Check package.json types/typings field
-    const pkgJsonPath = path.join(pkgDir, 'package.json');
-    if (fs.existsSync(pkgJsonPath)) {
-        try {
-            const pkgJson = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf-8'));
-            const typesField = pkgJson.types || pkgJson.typings;
-            if (typesField) {
-                const typesPath = path.resolve(pkgDir, typesField);
-                if (fs.existsSync(typesPath)) {
-                    return typesPath;
-                }
-            }
-            // 1b. Check exports field for types (modern packages)
-            if (pkgJson.exports) {
-                const exportsTypesPath = resolveExportsTypes(pkgJson.exports, pkgDir);
-                if (exportsTypesPath) {
-                    return exportsTypesPath;
-                }
-            }
-        }
-        catch {
-            // ignore malformed package.json
-        }
-    }
-    // 2. Fall back to @types/<pkg>/index.d.ts
-    // For scoped packages @scope/pkg, DefinitelyTyped uses @types/scope__pkg
-    // but also check the plain name for non-scoped packages
-    const atTypesName = packageSpecifier.startsWith('@')
-        ? packageSpecifier.replace('@', '').replace('/', '__')
-        : packageSpecifier;
-    const atTypesPath = path.join(nmDir, '@types', atTypesName, 'index.d.ts');
-    if (fs.existsSync(atTypesPath)) {
-        return atTypesPath;
-    }
-    // 3. Fall back to <pkg>/index.d.ts
-    const indexDtsPath = path.join(pkgDir, 'index.d.ts');
-    if (fs.existsSync(indexDtsPath)) {
-        return indexDtsPath;
-    }
-    return null;
-}
-//# sourceMappingURL=resolve-package-types.js.map

package/dist/runtime/CancellationError.js

@@ -1,20 +0,0 @@
-/**
- * Error thrown when workflow execution is cancelled via AbortSignal.
- */
-export class CancellationError extends Error {
-    executionIndex;
-    nodeId;
-    timestamp;
-    constructor(message = "Workflow execution cancelled", executionIndex = 0, nodeId, timestamp = Date.now()) {
-        super(message);
-        this.executionIndex = executionIndex;
-        this.nodeId = nodeId;
-        this.timestamp = timestamp;
-        this.name = "CancellationError";
-    }
-    static isCancellationError(error) {
-        return (error instanceof CancellationError ||
-            (error instanceof Error && error.name === "CancellationError"));
-    }
-}
-//# sourceMappingURL=CancellationError.js.map

package/dist/runtime/ExecutionContext.js

@@ -1,280 +0,0 @@
-import { CancellationError } from './CancellationError.js';
-/**
- * Runtime execution context for generated workflows
- *
- * Manages variable storage, execution tracking, and pull execution (lazy evaluation).
- * This class is used internally by generated workflow code.
- *
- * Key Features:
- * - Variable storage with execution-scoped addressing
- * - Pull execution support (lazy evaluation)
- * - Debug event emission
- * - Async and sync execution modes
- *
- * @example
- * ```typescript
- * const ctx = new GeneratedExecutionContext(true, debugger);
- * const execIndex = ctx.addExecution('node1');
- * ctx.setVariable({ nodeName: 'node1', portName: 'result', executionIndex: execIndex }, 42);
- * const value = await ctx.getVariable({ nodeName: 'node1', portName: 'result', executionIndex: execIndex });
- * ```
- */
-export class GeneratedExecutionContext {
-    variables = new Map();
-    executions = new Map();
-    executionCounter = 0;
-    isAsync;
-    flowWeaverDebugger;
-    pullExecutors = new Map();
-    nodeExecutionIndices = new Map();
-    abortSignal;
-    /**
-     * Create a new execution context
-     * @param isAsync - Whether the workflow runs in async mode (default: true)
-     * @param flowWeaverDebugger - Optional debugger for emitting execution events
-     * @param abortSignal - Optional AbortSignal for cancellation support
-     */
-    constructor(isAsync = true, flowWeaverDebugger, abortSignal) {
-        this.isAsync = isAsync;
-        this.flowWeaverDebugger = flowWeaverDebugger;
-        this.abortSignal = abortSignal;
-    }
-    registerPullExecutor(id, executor) {
-        this.pullExecutors.set(id, executor);
-    }
-    addExecution(id, parentIndex, scopeName) {
-        const index = this.executionCounter++;
-        this.executions.set(this.getExecutionKey(id, index), {
-            id,
-            index,
-            parentIndex,
-            scopeName,
-        });
-        this.nodeExecutionIndices.set(id, index);
-        return index;
-    }
-    setVariable(address, value) {
-        const key = this.getVariableKey(address);
-        this.variables.set(key, value);
-        if (this.flowWeaverDebugger) {
-            const actualValue = typeof value === 'function' ? value() : value;
-            this.sendVariableSetEvent({
-                identifier: {
-                    nodeTypeName: address.nodeTypeName || 'unknown',
-                    id: address.id,
-                    portName: address.portName,
-                    executionIndex: address.executionIndex,
-                    key: 'default',
-                    ...(address.scope !== undefined && { scope: address.scope }),
-                    ...(address.side !== undefined && { side: address.side }),
-                },
-                value: actualValue,
-            });
-        }
-        return this.isAsync ? Promise.resolve() : undefined;
-    }
-    getVariable(address) {
-        const executor = this.pullExecutors.get(address.id);
-        if (executor) {
-            if (!this.hasVariable(address)) {
-                const result = executor();
-                // Handle async executor (returns Promise)
-                if (result instanceof Promise) {
-                    return result.then(() => {
-                        const trackedIndex = this.nodeExecutionIndices.get(address.id);
-                        const finalAddress = trackedIndex !== undefined ? { ...address, executionIndex: trackedIndex } : address;
-                        return this.retrieveVariable(finalAddress);
-                    });
-                }
-                // Handle sync executor (returns void)
-                const trackedIndex = this.nodeExecutionIndices.get(address.id);
-                const finalAddress = trackedIndex !== undefined ? { ...address, executionIndex: trackedIndex } : address;
-                return this.retrieveVariable(finalAddress);
-            }
-        }
-        return this.retrieveVariable(address);
-    }
-    retrieveVariable(address) {
-        const key = this.getVariableKey(address);
-        if (!this.variables.has(key)) {
-            throw new Error(`Variable not found: ${address.id}.${address.portName}[${address.executionIndex}]`);
-        }
-        const value = this.variables.get(key);
-        if (typeof value === 'function') {
-            const result = value();
-            if (result instanceof Promise) {
-                return result;
-            }
-            return this.isAsync ? Promise.resolve(result) : result;
-        }
-        return this.isAsync ? Promise.resolve(value) : value;
-    }
-    hasVariable(address) {
-        const key = this.getVariableKey(address);
-        return this.variables.has(key);
-    }
-    getExecution(id, index) {
-        return this.executions.get(this.getExecutionKey(id, index));
-    }
-    /**
-     * Create an isolated execution scope for container nodes
-     *
-     * Scopes provide isolated variable storage for nodes like ForEach loops.
-     * Child nodes execute within the scope, then variables are merged back.
-     *
-     * @param _parentNodeName - ID of the container node creating the scope
-     * @param _parentIndex - Execution index of the container
-     * @param _scopeName - Name of the scope (e.g., 'iteration')
-     * @param cleanScope - If true, create fresh scope without parent variables (per-port scopes). If false, inherit parent variables (node-level scopes).
-     * @returns New ExecutionContext for the scoped execution
-     *
-     * @example
-     * ```typescript
-     * // Per-port scope (clean=true): isolated variables
-     * const scopedCtx = ctx.createScope('forEach1', 0, 'iteration', true);
-     *
-     * // Node-level scope (clean=false): inherited variables
-     * const scopedCtx = ctx.createScope('container1', 0, 'block', false);
-     * ```
-     */
-    createScope(_parentNodeName, _parentIndex, _scopeName, cleanScope = false) {
-        const scopedContext = new GeneratedExecutionContext(this.isAsync, undefined, this.abortSignal);
-        if (cleanScope) {
-            // Fresh scope - don't copy parent variables (per-port scopes)
-            scopedContext.executionCounter = this.executionCounter;
-        }
-        else {
-            // Inherited scope - copy parent variables (node-level scopes)
-            scopedContext.variables = new Map(this.variables);
-            scopedContext.executions = new Map(this.executions);
-            scopedContext.executionCounter = this.executionCounter;
-        }
-        return scopedContext;
-    }
-    /**
-     * Merge a scoped execution context back into the parent context
-     *
-     * Copies all variables and execution info from the scoped context to this context.
-     * Updates the execution counter to maintain unique execution indices.
-     *
-     * @param scopedContext - The scoped context to merge
-     */
-    mergeScope(scopedContext) {
-        scopedContext.executions.forEach((info, key) => {
-            this.executions.set(key, info);
-        });
-        scopedContext.variables.forEach((value, key) => {
-            this.variables.set(key, value);
-        });
-        this.executionCounter = Math.max(this.executionCounter, scopedContext.executionCounter);
-    }
-    getVariableKey(address) {
-        return `${address.id}:${address.portName}:${address.executionIndex}`;
-    }
-    getExecutionKey(id, index) {
-        return `${id}:${index}`;
-    }
-    getExecutionCount() {
-        return this.executionCounter;
-    }
-    reset() {
-        this.variables.clear();
-        this.executions.clear();
-        this.executionCounter = 0;
-    }
-    /**
-     * Check if the workflow has been aborted
-     */
-    isAborted() {
-        return this.abortSignal?.aborted ?? false;
-    }
-    /**
-     * Throw CancellationError if the workflow has been aborted
-     * @param nodeId - Optional node ID to include in the error
-     */
-    checkAborted(nodeId) {
-        if (this.abortSignal?.aborted) {
-            throw new CancellationError(`Workflow execution cancelled${nodeId ? ` at ${nodeId}` : ''}`, this.executionCounter, nodeId);
-        }
-    }
-    sendStatusChangedEvent(args) {
-        if (this.flowWeaverDebugger) {
-            this.flowWeaverDebugger.sendEvent({
-                type: 'STATUS_CHANGED',
-                ...args,
-                innerFlowInvocation: this.flowWeaverDebugger.innerFlowInvocation,
-            });
-        }
-    }
-    sendVariableSetEvent(args) {
-        if (this.flowWeaverDebugger) {
-            this.flowWeaverDebugger.sendEvent({
-                type: 'VARIABLE_SET',
-                ...args,
-                innerFlowInvocation: this.flowWeaverDebugger.innerFlowInvocation,
-            });
-        }
-    }
-    sendLogErrorEvent(args) {
-        if (this.flowWeaverDebugger) {
-            this.flowWeaverDebugger.sendEvent({
-                type: 'LOG_ERROR',
-                ...args,
-                innerFlowInvocation: this.flowWeaverDebugger.innerFlowInvocation,
-            });
-        }
-    }
-    sendWorkflowCompletedEvent(args) {
-        if (this.flowWeaverDebugger) {
-            this.flowWeaverDebugger.sendEvent({
-                type: 'WORKFLOW_COMPLETED',
-                ...args,
-                innerFlowInvocation: this.flowWeaverDebugger.innerFlowInvocation,
-            });
-        }
-    }
-    /**
-     * Serialize the execution context state for checkpointing.
-     * Function values are resolved to concrete values before serialization.
-     */
-    serialize() {
-        const vars = {};
-        for (const [key, value] of this.variables) {
-            if (typeof value === 'function') {
-                try {
-                    vars[key] = value();
-                }
-                catch {
-                    vars[key] = value; // Let the checkpoint layer handle the marker
-                }
-            }
-            else {
-                vars[key] = value;
-            }
-        }
-        const execs = {};
-        for (const [key, info] of this.executions) {
-            execs[key] = { ...info };
-        }
-        const nodeCounts = {};
-        for (const [key, count] of this.nodeExecutionIndices) {
-            nodeCounts[key] = count;
-        }
-        return {
-            variables: vars,
-            executions: execs,
-            executionCounter: this.executionCounter,
-            nodeExecutionCounts: nodeCounts,
-        };
-    }
-    /**
-     * Restore execution context state from a checkpoint.
-     */
-    restore(data) {
-        this.variables = new Map(Object.entries(data.variables));
-        this.executions = new Map(Object.entries(data.executions));
-        this.executionCounter = data.executionCounter;
-        this.nodeExecutionIndices = new Map(Object.entries(data.nodeExecutionCounts));
-    }
-}
-//# sourceMappingURL=ExecutionContext.js.map