@stackables/bridge-compiler 0.0.1 → 1.0.1

package/build/{parser → bridge-compiler/src/parser}/parser.js

@@ -5,7 +5,7 @@
  * Produces the *exact same* AST types (`Instruction[]`).
  */
 import { CstParser } from "chevrotain";
-import { allTokens, Identifier, VersionKw, ToolKw, BridgeKw, DefineKw, ConstKw, WithKw, AsKw, FromKw, InputKw, OutputKw, ContextKw, OnKw, ErrorKw, Arrow, ForceKw, AliasKw, AndKw, OrKw, NotKw, ThrowKw, PanicKw, ContinueKw, BreakKw, NullCoalesce, ErrorCoalesce, SafeNav, CatchKw, LParen, RParen, LCurly, RCurly, LSquare, RSquare, Equals, Dot, Colon, Comma, StringLiteral, NumberLiteral, PathToken, TrueLiteral, FalseLiteral, NullLiteral, Star, Slash, Plus, Minus, GreaterEqual, LessEqual, DoubleEquals, NotEquals, GreaterThan, LessThan, QuestionMark, BridgeLexer, } from "./lexer.js";
+import { allTokens, Identifier, VersionKw, ToolKw, BridgeKw, DefineKw, ConstKw, WithKw, AsKw, FromKw, InputKw, OutputKw, ContextKw, OnKw, ErrorKw, Arrow, ForceKw, AliasKw, AndKw, OrKw, NotKw, ThrowKw, PanicKw, ContinueKw, BreakKw, NullCoalesce, ErrorCoalesce, SafeNav, CatchKw, LParen, RParen, LCurly, RCurly, LSquare, RSquare, Equals, Dot, Colon, Comma, StringLiteral, NumberLiteral, PathToken, TrueLiteral, FalseLiteral, NullLiteral, Star, Slash, Plus, Minus, GreaterEqual, LessEqual, DoubleEquals, NotEquals, GreaterThan, LessThan, QuestionMark, VersionTag, BridgeLexer, } from "./lexer.js";
 import { SELF_MODULE } from "@stackables/bridge-core";
 // ── Reserved-word guards (mirroring the regex parser) ──────────────────────
 const RESERVED_KEYWORDS = new Set([
@@ -160,6 +160,9 @@ class BridgeParser extends CstParser {
                 },
                 ALT: () => {
                     this.SUBRULE(this.dottedName, { LABEL: "toolName" });
+                    this.OPTION3(() => {
+                        this.CONSUME(VersionTag, { LABEL: "toolVersion" });
+                    });
                     this.CONSUME3(AsKw);
                     this.SUBRULE3(this.nameToken, { LABEL: "toolAlias" });
                 },
@@ -350,6 +353,9 @@ class BridgeParser extends CstParser {
                 },
                 ALT: () => {
                     this.SUBRULE(this.dottedName, { LABEL: "refName" });
+                    this.OPTION6(() => {
+                        this.CONSUME(VersionTag, { LABEL: "refVersion" });
+                    });
                     this.OPTION5(() => {
                         this.CONSUME5(AsKw);
                         this.SUBRULE5(this.nameToken, { LABEL: "refAlias" });
@@ -1051,6 +1057,19 @@ const parserInstance = new BridgeParser();
 // Lenient instance: error recovery enabled (used by parseBridgeDiagnostics)
 const diagParserInstance = new BridgeParser({ recovery: true });
 const BRIDGE_VERSION = "1.5";
+/** Minimum major version the parser can handle (inclusive). */
+const BRIDGE_MIN_MAJOR = 1;
+/** Maximum major version the parser can handle (inclusive). */
+const BRIDGE_MAX_MAJOR = 1;
+/** Exported parser version metadata for runtime use. */
+export const PARSER_VERSION = {
+    /** Current bridge language version */
+    current: BRIDGE_VERSION,
+    /** Minimum supported major version (inclusive) */
+    minMajor: BRIDGE_MIN_MAJOR,
+    /** Maximum supported major version (inclusive) */
+    maxMajor: BRIDGE_MAX_MAJOR,
+};
 // ═══════════════════════════════════════════════════════════════════════════
 //  Public API
 // ═══════════════════════════════════════════════════════════════════════════
@@ -1100,11 +1119,11 @@ export function parseBridgeDiagnostics(text) {
         });
     }
     // 3. Visit → AST (semantic errors thrown as "Line N: ..." messages)
-    let instructions = [];
+    let document = { instructions: [] };
     let startLines = new Map();
     try {
         const result = toBridgeAst(cst, []);
-        instructions = result.instructions;
+        document = { version: result.version, instructions: result.instructions };
         startLines = result.startLines;
     }
     catch (err) {
@@ -1120,7 +1139,7 @@ export function parseBridgeDiagnostics(text) {
             },
         });
     }
-    return { instructions, diagnostics, startLines };
+    return { document, diagnostics, startLines };
 }
 function internalParse(text, previousInstructions) {
     // 1. Lex
@@ -1137,7 +1156,8 @@ function internalParse(text, previousInstructions) {
         throw new Error(e.message);
     }
     // 3. Visit → AST
-    return toBridgeAst(cst, previousInstructions).instructions;
+    const result = toBridgeAst(cst, previousInstructions);
+    return { version: result.version, instructions: result.instructions };
 }
 // ═══════════════════════════════════════════════════════════════════════════
 //  CST → AST transformation (imperative visitor)
@@ -2204,9 +2224,22 @@ function toBridgeAst(cst, previousInstructions) {
     }
     const versionTok = tok(versionDecl, "ver");
     const versionNum = versionTok?.image;
-    if (versionNum !== BRIDGE_VERSION) {
-        throw new Error(`Unsupported bridge version "${versionNum}". This parser requires: version ${BRIDGE_VERSION}`);
+    if (!versionNum) {
+        throw new Error(`Missing version number. Bridge files must begin with: version ${BRIDGE_VERSION}`);
+    }
+    // Accept any version whose major falls within the supported range.
+    // When the parser supports multiple majors (e.g. 1.x through 2.x),
+    // bridge files from any of them are valid syntax.
+    const vParts = versionNum.split(".");
+    const vMajor = parseInt(vParts[0], 10);
+    const supportedRange = BRIDGE_MIN_MAJOR === BRIDGE_MAX_MAJOR
+        ? `${BRIDGE_MIN_MAJOR}.x`
+        : `${BRIDGE_MIN_MAJOR}.x – ${BRIDGE_MAX_MAJOR}.x`;
+    if (isNaN(vMajor) || vMajor < BRIDGE_MIN_MAJOR || vMajor > BRIDGE_MAX_MAJOR) {
+        throw new Error(`Unsupported bridge major version "${versionNum}". This parser supports version ${supportedRange}`);
     }
+    // Store the declared version (lives on BridgeDocument, not in instructions).
+    const version = versionNum;
     const tagged = [];
     for (const n of subs(cst, "constDecl"))
         tagged.push({
@@ -2270,7 +2303,7 @@ function toBridgeAst(cst, previousInstructions) {
             }
         }
     }
-    return { instructions, startLines };
+    return { version, instructions, startLines };
 }
 // ── Const ───────────────────────────────────────────────────────────────
 function buildConstDef(node) {
@@ -2319,7 +2352,13 @@ function buildToolDef(node, previousInstructions) {
             else if (wc.toolName) {
                 const tName = extractDottedName(wc.toolName[0]);
                 const tAlias = extractNameToken(wc.toolAlias[0]);
-                deps.push({ kind: "tool", handle: tAlias, tool: tName });
+                const tVersion = wc.toolVersion?.[0]?.image.slice(1);
+                deps.push({
+                    kind: "tool",
+                    handle: tAlias,
+                    tool: tName,
+                    ...(tVersion ? { version: tVersion } : {}),
+                });
             }
             continue;
         }
@@ -2400,10 +2439,10 @@ function buildBridge(node, previousInstructions) {
             `}`,
         ].join("\n");
         const result = internalParse(expandedText, previousInstructions);
-        const bridgeInst = result.find((i) => i.kind === "bridge");
+        const bridgeInst = result.instructions.find((i) => i.kind === "bridge");
         if (bridgeInst)
             bridgeInst.passthrough = passthroughName;
-        return result;
+        return result.instructions;
     }
     // Full bridge block
     const bodyLines = subs(node, "bridgeBodyLine");
@@ -2530,6 +2569,7 @@ function buildBridgeBody(bodyLines, bridgeType, bridgeField, previousInstruction
         }
         else if (wc.refName) {
             const name = extractDottedName(wc.refName[0]);
+            const versionTag = wc.refVersion?.[0]?.image.slice(1);
             const lastDot = name.lastIndexOf(".");
             const defaultHandle = lastDot !== -1 ? name.substring(lastDot + 1) : name;
             const handle = wc.refAlias
@@ -2554,7 +2594,12 @@ function buildBridgeBody(bodyLines, bridgeType, bridgeField, previousInstruction
                 const key = `${modulePart}:${fieldPart}`;
                 const instance = (instanceCounters.get(key) ?? 0) + 1;
                 instanceCounters.set(key, instance);
-                handleBindings.push({ handle, kind: "tool", name });
+                handleBindings.push({
+                    handle,
+                    kind: "tool",
+                    name,
+                    ...(versionTag ? { version: versionTag } : {}),
+                });
                 handleRes.set(handle, {
                     module: modulePart,
                     type: bridgeType,
@@ -2566,7 +2611,12 @@ function buildBridgeBody(bodyLines, bridgeType, bridgeField, previousInstruction
                 const key = `Tools:${name}`;
                 const instance = (instanceCounters.get(key) ?? 0) + 1;
                 instanceCounters.set(key, instance);
-                handleBindings.push({ handle, kind: "tool", name });
+                handleBindings.push({
+                    handle,
+                    kind: "tool",
+                    name,
+                    ...(versionTag ? { version: versionTag } : {}),
+                });
                 handleRes.set(handle, {
                     module: SELF_MODULE,
                     type: "Tools",

package/build/bridge-core/src/ExecutionTree.d.ts

@@ -0,0 +1,213 @@
+import type { Bridge, BridgeDocument, ToolMap } from "./types.ts";
+/** Fatal panic error — bypasses all error boundaries (`?.` and `catch`). */
+export declare class BridgePanicError extends Error {
+    constructor(message: string);
+}
+/** Abort error — raised when an external AbortSignal cancels execution. */
+export declare class BridgeAbortError extends Error {
+    constructor(message?: string);
+}
+/** Maximum shadow-tree nesting depth before a BridgePanicError is thrown. */
+export declare const MAX_EXECUTION_DEPTH = 30;
+/**
+ * Structured logger interface for Bridge engine events.
+ * Accepts any compatible logger: pino, winston, bunyan, `console`, etc.
+ * All methods default to silent no-ops when no logger is provided.
+ */
+export interface Logger {
+    debug?: (...args: any[]) => void;
+    info?: (...args: any[]) => void;
+    warn?: (...args: any[]) => void;
+    error?: (...args: any[]) => void;
+}
+/** Matches graphql's internal Path type (not part of the public exports map) */
+interface Path {
+    readonly prev: Path | undefined;
+    readonly key: string | number;
+    readonly typename: string | undefined;
+}
+type Trunk = {
+    module: string;
+    type: string;
+    field: string;
+    instance?: number;
+};
+/** Trace verbosity level.
+ *  - `"off"` (default) — no collection, zero overhead
+ *  - `"basic"` — tool, fn, timing, errors; no input/output
+ *  - `"full"` — everything including input and output */
+export type TraceLevel = "basic" | "full" | "off";
+/** A single recorded tool invocation. */
+export type ToolTrace = {
+    /** Tool name as resolved (e.g. "hereGeo", "std.str.toUpperCase") */
+    tool: string;
+    /** The function that was called (e.g. "httpCall", "upperCase") */
+    fn: string;
+    /** Input object passed to the tool function (only in "full" level) */
+    input?: Record<string, any>;
+    /** Resolved output (only in "full" level, on success) */
+    output?: any;
+    /** Error message (present when the tool threw) */
+    error?: string;
+    /** Wall-clock duration in milliseconds */
+    durationMs: number;
+    /** Monotonic timestamp (ms) relative to the first trace in the request */
+    startedAt: number;
+};
+/** Shared trace collector — one per request, passed through the tree. */
+export declare class TraceCollector {
+    readonly traces: ToolTrace[];
+    readonly level: "basic" | "full";
+    private readonly epoch;
+    constructor(level?: "basic" | "full");
+    /** Returns ms since the collector was created */
+    now(): number;
+    record(trace: ToolTrace): void;
+    /** Build a trace entry, omitting input/output for basic level. */
+    entry(base: {
+        tool: string;
+        fn: string;
+        startedAt: number;
+        durationMs: number;
+        input?: Record<string, any>;
+        output?: any;
+        error?: string;
+    }): ToolTrace;
+}
+export declare class ExecutionTree {
+    trunk: Trunk;
+    private document;
+    private context?;
+    private parent?;
+    state: Record<string, any>;
+    bridge: Bridge | undefined;
+    private toolDepCache;
+    private toolDefCache;
+    private pipeHandleMap;
+    /**
+     * Maps trunk keys to `@version` strings from handle bindings.
+     * Populated in the constructor so `schedule()` can prefer versioned
+     * tool lookups (e.g. `std.str.toLowerCase@999.1`) over the default.
+     */
+    private handleVersionMap;
+    /** Promise that resolves when all critical `force` handles have settled. */
+    private forcedExecution?;
+    /** Shared trace collector — present only when tracing is enabled. */
+    tracer?: TraceCollector;
+    /** Structured logger passed from BridgeOptions. Defaults to no-ops. */
+    logger?: Logger;
+    /** External abort signal — cancels execution when triggered. */
+    signal?: AbortSignal;
+    private toolFns?;
+    /** Shadow-tree nesting depth (0 for root). */
+    private depth;
+    constructor(trunk: Trunk, document: BridgeDocument, toolFns?: ToolMap, context?: Record<string, any> | undefined, parent?: ExecutionTree | undefined);
+    /** Derive tool name from a trunk */
+    private getToolName;
+    /** Deep-lookup a tool function by dotted name (e.g. "std.str.toUpperCase").
+     *  Falls back to a flat key lookup for backward compat (e.g. "hereapi.geocode" as literal key). */
+    private lookupToolFn;
+    /** Resolve a ToolDef by name, merging the extends chain (cached) */
+    private resolveToolDefByName;
+    /** Resolve a tool definition's wires into a nested input object */
+    private resolveToolWires;
+    /** Resolve a source reference from a tool wire against its dependencies */
+    private resolveToolSource;
+    /** Call a tool dependency (cached per request) */
+    private resolveToolDep;
+    schedule(target: Trunk, pullChain?: Set<string>): any;
+    /**
+     * Invoke a tool function, recording both an OpenTelemetry span and (when
+     * tracing is enabled) a ToolTrace entry.  All three tool-call sites in the
+     * engine delegate here so instrumentation lives in exactly one place.
+     */
+    private callTool;
+    shadow(): ExecutionTree;
+    /** Returns collected traces (empty array when tracing is disabled). */
+    getTraces(): ToolTrace[];
+    private pullSingle;
+    push(args: Record<string, any>): void;
+    /** Store the aggregated promise for critical forced handles so
+     *  `response()` can await it exactly once per bridge execution. */
+    setForcedExecution(p: Promise<void>): void;
+    /** Return the critical forced-execution promise (if any). */
+    getForcedExecution(): Promise<void> | undefined;
+    /**
+     * Eagerly schedule tools targeted by `force <handle>` statements.
+     *
+     * Returns an array of promises for **critical** forced handles (those
+     * without `?? null`).  Fire-and-forget handles (`catchError: true`) are
+     * scheduled but their errors are silently suppressed.
+     *
+     * Callers must `await Promise.all(...)` the returned promises so that a
+     * critical force failure propagates as a standard error.
+     */
+    executeForced(): Promise<any>[];
+    /**
+     * Resolve a set of matched wires.
+     *
+     * Architecture: two distinct resolution axes —
+     *
+     *  **Falsy Gate** (`||`, within a wire): `falsyFallbackRefs` + `falsyFallback`
+     *    → truthy check — falsy values (0, "", false) trigger fallback chain.
+     *
+     *  **Overdefinition** (across wires): multiple wires target the same path
+     *    → nullish check — only null/undefined falls through to the next wire.
+     *
+     * Per-wire layers:
+     *   Layer 1  — Execution (pullSingle + safe modifier)
+     *   Layer 2a — Falsy Gate   (falsyFallbackRefs → falsyFallback / falsyControl)
+     *   Layer 2b — Nullish Gate  (nullishFallbackRef / nullishFallback / nullishControl)
+     *   Layer 3  — Catch         (catchFallbackRef / catchFallback / catchControl)
+     *
+     * After layers 1–2b, the overdefinition boundary (`!= null`) decides whether
+     * to return or continue to the next wire.
+     */
+    private resolveWires;
+    /**
+     * Resolve an output field by path for use outside of a GraphQL resolver.
+     *
+     * This is the non-GraphQL equivalent of what `response()` does per field:
+     * it finds all wires targeting `this.trunk` at `path` and resolves them.
+     *
+     * Used by `executeBridge()` so standalone bridge execution does not need to
+     * fabricate GraphQL Path objects to pull output data.
+     *
+     * @param path - Output field path, e.g. `["lat"]`. Pass `[]` for whole-output
+     *               array bridges (`o <- items[] as x { ... }`).
+     * @param array - When `true` and the result is an array, wraps each element
+     *               in a shadow tree (mirrors `response()` array handling).
+     */
+    pullOutputField(path: string[], array?: boolean): Promise<unknown>;
+    /**
+     * Execute the bridge end-to-end without GraphQL.
+     *
+     * Injects `input` as the trunk arguments, runs forced wires, then pulls
+     * and materialises every output field into a plain JS object (or array of
+     * objects for array-mapped bridges).
+     *
+     * This is the single entry-point used by `executeBridge()`.
+     */
+    run(input: Record<string, unknown>): Promise<unknown>;
+    /**
+     * Recursively convert shadow trees into plain JS objects.
+     *
+     * Wire categories at each level (prefix = P):
+     *   Leaf  — `to.path = [...P, name]`, no deeper paths → scalar
+     *   Array — direct wire AND deeper paths → pull as array, recurse
+     *   Nested object — only deeper paths, no direct wire → pull each
+     *             full path and assemble via setNested
+     */
+    private materializeShadows;
+    response(ipath: Path, array: boolean): Promise<any>;
+    /**
+     * Find define output wires for a specific field path.
+     *
+     * Looks for whole-object define forward wires (`o <- defineHandle`)
+     * at path=[] for this trunk, then searches the define's output wires
+     * for ones matching the requested field path.
+     */
+    private findDefineFieldWires;
+}
+export {};
+//# sourceMappingURL=ExecutionTree.d.ts.map

package/build/bridge-core/src/ExecutionTree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExecutionTree.d.ts","sourceRoot":"","sources":["../../../../bridge-core/src/ExecutionTree.ts"],"names":[],"mappings":"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"}