litedbmodel 1.2.10 → 2.0.1

package/dist/scp/index.mjs

@@ -0,0 +1,4819 @@
+// src/scp/makesql/makesql.ts
+var MAKESQL = "makeSQL";
+function isMakeSQL(p) {
+  return typeof p === "object" && p !== null && typeof p.sql === "string" && Array.isArray(p.params);
+}
+var makeSqlCatalogEntry = {
+  name: MAKESQL,
+  inputPorts: {
+    sql: { type: "string", required: true },
+    params: { type: "arr" },
+    skip: { type: "bool" }
+  },
+  output: { shape: "items" },
+  portableToIR: true
+};
+var LITEDBMODEL_MAKESQL_CATALOG = {
+  [MAKESQL]: makeSqlCatalogEntry
+};
+function assembleMakeSQL(node) {
+  if (node.skip === true) return { sql: "", params: [] };
+  const chunks = node.sql.split("?");
+  if (chunks.length - 1 !== node.params.length) {
+    throw new Error(
+      `makeSQL placeholder/param mismatch: ${chunks.length - 1} '?' vs ${node.params.length} params in ${JSON.stringify(node.sql)}`
+    );
+  }
+  let sql2 = chunks[0];
+  const params = [];
+  for (let i = 0; i < node.params.length; i++) {
+    const p = node.params[i];
+    if (isMakeSQL(p)) {
+      const inner = assembleMakeSQL(p);
+      sql2 += inner.sql + chunks[i + 1];
+      params.push(...inner.params);
+    } else {
+      sql2 += "?" + chunks[i + 1];
+      params.push(p);
+    }
+  }
+  return { sql: sql2, params };
+}
+function composeMakeSQL(nodes) {
+  let sql2 = "";
+  const params = [];
+  for (const node of nodes) {
+    const r = assembleMakeSQL(node);
+    sql2 += r.sql;
+    params.push(...r.params);
+  }
+  return { sql: sql2, params };
+}
+
+// src/scp/makesql/handler.ts
+function renderPlaceholders(sql2, dialect) {
+  if (dialect !== "postgres") return sql2;
+  let out = "";
+  let index = 0;
+  let inString = false;
+  for (let i = 0; i < sql2.length; i++) {
+    const ch = sql2[i];
+    if (inString) {
+      out += ch;
+      if (ch === "'") inString = false;
+    } else if (ch === "'") {
+      out += ch;
+      inString = true;
+    } else if (ch === "?") {
+      out += `$${++index}`;
+    } else {
+      out += ch;
+    }
+  }
+  return out;
+}
+function toMakeSQL(ports) {
+  return {
+    sql: ports.sql,
+    params: ports.params ?? [],
+    skip: ports.skip === true
+  };
+}
+function renderPorts(ports, dialect) {
+  const node = toMakeSQL(ports);
+  const assembled = assembleMakeSQL(node);
+  return { sql: renderPlaceholders(assembled.sql, dialect), params: assembled.params };
+}
+function makeSqlHandler(exec, dialect) {
+  return async (ports, _ctx) => {
+    if (ports.skip === true) return { ok: [] };
+    const { sql: sql2, params } = renderPorts(ports, dialect);
+    const rows = await exec(sql2, params);
+    return { ok: rows };
+  };
+}
+function makeSqlHandlerSync(exec, dialect) {
+  return (ports, _ctx) => {
+    if (ports.skip === true) return { ok: [] };
+    const { sql: sql2, params } = renderPorts(ports, dialect);
+    const rows = exec(sql2, params);
+    return { ok: rows };
+  };
+}
+
+// src/DBValues.ts
+var DBToken = class {
+  value;
+  operator;
+  constructor(value, operator = "=") {
+    this.value = value;
+    this.operator = operator;
+  }
+  /**
+   * Compile the token to SQL fragment
+   * @param params - Parameter array to append values
+   * @param key - Column name (optional)
+   * @param _formatter - Optional formatter (used by DBCast subclasses)
+   * @returns SQL fragment
+   */
+  compile(params, key, _formatter) {
+    params.push(this.value);
+    if (key) {
+      return `${key} ${this.operator} ?`;
+    }
+    return "?";
+  }
+};
+var DBImmediateValue = class extends DBToken {
+  constructor(value) {
+    super(value, "=");
+  }
+  compile(_params, key) {
+    if (key) {
+      return `${key} ${this.operator} ${this.value}`;
+    }
+    return String(this.value);
+  }
+};
+var DBDynamicValue = class extends DBToken {
+  func;
+  values;
+  constructor(func, values = []) {
+    super(null, "=");
+    this.func = func;
+    this.values = values;
+  }
+  compile(params, key) {
+    for (const val of this.values) {
+      params.push(val);
+    }
+    if (key) {
+      return `${key} ${this.operator} ${this.func}`;
+    }
+    return this.func;
+  }
+};
+var DBTupleIn = class extends DBToken {
+  columns;
+  tuples;
+  constructor(columns, tuples) {
+    super(null, "IN");
+    this.columns = columns;
+    this.tuples = tuples;
+  }
+  compile(params, _key) {
+    if (this.tuples.length === 0) {
+      return "1 = 0";
+    }
+    const tuplePlaceholders = this.tuples.map((tuple) => {
+      const placeholders = tuple.map((val) => {
+        params.push(val);
+        return "?";
+      });
+      return `(${placeholders.join(", ")})`;
+    });
+    return `(${this.columns.join(", ")}) IN (${tuplePlaceholders.join(", ")})`;
+  }
+};
+function dbDynamic(func, values = []) {
+  return new DBDynamicValue(func, values);
+}
+function dbImmediate(value) {
+  return new DBImmediateValue(value);
+}
+var defaultFormatter = (placeholder, sqlType) => `${placeholder}::${sqlType}`;
+var DBCast = class extends DBToken {
+  /** The SQL type to cast to (e.g., 'uuid', 'jsonb', 'text[]') */
+  sqlType;
+  constructor(value, sqlType, operator = "=") {
+    super(value, operator);
+    this.sqlType = sqlType;
+  }
+  /**
+   * Compile to SQL fragment with type cast
+   * @param params - Parameter array to append values
+   * @param key - Column name (optional)
+   * @param formatter - Optional function to format placeholder with cast (driver-specific)
+   */
+  compile(params, key, formatter) {
+    params.push(this.value);
+    const format = formatter ?? defaultFormatter;
+    const placeholder = format("?", this.sqlType);
+    if (key) {
+      return `${key} ${this.operator} ${placeholder}`;
+    }
+    return placeholder;
+  }
+};
+var DBCastArray = class extends DBToken {
+  /** The SQL type to cast to */
+  sqlType;
+  constructor(values, sqlType) {
+    super(values, "IN");
+    this.sqlType = sqlType;
+  }
+  /**
+   * Compile to SQL fragment
+   * @param params - Parameter array to append values
+   * @param key - Column name (optional)
+   * @param formatter - Optional function to format placeholder with cast (driver-specific)
+   */
+  compile(params, key, formatter) {
+    const arr = this.value;
+    if (arr.length === 0) {
+      return "1 = 0";
+    }
+    const format = formatter ?? defaultFormatter;
+    const placeholder = format("?", this.sqlType);
+    const placeholders = arr.map((v) => {
+      params.push(v);
+      return placeholder;
+    });
+    if (key) {
+      return `${key} IN (${placeholders.join(", ")})`;
+    }
+    return `(${placeholders.join(", ")})`;
+  }
+};
+function dbCast(value, sqlType, operator = "=") {
+  return new DBCast(value, sqlType, operator);
+}
+function dbTupleIn(columns, tuples) {
+  return new DBTupleIn(columns, tuples);
+}
+var DBParentRef = class extends DBToken {
+  /** The parent column name */
+  columnName;
+  /** The parent table name */
+  tableName;
+  constructor(column) {
+    super(null, "=");
+    this.columnName = column.columnName;
+    this.tableName = column.tableName;
+  }
+  /**
+   * Compile to SQL - returns table.column format
+   */
+  compile(_params, _key) {
+    return `${this.tableName}.${this.columnName}`;
+  }
+};
+var DBSubquery = class extends DBToken {
+  constructor(parentColumns, tableName, selectColumns, conditions, subqueryOperator = "IN") {
+    super(null, subqueryOperator);
+    this.parentColumns = parentColumns;
+    this.tableName = tableName;
+    this.selectColumns = selectColumns;
+    this.conditions = conditions;
+    this.subqueryOperator = subqueryOperator;
+  }
+  parentColumns;
+  tableName;
+  selectColumns;
+  conditions;
+  subqueryOperator;
+  /** Format column as table.column */
+  formatColumn(col) {
+    return `${col.tableName}.${col.columnName}`;
+  }
+  /**
+   * Compile to SQL with parameter binding
+   */
+  compile(params, _key) {
+    const whereParts = [];
+    for (const cond of this.conditions) {
+      const colRef = this.formatColumn(cond.column);
+      if (cond.value instanceof DBParentRef) {
+        whereParts.push(`${colRef} = ${cond.value.compile(params)}`);
+      } else if (cond.value instanceof DBToken) {
+        whereParts.push(cond.value.compile(params, colRef));
+      } else if (cond.value === null) {
+        whereParts.push(`${colRef} IS NULL`);
+      } else if (Array.isArray(cond.value)) {
+        if (cond.value.length === 0) {
+          whereParts.push("1 = 0");
+        } else {
+          const placeholders = cond.value.map((v) => {
+            params.push(v);
+            return "?";
+          });
+          whereParts.push(`${colRef} IN (${placeholders.join(", ")})`);
+        }
+      } else {
+        params.push(cond.value);
+        whereParts.push(`${colRef} = ?`);
+      }
+    }
+    const whereClause2 = whereParts.length > 0 ? ` WHERE ${whereParts.join(" AND ")}` : "";
+    const selectClause = this.selectColumns.map((c) => this.formatColumn(c)).join(", ");
+    const subquery = `SELECT ${selectClause} FROM ${this.tableName}${whereClause2}`;
+    if (this.parentColumns.length === 1) {
+      return `${this.formatColumn(this.parentColumns[0])} ${this.subqueryOperator} (${subquery})`;
+    } else {
+      const parentColList = this.parentColumns.map((c) => this.formatColumn(c)).join(", ");
+      return `(${parentColList}) ${this.subqueryOperator} (${subquery})`;
+    }
+  }
+};
+var DBExists = class extends DBToken {
+  constructor(tableName, conditions, notExists = false) {
+    super(null, notExists ? "NOT EXISTS" : "EXISTS");
+    this.tableName = tableName;
+    this.conditions = conditions;
+    this.notExists = notExists;
+  }
+  tableName;
+  conditions;
+  notExists;
+  /** Format column as table.column */
+  formatColumn(col) {
+    return `${col.tableName}.${col.columnName}`;
+  }
+  /**
+   * Compile to SQL with parameter binding
+   */
+  compile(params, _key) {
+    const whereParts = [];
+    for (const cond of this.conditions) {
+      const colRef = this.formatColumn(cond.column);
+      if (cond.value instanceof DBParentRef) {
+        whereParts.push(`${colRef} = ${cond.value.compile(params)}`);
+      } else if (cond.value instanceof DBToken) {
+        whereParts.push(cond.value.compile(params, colRef));
+      } else if (cond.value === null) {
+        whereParts.push(`${colRef} IS NULL`);
+      } else if (Array.isArray(cond.value)) {
+        if (cond.value.length === 0) {
+          whereParts.push("1 = 0");
+        } else {
+          const placeholders = cond.value.map((v) => {
+            params.push(v);
+            return "?";
+          });
+          whereParts.push(`${colRef} IN (${placeholders.join(", ")})`);
+        }
+      } else {
+        params.push(cond.value);
+        whereParts.push(`${colRef} = ?`);
+      }
+    }
+    const whereClause2 = whereParts.length > 0 ? ` WHERE ${whereParts.join(" AND ")}` : "";
+    const subquery = `SELECT 1 FROM ${this.tableName}${whereClause2}`;
+    return `${this.operator} (${subquery})`;
+  }
+};
+
+// src/DBConditions.ts
+var DBConditions = class _DBConditions {
+  conditions;
+  operator;
+  nested;
+  constructor(conditions = {}, operator = "AND") {
+    this.conditions = conditions;
+    this.operator = operator;
+    this.nested = [];
+  }
+  /**
+   * Add conditions with specified operator
+   */
+  add(conditions, operator = "AND") {
+    if (conditions instanceof _DBConditions) {
+      this.nested.push({ conditions, operator });
+    } else {
+      const cond = new _DBConditions(conditions, operator);
+      this.nested.push({ conditions: cond, operator });
+    }
+    return this;
+  }
+  /**
+   * Compile conditions to SQL WHERE clause
+   * @param params - Parameter array to append values
+   * @param formatter - Optional SQL cast formatter (for driver-specific casting)
+   * @returns SQL WHERE clause (without 'WHERE' keyword)
+   */
+  compile(params, formatter) {
+    const parts = [];
+    for (const [key, value] of Object.entries(this.conditions)) {
+      const sql2 = this.compileCondition(key, value, params, formatter);
+      if (sql2) {
+        parts.push(sql2);
+      }
+    }
+    for (const nested of this.nested) {
+      const nestedSql = nested.conditions.compile(params, formatter);
+      if (nestedSql) {
+        parts.push(`(${nestedSql})`);
+      }
+    }
+    if (parts.length === 0) {
+      return "";
+    }
+    return parts.join(` ${this.operator} `);
+  }
+  /**
+   * Compile a single condition
+   */
+  compileCondition(key, value, params, formatter) {
+    if (key === "__or__" && Array.isArray(value)) {
+      const orParts = [];
+      for (const group of value) {
+        const groupCond = new _DBConditions(group, "AND");
+        const groupSql = groupCond.compile(params, formatter);
+        if (groupSql) {
+          orParts.push(`(${groupSql})`);
+        }
+      }
+      if (orParts.length > 0) {
+        return `(${orParts.join(" OR ")})`;
+      }
+      return "";
+    }
+    if (key === "__exists__" && value instanceof DBExists) {
+      return value.compile(params);
+    }
+    if (key === "__subquery__" && value instanceof DBSubquery) {
+      return value.compile(params);
+    }
+    if (key === "__raw__") {
+      if (typeof value === "string") {
+        return value;
+      }
+      if (Array.isArray(value)) {
+        if (value.length === 2 && typeof value[0] === "string" && Array.isArray(value[1])) {
+          const [sql2, rawParams] = value;
+          params.push(...rawParams);
+          return sql2;
+        }
+        const rawParts = value.filter((v) => typeof v === "string");
+        if (rawParts.length > 0) {
+          return rawParts.join(" AND ");
+        }
+      }
+      return "";
+    }
+    if (value instanceof DBToken) {
+      return value.compile(params, key, formatter);
+    }
+    if (key.startsWith("__")) {
+      if (value instanceof _DBConditions) {
+        return `(${value.compile(params, formatter)})`;
+      }
+      return "";
+    }
+    if (value instanceof _DBConditions) {
+      return `(${value.compile(params, formatter)})`;
+    }
+    if (value === null) {
+      return `${key} IS NULL`;
+    }
+    if (typeof value === "boolean") {
+      if (value && key.includes(" ")) {
+        return key;
+      }
+      return `${key} = ${value ? "TRUE" : "FALSE"}`;
+    }
+    if (Array.isArray(value)) {
+      if (key.includes("?")) {
+        return this.compileCustomOperator(key, value, params);
+      }
+      if (value.length === 0) {
+        return "1 = 0";
+      }
+      const placeholders = value.map((v) => {
+        params.push(v);
+        return "?";
+      });
+      return `${key} IN (${placeholders.join(", ")})`;
+    }
+    if (key.includes("?")) {
+      return this.compileCustomOperator(key, value, params);
+    }
+    params.push(value);
+    return `${key} = ?`;
+  }
+  /**
+   * Compile custom operator condition
+   * Key already contains ? placeholders, just push params in order
+   */
+  compileCustomOperator(key, value, params) {
+    if (Array.isArray(value)) {
+      for (const v of value) {
+        params.push(v);
+      }
+    } else {
+      params.push(value);
+    }
+    return key;
+  }
+  /**
+   * Check if conditions are empty
+   */
+  isEmpty() {
+    return Object.keys(this.conditions).length === 0 && this.nested.length === 0;
+  }
+  /**
+   * Get the raw conditions object
+   */
+  getConditions() {
+    return this.conditions;
+  }
+};
+
+// src/scp/makesql/json-array.ts
+function inListJson(dialect, col, values) {
+  if (dialect === "mysql") {
+    return {
+      sql: `${col} IN (SELECT JSON_UNQUOTE(v) FROM JSON_TABLE(?, '$[*]' COLUMNS(v JSON PATH '$')) jt)`,
+      // A BOOLEAN element serializes to `1`/`0` in the MySQL JSON param (NOT JSON `true`/`false`):
+      // `JSON_UNQUOTE(v)` on JSON `true` yields the STRING `'true'`, which MySQL coerces to `0`
+      // against a TINYINT(1) — silently mismatching. `1`/`0` is exactly what v1's `col IN (?)`
+      // bound (the mysql2 driver sends a JS bool as `1`/`0`), so this keeps v1 RESULT parity. SQL
+      // text + PG are untouched; SQLite's `json_each` coerces JSON booleans natively (no change).
+      param: JSON.stringify(values.map((v) => typeof v === "boolean" ? v ? 1 : 0 : v))
+    };
+  }
+  return { sql: `${col} IN (SELECT value FROM json_each(?))`, param: JSON.stringify(values) };
+}
+var JsonArrayConditions = class extends DBConditions {
+  _dialect;
+  constructor(conditions, dialect, operator = "AND") {
+    super(conditions, operator);
+    this._dialect = dialect;
+  }
+  compileCondition(key, value, params, formatter) {
+    if (Array.isArray(value) && value.length > 0 && !key.includes("?") && !key.startsWith("__") && !(value instanceof DBToken)) {
+      const { sql: sql2, param } = inListJson(this._dialect, key, value);
+      params.push(param);
+      return sql2;
+    }
+    return super.compileCondition(key, value, params, formatter);
+  }
+};
+function conditionsFor(conditions, dialect) {
+  if (dialect === "postgres") return new DBConditions(conditions);
+  return new JsonArrayConditions(conditions, dialect);
+}
+
+// src/scp/makesql/compile.ts
+var pgCastFormatter = (placeholder, sqlType) => `${placeholder}::${sqlType}`;
+var noCastFormatter = (placeholder) => placeholder;
+function formatterFor(dialect) {
+  return dialect === "postgres" ? pgCastFormatter : noCastFormatter;
+}
+function compileWhere(conditions, dialect) {
+  const params = [];
+  const formatter = formatterFor(dialect);
+  const core = conditionsFor(conditions, dialect).compile(params, formatter);
+  return { sql: core, params };
+}
+function whereClause(where) {
+  if (where.sql === "") return { sql: "", params: [] };
+  return { sql: ` WHERE ${where.sql}`, params: where.params };
+}
+function andTrailing(head, tails) {
+  const guardedTails = tails.map((t) => ({
+    sql: ` AND ${t.sql}`,
+    params: t.params,
+    ...t.skip !== void 0 ? { skip: t.skip } : {}
+  }));
+  return [head, ...guardedTails];
+}
+
+// src/SqlFragment.ts
+var SqlRaw = class {
+  constructor(value) {
+    this.value = value;
+  }
+  value;
+  _tag = "SqlRaw";
+  toString() {
+    return this.value;
+  }
+};
+var SqlRef = class {
+  _tag = "SqlRef";
+  tableName;
+  columnName;
+  constructor(column) {
+    this.tableName = column.tableName;
+    this.columnName = column.columnName;
+  }
+  toString() {
+    return `${this.tableName}.${this.columnName}`;
+  }
+};
+function isSqlFragment(value) {
+  return typeof value === "object" && value !== null && "_tag" in value && value._tag === "SqlFragment";
+}
+function isSqlTypedFragment(value) {
+  return typeof value === "object" && value !== null && "_tag" in value && value._tag === "SqlTypedFragment";
+}
+function isSqlCondition(value) {
+  return typeof value === "object" && value !== null && "_tag" in value && value._tag === "SqlCondition";
+}
+function isAnySqlFragment(value) {
+  return isSqlFragment(value) || isSqlTypedFragment(value) || isSqlCondition(value);
+}
+function isSqlRaw(value) {
+  return value instanceof SqlRaw;
+}
+function isSqlRef(value) {
+  return value instanceof SqlRef;
+}
+function hasTableName(value) {
+  return (typeof value === "object" || typeof value === "function") && value !== null && "TABLE_NAME" in value && typeof value.TABLE_NAME === "string" && !isColumn(value);
+}
+function isIdentifierLike(val) {
+  return isColumn(val) || hasTableName(val) || isSqlRaw(val) || isSqlRef(val) || val instanceof DBParentRef;
+}
+function processInterpolation(val, sqlParts, params) {
+  if (isColumn(val)) {
+    sqlParts.push(val.columnName);
+  } else if (hasTableName(val)) {
+    sqlParts.push(val.TABLE_NAME);
+  } else if (isSqlRaw(val)) {
+    sqlParts.push(val.value);
+  } else if (isSqlRef(val)) {
+    sqlParts.push(`${val.tableName}.${val.columnName}`);
+  } else if (val instanceof DBParentRef) {
+    sqlParts.push(`${val.tableName}.${val.columnName}`);
+  } else if (isAnySqlFragment(val)) {
+    sqlParts.push(val.sql);
+    if ("params" in val && Array.isArray(val.params)) {
+      params.push(...val.params);
+    }
+  } else if (Array.isArray(val)) {
+    if (val.length === 0) {
+      sqlParts.push("NULL");
+    } else {
+      const placeholders = val.map(() => "?");
+      for (const v of val) {
+        params.push(v);
+      }
+      sqlParts.push(placeholders.join(", "));
+    }
+  } else if (val === null || val === void 0) {
+    sqlParts.push("NULL");
+  } else {
+    params.push(val);
+    sqlParts.push("?");
+  }
+}
+function sql(strings, ...values) {
+  let firstColumn = null;
+  let columnCount = 0;
+  let valueCount = 0;
+  let otherIdentifierCount = 0;
+  for (const val of values) {
+    if (isColumn(val)) {
+      columnCount++;
+      if (!firstColumn) firstColumn = val;
+    } else if (isIdentifierLike(val)) {
+      otherIdentifierCount++;
+    } else if (isAnySqlFragment(val)) {
+      otherIdentifierCount++;
+    } else {
+      valueCount++;
+    }
+  }
+  const isConditionPattern = columnCount === 1 && otherIdentifierCount === 0 && isColumn(values[0]);
+  if (isConditionPattern && valueCount === 0 && values.length === 1) {
+    const col = values[0];
+    const sqlStr = strings[0] + col.columnName + strings[1];
+    return {
+      _tag: "SqlTypedFragment",
+      sql: sqlStr,
+      params: []
+    };
+  }
+  const sqlParts = [];
+  const params = [];
+  for (let i = 0; i < strings.length; i++) {
+    sqlParts.push(strings[i]);
+    if (i < values.length) {
+      processInterpolation(values[i], sqlParts, params);
+    }
+  }
+  const sqlString = sqlParts.join("");
+  if (isConditionPattern && valueCount > 0) {
+    return {
+      _tag: "SqlCondition",
+      sql: sqlString,
+      params
+    };
+  }
+  return {
+    _tag: "SqlFragment",
+    sql: sqlString,
+    params
+  };
+}
+sql.raw = function(value) {
+  return new SqlRaw(value);
+};
+sql.ref = function(column) {
+  return new SqlRef(column);
+};
+
+// src/Column.ts
+function orderToString(order) {
+  if (!order) return void 0;
+  if (typeof order === "string") return order;
+  if (Array.isArray(order)) {
+    return order.map((o) => o.toString()).join(", ");
+  }
+  return order.toString();
+}
+function isColumn(value) {
+  return typeof value === "function" && "_brand" in value && value._brand === "Column";
+}
+var SKIP = /* @__PURE__ */ Symbol.for("litedbmodel.SKIP");
+function isOrCond(cond) {
+  return typeof cond === "object" && cond !== null && "_type" in cond && cond._type === "or";
+}
+function condToKeyValue(cond) {
+  if (cond.length === 1) {
+    return [cond[0], true];
+  }
+  const [keyOrCol, value] = cond;
+  if (value === SKIP) {
+    return null;
+  }
+  if (Array.isArray(keyOrCol)) {
+    const columns = keyOrCol;
+    const tuples = value;
+    const columnNames = columns.map((col2) => col2.columnName);
+    return ["__tuple__", dbTupleIn(columnNames, tuples)];
+  }
+  if (isSqlTypedFragment(keyOrCol)) {
+    return [keyOrCol.sql, value];
+  }
+  if (typeof keyOrCol === "string") {
+    return [keyOrCol, value];
+  }
+  const col = keyOrCol;
+  const sqlCast = col.sqlCast;
+  if (value instanceof DBToken) {
+    return [col.columnName, value];
+  }
+  if (sqlCast) {
+    if (Array.isArray(value)) {
+      return [col.columnName, new DBCastArray(value, sqlCast)];
+    }
+    return [col.columnName, new DBCast(value, sqlCast, "=")];
+  }
+  return [col.columnName, value];
+}
+function sqlFragmentToKeyValue(frag) {
+  if (frag.params.length === 0) {
+    return [frag.sql, true];
+  }
+  if (frag.params.length === 1) {
+    return [frag.sql, frag.params[0]];
+  }
+  return [frag.sql, [...frag.params]];
+}
+function condsToRecord(conditions) {
+  const result = {};
+  for (const cond of conditions) {
+    if (cond === SKIP) {
+      continue;
+    }
+    if (isOrCond(cond)) {
+      const orGroups = cond.conditions.map((group) => condsToRecord(group));
+      result["__or__"] = orGroups;
+    } else if (isAnySqlFragment(cond)) {
+      const kv = sqlFragmentToKeyValue(cond);
+      if (kv !== null) {
+        const [key, value] = kv;
+        result[key] = value;
+      }
+    } else {
+      const kv = condToKeyValue(cond);
+      if (kv === null) continue;
+      const [key, value] = kv;
+      result[key] = value;
+    }
+  }
+  return result;
+}
+
+// src/scp/makesql/compile-select.ts
+function compileSelect(desc) {
+  const params = [];
+  const selectCols = desc.select ?? "*";
+  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);
+  const whereClause2 = conditionsFor(desc.conditions ?? {}, desc.dialect).compile(params, formatter);
+  let sql2 = "";
+  if (desc.cte) sql2 = `WITH ${desc.cte.name} AS (${desc.cte.sql}) `;
+  sql2 += `SELECT ${selectCols} FROM ${desc.tableName}`;
+  if (desc.join) sql2 += ` ${desc.join}`;
+  if (whereClause2) sql2 += ` WHERE ${whereClause2}`;
+  if (desc.group) sql2 += ` GROUP BY ${desc.group}`;
+  const orderClause = typeof desc.order === "string" ? desc.order : orderToString(desc.order);
+  if (orderClause) sql2 += ` ORDER BY ${orderClause}`;
+  if (desc.limit !== void 0) sql2 += ` LIMIT ${desc.limit}`;
+  if (desc.offset !== void 0) sql2 += ` OFFSET ${desc.offset}`;
+  if (desc.forUpdate) sql2 += " FOR UPDATE";
+  if (desc.append) sql2 += ` ${desc.append}`;
+  return { sql: sql2, params };
+}
+
+// src/TypeCast.ts
+function formatUTCDate(d) {
+  const y = d.getUTCFullYear();
+  const m = String(d.getUTCMonth() + 1).padStart(2, "0");
+  const day = String(d.getUTCDate()).padStart(2, "0");
+  return `${y}-${m}-${day}`;
+}
+
+// src/drivers/PostgresSqlBuilder.ts
+var postgresTypeCast = {
+  driverName: "postgres",
+  serializeArray(val) {
+    if (val === null || val === void 0) return null;
+    const escaped = val.map((v) => {
+      if (v === null) return "NULL";
+      if (typeof v === "string") {
+        const esc = v.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+        if (v.includes(",") || v.includes("{") || v.includes("}") || v.includes('"') || v.includes(" ")) {
+          return `"${esc}"`;
+        }
+        return esc;
+      }
+      return String(v);
+    });
+    return `{${escaped.join(",")}}`;
+  },
+  deserializeArray(val) {
+    if (val === null || val === void 0) return null;
+    if (Array.isArray(val)) return val;
+    return null;
+  },
+  serializeJson(val) {
+    if (val === null || val === void 0) return null;
+    return JSON.stringify(val);
+  },
+  deserializeJson(val) {
+    if (val === null || val === void 0) return null;
+    if (typeof val === "object") return val;
+    if (typeof val === "string") {
+      try {
+        return JSON.parse(val);
+      } catch {
+        return null;
+      }
+    }
+    return null;
+  },
+  serializeBooleanArray(val) {
+    if (val === null || val === void 0) return null;
+    const mapped = val.map((v) => v === null ? "NULL" : v ? "t" : "f");
+    return `{${mapped.join(",")}}`;
+  },
+  deserializeBooleanArray(val) {
+    if (val === null || val === void 0) return null;
+    if (Array.isArray(val)) return val;
+    return null;
+  },
+  /**
+   * PostgreSQL: serialize to ISO 8601 UTC string for explicit timezone handling
+   * This ensures TIMESTAMP WITH TIME ZONE stores the correct UTC moment
+   */
+  serializeDatetime(val) {
+    return val.toISOString();
+  },
+  /**
+   * PostgreSQL: serialize to UTC date string (YYYY-MM-DD)
+   * Uses UTC components to avoid timezone-related date shifts
+   */
+  serializeDate(val) {
+    return formatUTCDate(val);
+  }
+};
+function getArrayElementType(arrayType) {
+  if (!arrayType.endsWith("[]")) return arrayType;
+  return arrayType.slice(0, -2);
+}
+function buildJsonToTypeExpr(colRef, pgType) {
+  if (pgType === "jsonb" || pgType === "json") {
+    return `${colRef}::${pgType}`;
+  }
+  if (pgType.endsWith("[]")) {
+    const elemType = getArrayElementType(pgType);
+    return `CASE WHEN ${colRef} IS NULL THEN NULL ELSE COALESCE((SELECT array_agg(elem::${elemType}) FROM jsonb_array_elements_text(${colRef}::jsonb) AS elem), ARRAY[]::${pgType}) END`;
+  }
+  return colRef;
+}
+function inferPgType(val) {
+  if (val === null || val === void 0) return "text";
+  if (typeof val === "number") {
+    return Number.isInteger(val) ? "int" : "numeric";
+  }
+  if (typeof val === "bigint") return "bigint";
+  if (typeof val === "boolean") return "boolean";
+  if (typeof val === "string") return "text";
+  if (val instanceof Date) return "timestamp";
+  if (Array.isArray(val)) {
+    if (val.length === 0) return "text[]";
+    const first = val.find((v) => v !== null && v !== void 0);
+    if (first === void 0) return "text[]";
+    if (typeof first === "number") {
+      return Number.isInteger(first) ? "int[]" : "numeric[]";
+    }
+    if (typeof first === "boolean") return "boolean[]";
+    if (typeof first === "string") return "text[]";
+    if (first instanceof Date) return "timestamp[]";
+    return "jsonb";
+  }
+  if (typeof val === "object") return "jsonb";
+  return "text";
+}
+var postgresSqlBuilder = {
+  driverType: "postgres",
+  typeCast: postgresTypeCast,
+  supportsReturning: true,
+  buildInsert(options) {
+    const {
+      tableName,
+      columns,
+      records,
+      rawRecords,
+      sqlCastMap = /* @__PURE__ */ new Map(),
+      onConflict,
+      onConflictIgnore,
+      onConflictUpdate,
+      returning
+    } = options;
+    const params = [];
+    if (records.length > 1) {
+      const unnestArrays = [];
+      const selectExprs = [];
+      let hasDBToken = false;
+      for (const col of columns) {
+        const sqlCast = sqlCastMap.get(col);
+        let pgType = sqlCast;
+        if (!pgType && rawRecords) {
+          for (const r of rawRecords) {
+            const val = r[col];
+            if (val !== null && val !== void 0 && !(val instanceof DBToken)) {
+              pgType = inferPgType(val);
+              break;
+            }
+          }
+        }
+        pgType = pgType || "text";
+        const isArrayType = pgType.endsWith("[]") && pgType !== "jsonb" && pgType !== "json";
+        const isJsonType = pgType === "jsonb" || pgType === "json";
+        const colValues = records.map((r, idx) => {
+          const serializedVal = r[col];
+          if (serializedVal instanceof DBToken) {
+            hasDBToken = true;
+            return serializedVal;
+          }
+          if (isArrayType) {
+            const rawVal = rawRecords?.[idx]?.[col];
+            if (rawVal === null || rawVal === void 0) return null;
+            return JSON.stringify(rawVal);
+          }
+          return serializedVal;
+        });
+        if (hasDBToken) break;
+        params.push(colValues);
+        if (isArrayType) {
+          unnestArrays.push(`?::text[]`);
+          selectExprs.push(buildJsonToTypeExpr(`v.${col}`, pgType));
+        } else if (isJsonType) {
+          unnestArrays.push(`?::text[]`);
+          selectExprs.push(`v.${col}::${pgType}`);
+        } else {
+          unnestArrays.push(`?::${pgType}[]`);
+          selectExprs.push(`v.${col}`);
+        }
+      }
+      if (!hasDBToken) {
+        let sql3 = `INSERT INTO ${tableName} (${columns.join(", ")}) SELECT ${selectExprs.join(", ")} FROM UNNEST(${unnestArrays.join(", ")}) AS v(${columns.join(", ")})`;
+        if (onConflict) {
+          sql3 += ` ON CONFLICT (${onConflict.join(", ")})`;
+          if (onConflictIgnore) {
+            sql3 += " DO NOTHING";
+          } else if (onConflictUpdate) {
+            const updateCols = onConflictUpdate === "all" ? columns : onConflictUpdate;
+            const updateClauses = updateCols.map((c) => `${c} = EXCLUDED.${c}`);
+            sql3 += ` DO UPDATE SET ${updateClauses.join(", ")}`;
+          }
+        }
+        if (returning) {
+          sql3 += ` RETURNING ${returning}`;
+        }
+        return { sql: sql3, params };
+      }
+      params.length = 0;
+    }
+    const valueRows = [];
+    for (const record of records) {
+      const rowValues = [];
+      for (const col of columns) {
+        const val = record[col];
+        if (val instanceof DBToken) {
+          rowValues.push(val.compile(params));
+        } else {
+          params.push(val);
+          const sqlCast = sqlCastMap.get(col);
+          if (sqlCast && sqlCast !== "timestamp" && sqlCast !== "date") {
+            rowValues.push(`?::${sqlCast}`);
+          } else {
+            rowValues.push("?");
+          }
+        }
+      }
+      valueRows.push(`(${rowValues.join(", ")})`);
+    }
+    let sql2 = `INSERT INTO ${tableName} (${columns.join(", ")}) VALUES ${valueRows.join(", ")}`;
+    if (onConflict) {
+      sql2 += ` ON CONFLICT (${onConflict.join(", ")})`;
+      if (onConflictIgnore) {
+        sql2 += " DO NOTHING";
+      } else if (onConflictUpdate) {
+        const updateCols = onConflictUpdate === "all" ? columns : onConflictUpdate;
+        const updateClauses = updateCols.map((c) => `${c} = EXCLUDED.${c}`);
+        sql2 += ` DO UPDATE SET ${updateClauses.join(", ")}`;
+      }
+    }
+    if (returning) {
+      sql2 += ` RETURNING ${returning}`;
+    }
+    return { sql: sql2, params };
+  },
+  buildUpdateMany(options) {
+    const {
+      tableName,
+      keyColumns,
+      updateColumns,
+      records,
+      rawRecords,
+      sqlCastMap = /* @__PURE__ */ new Map(),
+      skipMap = /* @__PURE__ */ new Map(),
+      returning
+    } = options;
+    const params = [];
+    const allColumns = [...keyColumns, ...updateColumns];
+    const skipColumnsNeeded = /* @__PURE__ */ new Set();
+    for (const skipSet of skipMap.values()) {
+      for (const col of skipSet) {
+        skipColumnsNeeded.add(col);
+      }
+    }
+    const unnestArrays = [];
+    const colTypes = /* @__PURE__ */ new Map();
+    for (const col of allColumns) {
+      const sqlCast = sqlCastMap.get(col);
+      let pgType = sqlCast;
+      if (!pgType && rawRecords) {
+        for (const r of rawRecords) {
+          const val = r[col];
+          if (val !== null && val !== void 0 && !(val instanceof DBToken)) {
+            pgType = inferPgType(val);
+            break;
+          }
+        }
+      }
+      pgType = pgType || "text";
+      colTypes.set(col, pgType);
+      const isArrayType = pgType.endsWith("[]") && pgType !== "jsonb" && pgType !== "json";
+      const isJsonType = pgType === "jsonb" || pgType === "json";
+      const colValues = records.map((r, idx) => {
+        if (skipMap.get(idx)?.has(col)) {
+          return null;
+        }
+        const serializedVal = r[col];
+        if (isArrayType) {
+          const rawVal = rawRecords?.[idx]?.[col];
+          if (rawVal === null || rawVal === void 0) return null;
+          return JSON.stringify(rawVal);
+        }
+        if (isJsonType && serializedVal !== null && serializedVal !== void 0) {
+          return typeof serializedVal === "string" ? serializedVal : JSON.stringify(serializedVal);
+        }
+        return serializedVal;
+      });
+      params.push(colValues);
+      if (isArrayType || isJsonType) {
+        unnestArrays.push(`?::text[]`);
+      } else {
+        const castType = pgType === "timestamp" ? "timestamptz" : pgType;
+        unnestArrays.push(`?::${castType}[]`);
+      }
+    }
+    const skipFlagCols = [];
+    for (const col of skipColumnsNeeded) {
+      skipFlagCols.push(`_skip_${col}`);
+      const flagValues = records.map((_, idx) => skipMap.get(idx)?.has(col) ?? false);
+      params.push(flagValues);
+      unnestArrays.push(`?::boolean[]`);
+    }
+    const setClauses = [];
+    for (const col of updateColumns) {
+      const pgType = colTypes.get(col);
+      const isArrayType = pgType.endsWith("[]") && pgType !== "jsonb" && pgType !== "json";
+      const isJsonType = pgType === "jsonb" || pgType === "json";
+      let valueExpr;
+      if (isArrayType) {
+        valueExpr = buildJsonToTypeExpr(`v.${col}`, pgType);
+      } else if (isJsonType) {
+        valueExpr = `v.${col}::${pgType}`;
+      } else {
+        valueExpr = `v.${col}`;
+      }
+      if (skipColumnsNeeded.has(col)) {
+        setClauses.push(`${col} = CASE WHEN v._skip_${col} THEN t.${col} ELSE ${valueExpr} END`);
+      } else {
+        setClauses.push(`${col} = ${valueExpr}`);
+      }
+    }
+    const whereConditions = keyColumns.map((col) => `t.${col} = v.${col}`);
+    const allUnnestCols = [...allColumns, ...skipFlagCols];
+    let sql2 = `UPDATE ${tableName} AS t SET ${setClauses.join(", ")} FROM UNNEST(${unnestArrays.join(", ")}) AS v(${allUnnestCols.join(", ")}) WHERE ${whereConditions.join(" AND ")}`;
+    if (returning) {
+      sql2 += ` RETURNING ${returning}`;
+    }
+    return { sql: sql2, params };
+  },
+  buildFindByPkeys(options) {
+    const { tableName, pkeyColumns, pkeyValues, selectColumn, sqlCastMap } = options;
+    const params = [];
+    if (pkeyColumns.length === 1) {
+      const colValues = pkeyValues.map((v) => v[0]);
+      params.push(colValues);
+      const sqlCast = sqlCastMap?.get(pkeyColumns[0]);
+      const pgType = sqlCast || inferPgType(colValues.find((v) => v !== null && v !== void 0));
+      const sql3 = `SELECT ${selectColumn} FROM ${tableName} WHERE ${pkeyColumns[0]} = ANY(?::${pgType}[])`;
+      return { sql: sql3, params };
+    }
+    const unnestArrays = [];
+    for (let i = 0; i < pkeyColumns.length; i++) {
+      const colValues = pkeyValues.map((v) => v[i]);
+      params.push(colValues);
+      const sqlCast = sqlCastMap?.get(pkeyColumns[i]);
+      const pgType = sqlCast || inferPgType(colValues.find((v) => v !== null && v !== void 0));
+      unnestArrays.push(`?::${pgType}[]`);
+    }
+    const sql2 = `SELECT ${selectColumn} FROM ${tableName} WHERE (${pkeyColumns.join(", ")}) IN (SELECT * FROM UNNEST(${unnestArrays.join(", ")}))`;
+    return { sql: sql2, params };
+  },
+  buildReturning(_tableName, columns, alias) {
+    const prefix = alias ? `${alias}.` : "";
+    return columns.map((col) => `${prefix}${col}`).join(", ");
+  },
+  inferPgType
+};
+
+// src/drivers/MysqlSqlBuilder.ts
+var mysqlTypeCast = {
+  driverName: "mysql",
+  serializeArray(val) {
+    if (val === null || val === void 0) return null;
+    return JSON.stringify(val);
+  },
+  deserializeArray(val) {
+    if (val === null || val === void 0) return null;
+    if (Array.isArray(val)) return val;
+    if (typeof val === "string") {
+      try {
+        const parsed = JSON.parse(val);
+        return Array.isArray(parsed) ? parsed : null;
+      } catch {
+        return null;
+      }
+    }
+    return null;
+  },
+  serializeJson(val) {
+    if (val === null || val === void 0) return null;
+    return JSON.stringify(val);
+  },
+  deserializeJson(val) {
+    if (val === null || val === void 0) return null;
+    if (typeof val === "object") return val;
+    if (typeof val === "string") {
+      try {
+        return JSON.parse(val);
+      } catch {
+        return null;
+      }
+    }
+    return null;
+  },
+  serializeBooleanArray(val) {
+    if (val === null || val === void 0) return null;
+    return JSON.stringify(val);
+  },
+  deserializeBooleanArray(val) {
+    if (val === null || val === void 0) return null;
+    if (Array.isArray(val)) return val;
+    if (typeof val === "string") {
+      try {
+        const parsed = JSON.parse(val);
+        return Array.isArray(parsed) ? parsed : null;
+      } catch {
+        return null;
+      }
+    }
+    return null;
+  },
+  /**
+   * MySQL: return Date object as-is, let mysql2 driver handle conversion
+   * Note: MySQL DATETIME has no timezone - values stored/retrieved in server timezone
+   */
+  serializeDatetime(val) {
+    return val;
+  },
+  /**
+   * MySQL: return Date object as-is, let mysql2 driver handle conversion
+   */
+  serializeDate(val) {
+    return val;
+  }
+};
+var mysqlSqlBuilder = {
+  driverType: "mysql",
+  typeCast: mysqlTypeCast,
+  supportsReturning: false,
+  buildInsert(options) {
+    const {
+      tableName,
+      columns,
+      records,
+      onConflict,
+      onConflictIgnore,
+      onConflictUpdate,
+      returning
+    } = options;
+    const params = [];
+    const valueRows = [];
+    for (const record of records) {
+      const rowValues = [];
+      for (const col of columns) {
+        const val = record[col];
+        if (val instanceof DBToken) {
+          rowValues.push(val.compile(params));
+        } else {
+          params.push(val);
+          rowValues.push("?");
+        }
+      }
+      valueRows.push(`(${rowValues.join(", ")})`);
+    }
+    let sql2;
+    if (onConflict) {
+      if (onConflictIgnore) {
+        sql2 = `INSERT IGNORE INTO ${tableName} (${columns.join(", ")}) VALUES ${valueRows.join(", ")}`;
+      } else if (onConflictUpdate) {
+        const updateCols = onConflictUpdate === "all" ? columns : onConflictUpdate;
+        const updateClauses = updateCols.map((c) => `${c} = VALUES(${c})`);
+        sql2 = `INSERT INTO ${tableName} (${columns.join(", ")}) VALUES ${valueRows.join(", ")} ON DUPLICATE KEY UPDATE ${updateClauses.join(", ")}`;
+      } else {
+        sql2 = `INSERT INTO ${tableName} (${columns.join(", ")}) VALUES ${valueRows.join(", ")}`;
+      }
+    } else {
+      sql2 = `INSERT INTO ${tableName} (${columns.join(", ")}) VALUES ${valueRows.join(", ")}`;
+    }
+    if (returning) {
+      sql2 += ` RETURNING ${returning}`;
+    }
+    return { sql: sql2, params };
+  },
+  buildUpdateMany(options) {
+    const {
+      tableName,
+      keyColumns,
+      updateColumns,
+      records,
+      skipMap = /* @__PURE__ */ new Map()
+    } = options;
+    const params = [];
+    const allColumns = [...keyColumns, ...updateColumns];
+    const skipColumnsNeeded = /* @__PURE__ */ new Set();
+    for (const skipSet of skipMap.values()) {
+      for (const col of skipSet) {
+        skipColumnsNeeded.add(col);
+      }
+    }
+    const valueRowDefs = [];
+    const allValueCols = [...allColumns];
+    for (const col of skipColumnsNeeded) {
+      allValueCols.push(`_skip_${col}`);
+    }
+    for (let i = 0; i < records.length; i++) {
+      const record = records[i];
+      const rowValues = [];
+      for (const col of allColumns) {
+        const val = record[col];
+        if (val instanceof DBToken) {
+          rowValues.push(val.compile(params));
+        } else {
+          params.push(val);
+          rowValues.push("?");
+        }
+      }
+      for (const col of skipColumnsNeeded) {
+        const isSkipped = skipMap.get(i)?.has(col) ?? false;
+        params.push(isSkipped);
+        rowValues.push("?");
+      }
+      valueRowDefs.push(`ROW(${rowValues.join(", ")})`);
+    }
+    const setClauses = [];
+    for (const col of updateColumns) {
+      if (skipColumnsNeeded.has(col)) {
+        setClauses.push(`t.${col} = IF(v._skip_${col}, t.${col}, v.${col})`);
+      } else {
+        setClauses.push(`t.${col} = v.${col}`);
+      }
+    }
+    const whereConditions = keyColumns.map((col) => `t.${col} = v.${col}`);
+    const sql2 = `UPDATE ${tableName} AS t JOIN (VALUES ${valueRowDefs.join(", ")}) AS v(${allValueCols.join(", ")}) ON ${whereConditions.join(" AND ")} SET ${setClauses.join(", ")}`;
+    return { sql: sql2, params };
+  },
+  buildSelectPkeys(options) {
+    const { tableName, pkeyColumns, keyColumns, keyValues } = options;
+    const params = [];
+    const whereConditions = keyColumns.map((col, i) => {
+      params.push(keyValues.map((kv) => kv[i]));
+      return `${col} IN (?)`;
+    });
+    const sql2 = `SELECT DISTINCT ${pkeyColumns.join(", ")} FROM ${tableName} WHERE ${whereConditions.join(" AND ")}`;
+    return { sql: sql2, params };
+  },
+  buildFindByPkeys(options) {
+    const { tableName, pkeyColumns, pkeyValues, selectColumn } = options;
+    const params = [];
+    if (pkeyColumns.length === 1) {
+      const placeholders = pkeyValues.map(() => "?").join(", ");
+      params.push(...pkeyValues.map((v) => v[0]));
+      const sql3 = `SELECT ${selectColumn} FROM ${tableName} WHERE ${pkeyColumns[0]} IN (${placeholders})`;
+      return { sql: sql3, params };
+    }
+    const rowPlaceholders = [];
+    for (const pkValueTuple of pkeyValues) {
+      const rowVals = pkValueTuple.map(() => "?").join(", ");
+      params.push(...pkValueTuple);
+      rowPlaceholders.push(`ROW(${rowVals})`);
+    }
+    const onConditions = pkeyColumns.map((col) => `t.${col} = v.${col}`).join(" AND ");
+    const selectCol = selectColumn === "*" ? "t.*" : selectColumn;
+    const sql2 = `SELECT ${selectCol} FROM ${tableName} AS t JOIN (VALUES ${rowPlaceholders.join(", ")}) AS v(${pkeyColumns.join(", ")}) ON ${onConditions}`;
+    return { sql: sql2, params };
+  },
+  buildReturning() {
+    return void 0;
+  }
+};
+
+// src/drivers/SqliteSqlBuilder.ts
+var sqliteTypeCast = {
+  driverName: "sqlite",
+  serializeArray(val) {
+    if (val === null || val === void 0) return null;
+    return JSON.stringify(val);
+  },
+  deserializeArray(val) {
+    if (val === null || val === void 0) return null;
+    if (Array.isArray(val)) return val;
+    if (typeof val === "string") {
+      try {
+        const parsed = JSON.parse(val);
+        return Array.isArray(parsed) ? parsed : null;
+      } catch {
+        return null;
+      }
+    }
+    return null;
+  },
+  serializeJson(val) {
+    if (val === null || val === void 0) return null;
+    return JSON.stringify(val);
+  },
+  deserializeJson(val) {
+    if (val === null || val === void 0) return null;
+    if (typeof val === "object") return val;
+    if (typeof val === "string") {
+      try {
+        return JSON.parse(val);
+      } catch {
+        return null;
+      }
+    }
+    return null;
+  },
+  serializeBooleanArray(val) {
+    if (val === null || val === void 0) return null;
+    return JSON.stringify(val);
+  },
+  deserializeBooleanArray(val) {
+    if (val === null || val === void 0) return null;
+    if (Array.isArray(val)) return val;
+    if (typeof val === "string") {
+      try {
+        const parsed = JSON.parse(val);
+        return Array.isArray(parsed) ? parsed : null;
+      } catch {
+        return null;
+      }
+    }
+    return null;
+  },
+  /**
+   * SQLite: return Date object as-is, let better-sqlite3 driver handle conversion
+   * Note: SQLite stores as TEXT - values stored/retrieved in server timezone
+   */
+  serializeDatetime(val) {
+    return val;
+  },
+  /**
+   * SQLite: return Date object as-is, let better-sqlite3 driver handle conversion
+   */
+  serializeDate(val) {
+    return val;
+  }
+};
+var sqliteSqlBuilder = {
+  driverType: "sqlite",
+  typeCast: sqliteTypeCast,
+  supportsReturning: true,
+  buildInsert(options) {
+    const {
+      tableName,
+      columns,
+      records,
+      onConflict,
+      onConflictIgnore,
+      onConflictUpdate,
+      returning
+    } = options;
+    const params = [];
+    const valueRows = [];
+    for (const record of records) {
+      const rowValues = [];
+      for (const col of columns) {
+        const val = record[col];
+        if (val instanceof DBToken) {
+          rowValues.push(val.compile(params));
+        } else {
+          params.push(val);
+          rowValues.push("?");
+        }
+      }
+      valueRows.push(`(${rowValues.join(", ")})`);
+    }
+    let sql2;
+    if (onConflict) {
+      if (onConflictIgnore) {
+        sql2 = `INSERT OR IGNORE INTO ${tableName} (${columns.join(", ")}) VALUES ${valueRows.join(", ")}`;
+      } else if (onConflictUpdate) {
+        const updateCols = onConflictUpdate === "all" ? columns : onConflictUpdate;
+        const updateClauses = updateCols.map((c) => `${c} = excluded.${c}`);
+        sql2 = `INSERT INTO ${tableName} (${columns.join(", ")}) VALUES ${valueRows.join(", ")} ON CONFLICT (${onConflict.join(", ")}) DO UPDATE SET ${updateClauses.join(", ")}`;
+      } else {
+        sql2 = `INSERT INTO ${tableName} (${columns.join(", ")}) VALUES ${valueRows.join(", ")}`;
+      }
+    } else {
+      sql2 = `INSERT INTO ${tableName} (${columns.join(", ")}) VALUES ${valueRows.join(", ")}`;
+    }
+    if (returning) {
+      sql2 += ` RETURNING ${returning}`;
+    }
+    return { sql: sql2, params };
+  },
+  buildUpdateMany(options) {
+    const {
+      tableName,
+      keyColumns,
+      updateColumns,
+      records,
+      skipMap = /* @__PURE__ */ new Map(),
+      returning
+    } = options;
+    const params = [];
+    const setClauses = [];
+    const keyValues = records.map((r) => keyColumns.map((k) => r[k]));
+    for (const col of updateColumns) {
+      const whenClauses = [];
+      for (let i = 0; i < records.length; i++) {
+        const record = records[i];
+        const isSkipped = skipMap.get(i)?.has(col) ?? false;
+        const keyConditions = keyColumns.map((k) => {
+          params.push(record[k]);
+          return `${k} = ?`;
+        });
+        const keyCondition = keyConditions.length === 1 ? keyConditions[0] : `(${keyConditions.join(" AND ")})`;
+        if (isSkipped) {
+          whenClauses.push(`WHEN ${keyCondition} THEN ${tableName}.${col}`);
+        } else {
+          const val = record[col];
+          if (val instanceof DBToken) {
+            whenClauses.push(`WHEN ${keyCondition} THEN ${val.compile(params)}`);
+          } else {
+            params.push(val);
+            whenClauses.push(`WHEN ${keyCondition} THEN ?`);
+          }
+        }
+      }
+      setClauses.push(`${col} = CASE ${whenClauses.join(" ")} END`);
+    }
+    let whereClause2;
+    if (keyColumns.length === 1) {
+      const keyCol = keyColumns[0];
+      const placeholders = keyValues.map(() => "?");
+      whereClause2 = `${keyCol} IN (${placeholders.join(", ")})`;
+      for (const kv of keyValues) {
+        params.push(kv[0]);
+      }
+    } else {
+      const tuples = keyValues.map(() => `(${keyColumns.map(() => "?").join(", ")})`);
+      whereClause2 = `(${keyColumns.join(", ")}) IN (${tuples.join(", ")})`;
+      for (const kv of keyValues) {
+        params.push(...kv);
+      }
+    }
+    let sql2 = `UPDATE ${tableName} SET ${setClauses.join(", ")} WHERE ${whereClause2}`;
+    if (returning) {
+      sql2 += ` RETURNING ${returning}`;
+    }
+    return { sql: sql2, params };
+  },
+  buildFindByPkeys(options) {
+    const { tableName, pkeyColumns, pkeyValues, selectColumn } = options;
+    const params = [];
+    if (pkeyColumns.length === 1) {
+      const placeholders = pkeyValues.map(() => "?").join(", ");
+      params.push(...pkeyValues.map((v) => v[0]));
+      const sql3 = `SELECT ${selectColumn} FROM ${tableName} WHERE ${pkeyColumns[0]} IN (${placeholders})`;
+      return { sql: sql3, params };
+    }
+    const rowPlaceholders = [];
+    for (const pkValueTuple of pkeyValues) {
+      const rowVals = pkValueTuple.map(() => "?").join(", ");
+      params.push(...pkValueTuple);
+      rowPlaceholders.push(`(${rowVals})`);
+    }
+    const onConditions = pkeyColumns.map((col) => `t.${col} = v.${col}`).join(" AND ");
+    const selectCol = selectColumn === "*" ? "t.*" : selectColumn;
+    const sql2 = `WITH v(${pkeyColumns.join(", ")}) AS (VALUES ${rowPlaceholders.join(", ")}) SELECT ${selectCol} FROM ${tableName} AS t JOIN v ON ${onConditions}`;
+    return { sql: sql2, params };
+  },
+  buildReturning(tableName, columns) {
+    return columns.map((col) => `${tableName}.${col}`).join(", ");
+  }
+};
+
+// src/scp/makesql/json-batch.ts
+function rowsHaveDbToken(rows, columns) {
+  for (const r of rows) {
+    for (const c of columns) {
+      if (r[c] instanceof DBToken) return true;
+    }
+  }
+  return false;
+}
+function mysqlJsonTableColumn(col, rows) {
+  let sample;
+  for (const r of rows) {
+    const v = r[col];
+    if (v !== null && v !== void 0) {
+      sample = v;
+      break;
+    }
+  }
+  if (typeof sample === "boolean" || typeof sample === "bigint") {
+    return { colType: "BIGINT", selectExpr: (ref) => ref };
+  }
+  if (typeof sample === "number") {
+    return Number.isInteger(sample) ? { colType: "BIGINT", selectExpr: (ref) => ref } : { colType: "DECIMAL(65,30)", selectExpr: (ref) => ref };
+  }
+  if (sample !== null && typeof sample === "object") {
+    return { colType: "JSON", selectExpr: (ref) => ref };
+  }
+  return { colType: "JSON", selectExpr: (ref) => `JSON_UNQUOTE(${ref})` };
+}
+function rowsToJson(rows, columns) {
+  const objects = rows.map((r) => {
+    const o = {};
+    for (const c of columns) o[c] = r[c] === void 0 ? null : r[c];
+    return o;
+  });
+  return JSON.stringify(objects);
+}
+function mysqlInsertJson(opts) {
+  const { tableName, columns, records, onConflict, onConflictIgnore, onConflictUpdate, returning } = opts;
+  const jtCols = [];
+  const selectExprs = [];
+  for (const col of columns) {
+    const { colType, selectExpr } = mysqlJsonTableColumn(col, records);
+    jtCols.push(`${col} ${colType} PATH '$.${col}'`);
+    selectExprs.push(selectExpr(`jt.${col}`));
+  }
+  const jsonParam = rowsToJson(records, columns);
+  const source = `SELECT ${selectExprs.join(", ")} FROM JSON_TABLE(?, '$[*]' COLUMNS(${jtCols.join(", ")})) jt`;
+  let sql2;
+  if (onConflict && onConflictIgnore) {
+    sql2 = `INSERT IGNORE INTO ${tableName} (${columns.join(", ")}) ${source}`;
+  } else if (onConflict && onConflictUpdate) {
+    const updateCols = onConflictUpdate === "all" ? columns : onConflictUpdate;
+    const updateClauses = updateCols.map((c) => `${c} = VALUES(${c})`);
+    sql2 = `INSERT INTO ${tableName} (${columns.join(", ")}) ${source} ON DUPLICATE KEY UPDATE ${updateClauses.join(", ")}`;
+  } else {
+    sql2 = `INSERT INTO ${tableName} (${columns.join(", ")}) ${source}`;
+  }
+  if (returning) sql2 += ` RETURNING ${returning}`;
+  return { sql: sql2, params: [jsonParam] };
+}
+function sqliteInsertJson(opts) {
+  const { tableName, columns, records, onConflict, onConflictIgnore, onConflictUpdate, returning } = opts;
+  const selectExprs = columns.map((c) => `json_extract(value, '$.${c}')`);
+  const jsonParam = rowsToJson(records, columns);
+  const source = `SELECT ${selectExprs.join(", ")} FROM json_each(?)`;
+  let sql2;
+  if (onConflict && onConflictIgnore) {
+    sql2 = `INSERT OR IGNORE INTO ${tableName} (${columns.join(", ")}) ${source}`;
+  } 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(", ")}`;
+  } else {
+    sql2 = `INSERT INTO ${tableName} (${columns.join(", ")}) ${source}`;
+  }
+  if (returning) sql2 += ` RETURNING ${returning}`;
+  return { sql: sql2, params: [jsonParam] };
+}
+function mysqlUpdateManyJson(opts) {
+  const { tableName, keyColumns, updateColumns, records, skipMap = /* @__PURE__ */ new Map(), returning } = opts;
+  const allColumns = [...keyColumns, ...updateColumns];
+  const skipColumnsNeeded = /* @__PURE__ */ new Set();
+  for (const s of skipMap.values()) for (const c of s) skipColumnsNeeded.add(c);
+  const skipCols = [...skipColumnsNeeded];
+  const payload = records.map((r, i) => {
+    const o = {};
+    for (const c of allColumns) o[c] = r[c] === void 0 ? null : r[c];
+    for (const c of skipCols) o[`_skip_${c}`] = skipMap.get(i)?.has(c) ? 1 : 0;
+    return o;
+  });
+  const jsonParam = JSON.stringify(payload);
+  const jtCols = [];
+  const selectExprOf = /* @__PURE__ */ new Map();
+  for (const col of allColumns) {
+    const { colType, selectExpr } = mysqlJsonTableColumn(col, records);
+    jtCols.push(`${col} ${colType} PATH '$.${col}'`);
+    selectExprOf.set(col, selectExpr);
+  }
+  for (const c of skipCols) jtCols.push(`_skip_${c} BIGINT PATH '$._skip_${c}'`);
+  const setClauses = updateColumns.map((col) => {
+    const vExpr = selectExprOf.get(col)(`v.${col}`);
+    return skipColumnsNeeded.has(col) ? `u.${col} = IF(v._skip_${col}, u.${col}, ${vExpr})` : `u.${col} = ${vExpr}`;
+  });
+  const onConditions = keyColumns.map((k) => `u.${k} = ${selectExprOf.get(k)(`v.${k}`)}`);
+  let sql2 = `UPDATE ${tableName} AS u JOIN JSON_TABLE(?, '$[*]' COLUMNS(${jtCols.join(", ")})) AS v ON ${onConditions.join(" AND ")} SET ${setClauses.join(", ")}`;
+  if (returning) sql2 += ` RETURNING ${returning}`;
+  return { sql: sql2, params: [jsonParam] };
+}
+function sqliteUpdateManyJson(opts) {
+  const { tableName, keyColumns, updateColumns, records, skipMap = /* @__PURE__ */ new Map(), returning } = opts;
+  const allColumns = [...keyColumns, ...updateColumns];
+  const skipColumnsNeeded = /* @__PURE__ */ new Set();
+  for (const s of skipMap.values()) for (const c of s) skipColumnsNeeded.add(c);
+  const skipCols = [...skipColumnsNeeded];
+  const payload = records.map((r, i) => {
+    const o = {};
+    for (const c of allColumns) o[c] = r[c] === void 0 ? null : r[c];
+    for (const c of skipCols) o[`_skip_${c}`] = skipMap.get(i)?.has(c) ? 1 : 0;
+    return o;
+  });
+  const jsonParam = JSON.stringify(payload);
+  const params = [];
+  const keyMatch = keyColumns.map((k) => `json_extract(je.value, '$.${k}') = ${tableName}.${k}`).join(" AND ");
+  const setClauses = updateColumns.map((col) => {
+    params.push(jsonParam);
+    const valueExpr = skipColumnsNeeded.has(col) ? `CASE WHEN json_extract(je.value, '$._skip_${col}') THEN ${tableName}.${col} ELSE json_extract(je.value, '$.${col}') END` : `json_extract(je.value, '$.${col}')`;
+    return `${col} = (SELECT ${valueExpr} FROM json_each(?) je WHERE ${keyMatch} LIMIT 1)`;
+  });
+  let whereClause2;
+  if (keyColumns.length === 1) {
+    params.push(jsonParam);
+    whereClause2 = `${keyColumns[0]} IN (SELECT json_extract(value, '$.${keyColumns[0]}') FROM json_each(?))`;
+  } else {
+    params.push(jsonParam);
+    const match = keyColumns.map((k) => `json_extract(je.value, '$.${k}') = ${tableName}.${k}`).join(" AND ");
+    whereClause2 = `EXISTS (SELECT 1 FROM json_each(?) je WHERE ${match})`;
+  }
+  let sql2 = `UPDATE ${tableName} SET ${setClauses.join(", ")} WHERE ${whereClause2}`;
+  if (returning) sql2 += ` RETURNING ${returning}`;
+  return { sql: sql2, params };
+}
+
+// src/scp/makesql/compile-crud.ts
+function builderFor(dialect) {
+  switch (dialect) {
+    case "postgres":
+      return postgresSqlBuilder;
+    case "mysql":
+      return mysqlSqlBuilder;
+    case "sqlite":
+      return sqliteSqlBuilder;
+  }
+}
+function compileInsert(dialect, options) {
+  const { sql: sql2, params } = builderFor(dialect).buildInsert(options);
+  return { sql: sql2, params };
+}
+function compileInsertMany(dialect, options) {
+  const { records, rawRecords, tableName, sqlCastMap, onConflict, onConflictIgnore, onConflictUpdate, returning } = options;
+  const grouped = /* @__PURE__ */ new Map();
+  if (records.length === 1) {
+    const record = records[0];
+    const recordColumns = [];
+    for (const key of Object.keys(record)) {
+      const val = record[key];
+      if (val !== void 0 && !(val instanceof DBImmediateValue && val.value === "DEFAULT")) {
+        recordColumns.push(key);
+      }
+    }
+    recordColumns.sort();
+    grouped.set("_", { columns: recordColumns, records: [record], rawRecords: [rawRecords ? rawRecords[0] : record] });
+  } else {
+    for (let i = 0; i < records.length; i++) {
+      const record = records[i];
+      const recordColumns = [];
+      for (const key of Object.keys(record)) {
+        const val = record[key];
+        if (val !== void 0 && !(val instanceof DBImmediateValue && val.value === "DEFAULT")) {
+          recordColumns.push(key);
+        }
+      }
+      recordColumns.sort();
+      const patternKey = recordColumns.join(",");
+      if (!grouped.has(patternKey)) {
+        grouped.set(patternKey, { columns: recordColumns, records: [], rawRecords: [] });
+      }
+      const group = grouped.get(patternKey);
+      group.records.push(record);
+      group.rawRecords.push(rawRecords ? rawRecords[i] : record);
+    }
+  }
+  const components2 = [];
+  for (const { columns, records: groupRecords, rawRecords: groupRawRecords } of grouped.values()) {
+    if (dialect !== "postgres" && !rowsHaveDbToken(groupRecords, columns)) {
+      const jsonOpts = { tableName, columns, records: groupRecords, onConflict, onConflictIgnore, onConflictUpdate, returning };
+      components2.push(dialect === "mysql" ? mysqlInsertJson(jsonOpts) : sqliteInsertJson(jsonOpts));
+      continue;
+    }
+    components2.push(
+      compileInsert(dialect, {
+        tableName,
+        columns,
+        records: groupRecords,
+        rawRecords: groupRawRecords,
+        sqlCastMap,
+        onConflict,
+        onConflictIgnore,
+        onConflictUpdate,
+        returning
+      })
+    );
+  }
+  return components2;
+}
+function compileUpdateMany(dialect, options) {
+  if (dialect !== "postgres") {
+    const allCols = [...options.keyColumns, ...options.updateColumns];
+    if (!rowsHaveDbToken(options.records, allCols)) {
+      const jsonOpts = {
+        tableName: options.tableName,
+        keyColumns: options.keyColumns,
+        updateColumns: options.updateColumns,
+        records: options.records,
+        skipMap: options.skipMap,
+        returning: options.returning
+      };
+      return dialect === "mysql" ? mysqlUpdateManyJson(jsonOpts) : sqliteUpdateManyJson(jsonOpts);
+    }
+  }
+  const { sql: sql2, params } = builderFor(dialect).buildUpdateMany(options);
+  return { sql: sql2, params };
+}
+function compileUpdateSingle(opts) {
+  const params = [];
+  const formatter = opts.dialect === "postgres" ? formatterFor(opts.dialect) : void 0;
+  const sqlCastMap = opts.sqlCastMap ?? /* @__PURE__ */ new Map();
+  const setClauses = [];
+  for (const [col, val] of Object.entries(opts.serializedValues)) {
+    if (val instanceof DBToken) {
+      setClauses.push(`${col} = ${val.compile(params, void 0, formatter)}`);
+    } else {
+      params.push(val);
+      const sqlCast = sqlCastMap.get(col);
+      if (sqlCast && formatter && sqlCast !== "timestamp" && sqlCast !== "date") {
+        setClauses.push(`${col} = ${formatter("?", sqlCast)}`);
+      } else {
+        setClauses.push(`${col} = ?`);
+      }
+    }
+  }
+  const whereClause2 = conditionsFor(opts.conditions, opts.dialect).compile(params, formatter);
+  if (!whereClause2) throw new Error("UPDATE requires conditions");
+  let sql2 = `UPDATE ${opts.tableName} SET ${setClauses.join(", ")} WHERE ${whereClause2}`;
+  if (opts.returning) sql2 += ` RETURNING ${opts.returning}`;
+  return { sql: sql2, params };
+}
+function compileDelete(opts) {
+  const params = [];
+  const formatter = opts.dialect === "postgres" ? formatterFor(opts.dialect) : void 0;
+  const whereClause2 = conditionsFor(opts.conditions, opts.dialect).compile(params, formatter);
+  if (!whereClause2) throw new Error("DELETE requires conditions");
+  let sql2 = `DELETE FROM ${opts.tableName} WHERE ${whereClause2}`;
+  if (opts.returning) sql2 += ` RETURNING ${opts.returning}`;
+  return { sql: sql2, params };
+}
+function compileDeleteMany(opts) {
+  const { dialect, tableName, keyColumns, keys, returning } = opts;
+  if (keyColumns.length === 0) throw new Error("compileDeleteMany: keyColumns must be non-empty");
+  if (keys.length === 0) return [];
+  if (keyColumns.length === 1) {
+    const col = keyColumns[0];
+    const values = keys.map((k) => k[col]);
+    const conditions = { [col]: values };
+    return [compileDelete({ dialect, tableName, conditions, returning })];
+  }
+  const grouped = /* @__PURE__ */ new Map();
+  for (const key of keys) {
+    const present = keyColumns.filter((c) => key[c] !== void 0).sort();
+    const patternKey = present.join(",");
+    if (!grouped.has(patternKey)) grouped.set(patternKey, []);
+    grouped.get(patternKey).push(key);
+  }
+  const components2 = [];
+  for (const group of grouped.values()) {
+    const present = keyColumns.filter((c) => group[0][c] !== void 0);
+    const conditions = {};
+    for (const c of present) conditions[c] = group.map((k) => k[c]);
+    components2.push(compileDelete({ dialect, tableName, conditions, returning }));
+  }
+  return components2;
+}
+
+// src/scp/makesql/compile-relation.ts
+function inferPgArrayType(values, sqlCast) {
+  if (sqlCast) return `${sqlCast}[]`;
+  if (values.length === 0) return "text[]";
+  const sample = values[0];
+  if (typeof sample === "number") {
+    if (values.every((v) => Number.isInteger(v))) return "int[]";
+    return "numeric[]";
+  }
+  if (typeof sample === "bigint") return "bigint[]";
+  if (typeof sample === "boolean") return "boolean[]";
+  if (sample instanceof Date) return "timestamp[]";
+  return "text[]";
+}
+var PG_ARRAY_CAST_TOKEN = "@@PG_ARRAY_CAST@@";
+function resolvePgArrayCast(sql2, values) {
+  const at = sql2.indexOf(PG_ARRAY_CAST_TOKEN);
+  if (at < 0) return sql2;
+  return sql2.slice(0, at) + inferPgArrayType(values) + sql2.slice(at + PG_ARRAY_CAST_TOKEN.length);
+}
+function pgArrayCastType(values, sqlCast, defer) {
+  if (sqlCast) return `${sqlCast}[]`;
+  if (defer) return PG_ARRAY_CAST_TOKEN;
+  return inferPgArrayType(values);
+}
+function compileCompositeKeyStaticUnlimited(opts) {
+  const { tableName, targetKeys } = opts;
+  if (opts.dialect === "postgres") {
+    const unnestParams = targetKeys.map((k) => `?::${pgArrayCastType([], opts.sqlCastMap?.get(k), opts.deferPgArrayCast)}`).join(", ");
+    const unnestAlias = `_unnest_${tableName}`;
+    const columnAliases = targetKeys.map((k) => `_unnest_${tableName}_${k}`).join(", ");
+    const joinConditions = targetKeys.map((key) => `${tableName}.${key} = ${unnestAlias}._unnest_${tableName}_${key}`).join(" AND ");
+    const joinClause = `JOIN unnest(${unnestParams}) AS ${unnestAlias}(${columnAliases}) ON ${joinConditions}`;
+    return compileSelect({
+      dialect: opts.dialect,
+      tableName,
+      select: opts.select,
+      join: joinClause,
+      joinParams: targetKeys.map(() => [null]),
+      conditions: opts.conditions,
+      order: opts.order
+    });
+  }
+  const jsonSubquery = compositeJsonMembership(opts.dialect, tableName, targetKeys);
+  const conditions = { ...opts.conditions, __raw__: [jsonSubquery, [[null]]] };
+  return compileSelect({
+    dialect: opts.dialect,
+    tableName,
+    select: opts.select,
+    conditions,
+    order: opts.order
+  });
+}
+function compositeJsonMembership(dialect, tableName, targetKeys) {
+  if (dialect === "mysql") {
+    const cols = targetKeys.map((_, i) => `c${i}`);
+    const jtCols = cols.map((c, i) => `${c} JSON PATH '$[${i}]'`).join(", ");
+    const selectCols = cols.map((c) => `JSON_UNQUOTE(${c})`).join(", ");
+    const keyTuple = targetKeys.map((k) => `${tableName}.${k}`).join(", ");
+    return `(${keyTuple}) IN (SELECT ${selectCols} FROM JSON_TABLE(?, '$[*]' COLUMNS(${jtCols})) jt)`;
+  }
+  const match = targetKeys.map((k, i) => `json_extract(je.value, '$[${i}]') = ${tableName}.${k}`).join(" AND ");
+  return `EXISTS (SELECT 1 FROM json_each(?) je WHERE ${match})`;
+}
+function compileSingleKeyUnlimited(opts) {
+  if (opts.dialect === "postgres") {
+    const sqlCast = opts.sqlCastMap?.get(opts.targetKey);
+    const pgType = pgArrayCastType(opts.values, sqlCast, opts.deferPgArrayCast);
+    const conditions2 = {
+      __raw__: [`${opts.tableName}.${opts.targetKey} = ANY(?::${pgType})`, [opts.values]],
+      ...opts.conditions
+    };
+    return compileSelect({
+      dialect: opts.dialect,
+      tableName: opts.tableName,
+      select: opts.select,
+      conditions: conditions2,
+      order: opts.order
+    });
+  }
+  const conditions = { ...opts.conditions, [opts.targetKey]: opts.values };
+  return compileSelect({
+    dialect: opts.dialect,
+    tableName: opts.tableName,
+    select: opts.select,
+    conditions,
+    order: opts.order
+  });
+}
+function compileSingleKeyLimited(opts) {
+  if (opts.dialect === "postgres") {
+    const sqlCast = opts.sqlCastMap?.get(opts.targetKey);
+    const pgType = pgArrayCastType(opts.values, sqlCast, opts.deferPgArrayCast);
+    const lateralConditions = {
+      __raw__: `${opts.tableName}.${opts.targetKey} = _keys.key`,
+      ...opts.conditions
+    };
+    const inner = compileSelect({
+      dialect: opts.dialect,
+      tableName: opts.tableName,
+      conditions: lateralConditions,
+      order: opts.order,
+      limit: opts.limit
+    });
+    const sql2 = `SELECT ${opts.tableName}.* FROM unnest(?::${pgType}) AS _keys(key) CROSS JOIN LATERAL (${inner.sql}) ${opts.tableName}`;
+    return { sql: sql2, params: [opts.values, ...inner.params] };
+  }
+  const orderBy = opts.order || opts.targetKey;
+  const cteConditions = { [opts.targetKey]: opts.values, ...opts.conditions };
+  const cte = compileSelect({
+    dialect: opts.dialect,
+    tableName: opts.tableName,
+    select: `*, ROW_NUMBER() OVER (PARTITION BY ${opts.targetKey} ORDER BY ${orderBy}) AS _rn`,
+    conditions: cteConditions
+  });
+  return compileSelect({
+    dialect: opts.dialect,
+    tableName: "ranked",
+    conditions: { __raw__: `_rn <= ${opts.limit}` },
+    cte: { name: "ranked", sql: cte.sql, params: cte.params }
+  });
+}
+function transpose(targetKeys, tuples) {
+  return targetKeys.map((_, colIndex) => tuples.map((t) => t[colIndex]));
+}
+function compileCompositeKeyUnlimited(opts) {
+  const { tableName, targetKeys, tuples } = opts;
+  if (opts.dialect === "postgres") {
+    const columnArrays = transpose(targetKeys, tuples);
+    const unnestParams = columnArrays.map((arr, i) => `?::${inferPgArrayType(arr, opts.sqlCastMap?.get(targetKeys[i]))}`).join(", ");
+    const unnestAlias = `_unnest_${tableName}`;
+    const columnAliases = targetKeys.map((k) => `_unnest_${tableName}_${k}`).join(", ");
+    const joinConditions = targetKeys.map((key) => `${tableName}.${key} = ${unnestAlias}._unnest_${tableName}_${key}`).join(" AND ");
+    const joinClause = `JOIN unnest(${unnestParams}) AS ${unnestAlias}(${columnAliases}) ON ${joinConditions}`;
+    return compileSelect({
+      dialect: opts.dialect,
+      tableName,
+      select: opts.select,
+      join: joinClause,
+      joinParams: columnArrays,
+      conditions: opts.conditions,
+      order: opts.order
+    });
+  }
+  const tuplePlaceholders = tuples.map(() => `(${targetKeys.map(() => "?").join(", ")})`).join(", ");
+  const inClause = `(${targetKeys.join(", ")}) IN (${tuplePlaceholders})`;
+  const conditions = { ...opts.conditions, __raw__: [inClause, tuples.flat()] };
+  return compileSelect({
+    dialect: opts.dialect,
+    tableName,
+    select: opts.select,
+    conditions,
+    order: opts.order
+  });
+}
+function compileCompositeKeyLimited(opts) {
+  const { tableName, targetKeys, tuples, limit } = opts;
+  if (opts.dialect === "postgres") {
+    const columnArrays = transpose(targetKeys, tuples);
+    const unnestParams = columnArrays.map((arr, i) => `?::${inferPgArrayType(arr, opts.sqlCastMap?.get(targetKeys[i]))}`).join(", ");
+    const keyAliases = targetKeys.map((_, i) => `key${i}`).join(", ");
+    const keyConditions = targetKeys.map((key, i) => `${tableName}.${key} = _keys.key${i}`).join(" AND ");
+    const lateralConditions = { __raw__: keyConditions, ...opts.conditions };
+    const inner = compileSelect({
+      dialect: opts.dialect,
+      tableName,
+      conditions: lateralConditions,
+      order: opts.order,
+      limit
+    });
+    const sql2 = `SELECT ${tableName}.* FROM unnest(${unnestParams}) AS _keys(${keyAliases}) CROSS JOIN LATERAL (${inner.sql}) ${tableName}`;
+    return { sql: sql2, params: [...columnArrays, ...inner.params] };
+  }
+  const orderBy = opts.order || targetKeys.join(", ");
+  const partitionBy = targetKeys.join(", ");
+  const tuplePlaceholders = tuples.map(() => `(${targetKeys.map(() => "?").join(", ")})`).join(", ");
+  const inClause = `(${targetKeys.join(", ")}) IN (${tuplePlaceholders})`;
+  const cteParams = tuples.flat();
+  const cteConditions = { __raw__: [inClause, cteParams], ...opts.conditions };
+  const cte = compileSelect({
+    dialect: opts.dialect,
+    tableName,
+    select: `*, ROW_NUMBER() OVER (PARTITION BY ${partitionBy} ORDER BY ${orderBy}) AS _rn`,
+    conditions: cteConditions
+  });
+  return compileSelect({
+    dialect: opts.dialect,
+    tableName: "ranked",
+    conditions: { __raw__: `_rn <= ${limit}` },
+    cte: { name: "ranked", sql: cte.sql, params: cte.params }
+  });
+}
+function compileCompositeKeyStaticLimited(opts) {
+  const { tableName, targetKeys, limit } = opts;
+  if (opts.dialect === "postgres") {
+    const unnestParams = targetKeys.map((k) => `?::${pgArrayCastType([], opts.sqlCastMap?.get(k), opts.deferPgArrayCast)}`).join(", ");
+    const keyAliases = targetKeys.map((_, i) => `key${i}`).join(", ");
+    const keyConditions = targetKeys.map((key, i) => `${tableName}.${key} = _keys.key${i}`).join(" AND ");
+    const lateralConditions = { __raw__: keyConditions, ...opts.conditions };
+    const inner = compileSelect({
+      dialect: opts.dialect,
+      tableName,
+      conditions: lateralConditions,
+      order: opts.order,
+      limit
+    });
+    const sql2 = `SELECT ${tableName}.* FROM unnest(${unnestParams}) AS _keys(${keyAliases}) CROSS JOIN LATERAL (${inner.sql}) ${tableName}`;
+    return { sql: sql2, params: [...targetKeys.map(() => [null]), ...inner.params] };
+  }
+  const orderBy = opts.order || targetKeys.join(", ");
+  const partitionBy = targetKeys.join(", ");
+  const jsonSubquery = compositeJsonMembership(opts.dialect, tableName, targetKeys);
+  const cteConditions = { __raw__: [jsonSubquery, [[null]]], ...opts.conditions };
+  const cte = compileSelect({
+    dialect: opts.dialect,
+    tableName,
+    select: `*, ROW_NUMBER() OVER (PARTITION BY ${partitionBy} ORDER BY ${orderBy}) AS _rn`,
+    conditions: cteConditions
+  });
+  return compileSelect({
+    dialect: opts.dialect,
+    tableName: "ranked",
+    conditions: { __raw__: `_rn <= ${limit}` },
+    cte: { name: "ranked", sql: cte.sql, params: cte.params }
+  });
+}
+
+// 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";
+
+// src/scp/errors.ts
+var SqlFailure = class extends Error {
+  constructor(kind, policy, sqliteCode, message) {
+    super(message);
+    this.kind = kind;
+    this.policy = policy;
+    this.sqliteCode = sqliteCode;
+    this.name = "SqlFailure";
+  }
+  kind;
+  policy;
+  sqliteCode;
+};
+function isSqliteError(e) {
+  return typeof e === "object" && e !== null && typeof e.code === "string" && e.code.startsWith("SQLITE_");
+}
+function mapSqliteError(e) {
+  if (!isSqliteError(e)) {
+    const message2 = e instanceof Error ? e.message : String(e);
+    return new SqlFailure("driver_error", "fail", void 0, `non-SQLite driver error: ${message2}`);
+  }
+  const { code, message } = e;
+  const tagged = `[${code}] ${message}`;
+  if (code === "SQLITE_CONSTRAINT_FOREIGNKEY") {
+    return new SqlFailure("foreign_key_violation", "fail", code, tagged);
+  }
+  if (code.startsWith("SQLITE_CONSTRAINT")) {
+    return new SqlFailure("constraint_violation", "fail", code, tagged);
+  }
+  if (code === "SQLITE_BUSY" || code === "SQLITE_LOCKED") {
+    return new SqlFailure("retryable", "retry", code, tagged);
+  }
+  return new SqlFailure("driver_error", "fail", code, tagged);
+}
+
+// src/scp/writes.ts
+var ENTITY_ROOT = "__entity";
+var PATH_RE = /^\$\.(input|entity)\.([A-Za-z_][A-Za-z0-9_]*)$/;
+var REF_PATH_RE = /^\$\.ref\.([A-Za-z_][A-Za-z0-9_]*)\.([A-Za-z_][A-Za-z0-9_]*)$/;
+function parseEffectPath(value) {
+  const m = PATH_RE.exec(value);
+  if (m !== null) return { root: m[1], field: m[2] };
+  const r = REF_PATH_RE.exec(value);
+  if (r !== null) return { root: "ref", writeName: r[1], field: r[2] };
+  throw new Error(
+    `write-time relations: '${value}' is not a valid path-rooted value; use '$.input.<field>' (the Command input), '$.entity.<field>' (the sole written row), or '$.ref.<writeName>.<field>' (a named upstream write's RETURNING row).`
+  );
+}
+function assertPaths(map) {
+  for (const v of Object.values(map)) parseEffectPath(v);
+}
+var recorder = {
+  lifecycle(effects = {}) {
+    for (const r of effects.requires ?? []) assertPaths(r.keys);
+    if (effects.idempotency !== void 0) parseEffectPath(effects.idempotency.token);
+    for (const u of effects.unique ?? []) {
+      u.scope.forEach((p) => parseEffectPath(p));
+      u.fields.forEach((p) => parseEffectPath(p));
+    }
+    for (const d of effects.derive ?? []) assertPaths(d.keys);
+    for (const e of effects.edges ?? []) {
+      assertPaths(e.columns);
+      if (e.where !== void 0) assertPaths(e.where);
+    }
+    for (const em of effects.emits ?? []) assertPaths(em.payload);
+    return { effects: freezeEffects(effects) };
+  },
+  exists(table, keys) {
+    return { kind: "requires", table, keys };
+  },
+  unique(spec) {
+    return { kind: "unique", name: spec.name, guardTable: spec.guardTable, scope: spec.scope, fields: spec.fields };
+  },
+  increment(table, keys, attribute, amount) {
+    if (!Number.isFinite(amount)) {
+      throw new Error(`entityWrites: increment amount for '${table}.${attribute}' must be a finite number (got ${String(amount)})`);
+    }
+    return { kind: "derive", table, keys, attribute, amount };
+  },
+  edge(spec) {
+    if (spec.relation === "fk" && spec.where === void 0) {
+      throw new Error(`entityWrites: a 'fk' edge on '${spec.table}' requires a 'where' key map (the matched row's identity)`);
+    }
+    return {
+      kind: "edge",
+      relation: spec.relation,
+      action: spec.action,
+      table: spec.table,
+      columns: spec.columns,
+      ...spec.where !== void 0 ? { where: spec.where } : {}
+    };
+  },
+  event(name, outboxTable, payload) {
+    return { kind: "emit", name, outboxTable, payload };
+  },
+  idempotentBy(table, column, token) {
+    return { kind: "idempotency", table, column, token };
+  }
+};
+function freezeEffects(effects) {
+  const out = {};
+  if (effects.requires !== void 0) out.requires = effects.requires;
+  if (effects.idempotency !== void 0) out.idempotency = effects.idempotency;
+  if (effects.unique !== void 0) out.unique = effects.unique;
+  if (effects.derive !== void 0) out.derive = effects.derive;
+  if (effects.edges !== void 0) out.edges = effects.edges;
+  if (effects.emits !== void 0) out.emits = effects.emits;
+  return out;
+}
+function entityWrites(builder) {
+  const shape = builder(recorder);
+  if (shape.create === void 0 && shape.update === void 0 && shape.remove === void 0) {
+    throw new Error(
+      "entityWrites(...) must declare at least one lifecycle (`create` / `update` / `remove`)."
+    );
+  }
+  return {
+    ...shape.create !== void 0 ? { create: shape.create } : {},
+    ...shape.update !== void 0 ? { update: shape.update } : {},
+    ...shape.remove !== void 0 ? { remove: shape.remove } : {}
+  };
+}
+function edgeWrites(builder) {
+  const def = entityWrites(builder);
+  for (const phase of ["create", "update", "remove"]) {
+    const c = def[phase];
+    if (c === void 0) continue;
+    const e = c.effects;
+    if (e.requires !== void 0 || e.unique !== void 0 || e.derive !== void 0 || e.emits !== void 0 || e.idempotency !== void 0) {
+      throw new Error(
+        `edgeWrites: the '${phase}' lifecycle may declare ONLY 'edges' effects (an edge entity carries only edge writes; use entityWrites for a full save contract).`
+      );
+    }
+  }
+  return def;
+}
+function lifecycleFor(def, phase) {
+  return def[phase];
+}
+
+// src/scp/makesql/tx.ts
+function literalize(value) {
+  if (value === null || value === void 0) return null;
+  if (Array.isArray(value)) return { arr: value.map((e) => literalize(e)) };
+  if (typeof value === "object") {
+    const obj = {};
+    for (const [k, v] of Object.entries(value)) obj[k] = literalize(v);
+    return { obj };
+  }
+  return value;
+}
+function pathToRef(value) {
+  const p = parseEffectPath(value);
+  if (p.root === "input") return { ref: [p.field] };
+  if (p.root === "entity") return { ref: [ENTITY_ROOT, p.field] };
+  return { ref: [p.writeName, p.field] };
+}
+function guardInsert(dialect, table, columns, placeholders) {
+  const cols = `(${columns.join(", ")})`;
+  if (dialect === "mysql") return `INSERT IGNORE INTO ${table} ${cols} VALUES (${placeholders})`;
+  return `INSERT INTO ${table} ${cols} VALUES (${placeholders}) ON CONFLICT DO NOTHING`;
+}
+function makeIdGen() {
+  let n = 0;
+  return (role) => `tx_${role}_${n++}`;
+}
+function compileRequires(e, nextId) {
+  const cols = Object.keys(e.keys);
+  if (cols.length === 0) throw new Error(`write-plan: requires on '${e.table}' declares no keys`);
+  const whereSql = v1EqualityWhereText(cols);
+  const op = {
+    sql: `SELECT 1 FROM ${e.table} WHERE ${whereSql}`,
+    params: cols.map((c) => pathToRef(e.keys[c]))
+  };
+  return { id: nextId("requires"), role: "gate:requires", op, gate: "existsElseRollback", label: `requires ${e.table}` };
+}
+function compileIdempotency(e, nextId, dialect) {
+  const op = {
+    sql: guardInsert(dialect, e.table, [e.column], "?"),
+    params: [pathToRef(e.token)]
+  };
+  return { id: nextId("idem"), role: "gate:idempotency", op, gate: "insertedElseNoop", label: `idempotency ${e.table}` };
+}
+function compileUnique(e, nextId, dialect) {
+  const scopeCols = e.scope.map((_, i) => `s${i}`);
+  const fieldCols = e.fields.map((_, i) => `f${i}`);
+  const cols = ["name", ...scopeCols, ...fieldCols];
+  const placeholders = cols.map(() => "?").join(", ");
+  const params = [
+    e.name,
+    // literal discriminator (a closed-set string literal)
+    ...e.scope.map(pathToRef),
+    ...e.fields.map(pathToRef)
+  ];
+  const op = { sql: guardInsert(dialect, e.guardTable, cols, placeholders), params };
+  return { id: nextId("unique"), role: "gate:unique", op, gate: "insertedElseRollback", label: `unique ${e.name}` };
+}
+function compileDerive(e, nextId) {
+  const keyCols = Object.keys(e.keys);
+  if (keyCols.length === 0) throw new Error(`write-plan: derive on '${e.table}' declares no keys`);
+  const whereSql = v1EqualityWhereText(keyCols);
+  const op = {
+    sql: `UPDATE ${e.table} SET ${e.attribute} = ${e.attribute} + ? WHERE ${whereSql}`,
+    // SET amount is the first param (before the WHERE keys), matching the v1 param order.
+    params: [e.amount, ...keyCols.map((c) => pathToRef(e.keys[c]))]
+  };
+  return { id: nextId("derive"), role: "derive", op, label: `derive ${e.table}.${e.attribute}` };
+}
+function compileEdge(e, nextId) {
+  if (e.relation === "m2m") {
+    const cols = Object.keys(e.columns);
+    if (e.action === "set") {
+      const placeholders = cols.map(() => "?").join(", ");
+      const op3 = {
+        sql: `INSERT INTO ${e.table} (${cols.join(", ")}) VALUES (${placeholders})`,
+        params: cols.map((c) => pathToRef(e.columns[c]))
+      };
+      return { id: nextId("edge"), role: "edge", op: op3, label: `edge m2m link ${e.table}` };
+    }
+    const whereSql2 = v1EqualityWhereText(cols);
+    const op2 = {
+      sql: `DELETE FROM ${e.table} WHERE ${whereSql2}`,
+      params: cols.map((c) => pathToRef(e.columns[c]))
+    };
+    return { id: nextId("edge"), role: "edge", op: op2, label: `edge m2m unlink ${e.table}` };
+  }
+  const setCols = Object.keys(e.columns);
+  const whereCols = Object.keys(e.where);
+  const setClauses = setCols.map((c) => e.action === "set" ? `${c} = ?` : `${c} = NULL`);
+  const setParams = e.action === "set" ? setCols.map((c) => pathToRef(e.columns[c])) : [];
+  const whereSql = v1EqualityWhereText(whereCols);
+  const op = {
+    sql: `UPDATE ${e.table} SET ${setClauses.join(", ")} WHERE ${whereSql}`,
+    params: [...setParams, ...whereCols.map((c) => pathToRef(e.where[c]))]
+  };
+  return { id: nextId("edge"), role: "edge", op, label: `edge fk ${e.action} ${e.table}` };
+}
+function compileEmit(e, nextId) {
+  const payloadObj = {};
+  for (const [k, v] of Object.entries(e.payload)) payloadObj[k] = pathToRef(v);
+  const op = {
+    sql: `INSERT INTO ${e.outboxTable} (type, payload) VALUES (?, ?)`,
+    params: [e.name, { obj: payloadObj }]
+  };
+  return { id: nextId("emit"), role: "emit", op, label: `emit ${e.name}` };
+}
+var IN_SENTINEL = "@in";
+function stringPort(ports, name) {
+  const v = ports[name];
+  if (v === void 0) return void 0;
+  if (typeof v !== "string") throw new Error(`compileWriteNode: port '${name}' must be a literal string in the IR (got ${JSON.stringify(v)})`);
+  return v;
+}
+function collectFamily(ports, prefix) {
+  const out = {};
+  for (const k of Object.keys(ports)) {
+    if (k.startsWith(`${prefix}.`)) out[k.slice(prefix.length + 1)] = ports[k];
+  }
+  return out;
+}
+function opKey(node) {
+  if (node === null || typeof node !== "object" || Array.isArray(node)) return void 0;
+  const keys = Object.keys(node);
+  return keys.length === 1 ? keys[0] : void 0;
+}
+function columnOf(node, ctx) {
+  const op = opKey(node);
+  if (op !== "ref" && op !== "refOpt") throw new Error(`compileWriteNode: ${ctx}: the column operand must be a {ref:[\u2026]} path`);
+  const path = node[op];
+  if (!Array.isArray(path) || path.length === 0 || typeof path[path.length - 1] !== "string") {
+    throw new Error(`compileWriteNode: ${ctx}: column ref path must be a non-empty string path`);
+  }
+  return path[path.length - 1];
+}
+function binOperands(node, op, at) {
+  const args = node[op];
+  if (!Array.isArray(args) || args.length !== 2) throw new Error(`compileWriteNode: ${at}: '${op}' expects exactly 2 operands`);
+  return [args[0], args[1]];
+}
+var CMP_OPS = { lt: "<", le: "<=", gt: ">", ge: ">=", ne: "<>" };
+var PROBE = "__probe__";
+function v1ConditionText(conditions) {
+  const probe = [];
+  return new DBConditions(conditions).compile(probe);
+}
+function v1EqualityWhereText(columns) {
+  const conditions = {};
+  for (const c of columns) conditions[c] = PROBE;
+  return v1ConditionText(conditions);
+}
+function lowerWhereMember(node, at) {
+  const op = opKey(node);
+  if (op === void 0) throw new Error(`compileWriteNode: ${at}: a where member must be a single-operator Expression node`);
+  if (op === "eq") {
+    const [col, val] = binOperands(node, op, at);
+    const column = columnOf(col, at);
+    if (val === null) return { sql: v1ConditionText({ [column]: null }), params: [] };
+    return { sql: v1ConditionText({ [column]: PROBE }), params: [val] };
+  }
+  if (op in CMP_OPS) {
+    const [col, val] = binOperands(node, op, at);
+    const column = columnOf(col, at);
+    if (op === "ne" && val === null) return { sql: v1ConditionText({ [`${column} IS NOT NULL`]: true }), params: [] };
+    return { sql: v1ConditionText({ [`${column} ${CMP_OPS[op]} ?`]: PROBE }), params: [val] };
+  }
+  throw new Error(`compileWriteNode: ${at}: unsupported where operator '${op}' (write path supports eq/ne/lt/le/gt/ge)`);
+}
+function lowerWherePort(ports, at) {
+  const v = ports.where;
+  if (v === void 0) return { sql: "", params: [] };
+  if (typeof v !== "object" || v === null || !("arr" in v) || !Array.isArray(v.arr)) {
+    throw new Error(`compileWriteNode: ${at}: 'where' must be an {arr:[\u2026]} literal`);
+  }
+  const members = v.arr;
+  const parts = [];
+  const params = [];
+  members.forEach((m, i) => {
+    const f = lowerWhereMember(m, `${at}.where[${i}]`);
+    parts.push(f.sql);
+    params.push(...f.params);
+  });
+  return { sql: parts.join(" AND "), params };
+}
+function returningTail(ports) {
+  const r = stringPort(ports, "returning");
+  return r === void 0 ? "" : ` RETURNING ${r}`;
+}
+function pkPort(ports) {
+  const pk = stringPort(ports, "pk");
+  if (pk === void 0) return void 0;
+  const columns = pk.split(",").map((c) => c.trim()).filter((c) => c.length > 0);
+  if (columns.length === 0) return void 0;
+  const ai = stringPort(ports, "autoInc");
+  return { columns, autoInc: ai ?? null };
+}
+var MYSQL_PK_HINT_RE = /\s*\/\*scp:pk=[^*]*\*\//;
+function mysqlPkHint(op) {
+  if (op.pk === void 0) return op;
+  if (!/\breturning\b/i.test(op.sql)) return op;
+  const hint = ` /*scp:pk=${op.pk.columns.join(",")};ai=${op.pk.autoInc ?? ""}*/`;
+  return { ...op, sql: op.sql + hint };
+}
+function stripMysqlPkHint(sql2) {
+  return sql2.replace(MYSQL_PK_HINT_RE, "");
+}
+function compileWriteNode(node) {
+  const { component, ports } = node;
+  const table = stringPort(ports, "table");
+  if (table === void 0) throw new Error(`compileWriteNode: ${component} node requires a literal 'table' port`);
+  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 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 } : {} };
+    }
+    case "Update": {
+      const set = collectFamily(ports, "set");
+      const setCols = Object.keys(set);
+      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 sql2 = `UPDATE ${table} SET ${setClauses} WHERE ${where.sql}${returningTail(ports)}`;
+      return { sql: sql2, params: [...setCols.map((c) => set[c]), ...where.params] };
+    }
+    case "Delete": {
+      const where = lowerWherePort(ports, "Delete");
+      if (where.sql === "") throw new Error(`compileWriteNode: Delete requires a 'where' port`);
+      const sql2 = `DELETE FROM ${table} WHERE ${where.sql}${returningTail(ports)}`;
+      return { sql: sql2, params: where.params };
+    }
+    default:
+      throw new Error(`compileWriteNode: catalog component '${component}' has no write compile (SQL writes: Insert/Update/Delete)`);
+  }
+}
+function compileWriteGroup(base, lifecycle, nextId, dialect, seqRef) {
+  const e = lifecycle.effects;
+  const nodes = [];
+  const mk = (stmt, isGate) => {
+    const consumes = refHeadsOf(stmt).filter((h) => h !== ENTITY_ROOT && !isInputHead(h, stmt));
+    return { stmt, seq: seqRef.n++, consumes, produces: stmt.binds ?? null, isGate };
+  };
+  for (const r of e.requires ?? []) nodes.push(mk(compileRequires(r, nextId), true));
+  if (e.idempotency !== void 0) nodes.push(mk(compileIdempotency(e.idempotency, nextId, dialect), true));
+  for (const u of e.unique ?? []) nodes.push(mk(compileUnique(u, nextId, dialect), true));
+  const bodyId = nextId("body");
+  const bodyStmt = {
+    id: bodyId,
+    role: "body",
+    op: base.op,
+    label: base.label,
+    ...base.name !== void 0 ? { binds: base.name } : {}
+  };
+  nodes.push(mk(bodyStmt, false));
+  for (const d of e.derive ?? []) nodes.push(mk(compileDerive(d, nextId), false));
+  for (const ed of e.edges ?? []) nodes.push(mk(compileEdge(ed, nextId), false));
+  for (const em of e.emits ?? []) nodes.push(mk(compileEmit(em, nextId), false));
+  return { nodes, bodyId };
+}
+function topoOrder(nodes) {
+  const byName = /* @__PURE__ */ new Map();
+  for (const n of nodes) {
+    if (n.produces !== null) {
+      if (byName.has(n.produces)) {
+        throw new Error(`write-plan: two writes both bind the name '${n.produces}' \u2014 write names must be unique in a composite Command.`);
+      }
+      byName.set(n.produces, n);
+    }
+  }
+  const succ = /* @__PURE__ */ new Map();
+  const indeg = /* @__PURE__ */ new Map();
+  const nodeById = /* @__PURE__ */ new Map();
+  for (const n of nodes) {
+    nodeById.set(n.stmt.id, n);
+    succ.set(n.stmt.id, /* @__PURE__ */ new Set());
+    indeg.set(n.stmt.id, 0);
+  }
+  const addEdge = (fromId, toId) => {
+    if (fromId === toId) return;
+    const s = succ.get(fromId);
+    if (!s.has(toId)) {
+      s.add(toId);
+      indeg.set(toId, indeg.get(toId) + 1);
+    }
+  };
+  for (const n of nodes) {
+    for (const dep of n.consumes) {
+      const producer = byName.get(dep);
+      if (producer === void 0) {
+        throw new Error(
+          `write-plan: statement '${n.stmt.label}' references '$.ref.${dep}.*' but no write in this Command binds the name '${dep}' \u2014 a dangling write reference (fail-closed; no silent skip).`
+        );
+      }
+      addEdge(producer.stmt.id, n.stmt.id);
+    }
+  }
+  const gates = nodes.filter((n) => n.isGate);
+  const nonGates = nodes.filter((n) => !n.isGate);
+  for (const g of gates) for (const b of nonGates) addEdge(g.stmt.id, b.stmt.id);
+  const ordered = [];
+  const ready = nodes.filter((n) => indeg.get(n.stmt.id) === 0).sort((a, b) => a.seq - b.seq);
+  while (ready.length > 0) {
+    const n = ready.shift();
+    ordered.push(n.stmt);
+    for (const depId of succ.get(n.stmt.id)) {
+      indeg.set(depId, indeg.get(depId) - 1);
+      if (indeg.get(depId) === 0) {
+        const dn = nodeById.get(depId);
+        let lo = 0;
+        while (lo < ready.length && ready[lo].seq < dn.seq) lo++;
+        ready.splice(lo, 0, dn);
+      }
+    }
+  }
+  if (ordered.length !== nodes.length) {
+    const stuck = nodes.filter((n) => !ordered.includes(n.stmt)).map((n) => n.stmt.label);
+    throw new Error(
+      `write-plan: the write-time transaction DAG has a CYCLE (unresolvable ordering among [${stuck.join(", ")}]). This is either a mutual '$.ref' data dependency or a gate that depends on a body row (a gate cannot depend on a not-yet-written row). ESCALATE: the Command's write dependencies are contradictory \u2014 no order satisfies both the data dependencies and gate-first. (Fail-closed; the derivation never guesses an order.)`
+    );
+  }
+  return ordered;
+}
+function deriveTransactionPlan(phase, bases, lifecycle, dialect = "sqlite") {
+  if (bases.length === 0) {
+    throw new Error("write-plan: a Command must declare at least one base write (Insert/Update/Delete).");
+  }
+  const nextId = makeIdGen();
+  const seqRef = { n: 0 };
+  const composite = bases.length > 1;
+  const allNodes = [];
+  const bodyIds = [];
+  bases.forEach((base, i) => {
+    const lc = base.effects !== void 0 ? { effects: base.effects } : i === 0 ? lifecycle : { effects: {} };
+    const { nodes, bodyId } = compileWriteGroup(base, lc, nextId, dialect, seqRef);
+    allNodes.push(...nodes);
+    bodyIds.push(bodyId);
+  });
+  const statements = topoOrder(allNodes);
+  const soleBody = bases[0];
+  const soleBodyId = bodyIds[0];
+  const usesEntity = referencesHead(statements, ENTITY_ROOT);
+  const soleBodyReturns = /\breturning\b/i.test(soleBody.op.sql);
+  if (usesEntity && composite) {
+    throw new Error(
+      `write-plan: a composite (multi-write) Command uses '$.entity.*' \u2014 ambiguous which write it denotes. Address each write's row by name via '$.ref.<writeName>.<field>' (fail-closed).`
+    );
+  }
+  if (usesEntity && !soleBodyReturns) {
+    throw new Error(
+      `write-plan: a derive/edges/emits stage references '$.entity.*' but the body write ('${soleBody.label}') has no RETURNING clause \u2014 the written row cannot be exposed to later stages. Add a RETURNING to the base write (fail-closed; no absent-entity default).`
+    );
+  }
+  const entityFrom = usesEntity || !composite && soleBodyReturns ? soleBodyId : null;
+  for (const base of bases) {
+    if (base.name === void 0) continue;
+    if (referencesHead(statements, base.name) && !/\breturning\b/i.test(base.op.sql)) {
+      throw new Error(
+        `write-plan: write '${base.name}' is referenced as '$.ref.${base.name}.*' by a later statement but its op has no RETURNING clause \u2014 its row cannot be bound for downstream writes. Add a RETURNING to write '${base.name}' (fail-closed; no absent-row default).`
+      );
+    }
+  }
+  return { phase, entityFrom, statements, onIdempotentHit: "rollback" };
+}
+function deriveBatchPlan(phase, ops) {
+  if (ops.length === 0) {
+    throw new Error("write-plan: a batch write must declare at least one statement (createMany/updateMany/deleteMany produced none).");
+  }
+  const nextId = makeIdGen();
+  const statements = ops.map((op, i) => ({
+    id: nextId("body"),
+    role: "body",
+    op: { sql: op.sql, params: op.params.map((p) => literalize(p)) },
+    label: op.label ?? `batch[${i}]`
+  }));
+  return { phase, entityFrom: null, statements, onIdempotentHit: "rollback" };
+}
+function refHeadsOf(stmt) {
+  const heads = /* @__PURE__ */ new Set();
+  collectRefHeads(stmt.op.params, heads);
+  return [...heads];
+}
+function isInputHead(head, stmt) {
+  return refPathLengthFor(stmt.op.params, head) === 1;
+}
+function refPathLengthFor(node, head) {
+  let maxLen = 0;
+  const walk = (n) => {
+    if (n === null || typeof n !== "object") return;
+    if (Array.isArray(n)) {
+      for (const el of n) walk(el);
+      return;
+    }
+    const keys = Object.keys(n);
+    if (keys.length === 1 && keys[0] === "ref") {
+      const path = n.ref;
+      if (Array.isArray(path) && path[0] === head) maxLen = Math.max(maxLen, path.length);
+      return;
+    }
+    for (const k of keys) walk(n[k]);
+  };
+  walk(node);
+  return maxLen;
+}
+function referencesHead(statements, head) {
+  const heads = /* @__PURE__ */ new Set();
+  for (const s of statements) collectRefHeads(s.op.params, heads);
+  return heads.has(head);
+}
+function collectRefHeads(node, heads) {
+  if (node === null || typeof node !== "object") return;
+  if (Array.isArray(node)) {
+    for (const el of node) collectRefHeads(el, heads);
+    return;
+  }
+  const keys = Object.keys(node);
+  if (keys.length === 1 && keys[0] === "ref") {
+    const path = node.ref;
+    if (Array.isArray(path) && typeof path[0] === "string") heads.add(path[0]);
+    return;
+  }
+  for (const k of keys) collectRefHeads(node[k], heads);
+}
+function toDriverParam(v) {
+  if (typeof v === "bigint") {
+    if (v >= BigInt(Number.MIN_SAFE_INTEGER) && v <= BigInt(Number.MAX_SAFE_INTEGER)) return Number(v);
+    return v;
+  }
+  if (v !== null && typeof v === "object" && !Array.isArray(v)) return JSON.stringify(v);
+  return v;
+}
+function renderStatement(op, scope, dialect) {
+  const concrete = op.params.map((p) => evaluateExpression(p, scope));
+  const node = { sql: op.sql, params: concrete };
+  const assembled = assembleMakeSQL(node);
+  return { sql: renderPlaceholders(assembled.sql, dialect), params: assembled.params.map((p) => toDriverParam(p)) };
+}
+function execStatement(db, op, scope, dialect) {
+  const { sql: sql2, params } = renderStatement(op, scope, dialect);
+  const stmt = db.prepare(sql2);
+  const hasReturn = /\bselect\b/i.test(sql2.slice(0, 8)) || /\breturning\b/i.test(sql2);
+  if (hasReturn) {
+    const rows = stmt.all(...params);
+    return { rows, changes: rows.length };
+  }
+  const info = stmt.run(...params);
+  return { rows: [], changes: info.changes };
+}
+function gateShortCircuit(gate, result) {
+  switch (gate) {
+    case "existsElseRollback":
+      return result.rows.length === 0 ? "requires_absent" : null;
+    case "insertedElseRollback":
+      return result.changes === 0 ? "unique_collision" : null;
+    case "insertedElseNoop":
+      return result.changes === 0 ? "idempotent_duplicate" : null;
+  }
+}
+function executeTransaction(db, plan, input, dialect = "sqlite") {
+  db.prepare("BEGIN").run();
+  const executed = [];
+  const scope = { ...input };
+  let entity = null;
+  const isBatch = plan.entityFrom === null && plan.statements.every((s) => s.gate === void 0 && s.binds === void 0 && s.role === "body");
+  const returnedRows = [];
+  try {
+    for (const stmt of plan.statements) {
+      const result = execStatement(db, stmt.op, scope, dialect);
+      executed.push(stmt.id);
+      if (stmt.gate !== void 0) {
+        const reason = gateShortCircuit(stmt.gate, result);
+        if (reason !== null) {
+          db.prepare("ROLLBACK").run();
+          return { committed: false, shortCircuit: { statementId: stmt.id, reason }, entity: null, executed };
+        }
+      }
+      if (stmt.id === plan.entityFrom) {
+        entity = result.rows.length > 0 ? result.rows[0] : null;
+        if (entity !== null) scope[ENTITY_ROOT] = entity;
+      }
+      if (stmt.binds !== void 0 && result.rows.length > 0) {
+        scope[stmt.binds] = result.rows[0];
+      }
+      if (isBatch && stmt.role === "body" && result.rows.length > 0) returnedRows.push(result.rows);
+    }
+    db.prepare("COMMIT").run();
+    return { committed: true, entity, executed, ...returnedRows.length > 0 ? { returnedRows } : {} };
+  } catch (e) {
+    try {
+      db.prepare("ROLLBACK").run();
+    } catch {
+    }
+    throw mapSqliteError(e);
+  }
+}
+function countingDriver(db) {
+  const prepared = [];
+  const wrapped = {
+    prepare(sql2) {
+      prepared.push(sql2);
+      return db.prepare(sql2);
+    }
+  };
+  return { db: wrapped, prepared };
+}
+function renderTxStatement(op, scope, dialect = "sqlite") {
+  return renderStatement(op, scope, dialect);
+}
+
+// src/scp/makesql/authoring-compile.ts
+import { evaluateExpression as evaluateExpression2 } from "behavior-contracts";
+function isMap(n) {
+  return "map" in n;
+}
+function nodeRef(n) {
+  return isMap(n) ? { component: n.map.component, ports: n.map.ports } : { component: n.component, ports: n.ports };
+}
+function stringPort2(ports, name) {
+  const v = ports[name];
+  if (v === void 0) return void 0;
+  if (typeof v !== "string") {
+    throw new Error(`authoring-compile: port '${name}' must be a literal string in the IR (got ${JSON.stringify(v)})`);
+  }
+  return v;
+}
+function arrPort(ports, name) {
+  const v = ports[name];
+  if (v === void 0) return void 0;
+  if (typeof v === "object" && v !== null && "arr" in v && Array.isArray(v.arr)) {
+    return v.arr;
+  }
+  throw new Error(`authoring-compile: port '${name}' must be an {arr:[...]} literal in the IR (got ${JSON.stringify(v)})`);
+}
+function stringArrayPort(ports, name) {
+  const arr = arrPort(ports, name);
+  if (arr === void 0) return void 0;
+  return arr.map((e) => {
+    if (typeof e !== "string") throw new Error(`authoring-compile: '${name}' entries must be literal strings (got ${JSON.stringify(e)})`);
+    return e;
+  });
+}
+function opKey2(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 columnOf2(node, ctx) {
+  const op = opKey2(node);
+  if (op !== "ref" && op !== "refOpt") {
+    throw new Error(`authoring-compile: ${ctx}: the column operand must be a {ref:[...]} / {refOpt:[...]} path, got ${JSON.stringify(node)}`);
+  }
+  const path = node[op];
+  if (!Array.isArray(path) || path.length === 0 || typeof path[path.length - 1] !== "string") {
+    throw new Error(`authoring-compile: ${ctx}: column ref path must be a non-empty string path`);
+  }
+  return path[path.length - 1];
+}
+function inSentinelColumn(node) {
+  const op = opKey2(node);
+  if (op !== "ref" && op !== "refOpt") return void 0;
+  const path = node[op];
+  if (Array.isArray(path) && path.length >= 2 && path[0] === IN_SENTINEL && typeof path[path.length - 1] === "string") {
+    return path[path.length - 1];
+  }
+  return void 0;
+}
+function asInt(v) {
+  if (typeof v === "bigint") return Number(v);
+  if (typeof v === "number") return v;
+  throw new Error(`authoring-compile: limit/offset must evaluate to an integer, got ${JSON.stringify(v)}`);
+}
+function binOperands2(node, op, at) {
+  const args = node[op];
+  if (!Array.isArray(args) || args.length !== 2) {
+    throw new Error(`authoring-compile: ${at}: '${op}' expects exactly 2 operands`);
+  }
+  return [args[0], args[1]];
+}
+var CMP_OPS2 = { lt: "<", le: "<=", gt: ">", ge: ">=", ne: "<>" };
+function foldWhereMember(node, scope, into, at) {
+  const op = opKey2(node);
+  if (op === void 0) {
+    throw new Error(`authoring-compile: ${at}: a where member must be a single-operator Expression node, got ${JSON.stringify(node)}`);
+  }
+  if (op === "cond") {
+    const args = node.cond;
+    if (!Array.isArray(args) || args.length !== 3 || args[2] !== null) {
+      throw new Error(`authoring-compile: ${at}: a SKIP-optional condition must be {cond:[c, <member>, null]} (else = null)`);
+    }
+    const present = evaluateExpression2(args[0], scope);
+    if (present !== null && present !== false) foldWhereMember(args[1], scope, into, `${at}.cond.then`);
+    return;
+  }
+  if (op === "and") {
+    const args = node.and;
+    if (!Array.isArray(args) || args.length < 2) throw new Error(`authoring-compile: ${at}: 'and' group expects >= 2 members`);
+    args.forEach((m, i) => foldWhereMember(m, scope, into, `${at}.and[${i}]`));
+    return;
+  }
+  if (op === "or") {
+    const args = node.or;
+    if (!Array.isArray(args) || args.length < 2) throw new Error(`authoring-compile: ${at}: 'or' group expects >= 2 members`);
+    const branches = args.map((m, i) => {
+      const sub2 = {};
+      foldWhereMember(m, scope, sub2, `${at}.or[${i}]`);
+      return sub2;
+    });
+    const existing = into.__or__ ?? [];
+    into.__or__ = [...existing, ...branches];
+    return;
+  }
+  if (op === "eq") {
+    const [col, val] = binOperands2(node, op, at);
+    const inCol = inSentinelColumn(col);
+    if (inCol !== void 0) {
+      into[inCol] = evaluateExpression2(val, scope);
+      return;
+    }
+    const value = evaluateExpression2(val, scope);
+    into[columnOf2(col, at)] = value;
+    return;
+  }
+  if (op in CMP_OPS2) {
+    const [col, val] = binOperands2(node, op, at);
+    const column = columnOf2(col, at);
+    const value = evaluateExpression2(val, scope);
+    if (op === "ne" && value === null) {
+      into[`${column} IS NOT NULL`] = true;
+      return;
+    }
+    into[`${column} ${CMP_OPS2[op]} ?`] = value;
+    return;
+  }
+  throw new Error(`authoring-compile: ${at}: unsupported where operator '${op}' (supported: eq/ne/lt/le/gt/ge/and/or/cond; IN via ${IN_SENTINEL} column head; IS NULL via eq(col,null))`);
+}
+function foldWherePort(ports, scope, at) {
+  const arr = arrPort(ports, "where");
+  const conditions = {};
+  if (arr === void 0) return conditions;
+  arr.forEach((m, i) => foldWhereMember(m, scope, conditions, `${at}.where[${i}]`));
+  return conditions;
+}
+function collectFamily2(ports, prefix, scope) {
+  const out = {};
+  for (const k of Object.keys(ports)) {
+    if (k.startsWith(`${prefix}.`)) out[k.slice(prefix.length + 1)] = evaluateExpression2(ports[k], scope);
+  }
+  return out;
+}
+function compileAuthoredNode(node, scope, dialect) {
+  const { component, ports } = nodeRef(node);
+  const table = stringPort2(ports, "table");
+  if (table === void 0) throw new Error(`authoring-compile: ${component} node requires a literal 'table' port`);
+  const at = `${component}`;
+  switch (component) {
+    case "Select": {
+      const select = stringArrayPort(ports, "select");
+      const conditions = foldWherePort(ports, scope, at);
+      return compileSelect({
+        dialect,
+        tableName: table,
+        select: select ? select.join(", ") : void 0,
+        conditions,
+        order: stringPort2(ports, "order"),
+        group: stringPort2(ports, "group"),
+        limit: ports.limit !== void 0 ? asInt(evaluateExpression2(ports.limit, scope)) : void 0,
+        offset: ports.offset !== void 0 ? asInt(evaluateExpression2(ports.offset, scope)) : void 0
+      });
+    }
+    case "Insert": {
+      const values = collectFamily2(ports, "values", scope);
+      if (Object.keys(values).length === 0) throw new Error(`authoring-compile: Insert requires at least one 'values.<field>' port`);
+      const returning = stringPort2(ports, "returning");
+      const columns = Object.keys(values).sort();
+      return compileInsert(dialect, { tableName: table, columns, records: [values], returning });
+    }
+    case "Update": {
+      const set = collectFamily2(ports, "set", scope);
+      if (Object.keys(set).length === 0) throw new Error(`authoring-compile: Update requires at least one 'set.<field>' port`);
+      const conditions = foldWherePort(ports, scope, at);
+      return compileUpdateSingle({
+        dialect,
+        tableName: table,
+        serializedValues: set,
+        conditions,
+        returning: stringPort2(ports, "returning")
+      });
+    }
+    case "Delete": {
+      const conditions = foldWherePort(ports, scope, at);
+      return compileDelete({ dialect, tableName: table, conditions, returning: stringPort2(ports, "returning") });
+    }
+    default:
+      throw new Error(`authoring-compile: catalog component '${component}' has no makeSQL compile (SQL CRUD only: Select/Insert/Update/Delete)`);
+  }
+}
+function compileRelationMap(node, input, dialect, parentKey) {
+  const ports = node.map.ports;
+  const table = stringPort2(ports, "table");
+  if (table === void 0) throw new Error(`authoring-compile: relation map requires a literal 'table' port`);
+  const select = stringArrayPort(ports, "select");
+  const order = stringPort2(ports, "order");
+  const whereArr = arrPort(ports, "where") ?? [];
+  let targetKey;
+  const filters = {};
+  whereArr.forEach((m, i) => {
+    const op = opKey2(m);
+    if (op === "eq") {
+      const [col] = binOperands2(m, "eq", `relationMap.where[${i}]`);
+      const inCol = inSentinelColumn(col);
+      const name = inCol ?? columnOf2(col, `relationMap.where[${i}]`);
+      if (targetKey === void 0) {
+        targetKey = name;
+        return;
+      }
+    }
+    foldWhereMember(m, {}, filters, `relationMap.where[${i}]`);
+  });
+  if (targetKey === void 0) throw new Error(`authoring-compile: relation map 'where' must carry a key eq(...) member`);
+  const values = distinctKeys(input.parentRows, parentKey);
+  const base = {
+    dialect,
+    tableName: table,
+    conditions: Object.keys(filters).length > 0 ? filters : void 0,
+    order,
+    targetKey,
+    values
+  };
+  return input.limit !== void 0 ? compileSingleKeyLimited({ ...base, limit: input.limit }) : compileSingleKeyUnlimited({ ...base, select: select ? select.join(", ") : void 0 });
+}
+function distinctKeys(rows, key) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const r of rows) {
+    const v = r[key];
+    if (v === null || v === void 0) continue;
+    if (!seen.has(v)) {
+      seen.add(v);
+      out.push(v);
+    }
+  }
+  return out;
+}
+function compileAuthoredBehavior(contract, scope, dialect, entry2) {
+  const component = entry2 ? contract.components.find((c) => c.name === entry2) : contract.components[0];
+  if (component === void 0) {
+    throw new Error(`authoring-compile: entry component '${entry2 ?? "<first>"}' not found in contract`);
+  }
+  const relations = [];
+  let primaryNode;
+  for (const n of component.body) {
+    if ("cond" in n) continue;
+    if (isMap(n)) {
+      relations.push(n);
+      continue;
+    }
+    if (primaryNode === void 0) primaryNode = n;
+  }
+  if (primaryNode === void 0) {
+    throw new Error(`authoring-compile: behavior '${component.name}' has no primary catalog node`);
+  }
+  const normalized = normalizeInput(component, scope);
+  return {
+    name: component.name,
+    primary: compileAuthoredNode(primaryNode, normalized, dialect),
+    relations
+  };
+}
+function normalizeInput(component, input) {
+  const optional = /* @__PURE__ */ new Set();
+  for (const [port, schema] of Object.entries(component.inputPorts)) {
+    if (schema.required !== true) optional.add(port);
+  }
+  for (const n of component.body) skipGuardHeads(n, optional);
+  const out = { ...input };
+  for (const head of optional) {
+    if (!(head in out)) out[head] = null;
+  }
+  return out;
+}
+function skipGuardHeads(n, into) {
+  if ("cond" in 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;
+  const arr = where.arr;
+  if (!Array.isArray(arr)) return;
+  for (const m of arr) {
+    if (opKey2(m) === "cond") {
+      const cond = m.cond;
+      if (Array.isArray(cond) && cond.length === 3) collectRefHeads2(cond[0], into);
+    }
+  }
+}
+function collectRefHeads2(node, into) {
+  if (node === null || typeof node !== "object") return;
+  if (Array.isArray(node)) {
+    for (const e of node) collectRefHeads2(e, into);
+    return;
+  }
+  const op = opKey2(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]);
+    return;
+  }
+  for (const v of Object.values(node)) collectRefHeads2(v, into);
+}
+
+// src/scp/makesql/static-bundle.ts
+import {
+  evaluateExpression as evaluateExpression3,
+  runBehavior,
+  runBehaviorAsync
+} from "behavior-contracts";
+
+// src/scp/authoring-sql.ts
+import { eq, ne, lt, le, gt, ge } from "behavior-contracts";
+var BETWEEN_SENTINEL = "@between";
+var LIKE_SENTINEL = "@like";
+var CAST_SENTINEL = "@cast";
+var DYNAMIC_SENTINEL = "@dynamic";
+var IMMEDIATE_SENTINEL = "@immediate";
+var TUPLE_SENTINEL = "@tuple";
+var SUBQUERY_SENTINEL = "@subquery";
+var EXISTS_SENTINEL = "@exists";
+function sentinelRef($, head, segs) {
+  let node = $[head];
+  for (const s of segs) node = node[s];
+  return node;
+}
+function whereEq(col, value) {
+  return eq(col, value);
+}
+function whereNe(col, value) {
+  return ne(col, value);
+}
+function whereLt(col, value) {
+  return lt(col, value);
+}
+function whereLe(col, value) {
+  return le(col, value);
+}
+function whereGt(col, value) {
+  return gt(col, value);
+}
+function whereGe(col, value) {
+  return ge(col, value);
+}
+function whereIsNull(col) {
+  return eq(col, null);
+}
+function whereIn(col, value) {
+  return eq(col, value);
+}
+function inColumn($, name) {
+  return $[IN_SENTINEL][name];
+}
+function whereBetween($, col, lo, hi) {
+  return eq(sentinelRef($, BETWEEN_SENTINEL, [col]), [lo, hi]);
+}
+function whereLike($, col, pattern) {
+  return eq(sentinelRef($, LIKE_SENTINEL, [col, "LIKE"]), pattern);
+}
+function whereILike($, col, pattern) {
+  return eq(sentinelRef($, LIKE_SENTINEL, [col, "ILIKE"]), pattern);
+}
+function whereCast($, col, sqlType, value, op = "=") {
+  return eq(sentinelRef($, CAST_SENTINEL, [col, sqlType, op]), value);
+}
+function whereDynamic($, col, template, values) {
+  return eq(sentinelRef($, DYNAMIC_SENTINEL, [col, template]), values);
+}
+function whereImmediate($, col, sql2) {
+  return eq(sentinelRef($, IMMEDIATE_SENTINEL, [col, sql2]), null);
+}
+function whereTupleIn($, columns, tuples) {
+  return eq(sentinelRef($, TUPLE_SENTINEL, columns), tuples);
+}
+function whereInSubquery($, lhs, sub2, not2 = false) {
+  return eq(sentinelRef($, SUBQUERY_SENTINEL, [lhs, not2 ? "NOT IN" : "IN"]), sub2);
+}
+function whereExists($, sub2, not2 = false) {
+  return eq(sentinelRef($, EXISTS_SENTINEL, [not2 ? "NOT EXISTS" : "EXISTS"]), sub2);
+}
+
+// src/scp/makesql/static-bundle.ts
+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 stringPort3(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)})`);
+  return v;
+}
+function arrPort2(ports, name) {
+  const v = ports[name];
+  if (v === void 0) return void 0;
+  if (typeof v === "object" && v !== null && "arr" in v && Array.isArray(v.arr)) {
+    return v.arr;
+  }
+  throw new Error(`static-bundle: port '${name}' must be an {arr:[...]} literal in the IR (got ${JSON.stringify(v)})`);
+}
+function stringArrayPort2(ports, name) {
+  const arr = arrPort2(ports, name);
+  if (arr === void 0) return void 0;
+  return arr.map((e) => {
+    if (typeof e !== "string") throw new Error(`static-bundle: '${name}' entries must be literal strings (got ${JSON.stringify(e)})`);
+    return e;
+  });
+}
+function mapPort(ports, name) {
+  const v = ports[name];
+  if (v === void 0) return void 0;
+  if (typeof v === "object" && v !== null && "obj" in v && typeof v.obj === "object") {
+    const obj = v.obj;
+    if (typeof obj.name !== "string" || typeof obj.sql !== "string") {
+      throw new Error(`static-bundle: port '${name}' must be a {name, sql} literal map (got ${JSON.stringify(v)})`);
+    }
+    return { name: obj.name, sql: obj.sql };
+  }
+  throw new Error(`static-bundle: port '${name}' must be an {obj:{name, sql}} literal (got ${JSON.stringify(v)})`);
+}
+function exprArrayPort(ports, name) {
+  const arr = arrPort2(ports, name);
+  if (arr === void 0) return void 0;
+  return arr;
+}
+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 columnOf3(node, ctx) {
+  const op = opKey3(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") {
+    throw new Error(`static-bundle: ${ctx}: column ref path must be a non-empty string path`);
+  }
+  return path[path.length - 1];
+}
+function inSentinelColumn2(node) {
+  const op = opKey3(node);
+  if (op !== "ref" && op !== "refOpt") return void 0;
+  const path = node[op];
+  if (Array.isArray(path) && path.length >= 2 && path[0] === IN_SENTINEL && typeof path[path.length - 1] === "string") {
+    return path[path.length - 1];
+  }
+  return void 0;
+}
+function binOperands3(node, op, at) {
+  const args = node[op];
+  if (!Array.isArray(args) || args.length !== 2) throw new Error(`static-bundle: ${at}: '${op}' expects exactly 2 operands`);
+  return [args[0], args[1]];
+}
+function sentinelPath(node) {
+  const op = opKey3(node);
+  if (op !== "ref" && op !== "refOpt") return void 0;
+  const path = node[op];
+  if (!Array.isArray(path) || path.length === 0) return void 0;
+  return path.every((s) => typeof s === "string") ? path : void 0;
+}
+function litArr(node) {
+  if (node !== null && typeof node === "object" && !Array.isArray(node) && "arr" in node) {
+    const a = node.arr;
+    if (Array.isArray(a)) return a;
+  }
+  return void 0;
+}
+function nestedSub(node, at) {
+  if (node === null || typeof node !== "object" || Array.isArray(node) || !("obj" in node)) {
+    throw new Error(`static-bundle: ${at}: subquery operand must be a nested makeSQL Fragment {obj:{sql, params?}}`);
+  }
+  const obj = node.obj;
+  const sqlNode = obj.sql;
+  if (typeof sqlNode !== "string") throw new Error(`static-bundle: ${at}: nested subquery 'sql' must be a literal string`);
+  const params = obj.params === void 0 ? [] : litArr(obj.params) ?? undefinedThrow(at);
+  return { sql: sqlNode, params };
+}
+function undefinedThrow(at) {
+  throw new Error(`static-bundle: ${at}: nested subquery 'params' must be an {arr:[\u2026]} literal`);
+}
+function decodeSentinel(col, val, dialect, at) {
+  const path = sentinelPath(col);
+  if (path === void 0) return void 0;
+  const head = path[0];
+  if (head === BETWEEN_SENTINEL) {
+    const [column] = [path[1]];
+    const bounds = litArr(val);
+    if (bounds === void 0 || bounds.length !== 2) throw new Error(`static-bundle: ${at}: BETWEEN expects a 2-element bounds array`);
+    return { sql: v1ConditionText2({ [`${column} BETWEEN ? AND ?`]: [PROBE2, PROBE2] }, dialect), params: bounds };
+  }
+  if (head === LIKE_SENTINEL) {
+    const [column, keyword] = [path[1], path[2]];
+    return { sql: v1ConditionText2({ [`${column} ${keyword} ?`]: PROBE2 }, dialect), params: [val] };
+  }
+  if (head === CAST_SENTINEL) {
+    const [column, sqlType, cmpOp] = [path[1], path[2], path[3]];
+    return { sql: v1ConditionText2({ [column]: dbCast(PROBE2, sqlType, cmpOp) }, dialect), params: [val] };
+  }
+  if (head === DYNAMIC_SENTINEL) {
+    const [column, template] = [path[1], path[2]];
+    const values = litArr(val);
+    const nPlaceholders = (template.match(/\?/g) ?? []).length;
+    const probeVals = Array.from({ length: nPlaceholders }, () => PROBE2);
+    const deferred = values ?? [val];
+    if (deferred.length !== nPlaceholders) {
+      throw new Error(`static-bundle: ${at}: dbDynamic template has ${nPlaceholders} '?' but ${deferred.length} value-specs`);
+    }
+    return { sql: v1ConditionText2({ [column]: dbDynamic(template, probeVals) }, dialect), params: deferred };
+  }
+  if (head === IMMEDIATE_SENTINEL) {
+    const [column, sql2] = [path[1], path[2]];
+    return { sql: v1ConditionText2({ [column]: dbImmediate(sql2) }, dialect), params: [] };
+  }
+  if (head === TUPLE_SENTINEL) {
+    const columns = path.slice(1);
+    const tuples = litArr(val);
+    if (tuples === void 0) throw new Error(`static-bundle: ${at}: tuple-IN expects an array-of-tuples value`);
+    const rows = tuples.map((t) => litArr(t) ?? throwTuple(at));
+    const deferred = [];
+    for (const row of rows) for (const el of row) deferred.push(el);
+    const probeRows = rows.map((r) => r.map(() => PROBE2));
+    return { sql: tupleInText(columns, probeRows, dialect), params: deferred };
+  }
+  if (head === SUBQUERY_SENTINEL) {
+    const [lhs, keyword] = [path[1], path[2]];
+    const sub2 = nestedSub(val, at);
+    return { sql: `${lhs} ${keyword} (${sub2.sql})`, params: sub2.params };
+  }
+  if (head === EXISTS_SENTINEL) {
+    const [keyword] = [path[1]];
+    const sub2 = nestedSub(val, at);
+    return { sql: `${keyword} (${sub2.sql})`, params: sub2.params };
+  }
+  return void 0;
+}
+function throwTuple(at) {
+  throw new Error(`static-bundle: ${at}: each tuple-IN row must be an {arr:[\u2026]} literal`);
+}
+function tupleInText(columns, probeRows, dialect) {
+  const cond = { __tuple__: dbTupleIn([...columns], probeRows) };
+  return v1ConditionText2(cond, dialect);
+}
+var CMP_OPS3 = { lt: "<", le: "<=", gt: ">", ge: ">=", ne: "<>" };
+var PROBE2 = "__probe__";
+function v1ConditionText2(conditions, dialect) {
+  const probe = [];
+  return conditionsFor(conditions, dialect).compile(probe, formatterFor(dialect));
+}
+function v1GroupText(op, leafSqls) {
+  const operator = op === "and" ? "AND" : "OR";
+  const inner = new DBConditions({}, operator);
+  for (const sql2 of leafSqls) inner.add({ __raw__: sql2 }, operator);
+  const parent = new DBConditions({});
+  parent.add(inner);
+  const probe = [];
+  return parent.compile(probe);
+}
+function jsonArraySpec(dialect, valueSpec) {
+  return { __jsonArray: valueSpec, dialect };
+}
+function inListFragment(dialect, column, valueSpec) {
+  if (dialect === "postgres") {
+    const conditions2 = { __raw__: [`${column} = ANY(?)`, [PROBE2]] };
+    return { sql: v1ConditionText2(conditions2, dialect), params: [jsonArraySpec(dialect, valueSpec)] };
+  }
+  const conditions = { [column]: [PROBE2] };
+  return { sql: v1ConditionText2(conditions, dialect), params: [jsonArraySpec(dialect, valueSpec)] };
+}
+function lowerWhereMember2(node, dialect, at) {
+  const op = opKey3(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];
+    if (!Array.isArray(args) || args.length < 2) throw new Error(`static-bundle: ${at}: '${op}' group expects >= 2 members`);
+    const parts = [];
+    const params = [];
+    args.forEach((m, i) => {
+      const f = lowerWhereMember2(m, dialect, `${at}.${op}[${i}]`);
+      parts.push(f.sql);
+      params.push(...f.params);
+    });
+    return { sql: v1GroupText(op, parts), params };
+  }
+  if (op === "eq") {
+    const [col, val] = binOperands3(node, op, at);
+    const inCol = inSentinelColumn2(col);
+    if (inCol !== void 0) return inListFragment(dialect, inCol, val);
+    const additive = decodeSentinel(col, val, dialect, at);
+    if (additive !== void 0) return additive;
+    const column = columnOf3(col, at);
+    if (val === null) return { sql: v1ConditionText2({ [column]: null }, dialect), params: [] };
+    return { sql: v1ConditionText2({ [column]: PROBE2 }, dialect), params: [val] };
+  }
+  if (op in CMP_OPS3) {
+    const [col, val] = binOperands3(node, op, at);
+    const column = columnOf3(col, at);
+    if (op === "ne" && val === null) {
+      return { sql: v1ConditionText2({ [`${column} IS NOT NULL`]: true }, dialect), params: [] };
+    }
+    return { sql: v1ConditionText2({ [`${column} ${CMP_OPS3[op]} ?`]: PROBE2 }, dialect), params: [val] };
+  }
+  throw new Error(`static-bundle: ${at}: unsupported where operator '${op}' (supported: eq/ne/lt/le/gt/ge/and/or; IN via ${IN_SENTINEL}; IS NULL via eq(col,null))`);
+}
+function lowerWherePort2(ports, dialect, at) {
+  const arr = arrPort2(ports, "where");
+  if (arr === void 0 || arr.length === 0) return [];
+  const fragments = [];
+  arr.forEach((m, i) => {
+    const memberAt = `${at}.where[${i}]`;
+    if (opKey3(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)`);
+      }
+      const inner = lowerWhereMember2(cargs[1], dialect, `${memberAt}.cond.then`);
+      fragments.push({ sql: inner.sql, params: inner.params, skip: skipFrom(cargs[0]) });
+      return;
+    }
+    const f = lowerWhereMember2(m, dialect, memberAt);
+    fragments.push({ sql: f.sql, params: f.params });
+  });
+  return fragments.map((f) => ({ sql: f.sql, params: f.params, ...f.skip !== void 0 ? { skip: f.skip } : {} }));
+}
+function skipFrom(guard) {
+  return { not: [guard] };
+}
+function selectTail(desc, table) {
+  const full = compileSelect(desc).sql;
+  const head = `SELECT * FROM ${table}`;
+  return full.startsWith(head) ? full.slice(head.length) : full;
+}
+function limitOffsetTail(kind, dialect, table) {
+  const SENTINEL = 987654321;
+  const desc = kind === "limit" ? { dialect, tableName: table, limit: SENTINEL } : { dialect, tableName: table, offset: SENTINEL };
+  const tail = selectTail(desc, table);
+  return tail.replace(String(SENTINEL), "?");
+}
+function compileSelectNode(node, dialect) {
+  const { component, ports } = nodeRef2(node);
+  if (component !== "Select" && component !== "Count") {
+    throw new Error(`static-bundle: compileSelectNode only compiles Select/Count nodes (got '${component}')`);
+  }
+  const table = stringPort3(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 cols = isCount ? "COUNT(*) as count" : select && select.length > 0 ? select.join(", ") : "*";
+  const statements = [];
+  const cte = mapPort(ports, "cte");
+  const join = stringPort3(ports, "join");
+  const cteParams = exprArrayPort(ports, "cteParams");
+  const joinParams = exprArrayPort(ports, "joinParams");
+  const headDesc = { dialect, tableName: table, select: cols };
+  if (cte !== void 0) headDesc.cte = { name: cte.name, sql: cte.sql, params: [] };
+  if (join !== void 0) headDesc.join = join;
+  const headParams = [...cteParams ?? [], ...joinParams ?? []];
+  statements.push({ sql: compileSelect(headDesc).sql, params: headParams });
+  const whereFrags = lowerWherePort2(ports, dialect, component);
+  for (const frag of whereFrags) {
+    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");
+  if (group !== void 0) statements.push({ sql: selectTail({ dialect, tableName: table, group }, table), params: [] });
+  const order = stringPort3(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");
+  if (forUpdate === "true") statements.push({ sql: selectTail({ dialect, tableName: table, forUpdate: true }, table), params: [] });
+  const append = stringPort3(ports, "append");
+  if (append !== void 0) statements.push({ sql: selectTail({ dialect, tableName: table, append }, table), params: [] });
+  return statements;
+}
+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);
+    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)`);
+}
+function compileStaticBundle(contract, dialect, entry2) {
+  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`);
+  let primary;
+  for (const n of component.body) {
+    if ("cond" in n) continue;
+    if (isMap2(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`);
+  const statements = compilePrimaryNode(primary, dialect);
+  return {
+    dialect,
+    name: component.name,
+    statements,
+    optionalHeads: [...optionalHeadsOf(component, statements)]
+  };
+}
+function optionalHeadsOf(component, statements) {
+  const optional = /* @__PURE__ */ new Set();
+  for (const [port, schema] of Object.entries(component.inputPorts)) {
+    if (schema.required !== true) optional.add(port);
+  }
+  for (const n of component.body) skipGuardHeads2(n, optional);
+  for (const stmt of statements) {
+    for (const p of stmt.params) collectRefOptHeads(p, optional);
+    if (stmt.skip !== void 0) collectRefOptHeads(stmt.skip, optional);
+  }
+  return optional;
+}
+function collectRefOptHeads(node, into) {
+  if (node === null || typeof node !== "object") return;
+  if (Array.isArray(node)) {
+    for (const e of node) collectRefOptHeads(e, into);
+    return;
+  }
+  const keys = Object.keys(node);
+  if (keys.length === 1 && keys[0] === "refOpt") {
+    const path = node.refOpt;
+    if (Array.isArray(path) && path.length > 0 && typeof path[0] === "string") into.add(path[0]);
+    return;
+  }
+  for (const v of Object.values(node)) collectRefOptHeads(v, into);
+}
+function skipGuardHeads2(n, into) {
+  if ("cond" in n) return;
+  const ports = isMap2(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") {
+      const cond = m.cond;
+      if (Array.isArray(cond) && cond.length === 3) collectRefHeads3(cond[0], into);
+    }
+  }
+}
+function collectRefHeads3(node, into) {
+  if (node === null || typeof node !== "object") return;
+  if (Array.isArray(node)) {
+    for (const e of node) collectRefHeads3(e, into);
+    return;
+  }
+  const op = opKey3(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]);
+    return;
+  }
+  for (const v of Object.values(node)) collectRefHeads3(v, into);
+}
+function toDriverParam2(v) {
+  if (typeof v === "bigint") {
+    if (v >= BigInt(Number.MIN_SAFE_INTEGER) && v <= BigInt(Number.MAX_SAFE_INTEGER)) return Number(v);
+    return v;
+  }
+  return v;
+}
+function evalSpec(spec, scope) {
+  if (spec !== null && typeof spec === "object" && !Array.isArray(spec) && "__jsonArray" in spec) {
+    const marker = spec;
+    const arr = evaluateExpression3(marker.__jsonArray, scope);
+    if (!Array.isArray(arr)) throw new Error("static-bundle: IN-list value-spec did not evaluate to an array");
+    if (marker.dialect === "postgres") return arr.map((e) => toDriverParam2(e));
+    const encodeElem = (e) => marker.dialect === "mysql" && typeof e === "boolean" ? e ? 1 : 0 : toDriverParam2(e);
+    return JSON.stringify(arr.map(encodeElem));
+  }
+  return toDriverParam2(evaluateExpression3(spec, scope));
+}
+function renderStatements(statements, dialect, scope) {
+  const nodes = [];
+  let whereSeen = false;
+  for (const stmt of statements) {
+    if (stmt.skip !== void 0) {
+      const drop = evaluateExpression3(stmt.skip, scope);
+      if (drop !== null && drop !== false) continue;
+    }
+    let sql2 = stmt.sql;
+    if (stmt.whereFragment === true) {
+      sql2 = (whereSeen ? " AND " : " WHERE ") + stmt.sql;
+      whereSeen = true;
+    }
+    const params = stmt.params.map((p) => evalSpec(p, scope));
+    nodes.push({ sql: sql2, params });
+  }
+  const assembled = composeMakeSQL(nodes);
+  return { sql: renderPlaceholders(assembled.sql, dialect), params: assembled.params };
+}
+function renderBundle(bundle, scope) {
+  return renderStatements(bundle.statements, bundle.dialect, scope);
+}
+function normalizeInput2(bundle, input) {
+  const out = { ...input };
+  for (const head of bundle.optionalHeads) {
+    if (!(head in out)) out[head] = null;
+  }
+  return out;
+}
+function executeStaticBundle(bundle, input, db) {
+  const scope = normalizeInput2(bundle, input);
+  const { sql: sql2, params } = renderBundle(bundle, scope);
+  let stmt;
+  try {
+    stmt = db.prepare(sql2);
+    return stmt.all(...params);
+  } catch (e) {
+    throw mapSqliteError(e);
+  }
+}
+function executeStaticWrite(bundle, input, db) {
+  const scope = normalizeInput2(bundle, input);
+  const { sql: sql2, params } = renderBundle(bundle, scope);
+  const hasReturn = /\breturning\b/i.test(sql2);
+  try {
+    const stmt = db.prepare(sql2);
+    if (hasReturn) return stmt.all(...params);
+    const info = stmt.run(...params);
+    return [{ changes: info.changes, lastInsertRowid: toDriverParam2(BigInt(info.lastInsertRowid)) }];
+  } catch (e) {
+    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);
+  return [{ sql: op.sql, params: op.params }];
+}
+function compileReadGraph(contract, dialect, entry2) {
+  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`);
+  const statementsById = {};
+  for (const n of component.body) {
+    if ("cond" in n) continue;
+    statementsById[n.id] = compileNodeStatements(n, dialect);
+  }
+  const surrogateBody = 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 surrogate = { ...component, body: surrogateBody };
+  const ir = { irVersion: 1, exprVersion: 2, components: [surrogate] };
+  return {
+    dialect,
+    name: component.name,
+    ir,
+    statementsById,
+    optionalHeads: [...optionalHeadsOfComponent(component, dialect)]
+  };
+}
+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 };
+    }
+  };
+  const handlers = { [NODE_COMPONENT]: handle };
+  const normalized = { ...input };
+  for (const head of graph.optionalHeads) if (!(head in normalized)) normalized[head] = null;
+  try {
+    return runBehavior(graph.ir, handlers, normalized, graph.name);
+  } catch (e) {
+    throw reErrorToSqlFailure(e);
+  }
+}
+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;
+  try {
+    return await runBehaviorAsync(graph.ir, handlers, normalized, graph.name);
+  } catch (e) {
+    throw reErrorToSqlFailure(e);
+  }
+}
+function executeReadBehavior(contract, input, dialect, db, entry2) {
+  return executeReadGraph(compileReadGraph(contract, dialect, entry2), input, db);
+}
+function renderReadPrimary(graph, input) {
+  const ids = Object.keys(graph.statementsById);
+  const bodyIds = graph.ir.components[0].body.map((n) => n.id).filter((id) => ids.includes(id));
+  const primaryId = bodyIds[0];
+  if (primaryId === void 0) throw new Error("static-bundle: read graph has no primary node to render");
+  const scope = { ...input };
+  for (const head of graph.optionalHeads) if (!(head in scope)) scope[head] = null;
+  return renderStatements(graph.statementsById[primaryId], graph.dialect, scope);
+}
+function optionalHeadsOfComponent(component, dialect) {
+  const optional = /* @__PURE__ */ new Set();
+  for (const [port, schema] of Object.entries(component.inputPorts)) {
+    if (schema.required !== true) optional.add(port);
+  }
+  for (const n of component.body) skipGuardHeads2(n, optional);
+  for (const n of component.body) {
+    if ("cond" in n) continue;
+    const stmts = compileNodeStatements(n, dialect);
+    for (const stmt of stmts) {
+      for (const p of stmt.params) collectRefOptHeads(p, optional);
+      if (stmt.skip !== void 0) collectRefOptHeads(stmt.skip, optional);
+    }
+  }
+  return optional;
+}
+function reErrorToSqlFailure(e) {
+  const message = e instanceof Error ? e.message : String(e);
+  const m = /(SQLITE_[A-Z_]+)/.exec(message);
+  if (m) return mapSqliteError({ code: m[1], message });
+  return e;
+}
+
+// src/scp/makesql/pool-executor.ts
+function pgPoolExecutor(pool) {
+  return async (sql2, params) => {
+    const result = await pool.query(sql2, params);
+    return result.rows;
+  };
+}
+function mysqlPoolExecutor(pool) {
+  return async (sql2, params) => {
+    const [rows] = await pool.query(sql2, params);
+    return rows;
+  };
+}
+
+// src/scp/catalog.ts
+import { classifyBehaviorEffect } from "behavior-contracts";
+var P = (type, required) => required ? { type, required } : { type };
+var SELECT_PORTS = {
+  table: P("string", true),
+  select: P("string[]", true),
+  where: P("fragment"),
+  order: P("string"),
+  limit: P("expr"),
+  offset: P("expr"),
+  group: P("string"),
+  // Additive read-tail/head ports (V0 R3/R4/R5/R6). SQL is v1-sourced from the matching
+  // `SelectDesc` fields via `compileSelect` (`_buildSelectSQL`), wired in `compileSelectNode`:
+  //  - `forUpdate` (R3): a literal `'true'` string toggles the ` FOR UPDATE` tail.
+  //  - `join`/`joinParams` (R5): a literal JOIN clause text (`JOIN t ON …`) + its bound
+  //    value-specs (`expr[]`), spliced after `FROM <t>` (v1 `_buildSelectSQL` JOIN position).
+  //  - `cte`/`cteParams` (R4): a WITH-CTE `{name, sql}` literal + its bound value-specs,
+  //    prefixed as `WITH <name> AS (<sql>) ` (v1 WITH-wrap). `cteParams` bind FIRST (v1 param
+  //    order: CTE → JOIN → WHERE).
+  //  - `append` (R6): a raw trailing clause text (e.g. `HAVING …`) appended verbatim.
+  forUpdate: P("string"),
+  join: P("string"),
+  joinParams: P("expr[]"),
+  cte: P("map"),
+  cteParams: P("expr[]"),
+  append: P("string")
+};
+var WRITE_PORTS = {
+  table: P("string", true),
+  where: P("fragment"),
+  returning: P("string"),
+  onConflict: P("string"),
+  onConflictAction: P("string"),
+  // PRIMARY KEY descriptor for the MySQL RETURNING emulation (INSERT…RETURNING): `pk` is a
+  // comma-separated PK column list, `autoInc` names the single AUTO_INCREMENT column (absent for a
+  // client-supplied PK). Consumed by compileWriteNode → mysqlPkHint so the emulation re-selects by
+  // the REAL PK. Inert on PG/SQLite (native RETURNING).
+  pk: P("string"),
+  autoInc: P("string")
+};
+var entry = (name, inputPorts, shape, portableToIR) => ({
+  name,
+  inputPorts,
+  output: { shape },
+  portableToIR,
+  // Dynamic port families (where/set/values record ports) are validated by
+  // assertComponentsInCatalog, not statically enumerable. Tx overrides back to
+  // fail-closed (its one port is static).
+  additionalPorts: true
+});
+var LITEDBMODEL_CATALOG = {
+  // Read: `items` (a Select root yields a row list; per-row collapse to `item` is the
+  // consumer's cardinality concern, mirrored from graphddb Query's `cardinality` port).
+  Select: entry("Select", { ...SELECT_PORTS, cardinality: P("string") }, "items", true),
+  // COUNT(*) aggregate read (v1 `DBModel._count`): `SELECT COUNT(*) as count FROM t[ WHERE …]`.
+  // 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),
+  // Writes yield the RETURNING row list (`items`); a single-row write collapses at the
+  // consumer boundary, same as reads.
+  Insert: entry("Insert", WRITE_PORTS, "items", true),
+  Update: entry("Update", WRITE_PORTS, "items", true),
+  Delete: entry("Delete", WRITE_PORTS, "items", true),
+  // The dynamic WHERE/SET fragment-tree component (§8). Its ports carry the fragment
+  // tree; the compiler resolves SKIP/AND-OR structure to fragment existence rules.
+  Fragment: entry("Fragment", { tree: P("fragment", true) }, "item", true),
+  // The runtime-side atomic envelope: never referenced by the portable IR (a transaction
+  // IS a component over the CRUD primitives) — runtime-only. Its single port is static,
+  // so it keeps bc's fail-closed default (no additionalPorts opt-in).
+  Tx: {
+    ...entry("Tx", { statements: P("map[]", true) }, "item", false),
+    additionalPorts: false
+  }
+};
+function catalogEntry(name) {
+  return LITEDBMODEL_CATALOG[name];
+}
+var CATALOG_NAMES = [
+  "Select",
+  "Count",
+  "Insert",
+  "Update",
+  "Delete",
+  "Fragment",
+  "Tx"
+];
+var WRITE_CATALOG_NAMES = [
+  "Insert",
+  "Update",
+  "Delete",
+  "Tx"
+];
+var WRITE_SET = new Set(WRITE_CATALOG_NAMES);
+var WRITE_PORT_FAMILIES = [
+  "values.",
+  "set."
+];
+function assertComponentsInCatalog(components2) {
+  const errs = [];
+  for (const c of components2) {
+    for (const n of c.body) {
+      if ("cond" in n) continue;
+      const ref = "map" in n ? n.map : n;
+      const entryDef = LITEDBMODEL_CATALOG[ref.component];
+      if (entryDef === void 0) {
+        errs.push(`${c.name}/${n.id}: references '${ref.component}', not a LITEDBMODEL_CATALOG entry (known: ${CATALOG_NAMES.join(", ")})`);
+        continue;
+      }
+      const ports = ref.ports;
+      for (const [p, s] of Object.entries(entryDef.inputPorts)) {
+        if (s.required === true && !(p in ports)) {
+          errs.push(`${c.name}/${n.id} (${ref.component}): required port '${p}' is not wired`);
+        }
+      }
+      const isWriteItem = WRITE_SET.has(ref.component);
+      for (const p of Object.keys(ports)) {
+        if (p in entryDef.inputPorts) continue;
+        if (isWriteItem && WRITE_PORT_FAMILIES.some((f) => p.startsWith(f))) continue;
+        errs.push(`${c.name}/${n.id} (${ref.component}): port '${p}' is not declared by the catalog entry (nor a write record-family port)`);
+      }
+    }
+  }
+  if (errs.length > 0) {
+    throw new Error(`litedbmodel catalog validation failed (${errs.length} violation${errs.length === 1 ? "" : "s"}):
+ - ${errs.join("\n - ")}`);
+  }
+}
+function deriveContractEffect(component) {
+  return classifyBehaviorEffect(component, WRITE_CATALOG_NAMES) === "writing" ? "command" : "query";
+}
+
+// src/scp/dialect.ts
+function toDollarPlaceholders(sql2) {
+  let n = 0;
+  let out = "";
+  for (const ch of sql2) {
+    if (ch === "?") {
+      n += 1;
+      out += `$${n}`;
+    } else {
+      out += ch;
+    }
+  }
+  return out;
+}
+function onConflictClause(conflictColumns, action, excludedRef) {
+  const target = conflictColumns.length > 0 ? ` (${conflictColumns.join(", ")})` : "";
+  if (action === "ignore") {
+    return ` ON CONFLICT${target} DO NOTHING`;
+  }
+  const sets = action.updateColumns.map((c) => `${c} = ${excludedRef(c)}`);
+  return ` ON CONFLICT${target} DO UPDATE SET ${sets.join(", ")}`;
+}
+function guardInsertText(table, columns, placeholders, form) {
+  const head = form === "insertIgnore" ? "INSERT IGNORE INTO" : "INSERT INTO";
+  const tail = form === "trailingDoNothing" ? " ON CONFLICT DO NOTHING" : "";
+  return `${head} ${table} (${columns.join(", ")}) VALUES (${placeholders})${tail}`;
+}
+var SQLITE = Object.freeze({
+  name: "sqlite",
+  ignoreIsTrailingClause: false,
+  insertVerb(action) {
+    return action === "ignore" ? "INSERT OR IGNORE INTO" : "INSERT INTO";
+  },
+  insertConflictClause(conflictColumns, action) {
+    if (action === "ignore") return "";
+    return onConflictClause(conflictColumns, action, (c) => `excluded.${c}`);
+  },
+  guardInsert(table, columns, placeholders) {
+    return guardInsertText(table, columns, placeholders, "trailingDoNothing");
+  },
+  finalizePlaceholders(sql2) {
+    return sql2;
+  },
+  orderByNulls(expr, dir, nulls) {
+    return `${expr} ${dir} NULLS ${nulls}`;
+  }
+});
+var POSTGRES = Object.freeze({
+  name: "postgres",
+  ignoreIsTrailingClause: true,
+  insertVerb(_action) {
+    return "INSERT INTO";
+  },
+  insertConflictClause(conflictColumns, action) {
+    return onConflictClause(conflictColumns, action, (c) => `EXCLUDED.${c}`);
+  },
+  guardInsert(table, columns, placeholders) {
+    return guardInsertText(table, columns, placeholders, "trailingDoNothing");
+  },
+  finalizePlaceholders(sql2) {
+    return toDollarPlaceholders(sql2);
+  },
+  orderByNulls(expr, dir, nulls) {
+    return `${expr} ${dir} NULLS ${nulls}`;
+  }
+});
+var MYSQL = Object.freeze({
+  name: "mysql",
+  ignoreIsTrailingClause: false,
+  insertVerb(action) {
+    return action === "ignore" ? "INSERT IGNORE INTO" : "INSERT INTO";
+  },
+  insertConflictClause(_conflictColumns, action) {
+    if (action === "ignore") return "";
+    const sets = action.updateColumns.map((c) => `${c} = VALUES(${c})`);
+    return ` ON DUPLICATE KEY UPDATE ${sets.join(", ")}`;
+  },
+  guardInsert(table, columns, placeholders) {
+    return guardInsertText(table, columns, placeholders, "insertIgnore");
+  },
+  finalizePlaceholders(sql2) {
+    return sql2;
+  },
+  orderByNulls(expr, dir, nulls) {
+    const flagDir = nulls === "FIRST" ? "DESC" : "ASC";
+    return `${expr} IS NULL ${flagDir}, ${expr} ${dir}`;
+  }
+});
+var DIALECTS = Object.freeze({
+  sqlite: SQLITE,
+  postgres: POSTGRES,
+  mysql: MYSQL
+});
+function dialectFor(name) {
+  const d = DIALECTS[name];
+  if (d === void 0) {
+    throw new Error(`scp dialect: unknown dialect '${String(name)}' (known: ${Object.keys(DIALECTS).join(", ")})`);
+  }
+  return d;
+}
+
+// src/scp/guard.ts
+import { assertPortable, FORBIDDEN_OBJECT_KEY, PORTABLE_EXPR_OPERATORS, PortabilityError } from "behavior-contracts";
+function assertExprPortable(node, path = "$") {
+  assertPortable(node, path);
+  walkExpr(node, path);
+}
+function walkExpr(node, path) {
+  if (node === null || typeof node !== "object") return;
+  if (Array.isArray(node)) {
+    node.forEach((el, i) => walkExpr(el, `${path}[${i}]`));
+    return;
+  }
+  const keys = Object.keys(node);
+  if (keys.length === 1) {
+    const op = keys[0];
+    if (!PORTABLE_EXPR_OPERATORS.has(op)) {
+      throw new PortabilityError(path, `Portability Guard: '${op}' is not a portable Expression IR operator (closed set: ${[...PORTABLE_EXPR_OPERATORS].join(", ")})`);
+    }
+    const arg = node[op];
+    if (op === "obj") {
+      if (arg === null || typeof arg !== "object" || Array.isArray(arg)) {
+        throw new PortabilityError(`${path}.obj`, `Portability Guard: {obj: ...} expects an object (at ${path}.obj)`);
+      }
+      for (const [k, v] of Object.entries(arg)) {
+        if (k === FORBIDDEN_OBJECT_KEY) {
+          throw new PortabilityError(`${path}.obj`, `Portability Guard: object key "${FORBIDDEN_OBJECT_KEY}" is forbidden (fail-closed) at ${path}.obj`);
+        }
+        walkExpr(v, `${path}.obj.${k}`);
+      }
+      return;
+    }
+    walkExpr(arg, `${path}.${op}`);
+    return;
+  }
+  for (const k of keys) walkExpr(node[k], `${path}.${k}`);
+}
+function assertComponentPortable(component) {
+  const at = `component '${component.name}'`;
+  for (const n of component.body) {
+    if ("map" in n) {
+      assertExprPortable(n.map.over, `${at}/${n.id}.map.over`);
+      assertPortsPortable(n.map.ports, `${at}/${n.id}.map.ports`);
+      if (n.map.when !== void 0) assertExprPortable(n.map.when, `${at}/${n.id}.map.when`);
+    } else if ("cond" in n) {
+      assertExprPortable(n.cond.if, `${at}/${n.id}.cond.if`);
+      assertExprPortable(n.cond.then, `${at}/${n.id}.cond.then`);
+      assertExprPortable(n.cond.else, `${at}/${n.id}.cond.else`);
+    } else {
+      assertPortsPortable(n.ports, `${at}/${n.id}.ports`);
+    }
+  }
+  assertExprPortable(component.output, `${at}.output`);
+}
+function assertPortsPortable(ports, path) {
+  if (ports === null || typeof ports !== "object" || Array.isArray(ports)) {
+    assertExprPortable(ports, path);
+    return;
+  }
+  for (const [name, value] of Object.entries(ports)) {
+    assertExprPortable(value, `${path}.${name}`);
+  }
+}
+function assertComponentGraphPortable(ir) {
+  for (const c of ir.components) assertComponentPortable(c);
+}
+
+// src/scp/authoring.ts
+import {
+  catalogComponents,
+  compileBehaviors,
+  SemanticBehavior
+} from "behavior-contracts";
+var boundComponents;
+function components() {
+  if (boundComponents === void 0) {
+    boundComponents = catalogComponents(LITEDBMODEL_CATALOG);
+  }
+  return boundComponents;
+}
+function lowerBehaviorClass(cls, options) {
+  const ir = compileBehaviors(cls, {
+    ...options.inputPorts !== void 0 ? { inputPorts: options.inputPorts } : {},
+    ...options.concurrency !== void 0 ? { concurrency: options.concurrency } : {}
+  });
+  assertComponentsInCatalog(ir.components);
+  assertComponentGraphPortable(ir);
+  const methods = {};
+  for (const component of ir.components) {
+    methods[component.name] = {
+      name: component.name,
+      effect: deriveContractEffect(component),
+      component
+    };
+  }
+  return {
+    className: cls.name ?? "<anonymous>",
+    ir,
+    components: ir.components,
+    methods
+  };
+}
+function publishBehaviors(cls, options = {}) {
+  return lowerBehaviorClass(cls, options);
+}
+function compileEager(name, fn, options = {}) {
+  const cls = makeEagerClass(name, fn);
+  return lowerBehaviorClass(cls, options);
+}
+function makeEagerClass(name, fn) {
+  const L = components();
+  const cls = class extends SemanticBehavior {
+  };
+  const method = function($) {
+    return fn($, L);
+  };
+  Object.defineProperty(method, "toString", { value: () => fn.toString(), configurable: true });
+  Object.defineProperty(cls.prototype, name, {
+    value: method,
+    writable: true,
+    enumerable: false,
+    configurable: true
+  });
+  Object.defineProperty(cls, "name", { value: name, configurable: true });
+  return cls;
+}
+
+// src/scp/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) {
+  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})`);
+  }
+  if (decl.limit !== void 0 && (!Number.isInteger(decl.limit) || decl.limit < 0)) {
+    throw new Error(`relation '${decl.name}': per-parent limit must be a non-negative integer (got ${String(decl.limit)})`);
+  }
+  if (decl.limit !== void 0 && decl.order === void 0) {
+    throw new Error(
+      `relation '${decl.name}': a per-parent 'limit' requires an explicit 'order' (the per-parent window needs a deterministic ordering to decide which ${decl.limit} rows each parent keeps)`
+    );
+  }
+  const dialect = decl.dialect ?? "sqlite";
+  const composite = isCompositeDecl(decl);
+  const sql2 = compiledBatchSql(decl, dialect);
+  const conn = decl.connection !== void 0 ? { connection: decl.connection } : {};
+  if (composite) {
+    return {
+      name: decl.name,
+      kind: decl.kind,
+      parentKeys: [...decl.parentKeys],
+      targetKeys: [...decl.targetKeys],
+      dialect,
+      ...conn,
+      sql: sql2
+    };
+  }
+  return {
+    name: decl.name,
+    kind: decl.kind,
+    parentKey: decl.parentKey,
+    targetKey: decl.targetKey,
+    dialect,
+    ...conn,
+    sql: sql2
+  };
+}
+function isCompositeDecl(decl) {
+  const hasArrays = decl.parentKeys !== void 0 || decl.targetKeys !== void 0;
+  if (!hasArrays) {
+    if (decl.parentKey === void 0 || decl.targetKey === void 0) {
+      throw new Error(`relation '${decl.name}': a single-key relation requires 'parentKey' and 'targetKey'`);
+    }
+    return false;
+  }
+  if (decl.parentKeys === void 0 || decl.targetKeys === void 0) {
+    throw new Error(`relation '${decl.name}': a composite-key relation requires BOTH 'parentKeys' and 'targetKeys'`);
+  }
+  if (decl.parentKeys.length === 0 || decl.parentKeys.length !== decl.targetKeys.length) {
+    throw new Error(`relation '${decl.name}': 'parentKeys' and 'targetKeys' must be non-empty and equal-length (got ${decl.parentKeys.length} vs ${decl.targetKeys.length})`);
+  }
+  if (decl.parentKey !== void 0 || decl.targetKey !== void 0) {
+    throw new Error(`relation '${decl.name}': cannot mix single-key ('parentKey'/'targetKey') with composite ('parentKeys'/'targetKeys')`);
+  }
+  return true;
+}
+function compiledBatchSql(decl, dialect) {
+  if (decl.parentKeys !== void 0) {
+    const compositeBase = {
+      dialect,
+      tableName: decl.targetTable,
+      select: decl.select.join(", "),
+      order: decl.order,
+      targetKeys: [...decl.targetKeys],
+      deferPgArrayCast: true
+    };
+    const node2 = decl.limit !== void 0 ? compileCompositeKeyStaticLimited({ ...compositeBase, limit: decl.limit }) : compileCompositeKeyStaticUnlimited(compositeBase);
+    return assembleMakeSQL(node2).sql;
+  }
+  const placeholderKeys = [null];
+  const base = {
+    dialect,
+    tableName: decl.targetTable,
+    select: decl.select.join(", "),
+    order: decl.order,
+    targetKey: decl.targetKey,
+    values: placeholderKeys,
+    // The keys are UNKNOWN at symbolic compile (placeholder set), so the PG `= ANY(?::<T>[])`
+    // element type is DEFERRED to render (#46) — resolved from the real deduped keys via
+    // `inferPgArrayType`, reproducing v1's live-correct cast (`::int[]` for int keys). Baking a
+    // compile-time `text[]` here was the #43 regression (`integer = text` on real PG).
+    deferPgArrayCast: true
+  };
+  const node = decl.limit !== void 0 ? compileSingleKeyLimited({ ...base, limit: decl.limit }) : compileSingleKeyUnlimited(base);
+  return assembleMakeSQL(node).sql;
+}
+function parentKeyCols(op) {
+  return op.parentKeys ?? [op.parentKey];
+}
+function targetKeyCols(op) {
+  return op.targetKeys ?? [op.targetKey];
+}
+function keyIdentity(values) {
+  return values.map((v) => String(v)).join("\0");
+}
+function bindKeys(op, tuples) {
+  const composite = op.parentKeys !== void 0;
+  if (op.dialect === "postgres") {
+    if (!composite) return [tuples.map((t) => t[0])];
+    return parentKeyCols(op).map((_, col) => tuples.map((t) => t[col]));
+  }
+  const payload = composite ? tuples.map((t) => [...t]) : tuples.map((t) => t[0]);
+  return [JSON.stringify(payload)];
+}
+function runRelationOp(op, parents, db) {
+  const pCols = parentKeyCols(op);
+  const keys = dedupeKeys(parents, pCols);
+  const batch = /* @__PURE__ */ new Map();
+  let cast = op.sql;
+  if (op.dialect === "postgres") {
+    for (let col = 0; col < pCols.length; col++) cast = resolvePgArrayCast(cast, keys.map((t) => t[col]));
+  }
+  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));
+  for (const row of rows) {
+    const k = keyIdentity(tCols.map((c) => row[c]));
+    const list = batch.get(k);
+    if (list === void 0) batch.set(k, [row]);
+    else list.push(row);
+  }
+  return { sql: sql2, keys, batch };
+}
+function dedupeKeys(parents, keyCols) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const p of parents) {
+    const tuple = keyCols.map((c) => p[c]);
+    if (tuple.some((v) => v === void 0 || v === null)) continue;
+    const s = keyIdentity(tuple);
+    if (seen.has(s)) continue;
+    seen.add(s);
+    out.push(tuple);
+  }
+  return out;
+}
+function distributeToParent(op, parent, batch) {
+  const tuple = parentKeyCols(op).map((c) => parent[c]);
+  const rows = tuple.some((v) => v === void 0 || v === null) ? void 0 : batch.get(keyIdentity(tuple));
+  if (op.kind === "hasMany") return rows ?? [];
+  return rows !== void 0 && rows.length > 0 ? rows[0] : null;
+}
+
+// src/scp/typed-object.ts
+var RELATION_CONTEXT = /* @__PURE__ */ Symbol("litedbmodel:relation-context");
+var RelationContext = class {
+  siblings;
+  ops;
+  db;
+  hydrate;
+  /** CROSS-DB (V0 R1): name → driver registry; a tagged relation routes to `connections[tag]`. */
+  connections;
+  /** Per-relation resolved batch (name → grouping), memoized: one batch query per relation. */
+  resolved = /* @__PURE__ */ new Map();
+  constructor(siblings, ops, db, hydrate, connections) {
+    this.siblings = siblings;
+    this.ops = ops;
+    this.db = db;
+    this.hydrate = hydrate;
+    this.connections = connections;
+  }
+  /** The driver a relation runs against: its tagged cross-DB connection, else the primary `db`. */
+  driverFor(op) {
+    return op.connection === void 0 ? this.db : driverForOp(op, this.connections);
+  }
+  /**
+   * Resolve `relationName` for `parent` (lazy access). The relation is batch-loaded across
+   * ALL siblings on first access and memoized, so N sibling accesses issue ONE query. Returns
+   * the hydrated child(ren) per cardinality (`hasMany` → array, else single-or-null).
+   */
+  resolve(relationName, parent) {
+    const op = this.ops[relationName];
+    if (op === void 0) {
+      throw new Error(`relation '${relationName}' is not declared on this result set`);
+    }
+    let batch = this.resolved.get(relationName);
+    if (batch === void 0) {
+      batch = runRelationOp(op, this.siblings, this.driverFor(op)).batch;
+      this.resolved.set(relationName, batch);
+    }
+    return applyHydrate(distributeToParent(op, parent, batch), this.hydrate);
+  }
+};
+function driverForOp(op, connections) {
+  const d = connections?.[op.connection];
+  if (d === void 0) {
+    throw new Error(`cross-DB relation '${op.name}': no driver registered for connection '${op.connection}' (pass it in ReadOptions.connections)`);
+  }
+  return d;
+}
+function readRelationContext(o) {
+  const v = o[RELATION_CONTEXT];
+  return v instanceof RelationContext ? v : void 0;
+}
+function applyHydrate(value, hydrate) {
+  if (hydrate === void 0) return value;
+  if (value === null) return null;
+  if (Array.isArray(value)) return value.map((v) => v === null ? null : hydrate(v));
+  return hydrate(value);
+}
+function buildResultSet(rawRows, ops, db, options = {}) {
+  const selected = options.with ?? {};
+  const hydrate = options.hydrate;
+  const proto = {};
+  for (const name of Object.keys(ops)) {
+    if (selected[name] === true) continue;
+    Object.defineProperty(proto, name, {
+      enumerable: false,
+      configurable: true,
+      get() {
+        const ctx2 = readRelationContext(this);
+        if (ctx2 === void 0) {
+          return Promise.reject(
+            new Error(
+              `lazy relation '${name}': the batch context was dropped (spread/clone/JSON); re-read through the query API or declaratively select it via { with: { ${name}: true } }`
+            )
+          );
+        }
+        return Promise.resolve(ctx2.resolve(name, this));
+      }
+    });
+  }
+  const rows = rawRows.map((raw) => {
+    const o = Object.create(proto);
+    for (const k of Object.keys(raw)) o[k] = raw[k];
+    return o;
+  });
+  const ctx = new RelationContext(rows, ops, db, hydrate, options.connections);
+  for (const o of rows) {
+    Object.defineProperty(o, RELATION_CONTEXT, {
+      value: ctx,
+      enumerable: false,
+      writable: false,
+      configurable: false
+    });
+  }
+  for (const name of Object.keys(selected)) {
+    const op = ops[name];
+    if (op === void 0) throw new Error(`declarative select: relation '${name}' is not declared on this model`);
+    const relDb = op.connection === void 0 ? db : driverForOp(op, options.connections);
+    const { batch } = runRelationOp(op, rows, relDb);
+    for (const o of rows) {
+      o[name] = applyHydrate(distributeToParent(op, o, batch), hydrate);
+    }
+  }
+  if (hydrate === void 0) return rows;
+  return rows.map((o) => hydrate(o));
+}
+
+// src/scp/runtime.ts
+function primaryNodeOf(component) {
+  for (const n of component.body) {
+    if ("cond" in n) continue;
+    if ("map" in n) continue;
+    return n;
+  }
+  return void 0;
+}
+function isWriteComponent(component) {
+  const p = primaryNodeOf(component);
+  if (p === void 0 || "map" in p) return false;
+  const c = p.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);
+}
+function compileBundle(contract, entry2, relations = [], dialectName = "sqlite") {
+  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 = {};
+  for (const decl of relations) {
+    if (relationOps[decl.name] !== void 0) {
+      throw new Error(`scp runtime: duplicate relation declaration '${decl.name}'`);
+    }
+    relationOps[decl.name] = compileRelationOp({ ...decl, dialect: decl.dialect ?? dialectName });
+  }
+  if (isWriteComponent(component)) {
+    const writeNode = primaryNodeOf(component);
+    const op = compileWriteNode(writeNode);
+    return {
+      dialect: dialectName,
+      name: component.name,
+      statement: { sql: op.sql, params: op.params },
+      optionalHeads: [],
+      relations: relationOps
+    };
+  }
+  const readGraph = compileReadGraph(contract, dialectName, entry2);
+  return {
+    dialect: dialectName,
+    name: readGraph.name,
+    readGraph,
+    optionalHeads: readGraph.optionalHeads,
+    relations: relationOps
+  };
+}
+function executeBundle(bundle, input, options) {
+  if (bundle.statement !== void 0 && bundle.transaction === void 0) {
+    const view = {
+      dialect: bundle.dialect,
+      name: bundle.name,
+      statements: [bundle.statement],
+      optionalHeads: bundle.optionalHeads
+    };
+    return executeStaticWrite(view, input, options.db);
+  }
+  if (bundle.readGraph === void 0) {
+    throw new Error(`scp runtime: bundle '${bundle.name}' carries neither a read graph nor a write statement`);
+  }
+  return executeReadGraph(bundle.readGraph, input, options.db);
+}
+async function executeBundleAsync(bundle, input, options) {
+  if (bundle.readGraph === void 0) {
+    throw new Error(
+      `scp runtime: executeBundleAsync requires a READ bundle ('${bundle.name}' carries no read graph); the write-tx path stays synchronous + serial (use executeBundle / executeTransactionBundle).`
+    );
+  }
+  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);
+}
+function baseWriteNodeOf(component) {
+  const writes = component.body.filter(
+    (n) => !("cond" in n) && !("map" in n) && (n.component === "Insert" || n.component === "Update" || n.component === "Delete")
+  );
+  if (writes.length === 0) {
+    throw new Error(`scp write: Command '${component.name}' has no base write (Insert/Update/Delete) node`);
+  }
+  if (writes.length > 1) {
+    throw new Error(
+      `scp write: Command '${component.name}' has ${writes.length} base write nodes; WS5 initial scope is a SINGLE-statement Command + write-time relations (multi-write DAG is WS8, spec \xA76/\xA713).`
+    );
+  }
+  return writes[0];
+}
+function compileWriteBundle(contract, entry2, writes, phase, dialectName = "sqlite") {
+  const component = contract.components.find((c) => c.name === entry2);
+  if (component === void 0) throw new Error(`scp write: entry component '${entry2}' not found in contract`);
+  const lifecycle = lifecycleFor(writes, phase);
+  if (lifecycle === void 0) {
+    throw new Error(`scp write: the '${phase}' lifecycle is not declared in the entityWrites save contract`);
+  }
+  const writeNode = baseWriteNodeOf(component);
+  const baseOp = dialectName === "mysql" ? mysqlPkHint(compileWriteNode(writeNode)) : compileWriteNode(writeNode);
+  const base = { op: baseOp, label: `${writeNode.component}` };
+  const plan = deriveTransactionPlan(phase, [base], lifecycle, dialectName);
+  return {
+    dialect: dialectName,
+    name: component.name,
+    statement: { sql: baseOp.sql, params: baseOp.params },
+    optionalHeads: [],
+    relations: {},
+    transaction: plan
+  };
+}
+function compileCompositeWriteBundle(contract, entries, phase, dialectName = "sqlite") {
+  if (entries.length < 2) {
+    throw new Error("scp write: a composite write bundle needs at least 2 named write members (use compileWriteBundle for a single write).");
+  }
+  const bases = [];
+  let firstBaseOp;
+  let firstName = "";
+  for (const e of entries) {
+    const component = contract.components.find((c) => c.name === e.entry);
+    if (component === void 0) throw new Error(`scp write: entry component '${e.entry}' not found in contract`);
+    if (firstBaseOp === void 0) firstName = component.name;
+    const writeNode = baseWriteNodeOf(component);
+    const baseOp = compileWriteNode(writeNode);
+    if (firstBaseOp === void 0) firstBaseOp = baseOp;
+    bases.push({ op: baseOp, label: `${writeNode.component} ${e.name}`, name: e.name, effects: e.lifecycle.effects });
+  }
+  const plan = deriveTransactionPlan(phase, bases, { effects: {} }, dialectName);
+  return {
+    dialect: dialectName,
+    name: firstName,
+    statement: { sql: firstBaseOp.sql, params: firstBaseOp.params },
+    optionalHeads: [],
+    relations: {},
+    transaction: plan
+  };
+}
+function flattenBatchOp(node, label) {
+  const assembled = assembleMakeSQL(node);
+  return { sql: assembled.sql, params: assembled.params, label };
+}
+function compileCreateManyBundle(name, options, dialectName = "sqlite") {
+  const components2 = compileInsertMany(dialectName, options);
+  const ops = components2.map((c, i) => {
+    const flat = flattenBatchOp(c, `createMany group ${i}`);
+    if (dialectName === "mysql" && options.pk !== void 0 && options.returning !== void 0) {
+      return { ...flat, ...mysqlPkHint({ sql: flat.sql, params: flat.params, pk: options.pk }) };
+    }
+    return flat;
+  });
+  const plan = deriveBatchPlan("create", ops);
+  return { dialect: dialectName, name, statement: { sql: ops[0]?.sql ?? "", params: ops[0]?.params ?? [] }, optionalHeads: [], relations: {}, transaction: plan };
+}
+function compileUpdateManyBundle(name, options, dialectName = "sqlite") {
+  const op = flattenBatchOp(compileUpdateMany(dialectName, options), "updateMany");
+  const plan = deriveBatchPlan("update", [op]);
+  return { dialect: dialectName, name, statement: { sql: op.sql, params: op.params }, optionalHeads: [], relations: {}, transaction: plan };
+}
+function compileDeleteManyBundle(name, options, dialectName = "sqlite") {
+  const components2 = compileDeleteMany({ dialect: dialectName, ...options });
+  const ops = components2.map((c, i) => flattenBatchOp(c, `deleteMany group ${i}`));
+  if (ops.length === 0) {
+    return { dialect: dialectName, name, statement: { sql: "", params: [] }, optionalHeads: [], relations: {}, transaction: { phase: "remove", entityFrom: null, statements: [], onIdempotentHit: "rollback" } };
+  }
+  const plan = deriveBatchPlan("remove", ops);
+  return { dialect: dialectName, name, statement: { sql: ops[0].sql, params: ops[0].params }, optionalHeads: [], relations: {}, transaction: plan };
+}
+function executeCompositeCommand(contract, entries, phase, input, options) {
+  const bundle = compileCompositeWriteBundle(contract, entries, phase, options.dialect);
+  return executeTransactionBundle(bundle, input, options);
+}
+function executeCommand(contract, writes, phase, input, options) {
+  const bundle = compileWriteBundle(contract, options.entry, writes, phase, options.dialect);
+  return executeTransactionBundle(bundle, input, options);
+}
+function executeTransactionBundle(bundle, input, options) {
+  if (bundle.transaction === void 0) {
+    throw new Error("scp write: this bundle carries no transaction plan (not a write-time-relations Command bundle)");
+  }
+  return executeTransaction(options.db, bundle.transaction, input, bundle.dialect);
+}
+function read(contract, input, options) {
+  return readBundle(compileBundle(contract, options.entry, options.relations, options.dialect), input, options);
+}
+function readBundle(bundle, input, options) {
+  const out = executeBundle(bundle, input, options);
+  if (!Array.isArray(out)) {
+    throw new Error(
+      `scp read: the read behavior output is not a row list (got ${out === null ? "null" : typeof out}); the typed-object read surface expects a Select-shaped output`
+    );
+  }
+  const rawRows = out;
+  const readOpts = {
+    ...options.with !== void 0 ? { with: options.with } : {},
+    ...options.hydrate !== void 0 ? { hydrate: options.hydrate } : {},
+    // CROSS-DB relations (V0 R1): forward the connection registry so a tagged relation routes to
+    // its target DB. Absent for a single-DB read (every relation runs on the primary `db`).
+    ...options.connections !== void 0 ? { connections: options.connections } : {}
+  };
+  return buildResultSet(rawRows, bundle.relations, options.db, readOpts);
+}
+
+// src/scp/codegen.ts
+import { generateModule } from "behavior-contracts";
+var CODEGEN_LANGUAGES = ["typescript", "python", "go", "rust", "php"];
+function bundleToPortableIR(bundle) {
+  if (bundle.readGraph !== void 0) return bundle.readGraph.ir;
+  return makeSqlComponentIR(bundle.name);
+}
+function companionOf(bundle) {
+  const base = {
+    dialect: bundle.dialect,
+    optionalHeads: bundle.optionalHeads,
+    relations: bundle.relations,
+    ...bundle.readGraph !== void 0 ? { readGraph: bundle.readGraph } : {},
+    ...bundle.statement !== void 0 ? { statement: bundle.statement } : {}
+  };
+  return bundle.transaction === void 0 ? base : { ...base, transaction: bundle.transaction };
+}
+function assertLanguageSupported(language, registered) {
+  if (!CODEGEN_LANGUAGES.includes(language)) {
+    throw new Error(
+      `litedbmodel codegen: language '${language}' is not a supported target (supported: ${CODEGEN_LANGUAGES.join(", ")})`
+    );
+  }
+  if (!registered.includes(language)) {
+    throw new Error(
+      `litedbmodel codegen: bc's shared generator does not register an emitter for '${language}' (bc registered: ${[...registered].sort().join(", ")}). This is a bc#13 capability limit \u2014 ESCALATE to bc (bc#22 pattern), never fork a litedbmodel-local generator (codegen \u306F\u4E0A\u6D41\u6240\u6709, spec \xA79).`
+    );
+  }
+}
+function generateCodegenArtifact(bundle, language, registeredLanguages, runtimeImport) {
+  assertLanguageSupported(language, registeredLanguages);
+  const ir = bundleToPortableIR(bundle);
+  const module = generateModule(ir, runtimeImport === void 0 ? { language } : { language, runtimeImport });
+  return { language, module, companion: companionOf(bundle), ir, bundle };
+}
+function codegenExecuteBundleForTest(artifact, input, db) {
+  return executeBundle(artifact.bundle, input, { db });
+}
+
+// src/scp/index.ts
+import {
+  SemanticBehavior as SemanticBehavior2,
+  behavior,
+  when,
+  concat,
+  add,
+  sub,
+  mul,
+  div,
+  mod,
+  neg,
+  eq as eq2,
+  ne as ne2,
+  lt as lt2,
+  le as le2,
+  gt as gt2,
+  ge as ge2,
+  and,
+  or,
+  not,
+  coalesce,
+  len,
+  opt
+} from "behavior-contracts";
+export {
+  CATALOG_NAMES,
+  CODEGEN_LANGUAGES,
+  ENTITY_ROOT,
+  FindFilterLeakError,
+  LITEDBMODEL_CATALOG,
+  LITEDBMODEL_MAKESQL_CATALOG,
+  MAKESQL,
+  MYSQL,
+  PG_ARRAY_CAST_TOKEN,
+  POSTGRES,
+  RELATION_CONTEXT,
+  RELATION_KEYS_HEAD,
+  RelationContext,
+  SQLITE,
+  SemanticBehavior2 as SemanticBehavior,
+  SqlFailure,
+  WRITE_CATALOG_NAMES,
+  WRITE_PORT_FAMILIES,
+  add,
+  and,
+  andTrailing,
+  assembleMakeSQL,
+  assertComponentGraphPortable,
+  assertComponentPortable,
+  assertComponentsInCatalog,
+  assertExprPortable,
+  assertFindFilterFolded,
+  assertLanguageSupported,
+  behavior,
+  buildResultSet,
+  builderFor,
+  bundleToPortableIR,
+  catalogEntry,
+  coalesce,
+  codegenExecuteBundleForTest,
+  compileAuthoredBehavior,
+  compileAuthoredNode,
+  compileBundle,
+  compileCompositeKeyLimited,
+  compileCompositeKeyStaticUnlimited,
+  compileCompositeKeyUnlimited,
+  compileCompositeWriteBundle,
+  compileCreateManyBundle,
+  compileDelete as compileDeleteMakeSQL,
+  compileDeleteMany,
+  compileDeleteManyBundle,
+  compileEager,
+  compileInsert as compileInsertMakeSQL,
+  compileReadGraph,
+  compileRelationMap,
+  compileRelationOp,
+  compileSelect as compileSelectMakeSQL,
+  compileSelectNode,
+  compileSingleKeyLimited,
+  compileSingleKeyUnlimited,
+  compileStaticBundle,
+  compileUpdateMany,
+  compileUpdateManyBundle,
+  compileUpdateSingle,
+  compileWhere,
+  compileWriteBundle,
+  compileWriteNode,
+  components,
+  composeMakeSQL,
+  concat,
+  countingDriver,
+  deriveContractEffect,
+  deriveTransactionPlan,
+  dialectFor,
+  distributeToParent,
+  div,
+  edgeWrites,
+  entityWrites,
+  eq2 as eq,
+  executeBehavior,
+  executeBehaviorAsync,
+  executeBundle,
+  executeBundleAsync,
+  executeCommand,
+  executeCompositeCommand,
+  executeReadBehavior,
+  executeReadGraph,
+  executeReadGraphAsync,
+  executeStaticBundle,
+  executeStaticWrite,
+  executeTransaction,
+  executeTransactionBundle,
+  findFilterKeys,
+  formatterFor,
+  ge2 as ge,
+  generateCodegenArtifact,
+  gt2 as gt,
+  inColumn,
+  inferPgArrayType,
+  isMakeSQL,
+  le2 as le,
+  len,
+  lifecycleFor,
+  lt2 as lt,
+  makeSqlCatalogEntry,
+  makeSqlComponentIR,
+  makeSqlHandler,
+  makeSqlHandlerSync,
+  makeSqlInput,
+  mapSqliteError,
+  mod,
+  mul,
+  mysqlPkHint,
+  mysqlPoolExecutor,
+  ne2 as ne,
+  neg,
+  noCastFormatter,
+  not,
+  opt,
+  or,
+  parseEffectPath,
+  pgCastFormatter,
+  pgPoolExecutor,
+  publishBehaviors,
+  read,
+  readBundle,
+  readRelationContext,
+  renderPlaceholders,
+  renderPorts,
+  renderReadPrimary,
+  renderTxStatement,
+  resolvePgArrayCast,
+  runRelationOp,
+  stripMysqlPkHint,
+  sub,
+  toDollarPlaceholders,
+  when,
+  whereBetween,
+  whereCast,
+  whereClause,
+  whereDynamic,
+  whereEq,
+  whereExists,
+  whereGe,
+  whereGt,
+  whereILike,
+  whereImmediate,
+  whereIn,
+  whereInSubquery,
+  whereIsNull,
+  whereLe,
+  whereLike,
+  whereLt,
+  whereNe,
+  whereTupleIn
+};