litedbmodel 2.0.1 → 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);
 }
@@ -801,7 +804,7 @@ function condsToRecord(conditions) {
 // src/scp/makesql/compile-select.ts
 function compileSelect(desc) {
   const params = [];
-  const selectCols = desc.select ?? "*";
+  const selectCols = desc.select || (desc.selectColumn ?? "*");
   const formatter = formatterFor(desc.dialect);
   if (desc.cte?.params && desc.cte.params.length > 0) params.push(...desc.cte.params);
   if (desc.joinParams && desc.joinParams.length > 0) params.push(...desc.joinParams);
@@ -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";
 
@@ -2384,6 +2355,23 @@ function collectFamily(ports, prefix) {
   }
   return out;
 }
+function collectSqlCast(ports) {
+  const map = /* @__PURE__ */ new Map();
+  for (const k of Object.keys(ports)) {
+    if (!k.startsWith("sqlCast.")) continue;
+    const v = ports[k];
+    if (typeof v !== "string") {
+      throw new Error(`compileWriteNode: port '${k}' (a sqlCast type) must be a literal string in the IR (got ${JSON.stringify(v)})`);
+    }
+    map.set(k.slice("sqlCast.".length), v);
+  }
+  return map;
+}
+function castPlaceholder(dialect, sqlCastMap, column) {
+  const sqlCast = sqlCastMap.get(column);
+  if (dialect !== "postgres" || sqlCast === void 0 || sqlCast === "timestamp" || sqlCast === "date") return "?";
+  return formatterFor("postgres")("?", sqlCast);
+}
 function opKey(node) {
   if (node === null || typeof node !== "object" || Array.isArray(node)) return void 0;
   const keys = Object.keys(node);
@@ -2469,17 +2457,18 @@ function mysqlPkHint(op) {
 function stripMysqlPkHint(sql2) {
   return sql2.replace(MYSQL_PK_HINT_RE, "");
 }
-function compileWriteNode(node) {
+function compileWriteNode(node, dialect = "sqlite") {
   const { component, ports } = node;
   const table = stringPort(ports, "table");
   if (table === void 0) throw new Error(`compileWriteNode: ${component} node requires a literal 'table' port`);
+  const sqlCastMap = collectSqlCast(ports);
   switch (component) {
     case "Insert": {
       const values = collectFamily(ports, "values");
       const cols = Object.keys(values);
       if (cols.length === 0) throw new Error(`compileWriteNode: Insert requires at least one 'values.<field>' port`);
       const sorted = [...cols].sort();
-      const placeholders = sorted.map(() => "?").join(", ");
+      const placeholders = sorted.map((c) => castPlaceholder(dialect, sqlCastMap, c)).join(", ");
       const sql2 = `INSERT INTO ${table} (${sorted.join(", ")}) VALUES (${placeholders})${returningTail(ports)}`;
       const pk = pkPort(ports);
       return { sql: sql2, params: sorted.map((c) => values[c]), ...pk !== void 0 ? { pk } : {} };
@@ -2490,7 +2479,7 @@ function compileWriteNode(node) {
       if (setCols.length === 0) throw new Error(`compileWriteNode: Update requires at least one 'set.<field>' port`);
       const where = lowerWherePort(ports, "Update");
       if (where.sql === "") throw new Error(`compileWriteNode: Update requires a 'where' port`);
-      const setClauses = setCols.map((c) => `${c} = ?`).join(", ");
+      const setClauses = setCols.map((c) => `${c} = ${castPlaceholder(dialect, sqlCastMap, c)}`).join(", ");
       const sql2 = `UPDATE ${table} SET ${setClauses} WHERE ${where.sql}${returningTail(ports)}`;
       return { sql: sql2, params: [...setCols.map((c) => set[c]), ...where.params] };
     }
@@ -2724,6 +2713,8 @@ function gateShortCircuit(gate, result) {
       return result.changes === 0 ? "unique_collision" : null;
     case "insertedElseNoop":
       return result.changes === 0 ? "idempotent_duplicate" : null;
+    default:
+      throw new Error(`scp write: unknown gate rule '${String(gate)}'`);
   }
 }
 function executeTransaction(db, plan, input, dialect = "sqlite") {
@@ -2782,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 };
 }
@@ -3020,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;
@@ -3050,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;
@@ -3079,11 +3077,483 @@ 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
+var FindFilterLeakError = class extends Error {
+  constructor(modelName, missingKeys) {
+    super(
+      `FIND_FILTER leak: model '${modelName}' declares an implicit scope predicate on [${missingKeys.join(", ")}] that is NOT present in the SCP-authored WHERE. The SCP compile cannot auto-apply FIND_FILTER (no model context at compile time), so the scope predicate would be silently dropped (soft-delete / tenant scope leak). Fold the FIND_FILTER predicates into the authored L.Select({ where }) explicitly (e.g. whereEq/whereIsNull on ${missingKeys.join(", ")}).`
+    );
+    this.modelName = modelName;
+    this.missingKeys = missingKeys;
+    this.name = "FindFilterLeakError";
+  }
+  modelName;
+  missingKeys;
+};
+function findFilterKeys(filter) {
+  if (!filter || filter.length === 0) return [];
+  return Object.keys(condsToRecord(filter));
+}
+function assertFindFilterFolded(model, authoredWhereKeys) {
+  const required = findFilterKeys(model.FIND_FILTER);
+  if (required.length === 0) return;
+  const present = new Set(authoredWhereKeys);
+  const missing = required.filter((k) => !present.has(k));
+  if (missing.length > 0) {
+    throw new FindFilterLeakError(model.name ?? "<anonymous model>", missing);
+  }
+}
+
+// src/scp/coltype.ts
+function sqlTypeToBcScalar(sqlType) {
+  const t = sqlType.trim().toUpperCase().replace(/\(.*\)/, "").replace(/\b(UNSIGNED|ZEROFILL|PRECISION)\b/g, "").replace(/\s+/g, " ").trim();
+  switch (t) {
+    // int は既定 64bit(i64)。INTEGER も BIGINT も int（bigint を別型にしない — サイズ制限は列制約で表現）。
+    case "INTEGER":
+    case "INT":
+    case "BIGINT":
+    case "SMALLINT":
+    case "TINYINT":
+    case "MEDIUMINT":
+    case "INT2":
+    case "INT4":
+    case "INT8":
+      return "int";
+    // int と real は明確に分離。
+    case "REAL":
+    case "FLOAT":
+    case "DOUBLE":
+    case "FLOAT4":
+    case "FLOAT8":
+      return "float";
+    // decimal は精度保持のため文字列表現。
+    case "DECIMAL":
+    case "NUMERIC":
+    case "MONEY":
+      return "string";
+    case "TEXT":
+    case "VARCHAR":
+    case "CHAR":
+    case "CHARACTER":
+    case "CHARACTER VARYING":
+    case "CLOB":
+    case "UUID":
+      return "string";
+    case "BOOLEAN":
+    case "BOOL":
+      return "bool";
+    // date/timestamp は一旦 string（spec §4.1 owner 決定）。bc に date scalar が無く（behavior-contracts#84
+    // は defer）、DB は行ごとに別 TZ を保存しないので、文字列表現で往復させる。将来 bc date 型導入時に最適化。
+    case "DATE":
+    case "TIMESTAMP":
+    case "TIMESTAMPTZ":
+    case "DATETIME":
+    case "TIME":
+      return "string";
+    // JSON 列の表現は JSON テキスト＝文字列（TS のみ利便で object へ de/serialize。列を typed obj 化しない）。
+    case "JSON":
+    case "JSONB":
+      return "string";
+    default:
+      throw new Error(
+        `litedbmodel type system (spec \xA74.1): no bc outType mapping 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 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;
+  const unquote = (s) => s.replace(/^["`[]|["`\]]$/g, "");
+  const TABLE_CONSTRAINT = /^(PRIMARY|FOREIGN|UNIQUE|CHECK|CONSTRAINT|KEY|INDEX)\b/i;
+  for (const stmt of ddl) {
+    const m = CREATE.exec(stmt);
+    if (m === null) continue;
+    const table = unquote(m[1].trim());
+    const cols = /* @__PURE__ */ new Map();
+    for (const entry2 of splitTopLevel(m[2])) {
+      const line = entry2.trim();
+      if (line.length === 0) continue;
+      if (TABLE_CONSTRAINT.test(line)) continue;
+      const parsed = parseColumnDef(line);
+      if (parsed === void 0) continue;
+      cols.set(parsed.name, parsed.sqlType);
+    }
+    tables.set(table, cols);
+  }
+  return tables;
+}
+function splitTopLevel(body) {
+  const parts = [];
+  let depth = 0;
+  let cur = "";
+  for (const ch of body) {
+    if (ch === "(") depth++;
+    else if (ch === ")") depth--;
+    if (ch === "," && depth === 0) {
+      parts.push(cur);
+      cur = "";
+    } else cur += ch;
+  }
+  if (cur.trim().length > 0) parts.push(cur);
+  return parts;
+}
+var TYPE_CONTINUATION = /^(VARYING|PRECISION)$/i;
+function parseColumnDef(line) {
+  const unquote = (s) => s.replace(/^["`[]|["`\]]$/g, "");
+  const nameMatch = /^([A-Za-z0-9_."`[\]]+)\s+(.*)$/.exec(line);
+  if (nameMatch === null) return void 0;
+  const name = unquote(nameMatch[1]);
+  const rest = nameMatch[2].trim();
+  const typeMatch = /^([A-Za-z0-9_]+(?:\s*\([^)]*\))?)\s*(.*)$/.exec(rest);
+  if (typeMatch === null) return void 0;
+  let sqlType = typeMatch[1].trim();
+  const after = typeMatch[2].trim();
+  const nextWord = /^([A-Za-z]+)/.exec(after);
+  if (nextWord !== null && TYPE_CONTINUATION.test(nextWord[1])) sqlType = `${sqlType} ${nextWord[1]}`;
+  if (sqlType.length === 0) return void 0;
+  return { name, sqlType };
+}
+function schemaColumnTypeResolver(ddl) {
+  const tables = parseSchemaColumnTypes(ddl);
+  return (table, column) => {
+    const cols = tables.get(table);
+    if (cols === void 0) {
+      throw new Error(
+        `litedbmodel type system (spec \xA74.1): no schema for table '${table}' \u2014 cannot type its SELECT projection for typed codegen. The DDL (schema.sql SoT) must declare the table (known: ${[...tables.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}' (known columns: ${[...cols.keys()].join(", ")}). A projected column with no schema type cannot be typed for de-boxed codegen. No-assume, no-fallback.`
+      );
+    }
+    return sqlType;
+  };
+}
+
+// src/scp/makesql/outtype.ts
+function toPortableScalar(scalar, _table, _column) {
+  return scalar;
+}
+function isMap2(n) {
+  return "map" in n;
+}
+function nodeRef2(n) {
+  return isMap2(n) ? { component: n.map.component, ports: n.map.ports } : { component: n.component, ports: n.ports };
+}
+function opKey3(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 stringPort3(ports, name) {
+  const v = ports[name];
+  if (v === void 0) return void 0;
+  if (typeof v !== "string") {
+    throw new Error(`outtype: port '${name}' must be a literal string in the IR (got ${JSON.stringify(v)})`);
+  }
+  return v;
+}
+function stringArrayPort2(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.map((e) => {
+      if (typeof e !== "string") throw new Error(`outtype: '${name}' entries must be literal strings (got ${JSON.stringify(e)})`);
+      return e;
+    });
+  }
+  throw new Error(`outtype: port '${name}' must be an {arr:[\u2026]} literal in the IR (got ${JSON.stringify(v)})`);
+}
+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).`
+    );
+  }
+  const obj = {};
+  for (const col of projection) {
+    const entry2 = parseProjectionColumn(col, table, at);
+    if (entry2.kind === "computed") {
+      throw new Error(
+        `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.`
+      );
+    }
+    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 nodeTypes(node, resolveColumnType) {
+  const { component, ports } = nodeRef2(node);
+  const at = `node '${node.id}'`;
+  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 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 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) {
+  const op = opKey3(output);
+  if (op === "ref" || op === "refOpt") {
+    const path = output[op];
+    if (!Array.isArray(path) || path.length === 0 || typeof path[0] !== "string") {
+      throw new Error(`outtype: ${at}: a '${op}' output must reference a node id`);
+    }
+    if (path.length !== 1 || path[0].startsWith("$") || path[0] === IN_SENTINEL) {
+      throw new Error(
+        `outtype: ${at}: output ref path ${JSON.stringify(path)} is not a bare node-result reference; field access / input refs at the output position are not supported by the typed de-box path. No-assume, no-fallback.`
+      );
+    }
+    const t = byNode.get(path[0]);
+    if (t === void 0) throw new Error(`outtype: ${at}: output references node '${path[0]}' which has no derived outType`);
+    return t;
+  }
+  if (op === "obj") {
+    const obj = output.obj;
+    if (obj === null || typeof obj !== "object" || Array.isArray(obj)) throw new Error(`outtype: ${at}: 'obj' output must be a record`);
+    const out = {};
+    for (const [k, expr] of Object.entries(obj)) {
+      if (k === "__proto__") throw new Error(`outtype: ${at}: '__proto__' key forbidden in output obj`);
+      out[k] = outputType(expr, byNode, `${at}.obj.${k}`);
+    }
+    return { obj: out };
+  }
+  if (op === "arr") {
+    const arr = output.arr;
+    if (Array.isArray(arr)) throw new Error(`outtype: ${at}: an '{arr:[\u2026]}' literal list output cannot be typed as a homogeneous array. No-assume, no-fallback.`);
+    return { arr: outputType(arr, byNode, `${at}.arr`) };
+  }
+  if (op === "opt") {
+    const inner = output.opt;
+    return { opt: outputType(inner, byNode, `${at}.opt`) };
+  }
+  throw new Error(
+    `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;
+    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`), materializersByNode };
+}
+
 // src/scp/authoring-sql.ts
 import { eq, ne, lt, le, gt, ge } from "behavior-contracts";
 var BETWEEN_SENTINEL = "@between";
@@ -3155,13 +3625,16 @@ function whereExists($, sub2, not2 = false) {
 }
 
 // src/scp/makesql/static-bundle.ts
-function isMap2(n) {
+function isMap3(n) {
   return "map" in n;
 }
-function nodeRef2(n) {
-  return isMap2(n) ? { component: n.map.component, ports: n.map.ports } : { component: n.component, ports: n.ports };
+function isFanout2(n) {
+  return "fanout" in n;
 }
-function stringPort3(ports, name) {
+function nodeRef3(n) {
+  return isMap3(n) ? { component: n.map.component, ports: n.map.ports } : { component: n.component, ports: n.ports };
+}
+function stringPort4(ports, name) {
   const v = ports[name];
   if (v === void 0) return void 0;
   if (typeof v !== "string") throw new Error(`static-bundle: port '${name}' must be a literal string in the IR (got ${JSON.stringify(v)})`);
@@ -3175,7 +3648,7 @@ function arrPort2(ports, name) {
   }
   throw new Error(`static-bundle: port '${name}' must be an {arr:[...]} literal in the IR (got ${JSON.stringify(v)})`);
 }
-function stringArrayPort2(ports, name) {
+function stringArrayPort3(ports, name) {
   const arr = arrPort2(ports, name);
   if (arr === void 0) return void 0;
   return arr.map((e) => {
@@ -3200,13 +3673,13 @@ function exprArrayPort(ports, name) {
   if (arr === void 0) return void 0;
   return arr;
 }
-function opKey3(node) {
+function opKey4(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 columnOf3(node, ctx) {
-  const op = opKey3(node);
+  const op = opKey4(node);
   if (op !== "ref" && op !== "refOpt") throw new Error(`static-bundle: ${ctx}: the column operand must be a {ref:[\u2026]} / {refOpt:[\u2026]} path`);
   const path = node[op];
   if (!Array.isArray(path) || path.length === 0 || typeof path[path.length - 1] !== "string") {
@@ -3215,7 +3688,7 @@ function columnOf3(node, ctx) {
   return path[path.length - 1];
 }
 function inSentinelColumn2(node) {
-  const op = opKey3(node);
+  const op = opKey4(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") {
@@ -3229,7 +3702,7 @@ function binOperands3(node, op, at) {
   return [args[0], args[1]];
 }
 function sentinelPath(node) {
-  const op = opKey3(node);
+  const op = opKey4(node);
   if (op !== "ref" && op !== "refOpt") return void 0;
   const path = node[op];
   if (!Array.isArray(path) || path.length === 0) return void 0;
@@ -3344,7 +3817,7 @@ function inListFragment(dialect, column, valueSpec) {
   return { sql: v1ConditionText2(conditions, dialect), params: [jsonArraySpec(dialect, valueSpec)] };
 }
 function lowerWhereMember2(node, dialect, at) {
-  const op = opKey3(node);
+  const op = opKey4(node);
   if (op === void 0) throw new Error(`static-bundle: ${at}: a where member must be a single-operator Expression node`);
   if (op === "and" || op === "or") {
     const args = node[op];
@@ -3384,7 +3857,7 @@ function lowerWherePort2(ports, dialect, at) {
   const fragments = [];
   arr.forEach((m, i) => {
     const memberAt = `${at}.where[${i}]`;
-    if (opKey3(m) === "cond") {
+    if (opKey4(m) === "cond") {
       const cargs = m.cond;
       if (!Array.isArray(cargs) || cargs.length !== 3 || cargs[2] !== null) {
         throw new Error(`static-bundle: ${memberAt}: a SKIP-optional condition must be {cond:[c, <member>, null]} (else = null)`);
@@ -3413,18 +3886,18 @@ function limitOffsetTail(kind, dialect, table) {
   return tail.replace(String(SENTINEL), "?");
 }
 function compileSelectNode(node, dialect) {
-  const { component, ports } = nodeRef2(node);
+  const { component, ports } = nodeRef3(node);
   if (component !== "Select" && component !== "Count") {
     throw new Error(`static-bundle: compileSelectNode only compiles Select/Count nodes (got '${component}')`);
   }
-  const table = stringPort3(ports, "table");
+  const table = stringPort4(ports, "table");
   if (table === void 0) throw new Error(`static-bundle: ${component} node requires a literal 'table' port`);
   const isCount = component === "Count";
-  const select = stringArrayPort2(ports, "select");
+  const select = stringArrayPort3(ports, "select");
   const cols = isCount ? "COUNT(*) as count" : select && select.length > 0 ? select.join(", ") : "*";
   const statements = [];
   const cte = mapPort(ports, "cte");
-  const join = stringPort3(ports, "join");
+  const join = stringPort4(ports, "join");
   const cteParams = exprArrayPort(ports, "cteParams");
   const joinParams = exprArrayPort(ports, "joinParams");
   const headDesc = { dialect, tableName: table, select: cols };
@@ -3437,15 +3910,15 @@ function compileSelectNode(node, dialect) {
     statements.push({ sql: frag.sql, params: frag.params, whereFragment: true, ...frag.skip !== void 0 ? { skip: frag.skip } : {} });
   }
   if (isCount) return statements;
-  const group = stringPort3(ports, "group");
+  const group = stringPort4(ports, "group");
   if (group !== void 0) statements.push({ sql: selectTail({ dialect, tableName: table, group }, table), params: [] });
-  const order = stringPort3(ports, "order");
+  const order = stringPort4(ports, "order");
   if (order !== void 0) statements.push({ sql: selectTail({ dialect, tableName: table, order }, table), params: [] });
   if (ports.limit !== void 0) statements.push({ sql: limitOffsetTail("limit", dialect, table), params: [ports.limit] });
   if (ports.offset !== void 0) statements.push({ sql: limitOffsetTail("offset", dialect, table), params: [ports.offset] });
-  const forUpdate = stringPort3(ports, "forUpdate");
+  const forUpdate = stringPort4(ports, "forUpdate");
   if (forUpdate === "true") statements.push({ sql: selectTail({ dialect, tableName: table, forUpdate: true }, table), params: [] });
-  const append = stringPort3(ports, "append");
+  const append = stringPort4(ports, "append");
   if (append !== void 0) statements.push({ sql: selectTail({ dialect, tableName: table, append }, table), params: [] });
   return statements;
 }
@@ -3453,7 +3926,7 @@ function compilePrimaryNode(node, dialect) {
   const component = "map" in node ? node.map.component : node.component;
   if (component === "Select" || component === "Count") return compileSelectNode(node, dialect);
   if (component === "Insert" || component === "Update" || component === "Delete") {
-    const op = compileWriteNode(node);
+    const op = compileWriteNode(node, dialect);
     return [{ sql: op.sql, params: op.params }];
   }
   throw new Error(`static-bundle: catalog component '${component}' has no makeSQL compile (SQL CRUD only: Select/Count/Insert/Update/Delete)`);
@@ -3464,7 +3937,10 @@ function compileStaticBundle(contract, dialect, entry2) {
   let primary;
   for (const n of component.body) {
     if ("cond" in n) continue;
-    if (isMap2(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;
   }
   if (primary === void 0) throw new Error(`static-bundle: behavior '${component.name}' has no primary catalog node`);
@@ -3504,13 +3980,14 @@ function collectRefOptHeads(node, into) {
 }
 function skipGuardHeads2(n, into) {
   if ("cond" in n) return;
-  const ports = isMap2(n) ? n.map.ports : n.ports;
+  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;
   const arr = where.arr;
   if (!Array.isArray(arr)) return;
   for (const m of arr) {
-    if (opKey3(m) === "cond") {
+    if (opKey4(m) === "cond") {
       const cond = m.cond;
       if (Array.isArray(cond) && cond.length === 3) collectRefHeads3(cond[0], into);
     }
@@ -3522,7 +3999,7 @@ function collectRefHeads3(node, into) {
     for (const e of node) collectRefHeads3(e, into);
     return;
   }
-  const op = opKey3(node);
+  const op = opKey4(node);
   if (op === "ref" || op === "refOpt") {
     const path = node[op];
     if (Array.isArray(path) && path.length > 0 && typeof path[0] === "string") into.add(path[0]);
@@ -3530,6 +4007,43 @@ function collectRefHeads3(node, into) {
   }
   for (const v of Object.values(node)) collectRefHeads3(v, into);
 }
+function whereMemberColumns(node, into) {
+  const op = opKey4(node);
+  if (op === void 0) return;
+  if (op === "and" || op === "or") {
+    const args = node[op];
+    if (Array.isArray(args)) for (const m of args) whereMemberColumns(m, into);
+    return;
+  }
+  if (op === "cond") {
+    const cargs = node.cond;
+    if (Array.isArray(cargs) && cargs.length === 3) whereMemberColumns(cargs[1], into);
+    return;
+  }
+  if (op === "eq" || op in CMP_OPS3) {
+    const args = node[op];
+    if (!Array.isArray(args) || args.length !== 2) return;
+    const inCol = inSentinelColumn2(args[0]);
+    if (inCol !== void 0) {
+      into.add(inCol);
+      return;
+    }
+    const lhsOp = opKey4(args[0]);
+    if (lhsOp === "ref" || lhsOp === "refOpt") {
+      const path = args[0][lhsOp];
+      if (Array.isArray(path) && path.length > 0 && typeof path[path.length - 1] === "string" && path[0] !== IN_SENTINEL) {
+        into.add(path[path.length - 1]);
+      }
+    }
+  }
+}
+function authoredWhereKeysOf(ports) {
+  const keys = /* @__PURE__ */ new Set();
+  const arr = arrPort2(ports, "where");
+  if (arr === void 0) return keys;
+  for (const m of arr) whereMemberColumns(m, keys);
+  return keys;
+}
 function toDriverParam2(v) {
   if (typeof v === "bigint") {
     if (v >= BigInt(Number.MIN_SAFE_INTEGER) && v <= BigInt(Number.MAX_SAFE_INTEGER)) return Number(v);
@@ -3601,116 +4115,207 @@ 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);
-  const op = compileWriteNode(node);
+  const op = compileWriteNode(node, dialect);
   return [{ sql: op.sql, params: op.params }];
 }
-function compileReadGraph(contract, dialect, entry2) {
+function compileReadGraph(contract, dialect, entry2, findFilterModel, resolveColumnType) {
   const component = entry2 ? contract.components.find((c) => c.name === entry2) : contract.components[0];
   if (component === void 0) throw new Error(`static-bundle: entry component '${entry2 ?? "<first>"}' not found in contract`);
+  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));
+    }
+  }
   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 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];
-    if ("map" in n) {
-      return { ...n, map: { ...n.map, component: NODE_COMPONENT, ports: { [SCOPE_PORT]: scopePort(stmts) } } };
-    }
-    return { ...n, component: NODE_COMPONENT, ports: { [SCOPE_PORT]: scopePort(stmts) } };
+    const outType = readTypes?.byNode.get(n.id);
+    return outType !== void 0 ? { ...n, outType } : n;
   });
-  const surrogate = { ...component, body: surrogateBody };
-  const ir = { irVersion: 1, exprVersion: 2, components: [surrogate] };
+  const irComponent = {
+    ...component,
+    body: annotatedBody,
+    ...readTypes !== void 0 ? { outputType: readTypes.outputType } : {}
+  };
+  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);
   }
@@ -3735,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);
@@ -3751,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);
@@ -3822,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),
@@ -3860,13 +4492,18 @@ var WRITE_CATALOG_NAMES = [
 var WRITE_SET = new Set(WRITE_CATALOG_NAMES);
 var WRITE_PORT_FAMILIES = [
   "values.",
-  "set."
+  "set.",
+  "sqlCast."
 ];
 function assertComponentsInCatalog(components2) {
   const errs = [];
   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) {
@@ -4044,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`);
     }
@@ -4069,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 = {};
@@ -4091,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);
 }
@@ -4123,36 +4864,9 @@ function makeEagerClass(name, fn) {
   return cls;
 }
 
-// src/scp/find-filter-guard.ts
-var FindFilterLeakError = class extends Error {
-  constructor(modelName, missingKeys) {
-    super(
-      `FIND_FILTER leak: model '${modelName}' declares an implicit scope predicate on [${missingKeys.join(", ")}] that is NOT present in the SCP-authored WHERE. The SCP compile cannot auto-apply FIND_FILTER (no model context at compile time), so the scope predicate would be silently dropped (soft-delete / tenant scope leak). Fold the FIND_FILTER predicates into the authored L.Select({ where }) explicitly (e.g. whereEq/whereIsNull on ${missingKeys.join(", ")}).`
-    );
-    this.modelName = modelName;
-    this.missingKeys = missingKeys;
-    this.name = "FindFilterLeakError";
-  }
-  modelName;
-  missingKeys;
-};
-function findFilterKeys(filter) {
-  if (!filter || filter.length === 0) return [];
-  return Object.keys(condsToRecord(filter));
-}
-function assertFindFilterFolded(model, authoredWhereKeys) {
-  const required = findFilterKeys(model.FIND_FILTER);
-  if (required.length === 0) return;
-  const present = new Set(authoredWhereKeys);
-  const missing = required.filter((k) => !present.has(k));
-  if (missing.length > 0) {
-    throw new FindFilterLeakError(model.name ?? "<anonymous model>", missing);
-  }
-}
-
 // 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})`);
   }
@@ -4168,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,
@@ -4176,7 +4906,8 @@ function compileRelationOp(decl) {
       targetKeys: [...decl.targetKeys],
       dialect,
       ...conn,
-      sql: sql2
+      sql: sql2,
+      ...target
     };
   }
   return {
@@ -4186,7 +4917,8 @@ function compileRelationOp(decl) {
     targetKey: decl.targetKey,
     dialect,
     ...conn,
-    sql: sql2
+    sql: sql2,
+    ...target
   };
 }
 function isCompositeDecl(decl) {
@@ -4267,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);
@@ -4276,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 = [];
@@ -4402,6 +5158,100 @@ function buildResultSet(rawRows, ops, db, options = {}) {
   return rows.map((o) => hydrate(o));
 }
 
+// src/scp/makesql/writeouttype.ts
+function toPortableScalar2(scalar) {
+  return scalar;
+}
+var SHORT_CIRCUIT_TYPE = { obj: { statementId: "string", reason: "string" } };
+function targetAndReturning(sql2) {
+  const s = sql2.trim();
+  const ins = /^INSERT\s+(?:IGNORE\s+)?INTO\s+([A-Za-z_][A-Za-z0-9_]*)/i.exec(s);
+  const upd = /^UPDATE\s+([A-Za-z_][A-Za-z0-9_]*)/i.exec(s);
+  const del = /^DELETE\s+FROM\s+([A-Za-z_][A-Za-z0-9_]*)/i.exec(s);
+  const m = ins ?? upd ?? del;
+  if (m === null) {
+    throw new Error(
+      `writeouttype: a write body statement's SQL is not a recognized INSERT/UPDATE/DELETE (${JSON.stringify(sql2)}). The typed de-box must read the target table from the base write. No-assume, no-fallback.`
+    );
+  }
+  const table = m[1];
+  const clean = s.replace(/\s*\/\*scp:pk=[^*]*\*\//i, "");
+  const ret = /\bRETURNING\s+(.+?)\s*$/i.exec(clean);
+  if (ret === null) return { table, returning: null };
+  const cols = ret[1].split(",").map((c) => c.trim()).filter((c) => c.length > 0);
+  return { table, returning: cols };
+}
+function rowObjType2(table, returning, resolve) {
+  const obj = {};
+  for (const col of returning) {
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(col)) {
+      throw new Error(
+        `writeouttype: RETURNING column '${col}' on '${table}' is not a bare column name (alias / qualified / computed). The typed de-box needs bare schema columns so each maps to a SQL type. No-assume, no-fallback.`
+      );
+    }
+    if (col in obj) throw new Error(`writeouttype: duplicate RETURNING column '${col}' on '${table}'`);
+    obj[col] = toPortableScalar2(sqlTypeToBcScalar(resolve(table, col)));
+  }
+  return { obj };
+}
+function bodyStatements(plan) {
+  return plan.statements.filter((s) => s.role === "body");
+}
+function isBatchPlan(plan) {
+  return plan.entityFrom === null && plan.statements.length > 0 && plan.statements.every((s) => s.gate === void 0 && s.binds === void 0 && s.role === "body");
+}
+function writeTargetReturning(plan) {
+  const bodies = bodyStatements(plan);
+  if (bodies.length === 0) {
+    throw new Error(
+      `writeouttype: the transaction plan has no 'body' write statement \u2014 a write bundle must carry at least one base write. Cannot derive its output row type. No-assume, no-fallback.`
+    );
+  }
+  let table;
+  let returning;
+  for (const b of bodies) {
+    const { table: t, returning: r } = targetAndReturning(b.op.sql);
+    if (table === void 0) {
+      table = t;
+      returning = r;
+      continue;
+    }
+    if (t !== table) {
+      throw new Error(
+        `writeouttype: batch write body statements target DIFFERENT tables ('${table}' vs '${t}'); the typed de-box requires a homogeneous RETURNING row shape across a batch. No-assume, no-fallback.`
+      );
+    }
+    if (JSON.stringify(returning) !== JSON.stringify(r)) {
+      throw new Error(
+        `writeouttype: batch write body statements on '${table}' have DIFFERENT RETURNING projections (${JSON.stringify(returning)} vs ${JSON.stringify(r)}); the de-boxed row struct must be identical across a batch. No-assume, no-fallback.`
+      );
+    }
+  }
+  return { table, returning: returning ?? null };
+}
+function deriveWriteOutputType(plan, resolve) {
+  const { table, returning } = writeTargetReturning(plan);
+  const hasReturning = returning !== null;
+  const row = hasReturning ? rowObjType2(table, returning, resolve) : "null";
+  const fields = {
+    committed: "bool",
+    executed: { arr: "string" },
+    shortCircuit: { opt: SHORT_CIRCUIT_TYPE },
+    entity: { opt: row }
+  };
+  if (isBatchPlan(plan) && hasReturning) fields.returnedRows = { opt: { arr: { arr: row } } };
+  return { obj: fields };
+}
+function annotateWriteBundleOutType(bundle, resolve) {
+  if (bundle.transaction === void 0) {
+    throw new Error(
+      `writeouttype: bundle '${bundle.name}' carries no transaction plan \u2014 the write de-box types the TransactionResult of a write-Command / batch bundle. No-assume, no-fallback.`
+    );
+  }
+  const outputType2 = deriveWriteOutputType(bundle.transaction, resolve);
+  return { ...bundle, outputType: outputType2 };
+}
+
 // src/scp/runtime.ts
 function primaryNodeOf(component) {
   for (const n of component.body) {
@@ -4418,9 +5268,13 @@ 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") {
+function compileBundle(contract, entry2, relations = [], dialectName = "sqlite", findFilterModel, resolveColumnType) {
   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 relationOps = {};
@@ -4428,11 +5282,11 @@ 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);
-    const op = compileWriteNode(writeNode);
+    const op = compileWriteNode(writeNode, dialectName);
     return {
       dialect: dialectName,
       name: component.name,
@@ -4441,7 +5295,7 @@ function compileBundle(contract, entry2, relations = [], dialectName = "sqlite")
       relations: relationOps
     };
   }
-  const readGraph = compileReadGraph(contract, dialectName, entry2);
+  const readGraph = compileReadGraph(contract, dialectName, entry2, findFilterModel, resolveColumnType);
   return {
     dialect: dialectName,
     name: readGraph.name,
@@ -4474,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`);
@@ -4490,7 +5350,7 @@ function baseWriteNodeOf(component) {
   }
   return writes[0];
 }
-function compileWriteBundle(contract, entry2, writes, phase, dialectName = "sqlite") {
+function compileWriteBundle(contract, entry2, writes, phase, dialectName = "sqlite", resolveColumnType) {
   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);
@@ -4498,10 +5358,10 @@ function compileWriteBundle(contract, entry2, writes, phase, dialectName = "sqli
     throw new Error(`scp write: the '${phase}' lifecycle is not declared in the entityWrites save contract`);
   }
   const writeNode = baseWriteNodeOf(component);
-  const baseOp = dialectName === "mysql" ? mysqlPkHint(compileWriteNode(writeNode)) : compileWriteNode(writeNode);
+  const baseOp = dialectName === "mysql" ? mysqlPkHint(compileWriteNode(writeNode, dialectName)) : compileWriteNode(writeNode, dialectName);
   const base = { op: baseOp, label: `${writeNode.component}` };
   const plan = deriveTransactionPlan(phase, [base], lifecycle, dialectName);
-  return {
+  const bundle = {
     dialect: dialectName,
     name: component.name,
     statement: { sql: baseOp.sql, params: baseOp.params },
@@ -4509,6 +5369,7 @@ function compileWriteBundle(contract, entry2, writes, phase, dialectName = "sqli
     relations: {},
     transaction: plan
   };
+  return resolveColumnType === void 0 ? bundle : annotateWriteBundleOutType(bundle, resolveColumnType);
 }
 function compileCompositeWriteBundle(contract, entries, phase, dialectName = "sqlite") {
   if (entries.length < 2) {
@@ -4522,7 +5383,7 @@ function compileCompositeWriteBundle(contract, entries, phase, dialectName = "sq
     if (component === void 0) throw new Error(`scp write: entry component '${e.entry}' not found in contract`);
     if (firstBaseOp === void 0) firstName = component.name;
     const writeNode = baseWriteNodeOf(component);
-    const baseOp = compileWriteNode(writeNode);
+    const baseOp = compileWriteNode(writeNode, dialectName);
     if (firstBaseOp === void 0) firstBaseOp = baseOp;
     bases.push({ op: baseOp, label: `${writeNode.component} ${e.name}`, name: e.name, effects: e.lifecycle.effects });
   }
@@ -4540,7 +5401,7 @@ function flattenBatchOp(node, label) {
   const assembled = assembleMakeSQL(node);
   return { sql: assembled.sql, params: assembled.params, label };
 }
-function compileCreateManyBundle(name, options, dialectName = "sqlite") {
+function compileCreateManyBundle(name, options, dialectName = "sqlite", resolveColumnType) {
   const components2 = compileInsertMany(dialectName, options);
   const ops = components2.map((c, i) => {
     const flat = flattenBatchOp(c, `createMany group ${i}`);
@@ -4550,7 +5411,12 @@ function compileCreateManyBundle(name, options, dialectName = "sqlite") {
     return flat;
   });
   const plan = deriveBatchPlan("create", ops);
-  return { dialect: dialectName, name, statement: { sql: ops[0]?.sql ?? "", params: ops[0]?.params ?? [] }, optionalHeads: [], relations: {}, transaction: plan };
+  const head = ops[0];
+  if (head === void 0) {
+    throw new Error(`scp write: compileCreateManyBundle('${name}') produced no INSERT statements (empty createMany grouping) \u2014 an empty-ops batch bundle is a compile bug, not a silent empty-SQL default.`);
+  }
+  const bundle = { dialect: dialectName, name, statement: { sql: head.sql, params: head.params }, optionalHeads: [], relations: {}, transaction: plan };
+  return resolveColumnType === void 0 ? bundle : annotateWriteBundleOutType(bundle, resolveColumnType);
 }
 function compileUpdateManyBundle(name, options, dialectName = "sqlite") {
   const op = flattenBatchOp(compileUpdateMany(dialectName, options), "updateMany");
@@ -4581,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);
@@ -4602,11 +5472,18 @@ 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",
+  go: "go-typed-native",
+  rust: "rust-typed-native"
+};
 function bundleToPortableIR(bundle) {
   if (bundle.readGraph !== void 0) return bundle.readGraph.ir;
-  return makeSqlComponentIR(bundle.name);
+  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 = {
@@ -4614,27 +5491,262 @@ function companionOf(bundle) {
     optionalHeads: bundle.optionalHeads,
     relations: bundle.relations,
     ...bundle.readGraph !== void 0 ? { readGraph: bundle.readGraph } : {},
-    ...bundle.statement !== void 0 ? { statement: bundle.statement } : {}
+    ...bundle.statement !== void 0 ? { statement: bundle.statement } : {},
+    ...bundle.outputType !== void 0 ? { outputType: bundle.outputType } : {}
   };
   return bundle.transaction === void 0 ? base : { ...base, transaction: bundle.transaction };
 }
-function assertLanguageSupported(language, registered) {
+var TypedNativeCoverageError = class extends Error {
+  constructor(component, reasons) {
+    super(
+      `litedbmodel codegen (#60 m1): component '${component}' is not typed-native-coverable:
+` + reasons.map((r) => `  - ${r}`).join("\n") + `
+
+bc's typed-native endpoint (bc#77/#90) fails closed on an uncovered shape \u2014 this is NOT regenerated on the boxed '-typed'/'-typed-raw' emitter (retired from litedbmodel's codegen surface, #60 milestone 1). Report this as a bc#86 coverage gap (array-typed / non-scalar input heads have no native port type yet), or exclude this case from native-codegen benching.`
+    );
+    this.component = component;
+    this.reasons = reasons;
+    this.name = "TypedNativeCoverageError";
+  }
+  component;
+  reasons;
+};
+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;
+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) {
+      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(
+            named,
+            `input head '${named}' is bound by a non-scalar param shape (${JSON.stringify(param)}) \u2014 bc's typed-native emitter has no native port type for it (string/int/float/bool scalars only).`
+          );
+        }
+        continue;
+      }
+      const headName = path[0];
+      if (table === void 0) {
+        unresolved.set(headName, `input head '${headName}': could not resolve the owning table from the SELECT head SQL ('${head?.sql ?? "<none>"}')`);
+        continue;
+      }
+      const m = WHERE_FRAGMENT_COLUMN.exec(stmt.sql.trim());
+      if (m === null) {
+        unresolved.set(
+          headName,
+          `input head '${headName}': WHERE fragment SQL '${stmt.sql}' is not the closed '<col> <op> ?' shape this codegen-only deriver covers`
+        );
+        continue;
+      }
+      const column = m[1];
+      const sqlType = resolveColumnType(table, column);
+      const scalar = sqlTypeToBcScalar(sqlType);
+      const prior = byHead.get(headName);
+      if (prior !== void 0 && prior !== scalar) {
+        unresolved.set(headName, `input head '${headName}' resolves to conflicting scalar types ('${prior}' vs '${scalar}') across statements`);
+        continue;
+      }
+      byHead.set(headName, scalar);
+    }
+  }
+  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;
+  const keys = Object.keys(param);
+  if (keys.length !== 1 || keys[0] !== "ref" && keys[0] !== "refOpt") return void 0;
+  const path = param[keys[0]];
+  if (!Array.isArray(path) || path.length === 0 || !path.every((s) => typeof s === "string")) return void 0;
+  return path;
+}
+function headNameOf(param) {
+  if (param === null || typeof param !== "object" || Array.isArray(param)) return void 0;
+  const obj = param;
+  if ("__jsonArray" in obj) {
+    const inner = refPathOf(obj.__jsonArray);
+    return inner?.[0];
+  }
+  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 stmts = readGraph.statementsById[n.id] ?? [];
+      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);
+        if (prior !== void 0 && prior !== scalar) {
+          reasons.push(`input head '${head}' resolves to conflicting scalar types ('${prior}' vs '${scalar}') across nodes`);
+          continue;
+        }
+        inputPortTypes.set(head, scalar);
+      }
+      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 };
+    });
+    if (reasons.length > 0) throw new TypedNativeCoverageError(c.name, reasons);
+    const inputPorts = {};
+    for (const [name, scalar] of inputPortTypes) {
+      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 };
+}
+function typedEmitterFor(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)) {
+  const emitter = CODEGEN_EMITTER[language];
+  if (emitter === void 0) {
     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).`
+      `litedbmodel codegen: no READ codegen endpoint for '${language}'. litedbmodel codegen is STATIC de-interpreted codegen (spec \xA79) with NO literal/interpreter/boxed fallback (an unspec'd fallback is invalid). bc registers a READ endpoint only for ${Object.keys(CODEGEN_EMITTER).join("/")} \u2014 a '${language}' endpoint is a bc capability gap. ESCALATE to bc (bc#22 pattern); never substitute the literal emitter.`
     );
   }
+  if (!registered.includes(emitter)) {
+    throw new Error(
+      `litedbmodel codegen: bc's shared generator does not register the '${emitter}' emitter for '${language}' (bc registered: ${[...registered].sort().join(", ")}). ESCALATE to bc (bc#22 pattern), never fork locally.`
+    );
+  }
+  return emitter;
+}
+function codegenEmitterFor(language, registered) {
+  return typedEmitterFor(language, registered);
 }
-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, bundle };
+function needsHeadLowering(_emitter) {
+  return true;
+}
+function generateCodegenArtifact(bundle, language, registeredLanguages, resolveColumnType, runtimeImport) {
+  if (bundle.readGraph === void 0) {
+    throw new Error(
+      `litedbmodel codegen (#60 m1): bundle '${bundle.name}' has no readGraph \u2014 WRITE bundles are not codegen-module cases (they stay on the existing write/tx execution path). Only READ bundles are generated through generateCodegenArtifact.`
+    );
+  }
+  const emitter = typedEmitterFor(language, registeredLanguages);
+  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) {
   return executeBundle(artifact.bundle, input, { db });
@@ -4667,6 +5779,7 @@ import {
 } from "behavior-contracts";
 export {
   CATALOG_NAMES,
+  CODEGEN_EMITTER,
   CODEGEN_LANGUAGES,
   ENTITY_ROOT,
   FindFilterLeakError,
@@ -4682,6 +5795,7 @@ export {
   SQLITE,
   SemanticBehavior2 as SemanticBehavior,
   SqlFailure,
+  TypedNativeCoverageError,
   WRITE_CATALOG_NAMES,
   WRITE_PORT_FAMILIES,
   add,
@@ -4693,14 +5807,15 @@ export {
   assertComponentsInCatalog,
   assertExprPortable,
   assertFindFilterFolded,
-  assertLanguageSupported,
   behavior,
   buildResultSet,
   builderFor,
   bundleToPortableIR,
   catalogEntry,
   coalesce,
+  codegenEmitterFor,
   codegenExecuteBundleForTest,
+  columnTypeResolverFromColumnMap,
   compileAuthoredBehavior,
   compileAuthoredNode,
   compileBundle,
@@ -4714,6 +5829,7 @@ export {
   compileDeleteManyBundle,
   compileEager,
   compileInsert as compileInsertMakeSQL,
+  compileInsertMany,
   compileReadGraph,
   compileRelationMap,
   compileRelationOp,
@@ -4731,7 +5847,10 @@ export {
   components,
   composeMakeSQL,
   concat,
+  configurePgDeboxTypeParsers,
   countingDriver,
+  dbCast,
+  dbCastIn,
   deriveContractEffect,
   deriveTransactionPlan,
   dialectFor,
@@ -4753,6 +5872,7 @@ export {
   executeStaticWrite,
   executeTransaction,
   executeTransactionBundle,
+  failClosedMaterializeResolverFromColumnMap,
   findFilterKeys,
   formatterFor,
   ge2 as ge,
@@ -4764,15 +5884,19 @@ export {
   le2 as le,
   len,
   lifecycleFor,
+  lowerReadGraphForTypedNative,
   lt2 as lt,
   makeSqlCatalogEntry,
-  makeSqlComponentIR,
   makeSqlHandler,
   makeSqlHandlerSync,
-  makeSqlInput,
   mapSqliteError,
+  materializeCell,
+  materializeClassOrUndefined,
+  materializeResolverFromColumnMap,
   mod,
   mul,
+  mysqlDeboxExecutor,
+  mysqlDeboxPoolOptions,
   mysqlPkHint,
   mysqlPoolExecutor,
   ne2 as ne,
@@ -4782,7 +5906,9 @@ export {
   opt,
   or,
   parseEffectPath,
+  parseSchemaColumnTypes,
   pgCastFormatter,
+  pgDeboxExecutor,
   pgPoolExecutor,
   publishBehaviors,
   read,
@@ -4794,9 +5920,13 @@ export {
   renderTxStatement,
   resolvePgArrayCast,
   runRelationOp,
+  schemaColumnTypeResolver,
+  sqlTypeToBcScalar,
+  sqlTypeToMaterializeClass,
   stripMysqlPkHint,
   sub,
   toDollarPlaceholders,
+  typedEmitterFor,
   when,
   whereBetween,
   whereCast,