litedbmodel 2.0.2 → 2.1.0

package/dist/scp/index.mjs

@@ -238,6 +238,9 @@ var DBCastArray = class extends DBToken {
 function dbCast(value, sqlType, operator = "=") {
   return new DBCast(value, sqlType, operator);
 }
+function dbCastIn(values, sqlType) {
+  return new DBCastArray(values, sqlType);
+}
 function dbTupleIn(columns, tuples) {
   return new DBTupleIn(columns, tuples);
 }
@@ -1641,7 +1644,7 @@ function sqliteInsertJson(opts) {
   } else if (onConflict && onConflictUpdate) {
     const updateCols = onConflictUpdate === "all" ? columns : onConflictUpdate;
     const updateClauses = updateCols.map((c) => `${c} = excluded.${c}`);
-    sql2 = `INSERT INTO ${tableName} (${columns.join(", ")}) ${source} ON CONFLICT (${onConflict.join(", ")}) DO UPDATE SET ${updateClauses.join(", ")}`;
+    sql2 = `INSERT INTO ${tableName} (${columns.join(", ")}) ${source} WHERE true ON CONFLICT (${onConflict.join(", ")}) DO UPDATE SET ${updateClauses.join(", ")}`;
   } else {
     sql2 = `INSERT INTO ${tableName} (${columns.join(", ")}) ${source}`;
   }
@@ -2089,38 +2092,6 @@ function compileCompositeKeyStaticLimited(opts) {
   });
 }
 
-// src/scp/makesql/ir.ts
-function makeSqlComponentIR(entry2 = "Query") {
-  const component = {
-    name: entry2,
-    inputPorts: {
-      __sql: { type: "string", required: true },
-      __sqlParams: { type: "arr" },
-      __skip: { type: "bool" }
-    },
-    body: [
-      {
-        id: "q",
-        component: MAKESQL,
-        ports: {
-          sql: { ref: ["__sql"] },
-          params: { ref: ["__sqlParams"] },
-          skip: { ref: ["__skip"] }
-        }
-      }
-    ],
-    output: { ref: ["q"] }
-  };
-  return { irVersion: 1, exprVersion: 2, components: [component] };
-}
-function makeSqlInput(node) {
-  return {
-    __sql: node.sql,
-    __sqlParams: node.params,
-    __skip: node.skip === true
-  };
-}
-
 // src/scp/makesql/tx.ts
 import { evaluateExpression } from "behavior-contracts";
 
@@ -2802,6 +2773,9 @@ import { evaluateExpression as evaluateExpression2 } from "behavior-contracts";
 function isMap(n) {
   return "map" in n;
 }
+function isFanout(n) {
+  return "fanout" in n;
+}
 function nodeRef(n) {
   return isMap(n) ? { component: n.map.component, ports: n.map.ports } : { component: n.component, ports: n.ports };
 }
@@ -3040,6 +3014,9 @@ function compileAuthoredBehavior(contract, scope, dialect, entry2) {
   let primaryNode;
   for (const n of component.body) {
     if ("cond" in n) continue;
+    if (isFanout(n)) {
+      throw new Error(`authoring-compile: behavior '${component.name}' node '${n.id}' is a fanout node, not supported by litedbmodel (bc FanoutNode)`);
+    }
     if (isMap(n)) {
       relations.push(n);
       continue;
@@ -3070,6 +3047,7 @@ function normalizeInput(component, input) {
 }
 function skipGuardHeads(n, into) {
   if ("cond" in n) return;
+  if (isFanout(n)) return;
   const ports = isMap(n) ? n.map.ports : n.ports;
   const where = ports.where;
   if (typeof where !== "object" || where === null || !("arr" in where)) return;
@@ -3099,9 +3077,7 @@ function collectRefHeads2(node, into) {
 
 // src/scp/makesql/static-bundle.ts
 import {
-  evaluateExpression as evaluateExpression3,
-  runBehavior,
-  runBehaviorAsync
+  evaluateExpression as evaluateExpression3
 } from "behavior-contracts";
 
 // src/scp/find-filter-guard.ts
@@ -3187,6 +3163,142 @@ function sqlTypeToBcScalar(sqlType) {
       );
   }
 }
+function sqlTypeToMaterializeClass(sqlType) {
+  const t = sqlType.trim().toUpperCase().replace(/\(.*\)/, "").replace(/\b(UNSIGNED|ZEROFILL|PRECISION)\b/g, "").replace(/\s+/g, " ").trim();
+  switch (t) {
+    // 32-bit int family: JS number holds the full range exactly.
+    case "INTEGER":
+    case "INT":
+    case "SMALLINT":
+    case "TINYINT":
+    case "MEDIUMINT":
+    case "INT2":
+    case "INT4":
+      return "int32";
+    // 64-bit int: needs JS bigint for exactness.
+    case "BIGINT":
+    case "INT8":
+      return "int64";
+    case "BOOLEAN":
+    case "BOOL":
+      return "bool";
+    case "DATE":
+    case "TIMESTAMP":
+    case "TIMESTAMPTZ":
+    case "DATETIME":
+    case "TIME":
+      return "date";
+    // float / decimal(→string) / text / json / uuid — driver value already matches the outType.
+    case "REAL":
+    case "FLOAT":
+    case "DOUBLE":
+    case "FLOAT4":
+    case "FLOAT8":
+    case "DECIMAL":
+    case "NUMERIC":
+    case "MONEY":
+    case "TEXT":
+    case "VARCHAR":
+    case "CHAR":
+    case "CHARACTER":
+    case "CHARACTER VARYING":
+    case "CLOB":
+    case "UUID":
+    case "JSON":
+    case "JSONB":
+      return "passthrough";
+    default:
+      throw new Error(
+        `litedbmodel type system (spec \xA74.1): no materialization class for SQL type '${sqlType}' (normalized '${t}'). Add it to the \xA74.1 table or fix the column \u2014 ambiguous/unknown types are a hard error (no-assume, no-fallback), never defaulted.`
+      );
+  }
+}
+function materializeCell(value, klass) {
+  if (value === null || value === void 0) return value;
+  switch (klass) {
+    case "int64": {
+      if (typeof value === "bigint") return value.toString();
+      if (typeof value === "string") {
+        if (!/^-?\d+$/.test(value)) throw new Error(`materialize int64: driver returned a non-integer string '${value}'`);
+        return value;
+      }
+      if (typeof value === "number") {
+        if (!Number.isInteger(value)) throw new Error(`materialize int64: driver returned a non-integer number ${value} for a 64-bit int column`);
+        if (!Number.isSafeInteger(value)) {
+          throw new Error(
+            `materialize int64: driver returned an UNSAFE JS number ${value} for a 64-bit int column \u2014 precision was already lost before materialization (the driver must return int8 as string/bigint, not a rounded double). Configure the driver (better-sqlite3 safeIntegers / mysql2 supportBigNumbers+bigNumberStrings / pg int8-as-string).`
+          );
+        }
+        return value.toString();
+      }
+      throw new Error(`materialize int64: unexpected driver JS type ${typeof value}`);
+    }
+    case "int32": {
+      if (typeof value === "number") return value;
+      if (typeof value === "bigint") return Number(value);
+      if (typeof value === "string" && /^-?\d+$/.test(value)) return Number(value);
+      throw new Error(`materialize int32: unexpected driver JS type ${typeof value} (${String(value)})`);
+    }
+    case "date": {
+      if (typeof value === "string") return value;
+      if (value instanceof Date) return dateToTzString(value);
+      throw new Error(`materialize date: unexpected driver JS type ${typeof value}`);
+    }
+    case "bool": {
+      if (typeof value === "boolean") return value;
+      if (typeof value === "number") return value !== 0;
+      if (typeof value === "bigint") return value !== 0n;
+      if (typeof value === "string") {
+        const s = value.trim().toLowerCase();
+        if (s === "t" || s === "true" || s === "1") return true;
+        if (s === "f" || s === "false" || s === "0") return false;
+      }
+      throw new Error(`materialize bool: unexpected driver JS type ${typeof value} (${String(value)})`);
+    }
+    case "passthrough":
+      return value;
+  }
+}
+function dateToTzString(d) {
+  return d.toISOString();
+}
+function materializeResolverFromColumnMap(columnTypes) {
+  return (table, column) => {
+    const sqlType = columnTypes.get(table)?.get(column);
+    return sqlType === void 0 ? void 0 : materializeClassOrUndefined(sqlType);
+  };
+}
+function failClosedMaterializeResolverFromColumnMap(columnTypes) {
+  const resolveSqlType = columnTypeResolverFromColumnMap(columnTypes);
+  return (table, column) => {
+    const sqlType = resolveSqlType(table, column);
+    return sqlTypeToMaterializeClass(sqlType);
+  };
+}
+function columnTypeResolverFromColumnMap(columnTypes) {
+  return (table, column) => {
+    const cols = columnTypes.get(table);
+    if (cols === void 0) {
+      throw new Error(
+        `litedbmodel type system (spec \xA74.1): table '${table}' has no inline column-type declaration (the model's \`columns\` map). Declare it (\`static columns = { ${table}: { \u2026 } }\`) so its SELECT projection can be typed. Known tables: ${[...columnTypes.keys()].join(", ") || "<none>"}. No-assume, no-fallback.`
+      );
+    }
+    const sqlType = cols.get(column);
+    if (sqlType === void 0) {
+      throw new Error(
+        `litedbmodel type system (spec \xA74.1): column '${column}' not declared on table '${table}' (declared: ${[...cols.keys()].join(", ")}). Add it to the model's inline \`columns\`. No-assume, no-fallback.`
+      );
+    }
+    return sqlType;
+  };
+}
+function materializeClassOrUndefined(sqlType) {
+  try {
+    return sqlTypeToMaterializeClass(sqlType);
+  } catch {
+    return void 0;
+  }
+}
 function parseSchemaColumnTypes(ddl) {
   const tables = /* @__PURE__ */ new Map();
   const CREATE = /^\s*CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?([A-Za-z0-9_."`[\]]+)\s*\(([\s\S]*)\)\s*;?\s*$/i;
@@ -3293,7 +3405,29 @@ function stringArrayPort2(ports, name) {
   }
   throw new Error(`outtype: port '${name}' must be an {arr:[\u2026]} literal in the IR (got ${JSON.stringify(v)})`);
 }
-function rowObjType(table, projection, resolveColumnType, at) {
+function parseProjectionColumn(col, table, at) {
+  const raw = col.trim();
+  if (raw === "*" || raw.endsWith(".*")) {
+    throw new Error(
+      `outtype: ${at}: SELECT on '${table}' projects '${raw}' (a wildcard). A typed de-box needs the concrete column list to build the row struct + type each column \u2014 spec \xA74.1 is column-typed. Project explicit columns (no-assume, no-fallback).`
+    );
+  }
+  let expr = raw;
+  let alias;
+  const asMatch = /^(.*?)\s+AS\s+([A-Za-z_][A-Za-z0-9_]*)$/i.exec(raw);
+  if (asMatch !== null) {
+    expr = asMatch[1].trim();
+    alias = asMatch[2];
+  }
+  const refMatch = /^(?:([A-Za-z_][A-Za-z0-9_]*)\.)?([A-Za-z_][A-Za-z0-9_]*)$/.exec(expr);
+  if (refMatch !== null) {
+    const qualifier = refMatch[1];
+    const underlying = refMatch[2];
+    return { kind: "column", underlying, outputKey: alias ?? underlying, ...qualifier !== void 0 ? { qualifier } : {} };
+  }
+  return { kind: "computed", text: raw };
+}
+function rowObjType(table, projection, resolveColumnType, at, materializers) {
   if (projection === void 0 || projection.length === 0) {
     throw new Error(
       `outtype: ${at}: SELECT on '${table}' has no explicit column projection ('*' / empty). A typed de-box needs the concrete column list to build the row struct \u2014 spec \xA74.1 is column-typed. Project explicit columns (no-assume, no-fallback).`
@@ -3301,30 +3435,37 @@ function rowObjType(table, projection, resolveColumnType, at) {
   }
   const obj = {};
   for (const col of projection) {
-    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(col)) {
+    const entry2 = parseProjectionColumn(col, table, at);
+    if (entry2.kind === "computed") {
       throw new Error(
-        `outtype: ${at}: projected column '${col}' on '${table}' is not a bare column name (alias / qualified / computed). Typed de-box (spec \xA74.1) requires bare schema columns so each maps to a SQL type. No-assume, no-fallback.`
+        `outtype: ${at}: projected expression '${entry2.text}' on '${table}' is computed (function / aggregate / cast / literal) and cannot be typed into a concrete row struct field. Typed de-box (spec \xA74.1) requires bare/qualified/aliased schema columns. No-assume, no-fallback.`
       );
     }
-    if (col in obj) throw new Error(`outtype: ${at}: duplicate projected column '${col}' on '${table}'`);
-    obj[col] = toPortableScalar(sqlTypeToBcScalar(resolveColumnType(table, col)), table, col);
+    const { underlying, outputKey, qualifier } = entry2;
+    if (outputKey in obj) throw new Error(`outtype: ${at}: duplicate projected column key '${outputKey}' on '${table}'`);
+    const owner = qualifier ?? table;
+    const sqlType = resolveColumnType(owner, underlying);
+    obj[outputKey] = toPortableScalar(sqlTypeToBcScalar(sqlType), owner, underlying);
+    const klass = sqlTypeToMaterializeClass(sqlType);
+    if (klass !== "passthrough") materializers[outputKey] = klass;
   }
   return { obj };
 }
-function nodeOutType(node, resolveColumnType) {
+function nodeTypes(node, resolveColumnType) {
   const { component, ports } = nodeRef2(node);
   const at = `node '${node.id}'`;
-  if (component === "Count") return "int";
+  if (component === "Count") return { outType: "int", materializers: {} };
   if (component === "Select") {
     const table = stringPort3(ports, "table");
     if (table === void 0) throw new Error(`outtype: ${at}: Select node requires a literal 'table' port`);
     const projection = stringArrayPort2(ports, "select");
-    const row = rowObjType(table, projection, resolveColumnType, at);
-    if (isMap2(node)) return { arr: { arr: row } };
-    return { arr: row };
+    const materializers = {};
+    const row = rowObjType(table, projection, resolveColumnType, at, materializers);
+    const outType = isMap2(node) ? { arr: { arr: row } } : { arr: row };
+    return { outType, materializers };
   }
   throw new Error(
-    `outtype: ${at}: component '${component}' has no typed outType (typed read codegen covers Select/Count only). A write / unknown node cannot be de-boxed here \u2014 no-assume, no-fallback.`
+    `outtype: ${at}: component '${component}' has no typed outType (typed read de-box covers Select/Count only). A write / unknown node cannot be de-boxed here \u2014 no-assume, no-fallback.`
   );
 }
 function outputType(output, byNode, at) {
@@ -3366,13 +3507,51 @@ function outputType(output, byNode, at) {
     `outtype: ${at}: output expression ${JSON.stringify(output)} is not a typed composition (ref / obj / arr / opt of node results). The typed de-box path does not build a dynamic Value output tree \u2014 no-assume, no-fallback.`
   );
 }
+function crudNodeAsType(component, ports, resolveColumnType, at) {
+  const table = ports["table"];
+  if (typeof table !== "string") {
+    throw new Error(`outtype: ${at}: ${component} node requires a literal 'table' string port to type its output (got ${JSON.stringify(table)})`);
+  }
+  if (component === "Select") {
+    const select = ports["select"];
+    if (!Array.isArray(select) || select.length === 0) {
+      throw new Error(
+        `outtype: ${at}: Select has no explicit column projection ('*' / empty). A typed de-box needs the concrete column list to build the row struct \u2014 spec \xA74.1 is column-typed. Project explicit columns.`
+      );
+    }
+    const obj = {};
+    for (const raw of select) {
+      if (typeof raw !== "string") throw new Error(`outtype: ${at}: Select 'select' entries must be literal strings (got ${JSON.stringify(raw)})`);
+      const parsed = parseProjectionColumn(raw, table, at);
+      if (parsed.kind === "computed") continue;
+      const { underlying, outputKey, qualifier } = parsed;
+      if (outputKey in obj) throw new Error(`outtype: ${at}: duplicate projected column key '${outputKey}' on '${table}'`);
+      obj[outputKey] = toPortableScalar(sqlTypeToBcScalar(resolveColumnType(qualifier ?? table, underlying)), qualifier ?? table, underlying);
+    }
+    return { arr: { obj } };
+  }
+  if (component === "Insert" || component === "Update" || component === "Delete") {
+    const returning = ports["returning"];
+    if (returning === void 0) return { arr: { obj: {} } };
+    if (typeof returning !== "string") {
+      throw new Error(`outtype: ${at}: ${component} 'returning' port must be a literal string (got ${JSON.stringify(returning)})`);
+    }
+    const cols = returning.split(",").map((c) => c.trim()).filter((c) => c.length > 0);
+    if (cols.length === 0) return { arr: { obj: {} } };
+    return { arr: rowObjType(table, cols, resolveColumnType, at, {}) };
+  }
+  throw new Error(`outtype: ${at}: no pre-compile output type for component '${component}' (typed CRUD covers Select/Insert/Update/Delete; Count is static via catalog elemType).`);
+}
 function deriveReadOutTypes(component, resolveColumnType) {
   const byNode = /* @__PURE__ */ new Map();
+  const materializersByNode = /* @__PURE__ */ new Map();
   for (const n of component.body) {
     if ("cond" in n) continue;
-    byNode.set(n.id, nodeOutType(n, resolveColumnType));
+    const t = nodeTypes(n, resolveColumnType);
+    byNode.set(n.id, t.outType);
+    if (Object.keys(t.materializers).length > 0) materializersByNode.set(n.id, t.materializers);
   }
-  return { byNode, outputType: outputType(component.output, byNode, `component '${component.name}' output`) };
+  return { byNode, outputType: outputType(component.output, byNode, `component '${component.name}' output`), materializersByNode };
 }
 
 // src/scp/authoring-sql.ts
@@ -3449,6 +3628,9 @@ function whereExists($, sub2, not2 = false) {
 function isMap3(n) {
   return "map" in n;
 }
+function isFanout2(n) {
+  return "fanout" in n;
+}
 function nodeRef3(n) {
   return isMap3(n) ? { component: n.map.component, ports: n.map.ports } : { component: n.component, ports: n.ports };
 }
@@ -3755,6 +3937,9 @@ function compileStaticBundle(contract, dialect, entry2) {
   let primary;
   for (const n of component.body) {
     if ("cond" in n) continue;
+    if (isFanout2(n)) {
+      throw new Error(`static-bundle: behavior '${component.name}' node '${n.id}' is a fanout node, not supported by litedbmodel (bc FanoutNode)`);
+    }
     if (isMap3(n)) continue;
     if (primary === void 0) primary = n;
   }
@@ -3795,6 +3980,7 @@ function collectRefOptHeads(node, into) {
 }
 function skipGuardHeads2(n, into) {
   if ("cond" in n) return;
+  if (isFanout2(n)) return;
   const ports = isMap3(n) ? n.map.ports : n.ports;
   const where = ports.where;
   if (typeof where !== "object" || where === null || !("arr" in where)) return;
@@ -3929,38 +4115,6 @@ function executeStaticWrite(bundle, input, db) {
     throw mapSqliteError(e);
   }
 }
-var SCOPE_PORT = "__scope";
-var NODE_COMPONENT = "__makeSqlNode";
-function collectAllHeads(node, heads) {
-  if (node === null || typeof node !== "object") return;
-  if (Array.isArray(node)) {
-    for (const el of node) collectAllHeads(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) collectAllHeads(node[k], heads);
-}
-function statementHeads(statements) {
-  const heads = /* @__PURE__ */ new Set();
-  for (const stmt of statements) {
-    for (const p of stmt.params) collectAllHeads(p, heads);
-    if (stmt.skip !== void 0) collectAllHeads(stmt.skip, heads);
-  }
-  return heads;
-}
-function scopePort(statements) {
-  const obj = {};
-  for (const head of statementHeads(statements)) {
-    if (head === IN_SENTINEL) continue;
-    obj[head] = { ref: [head] };
-  }
-  return { obj };
-}
 function compileNodeStatements(node, dialect) {
   const component = "map" in node ? node.map.component : node.component;
   if (component === "Select" || component === "Count") return compileSelectNode(node, dialect);
@@ -3973,6 +4127,9 @@ function compileReadGraph(contract, dialect, entry2, findFilterModel, resolveCol
   if (findFilterModel !== void 0) {
     for (const n of component.body) {
       if ("cond" in n) continue;
+      if (isFanout2(n)) {
+        throw new Error(`static-bundle: read component '${component.name}' node '${n.id}' is a fanout node, not supported by litedbmodel (bc FanoutNode)`);
+      }
       const ref = "map" in n ? n.map : n;
       if (ref.component !== "Select" && ref.component !== "Count") continue;
       assertFindFilterFolded(findFilterModel, authoredWhereKeysOf(ref.ports));
@@ -3981,79 +4138,184 @@ function compileReadGraph(contract, dialect, entry2, findFilterModel, resolveCol
   const statementsById = {};
   for (const n of component.body) {
     if ("cond" in n) continue;
+    if (isFanout2(n)) {
+      throw new Error(`static-bundle: read component '${component.name}' node '${n.id}' is a fanout node, not supported by litedbmodel (bc FanoutNode)`);
+    }
     statementsById[n.id] = compileNodeStatements(n, dialect);
   }
-  const outTypes = resolveColumnType !== void 0 ? deriveReadOutTypes(component, resolveColumnType) : void 0;
-  const surrogateBody = component.body.map((n) => {
+  const readTypes = resolveColumnType !== void 0 ? deriveReadOutTypes(component, resolveColumnType) : void 0;
+  const materializers = readTypes?.materializersByNode;
+  const annotatedBody = component.body.map((n) => {
     if ("cond" in n) return n;
-    const stmts = statementsById[n.id];
-    const outType = outTypes?.byNode.get(n.id);
-    const outAnn = outType !== void 0 ? { outType } : {};
-    if ("map" in n) {
-      return { ...n, ...outAnn, map: { ...n.map, component: NODE_COMPONENT, ports: { [SCOPE_PORT]: scopePort(stmts) } } };
-    }
-    return { ...n, ...outAnn, component: NODE_COMPONENT, ports: { [SCOPE_PORT]: scopePort(stmts) } };
+    const outType = readTypes?.byNode.get(n.id);
+    return outType !== void 0 ? { ...n, outType } : n;
   });
-  const surrogate = {
+  const irComponent = {
     ...component,
-    body: surrogateBody,
-    ...outTypes !== void 0 ? { outputType: outTypes.outputType } : {}
+    body: annotatedBody,
+    ...readTypes !== void 0 ? { outputType: readTypes.outputType } : {}
   };
-  const ir = { irVersion: 1, exprVersion: 2, components: [surrogate] };
+  const ir = { ...contract.ir, components: [irComponent] };
   return {
     dialect,
     name: component.name,
     ir,
     statementsById,
-    optionalHeads: [...optionalHeadsOfComponent(component, dialect)]
+    optionalHeads: [...optionalHeadsOfComponent(component, dialect)],
+    ...materializers !== void 0 && materializers.size > 0 ? { materializersByNode: Object.fromEntries(materializers) } : {}
   };
 }
-function executeReadGraph(graph, input, db) {
-  const handle = (ports, ctx) => {
-    const stmts = graph.statementsById[ctx.nodeId];
-    if (stmts === void 0) return { error: `static-bundle: no statements for node '${ctx.nodeId}'` };
-    const scope = ports[SCOPE_PORT];
-    if (scope === null || typeof scope !== "object" || Array.isArray(scope)) {
-      return { error: `static-bundle: node '${ctx.nodeId}' surrogate scope did not evaluate to an object` };
-    }
-    const { sql: sql2, params } = renderStatements(stmts, graph.dialect, scope);
-    try {
-      const rows = db.prepare(sql2).all(...params);
-      return { ok: rows };
-    } catch (e) {
-      return { error: mapSqliteError(e).message };
+function materializeRows(rows, cols, safeIntegersOn = false) {
+  if (cols === void 0 && !safeIntegersOn) return rows;
+  for (const row of rows) {
+    for (const key of Object.keys(row)) {
+      const klass = cols?.[key];
+      if (klass !== void 0) {
+        row[key] = materializeCell(row[key], klass);
+        continue;
+      }
+      if (safeIntegersOn && typeof row[key] === "bigint") {
+        const v = row[key];
+        row[key] = v >= BigInt(Number.MIN_SAFE_INTEGER) && v <= BigInt(Number.MAX_SAFE_INTEGER) ? Number(v) : v.toString();
+      }
     }
-  };
-  const handlers = { [NODE_COMPONENT]: handle };
-  const normalized = { ...input };
-  for (const head of graph.optionalHeads) if (!(head in normalized)) normalized[head] = null;
+  }
+  return rows;
+}
+function hasInt64(cols) {
+  for (const k of Object.keys(cols)) if (cols[k] === "int64") return true;
+  return false;
+}
+function planStages(component) {
+  const plan = component.plan;
+  const groups = plan?.groups;
+  if (Array.isArray(groups)) {
+    return groups.map((st) => Array.isArray(st) ? st.filter((i) => typeof i === "number") : []);
+  }
+  return component.body.map((_n, i) => [i]);
+}
+function planConcurrency(component) {
+  const plan = component.plan;
+  const c = plan?.concurrency;
+  return typeof c === "number" && c >= 1 ? c : 1;
+}
+async function boundedMap(items, limit, fn) {
+  const out = new Array(items.length);
+  const cap = Math.max(1, Math.floor(limit));
+  let next = 0;
+  async function worker() {
+    for (; ; ) {
+      const i = next++;
+      if (i >= items.length) return;
+      out[i] = await fn(items[i], i);
+    }
+  }
+  await Promise.all(Array.from({ length: Math.min(cap, items.length) }, () => worker()));
+  return out;
+}
+function execReadNodeSync(graph, nodeId, scope, db) {
+  const stmts = graph.statementsById[nodeId];
+  if (stmts === void 0) throw new Error(`static-bundle: no statements for node '${nodeId}'`);
+  const { sql: sql2, params } = renderStatements(stmts, graph.dialect, scope);
+  const cols = graph.materializersByNode?.[nodeId];
+  try {
+    const stmt = db.prepare(sql2);
+    let safeIntegersOn = false;
+    if (cols !== void 0 && hasInt64(cols) && typeof stmt.safeIntegers === "function") {
+      stmt.safeIntegers(true);
+      safeIntegersOn = true;
+    }
+    const rows = stmt.all(...params);
+    return materializeRows(rows, cols, safeIntegersOn);
+  } catch (e) {
+    throw mapSqliteError(e);
+  }
+}
+function computeReadNodeSync(graph, node, base, db) {
+  if (node.cond !== void 0) return evaluateExpression3(node.cond, base);
+  if (node.map !== void 0) {
+    const over = evaluateExpression3(node.map.over, base);
+    if (!Array.isArray(over)) throw new Error(`static-bundle: map '${node.id}': 'over' is not an array`);
+    const asName = node.map.as ?? "$";
+    const out = [];
+    for (const el of over) {
+      out.push(execReadNodeSync(graph, node.id, { ...base, [asName]: el }, db));
+    }
+    return out;
+  }
+  return execReadNodeSync(graph, node.id, base, db);
+}
+function normalizeReadInput(graph, input) {
+  const out = { ...input };
+  for (const head of graph.optionalHeads) if (!(head in out)) out[head] = null;
+  return out;
+}
+function executeReadGraph(graph, input, db) {
+  const component = graph.ir.components[0];
+  const body = component.body;
+  const output = component.output ?? null;
+  const normalized = normalizeReadInput(graph, input);
   try {
-    return runBehavior(graph.ir, handlers, normalized, graph.name);
+    const results = [];
+    for (const stage of planStages(component)) {
+      const ordered = [...stage].sort((a, b) => a - b);
+      const base = { ...normalized };
+      for (const [id, v] of results) base[id] = v;
+      for (const idx of ordered) {
+        const node = body[idx];
+        base[node.id] = results[results.push([node.id, computeReadNodeSync(graph, node, base, db)]) - 1][1];
+      }
+    }
+    const scope = { ...normalized };
+    for (const [id, v] of results) scope[id] = v;
+    return evaluateExpression3(output, scope);
   } catch (e) {
     throw reErrorToSqlFailure(e);
   }
 }
+async function execReadNodeAsync(graph, nodeId, scope, exec) {
+  const stmts = graph.statementsById[nodeId];
+  if (stmts === void 0) throw new Error(`static-bundle: no statements for node '${nodeId}'`);
+  const { sql: sql2, params } = renderStatements(stmts, graph.dialect, scope);
+  try {
+    const rows = await exec(sql2, params);
+    return materializeRows(rows, graph.materializersByNode?.[nodeId]);
+  } catch (e) {
+    throw mapSqliteError(e);
+  }
+}
+async function computeReadNodeAsync(graph, node, base, exec, concurrency) {
+  if (node.cond !== void 0) return evaluateExpression3(node.cond, base);
+  if (node.map !== void 0) {
+    const over = evaluateExpression3(node.map.over, base);
+    if (!Array.isArray(over)) throw new Error(`static-bundle: map '${node.id}': 'over' is not an array`);
+    const asName = node.map.as ?? "$";
+    return await boundedMap(
+      over,
+      concurrency,
+      (el) => execReadNodeAsync(graph, node.id, { ...base, [asName]: el }, exec)
+    );
+  }
+  return execReadNodeAsync(graph, node.id, base, exec);
+}
 async function executeReadGraphAsync(graph, input, exec) {
-  const handle = async (ports, ctx) => {
-    const stmts = graph.statementsById[ctx.nodeId];
-    if (stmts === void 0) return { error: `static-bundle: no statements for node '${ctx.nodeId}'` };
-    const scope = ports[SCOPE_PORT];
-    if (scope === null || typeof scope !== "object" || Array.isArray(scope)) {
-      return { error: `static-bundle: node '${ctx.nodeId}' surrogate scope did not evaluate to an object` };
-    }
-    const { sql: sql2, params } = renderStatements(stmts, graph.dialect, scope);
-    try {
-      const rows = await exec(sql2, params);
-      return { ok: rows };
-    } catch (e) {
-      return { error: mapSqliteError(e).message };
-    }
-  };
-  const handlers = { [NODE_COMPONENT]: handle };
-  const normalized = { ...input };
-  for (const head of graph.optionalHeads) if (!(head in normalized)) normalized[head] = null;
+  const component = graph.ir.components[0];
+  const body = component.body;
+  const output = component.output ?? null;
+  const concurrency = planConcurrency(component);
+  const normalized = normalizeReadInput(graph, input);
   try {
-    return await runBehaviorAsync(graph.ir, handlers, normalized, graph.name);
+    const results = [];
+    for (const stage of planStages(component)) {
+      const ordered = [...stage].sort((a, b) => a - b);
+      const base = { ...normalized };
+      for (const [id, v] of results) base[id] = v;
+      const vals = await boundedMap(ordered, concurrency, (idx) => computeReadNodeAsync(graph, body[idx], base, exec, concurrency));
+      ordered.forEach((idx, i) => results.push([body[idx].id, vals[i]]));
+    }
+    const scope = { ...normalized };
+    for (const [id, v] of results) scope[id] = v;
+    return evaluateExpression3(output, scope);
   } catch (e) {
     throw reErrorToSqlFailure(e);
   }
@@ -4078,6 +4340,7 @@ function optionalHeadsOfComponent(component, dialect) {
   for (const n of component.body) skipGuardHeads2(n, optional);
   for (const n of component.body) {
     if ("cond" in n) continue;
+    if (isFanout2(n)) continue;
     const stmts = compileNodeStatements(n, dialect);
     for (const stmt of stmts) {
       for (const p of stmt.params) collectRefOptHeads(p, optional);
@@ -4094,12 +4357,35 @@ function reErrorToSqlFailure(e) {
 }
 
 // src/scp/makesql/pool-executor.ts
+var PG_OID = { INT8: 20, DATE: 1082, TIMESTAMP: 1114, TIMESTAMPTZ: 1184, TIME: 1083, TIMETZ: 1266 };
+function configurePgDeboxTypeParsers(types) {
+  const asString = (v) => v;
+  types.setTypeParser(PG_OID.DATE, asString);
+  types.setTypeParser(PG_OID.TIMESTAMP, asString);
+  types.setTypeParser(PG_OID.TIMESTAMPTZ, asString);
+  types.setTypeParser(PG_OID.TIME, asString);
+  types.setTypeParser(PG_OID.TIMETZ, asString);
+}
+var mysqlDeboxPoolOptions = {
+  supportBigNumbers: true,
+  bigNumberStrings: true,
+  dateStrings: true
+};
 function pgPoolExecutor(pool) {
   return async (sql2, params) => {
     const result = await pool.query(sql2, params);
     return result.rows;
   };
 }
+function pgDeboxExecutor(pg, config) {
+  configurePgDeboxTypeParsers(pg.types);
+  const pool = new pg.Pool(config);
+  return { pool, exec: pgPoolExecutor(pool) };
+}
+function mysqlDeboxExecutor(mysql2, config) {
+  const pool = mysql2.createPool({ ...config, ...mysqlDeboxPoolOptions });
+  return { pool, exec: mysqlPoolExecutor(pool) };
+}
 function mysqlPoolExecutor(pool) {
   return async (sql2, params) => {
     const [rows] = await pool.query(sql2, params);
@@ -4165,7 +4451,10 @@ var LITEDBMODEL_CATALOG = {
   // Only `table` (required) + the optional `where` fragment tree — v1's count carries no
   // projection/order/limit/offset (it counts the filtered rows). Output is a one-row `[{count}]`
   // list (the `items` shape, like every read); the consumer reads `count` — v1's `parseInt(count)`.
-  Count: entry("Count", { table: P("string", true), where: P("fragment") }, "items", true),
+  // bc 0.8.0 (SA5): Count's output element type is STATICALLY determined (`int` — the counted rows),
+  // so it declares a catalog `elemType` and needs no per-call `.as` (unlike Select, whose row shape is
+  // per-projection). `baseOutTypeFromEntry` bakes node.outType = {arr:'int'} (items shape) at record.
+  Count: { ...entry("Count", { table: P("string", true), where: P("fragment") }, "items", true), elemType: "int" },
   // 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),
@@ -4211,6 +4500,10 @@ function assertComponentsInCatalog(components2) {
   for (const c of components2) {
     for (const n of c.body) {
       if ("cond" in n) continue;
+      if ("fanout" in n) {
+        errs.push(`${c.name}/${n.id}: fanout node is not supported by litedbmodel (bc FanoutNode)`);
+        continue;
+      }
       const ref = "map" in n ? n.map : n;
       const entryDef = LITEDBMODEL_CATALOG[ref.component];
       if (entryDef === void 0) {
@@ -4388,6 +4681,8 @@ function assertComponentPortable(component) {
       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 if ("fanout" in n) {
+      throw new Error(`${at}/${n.id}: fanout node is not supported by litedbmodel (bc FanoutNode)`);
     } else {
       assertPortsPortable(n.ports, `${at}/${n.id}.ports`);
     }
@@ -4413,18 +4708,63 @@ import {
   compileBehaviors,
   SemanticBehavior
 } from "behavior-contracts";
+var boundRaw;
 var boundComponents;
+var currentResolver;
+function withColumnResolver(resolve, fn) {
+  const prev = currentResolver;
+  currentResolver = resolve;
+  try {
+    return fn();
+  } finally {
+    currentResolver = prev;
+  }
+}
+var READ_TYPED_LEAF = "Select";
+var WRITE_TYPED_LEAVES = /* @__PURE__ */ new Set(["Insert", "Update", "Delete"]);
+function wrapLeaf(name, raw) {
+  const isRead = name === READ_TYPED_LEAF;
+  const isWrite = WRITE_TYPED_LEAVES.has(name);
+  if (!isRead && !isWrite) return raw;
+  return (ports) => {
+    const handle = raw(ports);
+    if (isRead && currentResolver === void 0) {
+      throw new Error(
+        `scp authoring: a Select node needs its output row type at compile time (bc 0.8.0 all-nodes-typed gate), but the model declares NO \`columns\` \u2014 a typed read REQUIRES an inline \`static columns\` SoT (or \`options.columns\`). No-assume, no-fallback.`
+      );
+    }
+    const outType = currentResolver !== void 0 ? crudNodeAsType(name, ports, currentResolver, `${name} node`) : { arr: { obj: {} } };
+    return handle.as(outType);
+  };
+}
+function rawComponents() {
+  if (boundRaw === void 0) {
+    boundRaw = catalogComponents(LITEDBMODEL_CATALOG);
+  }
+  return boundRaw;
+}
 function components() {
   if (boundComponents === void 0) {
-    boundComponents = catalogComponents(LITEDBMODEL_CATALOG);
+    const raw = rawComponents();
+    const wrapped = {};
+    for (const name of Object.keys(raw)) wrapped[name] = wrapLeaf(name, raw[name]);
+    boundComponents = wrapped;
   }
   return boundComponents;
 }
 function lowerBehaviorClass(cls, options) {
-  const ir = compileBehaviors(cls, {
-    ...options.inputPorts !== void 0 ? { inputPorts: options.inputPorts } : {},
-    ...options.concurrency !== void 0 ? { concurrency: options.concurrency } : {}
-  });
+  const className = cls.name ?? "<anonymous>";
+  const declaredColumns = options.columns ?? cls.columns;
+  const columnMap = declaredColumns !== void 0 ? toColumnMap(declaredColumns) : void 0;
+  const materializeResolver = columnMap !== void 0 ? failClosedMaterializeResolverFromColumnMap(columnMap) : void 0;
+  const resolveColumnType = columnMap !== void 0 ? columnTypeResolverFromColumnMap(columnMap) : void 0;
+  const ir = withColumnResolver(
+    resolveColumnType,
+    () => compileBehaviors(cls, {
+      ...options.inputPorts !== void 0 ? { inputPorts: options.inputPorts } : {},
+      ...options.concurrency !== void 0 ? { concurrency: options.concurrency } : {}
+    })
+  );
   assertComponentsInCatalog(ir.components);
   assertComponentGraphPortable(ir);
   const methods = {};
@@ -4435,13 +4775,70 @@ function lowerBehaviorClass(cls, options) {
       component
     };
   }
+  assertReadColumnsDeclared(className, ir.components, methods, resolveColumnType);
   return {
-    className: cls.name ?? "<anonymous>",
+    className,
     ir,
     components: ir.components,
-    methods
+    methods,
+    ...materializeResolver !== void 0 ? { materializeResolver } : {},
+    ...resolveColumnType !== void 0 ? { resolveColumnType } : {}
   };
 }
+function toColumnMap(columns) {
+  const map = /* @__PURE__ */ new Map();
+  for (const [table, cols] of Object.entries(columns)) {
+    const inner = /* @__PURE__ */ new Map();
+    for (const [col, sqlType] of Object.entries(cols)) inner.set(col, sqlType);
+    map.set(table, inner);
+  }
+  return map;
+}
+function literalStringPort(ports, name) {
+  const v = ports[name];
+  return typeof v === "string" ? v : void 0;
+}
+function literalStringArrayPort(ports, name) {
+  const v = ports[name];
+  if (v !== null && typeof v === "object" && "arr" in v && Array.isArray(v.arr)) {
+    const arr = v.arr;
+    if (arr.every((e) => typeof e === "string")) return arr;
+  }
+  return void 0;
+}
+function selectProjectionsOf(component) {
+  const out = [];
+  for (const n of component.body) {
+    if ("cond" in n) continue;
+    if ("fanout" in n) {
+      throw new Error(`selectProjectionsOf: component '${component.name}' node '${n.id}' is a fanout node, not supported by litedbmodel (bc FanoutNode)`);
+    }
+    const ref = "map" in n ? n.map : n;
+    if (ref.component !== "Select") continue;
+    const ports = ref.ports;
+    const table = literalStringPort(ports, "table");
+    const columns = literalStringArrayPort(ports, "select");
+    if (table === void 0 || columns === void 0 || columns.length === 0) continue;
+    out.push({ table, columns });
+  }
+  return out;
+}
+function assertReadColumnsDeclared(className, components2, methods, resolveColumnType) {
+  for (const component of components2) {
+    if (methods[component.name]?.effect !== "query") continue;
+    for (const proj of selectProjectionsOf(component)) {
+      const at = `model '${className}' method '${component.name}'`;
+      const schemaCols = proj.columns.map((col) => parseProjectionColumn(col, proj.table, at)).filter((e) => e.kind === "column").map((e) => ({ table: e.qualifier ?? proj.table, column: e.underlying }));
+      if (schemaCols.length === 0) continue;
+      if (resolveColumnType === void 0) {
+        throw new Error(
+          `scp publishBehaviors: ${at} reads projecting typed columns [${schemaCols.map((s) => `${s.table}.${s.column}`).join(", ")}] but the model declares NO \`columns\`. A typed read REQUIRES an inline \`static columns\` declaration so the read-path de-box (INT\u2192number / BIGINT\u2192string / DATE\u2192string / BOOLEAN\u2192boolean) is always-on \u2014 never a silent raw (rounded i64) result. Declare the model's \`static columns\`.`
+        );
+      }
+      for (const s of schemaCols) resolveColumnType(s.table, s.column);
+    }
+  }
+}
 function publishBehaviors(cls, options = {}) {
   return lowerBehaviorClass(cls, options);
 }
@@ -4469,7 +4866,7 @@ function makeEagerClass(name, fn) {
 
 // src/scp/relation.ts
 var RELATION_KEYS_HEAD = "__keys";
-function compileRelationOp(decl) {
+function compileRelationOp(decl, resolveColumnType) {
   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})`);
   }
@@ -4485,6 +4882,22 @@ function compileRelationOp(decl) {
   const composite = isCompositeDecl(decl);
   const sql2 = compiledBatchSql(decl, dialect);
   const conn = decl.connection !== void 0 ? { connection: decl.connection } : {};
+  const materializers = {};
+  if (resolveColumnType !== void 0) {
+    const at = `relation '${decl.name}'`;
+    for (const c of decl.select) {
+      const entry2 = parseProjectionColumn(c, decl.targetTable, at);
+      if (entry2.kind === "computed") continue;
+      const sqlType = resolveColumnType(entry2.qualifier ?? decl.targetTable, entry2.underlying);
+      const klass = sqlTypeToMaterializeClass(sqlType);
+      if (klass !== "passthrough") materializers[entry2.outputKey] = klass;
+    }
+  }
+  const target = {
+    targetTable: decl.targetTable,
+    select: [...decl.select],
+    ...Object.keys(materializers).length > 0 ? { materializers } : {}
+  };
   if (composite) {
     return {
       name: decl.name,
@@ -4493,7 +4906,8 @@ function compileRelationOp(decl) {
       targetKeys: [...decl.targetKeys],
       dialect,
       ...conn,
-      sql: sql2
+      sql: sql2,
+      ...target
     };
   }
   return {
@@ -4503,7 +4917,8 @@ function compileRelationOp(decl) {
     targetKey: decl.targetKey,
     dialect,
     ...conn,
-    sql: sql2
+    sql: sql2,
+    ...target
   };
 }
 function isCompositeDecl(decl) {
@@ -4584,7 +4999,14 @@ function runRelationOp(op, parents, db) {
   const sql2 = renderPlaceholders(cast, op.dialect);
   if (keys.length === 0) return { sql: sql2, keys, batch };
   const tCols = targetKeyCols(op);
-  const rows = db.prepare(sql2).all(...bindKeys(op, keys));
+  const childCols = op.materializers;
+  const int64Child = childCols !== void 0 && Object.values(childCols).includes("int64");
+  const stmt = db.prepare(sql2);
+  if (int64Child && typeof stmt.safeIntegers === "function") {
+    stmt.safeIntegers(true);
+  }
+  const rawRows = stmt.all(...bindKeys(op, keys));
+  const rows = materializeChildRows(rawRows, childCols, int64Child);
   for (const row of rows) {
     const k = keyIdentity(tCols.map((c) => row[c]));
     const list = batch.get(k);
@@ -4593,6 +5015,23 @@ function runRelationOp(op, parents, db) {
   }
   return { sql: sql2, keys, batch };
 }
+function materializeChildRows(rows, cols, safeIntegersOn) {
+  if (cols === void 0 && !safeIntegersOn) return rows;
+  for (const row of rows) {
+    for (const key of Object.keys(row)) {
+      const klass = cols?.[key];
+      if (klass !== void 0) {
+        row[key] = materializeCell(row[key], klass);
+        continue;
+      }
+      if (safeIntegersOn && typeof row[key] === "bigint") {
+        const v = row[key];
+        row[key] = v >= BigInt(Number.MIN_SAFE_INTEGER) && v <= BigInt(Number.MAX_SAFE_INTEGER) ? Number(v) : v.toString();
+      }
+    }
+  }
+  return rows;
+}
 function dedupeKeys(parents, keyCols) {
   const seen = /* @__PURE__ */ new Set();
   const out = [];
@@ -4829,7 +5268,11 @@ function isWriteComponent(component) {
   return c === "Insert" || c === "Update" || c === "Delete";
 }
 function executeBehavior(contract, input, options) {
-  return executeBundle(compileBundle(contract, options.entry, options.relations, options.dialect), input, options);
+  return executeBundle(
+    compileBundle(contract, options.entry, options.relations, options.dialect, void 0, contract.resolveColumnType),
+    input,
+    options
+  );
 }
 function compileBundle(contract, entry2, relations = [], dialectName = "sqlite", findFilterModel, resolveColumnType) {
   const component = entry2 ? contract.components.find((c) => c.name === entry2) : contract.components[0];
@@ -4839,7 +5282,7 @@ function compileBundle(contract, entry2, relations = [], dialectName = "sqlite",
     if (relationOps[decl.name] !== void 0) {
       throw new Error(`scp runtime: duplicate relation declaration '${decl.name}'`);
     }
-    relationOps[decl.name] = compileRelationOp({ ...decl, dialect: decl.dialect ?? dialectName });
+    relationOps[decl.name] = compileRelationOp({ ...decl, dialect: decl.dialect ?? dialectName }, resolveColumnType);
   }
   if (isWriteComponent(component)) {
     const writeNode = primaryNodeOf(component);
@@ -4885,11 +5328,17 @@ async function executeBundleAsync(bundle, input, options) {
   return executeReadGraphAsync(bundle.readGraph, input, options.exec);
 }
 async function executeBehaviorAsync(contract, input, options) {
-  return executeBundleAsync(compileBundle(contract, options.entry, options.relations, options.dialect), input, options);
+  return executeBundleAsync(
+    compileBundle(contract, options.entry, options.relations, options.dialect, void 0, contract.resolveColumnType),
+    input,
+    options
+  );
 }
 function baseWriteNodeOf(component) {
   const writes = component.body.filter(
-    (n) => !("cond" in n) && !("map" in n) && (n.component === "Insert" || n.component === "Update" || n.component === "Delete")
+    // `fanout` (bc 0.7.3+ FanoutNode) is excluded from narrowing here: litedbmodel never emits
+    // it, and it carries no base write op, so it can never be a write node.
+    (n) => !("cond" in n) && !("map" in n) && !("fanout" 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`);
@@ -4998,7 +5447,11 @@ function executeTransactionBundle(bundle, input, options) {
   return executeTransaction(options.db, bundle.transaction, input, bundle.dialect);
 }
 function read(contract, input, options) {
-  return readBundle(compileBundle(contract, options.entry, options.relations, options.dialect), input, options);
+  return readBundle(
+    compileBundle(contract, options.entry, options.relations, options.dialect, void 0, contract.resolveColumnType),
+    input,
+    options
+  );
 }
 function readBundle(bundle, input, options) {
   const out = executeBundle(bundle, input, options);
@@ -5019,7 +5472,7 @@ function readBundle(bundle, input, options) {
 }
 
 // src/scp/codegen.ts
-import { generateModule } from "behavior-contracts";
+import { generateModule, loadCompiledIR } from "behavior-contracts";
 var CODEGEN_LANGUAGES = ["typescript", "python", "go", "rust", "php"];
 var CODEGEN_EMITTER = {
   typescript: "typescript-typed",
@@ -5028,12 +5481,9 @@ var CODEGEN_EMITTER = {
 };
 function bundleToPortableIR(bundle) {
   if (bundle.readGraph !== void 0) return bundle.readGraph.ir;
-  const ir = makeSqlComponentIR(bundle.name);
-  if (bundle.outputType === void 0) return ir;
-  const c = ir.components[0];
-  const body = c.body.map((n, i) => i === 0 ? { ...n, outType: bundle.outputType } : n);
-  const component = { ...c, body, outputType: bundle.outputType };
-  return { ...ir, components: [component] };
+  throw new Error(
+    `litedbmodel codegen: bundle '${bundle.name}' has no readGraph \u2014 a WRITE bundle carries a single compiled makeSQL statement, not a portable component-graph IR, and is not a codegen-module case (#12: the hand-built makeSQL write surrogate IR is eliminated; writes ride the write/tx exec path).`
+  );
 }
 function companionOf(bundle) {
   const base = {
@@ -5046,7 +5496,6 @@ function companionOf(bundle) {
   };
   return bundle.transaction === void 0 ? base : { ...base, transaction: bundle.transaction };
 }
-var SCOPE_PORT2 = "__scope";
 var TypedNativeCoverageError = class extends Error {
   constructor(component, reasons) {
     super(
@@ -5064,17 +5513,56 @@ bc's typed-native endpoint (bc#77/#90) fails closed on an uncovered shape \u2014
 };
 var WHERE_FRAGMENT_COLUMN = /^([A-Za-z_][A-Za-z0-9_]*)\s+(?:=|<>|<=|>=|<|>|LIKE|ILIKE)\s*\?$/;
 var SELECT_FROM_TABLE = /\bFROM\s+([A-Za-z_][A-Za-z0-9_]*)\b/i;
-function deriveHeadTypesFromStatements(statements, resolveColumnType) {
+var IN_LIST_COLUMN = /^([A-Za-z_][A-Za-z0-9_]*)\s+(?:IN\s*\(|=\s*ANY\s*\()/i;
+function deriveHeadTypesFromStatements(statements, resolveColumnType, elementVar) {
   const byHead = /* @__PURE__ */ new Map();
+  const arrayHeads = /* @__PURE__ */ new Map();
   const unresolved = /* @__PURE__ */ new Map();
   const head = statements[0];
   const tableMatch = head === void 0 ? null : SELECT_FROM_TABLE.exec(head.sql);
   const table = tableMatch?.[1];
   for (const stmt of statements) {
-    if (stmt.whereFragment !== true) continue;
+    if (stmt.whereFragment !== true) {
+      for (const param of stmt.params) {
+        const lh = limitHeadNameOf(param);
+        if (lh === void 0) continue;
+        if (elementVar !== void 0 && lh === elementVar) continue;
+        const prior = byHead.get(lh);
+        if (prior !== void 0 && prior !== "int") {
+          unresolved.set(lh, `input head '${lh}' resolves to conflicting scalar types ('${prior}' vs 'int' from a LIMIT clause) across statements`);
+          continue;
+        }
+        byHead.set(lh, "int");
+      }
+      continue;
+    }
     for (const param of stmt.params) {
       const path = refPathOf(param);
+      if (path !== void 0 && elementVar !== void 0 && path[0] === elementVar) continue;
       if (path === void 0 || path.length !== 1) {
+        const arrHead = arrayHeadNameOf(param);
+        if (arrHead !== void 0) {
+          if (table === void 0) {
+            unresolved.set(arrHead, `input head '${arrHead}': could not resolve the owning table from the SELECT head SQL ('${head?.sql ?? "<none>"}')`);
+            continue;
+          }
+          const cm = IN_LIST_COLUMN.exec(stmt.sql.trim());
+          if (cm === null) {
+            unresolved.set(
+              arrHead,
+              `input head '${arrHead}': IN-list WHERE fragment SQL '${stmt.sql}' is not the closed '<col> IN (\u2026)'/'<col> = ANY(?)' shape this codegen-only deriver covers`
+            );
+            continue;
+          }
+          const elemType = sqlTypeToBcScalar(resolveColumnType(table, cm[1]));
+          const priorElem = arrayHeads.get(arrHead);
+          if (priorElem !== void 0 && priorElem !== elemType) {
+            unresolved.set(arrHead, `input head '${arrHead}' resolves to conflicting array element scalar types ('${priorElem}' vs '${elemType}') across statements`);
+            continue;
+          }
+          arrayHeads.set(arrHead, elemType);
+          continue;
+        }
         const named = headNameOf(param);
         if (named !== void 0) {
           unresolved.set(
@@ -5108,7 +5596,12 @@ function deriveHeadTypesFromStatements(statements, resolveColumnType) {
       byHead.set(headName, scalar);
     }
   }
-  return { byHead, unresolved };
+  for (const head2 of arrayHeads.keys()) {
+    if (byHead.has(head2)) {
+      unresolved.set(head2, `input head '${head2}' is bound both as a scalar and as an array param \u2014 no single native port type`);
+    }
+  }
+  return { byHead, arrayHeads, unresolved };
 }
 function refPathOf(param) {
   if (param === null || typeof param !== "object" || Array.isArray(param)) return void 0;
@@ -5127,22 +5620,56 @@ function headNameOf(param) {
   }
   return void 0;
 }
+function elementFieldRefs(statements, elementVar) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const stmt of statements) {
+    for (const param of stmt.params) {
+      const path = refPathOf(param);
+      if (path === void 0 || path.length !== 2 || path[0] !== elementVar) continue;
+      const field = path[1];
+      if (!seen.has(field)) {
+        seen.add(field);
+        out.push(field);
+      }
+    }
+  }
+  return out;
+}
+function limitHeadNameOf(param) {
+  if (param === null || typeof param !== "object" || Array.isArray(param)) return void 0;
+  const obj = param;
+  const args = obj.coalesce;
+  if (!Array.isArray(args) || args.length !== 2) return void 0;
+  const [refPart, dflt] = args;
+  if (typeof dflt !== "number" || !Number.isInteger(dflt)) return void 0;
+  if (refPart === null || typeof refPart !== "object" || Array.isArray(refPart)) return void 0;
+  const rp = refPart;
+  const keys = Object.keys(rp);
+  if (keys.length !== 1 || keys[0] !== "ref" && keys[0] !== "refOpt") return void 0;
+  const path = rp[keys[0]];
+  if (!Array.isArray(path) || path.length !== 1 || typeof path[0] !== "string") return void 0;
+  return path[0];
+}
+function arrayHeadNameOf(param) {
+  if (param === null || typeof param !== "object" || Array.isArray(param)) return void 0;
+  const obj = param;
+  if (!("__jsonArray" in obj)) return void 0;
+  const inner = refPathOf(obj.__jsonArray);
+  return inner !== void 0 && inner.length === 1 ? inner[0] : void 0;
+}
 function lowerReadGraphForTypedNative(readGraph, resolveColumnType) {
   const ir = readGraph.ir;
   const reasons = [];
   const components2 = ir.components.map((c) => {
     const inputPortTypes = /* @__PURE__ */ new Map();
+    const inputPortElemTypes = /* @__PURE__ */ new Map();
     const body = c.body.map((n) => {
       if ("cond" in n) return n;
       const isMapNode = "map" in n;
-      const ref = isMapNode ? n.map : n;
-      const scopeVal = ref.ports[SCOPE_PORT2];
-      if (scopeVal === void 0 || typeof scopeVal !== "object" || scopeVal === null || !("obj" in scopeVal)) {
-        return n;
-      }
-      const obj = scopeVal.obj;
       const stmts = readGraph.statementsById[n.id] ?? [];
-      const { byHead, unresolved } = deriveHeadTypesFromStatements(stmts, resolveColumnType);
+      const elementVar = isMapNode ? n.map.as ?? void 0 : void 0;
+      const { byHead, arrayHeads, unresolved } = deriveHeadTypesFromStatements(stmts, resolveColumnType, elementVar);
       for (const [, reason] of unresolved) reasons.push(`node '${n.id}': ${reason}`);
       for (const [head, scalar] of byHead) {
         const prior = inputPortTypes.get(head);
@@ -5152,12 +5679,20 @@ function lowerReadGraphForTypedNative(readGraph, resolveColumnType) {
         }
         inputPortTypes.set(head, scalar);
       }
-      const newPorts = {};
-      for (const head of Object.keys(obj)) {
-        if (!byHead.has(head) && !unresolved.has(head)) {
-          reasons.push(`node '${n.id}': input head '${head}' referenced by the surrogate scope but not resolved by any WHERE fragment \u2014 cannot type it for native codegen`);
+      for (const [head, elem] of arrayHeads) {
+        const prior = inputPortElemTypes.get(head);
+        if (prior !== void 0 && prior !== elem) {
+          reasons.push(`input head '${head}' resolves to conflicting array element scalar types ('${prior}' vs '${elem}') across nodes`);
           continue;
         }
+        inputPortElemTypes.set(head, elem);
+      }
+      const newPorts = {};
+      if (isMapNode && elementVar !== void 0) {
+        const fields = elementFieldRefs(stmts, elementVar);
+        for (const field of fields) newPorts[field] = { ref: [elementVar, field] };
+      }
+      for (const head of [...byHead.keys(), ...arrayHeads.keys()]) {
         newPorts[head] = { ref: [head] };
       }
       return isMapNode ? { ...n, map: { ...n.map, ports: newPorts } } : { ...n, ports: newPorts };
@@ -5168,6 +5703,10 @@ function lowerReadGraphForTypedNative(readGraph, resolveColumnType) {
       const schema = (c.inputPorts ?? {})[name];
       inputPorts[name] = schema === void 0 ? { required: true, type: scalar } : { ...schema, type: scalar };
     }
+    for (const [name, elem] of inputPortElemTypes) {
+      const schema = (c.inputPorts ?? {})[name];
+      inputPorts[name] = { ...schema ?? { required: true }, type: "array", elemType: elem };
+    }
     return { ...c, body, inputPorts };
   });
   return { ...ir, components: components2 };
@@ -5194,8 +5733,8 @@ function typedEmitterFor(language, registered) {
 function codegenEmitterFor(language, registered) {
   return typedEmitterFor(language, registered);
 }
-function isTypedNativeEmitter(emitter) {
-  return emitter.endsWith("-typed-native");
+function needsHeadLowering(_emitter) {
+  return true;
 }
 function generateCodegenArtifact(bundle, language, registeredLanguages, resolveColumnType, runtimeImport) {
   if (bundle.readGraph === void 0) {
@@ -5204,8 +5743,9 @@ function generateCodegenArtifact(bundle, language, registeredLanguages, resolveC
     );
   }
   const emitter = typedEmitterFor(language, registeredLanguages);
-  const ir = isTypedNativeEmitter(emitter) ? lowerReadGraphForTypedNative(bundle.readGraph, resolveColumnType) : bundleToPortableIR(bundle);
-  const module = generateModule(ir, runtimeImport === void 0 ? { language: emitter } : { language: emitter, runtimeImport });
+  const ir = needsHeadLowering(emitter) ? lowerReadGraphForTypedNative(bundle.readGraph, resolveColumnType) : bundleToPortableIR(bundle);
+  const compiled = loadCompiledIR(ir);
+  const module = generateModule(compiled, runtimeImport === void 0 ? { language: emitter } : { language: emitter, runtimeImport });
   return { language, module, companion: companionOf(bundle), bundle };
 }
 function codegenExecuteBundleForTest(artifact, input, db) {
@@ -5275,6 +5815,7 @@ export {
   coalesce,
   codegenEmitterFor,
   codegenExecuteBundleForTest,
+  columnTypeResolverFromColumnMap,
   compileAuthoredBehavior,
   compileAuthoredNode,
   compileBundle,
@@ -5288,6 +5829,7 @@ export {
   compileDeleteManyBundle,
   compileEager,
   compileInsert as compileInsertMakeSQL,
+  compileInsertMany,
   compileReadGraph,
   compileRelationMap,
   compileRelationOp,
@@ -5305,7 +5847,10 @@ export {
   components,
   composeMakeSQL,
   concat,
+  configurePgDeboxTypeParsers,
   countingDriver,
+  dbCast,
+  dbCastIn,
   deriveContractEffect,
   deriveTransactionPlan,
   dialectFor,
@@ -5327,6 +5872,7 @@ export {
   executeStaticWrite,
   executeTransaction,
   executeTransactionBundle,
+  failClosedMaterializeResolverFromColumnMap,
   findFilterKeys,
   formatterFor,
   ge2 as ge,
@@ -5341,13 +5887,16 @@ export {
   lowerReadGraphForTypedNative,
   lt2 as lt,
   makeSqlCatalogEntry,
-  makeSqlComponentIR,
   makeSqlHandler,
   makeSqlHandlerSync,
-  makeSqlInput,
   mapSqliteError,
+  materializeCell,
+  materializeClassOrUndefined,
+  materializeResolverFromColumnMap,
   mod,
   mul,
+  mysqlDeboxExecutor,
+  mysqlDeboxPoolOptions,
   mysqlPkHint,
   mysqlPoolExecutor,
   ne2 as ne,
@@ -5359,6 +5908,7 @@ export {
   parseEffectPath,
   parseSchemaColumnTypes,
   pgCastFormatter,
+  pgDeboxExecutor,
   pgPoolExecutor,
   publishBehaviors,
   read,
@@ -5372,6 +5922,7 @@ export {
   runRelationOp,
   schemaColumnTypeResolver,
   sqlTypeToBcScalar,
+  sqlTypeToMaterializeClass,
   stripMysqlPkHint,
   sub,
   toDollarPlaceholders,