@stackables/bridge 1.6.0 → 1.7.0

package/build/bridge-format.js

@@ -1,1270 +1,14 @@
 import { SELF_MODULE } from "./types.js";
-// ── Parser ──────────────────────────────────────────────────────────────────
+import { parseBridgeChevrotain } from "./parser/index.js";
+export { parsePath } from "./utils.js";
 /**
- * Parse .bridge text format into structured instructions.
- *
- * The .bridge format is a human-readable representation of connection wires.
- * Multiple blocks are separated by `---`.
- * Tool blocks define API tools, bridge blocks define wire mappings.
- *
- * @param text - Bridge definition text
- * @returns Array of instructions (Bridge, ToolDef)
- */
-const BRIDGE_VERSION = "1.4";
-// Keywords that cannot be used as tool names, aliases, or const names
-const RESERVED_KEYWORDS = new Set(["bridge", "with", "as", "from", "const", "tool", "version", "define"]);
-// Source identifiers reserved for their special meaning inside bridge/tool blocks
-const SOURCE_IDENTIFIERS = new Set(["input", "output", "context"]);
-function assertNotReserved(name, lineNum, label) {
-    if (RESERVED_KEYWORDS.has(name.toLowerCase())) {
-        throw new Error(`Line ${lineNum}: "${name}" is a reserved keyword and cannot be used as a ${label}`);
-    }
-    if (SOURCE_IDENTIFIERS.has(name.toLowerCase())) {
-        throw new Error(`Line ${lineNum}: "${name}" is a reserved source identifier and cannot be used as a ${label}`);
-    }
-}
-/**
- * Strip a trailing `# comment` from a single source line, respecting string
- * literals so that a `#` inside `"..."` is never treated as a comment marker.
- * Leading/trailing whitespace of the returned value is preserved (callers trim
- * the result themselves as needed).
+ * Parse .bridge text — delegates to the Chevrotain parser.
  */
-function stripInlineComment(line) {
-    let inString = false;
-    for (let i = 0; i < line.length; i++) {
-        if (line[i] === '"')
-            inString = !inString;
-        if (!inString && line[i] === "#")
-            return line.slice(0, i).trimEnd();
-    }
-    return line;
-}
 export function parseBridge(text) {
-    // Normalize: CRLF → LF, tabs → 2 spaces, inline comments stripped
-    const normalized = text.replace(/\r\n?/g, "\n").replace(/\t/g, "  ");
-    const allLines = normalized.split("\n").map(stripInlineComment);
-    // Version check — first non-blank, non-comment line must be `version 1.4`
-    const firstContentIdx = allLines.findIndex((l) => l.trim() !== "" && !l.trim().startsWith("#"));
-    if (firstContentIdx === -1 || !/^version\s+/.test(allLines[firstContentIdx].trim())) {
-        throw new Error(`Missing version declaration. Bridge files must begin with: version ${BRIDGE_VERSION}`);
-    }
-    const versionToken = allLines[firstContentIdx].trim().replace(/^version\s+/, "");
-    if (versionToken !== BRIDGE_VERSION) {
-        throw new Error(`Unsupported bridge version "${versionToken}". This parser requires: version ${BRIDGE_VERSION}`);
-    }
-    // Blank out the version line so block-splitting ignores it
-    allLines[firstContentIdx] = "";
-    // Find separator lines (--- with optional surrounding whitespace)
-    const isSep = (line) => /^\s*---\s*$/.test(line);
-    // Collect block ranges as [start, end) line indices
-    const blockRanges = [];
-    let blockStart = 0;
-    for (let i = 0; i < allLines.length; i++) {
-        if (isSep(allLines[i])) {
-            blockRanges.push({ start: blockStart, end: i });
-            blockStart = i + 1;
-        }
-    }
-    blockRanges.push({ start: blockStart, end: allLines.length });
-    const instructions = [];
-    for (const { start, end } of blockRanges) {
-        const blockLines = allLines.slice(start, end);
-        // Split into sub-blocks by top-level `tool` or `bridge` keywords
-        const subBlocks = [];
-        let currentLines = [];
-        let currentOffset = start;
-        for (let i = 0; i < blockLines.length; i++) {
-            const trimmed = blockLines[i].trim();
-            if (/^(tool|bridge|const|define)\s/i.test(trimmed) && currentLines.length > 0) {
-                // Check if any non-blank content exists
-                if (currentLines.some((l) => l.trim())) {
-                    subBlocks.push({ startOffset: currentOffset, lines: currentLines });
-                }
-                currentLines = [blockLines[i]];
-                currentOffset = start + i;
-            }
-            else {
-                currentLines.push(blockLines[i]);
-            }
-        }
-        if (currentLines.some((l) => l.trim())) {
-            subBlocks.push({ startOffset: currentOffset, lines: currentLines });
-        }
-        for (const sub of subBlocks) {
-            const subText = sub.lines.join("\n").trim();
-            if (!subText)
-                continue;
-            let firstContentLine = 0;
-            while (firstContentLine < sub.lines.length && !sub.lines[firstContentLine].trim())
-                firstContentLine++;
-            const firstLine = sub.lines[firstContentLine]?.trim();
-            if (firstLine && /^tool\s/i.test(firstLine)) {
-                instructions.push(parseToolBlock(subText, sub.startOffset + firstContentLine, instructions));
-            }
-            else if (firstLine && /^define\s/i.test(firstLine)) {
-                instructions.push(parseDefineBlock(subText, sub.startOffset + firstContentLine));
-            }
-            else if (firstLine && /^bridge\s/i.test(firstLine)) {
-                instructions.push(...parseBridgeBlock(subText, sub.startOffset + firstContentLine, instructions));
-            }
-            else if (firstLine && /^const\s/i.test(firstLine)) {
-                instructions.push(...parseConstLines(subText, sub.startOffset + firstContentLine));
-            }
-            else if (firstLine && !firstLine.startsWith("#")) {
-                throw new Error(`Line ${sub.startOffset + firstContentLine + 1}: Expected "tool", "define", "bridge", or "const" declaration, got: ${firstLine}`);
-            }
-        }
-    }
-    return instructions;
-}
-// ── Bridge block parser ─────────────────────────────────────────────────────
-/**
- * Returns true when the token looks like a JSON literal rather than a
- * source reference (dotted path or pipe chain).
- * JSON start chars: `"`, `{`, `[`, digit, `-` + digit, `true`, `false`, `null`.
- */
-function isJsonLiteral(s) {
-    return /^["\{\[\d]/.test(s) || /^-\d/.test(s) ||
-        s === "true" || s === "false" || s === "null";
-}
-function parseBridgeBlock(block, lineOffset, previousInstructions) {
-    // ── Passthrough shorthand: `bridge Type.field with <name>` ──────────
-    // Expands into a full bridge that wires all input through the named
-    // handle (typically a define) and returns its output directly.
-    const shorthandMatch = block.match(/^bridge\s+(\w+)\.(\w+)\s+with\s+(\S+)\s*$/im);
-    if (shorthandMatch) {
-        const [, sType, sField, sName] = shorthandMatch;
-        const sHandle = sName.includes(".") ? sName.substring(sName.lastIndexOf(".") + 1) : sName;
-        const expanded = [
-            `bridge ${sType}.${sField} {`,
-            `  with ${sName} as ${sHandle}`,
-            `  with input`,
-            `  with output as __out`,
-            `  ${sHandle} <- input`,
-            `  __out <- ${sHandle}`,
-            `}`,
-        ].join("\n");
-        const result = parseBridgeBlock(expanded, lineOffset, previousInstructions);
-        // Tag the bridge instruction with the passthrough name for serialization
-        const bridgeInst = result.find((i) => i.kind === "bridge");
-        if (bridgeInst)
-            bridgeInst.passthrough = sName;
-        return result;
-    }
-    // Validate mandatory braces: `bridge Foo.bar {` ... `}`
-    const rawLines = block.split("\n");
-    const keywordIdx = rawLines.findIndex((l) => /^bridge\s/i.test(l.trim()));
-    if (keywordIdx !== -1) {
-        const kw = rawLines[keywordIdx].trim();
-        if (!kw.endsWith("{")) {
-            throw new Error(`Line ${lineOffset + keywordIdx + 1}: bridge block must use braces: bridge Type.field {`);
-        }
-        const hasClose = rawLines.some((l) => l.trimEnd() === "}");
-        if (!hasClose) {
-            throw new Error(`Line ${lineOffset + keywordIdx + 1}: bridge block missing closing }`);
-        }
-    }
-    // Strip braces for internal parsing
-    const lines = rawLines.map((l) => {
-        const trimmed = l.trimEnd();
-        if (trimmed === "}")
-            return "";
-        if (/^bridge\s/i.test(trimmed) && trimmed.endsWith("{"))
-            return trimmed.replace(/\s*\{\s*$/, "");
-        return trimmed;
-    });
-    const instructions = [];
-    /** 1-based global line number for error messages */
-    const ln = (i) => lineOffset + i + 1;
-    // ── Parse header ────────────────────────────────────────────────────
-    let bridgeType = "";
-    let bridgeField = "";
-    const handleRes = new Map();
-    const handleBindings = [];
-    const instanceCounters = new Map();
-    let bodyStartIndex = 0;
-    for (let i = 0; i < lines.length; i++) {
-        const line = lines[i].trim();
-        if (!line || line.startsWith("#")) {
-            continue;
-        }
-        if (/^bridge\s/i.test(line)) {
-            const match = line.match(/^bridge\s+(\w+)\.(\w+)$/i);
-            if (!match)
-                throw new Error(`Line ${ln(i)}: Invalid bridge declaration: ${line}`);
-            bridgeType = match[1];
-            bridgeField = match[2];
-            continue;
-        }
-        if (/^with\s/i.test(line)) {
-            if (!bridgeType) {
-                throw new Error(`Line ${ln(i)}: "with" declaration must come after "bridge" declaration`);
-            }
-            parseWithDeclaration(line, bridgeType, bridgeField, handleRes, handleBindings, instanceCounters, previousInstructions ?? [], ln(i));
-            continue;
-        }
-        // First non-header line — body starts here
-        bodyStartIndex = i;
-        break;
-    }
-    if (!bridgeType || !bridgeField) {
-        throw new Error(`Line ${ln(0)}: Missing bridge declaration`);
-    }
-    // ── Parse wire lines ────────────────────────────────────────────────
-    const wires = [];
-    let currentArrayToPath = null;
-    let currentIterHandle = null;
-    const arrayIterators = {};
-    /** Monotonically-increasing index; combined with a high base to produce
-     *  fork instances that can never collide with regular handle instances. */
-    let nextForkSeq = 0;
-    const pipeHandleEntries = [];
-    /**
-     * Parse a source expression (`handle.path` or `h1:h2:source`) into bridge
-     * wires, returning the terminal NodeRef.
-     *
-     * For pipe chains: pushes the intermediate `.in <- prev` wires and registers
-     * the fork instances, then returns the fork-root ref. The caller is
-     * responsible for pushing the TERMINAL wire (forkRoot → target).
-     *
-     * For simple refs: returns the resolved NodeRef directly (no wires pushed).
-     *
-     * @param forceOnOutermost  When true, marks the outermost intermediate pipe
-     *                          wire with `force: true` (used for `<-!`).
-     */
-    function buildSourceExpr(sourceStr, lineNum, forceOnOutermost) {
-        const parts = sourceStr.split(":");
-        if (parts.length === 1) {
-            return resolveAddress(sourceStr, handleRes, bridgeType, bridgeField, lineNum);
-        }
-        // Pipe chain
-        const actualSource = parts[parts.length - 1];
-        const tokenChain = parts.slice(0, -1);
-        const parseToken = (t) => {
-            const dot = t.indexOf(".");
-            return dot === -1
-                ? { handleName: t, fieldName: "in" }
-                : { handleName: t.substring(0, dot), fieldName: t.substring(dot + 1) };
-        };
-        for (const tok of tokenChain) {
-            const { handleName } = parseToken(tok);
-            if (!handleRes.has(handleName)) {
-                throw new Error(`Line ${lineNum}: Undeclared handle in pipe: "${handleName}". Add 'with <tool> as ${handleName}' to the bridge header.`);
-            }
-        }
-        let prevOutRef = resolveAddress(actualSource, handleRes, bridgeType, bridgeField, lineNum);
-        const reversedTokens = [...tokenChain].reverse();
-        for (let idx = 0; idx < reversedTokens.length; idx++) {
-            const tok = reversedTokens[idx];
-            const { handleName, fieldName } = parseToken(tok);
-            const res = handleRes.get(handleName);
-            const forkInstance = 100000 + nextForkSeq++;
-            const forkKey = `${res.module}:${res.type}:${res.field}:${forkInstance}`;
-            pipeHandleEntries.push({
-                key: forkKey,
-                handle: handleName,
-                baseTrunk: { module: res.module, type: res.type, field: res.field, instance: res.instance },
-            });
-            const forkInRef = { module: res.module, type: res.type, field: res.field, instance: forkInstance, path: parsePath(fieldName) };
-            const forkRootRef = { module: res.module, type: res.type, field: res.field, instance: forkInstance, path: [] };
-            const isOutermost = idx === reversedTokens.length - 1;
-            wires.push({ from: prevOutRef, to: forkInRef, pipe: true, ...(forceOnOutermost && isOutermost ? { force: true } : {}) });
-            prevOutRef = forkRootRef;
-        }
-        return prevOutRef; // fork-root ref
-    }
-    // ── Whether we are inside an element-mapping brace block
-    let inElementBlock = false;
-    for (let i = bodyStartIndex; i < lines.length; i++) {
-        const raw = lines[i];
-        const line = raw.trim();
-        if (!line || line.startsWith("#")) {
-            continue;
-        }
-        // Closing brace of an element mapping block `{ ... }`
-        if (line === "}") {
-            if (inElementBlock) {
-                currentArrayToPath = null;
-                currentIterHandle = null;
-                inElementBlock = false;
-                continue;
-            }
-            throw new Error(`Line ${ln(i)}: Unexpected "}" — not inside an element block`);
-        }
-        // Element mapping lines (inside a brace block)
-        if (inElementBlock && currentArrayToPath) {
-            if (!line.startsWith(".")) {
-                throw new Error(`Line ${ln(i)}: Element mapping lines must start with ".": ${line}`);
-            }
-            // Constant: .target = "value" or .target = value
-            const elemConstMatch = line.match(/^\.(\S+)\s*=\s*(?:"([^"]*)"|(\S+))$/);
-            if (elemConstMatch) {
-                const [, fieldName, quotedValue, unquotedValue] = elemConstMatch;
-                const value = quotedValue ?? unquotedValue;
-                wires.push({
-                    value,
-                    to: {
-                        module: SELF_MODULE,
-                        type: bridgeType,
-                        field: bridgeField,
-                        element: true,
-                        path: [...currentArrayToPath, ...parsePath(fieldName)],
-                    },
-                });
-                continue;
-            }
-            // Simple pull: .target <- <iter>.source (element-relative, no fallbacks)
-            const iterPfx = `${currentIterHandle}.`;
-            const elemRelMatch = line.match(/^\.(\S+)\s*<-\s*(\S+)$/);
-            if (elemRelMatch && elemRelMatch[2].startsWith(iterPfx)) {
-                const toPath = [...currentArrayToPath, ...parsePath(elemRelMatch[1])];
-                const fromPath = parsePath(elemRelMatch[2].slice(iterPfx.length));
-                wires.push({
-                    from: {
-                        module: SELF_MODULE,
-                        type: bridgeType,
-                        field: bridgeField,
-                        element: true,
-                        path: fromPath,
-                    },
-                    to: {
-                        module: SELF_MODULE,
-                        type: bridgeType,
-                        field: bridgeField,
-                        path: toPath,
-                    },
-                });
-                continue;
-            }
-            // Pull with fallbacks: .target <- source || "fallback" ?? errorSrc (relative or handle path)
-            const elemArrowMatch = line.match(/^\.(\S+)\s*<-\s*(.+)$/);
-            if (elemArrowMatch) {
-                const [, toField, rhs] = elemArrowMatch;
-                const toPath = [...currentArrayToPath, ...parsePath(toField)];
-                const toRef = { module: SELF_MODULE, type: bridgeType, field: bridgeField, path: toPath };
-                // Strip ?? tail
-                let exprCore = rhs.trim();
-                let fallback;
-                let fallbackRefStr;
-                const qqIdx = exprCore.lastIndexOf(" ?? ");
-                if (qqIdx !== -1) {
-                    const tail = exprCore.slice(qqIdx + 4).trim();
-                    exprCore = exprCore.slice(0, qqIdx).trim();
-                    if (isJsonLiteral(tail))
-                        fallback = tail;
-                    else
-                        fallbackRefStr = tail;
-                }
-                // Split on || — last may be JSON literal (nullFallback)
-                const orParts = exprCore.split(" || ").map((s) => s.trim());
-                let nullFallback;
-                let sourceParts = orParts;
-                if (orParts.length > 1 && isJsonLiteral(orParts[orParts.length - 1])) {
-                    nullFallback = orParts[orParts.length - 1];
-                    sourceParts = orParts.slice(0, -1);
-                }
-                let fallbackRef;
-                let fallbackInternalWires = [];
-                if (fallbackRefStr) {
-                    const preLen = wires.length;
-                    fallbackRef = buildSourceExpr(fallbackRefStr, ln(i), false);
-                    fallbackInternalWires = wires.splice(preLen);
-                }
-                for (let ci = 0; ci < sourceParts.length; ci++) {
-                    const srcStr = sourceParts[ci];
-                    const isLast = ci === sourceParts.length - 1;
-                    // Element-relative source: starts with "<iter>."
-                    const iterPrefix = `${currentIterHandle}.`;
-                    let fromRef;
-                    if (srcStr.startsWith(iterPrefix)) {
-                        fromRef = {
-                            module: SELF_MODULE,
-                            type: bridgeType,
-                            field: bridgeField,
-                            element: true,
-                            path: parsePath(srcStr.slice(iterPrefix.length)),
-                        };
-                    }
-                    else if (srcStr.startsWith(".")) {
-                        throw new Error(`Line ${ln(i)}: Use "${currentIterHandle}.field" to reference element fields, not ".field"`);
-                    }
-                    else {
-                        fromRef = buildSourceExpr(srcStr, ln(i), false);
-                    }
-                    const lastAttrs = isLast ? {
-                        ...(nullFallback ? { nullFallback } : {}),
-                        ...(fallback ? { fallback } : {}),
-                        ...(fallbackRef ? { fallbackRef } : {}),
-                    } : {};
-                    wires.push({ from: fromRef, to: toRef, ...lastAttrs });
-                }
-                wires.push(...fallbackInternalWires);
-                continue;
-            }
-            throw new Error(`Line ${ln(i)}: Invalid element mapping line: ${line}`);
-        }
-        // Constant wire: target = "value" or target = value (unquoted)
-        const constantMatch = line.match(/^(\S+)\s*=\s*(?:"([^"]*)"|(\S+))$/);
-        if (constantMatch) {
-            const [, targetStr, quotedValue, unquotedValue] = constantMatch;
-            const value = quotedValue ?? unquotedValue;
-            const toRef = resolveAddress(targetStr, handleRes, bridgeType, bridgeField, ln(i));
-            assertNoTargetIndices(toRef, ln(i));
-            wires.push({ value, to: toRef });
-            continue;
-        }
-        // ── Wire: target <- A [|| B [|| C]] [|| "nullLiteral"] [?? errorSrc|"errorLiteral"]
-        const arrowMatch = line.match(/^(\S+)\s*<-(!?)\s*(.+)$/);
-        if (arrowMatch) {
-            const [, targetStr, forceFlag, rhs] = arrowMatch;
-            const force = forceFlag === "!";
-            const rhsTrimmed = rhs.trim();
-            // ── Array mapping: target <- source[] as <iter> {
-            //    Opens a brace-delimited element block.
-            const arrayBraceMatch = rhsTrimmed.match(/^(\S+)\[\]\s+as\s+(\w+)\s*\{\s*$/);
-            if (arrayBraceMatch) {
-                const fromClean = arrayBraceMatch[1];
-                const iterHandle = arrayBraceMatch[2];
-                assertNotReserved(iterHandle, ln(i), "iterator handle");
-                const fromRef = resolveAddress(fromClean, handleRes, bridgeType, bridgeField, ln(i));
-                const toRef = resolveAddress(targetStr, handleRes, bridgeType, bridgeField, ln(i));
-                assertNoTargetIndices(toRef, ln(i));
-                wires.push({ from: fromRef, to: toRef });
-                currentArrayToPath = toRef.path;
-                currentIterHandle = iterHandle;
-                arrayIterators[toRef.path[0]] = iterHandle;
-                inElementBlock = true;
-                continue;
-            }
-            // ── Strip the ?? tail (last " ?? " wins in case source contains " ?? ")
-            let exprCore = rhsTrimmed;
-            let fallback;
-            let fallbackRefStr;
-            const qqIdx = rhsTrimmed.lastIndexOf(" ?? ");
-            if (qqIdx !== -1) {
-                exprCore = rhsTrimmed.slice(0, qqIdx).trim();
-                const tail = rhsTrimmed.slice(qqIdx + 4).trim();
-                if (isJsonLiteral(tail)) {
-                    fallback = tail;
-                }
-                else {
-                    fallbackRefStr = tail;
-                }
-            }
-            // ── Split on " || " to get coalesce chain parts
-            const orParts = exprCore.split(" || ").map((s) => s.trim());
-            // Last part may be a JSON literal → becomes nullFallback on the last source wire
-            let nullFallback;
-            let sourceParts = orParts;
-            if (orParts.length > 1 && isJsonLiteral(orParts[orParts.length - 1])) {
-                nullFallback = orParts[orParts.length - 1];
-                sourceParts = orParts.slice(0, -1);
-            }
-            if (sourceParts.length === 0) {
-                throw new Error(`Line ${ln(i)}: Wire has no source expression: ${line}`);
-            }
-            let fallbackRef;
-            let fallbackInternalWires = [];
-            if (fallbackRefStr) {
-                const preLen = wires.length;
-                fallbackRef = buildSourceExpr(fallbackRefStr, ln(i), false);
-                fallbackInternalWires = wires.splice(preLen);
-            }
-            const toRef = resolveAddress(targetStr, handleRes, bridgeType, bridgeField, ln(i));
-            assertNoTargetIndices(toRef, ln(i));
-            for (let ci = 0; ci < sourceParts.length; ci++) {
-                const isFirst = ci === 0;
-                const isLast = ci === sourceParts.length - 1;
-                const srcStr = sourceParts[ci];
-                const termRef = buildSourceExpr(srcStr, ln(i), force && isFirst);
-                const isPipeFork = termRef.instance != null && termRef.path.length === 0
-                    && srcStr.includes(":");
-                const lastAttrs = isLast ? {
-                    ...(nullFallback ? { nullFallback } : {}),
-                    ...(fallback ? { fallback } : {}),
-                    ...(fallbackRef ? { fallbackRef } : {}),
-                } : {};
-                if (isPipeFork) {
-                    wires.push({ from: termRef, to: toRef, pipe: true, ...lastAttrs });
-                }
-                else {
-                    wires.push({
-                        from: termRef,
-                        to: toRef,
-                        ...(force && isFirst ? { force: true } : {}),
-                        ...lastAttrs,
-                    });
-                }
-            }
-            wires.push(...fallbackInternalWires);
-            continue;
-        }
-        throw new Error(`Line ${ln(i)}: Unrecognized line: ${line}`);
-    }
-    // ── Inline define invocations ───────────────────────────────────────
-    const nextForkSeqRef = { value: nextForkSeq };
-    for (const hb of handleBindings) {
-        if (hb.kind !== "define")
-            continue;
-        const def = previousInstructions?.find((inst) => inst.kind === "define" && inst.name === hb.name);
-        if (!def) {
-            throw new Error(`Define "${hb.name}" referenced by handle "${hb.handle}" not found`);
-        }
-        inlineDefine(hb.handle, def, bridgeType, bridgeField, wires, pipeHandleEntries, handleBindings, instanceCounters, nextForkSeqRef);
-    }
-    instructions.unshift({
-        kind: "bridge",
-        type: bridgeType,
-        field: bridgeField,
-        handles: handleBindings,
-        wires,
-        arrayIterators: Object.keys(arrayIterators).length > 0 ? arrayIterators : undefined,
-        pipeHandles: pipeHandleEntries.length > 0 ? pipeHandleEntries : undefined,
-    });
-    return instructions;
-}
-/**
- * Parse a `with` declaration into handle bindings + resolution map.
- *
- * Supported forms:
- *   with <name> as <handle>     — tool reference (dotted or simple name)
- *   with <name>                 — shorthand: handle defaults to last segment of name
- *   with input as <handle>
- *   with context as <handle>
- *   with context                — shorthand for `with context as context`
- */
-function parseWithDeclaration(line, bridgeType, bridgeField, handleRes, handleBindings, instanceCounters, instructions, lineNum) {
-    /** Guard: reject duplicate handle names */
-    const checkDuplicate = (handle) => {
-        if (handleRes.has(handle)) {
-            throw new Error(`Line ${lineNum}: Duplicate handle name "${handle}"`);
-        }
-    };
-    // with input as <handle>
-    let match = line.match(/^with\s+input\s+as\s+(\w+)$/i);
-    if (match) {
-        const handle = match[1];
-        checkDuplicate(handle);
-        handleBindings.push({ handle, kind: "input" });
-        handleRes.set(handle, {
-            module: SELF_MODULE,
-            type: bridgeType,
-            field: bridgeField,
-        });
-        return;
-    }
-    // with input (shorthand — handle defaults to "input")
-    match = line.match(/^with\s+input$/i);
-    if (match) {
-        const handle = "input";
-        checkDuplicate(handle);
-        handleBindings.push({ handle, kind: "input" });
-        handleRes.set(handle, {
-            module: SELF_MODULE,
-            type: bridgeType,
-            field: bridgeField,
-        });
-        return;
-    }
-    // with output as <handle>
-    match = line.match(/^with\s+output\s+as\s+(\w+)$/i);
-    if (match) {
-        const handle = match[1];
-        checkDuplicate(handle);
-        handleBindings.push({ handle, kind: "output" });
-        handleRes.set(handle, {
-            module: SELF_MODULE,
-            type: bridgeType,
-            field: bridgeField,
-        });
-        return;
-    }
-    // with output (shorthand — handle defaults to "output")
-    match = line.match(/^with\s+output$/i);
-    if (match) {
-        const handle = "output";
-        checkDuplicate(handle);
-        handleBindings.push({ handle, kind: "output" });
-        handleRes.set(handle, {
-            module: SELF_MODULE,
-            type: bridgeType,
-            field: bridgeField,
-        });
-        return;
-    }
-    // with context as <handle>
-    match = line.match(/^with\s+context\s+as\s+(\w+)$/i);
-    if (match) {
-        const handle = match[1];
-        checkDuplicate(handle);
-        handleBindings.push({ handle, kind: "context" });
-        handleRes.set(handle, {
-            module: SELF_MODULE,
-            type: "Context",
-            field: "context",
-        });
-        return;
-    }
-    // with context (shorthand — handle defaults to "context")
-    match = line.match(/^with\s+context$/i);
-    if (match) {
-        const handle = "context";
-        checkDuplicate(handle);
-        handleBindings.push({ handle, kind: "context" });
-        handleRes.set(handle, {
-            module: SELF_MODULE,
-            type: "Context",
-            field: "context",
-        });
-        return;
-    }
-    // with const as <handle>
-    match = line.match(/^with\s+const\s+as\s+(\w+)$/i);
-    if (match) {
-        const handle = match[1];
-        checkDuplicate(handle);
-        handleBindings.push({ handle, kind: "const" });
-        handleRes.set(handle, {
-            module: SELF_MODULE,
-            type: "Const",
-            field: "const",
-        });
-        return;
-    }
-    // with const (shorthand — handle defaults to "const")
-    match = line.match(/^with\s+const$/i);
-    if (match) {
-        const handle = "const";
-        checkDuplicate(handle);
-        handleBindings.push({ handle, kind: "const" });
-        handleRes.set(handle, {
-            module: SELF_MODULE,
-            type: "Const",
-            field: "const",
-        });
-        return;
-    }
-    // with <name> as <handle> — check for define invocation first
-    match = line.match(/^with\s+(\S+)\s+as\s+(\w+)$/i);
-    if (match) {
-        const name = match[1];
-        const handle = match[2];
-        checkDuplicate(handle);
-        assertNotReserved(handle, lineNum, "handle alias");
-        // Check if name matches a known define
-        const defineDef = instructions.find((inst) => inst.kind === "define" && inst.name === name);
-        if (defineDef) {
-            handleBindings.push({ handle, kind: "define", name });
-            handleRes.set(handle, {
-                module: `__define_${handle}`,
-                type: bridgeType,
-                field: bridgeField,
-            });
-            return;
-        }
-        const lastDot = name.lastIndexOf(".");
-        if (lastDot !== -1) {
-            const modulePart = name.substring(0, lastDot);
-            const fieldPart = name.substring(lastDot + 1);
-            const key = `${modulePart}:${fieldPart}`;
-            const instance = (instanceCounters.get(key) ?? 0) + 1;
-            instanceCounters.set(key, instance);
-            handleBindings.push({ handle, kind: "tool", name });
-            handleRes.set(handle, {
-                module: modulePart,
-                type: bridgeType,
-                field: fieldPart,
-                instance,
-            });
-        }
-        else {
-            // Simple name — inline tool function
-            const key = `Tools:${name}`;
-            const instance = (instanceCounters.get(key) ?? 0) + 1;
-            instanceCounters.set(key, instance);
-            handleBindings.push({ handle, kind: "tool", name });
-            handleRes.set(handle, {
-                module: SELF_MODULE,
-                type: "Tools",
-                field: name,
-                instance,
-            });
-        }
-        return;
-    }
-    // with <name>  — shorthand: handle defaults to the last segment of name
-    // Must come after the `with input` / `with context` guards above.
-    match = line.match(/^with\s+(\S+)$/i);
-    if (match) {
-        const name = match[1];
-        const lastDot = name.lastIndexOf(".");
-        const handle = lastDot !== -1 ? name.substring(lastDot + 1) : name;
-        checkDuplicate(handle);
-        // Check if name matches a known define
-        const defineDef = instructions.find((inst) => inst.kind === "define" && inst.name === name);
-        if (defineDef) {
-            handleBindings.push({ handle, kind: "define", name });
-            handleRes.set(handle, {
-                module: `__define_${handle}`,
-                type: bridgeType,
-                field: bridgeField,
-            });
-            return;
-        }
-        if (lastDot !== -1) {
-            const modulePart = name.substring(0, lastDot);
-            const fieldPart = name.substring(lastDot + 1);
-            const key = `${modulePart}:${fieldPart}`;
-            const instance = (instanceCounters.get(key) ?? 0) + 1;
-            instanceCounters.set(key, instance);
-            handleBindings.push({ handle, kind: "tool", name });
-            handleRes.set(handle, { module: modulePart, type: bridgeType, field: fieldPart, instance });
-        }
-        else {
-            const key = `Tools:${name}`;
-            const instance = (instanceCounters.get(key) ?? 0) + 1;
-            instanceCounters.set(key, instance);
-            handleBindings.push({ handle, kind: "tool", name });
-            handleRes.set(handle, { module: SELF_MODULE, type: "Tools", field: name, instance });
-        }
-        return;
-    }
-    throw new Error(`Line ${lineNum}: Invalid with declaration: ${line}`);
-}
-// ── Define inlining ─────────────────────────────────────────────────────────
-/**
- * Inline a define invocation into a bridge's wires.
- *
- * Splits the define handle into separate input/output synthetic trunks,
- * clones the define's internal wires with remapped references, and adds
- * them to the bridge. Tool instances are remapped to avoid collisions.
- *
- * The executor treats synthetic trunks (module starting with `__define_`)
- * as pass-through data containers — no tool function is called.
- */
-function inlineDefine(defineHandle, defineDef, bridgeType, bridgeField, wires, pipeHandleEntries, handleBindings, instanceCounters, nextForkSeqRef) {
-    const genericModule = `__define_${defineHandle}`;
-    const inModule = `__define_in_${defineHandle}`;
-    const outModule = `__define_out_${defineHandle}`;
-    // The define was parsed as synthetic `bridge Define.<name>`, so its
-    // internal refs use type="Define", field=defineName for I/O, and
-    // standard tool resolutions for tools.
-    const defType = "Define";
-    const defField = defineDef.name;
-    // ── 1. Build trunk remapping for define's tool handles ──────────────
-    // Replay define's instance counter to determine original instances
-    const defCounters = new Map();
-    const trunkRemap = new Map();
-    for (const hb of defineDef.handles) {
-        if (hb.kind === "input" || hb.kind === "output" || hb.kind === "context" || hb.kind === "const")
-            continue;
-        if (hb.kind === "define")
-            continue; // nested defines — future
-        const name = hb.kind === "tool" ? hb.name : "";
-        if (!name)
-            continue;
-        const lastDot = name.lastIndexOf(".");
-        let oldModule, oldType, oldField, instanceKey, bridgeKey;
-        if (lastDot !== -1) {
-            oldModule = name.substring(0, lastDot);
-            oldType = defType;
-            oldField = name.substring(lastDot + 1);
-            instanceKey = `${oldModule}:${oldField}`;
-            bridgeKey = instanceKey;
-        }
-        else {
-            oldModule = SELF_MODULE;
-            oldType = "Tools";
-            oldField = name;
-            instanceKey = `Tools:${name}`;
-            bridgeKey = instanceKey;
-        }
-        // Old instance (from define's isolated counter)
-        const oldInstance = (defCounters.get(instanceKey) ?? 0) + 1;
-        defCounters.set(instanceKey, oldInstance);
-        // New instance (from bridge's counter)
-        const newInstance = (instanceCounters.get(bridgeKey) ?? 0) + 1;
-        instanceCounters.set(bridgeKey, newInstance);
-        const oldKey = `${oldModule}:${oldType}:${oldField}:${oldInstance}`;
-        trunkRemap.set(oldKey, { module: oldModule, type: oldType, field: oldField, instance: newInstance });
-        // Add internal tool handle to bridge's handle bindings (namespaced)
-        handleBindings.push({ handle: `${defineHandle}$${hb.handle}`, kind: "tool", name });
-    }
-    // ── 2. Remap bridge wires involving the define handle ───────────────
-    for (const wire of wires) {
-        if ("from" in wire) {
-            if (wire.to.module === genericModule) {
-                wire.to = { ...wire.to, module: inModule };
-            }
-            if (wire.from.module === genericModule) {
-                wire.from = { ...wire.from, module: outModule };
-            }
-            if (wire.fallbackRef?.module === genericModule) {
-                wire.fallbackRef = { ...wire.fallbackRef, module: outModule };
-            }
-        }
-        if ("value" in wire && wire.to.module === genericModule) {
-            wire.to = { ...wire.to, module: inModule };
-        }
-    }
-    // ── 3. Clone, remap, and add define's wires ────────────────────────
-    // Compute fork instance offset (define's fork instances start at 100000,
-    // bridge's may overlap — offset them to avoid collision)
-    const forkOffset = nextForkSeqRef.value;
-    let maxDefForkSeq = 0;
-    function remapRef(ref, side) {
-        // Define I/O trunk → split into input/output synthetic trunks
-        if (ref.module === SELF_MODULE && ref.type === defType && ref.field === defField) {
-            const targetModule = side === "from" ? inModule : outModule;
-            return { ...ref, module: targetModule, type: bridgeType, field: bridgeField };
-        }
-        // Tool trunk → remap instance
-        const key = `${ref.module}:${ref.type}:${ref.field}:${ref.instance ?? ""}`;
-        const newTrunk = trunkRemap.get(key);
-        if (newTrunk) {
-            return { ...ref, module: newTrunk.module, type: newTrunk.type, field: newTrunk.field, instance: newTrunk.instance };
-        }
-        // Fork instance → offset (fork instances are >= 100000)
-        if (ref.instance != null && ref.instance >= 100000) {
-            const defSeq = ref.instance - 100000;
-            if (defSeq + 1 > maxDefForkSeq)
-                maxDefForkSeq = defSeq + 1;
-            return { ...ref, instance: ref.instance + forkOffset };
-        }
-        return ref;
-    }
-    for (const wire of defineDef.wires) {
-        const cloned = JSON.parse(JSON.stringify(wire));
-        if ("from" in cloned) {
-            cloned.from = remapRef(cloned.from, "from");
-            cloned.to = remapRef(cloned.to, "to");
-            if (cloned.fallbackRef) {
-                cloned.fallbackRef = remapRef(cloned.fallbackRef, "from");
-            }
-        }
-        else {
-            // Constant wire
-            cloned.to = remapRef(cloned.to, "to");
-        }
-        wires.push(cloned);
-    }
-    // Advance bridge's fork counter past define's forks
-    nextForkSeqRef.value += maxDefForkSeq;
-    // ── 4. Remap and merge pipe handles ─────────────────────────────────
-    if (defineDef.pipeHandles) {
-        for (const ph of defineDef.pipeHandles) {
-            const parts = ph.key.split(":");
-            // key format: "module:type:field:instance"
-            const phInstance = parseInt(parts[parts.length - 1]);
-            let newKey = ph.key;
-            if (phInstance >= 100000) {
-                const newInst = phInstance + forkOffset;
-                parts[parts.length - 1] = String(newInst);
-                newKey = parts.join(":");
-            }
-            // Remap baseTrunk
-            const bt = ph.baseTrunk;
-            const btKey = `${bt.module}:${defType}:${bt.field}:${bt.instance ?? ""}`;
-            const newBt = trunkRemap.get(btKey);
-            // Also try with Tools type for simple names
-            const btKey2 = `${bt.module}:Tools:${bt.field}:${bt.instance ?? ""}`;
-            const newBt2 = trunkRemap.get(btKey2);
-            const resolvedBt = newBt ?? newBt2;
-            pipeHandleEntries.push({
-                key: newKey,
-                handle: `${defineHandle}$${ph.handle}`,
-                baseTrunk: resolvedBt
-                    ? { module: resolvedBt.module, type: resolvedBt.type, field: resolvedBt.field, instance: resolvedBt.instance }
-                    : ph.baseTrunk,
-            });
-        }
-    }
+    return parseBridgeChevrotain(text);
 }
-/**
- * Resolve an address string into a structured NodeRef.
- *
- * Resolution rules:
- *   1. No dot, but whole address is a declared handle → handle root (path: [])
- *   2. No dot, not a handle → output field on the bridge trunk
- *   3. Prefix matches a declared handle → resolve via handle binding
- *   4. Otherwise → nested output path (e.g., topPick.address)
- */
-function resolveAddress(address, handles, bridgeType, bridgeField, lineNum) {
-    const dotIndex = address.indexOf(".");
-    if (dotIndex === -1) {
-        // Whole address is a declared handle → resolve to its root (path: [])
-        const resolution = handles.get(address);
-        if (resolution) {
-            const ref = {
-                module: resolution.module,
-                type: resolution.type,
-                field: resolution.field,
-                path: [],
-            };
-            if (resolution.instance != null)
-                ref.instance = resolution.instance;
-            return ref;
-        }
-        // Strict scoping: every reference must go through a declared handle.
-        throw new Error(`${lineNum != null ? `Line ${lineNum}: ` : ""}Undeclared reference "${address}". ` +
-            `Add 'with output as o' for output fields, or 'with ${address}' for a tool.`);
-    }
-    const prefix = address.substring(0, dotIndex);
-    const rest = address.substring(dotIndex + 1);
-    const pathParts = parsePath(rest);
-    // Known handle
-    const resolution = handles.get(prefix);
-    if (resolution) {
-        const ref = {
-            module: resolution.module,
-            type: resolution.type,
-            field: resolution.field,
-            path: pathParts,
-        };
-        if (resolution.instance != null) {
-            ref.instance = resolution.instance;
-        }
-        return ref;
-    }
-    // Strict scoping: prefix must be a known handle.
-    throw new Error(`${lineNum != null ? `Line ${lineNum}: ` : ""}Undeclared handle "${prefix}". ` +
-        `Add 'with ${prefix}' or 'with ${prefix} as ${prefix}' to the bridge header.`);
-}
-/** Reject explicit array indices on the target (LHS) of a wire. */
-function assertNoTargetIndices(ref, lineNum) {
-    if (ref.path.some((seg) => /^\d+$/.test(seg))) {
-        throw new Error(`${lineNum != null ? `Line ${lineNum}: ` : ""}` +
-            `Explicit array index in wire target is not supported. ` +
-            `Use array mapping (\`[] as iter { }\`) instead.`);
-    }
-}
-// ── Const block parser ──────────────────────────────────────────────────────
-/**
- * Parse `const` declarations into ConstDef instructions.
- *
- * Supports single-line and multi-line JSON values:
- *   const fallbackGeo = { "lat": 0, "lon": 0 }
- *   const bigConfig = {
- *     "timeout": 5000,
- *     "retries": 3
- *   }
- *   const defaultCurrency = "EUR"
- *   const limit = 10
- */
-function parseConstLines(block, lineOffset) {
-    const lines = block.split("\n");
-    const results = [];
-    const ln = (i) => lineOffset + i + 1;
-    let i = 0;
-    while (i < lines.length) {
-        const line = lines[i].trim();
-        if (!line || line.startsWith("#")) {
-            i++;
-            continue;
-        }
-        const constMatch = line.match(/^const\s+(\w+)\s*=\s*(.*)/i);
-        if (!constMatch) {
-            throw new Error(`Line ${ln(i)}: Expected const declaration, got: ${line}`);
-        }
-        const name = constMatch[1];
-        assertNotReserved(name, ln(i), "const name");
-        let valuePart = constMatch[2].trim();
-        // Multi-line: if value starts with { or [ and isn't balanced, read more lines
-        if (/^[{[]/.test(valuePart)) {
-            let depth = 0;
-            for (const ch of valuePart) {
-                if (ch === "{" || ch === "[")
-                    depth++;
-                if (ch === "}" || ch === "]")
-                    depth--;
-            }
-            while (depth > 0 && i + 1 < lines.length) {
-                i++;
-                const nextLine = lines[i];
-                valuePart += "\n" + nextLine;
-                for (const ch of nextLine) {
-                    if (ch === "{" || ch === "[")
-                        depth++;
-                    if (ch === "}" || ch === "]")
-                        depth--;
-                }
-            }
-            if (depth !== 0) {
-                throw new Error(`Line ${ln(i)}: Unbalanced brackets in const "${name}"`);
-            }
-        }
-        // Validate the value is parseable JSON
-        const jsonValue = valuePart.trim();
-        try {
-            JSON.parse(jsonValue);
-        }
-        catch {
-            throw new Error(`Line ${ln(i)}: Invalid JSON value for const "${name}": ${jsonValue}`);
-        }
-        results.push({ kind: "const", name, value: jsonValue });
-        i++;
-    }
-    return results;
-}
-// ── Define block parser ─────────────────────────────────────────────────────
-/**
- * Parse a `define` block into a DefineDef instruction.
- *
- * Delegates to parseBridgeBlock with a synthetic `bridge Define.<name>` header,
- * then converts the resulting Bridge to a DefineDef template.
- *
- * Example:
- *   define secureProfile {
- *     with userApi as api
- *     with input as i
- *     with output as o
- *     api.id <- i.userId
- *     o.name <- api.login
- *   }
- */
-function parseDefineBlock(block, lineOffset) {
-    const rawLines = block.split("\n");
-    // Find the define header line
-    let headerIdx = -1;
-    let defineName = "";
-    for (let i = 0; i < rawLines.length; i++) {
-        const line = rawLines[i].trim();
-        if (!line || line.startsWith("#"))
-            continue;
-        const m = line.match(/^define\s+(\w+)\s*\{?\s*$/i);
-        if (!m) {
-            throw new Error(`Line ${lineOffset + i + 1}: Expected define declaration: define <name> {. Got: ${line}`);
-        }
-        defineName = m[1];
-        assertNotReserved(defineName, lineOffset + i + 1, "define name");
-        headerIdx = i;
-        break;
-    }
-    if (!defineName) {
-        throw new Error(`Line ${lineOffset + 1}: Missing define declaration`);
-    }
-    // Validate braces
-    const kw = rawLines[headerIdx].trim();
-    if (!kw.endsWith("{")) {
-        throw new Error(`Line ${lineOffset + headerIdx + 1}: define block must use braces: define ${defineName} {`);
-    }
-    const hasClose = rawLines.some((l) => l.trimEnd() === "}");
-    if (!hasClose) {
-        throw new Error(`Line ${lineOffset + headerIdx + 1}: define block missing closing }`);
-    }
-    // Rewrite header to a synthetic bridge: `bridge Define.<name> {`
-    const syntheticLines = [...rawLines];
-    syntheticLines[headerIdx] = rawLines[headerIdx]
-        .replace(/^(\s*)define\s+\w+/i, `$1bridge Define.${defineName}`);
-    const syntheticBlock = syntheticLines.join("\n");
-    const results = parseBridgeBlock(syntheticBlock, lineOffset);
-    const bridge = results[0];
-    return {
-        kind: "define",
-        name: defineName,
-        handles: bridge.handles,
-        wires: bridge.wires,
-        ...(bridge.arrayIterators ? { arrayIterators: bridge.arrayIterators } : {}),
-        ...(bridge.pipeHandles ? { pipeHandles: bridge.pipeHandles } : {}),
-    };
-}
-// ── Tool block parser ───────────────────────────────────────────────────────
-/**
- * Parse a `tool` block into a ToolDef instruction.
- *
- * Format:
- *   tool hereapi from httpCall {
- *     with context
- *     .baseUrl = "https://geocode.search.hereapi.com/v1"
- *     .headers.apiKey <- context.hereapi.apiKey
- *   }
- *
- *   tool hereapi.geocode from hereapi {
- *     .method = GET
- *     .path = /geocode
- *   }
- *
- * When the source matches a previously-defined tool name,
- * it's treated as inheritance (child inherits parent). Otherwise the source
- * is treated as a function name.
- */
-function parseToolBlock(block, lineOffset, previousInstructions) {
-    // Validate mandatory braces for blocks that have a body (deps / wires)
-    const rawLines = block.split("\n");
-    const keywordIdx = rawLines.findIndex((l) => /^tool\s/i.test(l.trim()));
-    if (keywordIdx !== -1) {
-        // Check if there are non-blank, non-comment body lines after the keyword
-        const bodyLines = rawLines.slice(keywordIdx + 1).filter((l) => {
-            const t = l.trim();
-            return t !== "" && !t.startsWith("#") && t !== "}";
-        });
-        const kw = rawLines[keywordIdx].trim();
-        if (bodyLines.length > 0) {
-            if (!kw.endsWith("{")) {
-                throw new Error(`Line ${lineOffset + keywordIdx + 1}: tool block with body must use braces: tool foo from bar {`);
-            }
-            const hasClose = rawLines.some((l) => l.trimEnd() === "}");
-            if (!hasClose) {
-                throw new Error(`Line ${lineOffset + keywordIdx + 1}: tool block missing closing }`);
-            }
-        }
-    }
-    // Strip braces for internal parsing
-    const lines = rawLines.map((l) => {
-        const trimmed = l.trimEnd();
-        if (trimmed === "}")
-            return "";
-        if (/^tool\s/i.test(trimmed) && trimmed.endsWith("{"))
-            return trimmed.replace(/\s*\{\s*$/, "");
-        return trimmed;
-    });
-    /** 1-based global line number for error messages */
-    const ln = (i) => lineOffset + i + 1;
-    let toolName = "";
-    let toolFn;
-    let toolExtends;
-    const deps = [];
-    const wires = [];
-    for (let i = 0; i < lines.length; i++) {
-        const raw = lines[i];
-        const line = raw.trim();
-        if (!line || line.startsWith("#"))
-            continue;
-        // Tool declaration: tool <name> from <source>
-        if (/^tool\s/i.test(line)) {
-            const toolMatch = line.match(/^tool\s+(\S+)\s+from\s+(\S+)$/i);
-            if (!toolMatch) {
-                throw new Error(`Line ${ln(i)}: Invalid tool declaration: ${line}. Expected: tool <name> from <source>`);
-            }
-            toolName = toolMatch[1];
-            const source = toolMatch[2];
-            assertNotReserved(toolName, ln(i), "tool name");
-            // If source matches a previously-defined tool, it's inheritance; otherwise it's a function name
-            const isKnownTool = previousInstructions?.some((inst) => inst.kind === "tool" && inst.name === source);
-            if (isKnownTool) {
-                toolExtends = source;
-            }
-            else {
-                toolFn = source;
-            }
-            continue;
-        }
-        // with context or with context as <handle>
-        const contextMatch = line.match(/^with\s+context(?:\s+as\s+(\w+))?$/i);
-        if (contextMatch) {
-            const handle = contextMatch[1] ?? "context";
-            deps.push({ kind: "context", handle });
-            continue;
-        }
-        // with const or with const as <handle>
-        const constDepMatch = line.match(/^with\s+const(?:\s+as\s+(\w+))?$/i);
-        if (constDepMatch) {
-            const handle = constDepMatch[1] ?? "const";
-            deps.push({ kind: "const", handle });
-            continue;
-        }
-        // with <tool> as <handle>
-        const toolDepMatch = line.match(/^with\s+(\S+)\s+as\s+(\w+)$/i);
-        if (toolDepMatch) {
-            deps.push({ kind: "tool", handle: toolDepMatch[2], tool: toolDepMatch[1] });
-            continue;
-        }
-        // on error = <json> (constant fallback)
-        const onErrorConstMatch = line.match(/^on\s+error\s*=\s*(.+)$/i);
-        if (onErrorConstMatch) {
-            let valuePart = onErrorConstMatch[1].trim();
-            // Multi-line JSON: if starts with { or [ and isn't balanced, read more lines
-            if (/^[{[]/.test(valuePart)) {
-                let depth = 0;
-                for (const ch of valuePart) {
-                    if (ch === "{" || ch === "[")
-                        depth++;
-                    if (ch === "}" || ch === "]")
-                        depth--;
-                }
-                while (depth > 0 && i + 1 < lines.length) {
-                    i++;
-                    const nextLine = lines[i];
-                    valuePart += "\n" + nextLine;
-                    for (const ch of nextLine) {
-                        if (ch === "{" || ch === "[")
-                            depth++;
-                        if (ch === "}" || ch === "]")
-                            depth--;
-                    }
-                }
-            }
-            wires.push({ kind: "onError", value: valuePart.trim() });
-            continue;
-        }
-        // on error <- source (pull fallback from context/dep)
-        const onErrorPullMatch = line.match(/^on\s+error\s*<-\s*(\S+)$/i);
-        if (onErrorPullMatch) {
-            wires.push({ kind: "onError", source: onErrorPullMatch[1] });
-            continue;
-        }
-        // Constant wire: .target = "value" or .target = value (unquoted)
-        const constantMatch = line.match(/^\.(\S+)\s*=\s*(?:"([^"]*)"|(\S+))$/);
-        if (constantMatch) {
-            const value = constantMatch[2] ?? constantMatch[3];
-            wires.push({
-                target: constantMatch[1],
-                kind: "constant",
-                value,
-            });
-            continue;
-        }
-        // Pull wire: .target <- source
-        const pullMatch = line.match(/^\.(\S+)\s*<-\s*(\S+)$/);
-        if (pullMatch) {
-            wires.push({ target: pullMatch[1], kind: "pull", source: pullMatch[2] });
-            continue;
-        }
-        // Catch bare param lines without leading dot — give a helpful error
-        if (/^[a-zA-Z]/.test(line)) {
-            throw new Error(`Line ${ln(i)}: Tool params require a dot prefix: ".${line.split(/[\s=<]/)[0]} ...". Only 'with' and 'on error' lines are unprefixed.`);
-        }
-        throw new Error(`Line ${ln(i)}: Unrecognized tool line: ${line}`);
-    }
-    if (!toolName)
-        throw new Error(`Line ${ln(0)}: Missing tool name`);
-    return {
-        kind: "tool",
-        name: toolName,
-        fn: toolFn,
-        extends: toolExtends,
-        deps,
-        wires,
-    };
-}
-// ── Path parser ─────────────────────────────────────────────────────────────
-/**
- * Parse a dot-separated path with optional array indices.
- *
- * "items[0].position.lat" → ["items", "0", "position", "lat"]
- * "properties[]"          → ["properties"]  ([] is stripped, signals array)
- * "x-message-id"          → ["x-message-id"]
- */
-export function parsePath(text) {
-    const parts = [];
-    for (const segment of text.split(".")) {
-        const match = segment.match(/^([^[]+)(?:\[(\d*)\])?$/);
-        if (match) {
-            parts.push(match[1]);
-            if (match[2] !== undefined && match[2] !== "") {
-                parts.push(match[2]);
-            }
-        }
-        else {
-            parts.push(segment);
-        }
-    }
-    return parts;
-}
-// ── Serializer ──────────────────────────────────────────────────────────────
-/**
- * Serialize structured instructions back to .bridge text format.
- */
+const BRIDGE_VERSION = "1.4";
+// ── Serializer ───────────────────────────────────────────────────────────────
 export function serializeBridge(instructions) {
     const bridges = instructions.filter((i) => i.kind === "bridge");
     const tools = instructions.filter((i) => i.kind === "tool");
@@ -1288,6 +32,21 @@ export function serializeBridge(instructions) {
     }
     return `version ${BRIDGE_VERSION}\n\n` + blocks.join("\n\n") + "\n";
 }
+/**
+ * Whether a value string needs quoting to be re-parseable as a bare value.
+ * Safe unquoted: number, boolean, null, /path, simple-identifier, keyword.
+ */
+function needsQuoting(v) {
+    if (v === "" || v === "true" || v === "false" || v === "null")
+        return false;
+    if (/^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?$/.test(v))
+        return false; // number
+    if (/^\/[\w./-]*$/.test(v))
+        return false; // /path
+    if (/^[a-zA-Z_][\w-]*$/.test(v))
+        return false; // identifier / keyword
+    return true;
+}
 function serializeToolBlock(tool) {
     const lines = [];
     const hasBody = tool.deps.length > 0 || tool.wires.length > 0;
@@ -1327,8 +86,7 @@ function serializeToolBlock(tool) {
             }
         }
         else if (wire.kind === "constant") {
-            // Use quoted form if value contains spaces or special chars, unquoted otherwise
-            if (/\s/.test(wire.value) || wire.value === "") {
+            if (needsQuoting(wire.value)) {
                 lines.push(`  .${wire.target} = "${wire.value}"`);
             }
             else {