@b9g/zen 0.1.0

package/src/zen.js

@@ -0,0 +1,2143 @@
+/// <reference types="./zen.d.ts" />
+import "../chunk-2IEEEMRN.js";
+import {
+  AlreadyExistsError,
+  CURRENT_DATE,
+  CURRENT_TIME,
+  CURRENT_TIMESTAMP,
+  ConnectionError,
+  ConstraintPreflightError,
+  ConstraintViolationError,
+  DatabaseError,
+  EnsureError,
+  MigrationError,
+  MigrationLockError,
+  NOW,
+  NotFoundError,
+  QueryError,
+  SchemaDriftError,
+  TODAY,
+  TableDefinitionError,
+  TransactionError,
+  ValidationError,
+  decodeData,
+  extendZod,
+  hasErrorCode,
+  ident,
+  isDatabaseError,
+  isSQLBuiltin,
+  isSQLIdentifier,
+  isSQLTemplate,
+  makeTemplate,
+  resolveSQLBuiltin,
+  table,
+  validateWithStandardSchema
+} from "../chunk-56M5Z3A6.js";
+
+// src/zen.ts
+import { z as zod } from "zod";
+
+// src/impl/database.ts
+import { z } from "zod";
+
+// src/impl/query.ts
+function extractEntityData(row, tableName) {
+  const prefix = `${tableName}.`;
+  const entity = {};
+  let hasData = false;
+  for (const [key, value] of Object.entries(row)) {
+    if (key.startsWith(prefix)) {
+      const fieldName = key.slice(prefix.length);
+      entity[fieldName] = value;
+      if (value !== null && value !== void 0) {
+        hasData = true;
+      }
+    }
+  }
+  return hasData ? entity : null;
+}
+function getPrimaryKeyValue(entity, table2) {
+  const pk = table2.meta.primary;
+  if (pk === null) {
+    return null;
+  }
+  const value = entity[pk];
+  return value !== null && value !== void 0 ? String(value) : null;
+}
+function entityKey(tableName, primaryKey) {
+  return `${tableName}:${primaryKey}`;
+}
+function buildEntityMap(rows, tables) {
+  const entities = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    for (const table2 of tables) {
+      const data = extractEntityData(row, table2.name);
+      if (!data)
+        continue;
+      const pk = getPrimaryKeyValue(data, table2);
+      if (!pk)
+        continue;
+      const key = entityKey(table2.name, pk);
+      if (!entities.has(key)) {
+        const decoded = decodeData(table2, data);
+        const parsed = validateWithStandardSchema(
+          table2.schema,
+          decoded
+        );
+        entities.set(key, parsed);
+      }
+    }
+  }
+  return entities;
+}
+function resolveReferences(entities, tables) {
+  for (const table2 of tables) {
+    const refs = table2.references();
+    if (refs.length === 0)
+      continue;
+    const prefix = `${table2.name}:`;
+    for (const [key, entity] of entities) {
+      if (!key.startsWith(prefix))
+        continue;
+      for (const ref of refs) {
+        const foreignKeyValue = entity[ref.fieldName];
+        const refEntity = foreignKeyValue === null || foreignKeyValue === void 0 ? null : entities.get(
+          entityKey(ref.table.name, String(foreignKeyValue))
+        ) ?? null;
+        Object.defineProperty(entity, ref.as, {
+          value: refEntity,
+          enumerable: true,
+          writable: false,
+          configurable: true
+        });
+      }
+    }
+  }
+  const reverseIndex = /* @__PURE__ */ new Map();
+  for (const table2 of tables) {
+    const refs = table2.references();
+    if (refs.length === 0)
+      continue;
+    for (const ref of refs) {
+      if (!ref.reverseAs)
+        continue;
+      const indexKey = `${table2.name}:${ref.fieldName}`;
+      const fkIndex = /* @__PURE__ */ new Map();
+      const prefix = `${table2.name}:`;
+      for (const [key, entity] of entities) {
+        if (!key.startsWith(prefix))
+          continue;
+        const fkValue = entity[ref.fieldName];
+        if (fkValue === null || fkValue === void 0)
+          continue;
+        const fkStr = String(fkValue);
+        if (!fkIndex.has(fkStr)) {
+          fkIndex.set(fkStr, []);
+        }
+        fkIndex.get(fkStr).push(entity);
+      }
+      reverseIndex.set(indexKey, fkIndex);
+    }
+  }
+  for (const table2 of tables) {
+    const refs = table2.references();
+    if (refs.length === 0)
+      continue;
+    for (const ref of refs) {
+      if (!ref.reverseAs)
+        continue;
+      const indexKey = `${table2.name}:${ref.fieldName}`;
+      const fkIndex = reverseIndex.get(indexKey);
+      if (!fkIndex)
+        continue;
+      const targetPrefix = `${ref.table.name}:`;
+      for (const [key, entity] of entities) {
+        if (!key.startsWith(targetPrefix))
+          continue;
+        const pk = entity[ref.table.meta.primary];
+        if (pk === null || pk === void 0)
+          continue;
+        const pkStr = String(pk);
+        Object.defineProperty(entity, ref.reverseAs, {
+          value: fkIndex.get(pkStr) ?? [],
+          enumerable: false,
+          writable: false,
+          configurable: true
+        });
+      }
+    }
+  }
+}
+function applyDerivedProperties(entities, tables) {
+  for (const table2 of tables) {
+    const derive = table2.meta.derive;
+    if (!derive)
+      continue;
+    const prefix = `${table2.name}:`;
+    for (const [key, entity] of entities) {
+      if (!key.startsWith(prefix))
+        continue;
+      for (const [propName, deriveFn] of Object.entries(derive)) {
+        Object.defineProperty(entity, propName, {
+          get() {
+            return deriveFn(this);
+          },
+          enumerable: false,
+          configurable: true
+        });
+      }
+    }
+  }
+}
+function extractMainEntities(rows, mainTable, entities) {
+  const results = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const row of rows) {
+    const data = extractEntityData(row, mainTable.name);
+    if (!data)
+      continue;
+    const pk = getPrimaryKeyValue(data, mainTable);
+    if (!pk)
+      continue;
+    const key = entityKey(mainTable.name, pk);
+    if (seen.has(key))
+      continue;
+    seen.add(key);
+    const entity = entities.get(key);
+    if (entity) {
+      results.push(entity);
+    }
+  }
+  return results;
+}
+function validateRegisteredTables(rows, tables) {
+  if (rows.length === 0)
+    return;
+  const registeredPrefixes = new Set(tables.map((t) => `${t.name}.`));
+  const unregisteredTables = [];
+  const firstRow = rows[0];
+  for (const key of Object.keys(firstRow)) {
+    const dotIndex = key.indexOf(".");
+    if (dotIndex === -1)
+      continue;
+    const prefix = key.slice(0, dotIndex + 1);
+    if (!registeredPrefixes.has(prefix)) {
+      const tableName = key.slice(0, dotIndex);
+      if (!unregisteredTables.includes(tableName)) {
+        unregisteredTables.push(tableName);
+      }
+    }
+  }
+  if (unregisteredTables.length > 0) {
+    const tableList = unregisteredTables.map((t) => `"${t}"`).join(", ");
+    throw new Error(
+      `Query results contain columns for table(s) ${tableList} not passed to all()/one(). Add them to the tables array, or use query() for raw results.`
+    );
+  }
+}
+function normalize(rows, tables) {
+  if (tables.length === 0) {
+    throw new Error("At least one table is required");
+  }
+  if (rows.length === 0) {
+    return [];
+  }
+  validateRegisteredTables(rows, tables);
+  const entities = buildEntityMap(rows, tables);
+  resolveReferences(entities, tables);
+  applyDerivedProperties(entities, tables);
+  const mainTable = tables[0];
+  return extractMainEntities(rows, mainTable, entities);
+}
+function normalizeOne(row, tables) {
+  if (!row)
+    return null;
+  const results = normalize([row], tables);
+  return results[0] ?? null;
+}
+
+// src/impl/database.ts
+var DB_EXPR = Symbol.for("@b9g/zen:db-expr");
+function isDBExpression(value) {
+  return value !== null && typeof value === "object" && DB_EXPR in value && value[DB_EXPR] === true;
+}
+function createDBExpr(strings, values = []) {
+  return { [DB_EXPR]: true, strings, values };
+}
+function extractDBExpressions(data, table2) {
+  const regularData = {};
+  const expressions = {};
+  const symbols = {};
+  for (const [key, value] of Object.entries(data)) {
+    if (isDBExpression(value)) {
+      if (table2) {
+        const fieldMeta = table2.meta.fields[key];
+        if (fieldMeta?.encode || fieldMeta?.decode) {
+          throw new Error(
+            `Cannot use DB expression for field "${key}" which has encode/decode. DB expressions bypass encoding and are sent directly to the database.`
+          );
+        }
+      }
+      expressions[key] = value;
+    } else if (isSQLBuiltin(value)) {
+      if (table2) {
+        const fieldMeta = table2.meta.fields[key];
+        if (fieldMeta?.encode || fieldMeta?.decode) {
+          throw new Error(
+            `Cannot use SQL symbol for field "${key}" which has encode/decode. SQL symbols bypass encoding and are sent directly to the database.`
+          );
+        }
+      }
+      symbols[key] = value;
+    } else {
+      regularData[key] = value;
+    }
+  }
+  return { regularData, expressions, symbols };
+}
+function injectSchemaExpressions(table2, data, operation) {
+  const result = { ...data };
+  for (const [fieldName, fieldMeta] of Object.entries(table2.meta.fields)) {
+    if (fieldName in data)
+      continue;
+    if (fieldMeta.autoIncrement)
+      continue;
+    const meta = operation === "insert" ? fieldMeta.inserted ?? fieldMeta.upserted : fieldMeta.updated ?? fieldMeta.upserted;
+    if (!meta)
+      continue;
+    if (meta.type === "sql") {
+      result[fieldName] = createDBExpr(
+        meta.template[0],
+        meta.template.slice(1)
+      );
+    } else if (meta.type === "symbol") {
+      result[fieldName] = meta.symbol;
+    } else if (meta.type === "function") {
+      result[fieldName] = meta.fn();
+    }
+  }
+  return result;
+}
+function encodeData(table2, data) {
+  const encoded = {};
+  const shape = table2.schema.shape;
+  for (const [key, value] of Object.entries(data)) {
+    const fieldMeta = table2.meta.fields[key];
+    const fieldSchema = shape?.[key];
+    if (fieldMeta?.encode && typeof fieldMeta.encode === "function") {
+      encoded[key] = fieldMeta.encode(value);
+    } else if (fieldSchema) {
+      let core = fieldSchema;
+      while (typeof core.unwrap === "function") {
+        if (core instanceof z.ZodArray || core instanceof z.ZodObject) {
+          break;
+        }
+        core = core.unwrap();
+      }
+      if ((core instanceof z.ZodObject || core instanceof z.ZodArray) && value !== null && value !== void 0) {
+        encoded[key] = JSON.stringify(value);
+      } else {
+        encoded[key] = value;
+      }
+    } else {
+      encoded[key] = value;
+    }
+  }
+  return encoded;
+}
+function mergeExpression(baseStrings, baseValues, expr) {
+  baseStrings[baseStrings.length - 1] += expr.strings[0];
+  for (let i = 1; i < expr.strings.length; i++) {
+    baseStrings.push(expr.strings[i]);
+  }
+  baseValues.push(...expr.values);
+}
+function buildInsertParts(tableName, data, expressions, symbols = {}) {
+  const regularCols = Object.keys(data);
+  const exprCols = Object.keys(expressions);
+  const symbolCols = Object.keys(symbols);
+  const allCols = [...regularCols, ...symbolCols, ...exprCols];
+  if (allCols.length === 0) {
+    throw new Error("Insert requires at least one column");
+  }
+  const strings = ["INSERT INTO "];
+  const values = [];
+  values.push(ident(tableName));
+  strings.push(" (");
+  for (let i = 0; i < allCols.length; i++) {
+    values.push(ident(allCols[i]));
+    strings.push(i < allCols.length - 1 ? ", " : ") VALUES (");
+  }
+  const valueCols = [...regularCols, ...symbolCols];
+  for (let i = 0; i < valueCols.length; i++) {
+    const col = valueCols[i];
+    values.push(col in data ? data[col] : symbols[col]);
+    strings.push(i < valueCols.length - 1 ? ", " : "");
+  }
+  for (let i = 0; i < exprCols.length; i++) {
+    if (valueCols.length > 0 || i > 0) {
+      strings[strings.length - 1] += ", ";
+    }
+    mergeExpression(strings, values, expressions[exprCols[i]]);
+  }
+  strings[strings.length - 1] += ")";
+  return {
+    strings: makeTemplate(strings),
+    values
+  };
+}
+function buildUpdateByIdParts(tableName, pk, data, expressions, id, symbols = {}) {
+  const regularCols = Object.keys(data);
+  const exprCols = Object.keys(expressions);
+  const symbolCols = Object.keys(symbols);
+  const valueCols = [...regularCols, ...symbolCols];
+  const strings = ["UPDATE "];
+  const values = [];
+  values.push(ident(tableName));
+  strings.push(" SET ");
+  for (let i = 0; i < valueCols.length; i++) {
+    const col = valueCols[i];
+    values.push(ident(col));
+    strings.push(" = ");
+    values.push(col in data ? data[col] : symbols[col]);
+    strings.push(i < valueCols.length - 1 ? ", " : "");
+  }
+  for (let i = 0; i < exprCols.length; i++) {
+    if (valueCols.length > 0 || i > 0) {
+      strings[strings.length - 1] += ", ";
+    }
+    values.push(ident(exprCols[i]));
+    strings.push(" = ");
+    mergeExpression(strings, values, expressions[exprCols[i]]);
+  }
+  strings[strings.length - 1] += " WHERE ";
+  values.push(ident(pk));
+  strings.push(" = ");
+  values.push(id);
+  strings.push("");
+  return {
+    strings: makeTemplate(strings),
+    values
+  };
+}
+function buildUpdateByIdsParts(tableName, pk, data, expressions, ids, symbols = {}) {
+  const regularCols = Object.keys(data);
+  const exprCols = Object.keys(expressions);
+  const symbolCols = Object.keys(symbols);
+  const valueCols = [...regularCols, ...symbolCols];
+  const strings = ["UPDATE "];
+  const values = [];
+  values.push(ident(tableName));
+  strings.push(" SET ");
+  for (let i = 0; i < valueCols.length; i++) {
+    const col = valueCols[i];
+    values.push(ident(col));
+    strings.push(" = ");
+    values.push(col in data ? data[col] : symbols[col]);
+    strings.push(i < valueCols.length - 1 ? ", " : "");
+  }
+  for (let i = 0; i < exprCols.length; i++) {
+    if (valueCols.length > 0 || i > 0) {
+      strings[strings.length - 1] += ", ";
+    }
+    values.push(ident(exprCols[i]));
+    strings.push(" = ");
+    mergeExpression(strings, values, expressions[exprCols[i]]);
+  }
+  strings[strings.length - 1] += " WHERE ";
+  values.push(ident(pk));
+  strings.push(" IN (");
+  for (let i = 0; i < ids.length; i++) {
+    values.push(ids[i]);
+    strings.push(i < ids.length - 1 ? ", " : ")");
+  }
+  return {
+    strings: makeTemplate(strings),
+    values
+  };
+}
+function buildSelectCols(tables) {
+  const strings = [""];
+  const values = [];
+  let needsComma = false;
+  for (const table2 of tables) {
+    const tableName = table2.name;
+    const shape = table2.schema.shape;
+    const derivedFields = new Set(
+      table2.meta.derivedFields ?? []
+    );
+    for (const fieldName of Object.keys(shape)) {
+      if (derivedFields.has(fieldName))
+        continue;
+      if (needsComma) {
+        strings[strings.length - 1] += ", ";
+      }
+      values.push(ident(tableName));
+      strings.push(".");
+      values.push(ident(fieldName));
+      strings.push(" AS ");
+      values.push(ident(`${tableName}.${fieldName}`));
+      strings.push("");
+      needsComma = true;
+    }
+    const derivedExprs = table2.meta.derivedExprs ?? [];
+    for (const expr of derivedExprs) {
+      if (needsComma) {
+        strings[strings.length - 1] += ", ";
+      }
+      const alias = `${tableName}.${expr.fieldName}`;
+      strings[strings.length - 1] += "(";
+      const exprStrings = expr.template[0];
+      const exprValues = expr.template.slice(1);
+      strings[strings.length - 1] += exprStrings[0];
+      for (let i = 1; i < exprStrings.length; i++) {
+        strings.push(exprStrings[i]);
+      }
+      values.push(...exprValues);
+      strings[strings.length - 1] += ") AS ";
+      values.push(ident(alias));
+      strings.push("");
+      needsComma = true;
+    }
+  }
+  return { strings, values };
+}
+function buildSelectByPkParts(tableName, pk, id) {
+  return {
+    strings: makeTemplate(["SELECT * FROM ", " WHERE ", " = ", ""]),
+    values: [ident(tableName), ident(pk), id]
+  };
+}
+function buildSelectByPksParts(tableName, pk, ids) {
+  const strings = ["SELECT * FROM ", " WHERE ", " IN ("];
+  const values = [ident(tableName), ident(pk)];
+  for (let i = 0; i < ids.length; i++) {
+    values.push(ids[i]);
+    strings.push(i < ids.length - 1 ? ", " : ")");
+  }
+  return {
+    strings: makeTemplate(strings),
+    values
+  };
+}
+function buildDeleteByPkParts(tableName, pk, id) {
+  return {
+    strings: makeTemplate(["DELETE FROM ", " WHERE ", " = ", ""]),
+    values: [ident(tableName), ident(pk), id]
+  };
+}
+function buildDeleteByPksParts(tableName, pk, ids) {
+  const strings = ["DELETE FROM ", " WHERE ", " IN ("];
+  const values = [ident(tableName), ident(pk)];
+  for (let i = 0; i < ids.length; i++) {
+    values.push(ids[i]);
+    strings.push(i < ids.length - 1 ? ", " : ")");
+  }
+  return {
+    strings: makeTemplate(strings),
+    values
+  };
+}
+function appendReturning(parts) {
+  const strings = [...parts.strings];
+  strings[strings.length - 1] += " RETURNING *";
+  return {
+    strings: makeTemplate(strings),
+    values: parts.values
+  };
+}
+function expandFragments(strings, values) {
+  const newStrings = [strings[0]];
+  const newValues = [];
+  for (let i = 0; i < values.length; i++) {
+    const value = values[i];
+    if (isSQLTemplate(value)) {
+      const valueStrings = value[0];
+      const valueValues = value.slice(1);
+      newStrings[newStrings.length - 1] += valueStrings[0];
+      for (let j = 1; j < valueStrings.length; j++) {
+        newStrings.push(valueStrings[j]);
+      }
+      newValues.push(...valueValues);
+      newStrings[newStrings.length - 1] += strings[i + 1];
+    } else {
+      newStrings.push(strings[i + 1]);
+      newValues.push(value);
+    }
+  }
+  return {
+    strings: makeTemplate(newStrings),
+    values: newValues
+  };
+}
+var DatabaseUpgradeEvent = class extends Event {
+  oldVersion;
+  newVersion;
+  #promises = [];
+  constructor(type, init) {
+    super(type);
+    this.oldVersion = init.oldVersion;
+    this.newVersion = init.newVersion;
+  }
+  /**
+   * Extend the event lifetime until the promise settles.
+   * Like ExtendableEvent.waitUntil() from ServiceWorker.
+   */
+  waitUntil(promise) {
+    this.#promises.push(promise);
+  }
+  /**
+   * @internal Wait for all waitUntil promises to settle.
+   */
+  async _settle() {
+    await Promise.all(this.#promises);
+  }
+};
+var Transaction = class {
+  #driver;
+  constructor(driver) {
+    this.#driver = driver;
+  }
+  all(tables) {
+    const tableArray = Array.isArray(tables) ? tables : [tables];
+    return async (strings, ...values) => {
+      const { strings: colStrings, values: colValues } = buildSelectCols(tableArray);
+      const { strings: expandedStrings, values: expandedValues } = expandFragments(strings, values);
+      const queryStrings = ["SELECT "];
+      const queryValues = [];
+      queryStrings[0] += colStrings[0];
+      for (let i = 1; i < colStrings.length; i++) {
+        queryStrings.push(colStrings[i]);
+      }
+      queryValues.push(...colValues);
+      queryStrings[queryStrings.length - 1] += " FROM ";
+      queryValues.push(ident(tableArray[0].name));
+      queryStrings.push(" ");
+      queryStrings[queryStrings.length - 1] += expandedStrings[0];
+      for (let i = 1; i < expandedStrings.length; i++) {
+        queryStrings.push(expandedStrings[i]);
+      }
+      queryValues.push(...expandedValues);
+      const rows = await this.#driver.all(
+        makeTemplate(queryStrings),
+        queryValues
+      );
+      return normalize(rows, tableArray);
+    };
+  }
+  get(tables, id) {
+    if (id !== void 0) {
+      const table2 = tables;
+      const pk = table2.meta.primary;
+      if (!pk) {
+        return Promise.reject(
+          new Error(`Table ${table2.name} has no primary key defined`)
+        );
+      }
+      const { strings, values } = buildSelectByPkParts(table2.name, pk, id);
+      return this.#driver.get(strings, values).then((row) => {
+        if (!row)
+          return null;
+        return decodeData(table2, row);
+      });
+    }
+    const tableArray = Array.isArray(tables) ? tables : [tables];
+    return async (strings, ...values) => {
+      const { strings: colStrings, values: colValues } = buildSelectCols(tableArray);
+      const { strings: expandedStrings, values: expandedValues } = expandFragments(strings, values);
+      const queryStrings = ["SELECT "];
+      const queryValues = [];
+      queryStrings[0] += colStrings[0];
+      for (let i = 1; i < colStrings.length; i++) {
+        queryStrings.push(colStrings[i]);
+      }
+      queryValues.push(...colValues);
+      queryStrings[queryStrings.length - 1] += " FROM ";
+      queryValues.push(ident(tableArray[0].name));
+      queryStrings.push(" ");
+      queryStrings[queryStrings.length - 1] += expandedStrings[0];
+      for (let i = 1; i < expandedStrings.length; i++) {
+        queryStrings.push(expandedStrings[i]);
+      }
+      queryValues.push(...expandedValues);
+      const row = await this.#driver.get(
+        makeTemplate(queryStrings),
+        queryValues
+      );
+      return normalizeOne(row, tableArray);
+    };
+  }
+  async insert(table2, data) {
+    if (Array.isArray(data)) {
+      if (data.length === 0) {
+        return [];
+      }
+      const results = [];
+      for (const row of data) {
+        results.push(await this.#insertOne(table2, row));
+      }
+      return results;
+    }
+    return this.#insertOne(table2, data);
+  }
+  async #insertOne(table2, data) {
+    if (table2.meta.isPartial) {
+      throw new Error(
+        `Cannot insert into partial table "${table2.name}". Use the full table definition instead.`
+      );
+    }
+    if (table2.meta.isDerived) {
+      throw new Error(
+        `Cannot insert into derived table "${table2.name}". Derived tables are SELECT-only.`
+      );
+    }
+    const dataWithSchemaExprs = injectSchemaExpressions(
+      table2,
+      data,
+      "insert"
+    );
+    const { regularData, expressions, symbols } = extractDBExpressions(
+      dataWithSchemaExprs,
+      table2
+    );
+    let schema = table2.schema;
+    const skipFields = { ...expressions, ...symbols };
+    if (Object.keys(skipFields).length > 0) {
+      const skipFieldSchemas = Object.keys(skipFields).reduce(
+        (acc, key) => {
+          acc[key] = table2.schema.shape[key].optional();
+          return acc;
+        },
+        {}
+      );
+      schema = table2.schema.extend(skipFieldSchemas);
+    }
+    const validated = validateWithStandardSchema(
+      schema,
+      regularData
+    );
+    const encoded = encodeData(table2, validated);
+    const insertParts = buildInsertParts(
+      table2.name,
+      encoded,
+      expressions,
+      symbols
+    );
+    if (this.#driver.supportsReturning) {
+      const { strings, values } = appendReturning(insertParts);
+      const row = await this.#driver.get(
+        strings,
+        values
+      );
+      return decodeData(table2, row);
+    }
+    await this.#driver.run(insertParts.strings, insertParts.values);
+    const pk = table2.meta.primary;
+    const pkValue = pk ? encoded[pk] ?? (expressions[pk] ? void 0 : null) : null;
+    if (pk && pkValue !== void 0 && pkValue !== null) {
+      const { strings, values } = buildSelectByPkParts(table2.name, pk, pkValue);
+      const row = await this.#driver.get(
+        strings,
+        values
+      );
+      if (row) {
+        return decodeData(table2, row);
+      }
+    }
+    return validated;
+  }
+  update(table2, data, idOrIds) {
+    if (idOrIds === void 0) {
+      return async (strings, ...values) => {
+        return this.#updateWithWhere(table2, data, strings, values);
+      };
+    }
+    if (Array.isArray(idOrIds)) {
+      return this.#updateByIds(table2, data, idOrIds);
+    }
+    return this.#updateById(table2, data, idOrIds);
+  }
+  async #updateById(table2, data, id) {
+    const pk = table2.meta.primary;
+    if (!pk) {
+      throw new Error(`Table ${table2.name} has no primary key defined`);
+    }
+    if (table2.meta.isDerived) {
+      throw new Error(
+        `Cannot update derived table "${table2.name}". Derived tables are SELECT-only.`
+      );
+    }
+    const dataWithSchemaExprs = injectSchemaExpressions(
+      table2,
+      data,
+      "update"
+    );
+    const { regularData, expressions, symbols } = extractDBExpressions(
+      dataWithSchemaExprs,
+      table2
+    );
+    const partialSchema = table2.schema.partial();
+    const validated = validateWithStandardSchema(
+      partialSchema,
+      regularData
+    );
+    const allColumns = [
+      ...Object.keys(validated),
+      ...Object.keys(expressions),
+      ...Object.keys(symbols)
+    ];
+    if (allColumns.length === 0) {
+      throw new Error("No fields to update");
+    }
+    const encoded = encodeData(table2, validated);
+    const updateParts = buildUpdateByIdParts(
+      table2.name,
+      pk,
+      encoded,
+      expressions,
+      id,
+      symbols
+    );
+    if (this.#driver.supportsReturning) {
+      const { strings, values } = appendReturning(updateParts);
+      const row2 = await this.#driver.get(
+        strings,
+        values
+      );
+      if (!row2)
+        return null;
+      return decodeData(table2, row2);
+    }
+    await this.#driver.run(updateParts.strings, updateParts.values);
+    const { strings: selectStrings, values: selectValues } = buildSelectByPkParts(
+      table2.name,
+      pk,
+      id
+    );
+    const row = await this.#driver.get(
+      selectStrings,
+      selectValues
+    );
+    if (!row)
+      return null;
+    return decodeData(table2, row);
+  }
+  async #updateByIds(table2, data, ids) {
+    if (ids.length === 0) {
+      return [];
+    }
+    const pk = table2.meta.primary;
+    if (!pk) {
+      throw new Error(`Table ${table2.name} has no primary key defined`);
+    }
+    if (table2.meta.isDerived) {
+      throw new Error(
+        `Cannot update derived table "${table2.name}". Derived tables are SELECT-only.`
+      );
+    }
+    const dataWithSchemaExprs = injectSchemaExpressions(
+      table2,
+      data,
+      "update"
+    );
+    const { regularData, expressions, symbols } = extractDBExpressions(
+      dataWithSchemaExprs,
+      table2
+    );
+    const partialSchema = table2.schema.partial();
+    const validated = validateWithStandardSchema(
+      partialSchema,
+      regularData
+    );
+    const allColumns = [
+      ...Object.keys(validated),
+      ...Object.keys(expressions),
+      ...Object.keys(symbols)
+    ];
+    if (allColumns.length === 0) {
+      throw new Error("No fields to update");
+    }
+    const encoded = encodeData(table2, validated);
+    const updateParts = buildUpdateByIdsParts(
+      table2.name,
+      pk,
+      encoded,
+      expressions,
+      ids,
+      symbols
+    );
+    if (this.#driver.supportsReturning) {
+      const { strings, values } = appendReturning(updateParts);
+      const rows2 = await this.#driver.all(
+        strings,
+        values
+      );
+      const resultMap2 = /* @__PURE__ */ new Map();
+      for (const row of rows2) {
+        const entity = decodeData(table2, row);
+        resultMap2.set(row[pk], entity);
+      }
+      return ids.map((id) => resultMap2.get(id) ?? null);
+    }
+    await this.#driver.run(updateParts.strings, updateParts.values);
+    const { strings: selectStrings, values: selectValues } = buildSelectByPksParts(table2.name, pk, ids);
+    const rows = await this.#driver.all(
+      selectStrings,
+      selectValues
+    );
+    const resultMap = /* @__PURE__ */ new Map();
+    for (const row of rows) {
+      const entity = decodeData(table2, row);
+      resultMap.set(row[pk], entity);
+    }
+    return ids.map((id) => resultMap.get(id) ?? null);
+  }
+  async #updateWithWhere(table2, data, strings, templateValues) {
+    if (table2.meta.isDerived) {
+      throw new Error(
+        `Cannot update derived table "${table2.name}". Derived tables are SELECT-only.`
+      );
+    }
+    const pk = table2.meta.primary;
+    if (!pk) {
+      throw new Error(`Table ${table2.name} has no primary key defined`);
+    }
+    const dataWithSchemaExprs = injectSchemaExpressions(
+      table2,
+      data,
+      "update"
+    );
+    const { regularData, expressions } = extractDBExpressions(
+      dataWithSchemaExprs,
+      table2
+    );
+    const partialSchema = table2.schema.partial();
+    const validated = validateWithStandardSchema(
+      partialSchema,
+      regularData
+    );
+    const allColumns = [...Object.keys(validated), ...Object.keys(expressions)];
+    if (allColumns.length === 0) {
+      throw new Error("No fields to update");
+    }
+    const encoded = encodeData(table2, validated);
+    const { strings: whereStrings, values: whereValues } = expandFragments(
+      strings,
+      templateValues
+    );
+    const setCols = Object.keys(encoded);
+    const exprCols = Object.keys(expressions);
+    const queryStrings = ["UPDATE "];
+    const queryValues = [];
+    queryValues.push(ident(table2.name));
+    queryStrings.push(" SET ");
+    for (let i = 0; i < setCols.length; i++) {
+      const col = setCols[i];
+      queryValues.push(ident(col));
+      queryStrings.push(" = ");
+      queryValues.push(encoded[col]);
+      queryStrings.push(i < setCols.length - 1 ? ", " : "");
+    }
+    for (let i = 0; i < exprCols.length; i++) {
+      if (setCols.length > 0 || i > 0) {
+        queryStrings[queryStrings.length - 1] += ", ";
+      }
+      queryValues.push(ident(exprCols[i]));
+      queryStrings.push(" = ");
+      mergeExpression(queryStrings, queryValues, expressions[exprCols[i]]);
+    }
+    queryStrings[queryStrings.length - 1] += " " + whereStrings[0];
+    for (let i = 1; i < whereStrings.length; i++) {
+      queryStrings.push(whereStrings[i]);
+    }
+    queryValues.push(...whereValues);
+    if (this.#driver.supportsReturning) {
+      queryStrings[queryStrings.length - 1] += " RETURNING *";
+      const rows2 = await this.#driver.all(
+        makeTemplate(queryStrings),
+        queryValues
+      );
+      return rows2.map((row) => decodeData(table2, row));
+    }
+    const selectIdStrings = ["SELECT "];
+    const selectIdValues = [];
+    selectIdValues.push(ident(pk));
+    selectIdStrings.push(" FROM ");
+    selectIdValues.push(ident(table2.name));
+    selectIdStrings.push(" " + whereStrings[0]);
+    for (let i = 1; i < whereStrings.length; i++) {
+      selectIdStrings.push(whereStrings[i]);
+    }
+    selectIdValues.push(...whereValues);
+    const idRows = await this.#driver.all(
+      makeTemplate(selectIdStrings),
+      selectIdValues
+    );
+    const ids = idRows.map((r) => r[pk]);
+    if (ids.length === 0) {
+      return [];
+    }
+    await this.#driver.run(makeTemplate(queryStrings), queryValues);
+    const { strings: selectStrings, values: selectVals } = buildSelectByPksParts(
+      table2.name,
+      pk,
+      ids
+    );
+    const rows = await this.#driver.all(
+      selectStrings,
+      selectVals
+    );
+    return rows.map((row) => decodeData(table2, row));
+  }
+  delete(table2, idOrIds) {
+    if (idOrIds === void 0) {
+      return async (strings, ...values) => {
+        const { strings: expandedStrings, values: expandedValues } = expandFragments(strings, values);
+        const deleteStrings = ["DELETE FROM "];
+        const deleteValues = [ident(table2.name)];
+        deleteStrings.push(" " + expandedStrings[0]);
+        for (let i = 1; i < expandedStrings.length; i++) {
+          deleteStrings.push(expandedStrings[i]);
+        }
+        deleteValues.push(...expandedValues);
+        return this.#driver.run(makeTemplate(deleteStrings), deleteValues);
+      };
+    }
+    if (Array.isArray(idOrIds)) {
+      return this.#deleteByIds(table2, idOrIds);
+    }
+    return this.#deleteById(table2, idOrIds);
+  }
+  async #deleteById(table2, id) {
+    const pk = table2.meta.primary;
+    if (!pk) {
+      throw new Error(`Table ${table2.name} has no primary key defined`);
+    }
+    const { strings, values } = buildDeleteByPkParts(table2.name, pk, id);
+    return this.#driver.run(strings, values);
+  }
+  async #deleteByIds(table2, ids) {
+    if (ids.length === 0) {
+      return 0;
+    }
+    const pk = table2.meta.primary;
+    if (!pk) {
+      throw new Error(`Table ${table2.name} has no primary key defined`);
+    }
+    const { strings, values } = buildDeleteByPksParts(table2.name, pk, ids);
+    return this.#driver.run(strings, values);
+  }
+  softDelete(table2, idOrIds) {
+    const softDeleteField = table2.meta.softDeleteField;
+    if (!softDeleteField) {
+      throw new Error(
+        `Table ${table2.name} does not have a soft delete field. Use softDelete() wrapper to mark a field.`
+      );
+    }
+    if (idOrIds === void 0) {
+      return async (strings, ...values) => {
+        return this.#softDeleteWithWhere(table2, strings, values);
+      };
+    }
+    if (Array.isArray(idOrIds)) {
+      return this.#softDeleteByIds(table2, idOrIds);
+    }
+    return this.#softDeleteById(table2, idOrIds);
+  }
+  async #softDeleteById(table2, id) {
+    const pk = table2.meta.primary;
+    if (!pk) {
+      throw new Error(`Table ${table2.name} has no primary key defined`);
+    }
+    const softDeleteField = table2.meta.softDeleteField;
+    const schemaExprs = injectSchemaExpressions(table2, {}, "update");
+    const { expressions, symbols } = extractDBExpressions(schemaExprs);
+    const queryStrings = ["UPDATE "];
+    const queryValues = [];
+    queryValues.push(ident(table2.name));
+    queryStrings.push(" SET ");
+    queryValues.push(ident(softDeleteField));
+    queryStrings.push(" = CURRENT_TIMESTAMP");
+    for (const [field, expr] of Object.entries(expressions)) {
+      if (field !== softDeleteField) {
+        queryStrings[queryStrings.length - 1] += ", ";
+        queryValues.push(ident(field));
+        queryStrings.push(" = ");
+        mergeExpression(queryStrings, queryValues, expr);
+      }
+    }
+    for (const [field, sym] of Object.entries(symbols)) {
+      if (field !== softDeleteField) {
+        queryStrings[queryStrings.length - 1] += ", ";
+        queryValues.push(ident(field));
+        queryStrings.push(` = ${resolveSQLBuiltin(sym)}`);
+      }
+    }
+    queryStrings[queryStrings.length - 1] += " WHERE ";
+    queryValues.push(ident(pk));
+    queryStrings.push(" = ");
+    queryValues.push(id);
+    queryStrings.push("");
+    return this.#driver.run(makeTemplate(queryStrings), queryValues);
+  }
+  async #softDeleteByIds(table2, ids) {
+    if (ids.length === 0) {
+      return 0;
+    }
+    const pk = table2.meta.primary;
+    if (!pk) {
+      throw new Error(`Table ${table2.name} has no primary key defined`);
+    }
+    const softDeleteField = table2.meta.softDeleteField;
+    const schemaExprs = injectSchemaExpressions(table2, {}, "update");
+    const { expressions, symbols } = extractDBExpressions(schemaExprs);
+    const queryStrings = ["UPDATE "];
+    const queryValues = [];
+    queryValues.push(ident(table2.name));
+    queryStrings.push(" SET ");
+    queryValues.push(ident(softDeleteField));
+    queryStrings.push(" = CURRENT_TIMESTAMP");
+    for (const [field, expr] of Object.entries(expressions)) {
+      if (field !== softDeleteField) {
+        queryStrings[queryStrings.length - 1] += ", ";
+        queryValues.push(ident(field));
+        queryStrings.push(" = ");
+        mergeExpression(queryStrings, queryValues, expr);
+      }
+    }
+    for (const [field, sym] of Object.entries(symbols)) {
+      if (field !== softDeleteField) {
+        queryStrings[queryStrings.length - 1] += ", ";
+        queryValues.push(ident(field));
+        queryStrings.push(` = ${resolveSQLBuiltin(sym)}`);
+      }
+    }
+    queryStrings[queryStrings.length - 1] += " WHERE ";
+    queryValues.push(ident(pk));
+    queryStrings.push(" IN (");
+    for (let i = 0; i < ids.length; i++) {
+      queryValues.push(ids[i]);
+      queryStrings.push(i < ids.length - 1 ? ", " : ")");
+    }
+    return this.#driver.run(makeTemplate(queryStrings), queryValues);
+  }
+  async #softDeleteWithWhere(table2, strings, templateValues) {
+    const softDeleteField = table2.meta.softDeleteField;
+    const schemaExprs = injectSchemaExpressions(table2, {}, "update");
+    const { expressions, symbols } = extractDBExpressions(schemaExprs);
+    const { strings: expandedStrings, values: expandedValues } = expandFragments(
+      strings,
+      templateValues
+    );
+    const queryStrings = ["UPDATE "];
+    const queryValues = [];
+    queryValues.push(ident(table2.name));
+    queryStrings.push(" SET ");
+    queryValues.push(ident(softDeleteField));
+    queryStrings.push(" = CURRENT_TIMESTAMP");
+    for (const [field, expr] of Object.entries(expressions)) {
+      if (field !== softDeleteField) {
+        queryStrings[queryStrings.length - 1] += ", ";
+        queryValues.push(ident(field));
+        queryStrings.push(" = ");
+        mergeExpression(queryStrings, queryValues, expr);
+      }
+    }
+    for (const [field, sym] of Object.entries(symbols)) {
+      if (field !== softDeleteField) {
+        queryStrings[queryStrings.length - 1] += ", ";
+        queryValues.push(ident(field));
+        queryStrings.push(` = ${resolveSQLBuiltin(sym)}`);
+      }
+    }
+    queryStrings[queryStrings.length - 1] += " " + expandedStrings[0];
+    for (let i = 1; i < expandedStrings.length; i++) {
+      queryStrings.push(expandedStrings[i]);
+    }
+    queryValues.push(...expandedValues);
+    return this.#driver.run(makeTemplate(queryStrings), queryValues);
+  }
+  // ==========================================================================
+  // Raw - No Normalization
+  // ==========================================================================
+  async query(strings, ...values) {
+    const { strings: expandedStrings, values: expandedValues } = expandFragments(
+      strings,
+      values
+    );
+    return this.#driver.all(expandedStrings, expandedValues);
+  }
+  async exec(strings, ...values) {
+    const { strings: expandedStrings, values: expandedValues } = expandFragments(
+      strings,
+      values
+    );
+    return this.#driver.run(expandedStrings, expandedValues);
+  }
+  async val(strings, ...values) {
+    const { strings: expandedStrings, values: expandedValues } = expandFragments(
+      strings,
+      values
+    );
+    return this.#driver.val(expandedStrings, expandedValues);
+  }
+  // ==========================================================================
+  // Debugging
+  // ==========================================================================
+  /**
+   * Print the generated SQL and parameters without executing.
+   * Useful for debugging query composition and fragment expansion.
+   * Note: SQL shown uses ? placeholders; actual query may use $1, $2 etc.
+   */
+  print(strings, ...values) {
+    const { strings: expandedStrings, values: expandedValues } = expandFragments(
+      strings,
+      values
+    );
+    let sql = expandedStrings[0];
+    for (let i = 1; i < expandedStrings.length; i++) {
+      sql += "?" + expandedStrings[i];
+    }
+    return { sql, params: expandedValues };
+  }
+};
+var Database = class extends EventTarget {
+  #driver;
+  #version = 0;
+  #opened = false;
+  constructor(driver) {
+    super();
+    this.#driver = driver;
+  }
+  /**
+   * Current database schema version.
+   * Returns 0 if database has never been opened.
+   */
+  get version() {
+    return this.#version;
+  }
+  /**
+   * Open the database at a specific version.
+   *
+   * If the requested version is higher than the current version,
+   * fires an "upgradeneeded" event and waits for all waitUntil()
+   * promises before completing.
+   *
+   * Migration safety: Uses exclusive locking to prevent race conditions
+   * when multiple processes attempt migrations simultaneously.
+   *
+   * @example
+   * db.addEventListener("upgradeneeded", (e) => {
+   *   e.waitUntil(runMigrations(e));
+   * });
+   * await db.open(2);
+   */
+  async open(version) {
+    if (this.#opened) {
+      throw new Error("Database already opened");
+    }
+    const runMigration = async () => {
+      await this.#ensureMigrationsTable();
+      const currentVersion = await this.#getCurrentVersionLocked();
+      if (version > currentVersion) {
+        const event = new DatabaseUpgradeEvent("upgradeneeded", {
+          oldVersion: currentVersion,
+          newVersion: version
+        });
+        this.dispatchEvent(event);
+        await event._settle();
+        await this.#setVersion(version);
+      }
+    };
+    if (this.#driver.withMigrationLock) {
+      await this.#driver.withMigrationLock(runMigration);
+    } else {
+      await this.#driver.transaction(runMigration);
+    }
+    this.#version = version;
+    this.#opened = true;
+  }
+  // ==========================================================================
+  // Migration Table Helpers
+  // ==========================================================================
+  async #ensureMigrationsTable() {
+    const createTable = makeTemplate([
+      `CREATE TABLE IF NOT EXISTS _migrations (
+				version INTEGER PRIMARY KEY
+			)`
+    ]);
+    await this.#driver.run(createTable, []);
+  }
+  async #getCurrentVersionLocked() {
+    const selectVersion = makeTemplate([
+      `SELECT MAX(version) as version FROM _migrations`
+    ]);
+    const row = await this.#driver.get(selectVersion, []);
+    return row?.version ?? 0;
+  }
+  async #setVersion(version) {
+    const insertVersion = makeTemplate([
+      `INSERT INTO _migrations (version) VALUES (`,
+      `)`
+    ]);
+    await this.#driver.run(insertVersion, [version]);
+  }
+  all(tables) {
+    const tableArray = Array.isArray(tables) ? tables : [tables];
+    return async (strings, ...values) => {
+      const { strings: colStrings, values: colValues } = buildSelectCols(tableArray);
+      const { strings: expandedStrings, values: expandedValues } = expandFragments(strings, values);
+      const queryStrings = ["SELECT "];
+      const queryValues = [];
+      queryStrings[0] += colStrings[0];
+      for (let i = 1; i < colStrings.length; i++) {
+        queryStrings.push(colStrings[i]);
+      }
+      queryValues.push(...colValues);
+      queryStrings[queryStrings.length - 1] += " FROM ";
+      queryValues.push(ident(tableArray[0].name));
+      queryStrings.push(" ");
+      queryStrings[queryStrings.length - 1] += expandedStrings[0];
+      for (let i = 1; i < expandedStrings.length; i++) {
+        queryStrings.push(expandedStrings[i]);
+      }
+      queryValues.push(...expandedValues);
+      const rows = await this.#driver.all(
+        makeTemplate(queryStrings),
+        queryValues
+      );
+      return normalize(rows, tableArray);
+    };
+  }
+  get(tables, id) {
+    if (id !== void 0) {
+      const table2 = tables;
+      const pk = table2.meta.primary;
+      if (!pk) {
+        return Promise.reject(
+          new Error(`Table ${table2.name} has no primary key defined`)
+        );
+      }
+      const { strings, values } = buildSelectByPkParts(table2.name, pk, id);
+      return this.#driver.get(strings, values).then((row) => {
+        if (!row)
+          return null;
+        return decodeData(table2, row);
+      });
+    }
+    const tableArray = Array.isArray(tables) ? tables : [tables];
+    return async (strings, ...values) => {
+      const { strings: colStrings, values: colValues } = buildSelectCols(tableArray);
+      const { strings: expandedStrings, values: expandedValues } = expandFragments(strings, values);
+      const queryStrings = ["SELECT "];
+      const queryValues = [];
+      queryStrings[0] += colStrings[0];
+      for (let i = 1; i < colStrings.length; i++) {
+        queryStrings.push(colStrings[i]);
+      }
+      queryValues.push(...colValues);
+      queryStrings[queryStrings.length - 1] += " FROM ";
+      queryValues.push(ident(tableArray[0].name));
+      queryStrings.push(" ");
+      queryStrings[queryStrings.length - 1] += expandedStrings[0];
+      for (let i = 1; i < expandedStrings.length; i++) {
+        queryStrings.push(expandedStrings[i]);
+      }
+      queryValues.push(...expandedValues);
+      const row = await this.#driver.get(
+        makeTemplate(queryStrings),
+        queryValues
+      );
+      return normalizeOne(row, tableArray);
+    };
+  }
+  async insert(table2, data) {
+    if (Array.isArray(data)) {
+      if (data.length === 0) {
+        return [];
+      }
+      const results = [];
+      for (const row of data) {
+        results.push(await this.#insertOne(table2, row));
+      }
+      return results;
+    }
+    return this.#insertOne(table2, data);
+  }
+  async #insertOne(table2, data) {
+    if (table2.meta.isPartial) {
+      throw new Error(
+        `Cannot insert into partial table "${table2.name}". Use the full table definition instead.`
+      );
+    }
+    if (table2.meta.isDerived) {
+      throw new Error(
+        `Cannot insert into derived table "${table2.name}". Derived tables are SELECT-only.`
+      );
+    }
+    const dataWithSchemaExprs = injectSchemaExpressions(
+      table2,
+      data,
+      "insert"
+    );
+    const { regularData, expressions, symbols } = extractDBExpressions(
+      dataWithSchemaExprs,
+      table2
+    );
+    let schema = table2.schema;
+    const skipFields = { ...expressions, ...symbols };
+    if (Object.keys(skipFields).length > 0) {
+      const skipFieldSchemas = Object.keys(skipFields).reduce(
+        (acc, key) => {
+          acc[key] = table2.schema.shape[key].optional();
+          return acc;
+        },
+        {}
+      );
+      schema = table2.schema.extend(skipFieldSchemas);
+    }
+    const validated = validateWithStandardSchema(
+      schema,
+      regularData
+    );
+    const encoded = encodeData(table2, validated);
+    const insertParts = buildInsertParts(
+      table2.name,
+      encoded,
+      expressions,
+      symbols
+    );
+    if (this.#driver.supportsReturning) {
+      const { strings, values } = appendReturning(insertParts);
+      const row = await this.#driver.get(
+        strings,
+        values
+      );
+      return decodeData(table2, row);
+    }
+    await this.#driver.run(insertParts.strings, insertParts.values);
+    const pk = table2.meta.primary;
+    const pkValue = pk ? encoded[pk] ?? (expressions[pk] ? void 0 : null) : null;
+    if (pk && pkValue !== void 0 && pkValue !== null) {
+      const { strings, values } = buildSelectByPkParts(table2.name, pk, pkValue);
+      const row = await this.#driver.get(
+        strings,
+        values
+      );
+      if (row) {
+        return decodeData(table2, row);
+      }
+    }
+    return validated;
+  }
+  update(table2, data, idOrIds) {
+    if (idOrIds === void 0) {
+      return async (strings, ...values) => {
+        return this.#updateWithWhere(table2, data, strings, values);
+      };
+    }
+    if (Array.isArray(idOrIds)) {
+      return this.#updateByIds(table2, data, idOrIds);
+    }
+    return this.#updateById(table2, data, idOrIds);
+  }
+  async #updateById(table2, data, id) {
+    const pk = table2.meta.primary;
+    if (!pk) {
+      throw new Error(`Table ${table2.name} has no primary key defined`);
+    }
+    if (table2.meta.isDerived) {
+      throw new Error(
+        `Cannot update derived table "${table2.name}". Derived tables are SELECT-only.`
+      );
+    }
+    const dataWithSchemaExprs = injectSchemaExpressions(
+      table2,
+      data,
+      "update"
+    );
+    const { regularData, expressions, symbols } = extractDBExpressions(
+      dataWithSchemaExprs,
+      table2
+    );
+    const partialSchema = table2.schema.partial();
+    const validated = validateWithStandardSchema(
+      partialSchema,
+      regularData
+    );
+    const allColumns = [
+      ...Object.keys(validated),
+      ...Object.keys(expressions),
+      ...Object.keys(symbols)
+    ];
+    if (allColumns.length === 0) {
+      throw new Error("No fields to update");
+    }
+    const encoded = encodeData(table2, validated);
+    const updateParts = buildUpdateByIdParts(
+      table2.name,
+      pk,
+      encoded,
+      expressions,
+      id,
+      symbols
+    );
+    if (this.#driver.supportsReturning) {
+      const { strings, values } = appendReturning(updateParts);
+      const row2 = await this.#driver.get(
+        strings,
+        values
+      );
+      if (!row2)
+        return null;
+      return decodeData(table2, row2);
+    }
+    await this.#driver.run(updateParts.strings, updateParts.values);
+    const { strings: selectStrings, values: selectValues } = buildSelectByPkParts(
+      table2.name,
+      pk,
+      id
+    );
+    const row = await this.#driver.get(
+      selectStrings,
+      selectValues
+    );
+    if (!row)
+      return null;
+    return decodeData(table2, row);
+  }
+  async #updateByIds(table2, data, ids) {
+    if (ids.length === 0) {
+      return [];
+    }
+    const pk = table2.meta.primary;
+    if (!pk) {
+      throw new Error(`Table ${table2.name} has no primary key defined`);
+    }
+    if (table2.meta.isDerived) {
+      throw new Error(
+        `Cannot update derived table "${table2.name}". Derived tables are SELECT-only.`
+      );
+    }
+    const dataWithSchemaExprs = injectSchemaExpressions(
+      table2,
+      data,
+      "update"
+    );
+    const { regularData, expressions, symbols } = extractDBExpressions(
+      dataWithSchemaExprs,
+      table2
+    );
+    const partialSchema = table2.schema.partial();
+    const validated = validateWithStandardSchema(
+      partialSchema,
+      regularData
+    );
+    const allColumns = [
+      ...Object.keys(validated),
+      ...Object.keys(expressions),
+      ...Object.keys(symbols)
+    ];
+    if (allColumns.length === 0) {
+      throw new Error("No fields to update");
+    }
+    const encoded = encodeData(table2, validated);
+    const updateParts = buildUpdateByIdsParts(
+      table2.name,
+      pk,
+      encoded,
+      expressions,
+      ids,
+      symbols
+    );
+    if (this.#driver.supportsReturning) {
+      const { strings, values } = appendReturning(updateParts);
+      const rows2 = await this.#driver.all(
+        strings,
+        values
+      );
+      const resultMap2 = /* @__PURE__ */ new Map();
+      for (const row of rows2) {
+        const entity = decodeData(table2, row);
+        resultMap2.set(row[pk], entity);
+      }
+      return ids.map((id) => resultMap2.get(id) ?? null);
+    }
+    await this.#driver.run(updateParts.strings, updateParts.values);
+    const { strings: selectStrings, values: selectValues } = buildSelectByPksParts(table2.name, pk, ids);
+    const rows = await this.#driver.all(
+      selectStrings,
+      selectValues
+    );
+    const resultMap = /* @__PURE__ */ new Map();
+    for (const row of rows) {
+      const entity = decodeData(table2, row);
+      resultMap.set(row[pk], entity);
+    }
+    return ids.map((id) => resultMap.get(id) ?? null);
+  }
+  async #updateWithWhere(table2, data, strings, templateValues) {
+    if (table2.meta.isDerived) {
+      throw new Error(
+        `Cannot update derived table "${table2.name}". Derived tables are SELECT-only.`
+      );
+    }
+    const pk = table2.meta.primary;
+    if (!pk) {
+      throw new Error(`Table ${table2.name} has no primary key defined`);
+    }
+    const dataWithSchemaExprs = injectSchemaExpressions(
+      table2,
+      data,
+      "update"
+    );
+    const { regularData, expressions } = extractDBExpressions(
+      dataWithSchemaExprs,
+      table2
+    );
+    const partialSchema = table2.schema.partial();
+    const validated = validateWithStandardSchema(
+      partialSchema,
+      regularData
+    );
+    const allColumns = [...Object.keys(validated), ...Object.keys(expressions)];
+    if (allColumns.length === 0) {
+      throw new Error("No fields to update");
+    }
+    const encoded = encodeData(table2, validated);
+    const { strings: whereStrings, values: whereValues } = expandFragments(
+      strings,
+      templateValues
+    );
+    const setCols = Object.keys(encoded);
+    const exprCols = Object.keys(expressions);
+    const queryStrings = ["UPDATE "];
+    const queryValues = [];
+    queryValues.push(ident(table2.name));
+    queryStrings.push(" SET ");
+    for (let i = 0; i < setCols.length; i++) {
+      const col = setCols[i];
+      queryValues.push(ident(col));
+      queryStrings.push(" = ");
+      queryValues.push(encoded[col]);
+      queryStrings.push(i < setCols.length - 1 ? ", " : "");
+    }
+    for (let i = 0; i < exprCols.length; i++) {
+      if (setCols.length > 0 || i > 0) {
+        queryStrings[queryStrings.length - 1] += ", ";
+      }
+      queryValues.push(ident(exprCols[i]));
+      queryStrings.push(" = ");
+      mergeExpression(queryStrings, queryValues, expressions[exprCols[i]]);
+    }
+    queryStrings[queryStrings.length - 1] += " " + whereStrings[0];
+    for (let i = 1; i < whereStrings.length; i++) {
+      queryStrings.push(whereStrings[i]);
+    }
+    queryValues.push(...whereValues);
+    if (this.#driver.supportsReturning) {
+      queryStrings[queryStrings.length - 1] += " RETURNING *";
+      const rows2 = await this.#driver.all(
+        makeTemplate(queryStrings),
+        queryValues
+      );
+      return rows2.map((row) => decodeData(table2, row));
+    }
+    const selectIdStrings = ["SELECT "];
+    const selectIdValues = [];
+    selectIdValues.push(ident(pk));
+    selectIdStrings.push(" FROM ");
+    selectIdValues.push(ident(table2.name));
+    selectIdStrings.push(" " + whereStrings[0]);
+    for (let i = 1; i < whereStrings.length; i++) {
+      selectIdStrings.push(whereStrings[i]);
+    }
+    selectIdValues.push(...whereValues);
+    const idRows = await this.#driver.all(
+      makeTemplate(selectIdStrings),
+      selectIdValues
+    );
+    const ids = idRows.map((r) => r[pk]);
+    if (ids.length === 0) {
+      return [];
+    }
+    await this.#driver.run(makeTemplate(queryStrings), queryValues);
+    const { strings: selectStrings, values: selectVals } = buildSelectByPksParts(
+      table2.name,
+      pk,
+      ids
+    );
+    const rows = await this.#driver.all(
+      selectStrings,
+      selectVals
+    );
+    return rows.map((row) => decodeData(table2, row));
+  }
+  delete(table2, idOrIds) {
+    if (idOrIds === void 0) {
+      return async (strings, ...values) => {
+        const { strings: expandedStrings, values: expandedValues } = expandFragments(strings, values);
+        const deleteStrings = ["DELETE FROM "];
+        const deleteValues = [ident(table2.name)];
+        deleteStrings.push(" " + expandedStrings[0]);
+        for (let i = 1; i < expandedStrings.length; i++) {
+          deleteStrings.push(expandedStrings[i]);
+        }
+        deleteValues.push(...expandedValues);
+        return this.#driver.run(makeTemplate(deleteStrings), deleteValues);
+      };
+    }
+    if (Array.isArray(idOrIds)) {
+      return this.#deleteByIds(table2, idOrIds);
+    }
+    return this.#deleteById(table2, idOrIds);
+  }
+  async #deleteById(table2, id) {
+    const pk = table2.meta.primary;
+    if (!pk) {
+      throw new Error(`Table ${table2.name} has no primary key defined`);
+    }
+    const { strings, values } = buildDeleteByPkParts(table2.name, pk, id);
+    return this.#driver.run(strings, values);
+  }
+  async #deleteByIds(table2, ids) {
+    if (ids.length === 0) {
+      return 0;
+    }
+    const pk = table2.meta.primary;
+    if (!pk) {
+      throw new Error(`Table ${table2.name} has no primary key defined`);
+    }
+    const { strings, values } = buildDeleteByPksParts(table2.name, pk, ids);
+    return this.#driver.run(strings, values);
+  }
+  softDelete(table2, idOrIds) {
+    const softDeleteField = table2.meta.softDeleteField;
+    if (!softDeleteField) {
+      throw new Error(
+        `Table ${table2.name} does not have a soft delete field. Use softDelete() wrapper to mark a field.`
+      );
+    }
+    if (idOrIds === void 0) {
+      return async (strings, ...values) => {
+        return this.#softDeleteWithWhere(table2, strings, values);
+      };
+    }
+    if (Array.isArray(idOrIds)) {
+      return this.#softDeleteByIds(table2, idOrIds);
+    }
+    return this.#softDeleteById(table2, idOrIds);
+  }
+  async #softDeleteById(table2, id) {
+    const pk = table2.meta.primary;
+    if (!pk) {
+      throw new Error(`Table ${table2.name} has no primary key defined`);
+    }
+    const softDeleteField = table2.meta.softDeleteField;
+    const schemaExprs = injectSchemaExpressions(table2, {}, "update");
+    const { expressions, symbols } = extractDBExpressions(schemaExprs);
+    const queryStrings = ["UPDATE "];
+    const queryValues = [];
+    queryValues.push(ident(table2.name));
+    queryStrings.push(" SET ");
+    queryValues.push(ident(softDeleteField));
+    queryStrings.push(" = CURRENT_TIMESTAMP");
+    for (const [field, expr] of Object.entries(expressions)) {
+      if (field !== softDeleteField) {
+        queryStrings[queryStrings.length - 1] += ", ";
+        queryValues.push(ident(field));
+        queryStrings.push(" = ");
+        mergeExpression(queryStrings, queryValues, expr);
+      }
+    }
+    for (const [field, sym] of Object.entries(symbols)) {
+      if (field !== softDeleteField) {
+        queryStrings[queryStrings.length - 1] += ", ";
+        queryValues.push(ident(field));
+        queryStrings.push(` = ${resolveSQLBuiltin(sym)}`);
+      }
+    }
+    queryStrings[queryStrings.length - 1] += " WHERE ";
+    queryValues.push(ident(pk));
+    queryStrings.push(" = ");
+    queryValues.push(id);
+    queryStrings.push("");
+    return this.#driver.run(makeTemplate(queryStrings), queryValues);
+  }
+  async #softDeleteByIds(table2, ids) {
+    if (ids.length === 0) {
+      return 0;
+    }
+    const pk = table2.meta.primary;
+    if (!pk) {
+      throw new Error(`Table ${table2.name} has no primary key defined`);
+    }
+    const softDeleteField = table2.meta.softDeleteField;
+    const schemaExprs = injectSchemaExpressions(table2, {}, "update");
+    const { expressions, symbols } = extractDBExpressions(schemaExprs);
+    const queryStrings = ["UPDATE "];
+    const queryValues = [];
+    queryValues.push(ident(table2.name));
+    queryStrings.push(" SET ");
+    queryValues.push(ident(softDeleteField));
+    queryStrings.push(" = CURRENT_TIMESTAMP");
+    for (const [field, expr] of Object.entries(expressions)) {
+      if (field !== softDeleteField) {
+        queryStrings[queryStrings.length - 1] += ", ";
+        queryValues.push(ident(field));
+        queryStrings.push(" = ");
+        mergeExpression(queryStrings, queryValues, expr);
+      }
+    }
+    for (const [field, sym] of Object.entries(symbols)) {
+      if (field !== softDeleteField) {
+        queryStrings[queryStrings.length - 1] += ", ";
+        queryValues.push(ident(field));
+        queryStrings.push(` = ${resolveSQLBuiltin(sym)}`);
+      }
+    }
+    queryStrings[queryStrings.length - 1] += " WHERE ";
+    queryValues.push(ident(pk));
+    queryStrings.push(" IN (");
+    for (let i = 0; i < ids.length; i++) {
+      queryValues.push(ids[i]);
+      queryStrings.push(i < ids.length - 1 ? ", " : ")");
+    }
+    return this.#driver.run(makeTemplate(queryStrings), queryValues);
+  }
+  async #softDeleteWithWhere(table2, strings, templateValues) {
+    const softDeleteField = table2.meta.softDeleteField;
+    const schemaExprs = injectSchemaExpressions(table2, {}, "update");
+    const { expressions, symbols } = extractDBExpressions(schemaExprs);
+    const { strings: expandedStrings, values: expandedValues } = expandFragments(
+      strings,
+      templateValues
+    );
+    const queryStrings = ["UPDATE "];
+    const queryValues = [];
+    queryValues.push(ident(table2.name));
+    queryStrings.push(" SET ");
+    queryValues.push(ident(softDeleteField));
+    queryStrings.push(" = CURRENT_TIMESTAMP");
+    for (const [field, expr] of Object.entries(expressions)) {
+      if (field !== softDeleteField) {
+        queryStrings[queryStrings.length - 1] += ", ";
+        queryValues.push(ident(field));
+        queryStrings.push(" = ");
+        mergeExpression(queryStrings, queryValues, expr);
+      }
+    }
+    for (const [field, sym] of Object.entries(symbols)) {
+      if (field !== softDeleteField) {
+        queryStrings[queryStrings.length - 1] += ", ";
+        queryValues.push(ident(field));
+        queryStrings.push(` = ${resolveSQLBuiltin(sym)}`);
+      }
+    }
+    queryStrings[queryStrings.length - 1] += " " + expandedStrings[0];
+    for (let i = 1; i < expandedStrings.length; i++) {
+      queryStrings.push(expandedStrings[i]);
+    }
+    queryValues.push(...expandedValues);
+    return this.#driver.run(makeTemplate(queryStrings), queryValues);
+  }
+  // ==========================================================================
+  // Raw - No Normalization
+  // ==========================================================================
+  /**
+   * Execute a raw query and return rows.
+   *
+   * @example
+   * const counts = await db.query<{ count: number }>`
+   *   SELECT COUNT(*) as count FROM posts WHERE author_id = ${userId}
+   * `;
+   */
+  async query(strings, ...values) {
+    const { strings: expandedStrings, values: expandedValues } = expandFragments(
+      strings,
+      values
+    );
+    return this.#driver.all(expandedStrings, expandedValues);
+  }
+  /**
+   * Execute a statement (INSERT, UPDATE, DELETE, DDL).
+   *
+   * @example
+   * await db.exec`CREATE TABLE IF NOT EXISTS users (id TEXT PRIMARY KEY)`;
+   */
+  async exec(strings, ...values) {
+    const { strings: expandedStrings, values: expandedValues } = expandFragments(
+      strings,
+      values
+    );
+    return this.#driver.run(expandedStrings, expandedValues);
+  }
+  /**
+   * Execute a query and return a single value.
+   *
+   * @example
+   * const count = await db.val<number>`SELECT COUNT(*) FROM posts`;
+   */
+  async val(strings, ...values) {
+    const { strings: expandedStrings, values: expandedValues } = expandFragments(
+      strings,
+      values
+    );
+    return this.#driver.val(expandedStrings, expandedValues);
+  }
+  // ==========================================================================
+  // Debugging
+  // ==========================================================================
+  /**
+   * Print the generated SQL and parameters without executing.
+   * Useful for debugging query composition and fragment expansion.
+   * Note: SQL shown uses ? placeholders; actual query may use $1, $2 etc.
+   */
+  print(strings, ...values) {
+    const { strings: expandedStrings, values: expandedValues } = expandFragments(
+      strings,
+      values
+    );
+    let sql = expandedStrings[0];
+    for (let i = 1; i < expandedStrings.length; i++) {
+      sql += "?" + expandedStrings[i];
+    }
+    return { sql, params: expandedValues };
+  }
+  // ==========================================================================
+  // Schema Ensure Methods
+  // ==========================================================================
+  /**
+   * Ensure a table exists with its columns and indexes.
+   *
+   * **For new tables**: Creates the table with full structure including
+   * primary key, unique constraints, foreign keys, and indexes.
+   *
+   * **For existing tables**: Only performs safe, additive operations:
+   * - Adds missing columns
+   * - Adds missing non-unique indexes
+   *
+   * Unique constraints and foreign keys on existing tables require
+   * explicit `ensureConstraints()` call (they can fail or lock).
+   *
+   * @throws {EnsureError} If DDL execution fails
+   * @throws {SchemaDriftError} If existing table has missing constraints
+   *   (directs user to run ensureConstraints)
+   *
+   * @example
+   * // In migration handler
+   * await db.ensureTable(Users);
+   * await db.ensureTable(Posts); // FK to Users - ensure Users first
+   */
+  async ensureTable(table2) {
+    if (!this.#driver.ensureTable) {
+      throw new Error(
+        "Driver does not implement ensureTable(). Schema ensure methods require a driver with schema management support."
+      );
+    }
+    const doEnsure = () => this.#driver.ensureTable(table2);
+    if (this.#driver.withMigrationLock) {
+      return await this.#driver.withMigrationLock(doEnsure);
+    }
+    return await doEnsure();
+  }
+  /**
+   * Ensure constraints (unique, foreign key) are applied to an existing table.
+   *
+   * **WARNING**: This operation can be expensive and cause locks on large tables.
+   * It performs preflight checks to detect data violations before applying constraints.
+   *
+   * For each declared constraint:
+   * 1. Preflight: Check for violations (duplicates for UNIQUE, orphans for FK)
+   * 2. If violations found: Throw ConstraintPreflightError with diagnostic query
+   * 3. If clean: Apply the constraint
+   *
+   * @throws {Error} If table doesn't exist
+   * @throws {ConstraintPreflightError} If data violates a constraint
+   * @throws {EnsureError} If DDL execution fails
+   *
+   * @example
+   * // After ensuring table structure
+   * await db.ensureTable(Users);
+   * // Explicitly apply constraints (may lock, may fail)
+   * await db.ensureConstraints(Users);
+   */
+  async ensureConstraints(table2) {
+    if (!this.#driver.ensureConstraints) {
+      throw new Error(
+        "Driver does not implement ensureConstraints(). Schema ensure methods require a driver with schema management support."
+      );
+    }
+    const doEnsure = () => this.#driver.ensureConstraints(table2);
+    if (this.#driver.withMigrationLock) {
+      return await this.#driver.withMigrationLock(doEnsure);
+    }
+    return await doEnsure();
+  }
+  /**
+   * Copy column data for safe rename migrations.
+   *
+   * Executes: UPDATE <table> SET <toField> = <fromField> WHERE <toField> IS NULL
+   *
+   * This is idempotent - rows where toField already has a value are skipped.
+   * The fromField may be a legacy column not in the current schema.
+   *
+   * @param table The table to update
+   * @param fromField Source column (may be legacy/not in schema)
+   * @param toField Destination column (must exist in schema)
+   * @returns Number of rows updated
+   *
+   * @example
+   * // Rename "email" to "emailAddress":
+   * // 1. Add new column
+   * await db.ensureTable(UsersWithEmailAddress);
+   * // 2. Copy data
+   * const updated = await db.copyColumn(Users, "email", "emailAddress");
+   * // 3. Later: remove old column (manual migration)
+   */
+  async copyColumn(table2, fromField, toField) {
+    const fields = Object.keys(table2.meta.fields);
+    if (!fields.includes(toField)) {
+      throw new Error(
+        `Destination field "${toField}" does not exist in table "${table2.name}". Available fields: ${fields.join(", ")}`
+      );
+    }
+    if (this.#driver.copyColumn) {
+      const doCopy2 = () => this.#driver.copyColumn(table2, fromField, toField);
+      if (this.#driver.withMigrationLock) {
+        return await this.#driver.withMigrationLock(doCopy2);
+      }
+      return await doCopy2();
+    }
+    const doCopy = async () => {
+      const tableName = table2.name;
+      const columnExists = await this.#checkColumnExists(tableName, fromField);
+      if (!columnExists) {
+        throw new EnsureError(
+          `Source field "${fromField}" does not exist in table "${tableName}"`,
+          { operation: "copyColumn", table: tableName, step: 0 }
+        );
+      }
+      try {
+        const updateStrings = makeTemplate([
+          "UPDATE ",
+          " SET ",
+          " = ",
+          " WHERE ",
+          " IS NULL"
+        ]);
+        const updateValues = [
+          ident(tableName),
+          ident(toField),
+          ident(fromField),
+          ident(toField)
+        ];
+        return await this.#driver.run(updateStrings, updateValues);
+      } catch (error) {
+        throw new EnsureError(
+          `copyColumn failed: ${error instanceof Error ? error.message : String(error)}`,
+          { operation: "copyColumn", table: tableName, step: 0 },
+          { cause: error }
+        );
+      }
+    };
+    if (this.#driver.withMigrationLock) {
+      return await this.#driver.withMigrationLock(doCopy);
+    }
+    return await doCopy();
+  }
+  /**
+   * Check if a column exists in the actual database table.
+   * Queries the actual table structure to verify column existence.
+   */
+  async #checkColumnExists(tableName, columnName) {
+    if (this.#driver.getColumns) {
+      const columns = await this.#driver.getColumns(tableName);
+      return columns.some((col) => col.name === columnName);
+    }
+    try {
+      const pragmaStrings = makeTemplate(["PRAGMA table_info(", ")"]);
+      const pragmaValues = [ident(tableName)];
+      const columns = await this.#driver.all(
+        pragmaStrings,
+        pragmaValues
+      );
+      if (columns.length > 0) {
+        return columns.some((col) => col.name === columnName);
+      }
+    } catch {
+    }
+    try {
+      const schemaStrings = makeTemplate([
+        "SELECT column_name FROM information_schema.columns WHERE table_name = ",
+        " AND column_name = ",
+        " LIMIT 1"
+      ]);
+      const schemaValues = [tableName, columnName];
+      const result = await this.#driver.all(schemaStrings, schemaValues);
+      return result.length > 0;
+    } catch {
+      return true;
+    }
+  }
+  // ==========================================================================
+  // Transactions
+  // ==========================================================================
+  /**
+   * Execute a function within a database transaction.
+   *
+   * If the function completes successfully, the transaction is committed.
+   * If the function throws an error, the transaction is rolled back.
+   *
+   * All operations within the transaction callback use the same database
+   * connection, ensuring transactional consistency.
+   *
+   * @example
+   * await db.transaction(async (tx) => {
+   *   const user = await tx.insert(users, { id: "1", name: "Alice" });
+   *   await tx.insert(posts, { id: "1", authorId: user.id, title: "Hello" });
+   *   // If any insert fails, both are rolled back
+   * });
+   */
+  async transaction(fn) {
+    return await this.#driver.transaction(async (txDriver) => {
+      const tx = new Transaction(txDriver);
+      return await fn(tx);
+    });
+  }
+};
+
+// src/zen.ts
+extendZod(zod);
+export {
+  AlreadyExistsError,
+  CURRENT_DATE,
+  CURRENT_TIME,
+  CURRENT_TIMESTAMP,
+  ConnectionError,
+  ConstraintPreflightError,
+  ConstraintViolationError,
+  Database,
+  DatabaseError,
+  DatabaseUpgradeEvent,
+  EnsureError,
+  MigrationError,
+  MigrationLockError,
+  NOW,
+  NotFoundError,
+  QueryError,
+  SchemaDriftError,
+  TODAY,
+  TableDefinitionError,
+  Transaction,
+  TransactionError,
+  ValidationError,
+  hasErrorCode,
+  ident,
+  isDatabaseError,
+  isSQLBuiltin,
+  isSQLIdentifier,
+  isSQLTemplate,
+  table,
+  zod as z
+};