litedbmodel 2.0.1 → 2.0.2

package/dist/scp/index.mjs

@@ -801,7 +801,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);
@@ -2384,6 +2384,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 +2486,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 +2508,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 +2742,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") {
@@ -3084,6 +3104,277 @@ import {
   runBehaviorAsync
 } 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 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 rowObjType(table, projection, resolveColumnType, at) {
+  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) {
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(col)) {
+      throw new Error(
+        `outtype: ${at}: projected column '${col}' on '${table}' is not a bare column name (alias / qualified / computed). Typed de-box (spec \xA74.1) requires bare schema columns so each maps to a SQL type. No-assume, no-fallback.`
+      );
+    }
+    if (col in obj) throw new Error(`outtype: ${at}: duplicate projected column '${col}' on '${table}'`);
+    obj[col] = toPortableScalar(sqlTypeToBcScalar(resolveColumnType(table, col)), table, col);
+  }
+  return { obj };
+}
+function nodeOutType(node, resolveColumnType) {
+  const { component, ports } = nodeRef2(node);
+  const at = `node '${node.id}'`;
+  if (component === "Count") return "int";
+  if (component === "Select") {
+    const table = stringPort3(ports, "table");
+    if (table === void 0) throw new Error(`outtype: ${at}: Select node requires a literal 'table' port`);
+    const projection = stringArrayPort2(ports, "select");
+    const row = rowObjType(table, projection, resolveColumnType, at);
+    if (isMap2(node)) return { arr: { arr: row } };
+    return { arr: row };
+  }
+  throw new Error(
+    `outtype: ${at}: component '${component}' has no typed outType (typed read codegen covers Select/Count only). A write / unknown node cannot be de-boxed here \u2014 no-assume, no-fallback.`
+  );
+}
+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 deriveReadOutTypes(component, resolveColumnType) {
+  const byNode = /* @__PURE__ */ new Map();
+  for (const n of component.body) {
+    if ("cond" in n) continue;
+    byNode.set(n.id, nodeOutType(n, resolveColumnType));
+  }
+  return { byNode, outputType: outputType(component.output, byNode, `component '${component.name}' output`) };
+}
+
 // src/scp/authoring-sql.ts
 import { eq, ne, lt, le, gt, ge } from "behavior-contracts";
 var BETWEEN_SENTINEL = "@between";
@@ -3155,13 +3446,13 @@ 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 nodeRef3(n) {
+  return isMap3(n) ? { component: n.map.component, ports: n.map.ports } : { component: n.component, ports: n.ports };
 }
-function stringPort3(ports, name) {
+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 +3466,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 +3491,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 +3506,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 +3520,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 +3635,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 +3675,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 +3704,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 +3728,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 +3744,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 +3755,7 @@ function compileStaticBundle(contract, dialect, entry2) {
   let primary;
   for (const n of component.body) {
     if ("cond" in n) continue;
-    if (isMap2(n)) continue;
+    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 +3795,13 @@ function collectRefOptHeads(node, into) {
 }
 function skipGuardHeads2(n, into) {
   if ("cond" in n) return;
-  const ports = isMap2(n) ? n.map.ports : n.ports;
+  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 +3813,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 +3821,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);
@@ -3636,26 +3964,41 @@ function scopePort(statements) {
 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;
+      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;
     statementsById[n.id] = compileNodeStatements(n, dialect);
   }
+  const outTypes = resolveColumnType !== void 0 ? deriveReadOutTypes(component, resolveColumnType) : void 0;
   const surrogateBody = component.body.map((n) => {
     if ("cond" in n) return n;
     const stmts = statementsById[n.id];
+    const outType = outTypes?.byNode.get(n.id);
+    const outAnn = outType !== void 0 ? { outType } : {};
     if ("map" in n) {
-      return { ...n, map: { ...n.map, component: NODE_COMPONENT, ports: { [SCOPE_PORT]: scopePort(stmts) } } };
+      return { ...n, ...outAnn, map: { ...n.map, component: NODE_COMPONENT, ports: { [SCOPE_PORT]: scopePort(stmts) } } };
     }
-    return { ...n, component: NODE_COMPONENT, ports: { [SCOPE_PORT]: scopePort(stmts) } };
+    return { ...n, ...outAnn, component: NODE_COMPONENT, ports: { [SCOPE_PORT]: scopePort(stmts) } };
   });
-  const surrogate = { ...component, body: surrogateBody };
+  const surrogate = {
+    ...component,
+    body: surrogateBody,
+    ...outTypes !== void 0 ? { outputType: outTypes.outputType } : {}
+  };
   const ir = { irVersion: 1, exprVersion: 2, components: [surrogate] };
   return {
     dialect,
@@ -3860,7 +4203,8 @@ 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 = [];
@@ -4123,33 +4467,6 @@ 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) {
@@ -4402,6 +4719,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) {
@@ -4420,7 +4831,7 @@ function isWriteComponent(component) {
 function executeBehavior(contract, input, options) {
   return executeBundle(compileBundle(contract, options.entry, options.relations, options.dialect), 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 = {};
@@ -4432,7 +4843,7 @@ function compileBundle(contract, entry2, relations = [], dialectName = "sqlite")
   }
   if (isWriteComponent(component)) {
     const writeNode = primaryNodeOf(component);
-    const op = compileWriteNode(writeNode);
+    const op = compileWriteNode(writeNode, dialectName);
     return {
       dialect: dialectName,
       name: component.name,
@@ -4441,7 +4852,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,
@@ -4490,7 +4901,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 +4909,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 +4920,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 +4934,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 +4952,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 +4962,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");
@@ -4604,9 +5021,19 @@ function readBundle(bundle, input, options) {
 // src/scp/codegen.ts
 import { generateModule } 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);
+  const ir = makeSqlComponentIR(bundle.name);
+  if (bundle.outputType === void 0) return ir;
+  const c = ir.components[0];
+  const body = c.body.map((n, i) => i === 0 ? { ...n, outType: bundle.outputType } : n);
+  const component = { ...c, body, outputType: bundle.outputType };
+  return { ...ir, components: [component] };
 }
 function companionOf(bundle) {
   const base = {
@@ -4614,27 +5041,172 @@ 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 SCOPE_PORT2 = "__scope";
+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;
+function deriveHeadTypesFromStatements(statements, resolveColumnType) {
+  const byHead = /* @__PURE__ */ new Map();
+  const unresolved = /* @__PURE__ */ new Map();
+  const head = statements[0];
+  const tableMatch = head === void 0 ? null : SELECT_FROM_TABLE.exec(head.sql);
+  const table = tableMatch?.[1];
+  for (const stmt of statements) {
+    if (stmt.whereFragment !== true) continue;
+    for (const param of stmt.params) {
+      const path = refPathOf(param);
+      if (path === void 0 || path.length !== 1) {
+        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);
+    }
+  }
+  return { byHead, 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 lowerReadGraphForTypedNative(readGraph, resolveColumnType) {
+  const ir = readGraph.ir;
+  const reasons = [];
+  const components2 = ir.components.map((c) => {
+    const inputPortTypes = /* @__PURE__ */ new Map();
+    const body = c.body.map((n) => {
+      if ("cond" in n) return n;
+      const isMapNode = "map" in n;
+      const ref = isMapNode ? n.map : n;
+      const scopeVal = ref.ports[SCOPE_PORT2];
+      if (scopeVal === void 0 || typeof scopeVal !== "object" || scopeVal === null || !("obj" in scopeVal)) {
+        return n;
+      }
+      const obj = scopeVal.obj;
+      const stmts = readGraph.statementsById[n.id] ?? [];
+      const { byHead, unresolved } = deriveHeadTypesFromStatements(stmts, resolveColumnType);
+      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);
+      }
+      const newPorts = {};
+      for (const head of Object.keys(obj)) {
+        if (!byHead.has(head) && !unresolved.has(head)) {
+          reasons.push(`node '${n.id}': input head '${head}' referenced by the surrogate scope but not resolved by any WHERE fragment \u2014 cannot type it for native codegen`);
+          continue;
+        }
+        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 };
+    }
+    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 isTypedNativeEmitter(emitter) {
+  return emitter.endsWith("-typed-native");
+}
+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 = isTypedNativeEmitter(emitter) ? lowerReadGraphForTypedNative(bundle.readGraph, resolveColumnType) : bundleToPortableIR(bundle);
+  const module = generateModule(ir, 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 +5239,7 @@ import {
 } from "behavior-contracts";
 export {
   CATALOG_NAMES,
+  CODEGEN_EMITTER,
   CODEGEN_LANGUAGES,
   ENTITY_ROOT,
   FindFilterLeakError,
@@ -4682,6 +5255,7 @@ export {
   SQLITE,
   SemanticBehavior2 as SemanticBehavior,
   SqlFailure,
+  TypedNativeCoverageError,
   WRITE_CATALOG_NAMES,
   WRITE_PORT_FAMILIES,
   add,
@@ -4693,13 +5267,13 @@ export {
   assertComponentsInCatalog,
   assertExprPortable,
   assertFindFilterFolded,
-  assertLanguageSupported,
   behavior,
   buildResultSet,
   builderFor,
   bundleToPortableIR,
   catalogEntry,
   coalesce,
+  codegenEmitterFor,
   codegenExecuteBundleForTest,
   compileAuthoredBehavior,
   compileAuthoredNode,
@@ -4764,6 +5338,7 @@ export {
   le2 as le,
   len,
   lifecycleFor,
+  lowerReadGraphForTypedNative,
   lt2 as lt,
   makeSqlCatalogEntry,
   makeSqlComponentIR,
@@ -4782,6 +5357,7 @@ export {
   opt,
   or,
   parseEffectPath,
+  parseSchemaColumnTypes,
   pgCastFormatter,
   pgPoolExecutor,
   publishBehaviors,
@@ -4794,9 +5370,12 @@ export {
   renderTxStatement,
   resolvePgArrayCast,
   runRelationOp,
+  schemaColumnTypeResolver,
+  sqlTypeToBcScalar,
   stripMysqlPkHint,
   sub,
   toDollarPlaceholders,
+  typedEmitterFor,
   when,
   whereBetween,
   whereCast,