@crvouga/sqlite-mem 1.1.2 → 1.3.0

package/dist/index.js

@@ -640,10 +640,12 @@ var PREC = {
   JSON_ARROW: 80
 };
 var Parser = class {
-  constructor(tokens) {
+  constructor(tokens, source = "") {
     this.tokens = tokens;
+    this.source = source;
   }
   tokens;
+  source;
   pos = 0;
   current() {
     return this.tokens[this.pos] ?? this.tokens[this.tokens.length - 1];
@@ -727,13 +729,21 @@ var Parser = class {
   }
   // ── Statements ──────────────────────────────────────────────────────────
   parseStatements() {
-    const stmts = [];
+    return this.parseUnits().map((unit) => unit.statement);
+  }
+  /** Parse statements with per-statement source slices for catalog `sql` text. */
+  parseUnits() {
+    const units = [];
     while (!this.at("EOF")) {
       if (this.match("SEMI")) continue;
-      stmts.push(this.parseStatement());
+      const start = this.current().start;
+      const statement = this.parseStatement();
+      const end = this.pos > 0 ? this.tokens[this.pos - 1].end : this.current().end;
       this.match("SEMI");
+      const sql = this.source ? this.source.slice(start, end).trimEnd() : "";
+      units.push({ statement, sql });
     }
-    return stmts;
+    return units;
   }
   parseStatement() {
     if (this.match("EXPLAIN")) {
@@ -745,13 +755,20 @@ var Parser = class {
       const stmt = this.parseStatement();
       return { type: "explain", queryPlan, statement: stmt };
     }
-    if (this.check("WITH", "SELECT")) return this.parseSelectStmt();
+    if (this.at("WITH")) {
+      const withClause = this.parseWithClause();
+      if (this.at("SELECT")) return this.parseSelectStmt(withClause);
+      if (this.at("INSERT") || this.at("REPLACE")) return this.parseInsertStmt(withClause);
+      if (this.at("UPDATE")) return this.parseUpdateStmt(withClause);
+      if (this.at("DELETE")) return this.parseDeleteStmt(withClause);
+      this.syntaxError("expected SELECT, INSERT, UPDATE, or DELETE after WITH clause");
+    }
     if (this.at("SELECT")) return this.parseSelectStmt();
-    if (this.check("WITH", "INSERT") || this.at("INSERT") || this.at("REPLACE")) {
+    if (this.at("INSERT") || this.at("REPLACE")) {
       return this.parseInsertStmt();
     }
-    if (this.check("WITH", "UPDATE") || this.at("UPDATE")) return this.parseUpdateStmt();
-    if (this.check("WITH", "DELETE") || this.at("DELETE")) return this.parseDeleteStmt();
+    if (this.at("UPDATE")) return this.parseUpdateStmt();
+    if (this.at("DELETE")) return this.parseDeleteStmt();
     if (this.at("CREATE")) return this.parseCreateStmt();
     if (this.at("DROP")) return this.parseDropStmt();
     if (this.at("ALTER")) return this.parseAlterTableStmt();
@@ -813,12 +830,15 @@ var Parser = class {
         this.expect("RPAREN");
       }
       this.expect("AS");
-      if (this.match("NOT")) this.expect("MATERIALIZED", "expected MATERIALIZED after NOT");
-      else this.match("MATERIALIZED");
+      let materialized = null;
+      if (this.match("NOT")) {
+        this.expect("MATERIALIZED", "expected MATERIALIZED after NOT");
+        materialized = "not_materialized";
+      } else if (this.match("MATERIALIZED")) materialized = "materialized";
       this.expect("LPAREN");
-      const select = this.at("VALUES") ? this.parseValuesAsSelect() : this.parseSelectCore();
+      const select = this.at("VALUES") ? this.parseValuesAsSelect() : this.at("WITH") ? this.parseSelectStmt() : this.parseSelectCore();
       this.expect("RPAREN");
-      ctes.push({ name, columns, select });
+      ctes.push({ name, columns, materialized, select });
     } while (this.match("COMMA"));
     return { recursive, ctes };
   }
@@ -826,8 +846,7 @@ var Parser = class {
     return this.at("WITH") ? this.parseWithClause() : null;
   }
   // ── SELECT ──────────────────────────────────────────────────────────────
-  parseSelectStmt() {
-    const withClause = this.parseOptionalWith();
+  parseSelectStmt(withClause = this.parseOptionalWith()) {
     const select = this.parseSelectCore();
     select.with = withClause;
     return select;
@@ -1125,8 +1144,7 @@ var Parser = class {
     return { limit: first, offset };
   }
   // ── INSERT / REPLACE ────────────────────────────────────────────────────
-  parseInsertStmt() {
-    const withClause = this.parseOptionalWith();
+  parseInsertStmt(withClause = this.parseOptionalWith()) {
     let mode = "insert";
     if (this.match("REPLACE")) {
       mode = "replace";
@@ -1229,8 +1247,7 @@ var Parser = class {
     return this.parseResultColumns();
   }
   // ── UPDATE ──────────────────────────────────────────────────────────────
-  parseUpdateStmt() {
-    const withClause = this.parseOptionalWith();
+  parseUpdateStmt(withClause = this.parseOptionalWith()) {
     this.expect("UPDATE");
     const or = this.mapUpdateOr(this.parseOrConflict());
     const table = this.parseTableName();
@@ -1245,8 +1262,7 @@ var Parser = class {
     return { type: "update", with: withClause, or, table, alias, set, from, where, returning };
   }
   // ── DELETE ──────────────────────────────────────────────────────────────
-  parseDeleteStmt() {
-    const withClause = this.parseOptionalWith();
+  parseDeleteStmt(withClause = this.parseOptionalWith()) {
     this.expect("DELETE");
     this.expect("FROM");
     const table = this.parseTableName();
@@ -1915,6 +1931,24 @@ var Parser = class {
           left = this.parseLikeRhs(left, true, "GLOB");
           continue;
         }
+        if (n.kind === "REGEXP") {
+          this.advance();
+          this.advance();
+          const pattern = this.parseExprPrec(PREC.IS_IN_LIKE + 1);
+          left = {
+            type: "unary",
+            op: "NOT",
+            expr: {
+              type: "function",
+              name: "REGEXP",
+              distinct: false,
+              args: [pattern, left],
+              orderBy: [],
+              filter: null
+            }
+          };
+          continue;
+        }
         if (n.kind === "BETWEEN") {
           this.advance();
           this.advance();
@@ -1970,6 +2004,12 @@ var Parser = class {
         left = this.parseLikeRhs(left, false, "GLOB");
         continue;
       }
+      if (this.at("REGEXP") && PREC.IS_IN_LIKE >= minPrec) {
+        this.advance();
+        const pattern = this.parseExprPrec(PREC.IS_IN_LIKE + 1);
+        left = { type: "function", name: "REGEXP", distinct: false, args: [pattern, left], orderBy: [], filter: null };
+        continue;
+      }
       if (this.at("MATCH") && PREC.IS_IN_LIKE >= minPrec) {
         this.advance();
         const right2 = this.parseExprPrec(PREC.IS_IN_LIKE + 1);
@@ -2128,7 +2168,7 @@ var Parser = class {
     }
     if (this.at("CURRENT_DATE") || this.at("CURRENT_TIME") || this.at("CURRENT_TIMESTAMP")) {
       const tok = this.advance();
-      return { type: "function", name: tok.value, distinct: false, args: [], filter: null };
+      return { type: "function", name: tok.value, distinct: false, args: [], orderBy: [], filter: null };
     }
     if (this.at("NUMBER")) {
       const tok = this.advance();
@@ -2211,6 +2251,7 @@ var Parser = class {
         } while (this.match("COMMA"));
       }
     }
+    const orderBy = this.parseOrderBy();
     this.expect("RPAREN");
     if (this.match("FILTER")) {
       this.expect("LPAREN");
@@ -2231,13 +2272,13 @@ var Parser = class {
         window = this.parseWindowSpec();
         this.expect("RPAREN");
       }
-      const func = isAgg ? { type: "aggregate", name: upper, distinct, args, filter } : { type: "function", name, distinct, args, filter };
+      const func = isAgg ? { type: "aggregate", name: upper, distinct, args, orderBy, filter } : { type: "function", name, distinct, args, orderBy, filter };
       return { type: "window", func, window };
     }
     if (isAgg) {
-      return { type: "aggregate", name: upper, distinct, args, filter };
+      return { type: "aggregate", name: upper, distinct, args, orderBy, filter };
     }
-    return { type: "function", name, distinct, args, filter };
+    return { type: "function", name, distinct, args, orderBy, filter };
   }
   parseCaseExpr(base) {
     const whens = [];
@@ -2328,14 +2369,13 @@ var Parser = class {
     return { kind: "following", expr };
   }
 };
-function parseTokens(tokens) {
-  return new Parser(tokens).parseStatements();
+function parseTokenUnits(tokens, source) {
+  return new Parser(tokens, source).parseUnits();
 }
 
 // src/parser/index.ts
-function parse(sql) {
-  const tokens = tokenize(sql);
-  return parseTokens(tokens);
+function parseUnits(sql) {
+  return parseTokenUnits(tokenize(sql), sql);
 }
 
 // src/runtime/clock.ts
@@ -2345,8 +2385,12 @@ function fixedClock(instant = DEFAULT_NOW) {
   if (Number.isNaN(ms)) throw new RangeError("invalid clock instant");
   return () => new Date(ms);
 }
+function systemClock() {
+  return () => /* @__PURE__ */ new Date();
+}
 function resolveClock(now) {
   if (now === void 0) return fixedClock(DEFAULT_NOW);
+  if (now === "system") return systemClock();
   if (typeof now === "function") return () => new Date(now().getTime());
   return fixedClock(now);
 }
@@ -2411,6 +2455,28 @@ var Prng = class _Prng {
     return copy;
   }
 };
+var OsEntropy = class _OsEntropy extends Prng {
+  constructor() {
+    super(1);
+  }
+  nextU64() {
+    const bytes = new Uint8Array(8);
+    crypto.getRandomValues(bytes);
+    let value = 0n;
+    for (let i = 0; i < 8; i++) {
+      value |= BigInt(bytes[i]) << BigInt(i * 8);
+    }
+    return BigInt.asUintN(64, value);
+  }
+  getState() {
+    return 0n;
+  }
+  setState(_state) {
+  }
+  clone() {
+    return new _OsEntropy();
+  }
+};
 
 // src/types/value.ts
 var SqlReal = class {
@@ -2517,6 +2583,23 @@ function applyAffinity(value, affinity) {
       return value;
   }
 }
+function applyComparisonAffinity(left, right, leftAffinity, rightAffinity) {
+  const leftNumeric = leftAffinity === "INTEGER" || leftAffinity === "REAL" || leftAffinity === "NUMERIC";
+  const rightNumeric = rightAffinity === "INTEGER" || rightAffinity === "REAL" || rightAffinity === "NUMERIC";
+  const leftNone = leftAffinity === null || leftAffinity === "BLOB";
+  const rightNone = rightAffinity === null || rightAffinity === "BLOB";
+  if (leftNumeric && (rightAffinity === "TEXT" || rightNone)) {
+    const affinity = leftAffinity === "REAL" ? "REAL" : "NUMERIC";
+    return [left, applyAffinity(right, affinity)];
+  }
+  if (rightNumeric && (leftAffinity === "TEXT" || leftNone)) {
+    const affinity = rightAffinity === "REAL" ? "REAL" : "NUMERIC";
+    return [applyAffinity(left, affinity), right];
+  }
+  if (leftAffinity === "TEXT" && rightNone) return [left, applyAffinity(right, "TEXT")];
+  if (rightAffinity === "TEXT" && leftNone) return [applyAffinity(left, "TEXT"), right];
+  return [left, right];
+}
 function coerceToNumber(value) {
   if (value === null) return null;
   if (value instanceof SqlReal) return value.value;
@@ -2673,14 +2756,18 @@ function jsonErrorPosition(input) {
   }
 }
 function isValidJsonText(input, flags = 0) {
-  const allowJson5 = (flags & 2) !== 0 || (flags & 1) !== 0;
+  const allowCanonical = flags === 0 || (flags & 1) !== 0;
+  const allowJson5 = (flags & 2) !== 0;
   try {
     if (allowJson5) {
       parseJsonText(input);
       return true;
     }
-    parseJsonText(input, { strictCanonical: true });
-    return true;
+    if (allowCanonical) {
+      parseJsonText(input, { strictCanonical: true });
+      return true;
+    }
+    return false;
   } catch {
     return false;
   }
@@ -4209,7 +4296,11 @@ function applyModifier(date, modifier) {
   const normalized = modifier.trim().toLowerCase();
   if (normalized === "unixepoch") return new Date((date.getTime() / 864e5 + JULIAN_UNIX_EPOCH) * 1e3);
   if (normalized === "utc" || normalized === "localtime") return result;
-  if (normalized === "start of day") result.setUTCHours(0, 0, 0, 0);
+  const weekday = /^weekday\s+([0-6])$/.exec(normalized);
+  if (weekday) {
+    const target = Number(weekday[1]);
+    result.setUTCDate(result.getUTCDate() + (target - result.getUTCDay() + 7) % 7);
+  } else if (normalized === "start of day") result.setUTCHours(0, 0, 0, 0);
   else if (normalized === "start of month") {
     result.setUTCDate(1);
     result.setUTCHours(0, 0, 0, 0);
@@ -4667,13 +4758,15 @@ var mathFunctions = {
 function escapeRegexChar(char) {
   return /[\\^$.*+?()[\]{}|]/.test(char) ? `\\${char}` : char;
 }
-function likeLiteral(char) {
-  const code = char.codePointAt(0);
-  if (code >= 65 && code <= 90) return `[${char}${char.toLowerCase()}]`;
-  if (code >= 97 && code <= 122) return `[${char}${char.toUpperCase()}]`;
+function likeLiteral(char, caseSensitive) {
+  if (!caseSensitive) {
+    const code = char.codePointAt(0);
+    if (code >= 65 && code <= 90) return `[${char}${char.toLowerCase()}]`;
+    if (code >= 97 && code <= 122) return `[${char}${char.toUpperCase()}]`;
+  }
   return escapeRegexChar(char);
 }
-function likeMatch(text2, pattern, escape = null) {
+function likeMatch(text2, pattern, escape = null, caseSensitive = false) {
   if (escape !== null && [...escape].length !== 1) {
     throw new SqliteError("ESCAPE expression must be a single character", "other");
   }
@@ -4683,13 +4776,13 @@ function likeMatch(text2, pattern, escape = null) {
     const char = chars[i];
     if (escape !== null && char === escape) {
       const next = chars[++i];
-      source += next === void 0 ? likeLiteral(char) : likeLiteral(next);
+      source += next === void 0 ? likeLiteral(char, caseSensitive) : likeLiteral(next, caseSensitive);
     } else if (char === "%") {
       source += "[\\s\\S]*";
     } else if (char === "_") {
       source += "[\\s\\S]";
     } else {
-      source += likeLiteral(char);
+      source += likeLiteral(char, caseSensitive);
     }
   }
   return new RegExp(`${source}$`).test(text2);
@@ -4996,11 +5089,11 @@ var scalarFunctions = {
     requireArgs3("load_extension", args, 1, 2);
     throw new SqliteError("not authorized", "misuse");
   },
-  like(args) {
+  like(args, context) {
     requireArgs3("like", args, 2, 3);
     if (args[0] === null || args[1] === null || args[2] === null) return null;
     const escape = args[2] === void 0 ? null : text(args[2]);
-    return likeMatch(text(args[1]), text(args[0]), escape) ? 1 : 0;
+    return likeMatch(text(args[1]), text(args[0]), escape, context.caseSensitiveLike === true) ? 1 : 0;
   },
   glob(args) {
     requireArgs3("glob", args, 2);
@@ -5345,7 +5438,8 @@ function sqlOr(left, right) {
   if (leftTruth === null || rightTruth === null) return null;
   return 0;
 }
-function compareResult(op, left, right, collation) {
+function compareResult(op, left, right, collation, leftAffinity = null, rightAffinity = null) {
+  [left, right] = applyComparisonAffinity(left, right, leftAffinity, rightAffinity);
   if (op === "IS" || op === "IS NOT" || op === "IS DISTINCT FROM" || op === "IS NOT DISTINCT FROM") {
     const equal = left === null || right === null ? left === right : (collation ? compareWithCollation(left, right, collation) : compareSql(left, right)) === 0;
     if (op === "IS" || op === "IS NOT DISTINCT FROM") return booleanValue(equal);
@@ -5398,11 +5492,18 @@ function evalBinary(op, leftExpr, rightExpr, ctx) {
   if (["=", "==", "!=", "<>", "<", "<=", ">", ">=", "IS", "IS NOT", "IS DISTINCT FROM", "IS NOT DISTINCT FROM"].includes(
     op
   )) {
-    return compareResult(op, left, right, resolveComparisonCollation(leftExpr, rightExpr, ctx) ?? void 0);
+    return compareResult(
+      op,
+      left,
+      right,
+      resolveComparisonCollation(leftExpr, rightExpr, ctx) ?? void 0,
+      resolveComparisonAffinity(leftExpr, ctx),
+      resolveComparisonAffinity(rightExpr, ctx)
+    );
   }
   if (op === "LIKE" || op === "NOT LIKE" || op === "GLOB" || op === "NOT GLOB") {
     if (left === null || right === null) return null;
-    const matches = op.includes("LIKE") ? likeMatch(textValue(left), textValue(right)) : globMatch(textValue(left), textValue(right));
+    const matches = op.includes("LIKE") ? likeMatch(textValue(left), textValue(right), null, ctx.functionContext?.caseSensitiveLike === true) : globMatch(textValue(left), textValue(right));
     return booleanValue(op.startsWith("NOT") ? !matches : matches);
   }
   if (left === null || right === null) return null;
@@ -5577,14 +5678,26 @@ function inheritedCollation(expr, ctx) {
       return null;
   }
 }
-function evalIn(left, values, not) {
+function resolveComparisonAffinity(expr, ctx) {
+  switch (expr.type) {
+    case "column":
+      return ctx.resolveAffinity?.(expr.table, expr.name) ?? ctx.parent?.resolveAffinity?.(expr.table, expr.name) ?? null;
+    case "cast":
+      return affinityFromTypeName(expr.typeName);
+    case "collate":
+      return resolveComparisonAffinity(expr.expr, ctx);
+    default:
+      return null;
+  }
+}
+function evalIn(left, values, not, leftAffinity) {
   if (values.length === 0) return booleanValue(not);
   if (left === null) return null;
   let sawNull = false;
   for (const value of values) {
     if (value === null) {
       sawNull = true;
-    } else if (compareSql(left, value) === 0) {
+    } else if (compareSql(...applyComparisonAffinity(left, value, leftAffinity, null)) === 0) {
       return booleanValue(!not);
     }
   }
@@ -5630,8 +5743,9 @@ function evalExpr(expr, ctx) {
     case "between": {
       const value = evalExpr(expr.expr, ctx);
       const collation = resolveComparisonCollation(expr.expr, expr.lower, ctx) ?? resolveComparisonCollation(expr.expr, expr.upper, ctx) ?? void 0;
-      const lower = compareResult(">=", value, evalExpr(expr.lower, ctx), collation);
-      const result = sqlAnd(lower, () => compareResult("<=", value, evalExpr(expr.upper, ctx), collation));
+      const affinity = resolveComparisonAffinity(expr.expr, ctx);
+      const lower = compareResult(">=", value, evalExpr(expr.lower, ctx), collation, affinity);
+      const result = sqlAnd(lower, () => compareResult("<=", value, evalExpr(expr.upper, ctx), collation, affinity));
       if (result === null) return null;
       return expr.not ? booleanValue(result === 0) : result;
     }
@@ -5658,14 +5772,19 @@ function evalExpr(expr, ctx) {
       }
       const left = evalExpr(expr.expr, ctx);
       const values = Array.isArray(expr.values) ? expr.values.map((value) => evalExpr(value, ctx)) : executeSelect(ctx, expr.values).rows.map((row) => row[0] ?? null);
-      return evalIn(left, values, expr.not);
+      return evalIn(left, values, expr.not, resolveComparisonAffinity(expr.expr, ctx));
     }
     case "like": {
       const value = evalExpr(expr.expr, ctx);
       const pattern = evalExpr(expr.pattern, ctx);
       const escape = expr.escape === null ? null : evalExpr(expr.escape, ctx);
       if (value === null || pattern === null || escape === null && expr.escape !== null) return null;
-      const match = expr.op === "LIKE" ? likeMatch(textValue(value), textValue(pattern), escape === null ? null : textValue(escape)) : globMatch(textValue(value), textValue(pattern));
+      const match = expr.op === "LIKE" ? likeMatch(
+        textValue(value),
+        textValue(pattern),
+        escape === null ? null : textValue(escape),
+        ctx.functionContext?.caseSensitiveLike === true
+      ) : globMatch(textValue(value), textValue(pattern));
       return booleanValue(expr.not ? !match : match);
     }
     case "case": {
@@ -6806,7 +6925,7 @@ var Fts5VirtualTable = class _Fts5VirtualTable {
   insert(values, rowid) {
     const command = this.detectCommand(values);
     if (command !== null) {
-      this.runCommand(command, values);
+      this.runCommand(command, values, rowid);
       return 0;
     }
     const assigned = rowid ?? this.nextRowid++;
@@ -6955,18 +7074,63 @@ var Fts5VirtualTable = class _Fts5VirtualTable {
     }
     return parts.join(" ");
   }
-  /** FTS3 matchinfo default format 'pcx' simplified → blob of 32-bit LE ints. */
-  matchinfo(cursor, _format = "pcx") {
+  /** FTS3 matchinfo format encoded as native-style 32-bit little-endian integers. */
+  matchinfo(cursor, format = "pcx") {
     const row = this.rows.get(cursor.rowid);
     const nPhrase = Math.max(1, cursor.phraseTerms.length);
     const nCol = this.columns.length;
-    const values = [nPhrase, nCol];
-    for (let p = 0; p < nPhrase; p++) {
-      for (let c = 0; c < nCol; c++) {
-        const col = this.columns[c];
-        const term = cursor.phraseTerms[p]?.[0] ?? "";
-        const tf = row ? this.termFreq(row, col, term) : 0;
-        values.push(tf);
+    const values = [];
+    for (const request of format) {
+      switch (request) {
+        case "p":
+          values.push(nPhrase);
+          break;
+        case "c":
+          values.push(nCol);
+          break;
+        case "s":
+          for (let c = 0; c < nCol; c++) {
+            let longest = 0;
+            let run = 0;
+            for (let p = 0; p < nPhrase; p++) {
+              const phrase = cursor.phraseTerms[p] ?? [];
+              if (row && this.phraseFreq(row, this.columns[c], phrase) > 0) {
+                run++;
+                longest = Math.max(longest, run);
+              } else {
+                run = 0;
+              }
+            }
+            values.push(longest);
+          }
+          break;
+        case "x":
+          for (let p = 0; p < nPhrase; p++) {
+            const phrase = cursor.phraseTerms[p] ?? [];
+            for (let c = 0; c < nCol; c++) {
+              const column = this.columns[c];
+              const localHits = row ? this.phraseFreq(row, column, phrase) : 0;
+              let globalHits = 0;
+              let matchingRows = 0;
+              for (const candidate of this.rows.values()) {
+                const hits = this.phraseFreq(candidate, column, phrase);
+                globalHits += hits;
+                if (hits > 0) matchingRows++;
+              }
+              values.push(localHits, globalHits, matchingRows);
+            }
+          }
+          break;
+        case "y":
+          for (let p = 0; p < nPhrase; p++) {
+            const phrase = cursor.phraseTerms[p] ?? [];
+            for (let c = 0; c < nCol; c++) {
+              values.push(row ? this.phraseFreq(row, this.columns[c], phrase) : 0);
+            }
+          }
+          break;
+        default:
+          throw new SqliteError(`unrecognized matchinfo request: ${request}`, "other");
       }
     }
     const buf = new Uint8Array(values.length * 4);
@@ -7014,13 +7178,9 @@ var Fts5VirtualTable = class _Fts5VirtualTable {
     if (!values.has(key)) return null;
     const v = values.get(key);
     if (typeof v !== "string") return null;
-    const otherContent = [...values.entries()].some(
-      ([k, val]) => k !== key && val !== null && this.columns.some((c) => c.toLowerCase() === k)
-    );
-    if (otherContent) return null;
     return v;
   }
-  runCommand(command, _values) {
+  runCommand(command, _values, rowid) {
     const cmd = command.toLowerCase();
     if (cmd === "optimize") return;
     if (cmd === "rebuild") {
@@ -7035,13 +7195,15 @@ var Fts5VirtualTable = class _Fts5VirtualTable {
           "other"
         );
       }
-      for (const rowid of [...this.rows.keys()]) this.delete(rowid);
+      for (const rowid2 of [...this.rows.keys()]) this.delete(rowid2);
       return;
     }
     if (cmd.startsWith("merge=") || cmd.startsWith("automerge=")) {
       throw new SqliteError("SQL logic error", "other");
     }
     if (cmd === "delete") {
+      if (rowid === void 0) throw new SqliteError("SQL logic error", "other");
+      this.delete(rowid);
       return;
     }
     throw new SqliteError("SQL logic error", "other");
@@ -7274,11 +7436,6 @@ var Fts5VirtualTable = class _Fts5VirtualTable {
     }
     return n;
   }
-  termFreq(row, column, term) {
-    const needle = this.normalizeQueryTerm(term);
-    const tokens = row.tokensByColumn.get(column.toLowerCase()) ?? [];
-    return tokens.filter((t) => t.term === needle || t.term.startsWith(needle)).length;
-  }
   docLength(row) {
     let n = 0;
     for (const col of this.indexedColumns()) n += (row.tokensByColumn.get(col.toLowerCase()) ?? []).length;
@@ -7542,6 +7699,8 @@ var Table = class _Table {
   scanCache = null;
   /** Lazy covering hashes: column nameLower → serializeIndexKey → rowids. */
   equalityHashes = null;
+  /** Cached maximum rowid. `undefined` means recompute after deleting the maximum. */
+  maximumRowid = null;
   frozen = false;
   constructor(name, columns, options = {}) {
     this.name = name;
@@ -7744,7 +7903,12 @@ var Table = class _Table {
     if (alias) values.set(normalizeColumnName(alias.name), targetKey);
     const candidate = { rowid: targetKey, values };
     this.validate(candidate, key);
-    if (targetKey !== key) this.rows.delete(key);
+    if (targetKey !== key) {
+      this.rows.delete(key);
+      if (this.maximumRowid !== null && this.maximumRowid !== void 0 && sameRowid2(key, this.maximumRowid)) {
+        this.maximumRowid = void 0;
+      }
+    }
     this.rows.set(targetKey, candidate);
     this.advanceNextRowid(targetKey);
     this.reindexEquality(existing, candidate);
@@ -7758,6 +7922,9 @@ var Table = class _Table {
     if (this.withoutRowid) this.clusteredRows.delete(this.makeClusterKey(existing.values));
     this.unindexEquality(existing);
     this.invalidateScan();
+    if (this.maximumRowid !== null && this.maximumRowid !== void 0 && sameRowid2(key, this.maximumRowid)) {
+      this.maximumRowid = void 0;
+    }
     return this.rows.delete(key);
   }
   *scan() {
@@ -7779,6 +7946,7 @@ var Table = class _Table {
       strict: this.strict
     });
     copy.nextRowid = this.nextRowid;
+    copy.maximumRowid = this.maximumRowid;
     for (const [rowid, row] of this.rows) copy.rows.set(rowid, cloneRow(row));
     for (const [clusterKey, row] of this.clusteredRows) copy.clusteredRows.set(clusterKey, cloneRow(row));
     return copy;
@@ -7791,6 +7959,7 @@ var Table = class _Table {
   }
   /** Rebuild clustered storage after snapshot decode or bulk load. */
   rebuildClusteredRows() {
+    this.maximumRowid = void 0;
     if (!this.withoutRowid) return;
     this.clusteredRows.clear();
     for (const row of this.rows.values()) {
@@ -7899,11 +8068,23 @@ var Table = class _Table {
     return primary[0];
   }
   allocateRowid() {
+    if (!this.columns.some((column) => column.autoincrement)) {
+      if (this.maximumRowid === void 0) {
+        this.maximumRowid = null;
+        for (const rowid of this.rows.keys()) {
+          if (this.maximumRowid === null || compareRowids(rowid, this.maximumRowid) > 0) this.maximumRowid = rowid;
+        }
+      }
+      return this.maximumRowid === null ? 1 : incrementRowid(this.maximumRowid);
+    }
     let candidate = canonicalRowid(this.nextRowid);
     while (this.rows.has(candidate)) candidate = incrementRowid(candidate);
     return candidate;
   }
   advanceNextRowid(rowid) {
+    if (this.maximumRowid === null || this.maximumRowid !== void 0 && compareRowids(rowid, this.maximumRowid) > 0) {
+      this.maximumRowid = rowid;
+    }
     if (compareRowids(rowid, this.nextRowid) >= 0) this.nextRowid = incrementRowid(rowid);
   }
 };
@@ -7993,6 +8174,8 @@ var DatabaseState = class _DatabaseState {
   changes = 0;
   totalChanges = 0;
   foreignKeysEnabled = false;
+  /** When true, LIKE / like() are case-sensitive (SQLite `PRAGMA case_sensitive_like`). */
+  caseSensitiveLike = false;
   schemaVersion = 0;
   userVersion = 0;
   databaseForSchema(schema, qualifiedForError) {
@@ -8437,6 +8620,7 @@ var DatabaseState = class _DatabaseState {
     copy.changes = this.changes;
     copy.totalChanges = this.totalChanges;
     copy.foreignKeysEnabled = this.foreignKeysEnabled;
+    copy.caseSensitiveLike = this.caseSensitiveLike;
     copy.schemaVersion = this.schemaVersion;
     copy.userVersion = this.userVersion;
     return copy;
@@ -8456,6 +8640,7 @@ var DatabaseState = class _DatabaseState {
     copy.changes = this.changes;
     copy.totalChanges = this.totalChanges;
     copy.foreignKeysEnabled = this.foreignKeysEnabled;
+    copy.caseSensitiveLike = this.caseSensitiveLike;
     copy.schemaVersion = this.schemaVersion;
     copy.userVersion = this.userVersion;
     return copy;
@@ -8517,6 +8702,7 @@ var DatabaseState = class _DatabaseState {
     this.changes = copy.changes;
     this.totalChanges = copy.totalChanges;
     this.foreignKeysEnabled = copy.foreignKeysEnabled;
+    this.caseSensitiveLike = copy.caseSensitiveLike;
     this.schemaVersion = copy.schemaVersion;
     this.userVersion = copy.userVersion;
   }
@@ -8983,6 +9169,8 @@ var ExecutionEnv = class {
   maxRows = Number.POSITIVE_INFINITY;
   includeNamedRows = true;
   includeValues = true;
+  /** Source text of the statement currently executing (for sqlite_master.sql). */
+  statementSql = null;
   constructor(state, transactions, params = [], functions = defaultFunctionRegistry, hooks = {}) {
     this.state = state;
     this.transactions = transactions;
@@ -9001,6 +9189,7 @@ var ExecutionEnv = class {
     this.maxRows = Number.POSITIVE_INFINITY;
     this.includeNamedRows = true;
     this.includeValues = true;
+    this.statementSql = null;
   }
   getBoundParameter(name) {
     if (typeof name === "number") {
@@ -9019,8 +9208,9 @@ var ExecutionEnv = class {
   createEvalContext(row = null, parent) {
     const scope = row ?? this.triggerScope;
     const cells = scope?.cells ?? [];
+    const inheritedParent = parent ?? (row !== null && this.triggerScope !== null && row !== this.triggerScope ? this.createEvalContext(this.triggerScope) : void 0);
     const context = {
-      parent,
+      parent: inheritedParent,
       ftsMatch: scope?.ftsMatch ?? null,
       functions: this.functions,
       functionContext: {
@@ -9030,6 +9220,7 @@ var ExecutionEnv = class {
         now: this.hooks.now,
         random: this.hooks.random,
         randomU64: this.hooks.randomU64,
+        caseSensitiveLike: this.state.caseSensitiveLike,
         ftsMatch: scope?.ftsMatch ?? null,
         ftsRowid: scope?.rowid,
         ftsSourceTable: scope?.sourceTable,
@@ -9088,6 +9279,17 @@ var ExecutionEnv = class {
         const cell = matches[0];
         return cell.affinity === "REAL" && typeof cell.value === "number" ? "real" : storageClassOf(cell.value);
       },
+      resolveAffinity: (table, name) => {
+        const key = name.toLowerCase();
+        const tableKey = table?.toLowerCase();
+        const matches = cells.filter((cell) => {
+          if ((cell.nameLower ?? cell.name.toLowerCase()) !== key) return false;
+          if (table === null) return !cell.hiddenByUsing;
+          return (cell.tableLower ?? cell.table?.toLowerCase()) === tableKey;
+        });
+        if (matches.length !== 1) return null;
+        return matches[0].affinity ?? null;
+      },
       resolveCollation: (table, name) => {
         const key = name.toLowerCase();
         const tableKey = table?.toLowerCase();
@@ -9220,6 +9422,78 @@ function executeDetach(stmt, env) {
   return emptyResult(0, env.state.lastInsertRowid);
 }
 
+// src/schema/master-sql.ts
+function normalizeMasterSql(sql) {
+  const trimmed = sql.trim().replace(/;+\s*$/u, "").trim();
+  if (!trimmed) return trimmed;
+  const tokens = tokenize(trimmed);
+  if (tokens.length === 0 || tokens[0].kind === "EOF") return trimmed;
+  let i = 0;
+  const at = (offset, ...kinds) => {
+    const tok = tokens[i + offset];
+    return tok !== void 0 && kinds.includes(tok.kind);
+  };
+  if (!at(0, "CREATE")) return trimmed;
+  i++;
+  if (at(0, "TEMP", "TEMPORARY")) i++;
+  let headKind = "table";
+  if (at(0, "UNIQUE") && at(1, "INDEX")) {
+    headKind = "unique_index";
+    i += 2;
+  } else if (at(0, "VIRTUAL") && at(1, "TABLE")) {
+    headKind = "vtable";
+    i += 2;
+  } else if (at(0, "TABLE")) {
+    headKind = "table";
+    i++;
+  } else if (at(0, "VIEW")) {
+    headKind = "view";
+    i++;
+  } else if (at(0, "INDEX")) {
+    headKind = "index";
+    i++;
+  } else if (at(0, "TRIGGER")) {
+    headKind = "trigger";
+    i++;
+  } else {
+    return trimmed;
+  }
+  if (at(0, "IF") && at(1, "NOT") && at(2, "EXISTS")) i += 3;
+  let nameText = "";
+  let nameEnd = 0;
+  if (tokens[i] && tokens[i].kind !== "EOF" && at(1, "DOT") && tokens[i + 2] && tokens[i + 2].kind !== "EOF") {
+    nameText = trimmed.slice(tokens[i + 2].start, tokens[i + 2].end);
+    nameEnd = tokens[i + 2].end;
+    i += 3;
+  } else if (tokens[i] && tokens[i].kind !== "EOF") {
+    nameText = trimmed.slice(tokens[i].start, tokens[i].end);
+    nameEnd = tokens[i].end;
+    i++;
+  }
+  const body = nameEnd < trimmed.length ? trimmed.slice(nameEnd) : "";
+  const needsSpace = body.length > 0 && !/^[\s(]/u.test(body);
+  const head = headKind === "unique_index" ? "CREATE UNIQUE INDEX" : headKind === "vtable" ? "CREATE VIRTUAL TABLE" : headKind === "view" ? "CREATE VIEW" : headKind === "index" ? "CREATE INDEX" : headKind === "trigger" ? "CREATE TRIGGER" : "CREATE TABLE";
+  if (body.length === 0) return `${head} ${nameText}`;
+  return needsSpace ? `${head} ${nameText} ${body}` : `${head} ${nameText}${body}`;
+}
+function appendAddColumnToMasterSql(originalSql, alterSql) {
+  if (!originalSql || !alterSql) return originalSql;
+  const match = alterSql.match(/\bADD\s+(?:COLUMN\s+)?(.+)$/iu);
+  if (!match?.[1]) return originalSql;
+  const colDef = match[1].trim().replace(/;+\s*$/u, "").trim();
+  const close = originalSql.lastIndexOf(")");
+  if (close < 0) return originalSql;
+  return `${originalSql.slice(0, close)}, ${colDef}${originalSql.slice(close)}`;
+}
+function synthesizeCtasMasterSql(tableName, columnNames) {
+  const cols = columnNames.map(quoteIdentIfNeeded).join(",");
+  return `CREATE TABLE ${quoteIdentIfNeeded(tableName)}(${cols})`;
+}
+function quoteIdentIfNeeded(name) {
+  if (/^[A-Za-z_][A-Za-z0-9_]*$/u.test(name)) return name;
+  return `"${name.replaceAll('"', '""')}"`;
+}
+
 // src/functions/window.ts
 function rowsEqual(left, right) {
   if (left.length !== right.length) return false;
@@ -9495,6 +9769,8 @@ function queryPragma(name, args, env) {
   switch (key) {
     case "foreign_keys":
       return single("foreign_keys", env.state.foreignKeysEnabled ? 1 : 0);
+    case "case_sensitive_like":
+      return single("case_sensitive_like", env.state.caseSensitiveLike ? 1 : 0);
     case "user_version":
       return single("user_version", env.state.userVersion);
     case "schema_version":
@@ -9922,83 +10198,6 @@ function hasTableValuedFunction(name) {
   return hasRegisteredTableValuedFunction(name);
 }
 
-// src/schema/catalog.ts
-function schemaCatalogRows(state) {
-  const tables = [...state.tables.values()].sort((a, b) => compareNames2(a.name, b.name));
-  const indexes = [...state.indexes.values()].sort((a, b) => compareNames2(a.name, b.name));
-  const views = [...state.views.values()].sort((a, b) => compareNames2(a.name, b.name));
-  const triggers = [...state.triggers.values()].sort((a, b) => compareNames2(a.name, b.name));
-  const rows = [];
-  let rootpage = 2;
-  for (const table of tables) {
-    rows.push({
-      type: "table",
-      name: table.name,
-      tbl_name: table.name,
-      rootpage: rootpage++,
-      sql: table.originalSql
-    });
-  }
-  for (const index of indexes) {
-    rows.push({
-      type: "index",
-      name: index.name,
-      tbl_name: index.tableName,
-      rootpage: rootpage++,
-      sql: index.originalSql
-    });
-  }
-  for (const view of views) {
-    rows.push({
-      type: "view",
-      name: view.name,
-      tbl_name: view.name,
-      rootpage: 0,
-      sql: view.originalSql
-    });
-  }
-  for (const trigger of triggers) {
-    rows.push({
-      type: "trigger",
-      name: trigger.name,
-      tbl_name: trigger.tableName,
-      rootpage: 0,
-      sql: trigger.originalSql
-    });
-  }
-  return rows;
-}
-function compareNames2(a, b) {
-  return a < b ? -1 : a > b ? 1 : 0;
-}
-function buildSchemaCatalog(state, name = "sqlite_schema") {
-  const catalog = new Table(name, [
-    makeColumnInfo("type", "TEXT"),
-    makeColumnInfo("name", "TEXT"),
-    makeColumnInfo("tbl_name", "TEXT"),
-    makeColumnInfo("rootpage", "INTEGER"),
-    makeColumnInfo("sql", "TEXT")
-  ]);
-  for (const row of schemaCatalogRows(state)) {
-    catalog.insert({
-      values: {
-        type: row.type,
-        name: row.name,
-        tbl_name: row.tbl_name,
-        rootpage: row.rootpage,
-        sql: row.sql
-      }
-    });
-  }
-  return catalog;
-}
-function buildSqliteSchema(state) {
-  return buildSchemaCatalog(state, "sqlite_schema");
-}
-function buildSqliteMaster(state) {
-  return buildSchemaCatalog(state, "sqlite_master");
-}
-
 // src/expressions/equals.ts
 function exprEquals(left, right) {
   if (left.type !== right.type) return false;
@@ -10392,6 +10591,83 @@ function columnOnTable(column, alias, tableName) {
   return column.table !== null && matchesTable(column.table, alias, tableName);
 }
 
+// src/schema/catalog.ts
+function schemaCatalogRows(state) {
+  const tables = [...state.tables.values()].sort((a, b) => compareNames2(a.name, b.name));
+  const indexes = [...state.indexes.values()].sort((a, b) => compareNames2(a.name, b.name));
+  const views = [...state.views.values()].sort((a, b) => compareNames2(a.name, b.name));
+  const triggers = [...state.triggers.values()].sort((a, b) => compareNames2(a.name, b.name));
+  const rows = [];
+  let rootpage = 2;
+  for (const table of tables) {
+    rows.push({
+      type: "table",
+      name: table.name,
+      tbl_name: table.name,
+      rootpage: rootpage++,
+      sql: table.originalSql
+    });
+  }
+  for (const index of indexes) {
+    rows.push({
+      type: "index",
+      name: index.name,
+      tbl_name: index.tableName,
+      rootpage: rootpage++,
+      sql: index.originalSql
+    });
+  }
+  for (const view of views) {
+    rows.push({
+      type: "view",
+      name: view.name,
+      tbl_name: view.name,
+      rootpage: 0,
+      sql: view.originalSql
+    });
+  }
+  for (const trigger of triggers) {
+    rows.push({
+      type: "trigger",
+      name: trigger.name,
+      tbl_name: trigger.tableName,
+      rootpage: 0,
+      sql: trigger.originalSql
+    });
+  }
+  return rows;
+}
+function compareNames2(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+function buildSchemaCatalog(state, name = "sqlite_schema") {
+  const catalog = new Table(name, [
+    makeColumnInfo("type", "TEXT"),
+    makeColumnInfo("name", "TEXT"),
+    makeColumnInfo("tbl_name", "TEXT"),
+    makeColumnInfo("rootpage", "INTEGER"),
+    makeColumnInfo("sql", "TEXT")
+  ]);
+  for (const row of schemaCatalogRows(state)) {
+    catalog.insert({
+      values: {
+        type: row.type,
+        name: row.name,
+        tbl_name: row.tbl_name,
+        rootpage: row.rootpage,
+        sql: row.sql
+      }
+    });
+  }
+  return catalog;
+}
+function buildSqliteSchema(state) {
+  return buildSchemaCatalog(state, "sqlite_schema");
+}
+function buildSqliteMaster(state) {
+  return buildSchemaCatalog(state, "sqlite_master");
+}
+
 // src/executor/simple-select.ts
 function tryExecuteSimpleSelect(stmt, env) {
   if (stmt.with || stmt.compound || stmt.distinct || stmt.groupBy.length > 0 || stmt.having || stmt.windows.length > 0)
@@ -10440,7 +10716,9 @@ function tryExecuteSimpleSelect(stmt, env) {
       } catch {
         return null;
       }
-      filters.push({ column: eq.column.toLowerCase(), value });
+      const column = eq.column.toLowerCase();
+      const affinity = isRowidName2(column) ? "INTEGER" : table.columns.find((item) => (item.nameLower ?? item.name.toLowerCase()) === column)?.affinity;
+      filters.push({ column, value: affinity ? applyAffinity(value, affinity) : value });
     }
   }
   let limit = env.maxRows;
@@ -10622,7 +10900,7 @@ function executeSelect2(stmt, env, parent) {
   }
   const savedCtes = new Map(env.ctes);
   try {
-    if (stmt.with) executeWith(stmt, env, parent);
+    if (stmt.with) executeWith(stmt.with, env, parent);
     const base = executeSelectCore(
       {
         ...stmt,
@@ -10678,22 +10956,39 @@ function executeSelect2(stmt, env, parent) {
     for (const [name, result] of savedCtes) env.ctes.set(name, result);
   }
 }
-function executeWith(stmt, env, parent) {
-  for (const cte of stmt.with.ctes) {
+function executeWith(withClause, env, parent) {
+  for (const cte of withClause.ctes) {
     const key = cte.name.toLowerCase();
-    if (stmt.with.recursive && referencesTable(cte.select, cte.name) && cte.select.compound) {
+    if (withClause.recursive && referencesTable(cte.select, cte.name) && cte.select.compound) {
       const anchor = executeSelect2({ ...cte.select, compound: null }, env, parent);
       const columns = cte.columns ?? anchor.columns;
-      let accumulated = resultValues(anchor);
-      let delta = accumulated;
-      while (true) {
-        env.ctes.set(key, valuesToResult(columns, delta));
-        const nextResult = executeSelect2(cte.select.compound.select, env, parent);
+      const recursive = cte.select.compound.select;
+      const limit = recursive.limit ? toInteger(evalExpr(recursive.limit.limit, env.createEvalContext(null, parent))) : null;
+      if (recursive.limit && limit === null) throw new SqliteError("datatype mismatch", "datatype_mismatch");
+      const maxRows = limit === null || Number(limit) < 0 ? Number.POSITIVE_INFINITY : Number(limit);
+      const queue = resultValues(anchor);
+      const discovered = [...queue];
+      const accumulated = [];
+      if (recursive.orderBy.length > 0) {
+        queue.sort((left, right) => compareCteQueueRows(left, right, columns, recursive.orderBy, env, parent));
+      }
+      while (queue.length > 0 && accumulated.length < maxRows) {
+        const current = queue.shift();
+        accumulated.push(current);
+        env.ctes.set(key, valuesToResult(columns, [current]));
+        const nextResult = executeSelect2({ ...recursive, orderBy: [], limit: null }, env, parent);
         const candidates = resultValues(nextResult);
-        const additions = cte.select.compound.op === "UNION ALL" ? candidates : candidates.filter((row) => !accumulated.some((existing) => rowsEqual2(existing, row)));
-        if (additions.length === 0) break;
-        accumulated = [...accumulated, ...additions];
-        delta = additions;
+        const additions = [];
+        for (const candidate of candidates) {
+          if (cte.select.compound.op !== "UNION ALL" && [...discovered, ...additions].some((existing) => rowsEqual2(existing, candidate)))
+            continue;
+          additions.push(candidate);
+        }
+        discovered.push(...additions);
+        queue.push(...additions);
+        if (recursive.orderBy.length > 0) {
+          queue.sort((left, right) => compareCteQueueRows(left, right, columns, recursive.orderBy, env, parent));
+        }
       }
       env.ctes.set(key, valuesToResult(columns, accumulated));
     } else {
@@ -10703,6 +10998,26 @@ function executeWith(stmt, env, parent) {
     }
   }
 }
+function compareCteQueueRows(left, right, columns, order, env, parent) {
+  const scope = (values) => ({
+    cells: columns.map((name, index) => ({ table: null, name, value: values[index] ?? null }))
+  });
+  const leftScope = scope(left);
+  const rightScope = scope(right);
+  for (const item of order) {
+    if (item.expr.type === "literal" && typeof item.expr.value === "number" && Number.isInteger(item.expr.value)) {
+      const index = item.expr.value - 1;
+      const result2 = compareNullable(left[index] ?? null, right[index] ?? null, item);
+      if (result2 !== 0) return result2;
+      continue;
+    }
+    const a = evalExpr(item.expr, env.createEvalContext(leftScope, parent));
+    const b = evalExpr(item.expr, env.createEvalContext(rightScope, parent));
+    const result = compareNullable(a, b, item, leftScope);
+    if (result !== 0) return result;
+  }
+  return 0;
+}
 function executeSelectCore(stmt, env, parent) {
   let scopes;
   let skipWhere = false;
@@ -10758,10 +11073,18 @@ function executeSelectCore(stmt, env, parent) {
     }
   }
   const groupBy = stmt.groupBy.map((expr) => {
-    if (expr.type !== "literal" || typeof expr.value !== "number" || !Number.isInteger(expr.value)) return expr;
-    const column = stmt.columns[expr.value - 1];
-    if (column?.type !== "expr") throw new SqliteError(`${expr.value}th GROUP BY term out of range`, "other");
-    return column.expr;
+    if (expr.type === "literal" && typeof expr.value === "number" && Number.isInteger(expr.value)) {
+      const column = stmt.columns[expr.value - 1];
+      if (column?.type !== "expr") throw new SqliteError(`${expr.value}th GROUP BY term out of range`, "other");
+      return column.expr;
+    }
+    if (expr.type === "column" && expr.table === null) {
+      const column = stmt.columns.find(
+        (candidate) => candidate.type === "expr" && candidate.alias?.toLowerCase() === expr.name.toLowerCase()
+      );
+      if (column?.type === "expr") return column.expr;
+    }
+    return expr;
   });
   const groups = aggregate ? groupRows(scopes, groupBy, env, parent) : scopes.map((scope) => [scope]);
   const windowScopes = aggregate ? groups.map((group) => group[0] ?? { cells: [] }) : scopes;
@@ -11218,7 +11541,10 @@ function groupRows(rows, expressions, env, parent) {
   const groups = [];
   const indexByKey = /* @__PURE__ */ new Map();
   for (const row of rows) {
-    const keyValues = expressions.map((expr) => evalExpr(expr, env.createEvalContext(row, parent)));
+    const keyValues = expressions.map((expr) => {
+      const value = evalExpr(expr, env.createEvalContext(row, parent));
+      return expr.type === "collate" ? normalizeForCollation(value, expr.collation) : value;
+    });
     const key = valueKey(keyValues);
     const index = indexByKey.get(key);
     if (index === void 0) {
@@ -11241,7 +11567,8 @@ function aggregateValue(expr, rows, env, parent) {
   const accumulator = env.functions.createAggregate(expr.name);
   if (!accumulator) throw new SqliteError(`no such aggregate function: ${expr.name}`, "other");
   const seen = [];
-  for (const row of rows) {
+  const orderedRows = expr.orderBy.length > 0 ? [...rows].sort((a, b) => compareScopes(a, b, expr.orderBy, env, parent)) : rows;
+  for (const row of orderedRows) {
     const ctx = env.createEvalContext(row, parent);
     if (expr.filter && isTruthySql(evalExpr(expr.filter, ctx)) !== true) continue;
     const args = expr.args === "*" ? [] : expr.args.map((arg) => evalExpr(arg, ctx));
@@ -11357,8 +11684,10 @@ function frameBounds(spec, index, length, ctx, defaultFrameEnd, orderKeys) {
   if (!spec.frame) return [0, spec.orderBy.length > 0 ? defaultFrameEnd : Math.max(0, length - 1)];
   const isRangeLike = spec.frame.type === "RANGE" || spec.frame.type === "GROUPS";
   let peerFirst = index;
+  let peerLast = index;
   if (isRangeLike && spec.orderBy.length > 0) {
     while (peerFirst > 0 && rowsEqual2(orderKeys[peerFirst], orderKeys[peerFirst - 1])) peerFirst--;
+    while (peerLast + 1 < length && rowsEqual2(orderKeys[peerLast], orderKeys[peerLast + 1])) peerLast++;
   }
   const bound = (item, isStart) => {
     switch (item.kind) {
@@ -11367,12 +11696,54 @@ function frameBounds(spec, index, length, ctx, defaultFrameEnd, orderKeys) {
       case "unbounded_following":
         return Math.max(0, length - 1);
       case "current_row":
-        if (isRangeLike) return isStart ? peerFirst : defaultFrameEnd;
+        if (isRangeLike) return isStart ? peerFirst : peerLast;
         return index;
       case "preceding":
-        return Math.max(0, index - Number(toInteger(evalExpr(item.expr, ctx)) ?? 0));
-      case "following":
-        return Math.min(Math.max(0, length - 1), index + Number(toInteger(evalExpr(item.expr, ctx)) ?? 0));
+      case "following": {
+        const offset = Number(evalExpr(item.expr, ctx));
+        if (spec.frame?.type === "GROUPS") {
+          const groups = [];
+          for (let i = 0; i < length; ) {
+            let last = i;
+            while (last + 1 < length && rowsEqual2(orderKeys[last], orderKeys[last + 1])) last++;
+            groups.push({ first: i, last });
+            i = last + 1;
+          }
+          const currentGroup = groups.findIndex((group) => index >= group.first && index <= group.last);
+          const delta = item.kind === "preceding" ? -offset : offset;
+          const target = groups[Math.max(0, Math.min(groups.length - 1, currentGroup + delta))];
+          return isStart ? target.first : target.last;
+        }
+        if (spec.frame?.type === "RANGE" && spec.orderBy.length === 1) {
+          const rawCurrent = orderKeys[index]?.[0];
+          const current = typeof rawCurrent === "number" ? rawCurrent : typeof rawCurrent === "bigint" ? Number(rawCurrent) : rawCurrent && typeof rawCurrent === "object" && "value" in rawCurrent ? Number(rawCurrent.value) : Number.NaN;
+          if (!Number.isFinite(current) || !Number.isFinite(offset)) return isStart ? peerFirst : peerLast;
+          const descending = spec.orderBy[0]?.dir === "DESC";
+          const signed = item.kind === "preceding" ? -offset : offset;
+          const target = current + (descending ? -signed : signed);
+          const numericKey = (position) => {
+            const value = orderKeys[position]?.[0];
+            if (typeof value === "number") return value;
+            if (typeof value === "bigint") return Number(value);
+            if (value && typeof value === "object" && "value" in value) return Number(value.value);
+            return Number.NaN;
+          };
+          if (isStart) {
+            for (let i = 0; i < length; i++) {
+              const value = numericKey(i);
+              if (descending && value <= target || !descending && value >= target) return i;
+            }
+            return length;
+          }
+          for (let i = length - 1; i >= 0; i--) {
+            const value = numericKey(i);
+            if (descending && value >= target || !descending && value <= target) return i;
+          }
+          return -1;
+        }
+        const rowOffset = Number(toInteger(evalExpr(item.expr, ctx)) ?? 0);
+        return item.kind === "preceding" ? Math.max(0, index - rowOffset) : Math.min(Math.max(0, length - 1), index + rowOffset);
+      }
     }
   };
   return [bound(spec.frame.start, true), bound(spec.frame.end, false)];
@@ -11704,14 +12075,17 @@ function scanFtsVocab(db, alias, vocab) {
 
 // src/executor/ddl.ts
 function executeCreateTable(stmt, env) {
+  const sourceSql = env.statementSql ? normalizeMasterSql(env.statementSql) : null;
   if (!stmt.asSelect) {
-    env.state.createTable(stmt);
+    env.state.createTable(stmt, sourceSql);
     env.state.recordChange(0);
     return emptyResult(0, env.state.lastInsertRowid);
   }
   const result = executeSelect2(stmt.asSelect, env);
   const columns = result.columns.map((name) => ({ name, typeName: null, constraints: [] }));
-  const table = env.state.createTable({ ...stmt, columns, constraints: [], asSelect: null });
+  const bareName = stmt.name.includes(".") ? stmt.name.split(".").pop() ?? stmt.name : stmt.name;
+  const ctasSql = synthesizeCtasMasterSql(bareName, result.columns);
+  const table = env.state.createTable({ ...stmt, columns, constraints: [], asSelect: null }, ctasSql);
   for (const values of resultValues(result)) {
     table.insert(
       new Map(table.columns.map((column, index) => [normalizeColumnName(column.name), values[index] ?? null]))
@@ -11736,7 +12110,7 @@ function executeCreateTable(stmt, env) {
   return emptyResult(0, env.state.lastInsertRowid);
 }
 function executeCreateIndex(stmt, env) {
-  const index = env.state.createIndex(stmt);
+  const index = env.state.createIndex(stmt, env.statementSql ? normalizeMasterSql(env.statementSql) : null);
   const table = env.state.getTable(stmt.table);
   try {
     for (const row of table.scan()) {
@@ -11816,6 +12190,7 @@ function executeAlterTable(stmt, env) {
       throw new SqliteError("Cannot add a NOT NULL column with default value NULL", "other");
     table.columns.push(column);
     for (const row of table.rows.values()) row.values.set(normalizeColumnName(column.name), defaultValue);
+    table.originalSql = appendAddColumnToMasterSql(table.originalSql, env.statementSql);
     table.clearEqualityHashes();
     env.state.schemaVersion++;
   } else {
@@ -11863,7 +12238,7 @@ function executeDropIndex(stmt, env) {
   return emptyResult(0, env.state.lastInsertRowid);
 }
 function executeCreateView(stmt, env) {
-  env.state.createView(stmt);
+  env.state.createView(stmt, env.statementSql ? normalizeMasterSql(env.statementSql) : null);
   return emptyResult(0, env.state.lastInsertRowid);
 }
 function executeDropView(stmt, env) {
@@ -11956,7 +12331,7 @@ function executeCreateTrigger(stmt, env) {
     forEachRow: stmt.forEachRow,
     body: stmt.body,
     updateColumns: stmt.updateColumns,
-    originalSql: null
+    originalSql: env.statementSql ? normalizeMasterSql(env.statementSql) : null
   });
   return emptyResult(0, env.state.lastInsertRowid);
 }
@@ -11999,6 +12374,7 @@ function executeTriggerProgram(trigger, table, oldRow, newValues, env) {
   }
   env.triggerDepth++;
   const savedScope = env.triggerScope;
+  const savedLastInsertRowid = env.state.lastInsertRowid;
   env.triggerScope = triggerScope(table, oldRow, newValues);
   try {
     for (const statement of trigger.body) {
@@ -12016,6 +12392,7 @@ function executeTriggerProgram(trigger, table, oldRow, newValues, env) {
     }
     throw error;
   } finally {
+    env.state.lastInsertRowid = savedLastInsertRowid;
     env.triggerScope = savedScope;
     env.triggerDepth--;
   }
@@ -12051,7 +12428,7 @@ function triggerScope(table, oldRow, newValues) {
 
 // src/executor/vtable.ts
 function executeCreateVirtualTable(stmt, env) {
-  env.state.createVirtualTable(stmt);
+  env.state.createVirtualTable(stmt, env.statementSql ? normalizeMasterSql(env.statementSql) : null);
   env.state.recordChange(0);
   return emptyResult(0, env.state.lastInsertRowid);
 }
@@ -12110,9 +12487,20 @@ function storeColumnValue(table, column, value) {
   return applyAffinity(value, column.affinity);
 }
 function executeInsert(stmt, env) {
+  try {
+    return withDmlCtes(stmt.with, env, () => executeInsertCore(stmt, env));
+  } catch (error) {
+    handleConflictRollback(stmt.mode === "insert_or_rollback", error, env);
+    throw error;
+  }
+}
+function executeInsertCore(stmt, env) {
   if (env.state.isVirtualTable(stmt.table)) {
     return executeVirtualInsert(stmt, env);
   }
+  const totalBefore = env.state.totalChanges;
+  const view = writableView(stmt.table, "INSERT", env);
+  if (view) return executeViewInsert(stmt, view, env, totalBefore);
   const fast = tryFastInsert(stmt, env);
   if (fast) return fast;
   const table = env.state.getWritableTable(stmt.table);
@@ -12130,11 +12518,14 @@ function executeInsert(stmt, env) {
   const suppliedIndexes = table.columns.map(
     (column) => columnNames.findIndex((name) => name.toLowerCase() === (column.nameLower ?? column.name.toLowerCase()))
   );
-  const unconstrained = table.isUnconstrained() && !stmt.upsert && stmt.mode === "insert" && stmt.returning.length === 0 && rowidIndexes.length === 0;
+  const unconstrained = table.isUnconstrained() && env.state.databaseForTable(table).triggers.size === 0 && !stmt.upsert && stmt.mode === "insert" && stmt.returning.length === 0 && rowidIndexes.length === 0;
   if (unconstrained) {
     for (const source of sourceRows) {
       if (source.length !== columnNames.length)
-        throw new SqliteError(`${source.length} values for ${columnNames.length} columns`, "other");
+        throw new SqliteError(
+          stmt.columns ? `${source.length} values for ${columnNames.length} columns` : `table ${table.name} has ${columnNames.length} columns but ${source.length} values were supplied`,
+          "other"
+        );
       const values = /* @__PURE__ */ new Map();
       for (let index = 0; index < table.columns.length; index++) {
         const column = table.columns[index];
@@ -12150,7 +12541,10 @@ function executeInsert(stmt, env) {
   }
   for (const source of sourceRows) {
     if (source.length !== columnNames.length)
-      throw new SqliteError(`${source.length} values for ${columnNames.length} columns`, "other");
+      throw new SqliteError(
+        stmt.columns ? `${source.length} values for ${columnNames.length} columns` : `table ${table.name} has ${columnNames.length} columns but ${source.length} values were supplied`,
+        "other"
+      );
     const values = /* @__PURE__ */ new Map();
     for (const column of table.columns) {
       if (column.generated) continue;
@@ -12238,9 +12632,12 @@ function executeInsert(stmt, env) {
       validateRow(table, row, env);
       if (table.indexes.length > 0) addIndexes(table, row, env);
       if (env.state.foreignKeysEnabled) checkForeignKeys(table, row, env);
+      if (!table.withoutRowid) {
+        last = rowid;
+        env.state.lastInsertRowid = rowid;
+      }
       fireInsertTriggers("AFTER", table, row.values, null, env);
       changes++;
-      last = table.withoutRowid ? 0 : rowid;
       if (stmt.returning.length)
         returningRows.push(projectReturning(stmt.returning, scopeFor(table, row, stmt.table, env), env));
     } catch (error) {
@@ -12253,12 +12650,12 @@ function executeInsert(stmt, env) {
       throw error;
     }
   }
-  env.state.recordChange(changes, last);
-  if (stmt.returning.length === 0) return emptyResult(changes, last);
-  return valuesToResult(returningNames(stmt.returning, table), returningRows, changes, last);
+  const reportedChanges = finalizeDmlChanges(totalBefore, changes, env, last);
+  if (stmt.returning.length === 0) return emptyResult(reportedChanges, last);
+  return valuesToResult(returningNames(stmt.returning, table), returningRows, reportedChanges, last);
 }
 function evaluateInsertSource(stmt, env) {
-  if (stmt.select) return resultValues(executeSelect2({ ...stmt.select, with: stmt.with ?? stmt.select.with }, env));
+  if (stmt.select) return resultValues(executeSelect2(stmt.select, env));
   if (!stmt.values) return [[]];
   const ctx = env.createEvalContext();
   return stmt.values.map(
@@ -12287,6 +12684,7 @@ function tryFastInsert(stmt, env) {
   } catch {
     return null;
   }
+  if (env.state.databaseForTable(table).triggers.size > 0) return null;
   if (!table.isUnconstrained()) return null;
   const values = /* @__PURE__ */ new Map();
   for (const slot of plan.slots) values.set(slot.key, applyAffinity(slot.read(env), slot.affinity));
@@ -12331,9 +12729,20 @@ function buildFastInsertPlan(stmt, env) {
   return { tableName: stmt.table, slots };
 }
 function executeUpdate(stmt, env) {
+  try {
+    return withDmlCtes(stmt.with, env, () => executeUpdateCore(stmt, env));
+  } catch (error) {
+    handleConflictRollback(stmt.or === "rollback", error, env);
+    throw error;
+  }
+}
+function executeUpdateCore(stmt, env) {
   if (env.state.isVirtualTable(stmt.table)) {
     return executeVirtualUpdate(stmt, env);
   }
+  const totalBefore = env.state.totalChanges;
+  const view = writableView(stmt.table, "UPDATE", env);
+  if (view) return executeViewUpdate(stmt, view, env, totalBefore);
   const table = env.state.getWritableTable(stmt.table);
   const alias = stmt.alias ?? stmt.table;
   const candidates = [];
@@ -12386,13 +12795,24 @@ function executeUpdate(stmt, env) {
       throw error;
     }
   }
-  env.state.recordChange(changes);
-  return valuesToResult(returningNames(stmt.returning, table), returningRows, changes, env.state.lastInsertRowid);
+  const reportedChanges = finalizeDmlChanges(totalBefore, changes, env);
+  return valuesToResult(
+    returningNames(stmt.returning, table),
+    returningRows,
+    reportedChanges,
+    env.state.lastInsertRowid
+  );
 }
 function executeDelete(stmt, env) {
+  return withDmlCtes(stmt.with, env, () => executeDeleteCore(stmt, env));
+}
+function executeDeleteCore(stmt, env) {
   if (env.state.isVirtualTable(stmt.table)) {
     return executeVirtualDelete(stmt, env);
   }
+  const totalBefore = env.state.totalChanges;
+  const view = writableView(stmt.table, "DELETE", env);
+  if (view) return executeViewDelete(stmt, view, env, totalBefore);
   const table = env.state.getWritableTable(stmt.table);
   const selectedSource = stmt.where === null ? null : tryIndexedTableRows({ type: "table", schema: null, name: stmt.table, alias: stmt.alias }, stmt.where, env);
   const selected = [...selectedSource ? selectedSource.rows : table.scan()].filter((row) => {
@@ -12410,8 +12830,120 @@ function executeDelete(stmt, env) {
     fireDeleteTriggers("AFTER", table, row, env);
     changes++;
   }
-  env.state.recordChange(changes);
-  return valuesToResult(returningNames(stmt.returning, table), returningRows, changes, env.state.lastInsertRowid);
+  const reportedChanges = finalizeDmlChanges(totalBefore, changes, env);
+  return valuesToResult(
+    returningNames(stmt.returning, table),
+    returningRows,
+    reportedChanges,
+    env.state.lastInsertRowid
+  );
+}
+function withDmlCtes(withClause, env, execute) {
+  if (!withClause) return execute();
+  const savedCtes = new Map(env.ctes);
+  try {
+    executeWith(withClause, env);
+    return execute();
+  } finally {
+    env.ctes.clear();
+    for (const [name, result] of savedCtes) env.ctes.set(name, result);
+  }
+}
+function handleConflictRollback(rollback, error, env) {
+  if (rollback && env.transactions.inTransaction && error instanceof SqliteError && error.category.startsWith("constraint")) {
+    env.transactions.rollback();
+  }
+}
+function writableView(name, event, env) {
+  const { schema, bare } = splitQualifiedName(name);
+  const db = env.state.databaseForSchema(schema, name);
+  const view = db.views.get(bare.toLowerCase());
+  if (!view) return null;
+  const hasInsteadOf = [...db.triggers.values()].some(
+    (trigger) => trigger.tableName.toLowerCase() === bare.toLowerCase() && trigger.event === event && trigger.timing === "INSTEAD"
+  );
+  if (!hasInsteadOf) {
+    env.state.getWritableTable(name);
+    throw new SqliteError(`cannot modify ${bare} because it is a view`, "other");
+  }
+  const names = view.columns ?? executeSelect2(view.select, env).columns;
+  return {
+    schema,
+    name: bare,
+    view,
+    table: new Table(
+      bare,
+      names.map((column) => makeColumnInfo(column, null))
+    )
+  };
+}
+function executeViewInsert(stmt, target, env, totalBefore) {
+  const columnNames = stmt.columns ?? target.table.columns.map((column) => column.name);
+  for (const name of columnNames) columnOf(target.table, name);
+  const suppliedIndexes = target.table.columns.map(
+    (column) => columnNames.findIndex((name) => name.toLowerCase() === normalizeColumnName(column.name))
+  );
+  for (const source of evaluateInsertSource(stmt, env)) {
+    if (source.length !== columnNames.length) {
+      throw new SqliteError(`${source.length} values for ${columnNames.length} columns`, "other");
+    }
+    const values = /* @__PURE__ */ new Map();
+    target.table.columns.forEach((column, index) => {
+      const supplied = suppliedIndexes[index] ?? -1;
+      values.set(normalizeColumnName(column.name), supplied < 0 ? null : source[supplied] ?? null);
+    });
+    fireInsertTriggers("INSTEAD", target.table, values, null, env);
+  }
+  const changes = finalizeDmlChanges(totalBefore, 0, env);
+  return emptyResult(changes, env.state.lastInsertRowid);
+}
+function executeViewUpdate(stmt, target, env, totalBefore) {
+  const alias = stmt.alias ?? target.name;
+  const scopes = scanView(target, alias, env);
+  const updatedColumns = new Set(
+    stmt.set.flatMap((item) => item.columns.map((name) => columnOf(target.table, name).name))
+  );
+  for (const scope of scopes) {
+    const ctx = env.createEvalContext(scope);
+    if (stmt.where && isTruthySql(evalExpr(stmt.where, ctx)) !== true) continue;
+    const oldRow = viewRow(target.table, scope);
+    const updates = evaluateSet(stmt.set, target.table, ctx);
+    const newValues = mergedValues(target.table, oldRow, updates);
+    fireUpdateTriggers("INSTEAD", target.table, oldRow, newValues, updatedColumns, env);
+  }
+  const changes = finalizeDmlChanges(totalBefore, 0, env);
+  return emptyResult(changes, env.state.lastInsertRowid);
+}
+function executeViewDelete(stmt, target, env, totalBefore) {
+  const alias = stmt.alias ?? target.name;
+  for (const scope of scanView(target, alias, env)) {
+    if (stmt.where && isTruthySql(evalExpr(stmt.where, env.createEvalContext(scope))) !== true) continue;
+    fireDeleteTriggers("INSTEAD", target.table, viewRow(target.table, scope), env);
+  }
+  const changes = finalizeDmlChanges(totalBefore, 0, env);
+  return emptyResult(changes, env.state.lastInsertRowid);
+}
+function scanView(target, alias, env) {
+  return scanFrom(
+    { type: "table", schema: target.schema, name: target.name, alias: alias === target.name ? null : alias },
+    env
+  );
+}
+function viewRow(table, scope) {
+  const values = /* @__PURE__ */ new Map();
+  for (const column of table.columns) {
+    const key = normalizeColumnName(column.name);
+    const cell = scope.cells.find((candidate) => normalizeColumnName(candidate.name) === key);
+    values.set(key, cell?.value ?? null);
+  }
+  return { rowid: scope.rowid ?? 0, values };
+}
+function finalizeDmlChanges(totalBefore, directChanges, env, last) {
+  const triggerChanges = env.state.totalChanges - totalBefore;
+  env.state.recordChange(directChanges, last);
+  const reportedChanges = triggerChanges + directChanges;
+  env.state.changes = reportedChanges;
+  return reportedChanges;
 }
 function mergedValues(table, row, updates) {
   const values = /* @__PURE__ */ new Map();
@@ -12722,7 +13254,7 @@ function applyReferentialDelete(parent, row, env) {
         } else if (constraint.onDelete === "SET DEFAULT") {
           const updated = updateOne(child, candidate, defaultUpdates(child, constraint.columns, env), env);
           changes += 1 + updated.cascaded;
-        } else if (!fkIsDeferred(constraint, env)) {
+        } else if (constraint.onDelete === "RESTRICT" || !fkIsDeferred(constraint, env)) {
           throw new SqliteError("FOREIGN KEY constraint failed", "constraint_foreign", "SQLITE_CONSTRAINT_FOREIGNKEY");
         }
       }
@@ -12765,7 +13297,7 @@ function applyReferentialUpdate(parent, before, after, env) {
         } else if (constraint.onUpdate === "SET DEFAULT") {
           const updated = updateOne(child, candidate, defaultUpdates(child, constraint.columns, env), env);
           changes += 1 + updated.cascaded;
-        } else if (!fkIsDeferred(constraint, env)) {
+        } else if (constraint.onUpdate === "RESTRICT" || !fkIsDeferred(constraint, env)) {
           throw new SqliteError("FOREIGN KEY constraint failed", "constraint_foreign", "SQLITE_CONSTRAINT_FOREIGNKEY");
         }
       }
@@ -13046,6 +13578,11 @@ function executePragma(name, expr, env) {
     if (!env.transactions.inTransaction) env.state.foreignKeysEnabled = coercePragmaTruthy(value);
     return emptyResult(0, env.state.lastInsertRowid);
   }
+  if (key === "case_sensitive_like" && expr !== null) {
+    const value = evalPragmaSetValue(expr, env);
+    env.state.caseSensitiveLike = coercePragmaTruthy(value);
+    return emptyResult(0, env.state.lastInsertRowid);
+  }
   if ((key === "user_version" || key === "schema_version") && expr !== null) {
     const value = evalPragmaSetValue(expr, env);
     const num2 = coercePragmaInt(value);
@@ -13193,10 +13730,11 @@ function executeAnalyze(stmt, env) {
 
 // src/api/statement.ts
 var Statement = class _Statement {
-  constructor(database, sql, statements) {
+  constructor(database, sql, statements, statementSqls) {
     this.database = database;
     this.sql = sql;
     this.statements = statements;
+    this.statementSqls = statementSqls;
     this.schemaVersion = database.state.schemaVersion;
   }
   database;
@@ -13204,13 +13742,24 @@ var Statement = class _Statement {
   namedPlan = null;
   env = null;
   statements;
+  statementSqls;
   schemaVersion;
   /**
    * Construct a {@link Statement} for {@link Database.prepare} / {@link Database.exec}.
    * @internal
    */
-  static create(database, sql, statements) {
-    return new _Statement(database, sql, statements);
+  static create(database, sql, statements, statementSqls) {
+    return new _Statement(database, sql, statements, statementSqls ?? statements.map(() => sql));
+  }
+  /** @internal Build from {@link parseUnits}. */
+  static createFromSql(database, sql) {
+    const units = parseUnits(sql);
+    return new _Statement(
+      database,
+      sql,
+      units.map((u) => u.statement),
+      units.map((u) => u.sql)
+    );
   }
   /**
    * Execute for side effects (INSERT / UPDATE / DELETE / DDL).
@@ -13258,7 +13807,10 @@ var Statement = class _Statement {
   execute(params, options) {
     this.database.assertOpen();
     this.reprepareIfSchemaChanged();
-    if (this.statements.length === 0) throw new SqliteError("empty statement", "misuse");
+    if (this.statements.length === 0) {
+      if (options?.named) throw new SqliteError("empty statement", "misuse");
+      return emptyResult(this.database.state.changes, this.database.state.lastInsertRowid);
+    }
     this.namedPlan ??= planNamedParameters(this.sql);
     const expected = this.namedPlan.expectedCount;
     if (params.length > 0 && params.length !== expected) {
@@ -13270,9 +13822,11 @@ var Statement = class _Statement {
     env.includeValues = true;
     this.bindNamed(env, params);
     let result;
-    for (const statement of this.statements) {
-      result = executeStatement(statement, env);
+    for (let i = 0; i < this.statements.length; i++) {
+      env.statementSql = this.statementSqls[i] ?? this.sql;
+      result = executeStatement(this.statements[i], env);
     }
+    env.statementSql = null;
     return result;
   }
   obtainEnv(params) {
@@ -13292,7 +13846,9 @@ var Statement = class _Statement {
   }
   reprepareIfSchemaChanged() {
     if (this.schemaVersion === this.database.state.schemaVersion) return;
-    this.statements = parse(this.sql);
+    const units = parseUnits(this.sql);
+    this.statements = units.map((u) => u.statement);
+    this.statementSqls = units.map((u) => u.sql);
     this.env = null;
     this.namedPlan = null;
     this.schemaVersion = this.database.state.schemaVersion;
@@ -13330,11 +13886,18 @@ function planNamedParameters(sql) {
 var Database = class {
   /** @internal Engine catalog, tables, and mutation counters. */
   state = new DatabaseState();
-  /** Seed used to construct the PRNG. */
+  /** Seed used to construct the PRNG. Ignored when {@link randomMode} is `"os"`. */
   seed;
+  /** Entropy mode for `random()` / `randomblob()`. */
+  randomMode;
+  /**
+   * When true, `'now'` follows the wall clock and {@link restore} does not freeze it.
+   * @internal
+   */
+  systemClock;
   /**
    * PRNG backing `random()` / `randomblob()` and related builtins.
-   * Prefer passing `seed` to the constructor.
+   * Prefer passing `seed` / `random` to the constructor.
    * @internal
    */
   prng;
@@ -13357,7 +13920,9 @@ var Database = class {
    */
   constructor(options = {}) {
     this.seed = options.seed ?? DEFAULT_DATABASE_SEED;
-    this.prng = new Prng(this.seed);
+    this.randomMode = options.random ?? "deterministic";
+    this.systemClock = options.now === "system";
+    this.prng = this.randomMode === "os" ? new OsEntropy() : new Prng(this.seed);
     this.now = resolveClock(options.now);
     this.transactions = new TransactionManager(this.state, this.prng);
   }
@@ -13374,7 +13939,7 @@ var Database = class {
     if (arguments.length > 1) {
       throw new SqliteError("exec() does not accept parameters; use prepare() or query()", "misuse");
     }
-    Statement.create(this, sql, parse(sql)).run();
+    Statement.createFromSql(this, sql).run();
   }
   /**
    * Execute a single-statement query and return all rows as objects keyed by column name.
@@ -13471,7 +14036,7 @@ var Database = class {
     this.state.replaceWith(decoded.state, { adopt: true });
     if (decoded.runtime) {
       this.prng.setState(decoded.runtime.prngState);
-      this.now = fixedClock(new Date(decoded.runtime.nowMs));
+      if (!this.systemClock) this.now = fixedClock(new Date(decoded.runtime.nowMs));
     }
   }
   /**
@@ -13506,6 +14071,15 @@ var Database = class {
     this.assertOpen();
     return this.state.lastInsertRowid;
   }
+  /**
+   * Cumulative rows changed by INSERT / UPDATE / DELETE (SQLite `total_changes()`).
+   *
+   * @throws {SqliteError} If the database is closed.
+   */
+  get totalChanges() {
+    this.assertOpen();
+    return this.state.totalChanges;
+  }
   /**
    * Throw if {@link close} has already been called.
    * @internal
@@ -13515,14 +14089,19 @@ var Database = class {
     if (this.closed) throw new SqliteError("Database is closed", "misuse");
   }
   prepareSingle(sql) {
-    const statements = parse(sql);
-    if (statements.length === 0) {
+    const units = parseUnits(sql);
+    if (units.length === 0) {
       throw new SqliteError("empty statement", "misuse");
     }
-    if (statements.length > 1) {
+    if (units.length > 1) {
       throw new SqliteError("query()/prepare() accept a single statement only; use exec() for scripts", "misuse");
     }
-    return Statement.create(this, sql, statements);
+    return Statement.create(
+      this,
+      sql,
+      units.map((u) => u.statement),
+      units.map((u) => u.sql)
+    );
   }
 };
 var disposeKey = Symbol.dispose;