@synergenius/flow-weaver 0.33.1 → 0.44.0

package/dist/mcp/tools-workflow-run.js

@@ -1,150 +0,0 @@
-/**
- * MCP tools for running workflows with waitForAgent pause/resume support.
- *
- * fw_workflow_run: Starts a workflow. If it hits waitForAgent, returns the
- * agent request to the MCP caller (e.g. Claude Code) with status "waiting_for_agent".
- * If the workflow completes without pausing, returns the result directly.
- *
- * fw_workflow_resume: Resumes a paused workflow with the agent's result.
- * Returns the final workflow result (or pauses again if another waitForAgent is hit).
- */
-import { z } from 'zod';
-import { executeWorkflowFromFile } from './workflow-executor.js';
-import { AgentChannel } from './agent-channel.js';
-import { storePendingRun, getPendingRun, removePendingRun, } from './run-registry.js';
-function makeToolResult(data) {
-    return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
-}
-function makeErrorResult(code, message) {
-    return {
-        content: [{ type: 'text', text: JSON.stringify({ error: code, message }) }],
-        isError: true,
-    };
-}
-function generateRunId() {
-    return `run-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-}
-/**
- * Race between workflow completion and agent pause.
- * Returns whichever happens first.
- */
-async function raceAgentPause(executionPromise, agentChannel) {
-    try {
-        const outcome = await Promise.race([
-            executionPromise.then((r) => ({
-                type: 'completed',
-                result: r?.result ?? r,
-            })),
-            agentChannel.onPause().then((request) => ({
-                type: 'waiting_for_agent',
-                request,
-            })),
-        ]);
-        return outcome;
-    }
-    catch (err) {
-        return {
-            type: 'error',
-            message: err instanceof Error ? err.message : String(err),
-        };
-    }
-}
-/** Exposed for testing — run workflow with pause/resume support */
-export async function runWorkflowWithAgent(filePath, params, workflowName) {
-    const agentChannel = new AgentChannel();
-    const runId = generateRunId();
-    const executionPromise = executeWorkflowFromFile(filePath, params, {
-        workflowName,
-        agentChannel,
-        includeTrace: true,
-    });
-    const outcome = await raceAgentPause(executionPromise, agentChannel);
-    if (outcome.type === 'completed') {
-        return { status: 'completed', result: outcome.result };
-    }
-    if (outcome.type === 'waiting_for_agent') {
-        storePendingRun({
-            runId,
-            filePath,
-            workflowName,
-            executionPromise,
-            agentChannel,
-            request: outcome.request,
-            createdAt: Date.now(),
-            tmpFiles: [],
-        });
-        return { status: 'waiting_for_agent', runId, agentRequest: outcome.request, agentChannel };
-    }
-    return { status: 'error', message: outcome.message };
-}
-/** Exposed for testing — resume a paused workflow with agent result */
-export async function resumeWorkflow(runId, agentResult) {
-    const pendingRun = getPendingRun(runId);
-    if (!pendingRun) {
-        return { status: 'error', message: `No pending run found with ID "${runId}".` };
-    }
-    pendingRun.agentChannel.resume(agentResult);
-    const outcome = await raceAgentPause(pendingRun.executionPromise, pendingRun.agentChannel);
-    if (outcome.type === 'completed') {
-        removePendingRun(runId);
-        return { status: 'completed', result: outcome.result };
-    }
-    if (outcome.type === 'waiting_for_agent') {
-        pendingRun.request = outcome.request;
-        return { status: 'waiting_for_agent', runId, agentRequest: outcome.request, agentChannel: pendingRun.agentChannel };
-    }
-    removePendingRun(runId);
-    return { status: 'error', message: outcome.message };
-}
-export function registerWorkflowRunTools(mcp) {
-    // -------------------------------------------------------------------------
-    // fw_workflow_run - Start a workflow, pause at waitForAgent
-    // -------------------------------------------------------------------------
-    mcp.tool('fw_workflow_run', 'Run a workflow. If it hits a waitForAgent node, returns the agent request so ' +
-        'you can respond. If it completes without pausing, returns the result directly.', {
-        filePath: z.string().describe('Path to the workflow .ts file'),
-        params: z
-            .record(z.unknown())
-            .optional()
-            .describe('Input parameters for the workflow'),
-        workflowName: z
-            .string()
-            .optional()
-            .describe('Specific workflow export name (for multi-workflow files)'),
-    }, async (args) => {
-        try {
-            const result = await runWorkflowWithAgent(args.filePath, args.params ?? {}, args.workflowName);
-            if (result.status === 'error') {
-                return makeErrorResult('EXECUTION_ERROR', result.message);
-            }
-            // Don't leak agentChannel to MCP output
-            const { agentChannel: _ac, ...output } = result;
-            return makeToolResult(output);
-        }
-        catch (err) {
-            return makeErrorResult('EXECUTION_ERROR', err instanceof Error ? err.message : String(err));
-        }
-    });
-    // -------------------------------------------------------------------------
-    // fw_workflow_resume - Resume a paused workflow with agent result
-    // -------------------------------------------------------------------------
-    mcp.tool('fw_workflow_resume', 'Resume a workflow that paused at waitForAgent. Provide the agent result to continue execution.', {
-        runId: z.string().describe('Run ID from fw_workflow_run'),
-        agentResult: z
-            .record(z.unknown())
-            .describe('The agent result to pass back to the workflow'),
-    }, async (args) => {
-        try {
-            const result = await resumeWorkflow(args.runId, args.agentResult);
-            if (result.status === 'error') {
-                return makeErrorResult('RESUME_ERROR', result.message);
-            }
-            const { agentChannel: _ac, ...output } = result;
-            return makeToolResult(output);
-        }
-        catch (err) {
-            return makeErrorResult('RESUME_ERROR', err instanceof Error ? err.message : String(err));
-        }
-    });
-}
-//# sourceMappingURL=tools-workflow-run.js.map

package/dist/mcp/types.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=types.js.map

package/dist/mcp/workflow-executor.js

@@ -1,242 +0,0 @@
-/**
- * Workflow executor for MCP-side compilation and execution.
- * Copies source to a temp file, compiles all workflows in-place, then dynamically imports and executes.
- */
-import * as path from 'path';
-import * as fs from 'fs';
-import { pathToFileURL } from 'url';
-import ts from 'typescript';
-import { compileWorkflow } from '../api/index.js';
-import { getAvailableWorkflows } from '../api/workflow-file-operations.js';
-/**
- * Compiles and executes a workflow from a TypeScript source file.
- * Copies the source to a temp file, compiles all workflows in-place (preserving sibling
- * functions for workflow composition), injects a trace-capturing debugger, and dynamically
- * imports and runs the target workflow function.
- * @param filePath - Path to the workflow `.ts` source file.
- * @param params - Parameters to pass to the workflow function.
- * @param options - Execution options.
- * @param options.workflowName - Name of a specific exported workflow function to execute.
- *   If omitted, the first exported function is used.
- * @param options.production - Enable production mode (no debug events). Defaults to `!includeTrace`.
- * @param options.includeTrace - Whether to capture and return execution trace events. Defaults to `true`.
- * @returns The workflow result, function name, execution time, and optional trace.
- * @throws If no exported workflow function is found in the compiled module.
- */
-export async function executeWorkflowFromFile(filePath, params, options) {
-    const resolvedPath = path.resolve(filePath);
-    const includeTrace = options?.includeTrace !== false;
-    // Copy source to temp file and compile ALL workflows in-place there.
-    // In-place compilation preserves all functions in the module (node types,
-    // sibling workflows), which is required for workflow composition where one
-    // workflow calls another as a node type.
-    //
-    // Temp files are written in the source file's directory (not os.tmpdir())
-    // so that ESM module resolution can walk up to the project's node_modules.
-    // On Windows, os.tmpdir() is disconnected from the project tree, causing
-    // bare import specifiers (e.g. 'zod', 'openai') to fail with MODULE_NOT_FOUND.
-    const tmpId = `fw-exec-${Date.now()}-${Math.random().toString(36).slice(2)}`;
-    const tmpBase = path.join(path.dirname(resolvedPath), tmpId);
-    const tmpTsFile = `${tmpBase}.ts`;
-    const tmpFile = `${tmpBase}.mjs`;
-    try {
-        fs.copyFileSync(resolvedPath, tmpTsFile);
-        // Discover all workflows in the file
-        const source = fs.readFileSync(resolvedPath, 'utf8');
-        const allWorkflows = getAvailableWorkflows(source);
-        // Compile each workflow in-place so all function bodies are generated.
-        // Debug controller requires dev mode (production: false) so that
-        // __ctrl__.beforeNode/afterNode hooks are emitted in generated code.
-        const production = options?.debugController
-            ? false
-            : (options?.production ?? !includeTrace);
-        for (const wf of allWorkflows) {
-            await compileWorkflow(tmpTsFile, {
-                write: true,
-                inPlace: true,
-                parse: { workflowName: wf.functionName },
-                generate: { production },
-            });
-        }
-        // Inject debugger binding: replace the TypeScript-only `declare const`
-        // with an actual assignment from globalThis so the executor can pass
-        // a trace-capturing debugger at runtime.
-        let compiledCode = fs.readFileSync(tmpTsFile, 'utf8');
-        compiledCode = compiledCode.replace('declare const __flowWeaverDebugger__: TDebugger | undefined;', 'const __flowWeaverDebugger__ = (globalThis as any).__fw_debugger__;');
-        // Transpile TypeScript to JavaScript so Node.js can import it directly
-        const jsOutput = ts.transpileModule(compiledCode, {
-            compilerOptions: {
-                module: ts.ModuleKind.ESNext,
-                target: ts.ScriptTarget.ESNext,
-                esModuleInterop: true,
-            },
-        });
-        // 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 posixRelative = relative.replace(/\\/g, '/');
-                        const normalized = posixRelative.startsWith('.') ? posixRelative : `./${posixRelative}`;
-                        return `from '${normalized}'`;
-                    }
-                }
-                return _match;
-            });
-        }
-        fs.writeFileSync(tmpFile, transpiledOutput, 'utf8');
-        // Create debugger to capture trace events
-        const trace = [];
-        const debugger_ = includeTrace
-            ? {
-                sendEvent: (event) => {
-                    const traceEvent = {
-                        type: event.type || 'UNKNOWN',
-                        timestamp: Date.now(),
-                        data: event,
-                    };
-                    trace.push(traceEvent);
-                    options?.onEvent?.(traceEvent);
-                },
-                innerFlowInvocation: false,
-            }
-            : undefined;
-        // Set global debugger before import so compiled code picks it up
-        globalThis.__fw_debugger__ = debugger_;
-        // Set mock config for built-in nodes (delay, waitForEvent, invokeWorkflow)
-        if (options?.mocks) {
-            globalThis.__fw_mocks__ = options.mocks;
-        }
-        // Set agent channel for waitForAgent pause/resume
-        if (options?.agentChannel) {
-            globalThis.__fw_agent_channel__ = options.agentChannel;
-        }
-        // Set debug controller for step-through debugging and checkpoint/resume
-        if (options?.debugController) {
-            globalThis.__fw_debug_controller__ = options.debugController;
-        }
-        // Dynamic import using file:// URL for cross-platform compatibility
-        // (Windows paths like C:\... break with bare import() — "Received protocol 'c:'")
-        const mod = await import(pathToFileURL(tmpFile).href);
-        // Register exported functions for local invokeWorkflow resolution
-        const workflowRegistry = {};
-        for (const [key, value] of Object.entries(mod)) {
-            if (typeof value === 'function' && key !== '__esModule') {
-                workflowRegistry[key] = value;
-            }
-        }
-        globalThis.__fw_workflow_registry__ = workflowRegistry;
-        // Find the target exported function
-        const exportedFn = findExportedFunction(mod, options?.workflowName);
-        if (!exportedFn) {
-            const available = Object.entries(mod)
-                .filter(([k, v]) => k !== '__esModule' && typeof v === 'function')
-                .map(([k]) => k);
-            const availStr = available.length > 0 ? `. Available: ${available.join(', ')}` : '';
-            throw new Error(options?.workflowName
-                ? `Workflow "${options.workflowName}" not found in file${availStr}`
-                : `No exported workflow function found in file${availStr}`);
-        }
-        const startTime = Date.now();
-        // Execute the workflow function: (execute, params, abortSignal?)
-        // In-place compiled functions use the module-level debugger, not a parameter.
-        const result = await exportedFn.fn(true, params ?? {});
-        const executionTime = Date.now() - startTime;
-        return {
-            result,
-            functionName: exportedFn.name,
-            executionTime,
-            ...(includeTrace && { trace, summary: computeTraceSummary(trace) }),
-        };
-    }
-    finally {
-        // Clean up globals
-        delete globalThis.__fw_debugger__;
-        delete globalThis.__fw_mocks__;
-        delete globalThis.__fw_workflow_registry__;
-        delete globalThis.__fw_agent_channel__;
-        delete globalThis.__fw_debug_controller__;
-        // Clean up temp files
-        try {
-            fs.unlinkSync(tmpFile);
-        }
-        catch { /* ignore */ }
-        try {
-            fs.unlinkSync(tmpTsFile);
-        }
-        catch { /* ignore */ }
-    }
-}
-/** Compute a concise summary from raw trace events. */
-export function computeTraceSummary(trace) {
-    if (trace.length === 0) {
-        return { totalNodes: 0, succeeded: 0, failed: 0, cancelled: 0, nodeTimings: [], totalDurationMs: 0 };
-    }
-    const nodeStartTimes = new Map();
-    const nodeFinalStatus = new Map();
-    const nodeTimings = [];
-    for (const event of trace) {
-        if (event.type !== 'STATUS_CHANGED' || !event.data)
-            continue;
-        const id = event.data.id;
-        const status = event.data.status;
-        if (!id || !status)
-            continue;
-        if (status === 'RUNNING') {
-            nodeStartTimes.set(id, event.timestamp);
-        }
-        if (status === 'SUCCEEDED' || status === 'FAILED' || status === 'CANCELLED') {
-            nodeFinalStatus.set(id, status);
-            const startTime = nodeStartTimes.get(id);
-            if (startTime !== undefined) {
-                nodeTimings.push({ nodeId: id, durationMs: event.timestamp - startTime });
-            }
-        }
-    }
-    let succeeded = 0;
-    let failed = 0;
-    let cancelled = 0;
-    for (const status of nodeFinalStatus.values()) {
-        if (status === 'SUCCEEDED')
-            succeeded++;
-        else if (status === 'FAILED')
-            failed++;
-        else if (status === 'CANCELLED')
-            cancelled++;
-    }
-    const totalDurationMs = trace[trace.length - 1].timestamp - trace[0].timestamp;
-    return {
-        totalNodes: nodeFinalStatus.size,
-        succeeded,
-        failed,
-        cancelled,
-        nodeTimings,
-        totalDurationMs,
-    };
-}
-function findExportedFunction(mod, preferredName) {
-    // If a preferred name is specified, try it first
-    if (preferredName && typeof mod[preferredName] === 'function') {
-        return { name: preferredName, fn: mod[preferredName] };
-    }
-    // Find first exported function (skip default if it's not a function)
-    for (const [key, value] of Object.entries(mod)) {
-        if (key === '__esModule')
-            continue;
-        if (typeof value === 'function') {
-            return { name: key, fn: value };
-        }
-    }
-    return null;
-}
-//# sourceMappingURL=workflow-executor.js.map

package/dist/migration/registry.js

@@ -1,29 +0,0 @@
-/**
- * Edge-Case Migration Registry
- *
- * The parse → generate round-trip handles ~95% of migrations automatically:
- * the parser adds defaults for missing fields, and the generator writes
- * current syntax. This registry is only for rare cases where that
- * round-trip can't handle a change (e.g., semantic renames, removed features).
- *
- * Expected growth: ~1-2 entries per year.
- */
-/**
- * Registry of edge-case migrations. Starts empty.
- * Add entries only when the parse→generate round-trip can't handle a change.
- */
-const migrations = [];
-/**
- * Apply all registered edge-case migrations to a workflow AST.
- * Called after parsing, before regeneration.
- */
-export function applyMigrations(ast) {
-    return migrations.reduce((current, migration) => migration.apply(current), ast);
-}
-/**
- * Get the list of registered migrations (for diagnostics/logging).
- */
-export function getRegisteredMigrations() {
-    return migrations.map((m) => ({ name: m.name }));
-}
-//# sourceMappingURL=registry.js.map

package/dist/node-types-generator.js

@@ -1,139 +0,0 @@
-import { RESERVED_PORT_NAMES, isExecutePort, isSuccessPort, isFailurePort, } from "./constants.js";
-export class NodeTypesGenerator {
-    generateNodeType(node, filePath, projectPath) {
-        const ports = [];
-        let portOrder = 0;
-        ports.push({
-            name: RESERVED_PORT_NAMES.EXECUTE,
-            defaultLabel: "Execute",
-            reference: RESERVED_PORT_NAMES.EXECUTE,
-            type: "STEP",
-            direction: "INPUT",
-            defaultOrder: portOrder++,
-        });
-        ports.push({
-            name: RESERVED_PORT_NAMES.ON_SUCCESS,
-            defaultLabel: "On Success",
-            reference: RESERVED_PORT_NAMES.ON_SUCCESS,
-            type: "STEP",
-            direction: "OUTPUT",
-            defaultOrder: portOrder++,
-        });
-        ports.push({
-            name: RESERVED_PORT_NAMES.ON_FAILURE,
-            defaultLabel: "On Failure",
-            reference: RESERVED_PORT_NAMES.ON_FAILURE,
-            type: "STEP",
-            direction: "OUTPUT",
-            failure: true,
-            defaultPlacement: "BOTTOM",
-            defaultOrder: portOrder++,
-        });
-        Object.entries(node.inputs).forEach(([portName, portConfig]) => {
-            if (isExecutePort(portName))
-                return;
-            ports.push({
-                name: portName,
-                defaultLabel: portConfig.label || this.formatLabel(portName),
-                reference: portName,
-                type: portConfig.dataType,
-                direction: "INPUT",
-                defaultOrder: portOrder++,
-                defaultHidden: portConfig.hidden,
-                ...(portConfig.scope && { scope: portConfig.scope }),
-            });
-        });
-        Object.entries(node.outputs).forEach(([portName, portConfig]) => {
-            if (isSuccessPort(portName) || isFailurePort(portName))
-                return;
-            ports.push({
-                name: portName,
-                defaultLabel: portConfig.label || this.formatLabel(portName),
-                reference: portName,
-                type: portConfig.dataType,
-                direction: "OUTPUT",
-                defaultOrder: portOrder++,
-                defaultHidden: portConfig.hidden,
-                ...(portConfig.scope && { scope: portConfig.scope }),
-            });
-        });
-        const functionText = node.functionText || '';
-        const parameters = this.extractParameters(functionText);
-        const synchronicity = this.determineSynchronicity(functionText);
-        const label = node.label || this.formatLabel(node.functionName);
-        const description = node.description ||
-            this.extractDescription(functionText) ||
-            `Node: ${label}`;
-        const category = "Custom";
-        return {
-            name: node.functionName,
-            variant: "LOCAL_FUNCTION",
-            synchronicity,
-            defaultLabel: label,
-            description,
-            category,
-            scopes: node.scope ? [node.scope] : node.scopes || [],
-            portConfigs: [],
-            ports,
-            defaultPullExecutionConfig: {
-                method: RESERVED_PORT_NAMES.EXECUTE,
-            },
-            path: filePath,
-            projectPath,
-            function: node.functionName,
-            parameters,
-        };
-    }
-    generateAllNodeTypes(nodes, filePath, projectPath) {
-        return nodes.map((node) => this.generateNodeType(node, filePath, projectPath));
-    }
-    generateNodeTypesModule(nodes, filePath, projectPath) {
-        const nodeTypes = this.generateAllNodeTypes(nodes, filePath, projectPath);
-        const lines = [];
-        lines.push("");
-        lines.push("");
-        lines.push("");
-        lines.push("import type { TLocalFunctionNodeType } from '@synergenius/flow-weaver';");
-        lines.push("");
-        lines.push("export const nodeTypes: TLocalFunctionNodeType[] = [");
-        nodeTypes.forEach((nodeType, idx) => {
-            lines.push(`  ${JSON.stringify(nodeType, null, 2)}${idx < nodeTypes.length - 1 ? "," : ""}`);
-        });
-        lines.push("];");
-        lines.push("");
-        nodeTypes.forEach((nodeType) => {
-            lines.push(`export const ${nodeType.name}NodeType = nodeTypes.find(n => n.name === '${nodeType.name}')!;`);
-        });
-        return lines.join("\n");
-    }
-    formatLabel(name) {
-        return name
-            .replace(/([A-Z])/g, " $1")
-            .replace(/^./, (str) => str.toUpperCase())
-            .trim();
-    }
-    extractDescription(functionText) {
-        const match = functionText.match(/\/\*\*\s*\n\s*\*\s*(.+?)\s*\n/);
-        return match ? match[1] : null;
-    }
-    extractParameters(functionText) {
-        const match = functionText.match(/function\s+\w+\s*\(([^)]*)\)/);
-        if (!match || !match[1])
-            return [];
-        return match[1]
-            .split(",")
-            .map((param) => param.trim().split(":")[0].trim())
-            .filter((p) => p.length > 0);
-    }
-    determineSynchronicity(functionText) {
-        if (functionText.includes("async function")) {
-            return "ASYNC";
-        }
-        if (!functionText.includes("await") && !functionText.includes("Promise")) {
-            return "SYNC";
-        }
-        return "BOTH";
-    }
-}
-export const nodeTypesGenerator = new NodeTypesGenerator();
-//# sourceMappingURL=node-types-generator.js.map

package/dist/parser/tag-registry.js

@@ -1,57 +0,0 @@
-/**
- * TagHandlerRegistry: dispatch table for pack-contributed JSDoc tag handlers.
- *
- * Packs declare tag handlers in their manifest. The parser populates this
- * registry at startup and delegates unknown tags to it before emitting
- * "unknown tag" warnings.
- */
-/**
- * Registry mapping tag names to pack-provided handler functions.
- * Used by the JSDoc parser to delegate tags it doesn't natively handle.
- */
-export class TagHandlerRegistry {
-    handlers = new Map();
-    /** Register a handler for one or more tag names. */
-    register(tags, namespace, scope, handler) {
-        const entry = { namespace, scope, handler };
-        for (const tag of tags) {
-            this.handlers.set(tag, entry);
-        }
-    }
-    /** Check if a handler is registered for the given tag. */
-    has(tagName) {
-        return this.handlers.has(tagName);
-    }
-    /** Get all registered tag names. */
-    getRegisteredTags() {
-        return [...this.handlers.keys()];
-    }
-    /**
-     * Handle a tag by delegating to the registered handler.
-     * The handler writes parsed data into `deployMap[namespace]`.
-     *
-     * @returns true if the tag was handled, false if no handler was found.
-     */
-    handle(tagName, comment, blockScope, deployMap, warnings) {
-        const entry = this.handlers.get(tagName);
-        if (!entry)
-            return false;
-        // Check scope compatibility
-        if (entry.scope !== 'both' && entry.scope !== blockScope) {
-            warnings.push(`@${tagName} is registered for ${entry.scope} blocks, not ${blockScope} blocks.`);
-            return true; // consumed, but with a warning
-        }
-        // Ensure the namespace slot exists
-        if (!deployMap[entry.namespace]) {
-            deployMap[entry.namespace] = {};
-        }
-        entry.handler(tagName, comment, {
-            deploy: deployMap[entry.namespace],
-            warnings,
-        });
-        return true;
-    }
-}
-/** Global tag handler registry singleton. Extensions register handlers here at startup. */
-export const tagHandlerRegistry = new TagHandlerRegistry();
-//# sourceMappingURL=tag-registry.js.map