litedbmodel 1.2.9 → 2.0.0

package/dist/scp/index.mjs

@@ -0,0 +1,2000 @@
+// src/scp/catalog.ts
+import { classifyBehaviorEffect } from "behavior-contracts";
+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 DIALECTS = Object.freeze({
+  sqlite: SQLITE,
+  postgres: POSTGRES,
+  mysql: MYSQL
+});
+function dialectFor(name) {
+  const d = DIALECTS[name];
+  if (d === void 0) {
+    throw new Error(`scp dialect: unknown dialect '${String(name)}' (known: ${Object.keys(DIALECTS).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
+import { evaluateExpression } from "behavior-contracts";
+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 = evaluateExpression(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(evaluateExpression(slot, scope));
+    return f.sql;
+  }
+  let sql = f.sql;
+  for (let i = 0; i < f.params.length; i++) {
+    const v = evaluateExpression(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(evaluateExpression(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(evaluateExpression(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(evaluateExpression(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
+import { assertPortable, FORBIDDEN_OBJECT_KEY, PORTABLE_EXPR_OPERATORS, PortabilityError } from "behavior-contracts";
+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
+import {
+  catalogComponents,
+  compileBehaviors,
+  SemanticBehavior
+} from "behavior-contracts";
+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
+import { eq, ne, lt, le, gt, ge } from "behavior-contracts";
+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/runtime.ts
+import {
+  runBehavior
+} from "behavior-contracts";
+
+// 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, nextId) {
+  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: nextId("requires"), role: "gate:requires", op, gate: "existsElseRollback", label: `requires ${e.table}` };
+}
+function compileIdempotency(e, nextId, dialect) {
+  const op = {
+    component: "Insert",
+    sql: dialect.guardInsert(e.table, [e.column], "?"),
+    where: null,
+    params: [pathToRef(e.token)],
+    assembly: { shape: "items" }
+  };
+  return { id: nextId("idem"), role: "gate:idempotency", op, gate: "insertedElseNoop", label: `idempotency ${e.table}` };
+}
+function compileUnique(e, nextId, 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: nextId("unique"), role: "gate:unique", op, gate: "insertedElseRollback", label: `unique ${e.name}` };
+}
+function compileDerive(e, nextId) {
+  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: nextId("derive"), role: "derive", op, label: `derive ${e.table}.${e.attribute}` };
+}
+function compileEdge(e, nextId) {
+  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: nextId("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: nextId("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: nextId("edge"), role: "edge", op, label: `edge fk ${e.action} ${e.table}` };
+}
+function compileEmit(e, nextId) {
+  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: nextId("emit"), role: "emit", op, label: `emit ${e.name}` };
+}
+function compileWriteGroup(base, lifecycle, nextId, 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, nextId), true));
+  if (e.idempotency !== void 0) nodes.push(mk(compileIdempotency(e.idempotency, nextId, dialect), true));
+  for (const u of e.unique ?? []) nodes.push(mk(compileUnique(u, nextId, dialect), true));
+  const bodyId = nextId("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, nextId), false));
+  for (const ed of e.edges ?? []) nodes.push(mk(compileEdge(ed, nextId), false));
+  for (const em of e.emits ?? []) nodes.push(mk(compileEmit(em, nextId), 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 nextId = 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, nextId, 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
+import { generateModule } from "behavior-contracts";
+import { runBehavior as runBehavior2 } from "behavior-contracts";
+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, registeredLanguages, runtimeImport) {
+  assertLanguageSupported(language, registeredLanguages);
+  const ir = bundleToPortableIR(bundle);
+  const module = generateModule(ir, runtimeImport === void 0 ? { language } : { language, runtimeImport });
+  return { language, module, 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 runBehavior2(ir, handlers, normalized, component.name);
+}
+
+// src/scp/index.ts
+import {
+  SemanticBehavior as SemanticBehavior2,
+  behavior,
+  when,
+  concat,
+  add,
+  sub,
+  mul,
+  div,
+  mod,
+  neg,
+  eq as eq2,
+  ne as ne2,
+  lt as lt2,
+  le as le2,
+  gt as gt2,
+  ge as ge2,
+  and,
+  or,
+  not,
+  coalesce,
+  len,
+  opt
+} from "behavior-contracts";
+export {
+  CATALOG_NAMES,
+  CODEGEN_LANGUAGES,
+  ENTITY_ROOT,
+  IN_SENTINEL,
+  LITEDBMODEL_CATALOG,
+  MYSQL,
+  POSTGRES,
+  RELATION_CONTEXT,
+  RELATION_KEYS_HEAD,
+  RelationContext,
+  SQLITE,
+  SemanticBehavior2 as 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,
+  eq2 as eq,
+  executeBehavior,
+  executeBundle,
+  executeCommand,
+  executeCompositeCommand,
+  executeTransaction,
+  executeTransactionBundle,
+  ge2 as ge,
+  generateCodegenArtifact,
+  gt2 as gt,
+  inColumn,
+  le2 as le,
+  len,
+  lifecycleFor,
+  lt2 as lt,
+  mapSqliteError,
+  mod,
+  mul,
+  ne2 as 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
+};