@crvouga/sqlite-mem 1.1.1 → 1.2.0

package/dist/unstable.js

@@ -125,6 +125,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;
@@ -281,14 +298,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;
   }
@@ -1694,7 +1715,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);
@@ -2152,13 +2177,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");
   }
@@ -2168,13 +2195,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);
@@ -2481,11 +2508,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);
@@ -2830,7 +2857,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);
@@ -2883,11 +2911,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;
@@ -3024,6 +3059,8 @@ function explicitCollation(expr) {
     case "unary":
     case "cast":
       return explicitCollation(expr.expr);
+    case "is_bool":
+      return explicitCollation(expr.expr);
     case "binary":
       return explicitCollation(expr.left) ?? explicitCollation(expr.right);
     case "between":
@@ -3054,18 +3091,32 @@ function inheritedCollation(expr, ctx) {
     case "unary":
     case "cast":
       return inheritedCollation(expr.expr, ctx);
+    case "is_bool":
+      return inheritedCollation(expr.expr, ctx);
     default:
       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);
     }
   }
@@ -3099,13 +3150,21 @@ function evalExpr(expr, ctx) {
       if (expr.op === "-") return asNumber(-numberValue(value));
       return ~integerValue(value);
     }
+    case "is_bool": {
+      const truth = isTruthySql(evalExpr(expr.expr, ctx));
+      if (!expr.not && expr.sense) return booleanValue(truth === true);
+      if (!expr.not && !expr.sense) return booleanValue(truth === false);
+      if (expr.not && expr.sense) return booleanValue(truth !== true);
+      return booleanValue(truth !== false);
+    }
     case "binary":
       return evalBinary(expr.op, expr.left, expr.right, 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;
     }
@@ -3132,14 +3191,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": {
@@ -3277,6 +3341,7 @@ var KEYWORDS = {
   FOREIGN: "FOREIGN",
   FROM: "FROM",
   FULL: "FULL",
+  FALSE: "FALSE",
   GENERATED: "GENERATED",
   GLOB: "GLOB",
   GROUP: "GROUP",
@@ -3351,6 +3416,7 @@ var KEYWORDS = {
   TO: "TO",
   TRANSACTION: "TRANSACTION",
   TRIGGER: "TRIGGER",
+  TRUE: "TRUE",
   UNBOUNDED: "UNBOUNDED",
   UNION: "UNION",
   UNIQUE: "UNIQUE",
@@ -3705,6 +3771,7 @@ var IDENT_KEYWORDS = /* @__PURE__ */ new Set([
   "FOREIGN",
   "FROM",
   "FULL",
+  "FALSE",
   "GENERATED",
   "GLOB",
   "GROUP",
@@ -3779,6 +3846,7 @@ var IDENT_KEYWORDS = /* @__PURE__ */ new Set([
   "TO",
   "TRANSACTION",
   "TRIGGER",
+  "TRUE",
   "UNBOUNDED",
   "UNION",
   "UNIQUE",
@@ -3927,13 +3995,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();
@@ -3995,12 +4070,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 };
   }
@@ -4008,8 +4086,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;
@@ -4307,8 +4384,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";
@@ -4411,8 +4487,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();
@@ -4427,8 +4502,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();
@@ -5097,6 +5171,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();
@@ -5125,6 +5217,14 @@ var Parser = class {
           continue;
         }
         const not = this.match("NOT");
+        if (this.match("TRUE")) {
+          left = { type: "is_bool", expr: left, not, sense: true };
+          continue;
+        }
+        if (this.match("FALSE")) {
+          left = { type: "is_bool", expr: left, not, sense: false };
+          continue;
+        }
         const right2 = this.parseIsRhs();
         left = { type: "binary", op: not ? "IS NOT" : "IS", left, right: right2 };
         continue;
@@ -5144,6 +5244,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);
@@ -5302,7 +5408,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();
@@ -5385,6 +5491,7 @@ var Parser = class {
         } while (this.match("COMMA"));
       }
     }
+    const orderBy = this.parseOrderBy();
     this.expect("RPAREN");
     if (this.match("FILTER")) {
       this.expect("LPAREN");
@@ -5405,13 +5512,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 = [];
@@ -5519,8 +5626,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);
 }
@@ -5585,6 +5696,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();
+  }
+};
 function deriveSeed(...parts) {
   let hash = 2166136261;
   for (const part of parts) {
@@ -6660,7 +6793,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++;
@@ -6809,18 +6942,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);
@@ -6868,13 +7046,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") {
@@ -6889,13 +7063,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");
@@ -7128,11 +7304,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;
@@ -7396,6 +7567,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;
@@ -7598,7 +7771,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);
@@ -7612,6 +7790,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() {
@@ -7633,6 +7814,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;
@@ -7645,6 +7827,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()) {
@@ -7753,11 +7936,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);
   }
 };
@@ -7832,6 +8027,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) {
@@ -8276,6 +8473,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;
@@ -8295,6 +8493,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;
@@ -8356,6 +8555,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;
   }
@@ -8700,6 +8900,7 @@ function jsonReviver(_key, value) {
 export {
   DEFAULT_DATABASE_SEED,
   DEFAULT_NOW,
+  OsEntropy,
   Prng,
   SqlJsonText,
   SqlReal,
@@ -8725,6 +8926,7 @@ export {
   resolveClock,
   sqlValueEquals,
   storageClassOf,
+  systemClock,
   toInteger,
   tokenize,
   typeofSql,