litedbmodel 1.2.9 → 2.0.0

package/dist/scp/index.cjs

@@ -0,0 +1,4744 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod2) => __copyProps(__defProp({}, "__esModule", { value: true }), mod2);
+
+// src/scp/index.ts
+var index_exports = {};
+__export(index_exports, {
+  CATALOG_NAMES: () => CATALOG_NAMES,
+  CODEGEN_LANGUAGES: () => CODEGEN_LANGUAGES,
+  ENTITY_ROOT: () => ENTITY_ROOT,
+  IN_SENTINEL: () => IN_SENTINEL,
+  LITEDBMODEL_CATALOG: () => LITEDBMODEL_CATALOG,
+  MYSQL: () => MYSQL,
+  POSTGRES: () => POSTGRES,
+  RELATION_CONTEXT: () => RELATION_CONTEXT,
+  RELATION_KEYS_HEAD: () => RELATION_KEYS_HEAD,
+  RelationContext: () => RelationContext,
+  SQLITE: () => SQLITE,
+  SemanticBehavior: () => SemanticBehavior,
+  SqlFailure: () => SqlFailure,
+  WHERE_SLOT: () => WHERE_SLOT,
+  WRITE_CATALOG_NAMES: () => WRITE_CATALOG_NAMES,
+  WRITE_PORT_FAMILIES: () => WRITE_PORT_FAMILIES,
+  add: () => add,
+  and: () => and,
+  assertComponentGraphPortable: () => assertComponentGraphPortable,
+  assertComponentPortable: () => assertComponentPortable,
+  assertComponentsInCatalog: () => assertComponentsInCatalog,
+  assertExprPortable: () => assertExprPortable,
+  assertLanguageSupported: () => assertLanguageSupported,
+  assertOperationPortable: () => assertOperationPortable,
+  behavior: () => behavior,
+  buildHandlers: () => buildHandlers,
+  buildResultSet: () => buildResultSet,
+  bundleToPortableIR: () => bundleToPortableIR,
+  catalogEntry: () => catalogEntry,
+  coalesce: () => coalesce,
+  codegenExecuteBundleForTest: () => codegenExecuteBundleForTest,
+  compileBundle: () => compileBundle,
+  compileComponentNodes: () => compileComponentNodes,
+  compileCompositeWriteBundle: () => compileCompositeWriteBundle,
+  compileDelete: () => compileDelete,
+  compileEager: () => compileEager,
+  compileInsert: () => compileInsert,
+  compileInsertFor: () => compileInsertFor,
+  compileNode: () => compileNode,
+  compileRelationOp: () => compileRelationOp,
+  compileSelect: () => compileSelect,
+  compileUpdate: () => compileUpdate,
+  compileWriteBundle: () => compileWriteBundle,
+  components: () => components,
+  concat: () => concat,
+  countingDriver: () => countingDriver,
+  deriveContractEffect: () => deriveContractEffect,
+  deriveTransactionPlan: () => deriveTransactionPlan,
+  dialectFor: () => dialectFor,
+  distributeToParent: () => distributeToParent,
+  div: () => div,
+  edgeWrites: () => edgeWrites,
+  entityWrites: () => entityWrites,
+  eq: () => eq,
+  executeBehavior: () => executeBehavior,
+  executeBundle: () => executeBundle,
+  executeCommand: () => executeCommand,
+  executeCompositeCommand: () => executeCompositeCommand,
+  executeTransaction: () => executeTransaction,
+  executeTransactionBundle: () => executeTransactionBundle,
+  ge: () => ge,
+  generateCodegenArtifact: () => generateCodegenArtifact,
+  gt: () => gt,
+  inColumn: () => inColumn,
+  le: () => le,
+  len: () => len,
+  lifecycleFor: () => lifecycleFor,
+  lt: () => lt,
+  mapSqliteError: () => mapSqliteError,
+  mod: () => mod,
+  mul: () => mul,
+  ne: () => ne,
+  neg: () => neg,
+  normalizeInput: () => normalizeInput,
+  not: () => not,
+  opt: () => opt,
+  or: () => or,
+  parseEffectPath: () => parseEffectPath,
+  publishBehaviors: () => publishBehaviors,
+  read: () => read,
+  readBundle: () => readBundle,
+  readRelationContext: () => readRelationContext,
+  renderOperation: () => renderOperation,
+  resolveRelationViaPlan: () => resolveRelationViaPlan,
+  runRelationOp: () => runRelationOp,
+  sub: () => sub,
+  toDollarPlaceholders: () => toDollarPlaceholders,
+  when: () => when,
+  whereEq: () => whereEq,
+  whereGe: () => whereGe,
+  whereGt: () => whereGt,
+  whereIn: () => whereIn,
+  whereIsNull: () => whereIsNull,
+  whereLe: () => whereLe,
+  whereLt: () => whereLt,
+  whereNe: () => whereNe
+});
+module.exports = __toCommonJS(index_exports);
+
+// node_modules/behavior-contracts/dist/expr-eval.js
+var ExprFailure = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "ExprFailure";
+  }
+};
+function fail(code, message) {
+  throw new ExprFailure(code, message);
+}
+var I64_MIN = -(2n ** 63n);
+var I64_MAX = 2n ** 63n - 1n;
+var WIDEN_EXACT = 2n ** 53n;
+function checkI64(v) {
+  if (v < I64_MIN || v > I64_MAX)
+    fail("INT_OVERFLOW", `i64 overflow: ${v}`);
+  return v;
+}
+function checkFinite(v) {
+  if (!Number.isFinite(v))
+    fail("NAN_OR_INF", `non-finite float: ${v}`);
+  return v;
+}
+function widenToFloat(v) {
+  if (typeof v === "number")
+    return v;
+  if (typeof v === "bigint") {
+    if (v > WIDEN_EXACT || v < -WIDEN_EXACT)
+      fail("PRECISION_LOSS", `int ${v} exceeds exact float range (\xB12^53)`);
+    return Number(v);
+  }
+  fail("TYPE_MISMATCH", `numeric operand expected, got ${typeName(v)}`);
+}
+function cmpCodePoints(a, b) {
+  const ia = a[Symbol.iterator]();
+  const ib = b[Symbol.iterator]();
+  for (; ; ) {
+    const ra = ia.next();
+    const rb = ib.next();
+    if (ra.done && rb.done)
+      return 0;
+    if (ra.done)
+      return -1;
+    if (rb.done)
+      return 1;
+    const ca = ra.value.codePointAt(0);
+    const cb = rb.value.codePointAt(0);
+    if (ca !== cb)
+      return ca < cb ? -1 : 1;
+  }
+}
+function typeName(v) {
+  if (v === null)
+    return "null";
+  if (typeof v === "bigint")
+    return "int";
+  if (typeof v === "number")
+    return "float";
+  if (Array.isArray(v))
+    return "arr";
+  return typeof v;
+}
+function requireBool(v, ctx) {
+  if (typeof v !== "boolean")
+    fail("TYPE_MISMATCH", `${ctx}: bool expected, got ${typeName(v)}\uFF08truthiness \u306F\u5B58\u5728\u3057\u306A\u3044\uFF09`);
+  return v;
+}
+function isPlainObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+var FORBIDDEN_OBJECT_KEY = "__proto__";
+function evaluate(node, scope = {}) {
+  if (node === null)
+    return null;
+  if (typeof node === "boolean" || typeof node === "string")
+    return node;
+  if (typeof node === "number") {
+    if (Number.isInteger(node)) {
+      if (!Number.isSafeInteger(node))
+        fail("INVALID_LITERAL", `integral number literal ${node} exceeds safe range; use {int:"..."}`);
+      return BigInt(node);
+    }
+    return checkFinite(node);
+  }
+  if (Array.isArray(node))
+    fail("INVALID_NODE", "bare array is not an expression (use {arr:[...]})");
+  if (!isPlainObject(node))
+    fail("INVALID_NODE", `invalid node: ${String(node)}`);
+  const keys = Object.keys(node);
+  if (keys.length !== 1)
+    fail("INVALID_NODE", `operator node must have exactly one key, got [${keys.join(", ")}]`);
+  const op = keys[0];
+  const arg = node[op];
+  switch (op) {
+    // ── リテラルラッパ ──
+    case "int": {
+      if (typeof arg !== "string")
+        fail("INVALID_NODE", "{int: ...} expects a string");
+      let v;
+      try {
+        v = BigInt(arg);
+      } catch {
+        fail("INVALID_LITERAL", `invalid int literal: ${arg}`);
+      }
+      return checkI64(v);
+    }
+    case "float": {
+      if (typeof arg !== "number")
+        fail("INVALID_NODE", "{float: ...} expects a number");
+      return checkFinite(arg);
+    }
+    // ── 参照 ──
+    case "ref":
+    case "refOpt": {
+      const path = argArray(op, arg);
+      if (path.length === 0 || !path.every((p) => typeof p === "string"))
+        fail("INVALID_NODE", `${op} expects a non-empty string path`);
+      const [head, ...rest] = path;
+      if (!Object.prototype.hasOwnProperty.call(scope, head))
+        fail("UNKNOWN_BINDING", `unknown binding: ${head}`);
+      let cur = scope[head];
+      for (const seg of rest) {
+        if (cur === null) {
+          if (op === "refOpt")
+            return null;
+          fail("NULL_REF", `null intermediate at .${seg}\uFF08?. \u3092\u4F7F\u3046\uFF09`);
+        }
+        if (!isPlainObject(cur))
+          fail("TYPE_MISMATCH", `cannot access .${seg} on ${typeName(cur)}`);
+        if (!Object.prototype.hasOwnProperty.call(cur, seg))
+          fail("MISSING_PROP", `missing property .${seg}`);
+        cur = cur[seg];
+      }
+      return cur;
+    }
+    // ── 構築 ──
+    case "obj": {
+      if (!isPlainObject(arg))
+        fail("INVALID_NODE", "{obj: ...} expects an object");
+      const out = {};
+      for (const k of Object.keys(arg)) {
+        if (k === FORBIDDEN_OBJECT_KEY)
+          fail("FORBIDDEN_KEY", `obj key "${FORBIDDEN_OBJECT_KEY}" is forbidden (fail-closed)`);
+        out[k] = evaluate(arg[k], scope);
+      }
+      return out;
+    }
+    case "arr":
+      return argArray(op, arg).map((e) => evaluate(e, scope));
+    // ── 数値（モノモーフィック・checked）──
+    case "add":
+    case "sub":
+    case "mul": {
+      const [a, b] = evalBinary(op, arg, scope);
+      if (typeof a === "bigint" && typeof b === "bigint") {
+        const r = op === "add" ? a + b : op === "sub" ? a - b : a * b;
+        return checkI64(r);
+      }
+      if (typeof a === "number" && typeof b === "number") {
+        const r = op === "add" ? a + b : op === "sub" ? a - b : a * b;
+        return checkFinite(r);
+      }
+      fail("TYPE_MISMATCH", `${op}: int\xD7int \u304B float\xD7float\uFF08got ${typeName(a)}\xD7${typeName(b)}\u3002\u6DF7\u5728\u306F\u660E\u793A\u5909\u63DB\u304C\u5FC5\u8981\uFF09`);
+    }
+    case "neg": {
+      const a = evaluate(argUnary(op, arg), scope);
+      if (typeof a === "bigint")
+        return checkI64(-a);
+      if (typeof a === "number")
+        return checkFinite(-a);
+      fail("TYPE_MISMATCH", `neg: numeric expected, got ${typeName(a)}`);
+    }
+    case "div": {
+      const [a, b] = evalBinary(op, arg, scope);
+      return checkFinite(widenToFloat(a) / widenToFloat(b));
+    }
+    case "mod": {
+      const [a, b] = evalBinary(op, arg, scope);
+      if (typeof a === "bigint" && typeof b === "bigint") {
+        if (b === 0n)
+          fail("MOD_ZERO", "int mod by zero");
+        return checkI64(a % b);
+      }
+      if (typeof a === "number" && typeof b === "number")
+        return checkFinite(a % b);
+      fail("TYPE_MISMATCH", `mod: int\xD7int \u304B float\xD7float\uFF08got ${typeName(a)}\xD7${typeName(b)}\uFF09`);
+    }
+    // ── 文字列 ──
+    case "concat": {
+      const rawParts = argArray(op, arg);
+      if (rawParts.length < 2)
+        fail("INVALID_NODE", `concat expects >= 2 args, got ${rawParts.length}`);
+      const parts = rawParts.map((e) => evaluate(e, scope));
+      for (const p of parts)
+        if (typeof p !== "string")
+          fail("TYPE_MISMATCH", `concat: string \u306E\u307F\uFF08got ${typeName(p)}\u3002\u6570\u5024\u306E\u6697\u9ED9 toString \u306F\u5B58\u5728\u3057\u306A\u3044\uFF09`);
+      return parts.join("");
+    }
+    // ── 比較 ──
+    case "eq":
+    case "ne": {
+      const [a, b] = evalBinary(op, arg, scope);
+      const equal = valueEquals(a, b);
+      return op === "eq" ? equal : !equal;
+    }
+    case "lt":
+    case "le":
+    case "gt":
+    case "ge": {
+      const [a, b] = evalBinary(op, arg, scope);
+      let c;
+      if (typeof a === "bigint" && typeof b === "bigint")
+        c = a < b ? -1 : a > b ? 1 : 0;
+      else if (typeof a === "number" && typeof b === "number")
+        c = a < b ? -1 : a > b ? 1 : 0;
+      else if (typeof a === "string" && typeof b === "string")
+        c = cmpCodePoints(a, b);
+      else
+        fail("TYPE_MISMATCH", `${op}: \u540C\u4E00\u578B\u306E int/float/string \u306E\u307F\uFF08got ${typeName(a)}\xD7${typeName(b)}\uFF09`);
+      switch (op) {
+        case "lt":
+          return c < 0;
+        case "le":
+          return c <= 0;
+        case "gt":
+          return c > 0;
+        case "ge":
+          return c >= 0;
+      }
+    }
+    // ── bool / null（短絡評価）──
+    case "and":
+    case "or": {
+      const [ea, eb] = rawBinary(op, arg);
+      const a = requireBool(evaluate(ea, scope), op);
+      if (op === "and" && !a)
+        return false;
+      if (op === "or" && a)
+        return true;
+      return requireBool(evaluate(eb, scope), op);
+    }
+    case "not":
+      return !requireBool(evaluate(argUnary(op, arg), scope), "not");
+    case "coalesce": {
+      const [ea, eb] = rawBinary(op, arg);
+      const a = evaluate(ea, scope);
+      return a === null ? evaluate(eb, scope) : a;
+    }
+    case "cond": {
+      if (!Array.isArray(arg) || arg.length !== 3)
+        fail("INVALID_NODE", "cond expects [c, t, e]");
+      const c = requireBool(evaluate(arg[0], scope), "cond");
+      return evaluate(c ? arg[1] : arg[2], scope);
+    }
+    // ── その他 ──
+    case "len": {
+      const a = evaluate(argUnary(op, arg), scope);
+      if (!Array.isArray(a))
+        fail("TYPE_MISMATCH", `len: \u914D\u5217\u306E\u307F\uFF08string length \u306F v1 \u306B\u5B58\u5728\u3057\u306A\u3044\u3002got ${typeName(a)}\uFF09`);
+      return BigInt(a.length);
+    }
+    default:
+      fail("UNKNOWN_OP", `unknown operator: ${op}\uFF08fail-closed\uFF09`);
+  }
+}
+function argArray(op, arg) {
+  if (!Array.isArray(arg))
+    fail("INVALID_NODE", `${op} expects an args array`);
+  return arg;
+}
+function argUnary(op, arg) {
+  const a = argArray(op, arg);
+  if (a.length !== 1)
+    fail("INVALID_NODE", `${op} expects 1 arg`);
+  return a[0];
+}
+function rawBinary(op, arg) {
+  const a = argArray(op, arg);
+  if (a.length !== 2)
+    fail("INVALID_NODE", `${op} expects 2 args`);
+  return [a[0], a[1]];
+}
+function evalBinary(op, arg, scope) {
+  const [ea, eb] = rawBinary(op, arg);
+  return [evaluate(ea, scope), evaluate(eb, scope)];
+}
+function valueEquals(a, b) {
+  if (a === null || b === null)
+    return a === null && b === null;
+  const ta = typeName(a);
+  const tb = typeName(b);
+  if (ta !== tb)
+    fail("TYPE_MISMATCH", `eq/ne: \u540C\u4E00\u578B\u306E\u307F\uFF08got ${ta}\xD7${tb}\uFF09`);
+  if (ta === "arr" || ta === "object")
+    fail("TYPE_MISMATCH", "eq/ne: obj/arr \u306E\u7B49\u4FA1\u306F v1 \u3067\u672A\u5B9A\u7FA9");
+  return a === b;
+}
+
+// node_modules/behavior-contracts/dist/canonical.js
+var CanonicalFailure = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "CanonicalFailure";
+  }
+};
+function fail2(code, message) {
+  throw new CanonicalFailure(code, message);
+}
+function pyFloatRepr(n) {
+  if (Number.isNaN(n) || !Number.isFinite(n))
+    fail2("NAN_OR_INF", `non-finite float cannot be serialized: ${n}`);
+  if (n === 0)
+    return Object.is(n, -0) ? "-0.0" : "0.0";
+  const neg2 = n < 0;
+  const abs = Math.abs(n);
+  const { digits, decpt } = shortestDigits(abs);
+  const body = decpt <= -4 || decpt > 16 ? formatScientific(digits, decpt) : formatFixed(digits, decpt);
+  return neg2 ? "-" + body : body;
+}
+function shortestDigits(abs) {
+  const s = abs.toString();
+  let mantissa;
+  let exp;
+  const eIdx = s.indexOf("e");
+  if (eIdx >= 0) {
+    mantissa = s.slice(0, eIdx);
+    exp = parseInt(s.slice(eIdx + 1), 10);
+  } else {
+    mantissa = s;
+    exp = 0;
+  }
+  const dot = mantissa.indexOf(".");
+  let intPart;
+  let fracPart;
+  if (dot >= 0) {
+    intPart = mantissa.slice(0, dot);
+    fracPart = mantissa.slice(dot + 1);
+  } else {
+    intPart = mantissa;
+    fracPart = "";
+  }
+  let allDigits = intPart + fracPart;
+  let decpt = intPart.length + exp;
+  let lead = 0;
+  while (lead < allDigits.length - 1 && allDigits[lead] === "0")
+    lead++;
+  if (lead > 0) {
+    allDigits = allDigits.slice(lead);
+    decpt -= lead;
+  }
+  allDigits = allDigits.replace(/0+$/, "");
+  if (allDigits === "") {
+    return { digits: "0", decpt: 1 };
+  }
+  return { digits: allDigits, decpt };
+}
+function formatFixed(digits, decpt) {
+  if (decpt <= 0) {
+    return "0." + "0".repeat(-decpt) + digits;
+  }
+  if (decpt >= digits.length) {
+    return digits + "0".repeat(decpt - digits.length) + ".0";
+  }
+  return digits.slice(0, decpt) + "." + digits.slice(decpt);
+}
+function formatScientific(digits, decpt) {
+  const first = digits[0];
+  const rest = digits.slice(1);
+  const mant = rest.length > 0 ? `${first}.${rest}` : first;
+  const e = decpt - 1;
+  const sign = e < 0 ? "-" : "+";
+  const mag = Math.abs(e).toString().padStart(2, "0");
+  return `${mant}e${sign}${mag}`;
+}
+function canonicalJson(v) {
+  if (isPlainObject2(v)) {
+    guardKeys(Object.keys(v));
+    const keys = Object.keys(v).sort(cmpCodePoints);
+    const parts = keys.map((k) => `${jsonString(k)}:${canonicalJson(v[k])}`);
+    return `{${parts.join(",")}}`;
+  }
+  if (Array.isArray(v))
+    return `[${v.map(canonicalJson).join(",")}]`;
+  return scalarJson(v);
+}
+function scalarJson(v) {
+  if (v === null)
+    return "null";
+  if (typeof v === "boolean")
+    return v ? "true" : "false";
+  if (typeof v === "string")
+    return jsonString(v);
+  if (typeof v === "bigint")
+    return v.toString();
+  if (typeof v === "number")
+    return pyFloatRepr(v);
+  fail2("INVALID_VALUE", `cannot serialize value of unknown type`);
+}
+function jsonString(s) {
+  return JSON.stringify(s);
+}
+function isPlainObject2(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function guardKeys(keys) {
+  if (keys.includes(FORBIDDEN_OBJECT_KEY))
+    fail2("FORBIDDEN_KEY", `object key "${FORBIDDEN_OBJECT_KEY}" is forbidden (fail-closed)`);
+}
+
+// node_modules/behavior-contracts/dist/plan.js
+var PlanFailure = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "PlanFailure";
+  }
+};
+function fail3(code, message) {
+  throw new PlanFailure(code, message);
+}
+function runPlan(plan, ops, exec) {
+  const states = new Array(ops.length);
+  const executedIdx = [];
+  const skippedIdx = [];
+  const stages = plan ? plan.groups : ops.map((_, i) => [i]);
+  const concurrency = plan ? plan.concurrency : 1;
+  validateCoverage(stages, ops.length);
+  for (const stage of stages) {
+    const ordered = [...stage].sort((a, b) => a - b);
+    void concurrency;
+    for (const i of ordered) {
+      states[i] = runOp(i, ops[i], states, exec, executedIdx, skippedIdx);
+    }
+  }
+  return {
+    states,
+    executed: executedIdx.sort((a, b) => a - b).map((i) => ops[i].id),
+    skipped: skippedIdx.sort((a, b) => a - b).map((i) => ops[i].id)
+  };
+}
+function preflightOp(i, op, states) {
+  const policy = op.policy ?? "fail";
+  if (policy !== "fail" && policy !== "retry" && policy !== "continue")
+    return { kind: "invalid-policy", message: `unknown policy kind: ${policy}` };
+  let boundValue = void 0;
+  if (op.parent !== null) {
+    const parent = states[op.parent];
+    if (!parent || parent.status !== "ok")
+      return { kind: "skip" };
+    if (op.bindField !== void 0) {
+      const pv = parent.value;
+      const bound = pv !== null && typeof pv === "object" && !Array.isArray(pv) ? pv[op.bindField] : void 0;
+      if (bound === void 0 || bound === null)
+        return { kind: "skip" };
+      boundValue = bound;
+    }
+  }
+  return { kind: "exec", policy, bound: boundValue };
+}
+function interpretOutcome(i, op, policy, outcome, executedIdx, skippedIdx) {
+  executedIdx.push(i);
+  if ("ok" in outcome)
+    return { status: "ok", value: outcome.ok };
+  if (policy === "fail") {
+    fail3("OP_FAILED", `operation '${op.id}' failed under 'fail' policy: ${outcome.error}`);
+  }
+  if (policy === "retry") {
+    fail3("OP_FAILED", `operation '${op.id}' failed under 'retry' policy (exhausted): ${outcome.error}`);
+  }
+  skippedIdx.push(i);
+  executedIdx.pop();
+  return { status: "skipped" };
+}
+function runOp(i, op, states, exec, executedIdx, skippedIdx) {
+  const pre = preflightOp(i, op, states);
+  if (pre.kind === "invalid-policy")
+    fail3("UNKNOWN_POLICY", pre.message);
+  if (pre.kind === "skip") {
+    skippedIdx.push(i);
+    return { status: "skipped" };
+  }
+  const outcome = exec(op, pre.bound);
+  return interpretOutcome(i, op, pre.policy, outcome, executedIdx, skippedIdx);
+}
+function validateCoverage(stages, n) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const stage of stages) {
+    for (const i of stage) {
+      if (i < 0 || i >= n)
+        fail3("INVALID_PLAN", `stage index ${i} out of range [0,${n})`);
+      if (seen.has(i))
+        fail3("INVALID_PLAN", `operation ${i} appears in more than one stage`);
+      seen.add(i);
+    }
+  }
+  if (seen.size !== n)
+    fail3("INVALID_PLAN", `plan does not cover all ${n} operations (covered ${seen.size})`);
+}
+
+// node_modules/behavior-contracts/dist/guard.js
+var PortabilityError = class extends Error {
+  path;
+  constructor(path, message) {
+    super(message);
+    this.path = path;
+    this.name = "PortabilityError";
+  }
+};
+function assertPortable(value, path = "$") {
+  if (typeof value === "function")
+    throw new PortabilityError(path, `Portability Guard: functions cannot be placed in IR (at ${path})`);
+  if (value instanceof Date || value instanceof Promise)
+    throw new PortabilityError(path, `Portability Guard: ${value.constructor.name} cannot be placed in IR (at ${path})`);
+  if (Array.isArray(value)) {
+    value.forEach((v, i) => assertPortable(v, `${path}[${i}]`));
+  } else if (value && typeof value === "object") {
+    for (const [k, v] of Object.entries(value))
+      assertPortable(v, `${path}.${k}`);
+  }
+}
+var PORTABLE_EXPR_OPERATORS = /* @__PURE__ */ new Set([
+  "int",
+  "float",
+  "ref",
+  "refOpt",
+  "obj",
+  "arr",
+  "add",
+  "sub",
+  "mul",
+  "neg",
+  "div",
+  "mod",
+  "concat",
+  "eq",
+  "ne",
+  "lt",
+  "le",
+  "gt",
+  "ge",
+  "and",
+  "or",
+  "not",
+  "coalesce",
+  "cond",
+  "len"
+]);
+function assertPortableComponentGraph(ir, path = "$") {
+  assertPortable(ir, path);
+  if (!ir || typeof ir !== "object")
+    throw new PortabilityError(path, `Portability Guard: IR root must be an object (at ${path})`);
+  const root = ir;
+  if (!Array.isArray(root.components))
+    throw new PortabilityError(`${path}.components`, `Portability Guard: IR.components must be an array`);
+  root.components.forEach((c, ci) => assertPortableComponent(c, `${path}.components[${ci}]`));
+}
+function assertPortableComponent(c, path) {
+  if (!c || typeof c !== "object")
+    throw new PortabilityError(path, `Portability Guard: component must be an object (at ${path})`);
+  const comp = c;
+  if (typeof comp.name !== "string")
+    throw new PortabilityError(`${path}.name`, `Portability Guard: component.name must be a string`);
+  if (!Array.isArray(comp.body))
+    throw new PortabilityError(`${path}.body`, `Portability Guard: component.body must be an array`);
+  comp.body.forEach((n, ni) => assertPortableBodyNode(n, `${path}.body[${ni}]`));
+  assertPortableExpr(comp.output, `${path}.output`);
+}
+function assertPortableBodyNode(n, path) {
+  if (!n || typeof n !== "object")
+    throw new PortabilityError(path, `Portability Guard: body node must be an object (at ${path})`);
+  const node = n;
+  if ("map" in node) {
+    const m = node.map;
+    requireStringComponent(m.component, `${path}.map.component`);
+    assertPortableExpr(m.over, `${path}.map.over`);
+    assertPortablePorts(m.ports, `${path}.map.ports`);
+    if (m.when !== void 0)
+      assertPortableExpr(m.when, `${path}.map.when`);
+    if (m.into !== void 0 && typeof m.into !== "string")
+      throw new PortabilityError(`${path}.map.into`, `Portability Guard: 'into' must be a string key (at ${path}.map.into)`);
+    if (m.batched !== void 0 && typeof m.batched !== "boolean")
+      throw new PortabilityError(`${path}.map.batched`, `Portability Guard: 'batched' must be a boolean (at ${path}.map.batched)`);
+  } else if ("cond" in node) {
+    const co = node.cond;
+    assertPortableExpr(co.if, `${path}.cond.if`);
+    assertPortableExpr(co.then, `${path}.cond.then`);
+    assertPortableExpr(co.else, `${path}.cond.else`);
+  } else if ("component" in node) {
+    requireStringComponent(node.component, `${path}.component`);
+    assertPortablePorts(node.ports, `${path}.ports`);
+  } else {
+    throw new PortabilityError(path, `Portability Guard: unknown body node kind (not componentRef/map/cond) at ${path}`);
+  }
+}
+function requireStringComponent(v, path) {
+  if (typeof v !== "string")
+    throw new PortabilityError(path, `Portability Guard: 'component' must be a string catalog reference, not ${typeof v} (at ${path})`);
+}
+function assertPortablePorts(ports, path) {
+  if (!ports || typeof ports !== "object" || Array.isArray(ports))
+    throw new PortabilityError(path, `Portability Guard: ports must be an object (at ${path})`);
+  for (const [k, v] of Object.entries(ports))
+    assertPortableExpr(v, `${path}.${k}`);
+}
+function assertPortableExpr(node, path) {
+  if (node === null || typeof node === "boolean" || typeof node === "string" || typeof node === "number")
+    return;
+  if (typeof node === "function")
+    throw new PortabilityError(path, `Portability Guard: functions cannot be placed in IR (at ${path})`);
+  if (Array.isArray(node)) {
+    node.forEach((e, i) => assertPortableExpr(e, `${path}[${i}]`));
+    return;
+  }
+  if (typeof node !== "object")
+    throw new PortabilityError(path, `Portability Guard: invalid expression node at ${path}`);
+  const keys = Object.keys(node);
+  if (keys.length === 1) {
+    const op = keys[0];
+    if (!PORTABLE_EXPR_OPERATORS.has(op))
+      throw new PortabilityError(path, `Portability Guard: unknown operator '${op}' (fail-closed) at ${path}`);
+    if (op === "obj") {
+      const arg = node[op];
+      if (!arg || typeof arg !== "object" || Array.isArray(arg))
+        throw new PortabilityError(`${path}.obj`, `Portability Guard: {obj: ...} expects an object (at ${path}.obj)`);
+      for (const [k, v] of Object.entries(arg)) {
+        if (k === FORBIDDEN_OBJECT_KEY)
+          throw new PortabilityError(`${path}.obj`, `Portability Guard: object key "${FORBIDDEN_OBJECT_KEY}" is forbidden (fail-closed) at ${path}.obj`);
+        assertPortableExpr(v, `${path}.obj.${k}`);
+      }
+      return;
+    }
+    assertPortableExpr(node[op], `${path}.${op}`);
+    return;
+  }
+  for (const [k, v] of Object.entries(node))
+    assertPortableExpr(v, `${path}.${k}`);
+}
+
+// node_modules/behavior-contracts/dist/behavior.js
+var BehaviorFailure = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "BehaviorFailure";
+  }
+};
+function bfail(code, message) {
+  throw new BehaviorFailure(code, message);
+}
+function nodeKind(n) {
+  if ("map" in n)
+    return "map";
+  if ("cond" in n)
+    return "cond";
+  if ("component" in n)
+    return "componentRef";
+  bfail("UNKNOWN_NODE_KIND", `body node '${n.id ?? "?"}' is not componentRef/map/cond`);
+}
+function nodeParent(n) {
+  if ("map" in n)
+    return n.map.parent;
+  if ("cond" in n)
+    return n.cond.parent;
+  return n.parent;
+}
+function nodeBindField(n) {
+  if ("map" in n || "cond" in n)
+    return void 0;
+  return n.bindField;
+}
+function nodePolicy(n) {
+  if ("map" in n)
+    return n.map.policy;
+  if ("cond" in n)
+    return void 0;
+  return n.policy;
+}
+function nodeRelationKind(n) {
+  if ("map" in n)
+    return n.map.relationKind;
+  if ("cond" in n)
+    return void 0;
+  return n.relationKind;
+}
+function evalPorts(ports, scope) {
+  const out = {};
+  for (const k of Object.keys(ports))
+    out[k] = evaluate(ports[k], scope);
+  return out;
+}
+function resolveEntry(ir, entry2) {
+  const comp = entry2 ? ir.components.find((c) => c.name === entry2) : ir.components[0];
+  if (!comp)
+    bfail("UNKNOWN_ENTRY", `component '${entry2 ?? "<first>"}' not found in IR`);
+  return comp;
+}
+function buildOps(body, idToIndex) {
+  return body.map((n) => {
+    const pid = nodeParent(n);
+    const parent = pid !== void 0 ? idToIndex.get(pid) ?? null : null;
+    const spec = { id: n.id, parent };
+    const bf = nodeBindField(n);
+    if (bf !== void 0)
+      spec.bindField = bf;
+    const rk = nodeRelationKind(n);
+    if (rk !== void 0)
+      spec.relationKind = rk;
+    const pol = nodePolicy(n);
+    if (pol !== void 0)
+      spec.policy = pol;
+    return spec;
+  });
+}
+function checkBatchAligned(opId, r, want) {
+  if (!Array.isArray(r) || r.length !== want)
+    bfail("MAP_BATCH_RESULT_MISMATCH", `map '${opId}': batched handler must return a list aligned to items (want ${want}, got ${Array.isArray(r) ? r.length : typeof r})`);
+  return r;
+}
+function applyInto(opId, into, over, keptIdx, collected) {
+  const augmented = [];
+  let k = 0;
+  for (let i = 0; i < over.length; i++) {
+    const el = over[i];
+    if (k < keptIdx.length && keptIdx[k] === i) {
+      if (el === null || typeof el !== "object" || Array.isArray(el))
+        bfail("MAP_INTO_ELEMENT_NOT_OBJECT", `map '${opId}': 'into' requires object elements (element ${i} is not an object)`);
+      augmented.push({ ...el, [into]: collected[k] });
+      k++;
+    } else {
+      augmented.push(el);
+    }
+  }
+  return augmented;
+}
+function writeUnproduced(states, ops, body, results) {
+  states.forEach((s, i) => {
+    if (s.status === "skipped") {
+      results[ops[i].id] = nodeRelationKind(body[i]) === "connection" ? { items: [], cursor: null } : null;
+    }
+  });
+}
+function runBehavior(ir, handlers, input = {}, entry2) {
+  const comp = resolveEntry(ir, entry2);
+  const body = comp.body;
+  const idToIndex = /* @__PURE__ */ new Map();
+  body.forEach((n, i) => idToIndex.set(n.id, i));
+  const ops = buildOps(body, idToIndex);
+  const results = {};
+  const baseScope = () => ({ ...input, ...results });
+  const exec = (op) => {
+    const idx = idToIndex.get(op.id);
+    const node = body[idx];
+    const kind = nodeKind(node);
+    if (kind === "cond") {
+      const c = node.cond;
+      const value = evaluate({ cond: [c.if, c.then, c.else] }, baseScope());
+      return { ok: value };
+    }
+    if (kind === "map") {
+      const m = node.map;
+      const over = evaluate(m.over, baseScope());
+      if (!Array.isArray(over))
+        bfail("MAP_OVER_NOT_ARRAY", `map '${op.id}': 'over' did not evaluate to an array`);
+      const handler2 = handlers[m.component];
+      if (!handler2)
+        bfail("UNKNOWN_COMPONENT", `component '${m.component}' has no handler (fail-closed)`);
+      const ctx = { nodeId: op.id, component: m.component };
+      const keep = (el, scope) => m.when === void 0 || evaluate({ cond: [m.when, true, false] }, scope) === true;
+      const keptIdx = [];
+      let collected;
+      if (m.batched === true) {
+        const items = [];
+        over.forEach((el, i) => {
+          const scope = { ...baseScope(), [m.as]: el };
+          if (!keep(el, scope))
+            return;
+          items.push(evalPorts(m.ports, scope));
+          keptIdx.push(i);
+        });
+        if (items.length === 0) {
+          collected = [];
+        } else {
+          const outcome = handler2({ items }, ctx);
+          if ("error" in outcome)
+            return outcome;
+          collected = checkBatchAligned(op.id, outcome.ok, items.length);
+        }
+      } else {
+        collected = [];
+        for (let i = 0; i < over.length; i++) {
+          const el = over[i];
+          const scope = { ...baseScope(), [m.as]: el };
+          if (!keep(el, scope))
+            continue;
+          const ports2 = evalPorts(m.ports, scope);
+          const outcome = handler2(ports2, { ...ctx, bound: el });
+          if ("error" in outcome)
+            return outcome;
+          collected.push(outcome.ok);
+          keptIdx.push(i);
+        }
+      }
+      if (m.into === void 0)
+        return { ok: collected };
+      return { ok: applyInto(op.id, m.into, over, keptIdx, collected) };
+    }
+    const cr = node;
+    const handler = handlers[cr.component];
+    if (!handler)
+      bfail("UNKNOWN_COMPONENT", `component '${cr.component}' has no handler (fail-closed)`);
+    const ports = evalPorts(cr.ports, baseScope());
+    return handler(ports, { nodeId: op.id, component: cr.component });
+  };
+  const wrappedExec = (op, bound) => {
+    const outcome = exec(op, bound);
+    if ("ok" in outcome)
+      results[op.id] = outcome.ok;
+    return outcome;
+  };
+  const plan = comp.plan ?? null;
+  const run = runPlan(plan, ops, wrappedExec);
+  writeUnproduced(run.states, ops, body, results);
+  return evaluate(comp.output, baseScope());
+}
+
+// node_modules/behavior-contracts/dist/builder.js
+var BuilderFailure = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "BuilderFailure";
+  }
+};
+function bfail2(code, message) {
+  throw new BuilderFailure(code, message);
+}
+function checkPortableEntry(name, entry2, fail4) {
+  if (entry2.portableToIR === false)
+    fail4("NOT_PORTABLE_COMPONENT", `component '${name}' is declared portableToIR: false and cannot be referenced from portable IR`);
+}
+function checkPortNames(name, entry2, portNames, fail4) {
+  const schema = entry2.inputPorts ?? {};
+  if (entry2.additionalPorts !== true) {
+    for (const k of portNames)
+      if (!Object.hasOwn(schema, k))
+        fail4("UNKNOWN_PORT", `component '${name}': unknown port '${k}' (catalog schema is the contract; declare it or opt in with additionalPorts: true)`);
+  }
+  for (const [k, s] of Object.entries(schema))
+    if (s.required === true && !portNames.includes(k))
+      fail4("MISSING_PORT", `component '${name}': required port '${k}' is missing`);
+}
+var SCALAR_TYPE_KINDS = {
+  string: "string",
+  number: "number",
+  int: "number",
+  float: "number",
+  boolean: "boolean",
+  bool: "boolean"
+};
+function literalKind(v) {
+  if (typeof v === "string")
+    return "string";
+  if (typeof v === "number")
+    return "number";
+  if (typeof v === "boolean")
+    return "boolean";
+  if (v !== null && typeof v === "object" && !Array.isArray(v)) {
+    const keys = Object.keys(v);
+    if (keys.length === 1 && (keys[0] === "int" || keys[0] === "float"))
+      return "number";
+  }
+  return null;
+}
+function checkDeclaredPortTypes(name, entry2, ports, fail4) {
+  for (const [k, s] of Object.entries(entry2.inputPorts ?? {})) {
+    if (!Object.hasOwn(ports, k))
+      continue;
+    const want = SCALAR_TYPE_KINDS[s.type];
+    if (want === void 0)
+      continue;
+    const got = literalKind(ports[k]);
+    if (got !== null && got !== want)
+      fail4("PORT_TYPE_MISMATCH", `component '${name}': port '${k}' is declared '${s.type}' but is wired a ${got} literal (declared ports are type-checked)`);
+  }
+}
+function collectNodeIdRefs(node, ids, out = []) {
+  if (Array.isArray(node)) {
+    for (const e of node)
+      collectNodeIdRefs(e, ids, out);
+    return out;
+  }
+  if (node && typeof node === "object") {
+    const keys = Object.keys(node);
+    if (keys.length === 1 && (keys[0] === "ref" || keys[0] === "refOpt")) {
+      const path = node[keys[0]];
+      if (Array.isArray(path) && typeof path[0] === "string" && ids.has(path[0]) && !out.includes(path[0]))
+        out.push(path[0]);
+      return out;
+    }
+    for (const k of keys)
+      collectNodeIdRefs(node[k], ids, out);
+  }
+  return out;
+}
+var DEFAULT_PLAN_CONCURRENCY = 16;
+function derivePlanFromDeps(nodes, depsByIndex, concurrency) {
+  if (nodes.length === 0)
+    return void 0;
+  const level = /* @__PURE__ */ new Map();
+  let pending = nodes.length;
+  while (pending > 0) {
+    let progress = false;
+    nodes.forEach((n, i) => {
+      if (level.has(n.id))
+        return;
+      let l = 0;
+      for (const d of depsByIndex[i]) {
+        const dl = d === n.id ? void 0 : level.get(d);
+        if (dl === void 0) {
+          l = -1;
+          break;
+        }
+        l = Math.max(l, dl + 1);
+      }
+      if (l < 0)
+        return;
+      level.set(n.id, l);
+      pending--;
+      progress = true;
+    });
+    if (!progress) {
+      const stuck = nodes.filter((n) => !level.has(n.id)).map((n) => `'${n.id}'`);
+      bfail2("DEPENDENCY_CYCLE", `component body has a dependency cycle among nodes [${stuck.join(", ")}]`);
+    }
+  }
+  const groups = [];
+  nodes.forEach((n, i) => {
+    const l = level.get(n.id);
+    (groups[l] ??= []).push(i);
+  });
+  return { groups, concurrency };
+}
+function canonicalizeDeep(v) {
+  if (Array.isArray(v))
+    return v.map(canonicalizeDeep);
+  if (v !== null && typeof v === "object") {
+    const src = v;
+    const out = {};
+    for (const k of Object.keys(src).sort(cmpCodePoints))
+      out[k] = canonicalizeDeep(src[k]);
+    return out;
+  }
+  return v;
+}
+var DEFINITION_KEYS = /* @__PURE__ */ new Set(["name", "inputPorts", "body", "output", "plan"]);
+var REF_NODE_KEYS = /* @__PURE__ */ new Set(["id", "component", "ports", "parent", "bindField", "relationKind", "policy"]);
+var MAP_NODE_KEYS = /* @__PURE__ */ new Set(["id", "map"]);
+var MAP_KEYS = /* @__PURE__ */ new Set(["over", "as", "component", "ports", "when", "into", "batched", "parent", "relationKind", "policy"]);
+var COND_NODE_KEYS = /* @__PURE__ */ new Set(["id", "cond"]);
+var COND_KEYS = /* @__PURE__ */ new Set(["if", "then", "else", "parent"]);
+var SCHEMA_KEYS = /* @__PURE__ */ new Set(["type", "required"]);
+var PLAN_KEYS = /* @__PURE__ */ new Set(["groups", "concurrency"]);
+var RELATION_KINDS = /* @__PURE__ */ new Set(["single", "connection"]);
+var POLICY_KINDS = /* @__PURE__ */ new Set(["fail", "retry", "continue"]);
+function isPlainObject3(v) {
+  return v !== null && typeof v === "object" && !Array.isArray(v);
+}
+function checkAllowedKeys(rec, allowed, code, at) {
+  for (const k of Object.keys(rec))
+    if (!allowed.has(k))
+      bfail2(code, `${at}: unknown key '${k}' (fail-closed)`);
+}
+function checkScopeKeyName(name, what, at) {
+  if (typeof name !== "string" || name === "")
+    bfail2("INVALID_NODE", `${at}: ${what} must be a non-empty string`);
+  if (name === FORBIDDEN_OBJECT_KEY)
+    bfail2("INVALID_NODE", `${at}: ${what} "${FORBIDDEN_OBJECT_KEY}" is forbidden (fail-closed)`);
+  return name;
+}
+function checkNodeWire(rec, ids, at) {
+  const out = {};
+  if (rec.parent !== void 0) {
+    if (typeof rec.parent !== "string")
+      bfail2("INVALID_NODE", `${at}: 'parent' must be a node id string`);
+    if (!ids.has(rec.parent))
+      bfail2("UNKNOWN_PARENT", `${at}: parent '${rec.parent}' is not a body node id`);
+    out.parent = rec.parent;
+  }
+  if (rec.relationKind !== void 0) {
+    if (typeof rec.relationKind !== "string" || !RELATION_KINDS.has(rec.relationKind))
+      bfail2("INVALID_NODE", `${at}: 'relationKind' must be "single" or "connection"`);
+    out.relationKind = rec.relationKind;
+  }
+  if (rec.policy !== void 0) {
+    if (typeof rec.policy !== "string" || !POLICY_KINDS.has(rec.policy))
+      bfail2("INVALID_NODE", `${at}: 'policy' must be "fail", "retry" or "continue"`);
+    out.policy = rec.policy;
+  }
+  return out;
+}
+function checkPortsShape(ports, at) {
+  if (!isPlainObject3(ports))
+    bfail2("INVALID_NODE", `${at}: 'ports' must be a plain object`);
+  for (const k of Object.keys(ports))
+    if (k === FORBIDDEN_OBJECT_KEY)
+      bfail2("INVALID_NODE", `${at}: port name "${FORBIDDEN_OBJECT_KEY}" is forbidden (fail-closed)`);
+  return ports;
+}
+function normalizeNode(raw, ids, at) {
+  const rec = raw;
+  const id = rec.id;
+  if (rec.map !== void 0) {
+    checkAllowedKeys(rec, MAP_NODE_KEYS, "INVALID_NODE", at);
+    if (!isPlainObject3(rec.map))
+      bfail2("INVALID_NODE", `${at}: 'map' must be a plain object`);
+    const m = rec.map;
+    checkAllowedKeys(m, MAP_KEYS, "INVALID_NODE", `${at}.map`);
+    if (m.over === void 0)
+      bfail2("INVALID_NODE", `${at}.map: 'over' is required`);
+    const as = checkScopeKeyName(m.as, "'as'", `${at}.map`);
+    if (!as.startsWith("$") || as.length < 2)
+      bfail2("INVALID_NODE", `${at}.map: 'as' must be a "$"-prefixed element binding (e.g. "$el"), got '${as}'`);
+    if (ids.has(as))
+      bfail2("INVALID_NODE", `${at}.map: 'as' binding '${as}' collides with a body node id`);
+    if (typeof m.component !== "string" || m.component === "")
+      bfail2("INVALID_NODE", `${at}.map: 'component' must be a non-empty catalog name string`);
+    const ports = checkPortsShape(m.ports, `${at}.map`);
+    const node = { id, map: { over: m.over, as, component: m.component, ports } };
+    if (m.when !== void 0)
+      node.map.when = m.when;
+    if (m.into !== void 0)
+      node.map.into = checkScopeKeyName(m.into, "'into'", `${at}.map`);
+    if (m.batched !== void 0) {
+      if (typeof m.batched !== "boolean")
+        bfail2("INVALID_NODE", `${at}.map: 'batched' must be a boolean`);
+      node.map.batched = m.batched;
+    }
+    const wire = checkNodeWire(m, ids, `${at}.map`);
+    if (wire.parent !== void 0)
+      node.map.parent = wire.parent;
+    if (wire.relationKind !== void 0)
+      node.map.relationKind = wire.relationKind;
+    if (wire.policy !== void 0)
+      node.map.policy = wire.policy;
+    return node;
+  }
+  if (rec.cond !== void 0) {
+    checkAllowedKeys(rec, COND_NODE_KEYS, "INVALID_NODE", at);
+    if (!isPlainObject3(rec.cond))
+      bfail2("INVALID_NODE", `${at}: 'cond' must be a plain object`);
+    const c = rec.cond;
+    checkAllowedKeys(c, COND_KEYS, "INVALID_NODE", `${at}.cond`);
+    if (c.if === void 0)
+      bfail2("INVALID_NODE", `${at}.cond: 'if' is required`);
+    if (c.then === void 0)
+      bfail2("INVALID_NODE", `${at}.cond: 'then' is required (use null for an empty branch)`);
+    if (c.else === void 0)
+      bfail2("INVALID_NODE", `${at}.cond: 'else' is required (use null for an empty branch)`);
+    const node = { id, cond: { if: c.if, then: c.then, else: c.else } };
+    const wire = checkNodeWire(c, ids, `${at}.cond`);
+    if (wire.parent !== void 0)
+      node.cond.parent = wire.parent;
+    return node;
+  }
+  if (rec.component !== void 0) {
+    checkAllowedKeys(rec, REF_NODE_KEYS, "INVALID_NODE", at);
+    if (typeof rec.component !== "string" || rec.component === "")
+      bfail2("INVALID_NODE", `${at}: 'component' must be a non-empty catalog name string`);
+    const ports = checkPortsShape(rec.ports, at);
+    const node = { id, component: rec.component, ports };
+    const wire = checkNodeWire(rec, ids, at);
+    if (wire.parent !== void 0)
+      node.parent = wire.parent;
+    if (rec.bindField !== void 0) {
+      if (typeof rec.bindField !== "string" || rec.bindField === "")
+        bfail2("INVALID_NODE", `${at}: 'bindField' must be a non-empty string`);
+      node.bindField = rec.bindField;
+    }
+    if (wire.relationKind !== void 0)
+      node.relationKind = wire.relationKind;
+    if (wire.policy !== void 0)
+      node.policy = wire.policy;
+    return node;
+  }
+  bfail2("INVALID_NODE", `${at}: body node must be componentRef ('component'), 'map' or 'cond'`);
+}
+function walkRefs(node, binding, ctx, at) {
+  if (node === null || typeof node !== "object")
+    return;
+  if (Array.isArray(node)) {
+    node.forEach((e, i) => walkRefs(e, binding, ctx, `${at}[${i}]`));
+    return;
+  }
+  const rec = node;
+  const keys = Object.keys(rec);
+  if (keys.length === 1) {
+    const op = keys[0];
+    const arg = rec[op];
+    if (op === "ref" || op === "refOpt") {
+      if (!Array.isArray(arg) || arg.length === 0 || arg.some((s) => typeof s !== "string"))
+        bfail2("UNKNOWN_REF", `${at}: '${op}' path must be a non-empty array of strings`);
+      const root = arg[0];
+      if (ctx.ids.has(root)) {
+        ctx.addDep(root);
+        return;
+      }
+      if (ctx.inputs.has(root) || binding !== null && root === binding)
+        return;
+      bfail2("UNKNOWN_REF", `${at}: reference root '${root}' is not a body node id, a declared input port${binding !== null ? `, or the map binding '${binding}'` : ""} (fail-closed)`);
+    }
+    if (op === "obj") {
+      if (isPlainObject3(arg))
+        for (const [k, v] of Object.entries(arg))
+          walkRefs(v, binding, ctx, `${at}.obj.${k}`);
+      return;
+    }
+    if (op === "int" || op === "float")
+      return;
+    walkRefs(arg, binding, ctx, `${at}.${op}`);
+    return;
+  }
+  for (const [k, v] of Object.entries(rec))
+    walkRefs(v, binding, ctx, `${at}.${k}`);
+}
+function nodeRefsAndDeps(n, ids, inputs, at) {
+  const deps = [];
+  const ctx = {
+    ids,
+    inputs,
+    addDep: (d) => {
+      if (!deps.includes(d))
+        deps.push(d);
+    }
+  };
+  if ("map" in n) {
+    walkRefs(n.map.over, null, ctx, `${at}.map.over`);
+    walkRefs(n.map.ports, n.map.as, ctx, `${at}.map.ports`);
+    if (n.map.when !== void 0)
+      walkRefs(n.map.when, n.map.as, ctx, `${at}.map.when`);
+    if (n.map.parent !== void 0 && !deps.includes(n.map.parent))
+      deps.push(n.map.parent);
+  } else if ("cond" in n) {
+    walkRefs(n.cond.if, null, ctx, `${at}.cond.if`);
+    walkRefs(n.cond.then, null, ctx, `${at}.cond.then`);
+    walkRefs(n.cond.else, null, ctx, `${at}.cond.else`);
+    if (n.cond.parent !== void 0 && !deps.includes(n.cond.parent))
+      deps.push(n.cond.parent);
+  } else {
+    walkRefs(n.ports, null, ctx, `${at}.ports`);
+    if (n.parent !== void 0 && !deps.includes(n.parent))
+      deps.push(n.parent);
+  }
+  return deps;
+}
+function validateSuppliedPlan(raw, body, depsByIndex) {
+  if (!isPlainObject3(raw))
+    bfail2("INVALID_PLAN", "'plan' must be an object, null (no plan) or omitted (derived)");
+  checkAllowedKeys(raw, PLAN_KEYS, "INVALID_PLAN", "plan");
+  const { groups, concurrency } = raw;
+  if (typeof concurrency !== "number" || !Number.isSafeInteger(concurrency) || concurrency < 1)
+    bfail2("INVALID_PLAN", "plan.concurrency must be a positive integer");
+  if (!Array.isArray(groups))
+    bfail2("INVALID_PLAN", "plan.groups must be an array of stages");
+  const n = body.length;
+  const stageOf = new Array(n);
+  const seen = /* @__PURE__ */ new Set();
+  groups.forEach((stage, s) => {
+    if (!Array.isArray(stage))
+      bfail2("INVALID_PLAN", `plan.groups[${s}] must be an array of body indexes`);
+    for (const i of stage) {
+      if (typeof i !== "number" || !Number.isSafeInteger(i) || i < 0 || i >= n)
+        bfail2("INVALID_PLAN", `plan.groups[${s}]: index ${String(i)} out of range [0,${n})`);
+      if (seen.has(i))
+        bfail2("INVALID_PLAN", `plan: body index ${i} appears in more than one stage`);
+      seen.add(i);
+      stageOf[i] = s;
+    }
+  });
+  if (seen.size !== n)
+    bfail2("INVALID_PLAN", `plan does not cover all ${n} body nodes (covered ${seen.size})`);
+  const idToIndex = new Map(body.map((node, i) => [node.id, i]));
+  body.forEach((node, i) => {
+    for (const d of depsByIndex[i]) {
+      const di = idToIndex.get(d);
+      if (stageOf[di] >= stageOf[i])
+        bfail2("INVALID_PLAN", `plan: node '${node.id}' (stage ${stageOf[i]}) depends on '${d}' (stage ${stageOf[di]}) \u2014 dependencies must be staged earlier`);
+    }
+  });
+  return { groups: groups.map((stage) => [...stage]), concurrency };
+}
+function buildComponentCore(data, opts) {
+  if (!isPlainObject3(data))
+    bfail2("INVALID_DEFINITION", "component definition must be a plain object");
+  const rec = data;
+  checkAllowedKeys(rec, DEFINITION_KEYS, "INVALID_DEFINITION", "definition");
+  if (typeof rec.name !== "string" || rec.name === "")
+    bfail2("INVALID_DEFINITION", "component 'name' must be a non-empty string");
+  const name = rec.name;
+  if (rec.output === void 0)
+    bfail2("INVALID_DEFINITION", `component '${name}': 'output' is required (use null for no output)`);
+  const inputPorts = {};
+  if (rec.inputPorts !== void 0) {
+    if (!isPlainObject3(rec.inputPorts))
+      bfail2("INVALID_DEFINITION", `component '${name}': 'inputPorts' must be an object`);
+    for (const [k, s] of Object.entries(rec.inputPorts)) {
+      if (k === FORBIDDEN_OBJECT_KEY)
+        bfail2("INVALID_DEFINITION", `component '${name}': input port name "${FORBIDDEN_OBJECT_KEY}" is forbidden (fail-closed)`);
+      if (!isPlainObject3(s))
+        bfail2("INVALID_DEFINITION", `component '${name}': inputPorts['${k}'] must be an object`);
+      checkAllowedKeys(s, SCHEMA_KEYS, "INVALID_DEFINITION", `component '${name}': inputPorts['${k}']`);
+      if (typeof s.type !== "string")
+        bfail2("INVALID_DEFINITION", `component '${name}': inputPorts['${k}'].type must be a string`);
+      if (s.required !== void 0 && typeof s.required !== "boolean")
+        bfail2("INVALID_DEFINITION", `component '${name}': inputPorts['${k}'].required must be a boolean`);
+      inputPorts[k] = s.required !== void 0 ? { type: s.type, required: s.required } : { type: s.type };
+    }
+  }
+  if (!Array.isArray(rec.body))
+    bfail2("INVALID_DEFINITION", `component '${name}': 'body' must be an array`);
+  const ids = /* @__PURE__ */ new Set();
+  rec.body.forEach((raw, i) => {
+    if (!isPlainObject3(raw))
+      bfail2("INVALID_NODE", `body[${i}]: node must be a plain object`);
+    const id = checkScopeKeyName(raw.id, "node 'id'", `body[${i}]`);
+    if (ids.has(id))
+      bfail2("DUPLICATE_NODE_ID", `body[${i}]: duplicate node id '${id}'`);
+    if (Object.hasOwn(inputPorts, id))
+      bfail2("INVALID_NODE", `body[${i}]: node id '${id}' collides with an input port name (the runBehavior scope would be ambiguous)`);
+    ids.add(id);
+  });
+  const body = rec.body.map((raw, i) => normalizeNode(raw, ids, `body[${i}]`));
+  if (opts.catalog !== void 0) {
+    const catalog = opts.catalog;
+    body.forEach((n, i) => {
+      const cname = "map" in n ? n.map.component : "cond" in n ? null : n.component;
+      if (cname === null)
+        return;
+      const ports = "map" in n ? n.map.ports : n.ports;
+      if (!Object.hasOwn(catalog, cname))
+        bfail2("UNKNOWN_COMPONENT", `body[${i}]: component '${cname}' is not in the catalog (fail-closed)`);
+      const entry2 = catalog[cname];
+      checkPortableEntry(cname, entry2, bfail2);
+      checkPortNames(cname, entry2, Object.keys(ports), bfail2);
+      checkDeclaredPortTypes(cname, entry2, ports, bfail2);
+    });
+  }
+  const inputs = new Set(Object.keys(inputPorts));
+  const depsByIndex = body.map((n, i) => nodeRefsAndDeps(n, ids, inputs, `body[${i}]`));
+  walkRefs(rec.output, null, { ids, inputs, addDep: () => {
+  } }, "output");
+  let plan;
+  if (rec.plan === null)
+    plan = void 0;
+  else if (rec.plan === void 0)
+    plan = derivePlanFromDeps(body, depsByIndex, opts.concurrency);
+  else
+    plan = validateSuppliedPlan(rec.plan, body, depsByIndex);
+  const assembled = { name, inputPorts, body, output: rec.output };
+  if (plan !== void 0)
+    assembled.plan = plan;
+  const component = canonicalizeDeep(assembled);
+  assertPortableComponentGraph({ irVersion: 1, exprVersion: SPEC_VERSIONS.expression, components: [component] });
+  return component;
+}
+
+// node_modules/behavior-contracts/dist/authoring.js
+var AuthoringFailure = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "AuthoringFailure";
+  }
+};
+function afail(code, message) {
+  throw new AuthoringFailure(code, message);
+}
+var BEHAVIOR_MARK = /* @__PURE__ */ Symbol.for("behavior-contracts.authoring.behavior");
+var SemanticBehavior = class {
+};
+function behavior(cls, _context) {
+  Object.defineProperty(cls, BEHAVIOR_MARK, { value: true, configurable: true });
+  return cls;
+}
+function isBehaviorClass(cls) {
+  if (typeof cls !== "function")
+    return false;
+  if (cls[BEHAVIOR_MARK] === true)
+    return true;
+  return cls === SemanticBehavior || cls.prototype instanceof SemanticBehavior;
+}
+var EXPR_META = /* @__PURE__ */ Symbol("behavior-contracts.authoring.expr");
+function exprMetaOf(v) {
+  if (v === null || typeof v !== "object" && typeof v !== "function")
+    return void 0;
+  return v[EXPR_META];
+}
+function makeExpr(meta) {
+  return new Proxy({}, {
+    get(_t, prop) {
+      if (prop === EXPR_META)
+        return meta;
+      if (typeof prop === "symbol") {
+        if (prop === Symbol.toPrimitive)
+          return () => notRecordable("implicit coercion of a recorded value (use concat/add/eq/... builders)");
+        return void 0;
+      }
+      if (prop === "then" || prop === "constructor" || prop === "inspect")
+        return void 0;
+      if (prop === "valueOf" || prop === "toString" || prop === "toJSON")
+        return () => notRecordable(`'${prop}' on a recorded value (implicit coercion is not statically interpretable)`);
+      if (prop === "map")
+        return (cb, opts) => recordMap(meta, cb, opts);
+      if (meta.refPath === null)
+        afail("COMPUTED_ACCESS", `property '.${prop}' on a computed expression cannot be lowered (bind the value through a component result or restructure the wiring)`);
+      if (meta.isInput && meta.refPath.length === 0)
+        recordInputPort(prop);
+      const path = [...meta.refPath, prop];
+      return makeExpr({ node: { [meta.refOp]: path }, refPath: path, refOp: meta.refOp, isInput: meta.isInput });
+    },
+    ownKeys() {
+      return notRecordable("spread / enumeration of a recorded value (Expression IR has no object-merge operator; wire explicit keys)");
+    },
+    getOwnPropertyDescriptor() {
+      return notRecordable("property enumeration of a recorded value");
+    },
+    set() {
+      return notRecordable("assignment into a recorded value (authoring is declarative)");
+    }
+  });
+}
+function notRecordable(what) {
+  afail("NOT_RECORDABLE", `not statically interpretable: ${what}`);
+}
+function opExpr(node) {
+  return makeExpr({ node, refPath: null, refOp: "ref", isInput: false });
+}
+function nodeHandle(id) {
+  return makeExpr({ node: { ref: [id] }, refPath: [id], refOp: "ref", isInput: false });
+}
+function lowerValue(v, at) {
+  const meta = exprMetaOf(v);
+  if (meta) {
+    if (meta.refPath !== null && meta.refPath.length === 0)
+      afail("WHOLE_INPUT", `${at}: the whole '$' input cannot be wired; reference a field of it`);
+    return meta.node;
+  }
+  if (v === null)
+    return null;
+  switch (typeof v) {
+    case "boolean":
+    case "string":
+      return v;
+    case "number":
+      if (Number.isInteger(v) && !Number.isSafeInteger(v))
+        afail("BAD_PORT_VALUE", `${at}: integral literal ${v} exceeds the safe range (use a bigint literal)`);
+      if (!Number.isFinite(v))
+        afail("BAD_PORT_VALUE", `${at}: non-finite number literal`);
+      return v;
+    case "bigint":
+      return { int: v.toString() };
+    case "undefined":
+      afail("BAD_PORT_VALUE", `${at}: undefined cannot be wired`);
+      break;
+    case "function":
+      afail("BAD_PORT_VALUE", `${at}: functions cannot be placed in IR (Portability Guard)`);
+      break;
+  }
+  if (Array.isArray(v))
+    return { arr: v.map((e, i) => lowerValue(e, `${at}[${i}]`)) };
+  if (v instanceof Date || v instanceof Promise)
+    afail("BAD_PORT_VALUE", `${at}: ${v.constructor.name} cannot be placed in IR (Portability Guard)`);
+  if (typeof v === "object") {
+    const out = {};
+    for (const k of Object.keys(v)) {
+      if (k === "__proto__")
+        afail("BAD_PORT_VALUE", `${at}: object key "__proto__" is forbidden (fail-closed)`);
+      out[k] = lowerValue(v[k], `${at}.${k}`);
+    }
+    return { obj: out };
+  }
+  afail("BAD_PORT_VALUE", `${at}: value cannot be wired`);
+}
+function binOp(op) {
+  return (a, b) => opExpr({ [op]: [lowerValue(a, op), lowerValue(b, op)] });
+}
+function unOp(op) {
+  return (a) => opExpr({ [op]: [lowerValue(a, op)] });
+}
+function concat(...parts) {
+  if (parts.length < 2)
+    afail("BAD_PORT_VALUE", `concat expects >= 2 args, got ${parts.length}`);
+  return opExpr({ concat: parts.map((p, i) => lowerValue(p, `concat[${i}]`)) });
+}
+var add = /* @__PURE__ */ binOp("add");
+var sub = /* @__PURE__ */ binOp("sub");
+var mul = /* @__PURE__ */ binOp("mul");
+var div = /* @__PURE__ */ binOp("div");
+var mod = /* @__PURE__ */ binOp("mod");
+var neg = /* @__PURE__ */ unOp("neg");
+var eq = /* @__PURE__ */ binOp("eq");
+var ne = /* @__PURE__ */ binOp("ne");
+var lt = /* @__PURE__ */ binOp("lt");
+var le = /* @__PURE__ */ binOp("le");
+var gt = /* @__PURE__ */ binOp("gt");
+var ge = /* @__PURE__ */ binOp("ge");
+var and = /* @__PURE__ */ binOp("and");
+var or = /* @__PURE__ */ binOp("or");
+var not = /* @__PURE__ */ unOp("not");
+var coalesce = /* @__PURE__ */ binOp("coalesce");
+var len = /* @__PURE__ */ unOp("len");
+function opt(x) {
+  const meta = exprMetaOf(x);
+  if (!meta || meta.refPath === null || meta.refPath.length === 0)
+    afail("BAD_PORT_VALUE", "opt(...) expects a reference (a recorded '$' field or node result)");
+  return makeExpr({ node: { refOpt: meta.refPath }, refPath: meta.refPath, refOp: "refOpt", isInput: meta.isInput });
+}
+var currentFrame = null;
+function requireFrame(what) {
+  if (!currentFrame)
+    afail("NO_FRAME", `${what} was used outside compileBehaviors() (recorders only work during build-time evaluation)`);
+  return currentFrame;
+}
+function recordInputPort(name) {
+  const f = requireFrame(`$.${name}`);
+  if (!f.inputPorts.has(name))
+    f.inputPorts.set(name, { type: "unknown", required: true });
+}
+function nextId(f) {
+  const id = `n${f.seq++}`;
+  f.nodeIds.add(id);
+  return id;
+}
+function composedCond(f) {
+  const conds = f.branchStack.map((b) => b.cond);
+  return conds.reduce((acc, c) => acc === void 0 ? c : { and: [acc, c] }, void 0);
+}
+function ensureGate(f) {
+  const bf = f.branchStack[f.branchStack.length - 1];
+  if (!bf)
+    return null;
+  if (f.branchStack.length > 1)
+    afail("NESTED_BRANCH", `method '${f.method}': a when(...) branch containing components cannot nest inside another when(...) branch (authoring v1; flatten to sibling gates)`);
+  if (bf.gateId === null) {
+    const id = nextId(f);
+    const gate = { id, cond: { if: composedCond(f), then: { obj: { ok: true } }, else: null } };
+    f.nodes.push(gate);
+    bf.gateId = id;
+  }
+  return bf;
+}
+function chooseParent(f, deps, bf) {
+  if (bf) {
+    const inBranch = deps.find((d) => {
+      const idx = f.nodes.findIndex((n) => n.id === d);
+      return idx >= bf.startLen;
+    });
+    if (inBranch !== void 0)
+      return { parent: inBranch };
+    return { parent: bf.gateId, bindField: "ok" };
+  }
+  if (deps.length > 0)
+    return { parent: deps[0] };
+  return {};
+}
+function catalogComponents(catalog) {
+  const out = {};
+  for (const name of Object.keys(catalog)) {
+    const entry2 = catalog[name];
+    out[name] = (ports) => recordComponentCall(name, entry2, ports);
+  }
+  return out;
+}
+function recordComponentCall(name, entry2, portsIn) {
+  const f = requireFrame(`component '${name}'`);
+  checkPortableEntry(name, entry2, afail);
+  if (!portsIn || typeof portsIn !== "object" || Array.isArray(portsIn) || exprMetaOf(portsIn))
+    afail("BAD_PORT_VALUE", `component '${name}': ports must be a plain object literal`);
+  checkPortNames(name, entry2, Object.keys(portsIn), afail);
+  const ports = {};
+  for (const k of Object.keys(portsIn))
+    ports[k] = lowerValue(portsIn[k], `component '${name}' port '${k}'`);
+  checkDeclaredPortTypes(name, entry2, ports, afail);
+  if (f.pendingMap) {
+    if (f.pendingMap.component !== null)
+      afail("MAP_MULTI_COMPONENT", `method '${f.method}': a .map callback must invoke exactly one component (got a second call: '${name}')`);
+    f.pendingMap.component = name;
+    f.pendingMap.ports = ports;
+    return opExpr(null);
+  }
+  const bf = ensureGate(f);
+  const deps = collectNodeIdRefs(ports, f.nodeIds);
+  const id = nextId(f);
+  const wire = chooseParent(f, deps, bf);
+  const node = { id, component: name, ports };
+  if (wire.parent !== void 0)
+    node.parent = wire.parent;
+  if (wire.bindField !== void 0)
+    node.bindField = wire.bindField;
+  f.nodes.push(node);
+  return nodeHandle(id);
+}
+function recordMap(overMeta, cb, opts) {
+  const f = requireFrame(".map");
+  if (f.pendingMap)
+    afail("NESTED_MAP", `method '${f.method}': nested .map is not in the v2 vocabulary (chain a second map over the augmented list \u2014 scp-ir-architecture.md \xA75.1)`);
+  if (f.branchStack.length > 0)
+    afail("MAP_IN_BRANCH", `method '${f.method}': .map inside a when(...) branch is not expressible in the IR (guard the 'over' expression instead)`);
+  if (typeof cb !== "function")
+    afail("MAP_NOT_LOWERABLE", `method '${f.method}': .map expects an inline arrow callback`);
+  if (cb.length > 1)
+    afail("MAP_NOT_LOWERABLE", `method '${f.method}': .map callback takes exactly one element binding (v1)`);
+  if (overMeta.refPath !== null && overMeta.refPath.length === 0)
+    afail("WHOLE_INPUT", `method '${f.method}': the whole '$' input cannot be iterated; reference an array field`);
+  if (opts !== void 0) {
+    if (opts === null || typeof opts !== "object")
+      afail("MAP_NOT_LOWERABLE", ".map options must be an object");
+    if (opts.into !== void 0 && typeof opts.into !== "string")
+      afail("MAP_NOT_LOWERABLE", ".map option 'into' must be a string key");
+    if (opts.batched !== void 0 && typeof opts.batched !== "boolean")
+      afail("MAP_NOT_LOWERABLE", ".map option 'batched' must be a boolean");
+  }
+  const as = `$e${f.mapSeq++}`;
+  const binding = makeExpr({ node: { ref: [as] }, refPath: [as], refOp: "ref", isInput: false });
+  f.pendingMap = { as, component: null, ports: null, when: void 0 };
+  let pm;
+  try {
+    cb(binding);
+  } finally {
+    pm = f.pendingMap;
+    f.pendingMap = null;
+  }
+  if (pm.component === null)
+    afail("MAP_NOT_LOWERABLE", `method '${f.method}': a .map callback must invoke a catalog component (a pure-transform map has no operator in the portable Expression IR v2 vocabulary)`);
+  const over = overMeta.node;
+  const deps = collectNodeIdRefs(over, f.nodeIds);
+  collectNodeIdRefs(pm.ports, f.nodeIds, deps);
+  if (pm.when !== void 0)
+    collectNodeIdRefs(pm.when, f.nodeIds, deps);
+  const id = nextId(f);
+  const node = {
+    id,
+    map: { over, as, component: pm.component, ports: pm.ports }
+  };
+  if (pm.when !== void 0)
+    node.map.when = pm.when;
+  if (opts?.into !== void 0)
+    node.map.into = opts.into;
+  if (opts?.batched === true)
+    node.map.batched = true;
+  if (deps.length > 0)
+    node.map.parent = deps[0];
+  f.nodes.push(node);
+  return nodeHandle(id);
+}
+function when(condition, then, otherwise) {
+  const f = requireFrame("when");
+  if (!exprMetaOf(condition))
+    afail("BAD_CONDITION", `method '${f.method}': when(...) condition must be a recorded expression (native ===/&&/?: over recorded values cannot be observed at build time \u2014 use eq/ne/and/... builders)`);
+  if (typeof then !== "function" || otherwise !== void 0 && typeof otherwise !== "function")
+    afail("BAD_BRANCH", `method '${f.method}': when(...) branches must be thunks (() => ...)`);
+  const c = lowerValue(condition, "when condition");
+  if (f.pendingMap) {
+    if (otherwise !== void 0)
+      afail("BAD_BRANCH", `method '${f.method}': when(...) inside a .map callback is guard-form only (no else \u2014 v2 'map.when' skips the element)`);
+    const before = f.pendingMap.component;
+    const result = then();
+    if (f.pendingMap.component === before) {
+      return opExpr({ cond: [c, lowerValue(result, "when then"), null] });
+    }
+    if (f.pendingMap.when !== void 0)
+      afail("BAD_CONDITION", `method '${f.method}': a .map callback records at most one when(...) guard`);
+    f.pendingMap.when = c;
+    return result;
+  }
+  const thenFrame = { cond: c, gateId: null, startLen: f.nodes.length };
+  f.branchStack.push(thenFrame);
+  let thenVal;
+  try {
+    thenVal = then();
+  } finally {
+    f.branchStack.pop();
+  }
+  const thenHasComponents = f.nodes.length > thenFrame.startLen;
+  let elseVal = null;
+  let elseHasComponents = false;
+  if (otherwise !== void 0) {
+    const elseFrame = { cond: { not: [c] }, gateId: null, startLen: f.nodes.length };
+    f.branchStack.push(elseFrame);
+    try {
+      elseVal = otherwise();
+    } finally {
+      f.branchStack.pop();
+    }
+    elseHasComponents = f.nodes.length > elseFrame.startLen;
+  }
+  if (!thenHasComponents && !elseHasComponents)
+    return opExpr({ cond: [c, lowerValue(thenVal, "when then"), lowerValue(elseVal, "when else")] });
+  if (otherwise === void 0)
+    return thenVal;
+  const id = nextId(f);
+  const phi = {
+    id,
+    cond: { if: c, then: lowerValue(thenVal, "when then"), else: lowerValue(elseVal, "when else") }
+  };
+  f.nodes.push(phi);
+  return nodeHandle(id);
+}
+var NATIVE_CONTROL_TOKEN = /\?\?=|&&=|\|\|=|\?\?|\?\.|&&|\|\||===|!==|==|!=|\bif\s*\(|\bswitch\s*\(|[?!]/;
+var REGEX_PRECEDING_KEYWORDS = /* @__PURE__ */ new Set([
+  "return",
+  "typeof",
+  "instanceof",
+  "in",
+  "of",
+  "case",
+  "do",
+  "else",
+  "void",
+  "delete",
+  "throw",
+  "new",
+  "yield",
+  "await"
+]);
+var WORD_CHAR = /[A-Za-z0-9_$#]/;
+function regexCanFollow(prev, word) {
+  if (prev === "")
+    return true;
+  if (WORD_CHAR.test(prev))
+    return REGEX_PRECEDING_KEYWORDS.has(word);
+  return !")]}\"'`.".includes(prev);
+}
+function stripNonCode(src) {
+  const out = src.split("");
+  const blank = (idx) => {
+    if (out[idx] !== "\n")
+      out[idx] = " ";
+  };
+  const stack = [{ tpl: false, braces: 0 }];
+  let prev = "";
+  let word = "";
+  let prevWasWord = false;
+  let i = 0;
+  while (i < src.length) {
+    const top = stack[stack.length - 1];
+    const ch = src[i];
+    if (top.tpl) {
+      if (ch === "\\") {
+        blank(i);
+        if (i + 1 < src.length)
+          blank(i + 1);
+        i += 2;
+        continue;
+      }
+      if (ch === "`") {
+        stack.pop();
+        i++;
+        prev = "`";
+        word = "";
+        prevWasWord = false;
+        continue;
+      }
+      if (ch === "$" && src[i + 1] === "{") {
+        stack.push({ tpl: false, braces: 0 });
+        i += 2;
+        prev = "{";
+        word = "";
+        prevWasWord = false;
+        continue;
+      }
+      blank(i);
+      i++;
+      continue;
+    }
+    const nx = src[i + 1];
+    if (ch === "/" && nx === "/") {
+      while (i < src.length && src[i] !== "\n")
+        blank(i++);
+      continue;
+    }
+    if (ch === "/" && nx === "*") {
+      blank(i);
+      blank(i + 1);
+      i += 2;
+      while (i < src.length && !(src[i] === "*" && src[i + 1] === "/"))
+        blank(i++);
+      if (i < src.length) {
+        blank(i);
+        blank(i + 1);
+        i += 2;
+      }
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      i++;
+      while (i < src.length && src[i] !== ch && src[i] !== "\n") {
+        if (src[i] === "\\") {
+          blank(i);
+          i++;
+          if (i < src.length) {
+            blank(i);
+            i++;
+          }
+          continue;
+        }
+        blank(i);
+        i++;
+      }
+      if (i < src.length && src[i] === ch)
+        i++;
+      prev = ch;
+      word = "";
+      prevWasWord = false;
+      continue;
+    }
+    if (ch === "`") {
+      stack.push({ tpl: true, braces: 0 });
+      i++;
+      prev = "`";
+      word = "";
+      prevWasWord = false;
+      continue;
+    }
+    if (ch === "/" && regexCanFollow(prev, word)) {
+      blank(i);
+      i++;
+      let inClass = false;
+      while (i < src.length && (inClass || src[i] !== "/") && src[i] !== "\n") {
+        if (src[i] === "\\") {
+          blank(i);
+          i++;
+          if (i < src.length) {
+            blank(i);
+            i++;
+          }
+          continue;
+        }
+        if (src[i] === "[")
+          inClass = true;
+        else if (src[i] === "]")
+          inClass = false;
+        blank(i);
+        i++;
+      }
+      if (i < src.length && src[i] === "/") {
+        blank(i);
+        i++;
+      }
+      while (i < src.length && /[a-z]/i.test(src[i])) {
+        blank(i);
+        i++;
+      }
+      prev = "/";
+      word = "";
+      prevWasWord = false;
+      continue;
+    }
+    if (ch === "{")
+      top.braces++;
+    else if (ch === "}") {
+      if (top.braces === 0 && stack.length > 1) {
+        stack.pop();
+        i++;
+        prev = "}";
+        word = "";
+        prevWasWord = false;
+        continue;
+      }
+      top.braces--;
+    }
+    if (WORD_CHAR.test(ch)) {
+      word = prevWasWord ? word + ch : ch;
+      prevWasWord = true;
+    } else {
+      prevWasWord = false;
+      if (!/\s/.test(ch))
+        word = "";
+    }
+    if (!/\s/.test(ch))
+      prev = ch;
+    i++;
+  }
+  return out.join("");
+}
+function nativeControlHint(token) {
+  if (token.startsWith("if"))
+    return { name: "if (...)", hint: "use when(cond, () => then, () => else)" };
+  if (token.startsWith("switch"))
+    return { name: "switch (...)", hint: "use when(...) chains with eq(...) conditions" };
+  switch (token) {
+    case "??=":
+    case "&&=":
+    case "||=":
+      return { name: token, hint: "authoring is declarative; bind a fresh const via coalesce/and/or builders" };
+    case "??":
+      return { name: "??", hint: "use coalesce(a, b)" };
+    case "?.":
+      return { name: "?.", hint: "use opt(x).field (refOpt)" };
+    case "&&":
+      return { name: "&&", hint: "use when(cond, () => x) for a guard, or and(a, b) for a boolean" };
+    case "||":
+      return { name: "||", hint: "use or(a, b) for a boolean, or coalesce(a, b) for a default" };
+    case "===":
+    case "==":
+      return { name: token, hint: "use eq(a, b)" };
+    case "!==":
+    case "!=":
+      return { name: token, hint: "use ne(a, b)" };
+    case "?":
+      return { name: "?:", hint: "use when(cond, () => then, () => else)" };
+    default:
+      return { name: "!", hint: "use not(x) or ne(a, b)" };
+  }
+}
+function scanNativeControlSyntax(source, label) {
+  const stripped = stripNonCode(source);
+  const bodyStart = stripped.indexOf("{");
+  if (bodyStart < 0)
+    return;
+  const m = NATIVE_CONTROL_TOKEN.exec(stripped.slice(bodyStart + 1));
+  if (!m)
+    return;
+  const at = bodyStart + 1 + m.index;
+  const excerpt = source.slice(Math.max(0, at - 30), Math.min(source.length, at + 30)).replace(/\s+/g, " ").trim();
+  const { name, hint } = nativeControlHint(m[0]);
+  afail("NATIVE_CONTROL_SYNTAX", `${label}: native control syntax '${name}' cannot be observed over recorded values at build time (JS Proxy has no ToBoolean/equality trap) and would silently mislower the DAG \u2014 ${hint} (near \`${excerpt}\`)`);
+}
+function compileBehaviors(cls, opts = {}) {
+  if (!isBehaviorClass(cls))
+    afail("NOT_A_BEHAVIOR_CLASS", `class '${cls?.name ?? String(cls)}' is not a behavior class (extend SemanticBehavior or mark it with @behavior)`);
+  const proto = cls.prototype;
+  const methodNames = Object.getOwnPropertyNames(proto).filter((name) => {
+    if (name === "constructor" || name.startsWith("_") || name.startsWith("#"))
+      return false;
+    const d = Object.getOwnPropertyDescriptor(proto, name);
+    return typeof d?.value === "function";
+  });
+  if (methodNames.length === 0)
+    afail("NO_PUBLIC_METHOD", `class '${cls.name}' declares no public method (each public method is one root Behavior)`);
+  for (const method of methodNames)
+    scanNativeControlSyntax(proto[method].toString(), `method '${method}'`);
+  for (const name of Object.getOwnPropertyNames(proto)) {
+    if (name === "constructor" || methodNames.includes(name))
+      continue;
+    const d = Object.getOwnPropertyDescriptor(proto, name);
+    if (typeof d?.value === "function")
+      scanNativeControlSyntax(d.value.toString(), `helper '${name}'`);
+  }
+  for (let k = cls; typeof k === "function" && k !== SemanticBehavior && k !== Function.prototype; k = Object.getPrototypeOf(k)) {
+    const src = Function.prototype.toString.call(k);
+    if (!/\{\s*\[native code\]\s*\}/.test(src))
+      scanNativeControlSyntax(src, `class '${k.name || "<anonymous>"}'`);
+  }
+  const instance = new cls();
+  const components2 = [];
+  for (const method of methodNames) {
+    const frame = {
+      method,
+      nodes: [],
+      nodeIds: /* @__PURE__ */ new Set(),
+      inputPorts: /* @__PURE__ */ new Map(),
+      seq: 0,
+      mapSeq: 0,
+      branchStack: [],
+      pendingMap: null
+    };
+    const dollar = makeExpr({ node: { ref: [] }, refPath: [], refOp: "ref", isInput: true });
+    currentFrame = frame;
+    let returned;
+    try {
+      returned = proto[method].call(instance, dollar);
+    } finally {
+      currentFrame = null;
+    }
+    if (returned === void 0)
+      afail("BAD_OUTPUT", `method '${method}' must return its Output Port (got undefined)`);
+    if (returned instanceof Promise)
+      afail("BAD_OUTPUT", `method '${method}' must be synchronous and declarative (async/await is derived by the compiler, not written)`);
+    const output = lowerValue(returned, `method '${method}' output`);
+    const inputPorts = {};
+    for (const [k, s] of frame.inputPorts)
+      inputPorts[k] = opts.inputPorts?.[method]?.[k] ?? s;
+    for (const [k, s] of Object.entries(opts.inputPorts?.[method] ?? {}))
+      if (!(k in inputPorts))
+        inputPorts[k] = s;
+    components2.push(buildComponentCore({ name: method, inputPorts, body: frame.nodes, output }, { concurrency: opts.concurrency ?? DEFAULT_PLAN_CONCURRENCY }));
+  }
+  const ir = { irVersion: 1, exprVersion: opts.exprVersion ?? SPEC_VERSIONS.expression, components: components2 };
+  assertPortableComponentGraph(ir);
+  return ir;
+}
+function referencedComponents(component) {
+  const out = [];
+  for (const n of component.body) {
+    const name = "map" in n ? n.map.component : "cond" in n ? null : n.component;
+    if (name !== null && !out.includes(name))
+      out.push(name);
+  }
+  return out;
+}
+function classifyBehaviorEffect(component, writeComponents) {
+  const writes = new Set(writeComponents);
+  return referencedComponents(component).some((c) => writes.has(c)) ? "writing" : "read-only";
+}
+
+// node_modules/behavior-contracts/dist/generator/fingerprint.js
+var FingerprintFailure = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "FingerprintFailure";
+  }
+};
+function toValueDomain(doc, path) {
+  if (doc === null || typeof doc === "boolean" || typeof doc === "string")
+    return doc;
+  if (typeof doc === "number") {
+    if (Number.isInteger(doc) && !Object.is(doc, -0)) {
+      if (Math.abs(doc) >= 2 ** 53)
+        throw new FingerprintFailure("UNSAFE_NUMBER", `integral number ${doc} at ${path} exceeds float64-exact range; portable IR must use {int:"..."} (fail-closed)`);
+      return BigInt(doc);
+    }
+    return doc;
+  }
+  if (Array.isArray(doc))
+    return doc.map((v, i) => toValueDomain(v, `${path}[${i}]`));
+  if (typeof doc === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(doc))
+      out[k] = toValueDomain(v, `${path}.${k}`);
+    return out;
+  }
+  throw new FingerprintFailure("INVALID_VALUE", `value of type ${typeof doc} at ${path} cannot appear in a portable IR document (fail-closed)`);
+}
+function utf8Bytes(s) {
+  const out = [];
+  for (const ch of s) {
+    const cp = ch.codePointAt(0);
+    if (cp <= 127)
+      out.push(cp);
+    else if (cp <= 2047)
+      out.push(192 | cp >> 6, 128 | cp & 63);
+    else if (cp <= 65535)
+      out.push(224 | cp >> 12, 128 | cp >> 6 & 63, 128 | cp & 63);
+    else
+      out.push(240 | cp >> 18, 128 | cp >> 12 & 63, 128 | cp >> 6 & 63, 128 | cp & 63);
+  }
+  return out;
+}
+function fnv1a64(bytes) {
+  let h = 0xcbf29ce484222325n;
+  const prime = 0x100000001b3n;
+  const mask = 0xffffffffffffffffn;
+  for (const b of bytes) {
+    h ^= BigInt(b);
+    h = h * prime & mask;
+  }
+  return h.toString(16).padStart(16, "0");
+}
+function fingerprintComponentGraph(doc) {
+  const s = canonicalJson(toValueDomain(doc, "$"));
+  return "fnv1a64:" + fnv1a64(utf8Bytes(s));
+}
+
+// node_modules/behavior-contracts/dist/generator/core.js
+var GeneratorFailure = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "GeneratorFailure";
+  }
+};
+function gfail(code, message) {
+  throw new GeneratorFailure(code, message);
+}
+var registry = /* @__PURE__ */ new Map();
+function registerEmitter(plugin) {
+  registry.set(plugin.language, plugin);
+}
+function registeredLanguages() {
+  return [...registry.keys()].sort();
+}
+function validateGeneratorInput(ir) {
+  if (ir === null || typeof ir !== "object" || Array.isArray(ir))
+    gfail("INPUT_NOT_PORTABLE_IR", "generator input must be a portable component-graph IR document ({irVersion, exprVersion, components[]} \u2014 scp-ir-architecture.md \xA75); got a non-object (fail-closed)");
+  const doc = ir;
+  if (doc.irVersion === void 0 || doc.components === void 0)
+    gfail("INPUT_NOT_PORTABLE_IR", "generator input must be a portable component-graph IR document ({irVersion, exprVersion, components[]}); the codegen path consumes portable IR ONLY \u2014 never source/internal IR or consumer bundles (fail-closed)");
+  if (doc.irVersion !== 1)
+    gfail("UNSUPPORTED_IR_VERSION", `irVersion ${String(doc.irVersion)} is not supported (supported: 1) (fail-closed)`);
+  const exprVersion = doc.exprVersion;
+  if (typeof exprVersion !== "number" || !Number.isInteger(exprVersion) || exprVersion < 1)
+    gfail("INPUT_NOT_PORTABLE_IR", `exprVersion must be a positive integer, got ${String(exprVersion)} (fail-closed)`);
+  if (exprVersion > SPEC_VERSIONS.expression)
+    gfail("UNSUPPORTED_EXPR_VERSION", `exprVersion ${exprVersion} exceeds supported expression version ${SPEC_VERSIONS.expression} (fail-closed)`);
+  assertPortableComponentGraph(ir);
+  const components2 = doc.components;
+  if (components2.length === 0)
+    gfail("EMPTY_IR", "IR has no components \u2014 nothing to generate (fail-closed)");
+  const seen = /* @__PURE__ */ new Set();
+  for (const c of components2) {
+    if (seen.has(c.name))
+      gfail("DUPLICATE_COMPONENT", `component name '${c.name}' appears more than once \u2014 bind() keys must be unique (fail-closed)`);
+    seen.add(c.name);
+  }
+  return ir;
+}
+function generateModule(ir, options) {
+  const plugin = registry.get(options.language);
+  if (!plugin)
+    gfail("UNKNOWN_LANGUAGE", `no emitter registered for language '${options.language}' (registered: ${registeredLanguages().join(", ")}) (fail-closed)`);
+  const validated = validateGeneratorInput(ir);
+  const fingerprint = fingerprintComponentGraph(validated);
+  const specVersions = {
+    behavior: SPEC_VERSIONS.behavior,
+    expression: SPEC_VERSIONS.expression,
+    plan: SPEC_VERSIONS.plan
+  };
+  const componentNames = validated.components.map((c) => c.name);
+  const ctx = {
+    ir: validated,
+    fingerprint,
+    specVersions,
+    componentNames,
+    runtimeImport: options.runtimeImport ?? plugin.defaultRuntimeImport
+  };
+  return {
+    language: plugin.language,
+    code: plugin.emit(ctx),
+    fingerprint,
+    specVersions,
+    componentNames,
+    filenameHint: plugin.filenameHint ?? `behaviors.generated${plugin.fileExtension}`
+  };
+}
+
+// node_modules/behavior-contracts/dist/generator/literal.js
+function rustStr(s) {
+  let out = '"';
+  for (const ch of s) {
+    const cp = ch.codePointAt(0);
+    if (ch === '"')
+      out += '\\"';
+    else if (ch === "\\")
+      out += "\\\\";
+    else if (ch === "\n")
+      out += "\\n";
+    else if (ch === "\r")
+      out += "\\r";
+    else if (ch === "	")
+      out += "\\t";
+    else if (cp < 32)
+      out += `\\u{${cp.toString(16)}}`;
+    else
+      out += ch;
+  }
+  return out + '"';
+}
+function phpStr(s) {
+  let out = '"';
+  for (const ch of s) {
+    const cp = ch.codePointAt(0);
+    if (ch === '"')
+      out += '\\"';
+    else if (ch === "\\")
+      out += "\\\\";
+    else if (ch === "$")
+      out += "\\$";
+    else if (ch === "\n")
+      out += "\\n";
+    else if (ch === "\r")
+      out += "\\r";
+    else if (ch === "	")
+      out += "\\t";
+    else if (cp < 32)
+      out += `\\u{${cp.toString(16)}}`;
+    else
+      out += ch;
+  }
+  return out + '"';
+}
+var jsonishArr = (open, close) => (items, pad, padIn) => `${open}
+${items.map((v) => padIn + v).join(",\n")}
+${pad}${close}`;
+var DIALECTS = {
+  ts: {
+    indentUnit: "  ",
+    null: "null",
+    true: "true",
+    false: "false",
+    str: (s) => JSON.stringify(s),
+    int: (t) => t,
+    float: (t) => t,
+    emptyArr: "[]",
+    emptyObj: "{}",
+    arr: jsonishArr("[", "]"),
+    obj: (entries, pad, padIn) => `{
+${entries.map(([k, v]) => `${padIn}${JSON.stringify(k)}: ${v}`).join(",\n")}
+${pad}}`
+  },
+  py: {
+    indentUnit: "  ",
+    null: "None",
+    true: "True",
+    false: "False",
+    str: (s) => JSON.stringify(s),
+    int: (t) => t,
+    float: (t) => t,
+    emptyArr: "[]",
+    emptyObj: "{}",
+    arr: jsonishArr("[", "]"),
+    obj: (entries, pad, padIn) => `{
+${entries.map(([k, v]) => `${padIn}${JSON.stringify(k)}: ${v}`).join(",\n")}
+${pad}}`
+  },
+  go: {
+    indentUnit: "	",
+    null: "nil",
+    true: "true",
+    false: "false",
+    str: (s) => JSON.stringify(s),
+    // JSON エスケープは Go 文字列リテラルとして合法
+    int: (t) => `json.Number("${t}")`,
+    float: (t) => `json.Number("${t}")`,
+    emptyArr: "[]dslcontracts.JNode{}",
+    emptyObj: "dslcontracts.JObjOf()",
+    arr: (items, pad, padIn) => `[]dslcontracts.JNode{
+${items.map((v) => `${padIn}${v},`).join("\n")}
+${pad}}`,
+    obj: (entries, pad, padIn) => `dslcontracts.JObjOf(
+${entries.map(([k, v]) => `${padIn}${JSON.stringify(k)}, ${v},`).join("\n")}
+${pad})`
+  },
+  rust: {
+    indentUnit: "    ",
+    null: "null",
+    // json! マクロ内の JSON トークン
+    true: "true",
+    false: "false",
+    str: rustStr,
+    int: (t) => t,
+    float: (t) => t,
+    emptyArr: "[]",
+    emptyObj: "{}",
+    arr: jsonishArr("[", "]"),
+    obj: (entries, pad, padIn) => `{
+${entries.map(([k, v]) => `${padIn}${rustStr(k)}: ${v}`).join(",\n")}
+${pad}}`
+  },
+  php: {
+    indentUnit: "    ",
+    null: "null",
+    true: "true",
+    false: "false",
+    str: phpStr,
+    int: (t) => t,
+    float: (t) => t,
+    emptyArr: "[]",
+    emptyObj: "(object) []",
+    arr: (items, pad, padIn) => `[
+${items.map((v) => `${padIn}${v},`).join("\n")}
+${pad}]`,
+    obj: (entries, pad, padIn) => `(object) [
+${entries.map(([k, v]) => `${padIn}${phpStr(k)} => ${v},`).join("\n")}
+${pad}]`
+  }
+};
+function scalarNumber(n, path, d) {
+  if (!Number.isFinite(n))
+    throw new FingerprintFailure("INVALID_VALUE", `non-finite number at ${path} cannot be emitted (fail-closed)`);
+  if (Object.is(n, -0))
+    return d.float("-0.0");
+  if (Number.isInteger(n)) {
+    if (Math.abs(n) >= 2 ** 53)
+      throw new FingerprintFailure("UNSAFE_NUMBER", `integral number ${n} at ${path} exceeds float64-exact range; portable IR must use {int:"..."} (fail-closed)`);
+    return d.int(String(n));
+  }
+  return d.float(String(n));
+}
+function emitDocLiteral(doc, style, indent = 0, path = "$") {
+  const d = DIALECTS[style];
+  const pad = d.indentUnit.repeat(indent);
+  const padIn = d.indentUnit.repeat(indent + 1);
+  if (doc === null)
+    return d.null;
+  if (typeof doc === "boolean")
+    return doc ? d.true : d.false;
+  if (typeof doc === "string")
+    return d.str(doc);
+  if (typeof doc === "number")
+    return scalarNumber(doc, path, d);
+  if (Array.isArray(doc)) {
+    if (doc.length === 0)
+      return d.emptyArr;
+    const items = doc.map((v, i) => emitDocLiteral(v, style, indent + 1, `${path}[${i}]`));
+    return d.arr(items, pad, padIn);
+  }
+  if (typeof doc === "object") {
+    const entries = Object.entries(doc);
+    if (entries.length === 0)
+      return d.emptyObj;
+    const emitted = entries.map(([k, v]) => [
+      k,
+      emitDocLiteral(v, style, indent + 1, `${path}.${k}`)
+    ]);
+    return d.obj(emitted, pad, padIn);
+  }
+  throw new FingerprintFailure("INVALID_VALUE", `value of type ${typeof doc} at ${path} cannot be emitted as a portable IR literal (fail-closed)`);
+}
+
+// node_modules/behavior-contracts/dist/generator/emit-typescript.js
+function emit(ctx) {
+  const { fingerprint, specVersions, componentNames, runtimeImport } = ctx;
+  const spec = runtimeImport;
+  const names = componentNames.map((n) => JSON.stringify(n)).join(", ");
+  const irLiteral = emitDocLiteral(ctx.ir, "ts");
+  return `// GENERATED by behavior-contracts common generator (bc#13) \u2014 DO NOT EDIT.
+// Input: portable component-graph IR only (scp-ir-architecture.md \xA75/\xA77.4).
+// This module is the codegen endpoint (\xA77.3 endpoint 3): the IR is embedded as a
+// typed native literal and handed to the EXISTING runtime core (runBehavior) \u2014
+// no execution logic is generated. Handlers are ALWAYS injected at the boundary
+// (IR + {effects,config,hooks} \u2014 concept.md \xA74.4); they are never generated.
+// irFingerprint: ${fingerprint}
+import { SPEC_VERSIONS, fingerprintComponentGraph, runBehavior, runBehaviorAsync } from ${JSON.stringify(spec)};
+import type { AsyncHandlers, ComponentGraphIR, Handlers, Scope, Value } from ${JSON.stringify(spec)};
+
+/** Spec versions baked at generation time (fail-closed constant comparison at load). */
+export const EXPECTED_SPEC_VERSIONS = { behavior: ${specVersions.behavior}, expression: ${specVersions.expression}, plan: ${specVersions.plan} } as const;
+
+/** FNV-1a 64 fingerprint of the source portable IR (canonicalJson discipline, #208). */
+export const IR_FINGERPRINT = ${JSON.stringify(fingerprint)};
+
+/** Component names exposed by bind()/bindAsync(), in IR declaration order. */
+export const COMPONENT_NAMES: readonly string[] = [${names}];
+
+/** The portable component-graph IR, embedded as a typed native literal (no JSON parse at runtime). */
+export const IR: ComponentGraphIR = ${irLiteral};
+
+// \u2500\u2500 load-time fail-closed checks (#208 prepared-artifact discipline) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+for (const [k, want] of Object.entries(EXPECTED_SPEC_VERSIONS)) {
+  const got = (SPEC_VERSIONS as Record<string, number>)[k];
+  if (got !== want)
+    throw new Error(
+      \`behavior-contracts generated module: spec-version skew for '\${k}' (generated=\${want}, runtime=\${got}) \u2014 regenerate against this runtime (fail-closed)\`,
+    );
+}
+if (fingerprintComponentGraph(IR) !== IR_FINGERPRINT)
+  throw new Error(
+    \`behavior-contracts generated module: IR fingerprint mismatch (baked=\${IR_FINGERPRINT}, embedded literal=\${fingerprintComponentGraph(IR)}) \u2014 the generated code was modified or corrupted (fail-closed)\`,
+  );
+
+/**
+ * bind \u2014 inject handlers (boundary injection; catalog name \u2192 implementation) and
+ * get one callable per component. Each call delegates to the runtime core's
+ * runBehavior over the embedded IR (dynamic-path equivalent \u2014 \xA77.3).
+ */
+export function bind(handlers: Handlers): Record<string, (input?: Scope) => Value> {
+  const bound: Record<string, (input?: Scope) => Value> = {};
+  for (const name of COMPONENT_NAMES) bound[name] = (input: Scope = {}) => runBehavior(IR, handlers, input, name);
+  return bound;
+}
+
+/** bindAsync \u2014 as bind, over runBehaviorAsync (bounded stage parallelism per plan.concurrency). */
+export function bindAsync(handlers: AsyncHandlers): Record<string, (input?: Scope) => Promise<Value>> {
+  const bound: Record<string, (input?: Scope) => Promise<Value>> = {};
+  for (const name of COMPONENT_NAMES)
+    bound[name] = (input: Scope = {}) => runBehaviorAsync(IR, handlers, input, name);
+  return bound;
+}
+`;
+}
+var typescriptEmitter = {
+  language: "typescript",
+  fileExtension: ".ts",
+  defaultRuntimeImport: "behavior-contracts",
+  emit
+};
+
+// node_modules/behavior-contracts/dist/generator/emit-python.js
+function pyStr(s) {
+  return JSON.stringify(s);
+}
+function emit2(ctx) {
+  const { fingerprint, specVersions, componentNames, runtimeImport } = ctx;
+  const names = componentNames.map(pyStr).join(", ");
+  const namesTuple = componentNames.length === 1 ? `(${names},)` : `(${names})`;
+  const irLiteral = emitDocLiteral(ctx.ir, "py");
+  return `# GENERATED by behavior-contracts common generator (bc#13) \u2014 DO NOT EDIT.
+# Input: portable component-graph IR only (scp-ir-architecture.md \xA75/\xA77.4).
+# This module is the codegen endpoint (\xA77.3 endpoint 3): the IR is embedded as a
+# native dict literal and handed to the EXISTING runtime core (run_behavior) \u2014
+# no execution logic is generated. Handlers are ALWAYS injected at the boundary
+# (IR + {effects,config,hooks}); they are never generated.
+# irFingerprint: ${fingerprint}
+from ${runtimeImport} import SPEC_VERSIONS, fingerprint_component_graph, run_behavior
+
+# Spec versions baked at generation time (fail-closed constant comparison at load).
+EXPECTED_SPEC_VERSIONS = {"behavior": ${specVersions.behavior}, "expression": ${specVersions.expression}, "plan": ${specVersions.plan}}
+
+# FNV-1a 64 fingerprint of the source portable IR (canonical_json discipline, #208).
+IR_FINGERPRINT = ${pyStr(fingerprint)}
+
+# Component names exposed by bind(), in IR declaration order.
+COMPONENT_NAMES = ${namesTuple}
+
+# The portable component-graph IR, embedded as a native dict literal (no JSON parse at runtime).
+IR = ${irLiteral}
+
+
+def _check_generated_module() -> None:
+    # load-time fail-closed checks (#208 prepared-artifact discipline).
+    for _k, _want in EXPECTED_SPEC_VERSIONS.items():
+        _got = SPEC_VERSIONS.get(_k)
+        if _got != _want:
+            raise RuntimeError(
+                "behavior-contracts generated module: spec-version skew for '%s' "
+                "(generated=%s, runtime=%s) \u2014 regenerate against this runtime (fail-closed)"
+                % (_k, _want, _got)
+            )
+    _got_fp = fingerprint_component_graph(IR)
+    if _got_fp != IR_FINGERPRINT:
+        raise RuntimeError(
+            "behavior-contracts generated module: IR fingerprint mismatch "
+            "(baked=%s, embedded literal=%s) \u2014 the generated code was modified or corrupted (fail-closed)"
+            % (IR_FINGERPRINT, _got_fp)
+        )
+
+
+_check_generated_module()
+
+
+def bind(handlers):
+    """Inject handlers (boundary injection; catalog name -> implementation) and get
+    one callable per component. Each call delegates to the runtime core's
+    run_behavior over the embedded IR (dynamic-path equivalent \u2014 \xA77.3)."""
+
+    def _make(name):
+        def _call(input=None):
+            return run_behavior(IR, handlers, dict(input or {}), name)
+
+        return _call
+
+    return {name: _make(name) for name in COMPONENT_NAMES}
+`;
+}
+var pythonEmitter = {
+  language: "python",
+  fileExtension: ".py",
+  defaultRuntimeImport: "behavior_contracts",
+  emit: emit2
+};
+
+// node_modules/behavior-contracts/dist/generator/emit-go.js
+function emit3(ctx) {
+  const { fingerprint, specVersions, componentNames, runtimeImport } = ctx;
+  const names = componentNames.map((n) => JSON.stringify(n)).join(", ");
+  const irLiteral = emitDocLiteral(ctx.ir, "go");
+  return `// GENERATED by behavior-contracts common generator (bc#13) \u2014 DO NOT EDIT.
+// Input: portable component-graph IR only (scp-ir-architecture.md \xA75/\xA77.4).
+// This module is the codegen endpoint (\xA77.3 endpoint 3): the IR is embedded as a
+// native JNode composite literal and handed to the EXISTING runtime core
+// (RunBehavior) \u2014 no execution logic is generated. Handlers are ALWAYS injected
+// at the boundary (IR + {effects,config,hooks} \u2014 concept.md \xA74.4); they are
+// never generated.
+// irFingerprint: ${fingerprint}
+
+package behaviors
+
+import (
+	"encoding/json"
+	"fmt"
+
+	dslcontracts ${JSON.stringify(runtimeImport)}
+)
+
+// ExpectedSpecVersions are the spec versions baked at generation time
+// (fail-closed constant comparison at init).
+var ExpectedSpecVersions = map[string]int64{"behavior": ${specVersions.behavior}, "expression": ${specVersions.expression}, "plan": ${specVersions.plan}}
+
+// IRFingerprint is the FNV-1a 64 fingerprint of the source portable IR
+// (CanonicalJSON discipline, #208).
+const IRFingerprint = ${JSON.stringify(fingerprint)}
+
+// ComponentNames are the components exposed by Bind(), in IR declaration order.
+var ComponentNames = []string{${names}}
+
+// IR is the portable component-graph IR, embedded as a native JNode composite
+// literal (no JSON parse at runtime).
+var IR dslcontracts.JNode = ${irLiteral}
+
+// init \u2014 load-time fail-closed checks (#208 prepared-artifact discipline).
+// A spec-version skew or fingerprint mismatch panics at package initialization,
+// so importing a stale/tampered generated module fails LOUDLY before any
+// behavior can run.
+func init() {
+	for k, want := range ExpectedSpecVersions {
+		if got := dslcontracts.SpecVersions[k]; got != want {
+			panic(fmt.Sprintf("behavior-contracts generated module: spec-version skew for '%s' (generated=%d, runtime=%d) \u2014 regenerate against this runtime (fail-closed)", k, want, got))
+		}
+	}
+	got, err := dslcontracts.FingerprintComponentGraph(IR)
+	if err != nil {
+		panic(fmt.Sprintf("behavior-contracts generated module: fingerprint recompute failed: %v (fail-closed)", err))
+	}
+	if got != IRFingerprint {
+		panic(fmt.Sprintf("behavior-contracts generated module: IR fingerprint mismatch (baked=%s, embedded literal=%s) \u2014 the generated code was modified or corrupted (fail-closed)", IRFingerprint, got))
+	}
+}
+
+// Bind \u2014 inject handlers (boundary injection; catalog name \u2192 implementation) and
+// get one executor func per component. Each call delegates to the runtime core's
+// RunBehavior over the embedded IR (dynamic-path equivalent \u2014 \xA77.3).
+func Bind(handlers dslcontracts.ComponentExec) map[string]func(input *dslcontracts.Obj) (dslcontracts.Value, error) {
+	bound := make(map[string]func(input *dslcontracts.Obj) (dslcontracts.Value, error), len(ComponentNames))
+	for _, name := range ComponentNames {
+		n := name
+		bound[n] = func(input *dslcontracts.Obj) (dslcontracts.Value, error) {
+			return dslcontracts.RunBehavior(IR, handlers, input, n)
+		}
+	}
+	return bound
+}
+`;
+}
+var goEmitter = {
+  language: "go",
+  fileExtension: ".go",
+  defaultRuntimeImport: "github.com/foo-ogawa/behavior-contracts/go",
+  emit: emit3
+};
+
+// node_modules/behavior-contracts/dist/generator/emit-rust.js
+function rustStrLit(s) {
+  return JSON.stringify(s);
+}
+function componentNamesConst(names) {
+  const items = names.map(rustStrLit);
+  const oneLine = `pub const COMPONENT_NAMES: [&str; ${names.length}] = [${items.join(", ")}];`;
+  if (oneLine.length <= 100)
+    return oneLine;
+  return `pub const COMPONENT_NAMES: [&str; ${names.length}] = [
+${items.map((s) => `    ${s},`).join("\n")}
+];`;
+}
+function emit4(ctx) {
+  const { fingerprint, specVersions, componentNames, runtimeImport } = ctx;
+  const irLiteral = emitDocLiteral(ctx.ir, "rust", 1);
+  return `// GENERATED by behavior-contracts common generator (bc#13) \u2014 DO NOT EDIT.
+// Input: portable component-graph IR only (scp-ir-architecture.md \xA75/\xA77.4).
+// This module is the codegen endpoint (\xA77.3 endpoint 3): the IR is embedded as
+// NATIVE json! constructor code (compile-time checked; no JSON-text parsing at
+// runtime) and handed to the EXISTING runtime core (run_behavior) \u2014 no execution
+// logic is generated. Handlers are ALWAYS injected at the boundary
+// (IR + {effects,config,hooks} \u2014 concept.md \xA74.4); they are never generated.
+//
+// Const deviation (documented): serde_json::Value is not const-constructible, so
+// the IR is built ONCE on first use behind std::sync::LazyLock (requires Rust
+// >= 1.80). The first-use fail-closed checks (#208 prepared-artifact discipline)
+// run inside the initializer: a spec-version skew or fingerprint mismatch panics
+// LOUDLY before any behavior can run.
+// irFingerprint: ${fingerprint}
+
+use ${runtimeImport}::{
+    fingerprint_component_graph, run_behavior, BehaviorError, ComponentExec, SpecVersions, Value,
+};
+use serde_json::{json, Value as J};
+use std::sync::LazyLock;
+
+/// Spec versions baked at generation time (fail-closed comparison on first use).
+pub const EXPECTED_SPEC_VERSIONS: [(&str, i64); 3] =
+    [("behavior", ${specVersions.behavior}), ("expression", ${specVersions.expression}), ("plan", ${specVersions.plan})];
+
+/// FNV-1a 64 fingerprint of the source portable IR (canonical_json discipline, #208).
+pub const IR_FINGERPRINT: &str = ${rustStrLit(fingerprint)};
+
+/// Component names exposed by bind(), in IR declaration order.
+${componentNamesConst(componentNames)}
+
+/// The portable component-graph IR, built once on first use from native json!
+/// constructor code (no JSON-text parsing at runtime; see the const-deviation
+/// note in the module header).
+pub static IR: LazyLock<J> = LazyLock::new(|| {
+    let ir = json!(${irLiteral});
+    check_generated_module(&ir);
+    ir
+});
+
+fn runtime_spec_version(key: &str) -> i64 {
+    match key {
+        "behavior" => SpecVersions::BEHAVIOR,
+        "expression" => SpecVersions::EXPRESSION,
+        "plan" => SpecVersions::PLAN,
+        other => {
+            panic!("behavior-contracts generated module: unknown spec key '{other}' (fail-closed)")
+        }
+    }
+}
+
+// First-use fail-closed checks (#208 prepared-artifact discipline).
+fn check_generated_module(ir: &J) {
+    for (key, want) in EXPECTED_SPEC_VERSIONS {
+        let got = runtime_spec_version(key);
+        if got != want {
+            panic!("behavior-contracts generated module: spec-version skew for '{key}' (generated={want}, runtime={got}) \u2014 regenerate against this runtime (fail-closed)");
+        }
+    }
+    for name in COMPONENT_NAMES {
+        let found = ir["components"]
+            .as_array()
+            .is_some_and(|cs| cs.iter().any(|c| c["name"] == name));
+        if !found {
+            panic!("behavior-contracts generated module: component '{name}' missing from the embedded IR \u2014 the generated code was modified or corrupted (fail-closed)");
+        }
+    }
+    let got_fp = fingerprint_component_graph(ir).unwrap_or_else(|e| {
+        panic!(
+            "behavior-contracts generated module: fingerprint recompute failed: {e} (fail-closed)"
+        )
+    });
+    if got_fp != IR_FINGERPRINT {
+        panic!("behavior-contracts generated module: IR fingerprint mismatch (baked={IR_FINGERPRINT}, embedded literal={got_fp}) \u2014 the generated code was modified or corrupted (fail-closed)");
+    }
+}
+
+/// Injected-handler accessor over the embedded IR (see [\`bind\`]). Rust ownership
+/// makes a map of per-component closures sharing one \`&mut handlers\` impractical,
+/// so the per-component executor surface is \`call(name, input)\` with the
+/// component name checked against [\`COMPONENT_NAMES\`] by the runtime core.
+pub struct Bound<H: ComponentExec> {
+    handlers: H,
+}
+
+/// bind \u2014 inject handlers (boundary injection; catalog name \u2192 implementation)
+/// and get an executor over the embedded IR. Each \`call\` delegates to the
+/// runtime core's run_behavior (dynamic-path equivalent \u2014 \xA77.3). Forces the
+/// first-use fail-closed checks.
+pub fn bind<H: ComponentExec>(handlers: H) -> Bound<H> {
+    LazyLock::force(&IR);
+    Bound { handlers }
+}
+
+impl<H: ComponentExec> Bound<H> {
+    pub fn call(&mut self, name: &str, input: &[(String, Value)]) -> Result<Value, BehaviorError> {
+        run_behavior(&IR, &mut self.handlers, input, Some(name))
+    }
+}
+`;
+}
+var rustEmitter = {
+  language: "rust",
+  fileExtension: ".rs",
+  defaultRuntimeImport: "behavior_contracts",
+  filenameHint: "behaviors_generated.rs",
+  emit: emit4
+};
+
+// node_modules/behavior-contracts/dist/generator/emit-php.js
+function phpSq(s) {
+  return `'${s.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
+}
+function emit5(ctx) {
+  const { fingerprint, specVersions, componentNames, runtimeImport } = ctx;
+  const names = componentNames.map(phpSq).join(", ");
+  const irLiteral = emitDocLiteral(ctx.ir, "php");
+  return `<?php
+
+// GENERATED by behavior-contracts common generator (bc#13) \u2014 DO NOT EDIT.
+// Input: portable component-graph IR only (scp-ir-architecture.md \xA75/\xA77.4).
+// This module is the codegen endpoint (\xA77.3 endpoint 3): the IR is embedded as a
+// native stdClass/array literal and handed to the EXISTING runtime core
+// (Behavior::runBehavior) \u2014 no execution logic is generated. Handlers are ALWAYS
+// injected at the boundary (IR + {effects,config,hooks} \u2014 concept.md \xA74.4); they
+// are never generated.
+// irFingerprint: ${fingerprint}
+
+declare(strict_types=1);
+
+// Spec versions baked at generation time (fail-closed constant comparison at require).
+$expectedSpecVersions = ['behavior' => ${specVersions.behavior}, 'expression' => ${specVersions.expression}, 'plan' => ${specVersions.plan}];
+
+// FNV-1a 64 fingerprint of the source portable IR (canonical-json discipline, #208).
+$irFingerprint = ${phpSq(fingerprint)};
+
+// Component names exposed by bind(), in IR declaration order.
+$componentNames = [${names}];
+
+// The portable component-graph IR, embedded as a native literal (no JSON parse at require).
+$ir = ${irLiteral};
+
+// Require-time fail-closed checks (#208 prepared-artifact discipline).
+$runtimeSpecVersions = [
+    'behavior' => \\${runtimeImport}\\SpecVersions::BEHAVIOR,
+    'expression' => \\${runtimeImport}\\SpecVersions::EXPRESSION,
+    'plan' => \\${runtimeImport}\\SpecVersions::PLAN,
+];
+foreach ($expectedSpecVersions as $specKey => $specWant) {
+    $specGot = $runtimeSpecVersions[$specKey] ?? null;
+    if ($specGot !== $specWant) {
+        throw new \\RuntimeException("behavior-contracts generated module: spec-version skew for '{$specKey}' (generated={$specWant}, runtime={$specGot}) \u2014 regenerate against this runtime (fail-closed)");
+    }
+}
+$gotFingerprint = \\${runtimeImport}\\Fingerprint::componentGraph($ir);
+if ($gotFingerprint !== $irFingerprint) {
+    throw new \\RuntimeException("behavior-contracts generated module: IR fingerprint mismatch (baked={$irFingerprint}, embedded literal={$gotFingerprint}) \u2014 the generated code was modified or corrupted (fail-closed)");
+}
+
+// bind \u2014 inject handlers (boundary injection; catalog name \u2192 implementation) and
+// get one executor closure per component. Each call delegates to the runtime
+// core's Behavior::runBehavior over the embedded IR (dynamic-path equivalent \u2014 \xA77.3).
+return (object) [
+    'EXPECTED_SPEC_VERSIONS' => $expectedSpecVersions,
+    'IR_FINGERPRINT' => $irFingerprint,
+    'COMPONENT_NAMES' => $componentNames,
+    'IR' => $ir,
+    'bind' => static function (array $handlers) use ($ir, $componentNames): array {
+        $bound = [];
+        foreach ($componentNames as $name) {
+            $bound[$name] = static fn (array $input = []): mixed => \\${runtimeImport}\\Behavior::runBehavior($ir, $handlers, $input, $name);
+        }
+        return $bound;
+    },
+];
+`;
+}
+var phpEmitter = {
+  language: "php",
+  fileExtension: ".php",
+  defaultRuntimeImport: "BehaviorContracts",
+  emit: emit5
+};
+
+// node_modules/behavior-contracts/dist/generator/index.js
+registerEmitter(typescriptEmitter);
+registerEmitter(pythonEmitter);
+registerEmitter(goEmitter);
+registerEmitter(rustEmitter);
+registerEmitter(phpEmitter);
+
+// node_modules/behavior-contracts/dist/index.js
+var SPEC_VERSIONS = {
+  expression: 2,
+  // v2: obj の __proto__ own key を FORBIDDEN_KEY に（fail-closed）
+  template: 1,
+  plan: 1,
+  canonical: 2,
+  // v2: obj 値の __proto__ own key を FORBIDDEN_KEY に（fail-closed）
+  behavior: 2,
+  // v2: map.when / map.into / map.batched / handler ctx（bc#22。v1 IR の意味論は不変）
+  guard: 1,
+  // 初版（bc#25: assertPortableComponentGraph の accept/reject を vector-pin）
+  c2: 1
+  // 初版（bc#28: c2-catalog-swap — catalog-swap 実行 + IR 構造一致の 5 言語 pin）
+};
+
+// src/scp/catalog.ts
+var P = (type, required) => required ? { type, required } : { type };
+var SELECT_PORTS = {
+  table: P("string", true),
+  select: P("string[]", true),
+  where: P("fragment"),
+  order: P("string"),
+  limit: P("expr"),
+  offset: P("expr"),
+  group: P("string")
+};
+var WRITE_PORTS = {
+  table: P("string", true),
+  where: P("fragment"),
+  returning: P("string"),
+  onConflict: P("string"),
+  onConflictAction: P("string")
+};
+var entry = (name, inputPorts, shape, portableToIR) => ({
+  name,
+  inputPorts,
+  output: { shape },
+  portableToIR,
+  // Dynamic port families (where/set/values record ports) are validated by
+  // assertComponentsInCatalog, not statically enumerable. Tx overrides back to
+  // fail-closed (its one port is static).
+  additionalPorts: true
+});
+var LITEDBMODEL_CATALOG = {
+  // Read: `items` (a Select root yields a row list; per-row collapse to `item` is the
+  // consumer's cardinality concern, mirrored from graphddb Query's `cardinality` port).
+  Select: entry("Select", { ...SELECT_PORTS, cardinality: P("string") }, "items", true),
+  // Writes yield the RETURNING row list (`items`); a single-row write collapses at the
+  // consumer boundary, same as reads.
+  Insert: entry("Insert", WRITE_PORTS, "items", true),
+  Update: entry("Update", WRITE_PORTS, "items", true),
+  Delete: entry("Delete", WRITE_PORTS, "items", true),
+  // The dynamic WHERE/SET fragment-tree component (§8). Its ports carry the fragment
+  // tree; the compiler resolves SKIP/AND-OR structure to fragment existence rules.
+  Fragment: entry("Fragment", { tree: P("fragment", true) }, "item", true),
+  // The runtime-side atomic envelope: never referenced by the portable IR (a transaction
+  // IS a component over the CRUD primitives) — runtime-only. Its single port is static,
+  // so it keeps bc's fail-closed default (no additionalPorts opt-in).
+  Tx: {
+    ...entry("Tx", { statements: P("map[]", true) }, "item", false),
+    additionalPorts: false
+  }
+};
+function catalogEntry(name) {
+  return LITEDBMODEL_CATALOG[name];
+}
+var CATALOG_NAMES = [
+  "Select",
+  "Insert",
+  "Update",
+  "Delete",
+  "Fragment",
+  "Tx"
+];
+var WRITE_CATALOG_NAMES = [
+  "Insert",
+  "Update",
+  "Delete",
+  "Tx"
+];
+var WRITE_SET = new Set(WRITE_CATALOG_NAMES);
+var WRITE_PORT_FAMILIES = [
+  "values.",
+  "set."
+];
+function assertComponentsInCatalog(components2) {
+  const errs = [];
+  for (const c of components2) {
+    for (const n of c.body) {
+      if ("cond" in n) continue;
+      const ref = "map" in n ? n.map : n;
+      const entryDef = LITEDBMODEL_CATALOG[ref.component];
+      if (entryDef === void 0) {
+        errs.push(`${c.name}/${n.id}: references '${ref.component}', not a LITEDBMODEL_CATALOG entry (known: ${CATALOG_NAMES.join(", ")})`);
+        continue;
+      }
+      const ports = ref.ports;
+      for (const [p, s] of Object.entries(entryDef.inputPorts)) {
+        if (s.required === true && !(p in ports)) {
+          errs.push(`${c.name}/${n.id} (${ref.component}): required port '${p}' is not wired`);
+        }
+      }
+      const isWriteItem = WRITE_SET.has(ref.component);
+      for (const p of Object.keys(ports)) {
+        if (p in entryDef.inputPorts) continue;
+        if (isWriteItem && WRITE_PORT_FAMILIES.some((f) => p.startsWith(f))) continue;
+        errs.push(`${c.name}/${n.id} (${ref.component}): port '${p}' is not declared by the catalog entry (nor a write record-family port)`);
+      }
+    }
+  }
+  if (errs.length > 0) {
+    throw new Error(`litedbmodel catalog validation failed (${errs.length} violation${errs.length === 1 ? "" : "s"}):
+ - ${errs.join("\n - ")}`);
+  }
+}
+function deriveContractEffect(component) {
+  return classifyBehaviorEffect(component, WRITE_CATALOG_NAMES) === "writing" ? "command" : "query";
+}
+
+// src/scp/ir.ts
+var WHERE_SLOT = "{where}";
+
+// src/scp/dialect.ts
+function toDollarPlaceholders(sql) {
+  let n = 0;
+  let out = "";
+  for (const ch of sql) {
+    if (ch === "?") {
+      n += 1;
+      out += `$${n}`;
+    } else {
+      out += ch;
+    }
+  }
+  return out;
+}
+function onConflictClause(conflictColumns, action, excludedRef) {
+  const target = conflictColumns.length > 0 ? ` (${conflictColumns.join(", ")})` : "";
+  if (action === "ignore") {
+    return ` ON CONFLICT${target} DO NOTHING`;
+  }
+  const sets = action.updateColumns.map((c) => `${c} = ${excludedRef(c)}`);
+  return ` ON CONFLICT${target} DO UPDATE SET ${sets.join(", ")}`;
+}
+function guardInsertText(table, columns, placeholders, form) {
+  const head = form === "insertIgnore" ? "INSERT IGNORE INTO" : "INSERT INTO";
+  const tail = form === "trailingDoNothing" ? " ON CONFLICT DO NOTHING" : "";
+  return `${head} ${table} (${columns.join(", ")}) VALUES (${placeholders})${tail}`;
+}
+var SQLITE = Object.freeze({
+  name: "sqlite",
+  ignoreIsTrailingClause: false,
+  insertVerb(action) {
+    return action === "ignore" ? "INSERT OR IGNORE INTO" : "INSERT INTO";
+  },
+  insertConflictClause(conflictColumns, action) {
+    if (action === "ignore") return "";
+    return onConflictClause(conflictColumns, action, (c) => `excluded.${c}`);
+  },
+  guardInsert(table, columns, placeholders) {
+    return guardInsertText(table, columns, placeholders, "trailingDoNothing");
+  },
+  finalizePlaceholders(sql) {
+    return sql;
+  },
+  orderByNulls(expr, dir, nulls) {
+    return `${expr} ${dir} NULLS ${nulls}`;
+  }
+});
+var POSTGRES = Object.freeze({
+  name: "postgres",
+  ignoreIsTrailingClause: true,
+  insertVerb(_action) {
+    return "INSERT INTO";
+  },
+  insertConflictClause(conflictColumns, action) {
+    return onConflictClause(conflictColumns, action, (c) => `EXCLUDED.${c}`);
+  },
+  guardInsert(table, columns, placeholders) {
+    return guardInsertText(table, columns, placeholders, "trailingDoNothing");
+  },
+  finalizePlaceholders(sql) {
+    return toDollarPlaceholders(sql);
+  },
+  orderByNulls(expr, dir, nulls) {
+    return `${expr} ${dir} NULLS ${nulls}`;
+  }
+});
+var MYSQL = Object.freeze({
+  name: "mysql",
+  ignoreIsTrailingClause: false,
+  insertVerb(action) {
+    return action === "ignore" ? "INSERT IGNORE INTO" : "INSERT INTO";
+  },
+  insertConflictClause(_conflictColumns, action) {
+    if (action === "ignore") return "";
+    const sets = action.updateColumns.map((c) => `${c} = VALUES(${c})`);
+    return ` ON DUPLICATE KEY UPDATE ${sets.join(", ")}`;
+  },
+  guardInsert(table, columns, placeholders) {
+    return guardInsertText(table, columns, placeholders, "insertIgnore");
+  },
+  finalizePlaceholders(sql) {
+    return sql;
+  },
+  orderByNulls(expr, dir, nulls) {
+    const flagDir = nulls === "FIRST" ? "DESC" : "ASC";
+    return `${expr} IS NULL ${flagDir}, ${expr} ${dir}`;
+  }
+});
+var DIALECTS2 = Object.freeze({
+  sqlite: SQLITE,
+  postgres: POSTGRES,
+  mysql: MYSQL
+});
+function dialectFor(name) {
+  const d = DIALECTS2[name];
+  if (d === void 0) {
+    throw new Error(`scp dialect: unknown dialect '${String(name)}' (known: ${Object.keys(DIALECTS2).join(", ")})`);
+  }
+  return d;
+}
+
+// src/scp/compile-dialect.ts
+var assembly = (shape) => ({ shape });
+function compileInsertFor(dialect, desc) {
+  const columns = Object.keys(desc.values);
+  if (columns.length === 0) throw new Error("INSERT requires at least one value column");
+  const placeholders = columns.map(() => "?").join(", ");
+  const params = columns.map((c) => desc.values[c]);
+  const conflictAction = resolveConflictAction(desc, columns);
+  const verb = dialect.insertVerb(conflictAction);
+  let sql = `${verb} ${desc.table} (${columns.join(", ")}) VALUES (${placeholders})`;
+  if (conflictAction !== void 0) {
+    sql += dialect.insertConflictClause(desc.onConflict ?? [], conflictAction);
+  }
+  if (desc.returning !== void 0) sql += ` RETURNING ${desc.returning.join(", ")}`;
+  return { component: "Insert", sql, where: null, params, assembly: assembly("items") };
+}
+function resolveConflictAction(desc, columns) {
+  if (desc.onConflict === void 0 || desc.onConflictAction === void 0) return void 0;
+  if (desc.onConflictAction === "ignore") return "ignore";
+  const cols = desc.onConflictAction.updateColumns === "all" ? columns : desc.onConflictAction.updateColumns;
+  return { updateColumns: cols };
+}
+
+// src/scp/compile-sqlite.ts
+function lowerCondition(c) {
+  if (c.kind === "group") {
+    const tree = {
+      connector: c.connector,
+      fragments: c.conditions.map(lowerCondition)
+    };
+    if (c.skipWhen !== void 0) {
+      throw new Error("a conditional (SKIP) group is not supported in WS1; guard the member conditions individually");
+    }
+    return tree;
+  }
+  let f;
+  switch (c.kind) {
+    case "eq":
+      f = { always: true, sql: `${c.column} = ?`, params: [c.value] };
+      break;
+    case "cmp":
+      f = { always: true, sql: `${c.column} ${c.op} ?`, params: [c.value] };
+      break;
+    case "isNull":
+      f = { always: true, sql: `${c.column} IS NULL`, params: [] };
+      break;
+    case "in":
+      f = { always: true, sql: `${c.column} IN (?)`, params: [c.value], expand: 0 };
+      break;
+  }
+  if (c.skipWhen !== void 0) {
+    delete f.always;
+    f.when = c.skipWhen;
+  }
+  return f;
+}
+function lowerWhere(conditions) {
+  if (conditions === void 0 || conditions.length === 0) return null;
+  return { connector: "AND", fragments: conditions.map(lowerCondition) };
+}
+var assembly2 = (shape) => ({ shape });
+function compileSelect(desc) {
+  const cols = desc.select.length === 1 && desc.select[0] === "*" ? "*" : desc.select.join(", ");
+  let sql = `SELECT ${cols} FROM ${desc.table}`;
+  const where = lowerWhere(desc.where);
+  if (where !== null) sql += WHERE_SLOT;
+  if (desc.group !== void 0) sql += ` GROUP BY ${desc.group}`;
+  if (desc.order !== void 0) sql += ` ORDER BY ${desc.order}`;
+  const params = [];
+  if (desc.limit !== void 0) {
+    sql += ` LIMIT ?`;
+    params.push(desc.limit);
+  }
+  if (desc.offset !== void 0) {
+    sql += ` OFFSET ?`;
+    params.push(desc.offset);
+  }
+  return { component: "Select", sql, where, params, assembly: assembly2("items") };
+}
+function compileInsert(desc) {
+  return compileInsertFor(SQLITE, desc);
+}
+function compileUpdate(desc) {
+  const setCols = Object.keys(desc.set);
+  if (setCols.length === 0) throw new Error("UPDATE requires at least one SET column");
+  const setClauses = setCols.map((c) => `${c} = ?`);
+  const params = setCols.map((c) => desc.set[c]);
+  const where = lowerWhere(desc.where);
+  if (where === null) throw new Error("UPDATE requires conditions");
+  let sql = `UPDATE ${desc.table} SET ${setClauses.join(", ")}${WHERE_SLOT}`;
+  if (desc.returning !== void 0) sql += ` RETURNING ${desc.returning.join(", ")}`;
+  return { component: "Update", sql, where, params, assembly: assembly2("items") };
+}
+function compileDelete(desc) {
+  const where = lowerWhere(desc.where);
+  if (where === null) throw new Error("DELETE requires conditions");
+  let sql = `DELETE FROM ${desc.table}${WHERE_SLOT}`;
+  if (desc.returning !== void 0) sql += ` RETURNING ${desc.returning.join(", ")}`;
+  return { component: "Delete", sql, where, params: [], assembly: assembly2("items") };
+}
+
+// src/scp/render.ts
+function isTree(node) {
+  return "connector" in node;
+}
+function fragmentPresent(f, scope) {
+  if (f.always === true) return true;
+  if (f.when === void 0) return false;
+  const v = evaluate(f.when, scope);
+  return v !== null && v !== false;
+}
+function renderFragment(f, scope, params) {
+  if (f.expand === void 0) {
+    for (const slot of f.params) params.push(evaluate(slot, scope));
+    return f.sql;
+  }
+  let sql = f.sql;
+  for (let i = 0; i < f.params.length; i++) {
+    const v = evaluate(f.params[i], scope);
+    if (i === f.expand) {
+      if (!Array.isArray(v)) {
+        throw new Error(`IN-list expansion slot ${i} did not bind to an array (got ${v === null ? "null" : typeof v})`);
+      }
+      if (v.length === 0) {
+        sql = "1 = 0";
+      } else {
+        sql = sql.replace("(?)", `(${v.map(() => "?").join(", ")})`);
+        for (const el of v) params.push(el);
+      }
+    } else {
+      params.push(v);
+    }
+  }
+  return sql;
+}
+function renderTree(tree, scope, params) {
+  const parts = [];
+  for (const node of tree.fragments) {
+    if (isTree(node)) {
+      const inner = renderTree(node, scope, params);
+      if (inner !== "") parts.push(`(${inner})`);
+    } else if (fragmentPresent(node, scope)) {
+      parts.push(renderFragment(node, scope, params));
+    }
+  }
+  if (parts.length === 0) return "";
+  return parts.join(` ${tree.connector} `);
+}
+function renderOperation(op, input, dialect = SQLITE) {
+  const params = [];
+  const markerIdx = op.sql.indexOf(WHERE_SLOT);
+  if (markerIdx === -1) {
+    for (const slot of op.params) params.push(evaluate(slot, input));
+    return { sql: finalize(op.sql, dialect), params };
+  }
+  const before = op.sql.slice(0, markerIdx);
+  const after = op.sql.slice(markerIdx + WHERE_SLOT.length);
+  const beforeQ = countPlaceholders(before);
+  const preStatics = op.params.slice(0, beforeQ);
+  const postStatics = op.params.slice(beforeQ);
+  for (const slot of preStatics) params.push(evaluate(slot, input));
+  let whereSql = "";
+  if (op.where !== null) {
+    const body = renderTree(op.where, input, params);
+    if (body !== "") whereSql = ` WHERE ${body}`;
+  }
+  for (const slot of postStatics) params.push(evaluate(slot, input));
+  return { sql: finalize(before + whereSql + after, dialect), params };
+}
+function finalize(sql, dialect) {
+  return dialect.finalizePlaceholders(sql);
+}
+function countPlaceholders(sql) {
+  let n = 0;
+  for (const ch of sql) if (ch === "?") n++;
+  return n;
+}
+
+// src/scp/guard.ts
+function assertExprPortable(node, path = "$") {
+  assertPortable(node, path);
+  walkExpr(node, path);
+}
+function walkExpr(node, path) {
+  if (node === null || typeof node !== "object") return;
+  if (Array.isArray(node)) {
+    node.forEach((el, i) => walkExpr(el, `${path}[${i}]`));
+    return;
+  }
+  const keys = Object.keys(node);
+  if (keys.length === 1) {
+    const op = keys[0];
+    if (!PORTABLE_EXPR_OPERATORS.has(op)) {
+      throw new PortabilityError(path, `Portability Guard: '${op}' is not a portable Expression IR operator (closed set: ${[...PORTABLE_EXPR_OPERATORS].join(", ")})`);
+    }
+    const arg = node[op];
+    if (op === "obj") {
+      if (arg === null || typeof arg !== "object" || Array.isArray(arg)) {
+        throw new PortabilityError(`${path}.obj`, `Portability Guard: {obj: ...} expects an object (at ${path}.obj)`);
+      }
+      for (const [k, v] of Object.entries(arg)) {
+        if (k === FORBIDDEN_OBJECT_KEY) {
+          throw new PortabilityError(`${path}.obj`, `Portability Guard: object key "${FORBIDDEN_OBJECT_KEY}" is forbidden (fail-closed) at ${path}.obj`);
+        }
+        walkExpr(v, `${path}.obj.${k}`);
+      }
+      return;
+    }
+    walkExpr(arg, `${path}.${op}`);
+    return;
+  }
+  for (const k of keys) walkExpr(node[k], `${path}.${k}`);
+}
+function assertFragmentPortable(node, path) {
+  if ("connector" in node) {
+    node.fragments.forEach((f, i) => assertFragmentPortable(f, `${path}.fragments[${i}]`));
+    return;
+  }
+  if (node.when !== void 0) assertExprPortable(node.when, `${path}.when`);
+  node.params.forEach((p, i) => assertExprPortable(p, `${path}.params[${i}]`));
+}
+function assertOperationPortable(op) {
+  op.params.forEach((p, i) => assertExprPortable(p, `$.params[${i}]`));
+  if (op.where !== null) assertFragmentPortable(op.where, "$.where");
+}
+function assertComponentPortable(component) {
+  const at = `component '${component.name}'`;
+  for (const n of component.body) {
+    if ("map" in n) {
+      assertExprPortable(n.map.over, `${at}/${n.id}.map.over`);
+      assertExprPortable(n.map.ports, `${at}/${n.id}.map.ports`);
+      if (n.map.when !== void 0) assertExprPortable(n.map.when, `${at}/${n.id}.map.when`);
+    } else if ("cond" in n) {
+      assertExprPortable(n.cond.if, `${at}/${n.id}.cond.if`);
+      assertExprPortable(n.cond.then, `${at}/${n.id}.cond.then`);
+      assertExprPortable(n.cond.else, `${at}/${n.id}.cond.else`);
+    } else {
+      assertExprPortable(n.ports, `${at}/${n.id}.ports`);
+    }
+  }
+  assertExprPortable(component.output, `${at}.output`);
+}
+function assertComponentGraphPortable(ir) {
+  for (const c of ir.components) assertComponentPortable(c);
+}
+
+// src/scp/authoring.ts
+var boundComponents;
+function components() {
+  if (boundComponents === void 0) {
+    boundComponents = catalogComponents(LITEDBMODEL_CATALOG);
+  }
+  return boundComponents;
+}
+function lowerBehaviorClass(cls, options) {
+  const ir = compileBehaviors(cls, {
+    ...options.inputPorts !== void 0 ? { inputPorts: options.inputPorts } : {},
+    ...options.concurrency !== void 0 ? { concurrency: options.concurrency } : {}
+  });
+  assertComponentsInCatalog(ir.components);
+  assertComponentGraphPortable(ir);
+  const methods = {};
+  for (const component of ir.components) {
+    methods[component.name] = {
+      name: component.name,
+      effect: deriveContractEffect(component),
+      component
+    };
+  }
+  return {
+    className: cls.name ?? "<anonymous>",
+    ir,
+    components: ir.components,
+    methods
+  };
+}
+function publishBehaviors(cls, options = {}) {
+  return lowerBehaviorClass(cls, options);
+}
+function compileEager(name, fn, options = {}) {
+  const cls = makeEagerClass(name, fn);
+  return lowerBehaviorClass(cls, options);
+}
+function makeEagerClass(name, fn) {
+  const L = components();
+  const cls = class extends SemanticBehavior {
+  };
+  const method = function($) {
+    return fn($, L);
+  };
+  Object.defineProperty(method, "toString", { value: () => fn.toString(), configurable: true });
+  Object.defineProperty(cls.prototype, name, {
+    value: method,
+    writable: true,
+    enumerable: false,
+    configurable: true
+  });
+  Object.defineProperty(cls, "name", { value: name, configurable: true });
+  return cls;
+}
+
+// src/scp/bridge.ts
+var IN_SENTINEL = "@in";
+function isMap(n) {
+  return "map" in n;
+}
+function nodeRef(n) {
+  return isMap(n) ? { component: n.map.component, ports: n.map.ports } : { component: n.component, ports: n.ports };
+}
+function stringPort(ports, name) {
+  const v = ports[name];
+  if (v === void 0) return void 0;
+  if (typeof v !== "string") {
+    throw new Error(`bridge: port '${name}' must be a literal string in the IR (got ${JSON.stringify(v)})`);
+  }
+  return v;
+}
+function arrPort(ports, name) {
+  const v = ports[name];
+  if (v === void 0) return void 0;
+  if (typeof v === "object" && v !== null && "arr" in v && Array.isArray(v.arr)) {
+    return v.arr;
+  }
+  throw new Error(`bridge: port '${name}' must be an {arr:[...]} literal in the IR (got ${JSON.stringify(v)})`);
+}
+function stringArrayPort(ports, name) {
+  const arr = arrPort(ports, name);
+  if (arr === void 0) return void 0;
+  return arr.map((e) => {
+    if (typeof e !== "string") throw new Error(`bridge: '${name}' entries must be literal strings (got ${JSON.stringify(e)})`);
+    return e;
+  });
+}
+function opKey(node) {
+  if (node === null || typeof node !== "object" || Array.isArray(node)) return void 0;
+  const keys = Object.keys(node);
+  return keys.length === 1 ? keys[0] : void 0;
+}
+function columnOf(node, ctx) {
+  const op = opKey(node);
+  if (op !== "ref" && op !== "refOpt") {
+    throw new Error(`bridge: ${ctx}: the column operand must be a {ref:[...]} / {refOpt:[...]} path, got ${JSON.stringify(node)}`);
+  }
+  const path = node[op];
+  if (!Array.isArray(path) || path.length === 0 || typeof path[path.length - 1] !== "string") {
+    throw new Error(`bridge: ${ctx}: column ref path must be a non-empty string path`);
+  }
+  return path[path.length - 1];
+}
+var CMP_OPS = {
+  lt: "<",
+  le: "<=",
+  gt: ">",
+  ge: ">=",
+  ne: "<>"
+};
+function inSentinelColumn(node) {
+  const op = opKey(node);
+  if (op !== "ref" && op !== "refOpt") return void 0;
+  const path = node[op];
+  if (Array.isArray(path) && path.length >= 2 && path[0] === IN_SENTINEL && typeof path[path.length - 1] === "string") {
+    return path[path.length - 1];
+  }
+  return void 0;
+}
+function lowerWhereMember(node, at) {
+  const op = opKey(node);
+  if (op === void 0) {
+    throw new Error(`bridge: ${at}: a where member must be a single-operator Expression node, got ${JSON.stringify(node)}`);
+  }
+  if (op === "cond") {
+    const args = node.cond;
+    if (!Array.isArray(args) || args.length !== 3 || args[2] !== null) {
+      throw new Error(`bridge: ${at}: a SKIP-optional condition must be {cond:[c, <member>, null]} (else = null)`);
+    }
+    const inner = lowerWhereMember(args[1], `${at}.cond.then`);
+    if (inner.skipWhen !== void 0) {
+      throw new Error(`bridge: ${at}: nested SKIP guards are not supported (one cond per member)`);
+    }
+    return { ...inner, skipWhen: args[0] };
+  }
+  if (op === "and" || op === "or") {
+    const args = node[op];
+    if (!Array.isArray(args) || args.length < 2) {
+      throw new Error(`bridge: ${at}: '${op}' group expects >= 2 members`);
+    }
+    return {
+      kind: "group",
+      connector: op === "and" ? "AND" : "OR",
+      conditions: args.map((m, i) => lowerWhereMember(m, `${at}.${op}[${i}]`))
+    };
+  }
+  if (op === "eq") {
+    const [col, val] = binOperands(node, op, at);
+    const inCol = inSentinelColumn(col);
+    if (inCol !== void 0) {
+      return { kind: "in", column: inCol, value: val };
+    }
+    if (val === null) {
+      return { kind: "isNull", column: columnOf(col, at) };
+    }
+    return { kind: "eq", column: columnOf(col, at), value: val };
+  }
+  if (op in CMP_OPS) {
+    const [col, val] = binOperands(node, op, at);
+    return { kind: "cmp", column: columnOf(col, at), op: CMP_OPS[op], value: val };
+  }
+  throw new Error(`bridge: ${at}: unsupported where operator '${op}' (supported: eq/ne/lt/le/gt/ge/and/or/cond; IN via ${IN_SENTINEL} column head; IS NULL via eq(col,null))`);
+}
+function binOperands(node, op, at) {
+  const args = node[op];
+  if (!Array.isArray(args) || args.length !== 2) {
+    throw new Error(`bridge: ${at}: '${op}' expects exactly 2 operands`);
+  }
+  return [args[0], args[1]];
+}
+function lowerWherePort(ports, at) {
+  const arr = arrPort(ports, "where");
+  if (arr === void 0) return void 0;
+  return arr.map((m, i) => lowerWhereMember(m, `${at}.where[${i}]`));
+}
+function collectFamily(ports, prefix) {
+  const out = {};
+  for (const k of Object.keys(ports)) {
+    if (k.startsWith(`${prefix}.`)) out[k.slice(prefix.length + 1)] = ports[k];
+  }
+  return out;
+}
+function conflictOf(ports) {
+  const onConflict = stringPort(ports, "onConflict");
+  const action = stringPort(ports, "onConflictAction");
+  if (onConflict === void 0) return {};
+  const keys = onConflict.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+  if (action === void 0 || action === "ignore") {
+    return { onConflict: keys, onConflictAction: "ignore" };
+  }
+  if (action === "update") {
+    return { onConflict: keys, onConflictAction: { updateColumns: "all" } };
+  }
+  const m = /^update:(.+)$/.exec(action);
+  if (m) {
+    return { onConflict: keys, onConflictAction: { updateColumns: m[1].split(",").map((s) => s.trim()) } };
+  }
+  throw new Error(`bridge: unsupported onConflictAction '${action}' (expected 'ignore' / 'update' / 'update:col,col')`);
+}
+function returningOf(ports) {
+  const r = stringPort(ports, "returning");
+  if (r === void 0) return void 0;
+  return r.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+}
+function compileNode(node, dialect = SQLITE) {
+  const { component, ports } = nodeRef(node);
+  const table = stringPort(ports, "table");
+  if (table === void 0) throw new Error(`bridge: ${component} node requires a literal 'table' port`);
+  const at = `${component}`;
+  switch (component) {
+    case "Select": {
+      const select = stringArrayPort(ports, "select");
+      if (select === void 0) throw new Error(`bridge: Select requires a 'select' {arr:[...]} port`);
+      const desc = { table, select };
+      const where = lowerWherePort(ports, at);
+      if (where !== void 0) desc.where = where;
+      const order = stringPort(ports, "order");
+      if (order !== void 0) desc.order = order;
+      const group = stringPort(ports, "group");
+      if (group !== void 0) desc.group = group;
+      if (ports.limit !== void 0) desc.limit = ports.limit;
+      if (ports.offset !== void 0) desc.offset = ports.offset;
+      return compileSelect(desc);
+    }
+    case "Insert": {
+      const values = collectFamily(ports, "values");
+      if (Object.keys(values).length === 0) throw new Error(`bridge: Insert requires at least one 'values.<field>' port`);
+      const desc = { table, values, ...conflictOf(ports) };
+      const returning = returningOf(ports);
+      if (returning !== void 0) desc.returning = returning;
+      return compileInsertFor(dialect, desc);
+    }
+    case "Update": {
+      const set = collectFamily(ports, "set");
+      if (Object.keys(set).length === 0) throw new Error(`bridge: Update requires at least one 'set.<field>' port`);
+      const where = lowerWherePort(ports, at);
+      if (where === void 0) throw new Error(`bridge: Update requires a 'where' port`);
+      const desc = { table, set, where };
+      const returning = returningOf(ports);
+      if (returning !== void 0) desc.returning = returning;
+      return compileUpdate(desc);
+    }
+    case "Delete": {
+      const where = lowerWherePort(ports, at);
+      if (where === void 0) throw new Error(`bridge: Delete requires a 'where' port`);
+      const desc = { table, where };
+      const returning = returningOf(ports);
+      if (returning !== void 0) desc.returning = returning;
+      return compileDelete(desc);
+    }
+    default:
+      throw new Error(`bridge: catalog component '${component}' has no Backend-Compile (SQL CRUD only: Select/Insert/Update/Delete)`);
+  }
+}
+function compileComponentNodes(component, dialect = SQLITE) {
+  const out = /* @__PURE__ */ new Map();
+  for (const n of component.body) {
+    if ("cond" in n) continue;
+    out.set(n.id, compileNode(n, dialect));
+  }
+  return out;
+}
+
+// src/scp/authoring-sql.ts
+function whereEq(col, value) {
+  return eq(col, value);
+}
+function whereNe(col, value) {
+  return ne(col, value);
+}
+function whereLt(col, value) {
+  return lt(col, value);
+}
+function whereLe(col, value) {
+  return le(col, value);
+}
+function whereGt(col, value) {
+  return gt(col, value);
+}
+function whereGe(col, value) {
+  return ge(col, value);
+}
+function whereIsNull(col) {
+  return eq(col, null);
+}
+function whereIn(col, value) {
+  return eq(col, value);
+}
+function inColumn($, name) {
+  return $[IN_SENTINEL][name];
+}
+
+// src/scp/errors.ts
+var SqlFailure = class extends Error {
+  constructor(kind, policy, sqliteCode, message) {
+    super(message);
+    this.kind = kind;
+    this.policy = policy;
+    this.sqliteCode = sqliteCode;
+    this.name = "SqlFailure";
+  }
+  kind;
+  policy;
+  sqliteCode;
+};
+function isSqliteError(e) {
+  return typeof e === "object" && e !== null && typeof e.code === "string" && e.code.startsWith("SQLITE_");
+}
+function mapSqliteError(e) {
+  if (!isSqliteError(e)) {
+    const message2 = e instanceof Error ? e.message : String(e);
+    return new SqlFailure("driver_error", "fail", void 0, `non-SQLite driver error: ${message2}`);
+  }
+  const { code, message } = e;
+  const tagged = `[${code}] ${message}`;
+  if (code === "SQLITE_CONSTRAINT_FOREIGNKEY") {
+    return new SqlFailure("foreign_key_violation", "fail", code, tagged);
+  }
+  if (code.startsWith("SQLITE_CONSTRAINT")) {
+    return new SqlFailure("constraint_violation", "fail", code, tagged);
+  }
+  if (code === "SQLITE_BUSY" || code === "SQLITE_LOCKED") {
+    return new SqlFailure("retryable", "retry", code, tagged);
+  }
+  return new SqlFailure("driver_error", "fail", code, tagged);
+}
+
+// src/scp/relation.ts
+var RELATION_KEYS_HEAD = "__keys";
+function compileRelationOp(decl) {
+  if (decl.kind !== "hasMany" && decl.limit !== void 0) {
+    throw new Error(`relation '${decl.name}': a per-parent 'limit' is only valid for hasMany (got ${decl.kind})`);
+  }
+  const query = decl.limit !== void 0 ? compileLimitedBatch(decl) : compilePlainBatch(decl);
+  return {
+    name: decl.name,
+    kind: decl.kind,
+    parentKey: decl.parentKey,
+    targetKey: decl.targetKey,
+    query
+  };
+}
+function keysRef() {
+  return { ref: [RELATION_KEYS_HEAD] };
+}
+function compilePlainBatch(decl) {
+  const cols = decl.select.join(", ");
+  const inFragment = {
+    always: true,
+    sql: `${decl.targetKey} IN (?)`,
+    params: [keysRef()],
+    expand: 0
+  };
+  const where = { connector: "AND", fragments: [inFragment] };
+  let sql = `SELECT ${cols} FROM ${decl.targetTable}${WHERE_SLOT}`;
+  if (decl.order !== void 0) sql += ` ORDER BY ${decl.order}`;
+  return { component: "Select", sql, where, params: [], assembly: { shape: "items" } };
+}
+function compileLimitedBatch(decl) {
+  const cols = decl.select.join(", ");
+  const limit = decl.limit;
+  if (!Number.isInteger(limit) || limit < 0) {
+    throw new Error(`relation '${decl.name}': per-parent limit must be a non-negative integer (got ${String(limit)})`);
+  }
+  if (decl.order === void 0) {
+    throw new Error(
+      `relation '${decl.name}': a per-parent 'limit' requires an explicit 'order' (the ROW_NUMBER() window needs a deterministic ordering to decide which ${limit} rows each parent keeps)`
+    );
+  }
+  const order = decl.order;
+  const inFragment = {
+    always: true,
+    sql: `${decl.targetKey} IN (?)`,
+    params: [keysRef()],
+    expand: 0
+  };
+  const where = { connector: "AND", fragments: [inFragment] };
+  const sql = `WITH ranked AS (SELECT ${cols}, ROW_NUMBER() OVER (PARTITION BY ${decl.targetKey} ORDER BY ${order}) AS _rn FROM ${decl.targetTable}${WHERE_SLOT}) SELECT ${cols} FROM ranked WHERE _rn <= ${limit}`;
+  return { component: "Select", sql, where, params: [], assembly: { shape: "items" } };
+}
+function runRelationOp(op, parents, db) {
+  const keys = dedupeKeys(parents, op.parentKey);
+  const batch = /* @__PURE__ */ new Map();
+  if (keys.length === 0) {
+    const rendered2 = renderOperation(op.query, { [RELATION_KEYS_HEAD]: [] });
+    return { sql: rendered2.sql, keys, batch };
+  }
+  const rendered = renderOperation(op.query, { [RELATION_KEYS_HEAD]: keys });
+  const rows = db.prepare(rendered.sql).all(...rendered.params);
+  for (const row of rows) {
+    const k = String(row[op.targetKey]);
+    const list = batch.get(k);
+    if (list === void 0) batch.set(k, [row]);
+    else list.push(row);
+  }
+  return { sql: rendered.sql, keys, batch };
+}
+function dedupeKeys(parents, parentKey) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const p of parents) {
+    const v = p[parentKey];
+    if (v === void 0 || v === null) continue;
+    const s = String(v);
+    if (seen.has(s)) continue;
+    seen.add(s);
+    out.push(v);
+  }
+  return out;
+}
+function distributeToParent(op, parent, batch) {
+  const key = parent[op.parentKey];
+  const rows = key === void 0 || key === null ? void 0 : batch.get(String(key));
+  if (op.kind === "hasMany") return rows ?? [];
+  return rows !== void 0 && rows.length > 0 ? rows[0] : null;
+}
+
+// src/scp/typed-object.ts
+var RELATION_CONTEXT = /* @__PURE__ */ Symbol("litedbmodel:relation-context");
+var RelationContext = class {
+  siblings;
+  ops;
+  db;
+  hydrate;
+  /** Per-relation resolved batch (name → grouping), memoized: one batch query per relation. */
+  resolved = /* @__PURE__ */ new Map();
+  constructor(siblings, ops, db, hydrate) {
+    this.siblings = siblings;
+    this.ops = ops;
+    this.db = db;
+    this.hydrate = hydrate;
+  }
+  /**
+   * Resolve `relationName` for `parent` (lazy access). The relation is batch-loaded across
+   * ALL siblings on first access and memoized, so N sibling accesses issue ONE query. Returns
+   * the hydrated child(ren) per cardinality (`hasMany` → array, else single-or-null).
+   */
+  resolve(relationName, parent) {
+    const op = this.ops[relationName];
+    if (op === void 0) {
+      throw new Error(`relation '${relationName}' is not declared on this result set`);
+    }
+    let batch = this.resolved.get(relationName);
+    if (batch === void 0) {
+      batch = runRelationOp(op, this.siblings, this.db).batch;
+      this.resolved.set(relationName, batch);
+    }
+    return applyHydrate(distributeToParent(op, parent, batch), this.hydrate);
+  }
+};
+function readRelationContext(o) {
+  const v = o[RELATION_CONTEXT];
+  return v instanceof RelationContext ? v : void 0;
+}
+function applyHydrate(value, hydrate) {
+  if (hydrate === void 0) return value;
+  if (value === null) return null;
+  if (Array.isArray(value)) return value.map((v) => v === null ? null : hydrate(v));
+  return hydrate(value);
+}
+function buildResultSet(rawRows, ops, db, options = {}) {
+  const selected = options.with ?? {};
+  const hydrate = options.hydrate;
+  const proto = {};
+  for (const name of Object.keys(ops)) {
+    if (selected[name] === true) continue;
+    Object.defineProperty(proto, name, {
+      enumerable: false,
+      configurable: true,
+      get() {
+        const ctx2 = readRelationContext(this);
+        if (ctx2 === void 0) {
+          return Promise.reject(
+            new Error(
+              `lazy relation '${name}': the batch context was dropped (spread/clone/JSON); re-read through the query API or declaratively select it via { with: { ${name}: true } }`
+            )
+          );
+        }
+        return Promise.resolve(ctx2.resolve(name, this));
+      }
+    });
+  }
+  const rows = rawRows.map((raw) => {
+    const o = Object.create(proto);
+    for (const k of Object.keys(raw)) o[k] = raw[k];
+    return o;
+  });
+  const ctx = new RelationContext(rows, ops, db, hydrate);
+  for (const o of rows) {
+    Object.defineProperty(o, RELATION_CONTEXT, {
+      value: ctx,
+      enumerable: false,
+      writable: false,
+      configurable: false
+    });
+  }
+  for (const name of Object.keys(selected)) {
+    const op = ops[name];
+    if (op === void 0) throw new Error(`declarative select: relation '${name}' is not declared on this model`);
+    const { batch } = runRelationOp(op, rows, db);
+    for (const o of rows) {
+      o[name] = applyHydrate(distributeToParent(op, o, batch), hydrate);
+    }
+  }
+  if (hydrate === void 0) return rows;
+  return rows.map((o) => hydrate(o));
+}
+
+// src/scp/writes.ts
+var ENTITY_ROOT = "__entity";
+var PATH_RE = /^\$\.(input|entity)\.([A-Za-z_][A-Za-z0-9_]*)$/;
+var REF_PATH_RE = /^\$\.ref\.([A-Za-z_][A-Za-z0-9_]*)\.([A-Za-z_][A-Za-z0-9_]*)$/;
+function parseEffectPath(value) {
+  const m = PATH_RE.exec(value);
+  if (m !== null) return { root: m[1], field: m[2] };
+  const r = REF_PATH_RE.exec(value);
+  if (r !== null) return { root: "ref", writeName: r[1], field: r[2] };
+  throw new Error(
+    `write-time relations: '${value}' is not a valid path-rooted value; use '$.input.<field>' (the Command input), '$.entity.<field>' (the sole written row), or '$.ref.<writeName>.<field>' (a named upstream write's RETURNING row).`
+  );
+}
+function assertPaths(map) {
+  for (const v of Object.values(map)) parseEffectPath(v);
+}
+var recorder = {
+  lifecycle(effects = {}) {
+    for (const r of effects.requires ?? []) assertPaths(r.keys);
+    if (effects.idempotency !== void 0) parseEffectPath(effects.idempotency.token);
+    for (const u of effects.unique ?? []) {
+      u.scope.forEach((p) => parseEffectPath(p));
+      u.fields.forEach((p) => parseEffectPath(p));
+    }
+    for (const d of effects.derive ?? []) assertPaths(d.keys);
+    for (const e of effects.edges ?? []) {
+      assertPaths(e.columns);
+      if (e.where !== void 0) assertPaths(e.where);
+    }
+    for (const em of effects.emits ?? []) assertPaths(em.payload);
+    return { effects: freezeEffects(effects) };
+  },
+  exists(table, keys) {
+    return { kind: "requires", table, keys };
+  },
+  unique(spec) {
+    return { kind: "unique", name: spec.name, guardTable: spec.guardTable, scope: spec.scope, fields: spec.fields };
+  },
+  increment(table, keys, attribute, amount) {
+    if (!Number.isFinite(amount)) {
+      throw new Error(`entityWrites: increment amount for '${table}.${attribute}' must be a finite number (got ${String(amount)})`);
+    }
+    return { kind: "derive", table, keys, attribute, amount };
+  },
+  edge(spec) {
+    if (spec.relation === "fk" && spec.where === void 0) {
+      throw new Error(`entityWrites: a 'fk' edge on '${spec.table}' requires a 'where' key map (the matched row's identity)`);
+    }
+    return {
+      kind: "edge",
+      relation: spec.relation,
+      action: spec.action,
+      table: spec.table,
+      columns: spec.columns,
+      ...spec.where !== void 0 ? { where: spec.where } : {}
+    };
+  },
+  event(name, outboxTable, payload) {
+    return { kind: "emit", name, outboxTable, payload };
+  },
+  idempotentBy(table, column, token) {
+    return { kind: "idempotency", table, column, token };
+  }
+};
+function freezeEffects(effects) {
+  const out = {};
+  if (effects.requires !== void 0) out.requires = effects.requires;
+  if (effects.idempotency !== void 0) out.idempotency = effects.idempotency;
+  if (effects.unique !== void 0) out.unique = effects.unique;
+  if (effects.derive !== void 0) out.derive = effects.derive;
+  if (effects.edges !== void 0) out.edges = effects.edges;
+  if (effects.emits !== void 0) out.emits = effects.emits;
+  return out;
+}
+function entityWrites(builder) {
+  const shape = builder(recorder);
+  if (shape.create === void 0 && shape.update === void 0 && shape.remove === void 0) {
+    throw new Error(
+      "entityWrites(...) must declare at least one lifecycle (`create` / `update` / `remove`)."
+    );
+  }
+  return {
+    ...shape.create !== void 0 ? { create: shape.create } : {},
+    ...shape.update !== void 0 ? { update: shape.update } : {},
+    ...shape.remove !== void 0 ? { remove: shape.remove } : {}
+  };
+}
+function edgeWrites(builder) {
+  const def = entityWrites(builder);
+  for (const phase of ["create", "update", "remove"]) {
+    const c = def[phase];
+    if (c === void 0) continue;
+    const e = c.effects;
+    if (e.requires !== void 0 || e.unique !== void 0 || e.derive !== void 0 || e.emits !== void 0 || e.idempotency !== void 0) {
+      throw new Error(
+        `edgeWrites: the '${phase}' lifecycle may declare ONLY 'edges' effects (an edge entity carries only edge writes; use entityWrites for a full save contract).`
+      );
+    }
+  }
+  return def;
+}
+function lifecycleFor(def, phase) {
+  return def[phase];
+}
+
+// src/scp/write-plan.ts
+function pathToRef(value) {
+  const p = parseEffectPath(value);
+  if (p.root === "input") return { ref: [p.field] };
+  if (p.root === "entity") return { ref: [ENTITY_ROOT, p.field] };
+  return { ref: [p.writeName, p.field] };
+}
+function makeIdGen() {
+  let n = 0;
+  return (role) => `tx_${role}_${n++}`;
+}
+function compileRequires(e, nextId2) {
+  const cols = Object.keys(e.keys);
+  if (cols.length === 0) throw new Error(`write-plan: requires on '${e.table}' declares no keys`);
+  const whereSql = cols.map((c) => `${c} = ?`).join(" AND ");
+  const params = cols.map((c) => pathToRef(e.keys[c]));
+  const op = {
+    component: "Select",
+    sql: `SELECT 1 FROM ${e.table} WHERE ${whereSql}`,
+    where: null,
+    params,
+    assembly: { shape: "items" }
+  };
+  return { id: nextId2("requires"), role: "gate:requires", op, gate: "existsElseRollback", label: `requires ${e.table}` };
+}
+function compileIdempotency(e, nextId2, dialect) {
+  const op = {
+    component: "Insert",
+    sql: dialect.guardInsert(e.table, [e.column], "?"),
+    where: null,
+    params: [pathToRef(e.token)],
+    assembly: { shape: "items" }
+  };
+  return { id: nextId2("idem"), role: "gate:idempotency", op, gate: "insertedElseNoop", label: `idempotency ${e.table}` };
+}
+function compileUnique(e, nextId2, dialect) {
+  const scopeCols = e.scope.map((_, i) => `s${i}`);
+  const fieldCols = e.fields.map((_, i) => `f${i}`);
+  const cols = ["name", ...scopeCols, ...fieldCols];
+  const placeholders = cols.map(() => "?").join(", ");
+  const params = [
+    e.name,
+    // literal discriminator (a closed-set string literal)
+    ...e.scope.map(pathToRef),
+    ...e.fields.map(pathToRef)
+  ];
+  const op = {
+    component: "Insert",
+    sql: dialect.guardInsert(e.guardTable, cols, placeholders),
+    where: null,
+    params,
+    assembly: { shape: "items" }
+  };
+  return { id: nextId2("unique"), role: "gate:unique", op, gate: "insertedElseRollback", label: `unique ${e.name}` };
+}
+function compileDerive(e, nextId2) {
+  const keyCols = Object.keys(e.keys);
+  if (keyCols.length === 0) throw new Error(`write-plan: derive on '${e.table}' declares no keys`);
+  const op = {
+    component: "Update",
+    sql: `UPDATE ${e.table} SET ${e.attribute} = ${e.attribute} + ?${WHERE_SLOT}`,
+    where: {
+      connector: "AND",
+      fragments: keyCols.map((c) => ({ always: true, sql: `${c} = ?`, params: [pathToRef(e.keys[c])] }))
+    },
+    params: [e.amount],
+    assembly: { shape: "items" }
+  };
+  return { id: nextId2("derive"), role: "derive", op, label: `derive ${e.table}.${e.attribute}` };
+}
+function compileEdge(e, nextId2) {
+  if (e.relation === "m2m") {
+    const cols = Object.keys(e.columns);
+    if (e.action === "set") {
+      const placeholders = cols.map(() => "?").join(", ");
+      const op3 = {
+        component: "Insert",
+        sql: `INSERT INTO ${e.table} (${cols.join(", ")}) VALUES (${placeholders})`,
+        where: null,
+        params: cols.map((c) => pathToRef(e.columns[c])),
+        assembly: { shape: "items" }
+      };
+      return { id: nextId2("edge"), role: "edge", op: op3, label: `edge m2m link ${e.table}` };
+    }
+    const op2 = {
+      component: "Delete",
+      sql: `DELETE FROM ${e.table}${WHERE_SLOT}`,
+      where: { connector: "AND", fragments: cols.map((c) => ({ always: true, sql: `${c} = ?`, params: [pathToRef(e.columns[c])] })) },
+      params: [],
+      assembly: { shape: "items" }
+    };
+    return { id: nextId2("edge"), role: "edge", op: op2, label: `edge m2m unlink ${e.table}` };
+  }
+  const setCols = Object.keys(e.columns);
+  const whereCols = Object.keys(e.where);
+  const setClauses = setCols.map((c) => e.action === "set" ? `${c} = ?` : `${c} = NULL`);
+  const setParams = e.action === "set" ? setCols.map((c) => pathToRef(e.columns[c])) : [];
+  const op = {
+    component: "Update",
+    sql: `UPDATE ${e.table} SET ${setClauses.join(", ")}${WHERE_SLOT}`,
+    where: { connector: "AND", fragments: whereCols.map((c) => ({ always: true, sql: `${c} = ?`, params: [pathToRef(e.where[c])] })) },
+    params: setParams,
+    assembly: { shape: "items" }
+  };
+  return { id: nextId2("edge"), role: "edge", op, label: `edge fk ${e.action} ${e.table}` };
+}
+function compileEmit(e, nextId2) {
+  const payloadObj = {};
+  for (const [k, v] of Object.entries(e.payload)) payloadObj[k] = pathToRef(v);
+  const op = {
+    component: "Insert",
+    sql: `INSERT INTO ${e.outboxTable} (type, payload) VALUES (?, ?)`,
+    where: null,
+    params: [e.name, { obj: payloadObj }],
+    assembly: { shape: "items" }
+  };
+  return { id: nextId2("emit"), role: "emit", op, label: `emit ${e.name}` };
+}
+function compileWriteGroup(base, lifecycle, nextId2, dialect, seqRef) {
+  const e = lifecycle.effects;
+  const nodes = [];
+  const mk = (stmt, isGate) => {
+    const consumes = refHeadsOf(stmt).filter((h) => h !== ENTITY_ROOT && !isInputHead(h, stmt));
+    return { stmt, seq: seqRef.n++, consumes, produces: stmt.binds ?? null, isGate };
+  };
+  for (const r of e.requires ?? []) nodes.push(mk(compileRequires(r, nextId2), true));
+  if (e.idempotency !== void 0) nodes.push(mk(compileIdempotency(e.idempotency, nextId2, dialect), true));
+  for (const u of e.unique ?? []) nodes.push(mk(compileUnique(u, nextId2, dialect), true));
+  const bodyId = nextId2("body");
+  const bodyStmt = {
+    id: bodyId,
+    role: "body",
+    op: base.op,
+    label: base.label,
+    ...base.name !== void 0 ? { binds: base.name } : {}
+  };
+  nodes.push(mk(bodyStmt, false));
+  for (const d of e.derive ?? []) nodes.push(mk(compileDerive(d, nextId2), false));
+  for (const ed of e.edges ?? []) nodes.push(mk(compileEdge(ed, nextId2), false));
+  for (const em of e.emits ?? []) nodes.push(mk(compileEmit(em, nextId2), false));
+  return { nodes, bodyId };
+}
+function topoOrder(nodes) {
+  const byName = /* @__PURE__ */ new Map();
+  for (const n of nodes) {
+    if (n.produces !== null) {
+      if (byName.has(n.produces)) {
+        throw new Error(`write-plan: two writes both bind the name '${n.produces}' \u2014 write names must be unique in a composite Command.`);
+      }
+      byName.set(n.produces, n);
+    }
+  }
+  const idOf = /* @__PURE__ */ new Map();
+  for (const n of nodes) idOf.set(n, n.stmt.id);
+  const succ = /* @__PURE__ */ new Map();
+  const indeg = /* @__PURE__ */ new Map();
+  const nodeById = /* @__PURE__ */ new Map();
+  for (const n of nodes) {
+    nodeById.set(n.stmt.id, n);
+    succ.set(n.stmt.id, /* @__PURE__ */ new Set());
+    indeg.set(n.stmt.id, 0);
+  }
+  const addEdge = (fromId, toId) => {
+    if (fromId === toId) return;
+    const s = succ.get(fromId);
+    if (!s.has(toId)) {
+      s.add(toId);
+      indeg.set(toId, indeg.get(toId) + 1);
+    }
+  };
+  for (const n of nodes) {
+    for (const dep of n.consumes) {
+      const producer = byName.get(dep);
+      if (producer === void 0) {
+        throw new Error(
+          `write-plan: statement '${n.stmt.label}' references '$.ref.${dep}.*' but no write in this Command binds the name '${dep}' \u2014 a dangling write reference (fail-closed; no silent skip).`
+        );
+      }
+      addEdge(producer.stmt.id, n.stmt.id);
+    }
+  }
+  const gates = nodes.filter((n) => n.isGate);
+  const nonGates = nodes.filter((n) => !n.isGate);
+  for (const g of gates) for (const b of nonGates) addEdge(g.stmt.id, b.stmt.id);
+  const ordered = [];
+  const ready = nodes.filter((n) => indeg.get(n.stmt.id) === 0).sort((a, b) => a.seq - b.seq);
+  while (ready.length > 0) {
+    const n = ready.shift();
+    ordered.push(n.stmt);
+    for (const depId of succ.get(n.stmt.id)) {
+      indeg.set(depId, indeg.get(depId) - 1);
+      if (indeg.get(depId) === 0) {
+        const dn = nodeById.get(depId);
+        let lo = 0;
+        while (lo < ready.length && ready[lo].seq < dn.seq) lo++;
+        ready.splice(lo, 0, dn);
+      }
+    }
+  }
+  if (ordered.length !== nodes.length) {
+    const stuck = nodes.filter((n) => !ordered.includes(n.stmt)).map((n) => n.stmt.label);
+    throw new Error(
+      `write-plan: the write-time transaction DAG has a CYCLE (unresolvable ordering among [${stuck.join(", ")}]). This is either a mutual '$.ref' data dependency or a gate that depends on a body row (a gate cannot depend on a not-yet-written row). ESCALATE: the Command's write dependencies are contradictory \u2014 no order satisfies both the data dependencies and gate-first. (Fail-closed; the derivation never guesses an order.)`
+    );
+  }
+  return ordered;
+}
+function deriveTransactionPlan(phase, bases, lifecycle, dialect = SQLITE) {
+  if (bases.length === 0) {
+    throw new Error("write-plan: a Command must declare at least one base write (Insert/Update/Delete).");
+  }
+  const nextId2 = makeIdGen();
+  const seqRef = { n: 0 };
+  const composite = bases.length > 1;
+  const allNodes = [];
+  const bodyIds = [];
+  bases.forEach((base, i) => {
+    const lc = base.effects !== void 0 ? { effects: base.effects } : i === 0 ? lifecycle : { effects: {} };
+    const { nodes, bodyId } = compileWriteGroup(base, lc, nextId2, dialect, seqRef);
+    allNodes.push(...nodes);
+    bodyIds.push(bodyId);
+  });
+  const statements = topoOrder(allNodes);
+  const soleBody = bases[0];
+  const soleBodyId = bodyIds[0];
+  const usesEntity = referencesHead(statements, ENTITY_ROOT);
+  const soleBodyReturns = /\breturning\b/i.test(soleBody.op.sql);
+  if (usesEntity && composite) {
+    throw new Error(
+      `write-plan: a composite (multi-write) Command uses '$.entity.*' \u2014 ambiguous which write it denotes. Address each write's row by name via '$.ref.<writeName>.<field>' (fail-closed).`
+    );
+  }
+  if (usesEntity && !soleBodyReturns) {
+    throw new Error(
+      `write-plan: a derive/edges/emits stage references '$.entity.*' but the body write ('${soleBody.label}') has no RETURNING clause \u2014 the written row cannot be exposed to later stages. Add a RETURNING to the base write (fail-closed; no absent-entity default).`
+    );
+  }
+  const entityFrom = usesEntity || !composite && soleBodyReturns ? soleBodyId : null;
+  for (const base of bases) {
+    if (base.name === void 0) continue;
+    if (referencesHead(statements, base.name) && !/\breturning\b/i.test(base.op.sql)) {
+      throw new Error(
+        `write-plan: write '${base.name}' is referenced as '$.ref.${base.name}.*' by a later statement but its op has no RETURNING clause \u2014 its row cannot be bound for downstream writes. Add a RETURNING to write '${base.name}' (fail-closed; no absent-row default).`
+      );
+    }
+  }
+  for (const s of statements) assertOperationPortable(s.op);
+  return { phase, entityFrom, statements, onIdempotentHit: "rollback" };
+}
+function refHeadsOf(stmt) {
+  const heads = /* @__PURE__ */ new Set();
+  collectRefHeads(stmt.op.params, heads);
+  if (stmt.op.where !== null) collectWhereHeads(stmt.op.where, heads);
+  return [...heads];
+}
+function isInputHead(head, stmt) {
+  return refPathLengthFor(stmt, head) === 1;
+}
+function refPathLengthFor(stmt, head) {
+  let maxLen = 0;
+  const walk = (node) => {
+    if (node === null || typeof node !== "object") return;
+    if (Array.isArray(node)) {
+      for (const el of node) walk(el);
+      return;
+    }
+    const keys = Object.keys(node);
+    if (keys.length === 1 && keys[0] === "ref") {
+      const path = node.ref;
+      if (Array.isArray(path) && path[0] === head) maxLen = Math.max(maxLen, path.length);
+      return;
+    }
+    for (const k of keys) walk(node[k]);
+  };
+  walk(stmt.op.params);
+  if (stmt.op.where !== null) {
+    const collectWhere = (node) => {
+      if (node === null || typeof node !== "object") return;
+      const n = node;
+      if ("connector" in n && Array.isArray(n.fragments)) {
+        for (const f of n.fragments) collectWhere(f);
+        return;
+      }
+      if (Array.isArray(n.params)) walk(n.params);
+    };
+    collectWhere(stmt.op.where);
+  }
+  return maxLen;
+}
+function referencesHead(statements, head) {
+  const heads = /* @__PURE__ */ new Set();
+  for (const s of statements) {
+    collectRefHeads(s.op.params, heads);
+    if (s.op.where !== null) collectWhereHeads(s.op.where, heads);
+  }
+  return heads.has(head);
+}
+function collectRefHeads(node, heads) {
+  if (node === null || typeof node !== "object") return;
+  if (Array.isArray(node)) {
+    for (const el of node) collectRefHeads(el, heads);
+    return;
+  }
+  const keys = Object.keys(node);
+  if (keys.length === 1 && keys[0] === "ref") {
+    const path = node.ref;
+    if (Array.isArray(path) && typeof path[0] === "string") heads.add(path[0]);
+    return;
+  }
+  for (const k of keys) collectRefHeads(node[k], heads);
+}
+function collectWhereHeads(node, heads) {
+  if (node === null || typeof node !== "object") return;
+  const n = node;
+  if ("connector" in n && Array.isArray(n.fragments)) {
+    for (const f of n.fragments) collectWhereHeads(f, heads);
+    return;
+  }
+  if (Array.isArray(n.params)) collectRefHeads(n.params, heads);
+}
+
+// src/scp/write-runtime.ts
+function toDriverParam(v) {
+  if (typeof v === "bigint") {
+    if (v >= BigInt(Number.MIN_SAFE_INTEGER) && v <= BigInt(Number.MAX_SAFE_INTEGER)) return Number(v);
+    return v;
+  }
+  if (v !== null && typeof v === "object" && !Array.isArray(v)) return JSON.stringify(v);
+  return v;
+}
+function execStatement(db, op, scope, dialect) {
+  const rendered = renderOperation(op, scope, dialect);
+  const params = rendered.params.map(toDriverParam);
+  const stmt = db.prepare(rendered.sql);
+  const hasReturn = op.component === "Select" || /\breturning\b/i.test(rendered.sql);
+  if (hasReturn) {
+    const rows = stmt.all(...params);
+    return { rows, changes: rows.length };
+  }
+  const info = stmt.run(...params);
+  return { rows: [], changes: info.changes };
+}
+function gateShortCircuit(gate, result) {
+  switch (gate) {
+    case "existsElseRollback":
+      return result.rows.length === 0 ? "requires_absent" : null;
+    case "insertedElseRollback":
+      return result.changes === 0 ? "unique_collision" : null;
+    case "insertedElseNoop":
+      return result.changes === 0 ? "idempotent_duplicate" : null;
+  }
+}
+function executeTransaction(db, plan, input, dialect = SQLITE) {
+  db.prepare("BEGIN").run();
+  const executed = [];
+  const scope = { ...input };
+  let entity = null;
+  try {
+    for (const stmt of plan.statements) {
+      const result = runOne(db, stmt, scope, executed, dialect);
+      if (stmt.gate !== void 0) {
+        const reason = gateShortCircuit(stmt.gate, result);
+        if (reason !== null) {
+          db.prepare("ROLLBACK").run();
+          return { committed: false, shortCircuit: { statementId: stmt.id, reason }, entity: null, executed };
+        }
+      }
+      if (stmt.id === plan.entityFrom) {
+        entity = result.rows.length > 0 ? result.rows[0] : null;
+        if (entity !== null) scope[ENTITY_ROOT] = entity;
+      }
+      if (stmt.binds !== void 0 && result.rows.length > 0) {
+        scope[stmt.binds] = result.rows[0];
+      }
+    }
+    db.prepare("COMMIT").run();
+    return { committed: true, entity, executed };
+  } catch (e) {
+    try {
+      db.prepare("ROLLBACK").run();
+    } catch {
+    }
+    throw mapSqliteError(e);
+  }
+}
+function runOne(db, stmt, scope, executed, dialect) {
+  const result = execStatement(db, stmt.op, scope, dialect);
+  executed.push(stmt.id);
+  return result;
+}
+function countingDriver(db) {
+  const prepared = [];
+  const wrapped = {
+    prepare(sql) {
+      prepared.push(sql);
+      return db.prepare(sql);
+    }
+  };
+  return { db: wrapped, prepared };
+}
+
+// src/scp/runtime.ts
+var SCOPE_PORT = "__scope";
+function toDriverParam2(v) {
+  if (typeof v === "bigint") {
+    if (v >= BigInt(Number.MIN_SAFE_INTEGER) && v <= BigInt(Number.MAX_SAFE_INTEGER)) return Number(v);
+    return v;
+  }
+  return v;
+}
+function collectHeads(node, heads) {
+  if (node === null || typeof node !== "object") return;
+  if (Array.isArray(node)) {
+    for (const el of node) collectHeads(el, heads);
+    return;
+  }
+  const keys = Object.keys(node);
+  if (keys.length === 1 && (keys[0] === "ref" || keys[0] === "refOpt")) {
+    const path = node[keys[0]];
+    if (Array.isArray(path) && typeof path[0] === "string") heads.add(path[0]);
+    return;
+  }
+  for (const k of keys) collectHeads(node[k], heads);
+}
+function collectRefOptHeads(node, heads) {
+  if (node === null || typeof node !== "object") return;
+  if (Array.isArray(node)) {
+    for (const el of node) collectRefOptHeads(el, heads);
+    return;
+  }
+  const keys = Object.keys(node);
+  if (keys.length === 1 && keys[0] === "refOpt") {
+    const path = node.refOpt;
+    if (Array.isArray(path) && typeof path[0] === "string") heads.add(path[0]);
+    return;
+  }
+  for (const k of keys) collectRefOptHeads(node[k], heads);
+}
+function collectFragmentHeads(node, heads) {
+  if ("connector" in node) {
+    for (const f of node.fragments) collectFragmentHeads(f, heads);
+    return;
+  }
+  if (node.when !== void 0) collectHeads(node.when, heads);
+  for (const p of node.params) collectHeads(p, heads);
+}
+function operationHeads(op) {
+  const heads = /* @__PURE__ */ new Set();
+  for (const p of op.params) collectHeads(p, heads);
+  if (op.where !== null) collectFragmentHeads(op.where, heads);
+  return heads;
+}
+function skipGuardedHeads(node, heads) {
+  if ("connector" in node) {
+    for (const f of node.fragments) skipGuardedHeads(f, heads);
+    return;
+  }
+  if (node.when !== void 0) {
+    collectHeads(node.when, heads);
+    for (const p of node.params) collectHeads(p, heads);
+  }
+}
+function operationRefOptHeads(op, heads) {
+  for (const p of op.params) collectRefOptHeads(p, heads);
+  if (op.where !== null) collectFragmentRefOptHeads(op.where, heads);
+}
+function collectFragmentRefOptHeads(node, heads) {
+  if ("connector" in node) {
+    for (const f of node.fragments) collectFragmentRefOptHeads(f, heads);
+    return;
+  }
+  if (node.when !== void 0) collectRefOptHeads(node.when, heads);
+  for (const p of node.params) collectRefOptHeads(p, heads);
+}
+function optionalHeadsOf(compiled) {
+  const heads = /* @__PURE__ */ new Set();
+  for (const op of Object.values(compiled)) {
+    if (op.where !== null) skipGuardedHeads(op.where, heads);
+    operationRefOptHeads(op, heads);
+  }
+  return heads;
+}
+function scopePort(op) {
+  const obj = {};
+  for (const head of operationHeads(op)) {
+    if (head === "@in") continue;
+    obj[head] = { ref: [head] };
+  }
+  return { obj };
+}
+function surrogateNode(node, compiled) {
+  if ("cond" in node) return node;
+  if ("map" in node) {
+    const op2 = compiled[node.id];
+    if (op2 === void 0) return node;
+    return { ...node, map: { ...node.map, ports: { [SCOPE_PORT]: scopePort(op2) } } };
+  }
+  const op = compiled[node.id];
+  if (op === void 0) return node;
+  return { ...node, ports: { [SCOPE_PORT]: scopePort(op) } };
+}
+function surrogateComponent(component, compiled) {
+  return { ...component, body: component.body.map((n) => surrogateNode(n, compiled)) };
+}
+function executeRendered(db, op, scope, dialect) {
+  const rendered = renderOperation(op, scope, dialect);
+  const params = rendered.params.map(toDriverParam2);
+  let stmt;
+  try {
+    stmt = db.prepare(rendered.sql);
+  } catch (e) {
+    return { error: mapSqliteError(e).message };
+  }
+  const hasReturn = op.component === "Select" || /\breturning\b/i.test(rendered.sql);
+  try {
+    if (hasReturn) {
+      const rows = stmt.all(...params);
+      return { ok: rows };
+    }
+    const info = stmt.run(...params);
+    return {
+      ok: [{ changes: info.changes, lastInsertRowid: toDriverParam2(BigInt(info.lastInsertRowid)) }]
+    };
+  } catch (e) {
+    return { error: mapSqliteError(e).message };
+  }
+}
+function buildHandlers(db, compiled, dialect) {
+  const handle = (ports, ctx) => {
+    const op = compiled[ctx.nodeId];
+    if (op === void 0) {
+      return { error: `scp runtime: no compiled operation for node '${ctx.nodeId}' (${ctx.component})` };
+    }
+    const scope = ports[SCOPE_PORT];
+    if (scope === null || typeof scope !== "object" || Array.isArray(scope)) {
+      return { error: `scp runtime: node '${ctx.nodeId}' surrogate scope did not evaluate to an object` };
+    }
+    return executeRendered(db, op, scope, dialect);
+  };
+  return { Select: handle, Insert: handle, Update: handle, Delete: handle };
+}
+function normalizeInput(component, optionalHeads, input) {
+  const out = { ...input };
+  for (const [port, schema] of Object.entries(component.inputPorts)) {
+    if (schema.required !== true && !(port in out)) out[port] = null;
+  }
+  for (const head of optionalHeads) {
+    if (!(head in out)) out[head] = null;
+  }
+  return out;
+}
+function executeBehavior(contract, input, options) {
+  return executeBundle(compileBundle(contract, options.entry, options.relations, options.dialect), input, options);
+}
+function compileBundle(contract, entry2, relations = [], dialectName = "sqlite") {
+  const dialect = dialectFor(dialectName);
+  const component = entry2 ? contract.components.find((c) => c.name === entry2) : contract.components[0];
+  if (component === void 0) {
+    throw new Error(`scp runtime: entry component '${entry2 ?? "<first>"}' not found in contract`);
+  }
+  const operations = {};
+  for (const [id, op] of compileComponentNodes(component, dialect)) operations[id] = op;
+  const surrogate = surrogateComponent(component, operations);
+  const relationOps = {};
+  for (const decl of relations) {
+    if (relationOps[decl.name] !== void 0) {
+      throw new Error(`scp runtime: duplicate relation declaration '${decl.name}'`);
+    }
+    relationOps[decl.name] = compileRelationOp(decl);
+  }
+  return {
+    irVersion: contract.ir.irVersion,
+    exprVersion: contract.ir.exprVersion,
+    dialect: dialectName,
+    component: surrogate,
+    operations,
+    optionalHeads: [...optionalHeadsOf(operations)],
+    relations: relationOps
+  };
+}
+function executeBundle(bundle, input, options) {
+  const surrogate = bundle.component;
+  const ir = {
+    irVersion: bundle.irVersion,
+    exprVersion: bundle.exprVersion,
+    components: [surrogate]
+  };
+  const handlers = buildHandlers(options.db, bundle.operations, dialectFor(bundle.dialect));
+  const optionalHeads = new Set(bundle.optionalHeads);
+  const normalized = normalizeInput(surrogate, optionalHeads, input);
+  try {
+    return runBehavior(ir, handlers, normalized, surrogate.name);
+  } catch (e) {
+    throw reErrorToSqlFailure(e);
+  }
+}
+function baseWriteNodeOf(component) {
+  const writes = component.body.filter(
+    (n) => !("cond" in n) && !("map" in n) && (n.component === "Insert" || n.component === "Update" || n.component === "Delete")
+  );
+  if (writes.length === 0) {
+    throw new Error(`scp write: Command '${component.name}' has no base write (Insert/Update/Delete) node`);
+  }
+  if (writes.length > 1) {
+    throw new Error(
+      `scp write: Command '${component.name}' has ${writes.length} base write nodes; WS5 initial scope is a SINGLE-statement Command + write-time relations (multi-write DAG is WS8, spec \xA76/\xA713).`
+    );
+  }
+  return writes[0];
+}
+function compileWriteBundle(contract, entry2, writes, phase, dialectName = "sqlite") {
+  const dialect = dialectFor(dialectName);
+  const component = contract.components.find((c) => c.name === entry2);
+  if (component === void 0) {
+    throw new Error(`scp write: entry component '${entry2}' not found in contract`);
+  }
+  const lifecycle = lifecycleFor(writes, phase);
+  if (lifecycle === void 0) {
+    throw new Error(`scp write: the '${phase}' lifecycle is not declared in the entityWrites save contract`);
+  }
+  const writeNode = baseWriteNodeOf(component);
+  const baseOp = compileNode(writeNode, dialect);
+  const base = { op: baseOp, label: `${baseOp.component} ${writeNode.component}` };
+  const plan = deriveTransactionPlan(phase, [base], lifecycle, dialect);
+  const operations = {};
+  for (const [id, op] of compileComponentNodes(component, dialect)) operations[id] = op;
+  const surrogate = surrogateComponent(component, operations);
+  return {
+    irVersion: contract.ir.irVersion,
+    exprVersion: contract.ir.exprVersion,
+    dialect: dialectName,
+    component: surrogate,
+    operations,
+    optionalHeads: [...optionalHeadsOf(operations)],
+    relations: {},
+    transaction: plan
+  };
+}
+function compileCompositeWriteBundle(contract, entries, phase, dialectName = "sqlite") {
+  if (entries.length < 2) {
+    throw new Error("scp write: a composite write bundle needs at least 2 named write members (use compileWriteBundle for a single write).");
+  }
+  const dialect = dialectFor(dialectName);
+  const bases = [];
+  const operations = {};
+  let firstComponent;
+  for (const e of entries) {
+    const component = contract.components.find((c) => c.name === e.entry);
+    if (component === void 0) throw new Error(`scp write: entry component '${e.entry}' not found in contract`);
+    if (firstComponent === void 0) firstComponent = component;
+    const writeNode = baseWriteNodeOf(component);
+    const baseOp = compileNode(writeNode, dialect);
+    bases.push({ op: baseOp, label: `${writeNode.component} ${e.name}`, name: e.name, effects: e.lifecycle.effects });
+    for (const [id, op] of compileComponentNodes(component, dialect)) operations[`${e.name}.${id}`] = op;
+  }
+  const plan = deriveTransactionPlan(phase, bases, { effects: {} }, dialect);
+  const surrogate = surrogateComponent(firstComponent, operations);
+  return {
+    irVersion: contract.ir.irVersion,
+    exprVersion: contract.ir.exprVersion,
+    dialect: dialectName,
+    component: surrogate,
+    operations,
+    optionalHeads: [...optionalHeadsOf(operations)],
+    relations: {},
+    transaction: plan
+  };
+}
+function executeCompositeCommand(contract, entries, phase, input, options) {
+  const bundle = compileCompositeWriteBundle(contract, entries, phase, options.dialect);
+  return executeTransactionBundle(bundle, input, options);
+}
+function executeCommand(contract, writes, phase, input, options) {
+  const bundle = compileWriteBundle(contract, options.entry, writes, phase, options.dialect);
+  return executeTransactionBundle(bundle, input, options);
+}
+function executeTransactionBundle(bundle, input, options) {
+  if (bundle.transaction === void 0) {
+    throw new Error("scp write: this bundle carries no transaction plan (not a write-time-relations Command bundle)");
+  }
+  return executeTransaction(options.db, bundle.transaction, input, dialectFor(bundle.dialect));
+}
+function read(contract, input, options) {
+  return readBundle(compileBundle(contract, options.entry, options.relations), input, options);
+}
+function readBundle(bundle, input, options) {
+  const out = executeBundle(bundle, input, options);
+  if (!Array.isArray(out)) {
+    throw new Error(
+      `scp read: the read behavior output is not a row list (got ${out === null ? "null" : typeof out}); the typed-object read surface expects a Select-shaped output`
+    );
+  }
+  const rawRows = out;
+  const readOpts = {
+    ...options.with !== void 0 ? { with: options.with } : {},
+    ...options.hydrate !== void 0 ? { hydrate: options.hydrate } : {}
+  };
+  return buildResultSet(rawRows, bundle.relations, options.db, readOpts);
+}
+var RELATION_BATCH_COMPONENT = "__RelationBatch";
+var RELATION_KEY_PORT = "__key";
+function resolveRelationViaPlan(op, parents, db) {
+  const elemAs = "$p";
+  const node = {
+    id: "rel",
+    map: {
+      over: { ref: ["__parents"] },
+      as: elemAs,
+      component: RELATION_BATCH_COMPONENT,
+      ports: { [RELATION_KEY_PORT]: { ref: [elemAs, op.parentKey] } },
+      into: op.name,
+      batched: true
+    }
+  };
+  const component = {
+    name: "__resolveRelation",
+    inputPorts: { __parents: { required: true } },
+    body: [node],
+    output: { ref: ["rel"] }
+  };
+  const ir = {
+    irVersion: 1,
+    exprVersion: 1,
+    components: [component]
+  };
+  const handlers = {
+    [RELATION_BATCH_COMPONENT]: (portsOrItems) => {
+      const items = portsOrItems.items;
+      if (!Array.isArray(items)) {
+        return { error: `${RELATION_BATCH_COMPONENT}: expected a batched {items:[\u2026]} invocation` };
+      }
+      const keyRows = items.map((it) => ({ [op.parentKey]: it[RELATION_KEY_PORT] }));
+      const { batch } = runRelationOp(op, keyRows, db);
+      const aligned = keyRows.map((r) => distributeToParent(op, r, batch));
+      return { ok: aligned };
+    }
+  };
+  const out = runBehavior(ir, handlers, { __parents: parents }, "__resolveRelation");
+  return out;
+}
+function reErrorToSqlFailure(e) {
+  const message = e instanceof Error ? e.message : String(e);
+  const m = /(SQLITE_[A-Z_]+)/.exec(message);
+  if (m) {
+    return mapSqliteError({ code: m[1], message });
+  }
+  return e;
+}
+
+// src/scp/codegen.ts
+var CODEGEN_LANGUAGES = ["typescript", "python", "go", "rust", "php"];
+function bundleToPortableIR(bundle) {
+  return {
+    irVersion: bundle.irVersion,
+    exprVersion: bundle.exprVersion,
+    components: [bundle.component]
+  };
+}
+function companionOf(bundle) {
+  const base = {
+    operations: bundle.operations,
+    dialect: bundle.dialect,
+    optionalHeads: bundle.optionalHeads,
+    relations: bundle.relations
+  };
+  return bundle.transaction === void 0 ? base : { ...base, transaction: bundle.transaction };
+}
+function assertLanguageSupported(language, registered) {
+  if (!CODEGEN_LANGUAGES.includes(language)) {
+    throw new Error(
+      `litedbmodel codegen: language '${language}' is not a supported target (supported: ${CODEGEN_LANGUAGES.join(", ")})`
+    );
+  }
+  if (!registered.includes(language)) {
+    throw new Error(
+      `litedbmodel codegen: bc's shared generator does not register an emitter for '${language}' (bc registered: ${[...registered].sort().join(", ")}). This is a bc#13 capability limit \u2014 ESCALATE to bc (bc#22 pattern), never fork a litedbmodel-local generator (codegen \u306F\u4E0A\u6D41\u6240\u6709, spec \xA79).`
+    );
+  }
+}
+function generateCodegenArtifact(bundle, language, registeredLanguages2, runtimeImport) {
+  assertLanguageSupported(language, registeredLanguages2);
+  const ir = bundleToPortableIR(bundle);
+  const module2 = generateModule(ir, runtimeImport === void 0 ? { language } : { language, runtimeImport });
+  return { language, module: module2, companion: companionOf(bundle), ir };
+}
+function codegenExecuteBundleForTest(artifact, input, db) {
+  const { ir } = artifact;
+  const component = ir.components[0];
+  const { operations, dialect, optionalHeads } = artifact.companion;
+  const handlers = buildHandlers(db, operations, dialectFor(dialect));
+  const normalized = normalizeInput(component, new Set(optionalHeads), input);
+  return runBehavior(ir, handlers, normalized, component.name);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CATALOG_NAMES,
+  CODEGEN_LANGUAGES,
+  ENTITY_ROOT,
+  IN_SENTINEL,
+  LITEDBMODEL_CATALOG,
+  MYSQL,
+  POSTGRES,
+  RELATION_CONTEXT,
+  RELATION_KEYS_HEAD,
+  RelationContext,
+  SQLITE,
+  SemanticBehavior,
+  SqlFailure,
+  WHERE_SLOT,
+  WRITE_CATALOG_NAMES,
+  WRITE_PORT_FAMILIES,
+  add,
+  and,
+  assertComponentGraphPortable,
+  assertComponentPortable,
+  assertComponentsInCatalog,
+  assertExprPortable,
+  assertLanguageSupported,
+  assertOperationPortable,
+  behavior,
+  buildHandlers,
+  buildResultSet,
+  bundleToPortableIR,
+  catalogEntry,
+  coalesce,
+  codegenExecuteBundleForTest,
+  compileBundle,
+  compileComponentNodes,
+  compileCompositeWriteBundle,
+  compileDelete,
+  compileEager,
+  compileInsert,
+  compileInsertFor,
+  compileNode,
+  compileRelationOp,
+  compileSelect,
+  compileUpdate,
+  compileWriteBundle,
+  components,
+  concat,
+  countingDriver,
+  deriveContractEffect,
+  deriveTransactionPlan,
+  dialectFor,
+  distributeToParent,
+  div,
+  edgeWrites,
+  entityWrites,
+  eq,
+  executeBehavior,
+  executeBundle,
+  executeCommand,
+  executeCompositeCommand,
+  executeTransaction,
+  executeTransactionBundle,
+  ge,
+  generateCodegenArtifact,
+  gt,
+  inColumn,
+  le,
+  len,
+  lifecycleFor,
+  lt,
+  mapSqliteError,
+  mod,
+  mul,
+  ne,
+  neg,
+  normalizeInput,
+  not,
+  opt,
+  or,
+  parseEffectPath,
+  publishBehaviors,
+  read,
+  readBundle,
+  readRelationContext,
+  renderOperation,
+  resolveRelationViaPlan,
+  runRelationOp,
+  sub,
+  toDollarPlaceholders,
+  when,
+  whereEq,
+  whereGe,
+  whereGt,
+  whereIn,
+  whereIsNull,
+  whereLe,
+  whereLt,
+  whereNe
+});