@stackables/bridge-core 0.0.1 → 1.0.1

package/build/{execute-bridge.js → bridge-core/src/execute-bridge.js}

@@ -1,6 +1,7 @@
 import { ExecutionTree, TraceCollector } from "./ExecutionTree.js";
 import { SELF_MODULE } from "./types.js";
-import { std } from "@stackables/bridge-stdlib";
+import { std as bundledStd, STD_VERSION as BUNDLED_STD_VERSION, } from "@stackables/bridge-stdlib";
+import { resolveStd, checkHandleVersions } from "./version-check.js";
 /**
  * Execute a bridge operation without GraphQL.
  *
@@ -11,12 +12,12 @@ import { std } from "@stackables/bridge-stdlib";
  *
  * @example
  * ```ts
- * import { parseBridgeDiagnostics, executeBridge } from "@stackables/bridge";
+ * import { parseBridge, executeBridge } from "@stackables/bridge";
  * import { readFileSync } from "node:fs";
  *
- * const { instructions } = parseBridgeDiagnostics(readFileSync("my.bridge", "utf8"));
+ * const document = parseBridge(readFileSync("my.bridge", "utf8"));
  * const { data } = await executeBridge({
- *   instructions,
+ *   document,
  *   operation: "Query.myField",
  *   input: { city: "Berlin" },
  * });
@@ -24,14 +25,20 @@ import { std } from "@stackables/bridge-stdlib";
  * ```
  */
 export async function executeBridge(options) {
-    const { instructions, operation, input = {}, context = {} } = options;
+    const { document: doc, operation, input = {}, context = {} } = options;
     const parts = operation.split(".");
     if (parts.length !== 2 || !parts[0] || !parts[1]) {
         throw new Error(`Invalid operation "${operation}" — expected "Type.field" (e.g. "Query.myField")`);
     }
     const [type, field] = parts;
     const trunk = { module: SELF_MODULE, type, field };
-    const tree = new ExecutionTree(trunk, instructions, { std, ...(options.tools ?? {}) }, context);
+    const userTools = options.tools ?? {};
+    // Resolve which std to use: bundled, or a versioned namespace from tools
+    const { namespace: activeStd, version: activeStdVersion } = resolveStd(doc.version, bundledStd, BUNDLED_STD_VERSION, userTools);
+    const allTools = { std: activeStd, ...userTools };
+    // Verify all @version-tagged handles can be satisfied
+    checkHandleVersions(doc.instructions, allTools, activeStdVersion);
+    const tree = new ExecutionTree(trunk, doc, allTools, context);
     if (options.logger)
         tree.logger = options.logger;
     if (options.signal)

package/build/{index.d.ts → bridge-core/src/index.d.ts}

@@ -8,9 +8,11 @@
  */
 export { executeBridge } from "./execute-bridge.ts";
 export type { ExecuteBridgeOptions, ExecuteBridgeResult, } from "./execute-bridge.ts";
-export { ExecutionTree, TraceCollector, BridgeAbortError, BridgePanicError, } from "./ExecutionTree.ts";
+export { checkStdVersion, checkHandleVersions, collectVersionedHandles, getBridgeVersion, hasVersionedToolFn, resolveStd, } from "./version-check.ts";
+export { mergeBridgeDocuments } from "./merge-documents.ts";
+export { ExecutionTree, TraceCollector, BridgeAbortError, BridgePanicError, MAX_EXECUTION_DEPTH, } from "./ExecutionTree.ts";
 export type { Logger, ToolTrace, TraceLevel } from "./ExecutionTree.ts";
 export { SELF_MODULE } from "./types.ts";
-export type { Bridge, CacheStore, ConstDef, ControlFlowInstruction, DefineDef, HandleBinding, Instruction, NodeRef, ToolCallFn, ToolContext, ToolDef, ToolDep, ToolMap, ToolWire, Wire, } from "./types.ts";
+export type { Bridge, BridgeDocument, CacheStore, ConstDef, ControlFlowInstruction, DefineDef, HandleBinding, Instruction, NodeRef, ToolCallFn, ToolContext, ToolDef, ToolDep, ToolMap, ToolWire, VersionDecl, Wire, } from "./types.ts";
 export { parsePath } from "./utils.ts";
 //# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,YAAY,EACV,oBAAoB,EACpB,mBAAmB,GACpB,MAAM,qBAAqB,CAAC;AAI7B,OAAO,EACL,eAAe,EACf,mBAAmB,EACnB,uBAAuB,EACvB,gBAAgB,EAChB,kBAAkB,EAClB,UAAU,GACX,MAAM,oBAAoB,CAAC;AAI5B,OAAO,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAI5D,OAAO,EACL,aAAa,EACb,cAAc,EACd,gBAAgB,EAChB,gBAAgB,EAChB,mBAAmB,GACpB,MAAM,oBAAoB,CAAC;AAC5B,YAAY,EAAE,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAIxE,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AACzC,YAAY,EACV,MAAM,EACN,cAAc,EACd,UAAU,EACV,QAAQ,EACR,sBAAsB,EACtB,SAAS,EACT,aAAa,EACb,WAAW,EACX,OAAO,EACP,UAAU,EACV,WAAW,EACX,OAAO,EACP,OAAO,EACP,OAAO,EACP,QAAQ,EACR,WAAW,EACX,IAAI,GACL,MAAM,YAAY,CAAC;AAIpB,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC"}

package/build/{index.js → bridge-core/src/index.js}

@@ -8,8 +8,12 @@
  */
 // ── Runtime engine ──────────────────────────────────────────────────────────
 export { executeBridge } from "./execute-bridge.js";
+// ── Version check ───────────────────────────────────────────────────────────
+export { checkStdVersion, checkHandleVersions, collectVersionedHandles, getBridgeVersion, hasVersionedToolFn, resolveStd, } from "./version-check.js";
+// ── Document utilities ──────────────────────────────────────────────────────
+export { mergeBridgeDocuments } from "./merge-documents.js";
 // ── Execution tree (advanced) ───────────────────────────────────────────────
-export { ExecutionTree, TraceCollector, BridgeAbortError, BridgePanicError, } from "./ExecutionTree.js";
+export { ExecutionTree, TraceCollector, BridgeAbortError, BridgePanicError, MAX_EXECUTION_DEPTH, } from "./ExecutionTree.js";
 // ── Types ───────────────────────────────────────────────────────────────────
 export { SELF_MODULE } from "./types.js";
 // ── Utilities ───────────────────────────────────────────────────────────────

package/build/bridge-core/src/merge-documents.d.ts

@@ -0,0 +1,25 @@
+import type { BridgeDocument } from "./types.ts";
+/**
+ * Merge multiple `BridgeDocument`s into one.
+ *
+ * Instructions are concatenated in order. For the version field, the
+ * **highest** declared version wins — this preserves the strictest
+ * compatibility requirement across all source documents. Documents
+ * without a version are silently skipped during version resolution.
+ *
+ * Top-level names (bridges, tools, constants, defines) must be globally
+ * unique across all merged documents. Duplicates cause an immediate error
+ * rather than silently shadowing one another.
+ *
+ * @throws Error when documents declare different **major** versions
+ *         (e.g. merging a `1.x` and `2.x` document is not allowed).
+ * @throws Error when documents define duplicate top-level names.
+ *
+ * @example
+ * ```ts
+ * const merged = mergeBridgeDocuments(weatherDoc, quotesDoc, authDoc);
+ * const schema = bridgeTransform(baseSchema, merged, { tools });
+ * ```
+ */
+export declare function mergeBridgeDocuments(...docs: BridgeDocument[]): BridgeDocument;
+//# sourceMappingURL=merge-documents.d.ts.map

package/build/bridge-core/src/merge-documents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge-documents.d.ts","sourceRoot":"","sources":["../../../src/merge-documents.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAe,MAAM,YAAY,CAAC;AAE9D;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,oBAAoB,CAClC,GAAG,IAAI,EAAE,cAAc,EAAE,GACxB,cAAc,CA8BhB"}

package/build/bridge-core/src/merge-documents.js

@@ -0,0 +1,91 @@
+/**
+ * Merge multiple `BridgeDocument`s into one.
+ *
+ * Instructions are concatenated in order. For the version field, the
+ * **highest** declared version wins — this preserves the strictest
+ * compatibility requirement across all source documents. Documents
+ * without a version are silently skipped during version resolution.
+ *
+ * Top-level names (bridges, tools, constants, defines) must be globally
+ * unique across all merged documents. Duplicates cause an immediate error
+ * rather than silently shadowing one another.
+ *
+ * @throws Error when documents declare different **major** versions
+ *         (e.g. merging a `1.x` and `2.x` document is not allowed).
+ * @throws Error when documents define duplicate top-level names.
+ *
+ * @example
+ * ```ts
+ * const merged = mergeBridgeDocuments(weatherDoc, quotesDoc, authDoc);
+ * const schema = bridgeTransform(baseSchema, merged, { tools });
+ * ```
+ */
+export function mergeBridgeDocuments(...docs) {
+    if (docs.length === 0) {
+        return { instructions: [] };
+    }
+    if (docs.length === 1) {
+        return docs[0];
+    }
+    const version = resolveVersion(docs);
+    const instructions = [];
+    // Track global namespaces to prevent collisions across merged files
+    const seenDefs = new Set();
+    for (const doc of docs) {
+        for (const inst of doc.instructions) {
+            const key = instructionKey(inst);
+            if (key) {
+                if (seenDefs.has(key)) {
+                    throw new Error(`Merge conflict: duplicate ${key.replace(":", " '")}' across bridge documents.`);
+                }
+                seenDefs.add(key);
+            }
+            instructions.push(inst);
+        }
+    }
+    return { version, instructions };
+}
+// ── Internal ────────────────────────────────────────────────────────────────
+/** Unique key for a top-level instruction, used for collision detection. */
+function instructionKey(inst) {
+    switch (inst.kind) {
+        case "const":
+            return `const:${inst.name}`;
+        case "tool":
+            return `tool:${inst.name}`;
+        case "define":
+            return `define:${inst.name}`;
+        case "bridge":
+            return `bridge:${inst.type}.${inst.field}`;
+    }
+}
+/**
+ * Pick the highest declared version, ensuring all documents share the same
+ * major.  Returns `undefined` when no document declares a version.
+ */
+function resolveVersion(docs) {
+    let best;
+    let bestMajor = -1;
+    let bestMinor = -1;
+    let bestPatch = -1;
+    for (const doc of docs) {
+        if (!doc.version)
+            continue;
+        const parts = doc.version.split(".").map(Number);
+        const [major = 0, minor = 0, patch = 0] = parts;
+        if (best !== undefined && major !== bestMajor) {
+            throw new Error(`Cannot merge bridge documents with different major versions: ` +
+                `${best} vs ${doc.version}. ` +
+                `Split them into separate bridgeTransform calls instead.`);
+        }
+        if (major > bestMajor ||
+            (major === bestMajor && minor > bestMinor) ||
+            (major === bestMajor && minor === bestMinor && patch > bestPatch)) {
+            best = doc.version;
+            bestMajor = major;
+            bestMinor = minor;
+            bestPatch = patch;
+        }
+    }
+    return best;
+}

package/build/bridge-core/src/tools/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/tools/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAC"}

package/build/bridge-core/src/tools/internal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"internal.d.ts","sourceRoot":"","sources":["../../../../src/tools/internal.ts"],"names":[],"mappings":"AAAA,wCAAwC;AACxC,wBAAgB,GAAG,CAAC,IAAI,EAAE;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CAE1D;AACD,6CAA6C;AAC7C,wBAAgB,QAAQ,CAAC,IAAI,EAAE;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CAE/D;AACD,6CAA6C;AAC7C,wBAAgB,QAAQ,CAAC,IAAI,EAAE;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CAE/D;AACD,2CAA2C;AAC3C,wBAAgB,MAAM,CAAC,IAAI,EAAE;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CAE7D;AACD,uEAAuE;AACvE,wBAAgB,EAAE,CAAC,IAAI,EAAE;IAAE,CAAC,EAAE,GAAG,CAAC;IAAC,CAAC,EAAE,GAAG,CAAA;CAAE,GAAG,OAAO,CAEpD;AACD,yEAAyE;AACzE,wBAAgB,GAAG,CAAC,IAAI,EAAE;IAAE,CAAC,EAAE,GAAG,CAAC;IAAC,CAAC,EAAE,GAAG,CAAA;CAAE,GAAG,OAAO,CAErD;AACD,kEAAkE;AAClE,wBAAgB,EAAE,CAAC,IAAI,EAAE;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAE1D;AACD,4EAA4E;AAC5E,wBAAgB,GAAG,CAAC,IAAI,EAAE;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAE3D;AACD,+DAA+D;AAC/D,wBAAgB,EAAE,CAAC,IAAI,EAAE;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAE1D;AACD,yEAAyE;AACzE,wBAAgB,GAAG,CAAC,IAAI,EAAE;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAE3D;AACD,mDAAmD;AACnD,wBAAgB,GAAG,CAAC,IAAI,EAAE;IAAE,CAAC,EAAE,GAAG,CAAA;CAAE,GAAG,OAAO,CAE7C;AACD,kEAAkE;AAClE,wBAAgB,GAAG,CAAC,IAAI,EAAE;IAAE,CAAC,EAAE,GAAG,CAAC;IAAC,CAAC,EAAE,GAAG,CAAA;CAAE,GAAG,OAAO,CAErD;AACD,iEAAiE;AACjE,wBAAgB,EAAE,CAAC,IAAI,EAAE;IAAE,CAAC,EAAE,GAAG,CAAC;IAAC,CAAC,EAAE,GAAG,CAAA;CAAE,GAAG,OAAO,CAEpD;AACD,kEAAkE;AAClE,wBAAgB,MAAM,CAAC,IAAI,EAAE;IAAE,KAAK,EAAE,OAAO,EAAE,CAAA;CAAE,GAAG;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,CAKpE"}

package/build/{types.d.ts → bridge-core/src/types.d.ts}

@@ -157,6 +157,7 @@ export type HandleBinding = {
     handle: string;
     kind: "tool";
     name: string;
+    version?: string;
 } | {
     handle: string;
     kind: "input";
@@ -212,6 +213,7 @@ export type ToolDep = {
     kind: "tool";
     handle: string;
     tool: string;
+    version?: string;
 } | {
     kind: "const";
     handle: string;
@@ -288,8 +290,33 @@ export type ConstDef = {
     /** Raw JSON string — parsed at runtime when accessed */
     value: string;
 };
-/** Union of all instruction types */
+/**
+ * Version declaration — records the bridge file's declared language version.
+ *
+ * Emitted by the parser as the first instruction. Used at runtime to verify
+ * that the standard library satisfies the bridge's minimum version requirement.
+ *
+ * Example:  `version 1.5`  →  `{ kind: "version", version: "1.5" }`
+ */
+export type VersionDecl = {
+    kind: "version";
+    /** Declared version string, e.g. "1.5" */
+    version: string;
+};
+/** Union of all instruction types (excludes VersionDecl — version lives on BridgeDocument) */
 export type Instruction = Bridge | ToolDef | ConstDef | DefineDef;
+/**
+ * Parsed bridge document — the structured output of the compiler.
+ *
+ * Wraps the instruction array with document-level metadata (version) and
+ * provides a natural home for future pre-computed optimisations.
+ */
+export interface BridgeDocument {
+    /** Declared language version (from `version X.Y` header). */
+    version?: string;
+    /** All instructions: bridge, tool, const, and define blocks. */
+    instructions: Instruction[];
+}
 /**
  * Define block — a reusable named subgraph (pipeline / macro).
  *

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

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

package/build/{types.js → bridge-core/src/types.js}

@@ -1,2 +1,3 @@
 /** Internal module identifier for the bridge's own trunk (input args + output fields) */
 export const SELF_MODULE = "_";
+/* c8 ignore stop */

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/utils.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;GAGG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAchD"}

package/build/bridge-core/src/version-check.d.ts

@@ -0,0 +1,64 @@
+import type { BridgeDocument, Instruction, ToolMap } from "./types.ts";
+/**
+ * Extract the declared bridge version from a document.
+ * Returns `undefined` if no version was declared.
+ */
+export declare function getBridgeVersion(doc: BridgeDocument): string | undefined;
+/**
+ * Verify that the standard library satisfies the bridge file's declared version.
+ *
+ * The bridge `version X.Y` header acts as a minimum-version constraint:
+ *  - Same major  → compatible (only major bumps introduce breaking changes)
+ *  - Bridge minor ≤ std minor → OK (std is same or newer)
+ *  - Bridge minor > std minor → ERROR (bridge needs features not in this std)
+ *  - Different major → ERROR (user must provide a compatible std explicitly)
+ *
+ * @throws Error with an actionable message when the std is incompatible.
+ */
+export declare function checkStdVersion(version: string | undefined, stdVersion: string): void;
+/**
+ * Resolve the standard library namespace and version to use.
+ *
+ * Checks the bundled std first.  When the bridge file targets a different
+ * major version (e.g. `version 1.5` vs bundled `2.0.0`), scans the
+ * user-provided tools map for a versioned namespace key like `"std@1.5"`.
+ *
+ * @returns The resolved std namespace and its version string.
+ * @throws Error with an actionable message when no compatible std is found.
+ */
+export declare function resolveStd(version: string | undefined, bundledStd: ToolMap, bundledStdVersion: string, userTools?: ToolMap): {
+    namespace: ToolMap;
+    version: string;
+};
+/**
+ * Collect every tool reference that carries an `@version` tag from handles
+ * (bridge/define blocks) and deps (tool blocks).
+ */
+export declare function collectVersionedHandles(instructions: Instruction[]): Array<{
+    name: string;
+    version: string;
+}>;
+/**
+ * Check whether a versioned dotted tool name can be resolved.
+ *
+ * In addition to the standard checks (namespace traversal, flat key),
+ * this also checks **versioned namespace keys** in the tool map:
+ *   - `"std.str.toLowerCase@999.1"` as a flat key
+ *   - `"std.str@999.1"` as a namespace key containing `toLowerCase`
+ *   - `"std@999.1"` as a namespace key, traversing to `str.toLowerCase`
+ */
+export declare function hasVersionedToolFn(toolFns: ToolMap, name: string, version: string): boolean;
+/**
+ * Validate that all versioned tool handles can be satisfied at runtime.
+ *
+ * For each handle with `@version`:
+ * 1. A versioned key or versioned namespace in the tool map → satisfied
+ * 2. A `std.*` tool whose STD_VERSION ≥ the requested version → satisfied
+ * 3. Otherwise → throws with an actionable error message
+ *
+ * Call this **before** constructing the ExecutionTree to fail early.
+ *
+ * @throws Error when a versioned tool cannot be satisfied.
+ */
+export declare function checkHandleVersions(instructions: Instruction[], toolFns: ToolMap, stdVersion: string): void;
+//# sourceMappingURL=version-check.d.ts.map

package/build/bridge-core/src/version-check.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version-check.d.ts","sourceRoot":"","sources":["../../../src/version-check.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,cAAc,EAEd,WAAW,EAEX,OAAO,EACR,MAAM,YAAY,CAAC;AAEpB;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM,GAAG,SAAS,CAExE;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,MAAM,GAAG,SAAS,EAC3B,UAAU,EAAE,MAAM,GACjB,IAAI,CAuBN;AAID;;;;;;;;;GASG;AACH,wBAAgB,UAAU,CACxB,OAAO,EAAE,MAAM,GAAG,SAAS,EAC3B,UAAU,EAAE,OAAO,EACnB,iBAAiB,EAAE,MAAM,EACzB,SAAS,GAAE,OAAY,GACtB;IAAE,SAAS,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CA4CzC;AAID;;;GAGG;AACH,wBAAgB,uBAAuB,CACrC,YAAY,EAAE,WAAW,EAAE,GAC1B,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC,CAmB1C;AAwBD;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,GACd,OAAO,CA8BT;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CACjC,YAAY,EAAE,WAAW,EAAE,EAC3B,OAAO,EAAE,OAAO,EAChB,UAAU,EAAE,MAAM,GACjB,IAAI,CA6BN"}

package/build/bridge-core/src/version-check.js

@@ -0,0 +1,205 @@
+/**
+ * Extract the declared bridge version from a document.
+ * Returns `undefined` if no version was declared.
+ */
+export function getBridgeVersion(doc) {
+    return doc.version;
+}
+/**
+ * Verify that the standard library satisfies the bridge file's declared version.
+ *
+ * The bridge `version X.Y` header acts as a minimum-version constraint:
+ *  - Same major  → compatible (only major bumps introduce breaking changes)
+ *  - Bridge minor ≤ std minor → OK (std is same or newer)
+ *  - Bridge minor > std minor → ERROR (bridge needs features not in this std)
+ *  - Different major → ERROR (user must provide a compatible std explicitly)
+ *
+ * @throws Error with an actionable message when the std is incompatible.
+ */
+export function checkStdVersion(version, stdVersion) {
+    if (!version)
+        return; // no version declared — nothing to check
+    const bParts = version.split(".").map(Number);
+    const sParts = stdVersion.split(".").map(Number);
+    const [bMajor = 0, bMinor = 0] = bParts;
+    const [sMajor = 0, sMinor = 0] = sParts;
+    if (bMajor !== sMajor) {
+        throw new Error(`Bridge version ${version} requires a ${bMajor}.x standard library, ` +
+            `but the provided std is ${stdVersion} (major version ${sMajor}). ` +
+            `Provide a compatible std as "std@${version}" in the tools map.`);
+    }
+    if (bMinor > sMinor) {
+        throw new Error(`Bridge version ${version} requires standard library ≥ ${bMajor}.${bMinor}, ` +
+            `but the installed @stackables/bridge-stdlib is ${stdVersion}. ` +
+            `Update @stackables/bridge-stdlib to ${bMajor}.${bMinor}.0 or later.`);
+    }
+}
+// ── Std resolution from tools map ───────────────────────────────────────────
+/**
+ * Resolve the standard library namespace and version to use.
+ *
+ * Checks the bundled std first.  When the bridge file targets a different
+ * major version (e.g. `version 1.5` vs bundled `2.0.0`), scans the
+ * user-provided tools map for a versioned namespace key like `"std@1.5"`.
+ *
+ * @returns The resolved std namespace and its version string.
+ * @throws Error with an actionable message when no compatible std is found.
+ */
+export function resolveStd(version, bundledStd, bundledStdVersion, userTools = {}) {
+    if (!version) {
+        return { namespace: bundledStd, version: bundledStdVersion };
+    }
+    const [bMajor = 0, bMinor = 0] = version.split(".").map(Number);
+    const [sMajor = 0, sMinor = 0] = bundledStdVersion.split(".").map(Number);
+    // Bundled std satisfies the bridge version
+    if (bMajor === sMajor && sMinor >= bMinor) {
+        return { namespace: bundledStd, version: bundledStdVersion };
+    }
+    // Scan tools for a versioned std namespace key (e.g. "std@1.5")
+    for (const key of Object.keys(userTools)) {
+        const match = key.match(/^std@(.+)$/);
+        if (match) {
+            const ver = match[1];
+            const parts = ver.split(".").map(Number);
+            const [vMajor = 0, vMinor = 0] = parts;
+            if (vMajor === bMajor && vMinor >= bMinor) {
+                const ns = userTools[key];
+                if (ns != null && typeof ns === "object" && !Array.isArray(ns)) {
+                    const fullVersion = parts.length <= 2 ? `${ver}.0` : ver;
+                    return { namespace: ns, version: fullVersion };
+                }
+            }
+        }
+    }
+    // No compatible std found — produce actionable error
+    if (bMajor !== sMajor) {
+        throw new Error(`Bridge version ${version} requires a ${bMajor}.x standard library, ` +
+            `but the bundled std is ${bundledStdVersion} (major version ${sMajor}). ` +
+            `Provide a compatible std as "std@${version}" in the tools map.`);
+    }
+    throw new Error(`Bridge version ${version} requires standard library ≥ ${bMajor}.${bMinor}, ` +
+        `but the installed @stackables/bridge-stdlib is ${bundledStdVersion}. ` +
+        `Update @stackables/bridge-stdlib to ${bMajor}.${bMinor}.0 or later.`);
+}
+// ── Versioned handle validation ─────────────────────────────────────────────
+/**
+ * Collect every tool reference that carries an `@version` tag from handles
+ * (bridge/define blocks) and deps (tool blocks).
+ */
+export function collectVersionedHandles(instructions) {
+    const result = [];
+    for (const inst of instructions) {
+        if (inst.kind === "bridge" || inst.kind === "define") {
+            for (const h of inst.handles) {
+                if (h.kind === "tool" && h.version) {
+                    result.push({ name: h.name, version: h.version });
+                }
+            }
+        }
+        if (inst.kind === "tool") {
+            for (const dep of inst.deps) {
+                if (dep.kind === "tool" && dep.version) {
+                    result.push({ name: dep.tool, version: dep.version });
+                }
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Check whether a dotted tool name resolves to a function in the tool map.
+ * Supports both namespace traversal (std.str.toUpperCase) and flat keys.
+ */
+function hasToolFn(toolFns, name) {
+    if (name.includes(".")) {
+        const parts = name.split(".");
+        let current = toolFns;
+        for (const part of parts) {
+            if (current == null || typeof current !== "object") {
+                current = undefined;
+                break;
+            }
+            current = current[part];
+        }
+        if (typeof current === "function")
+            return true;
+        // flat key fallback
+        return typeof toolFns[name] === "function";
+    }
+    return typeof toolFns[name] === "function";
+}
+/**
+ * Check whether a versioned dotted tool name can be resolved.
+ *
+ * In addition to the standard checks (namespace traversal, flat key),
+ * this also checks **versioned namespace keys** in the tool map:
+ *   - `"std.str.toLowerCase@999.1"` as a flat key
+ *   - `"std.str@999.1"` as a namespace key containing `toLowerCase`
+ *   - `"std@999.1"` as a namespace key, traversing to `str.toLowerCase`
+ */
+export function hasVersionedToolFn(toolFns, name, version) {
+    const versionedKey = `${name}@${version}`;
+    // 1. Flat key or direct namespace traversal
+    if (hasToolFn(toolFns, versionedKey))
+        return true;
+    // 2. Versioned namespace key lookup
+    //    For "std.str.toLowerCase" @ "999.1", try:
+    //      toolFns["std.str@999.1"]?.toLowerCase
+    //      toolFns["std@999.1"]?.str?.toLowerCase
+    if (name.includes(".")) {
+        const parts = name.split(".");
+        for (let i = parts.length - 1; i >= 1; i--) {
+            const nsKey = parts.slice(0, i).join(".") + "@" + version;
+            const remainder = parts.slice(i);
+            let ns = toolFns[nsKey];
+            if (ns != null && typeof ns === "object") {
+                for (const part of remainder) {
+                    if (ns == null || typeof ns !== "object") {
+                        ns = undefined;
+                        break;
+                    }
+                    ns = ns[part];
+                }
+                if (typeof ns === "function")
+                    return true;
+            }
+        }
+    }
+    return false;
+}
+/**
+ * Validate that all versioned tool handles can be satisfied at runtime.
+ *
+ * For each handle with `@version`:
+ * 1. A versioned key or versioned namespace in the tool map → satisfied
+ * 2. A `std.*` tool whose STD_VERSION ≥ the requested version → satisfied
+ * 3. Otherwise → throws with an actionable error message
+ *
+ * Call this **before** constructing the ExecutionTree to fail early.
+ *
+ * @throws Error when a versioned tool cannot be satisfied.
+ */
+export function checkHandleVersions(instructions, toolFns, stdVersion) {
+    const versioned = collectVersionedHandles(instructions);
+    for (const { name, version } of versioned) {
+        // 1. Flat key, namespace traversal, or versioned namespace key
+        if (hasVersionedToolFn(toolFns, name, version))
+            continue;
+        // 2. For std.* tools, check if the active std satisfies the version
+        if (name.startsWith("std.")) {
+            const sParts = stdVersion.split(".").map(Number);
+            const vParts = version.split(".").map(Number);
+            const [sMajor = 0, sMinor = 0] = sParts;
+            const [vMajor = 0, vMinor = 0] = vParts;
+            if (sMajor === vMajor && sMinor >= vMinor)
+                continue;
+            throw new Error(`Tool "${name}@${version}" requires standard library ≥ ${vMajor}.${vMinor}, ` +
+                `but the installed @stackables/bridge-stdlib is ${stdVersion}. ` +
+                `Either update the stdlib or provide the tool as ` +
+                `"${name}@${version}" in the tools map.`);
+        }
+        // 3. Non-std tool — must be provided with a versioned key or namespace
+        throw new Error(`Tool "${name}@${version}" is not available. ` +
+            `Provide it as "${name}@${version}" in the tools map.`);
+    }
+}

package/build/bridge-stdlib/src/index.d.ts

@@ -0,0 +1,34 @@
+/**
+ * @stackables/bridge-stdlib — Bridge standard library tools.
+ *
+ * Contains the `std` namespace tools (httpCall, string helpers, array helpers,
+ * audit) that ship with Bridge.  Referenced in `.bridge` files as
+ * `std.httpCall`, `std.str.toUpperCase`, etc.
+ *
+ * Separated from core so it can be versioned independently.
+ */
+import { audit } from "./tools/audit.ts";
+import * as arrays from "./tools/arrays.ts";
+import * as strings from "./tools/strings.ts";
+/**
+ * Standard library version.
+ *
+ * The bridge `version X.Y` header declares the minimum compatible std version.
+ * At runtime the engine compares this constant against the bridge's declared
+ * version to verify compatibility (same major, equal-or-higher minor).
+ */
+export declare const STD_VERSION = "1.5.0";
+export declare const std: {
+    readonly str: typeof strings;
+    readonly arr: typeof arrays;
+    readonly audit: typeof audit;
+    readonly httpCall: import("@stackables/bridge-types").ToolCallFn;
+};
+/**
+ * All known built-in tool names as "namespace.tool" strings.
+ *
+ * Useful for LSP/IDE autocomplete and diagnostics.
+ */
+export declare const builtinToolNames: readonly string[];
+export { createHttpCall } from "./tools/http-call.ts";
+//# sourceMappingURL=index.d.ts.map

package/build/bridge-stdlib/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../bridge-stdlib/src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAEzC,OAAO,KAAK,MAAM,MAAM,mBAAmB,CAAC;AAC5C,OAAO,KAAK,OAAO,MAAM,oBAAoB,CAAC;AAE9C;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,UAAU,CAAC;AASnC,eAAO,MAAM,GAAG;;;;;CAKN,CAAC;AAEX;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,EAAE,SAAS,MAAM,EAE7C,CAAC;AAEF,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC"}

package/build/bridge-stdlib/src/index.js

@@ -0,0 +1,40 @@
+/**
+ * @stackables/bridge-stdlib — Bridge standard library tools.
+ *
+ * Contains the `std` namespace tools (httpCall, string helpers, array helpers,
+ * audit) that ship with Bridge.  Referenced in `.bridge` files as
+ * `std.httpCall`, `std.str.toUpperCase`, etc.
+ *
+ * Separated from core so it can be versioned independently.
+ */
+import { audit } from "./tools/audit.js";
+import { createHttpCall } from "./tools/http-call.js";
+import * as arrays from "./tools/arrays.js";
+import * as strings from "./tools/strings.js";
+/**
+ * Standard library version.
+ *
+ * The bridge `version X.Y` header declares the minimum compatible std version.
+ * At runtime the engine compares this constant against the bridge's declared
+ * version to verify compatibility (same major, equal-or-higher minor).
+ */
+export const STD_VERSION = "1.5.0";
+/**
+ * Standard built-in tools — available under the `std` namespace.
+ *
+ * Referenced in `.bridge` files as `std.str.toUpperCase`, `std.arr.first`, etc.
+ */
+const httpCallFn = createHttpCall();
+export const std = {
+    str: strings,
+    arr: arrays,
+    audit,
+    httpCall: httpCallFn,
+};
+/**
+ * All known built-in tool names as "namespace.tool" strings.
+ *
+ * Useful for LSP/IDE autocomplete and diagnostics.
+ */
+export const builtinToolNames = Object.keys(std).map((k) => `std.${k}`);
+export { createHttpCall } from "./tools/http-call.js";