@haverstack/record-adapter-do-sqlite 0.10.0 → 0.12.0

package/dist/index.js

@@ -25,6 +25,10 @@ var RECORD_SCHEMA_SQL = `
   -- qualifier: related_stack for a record in another stack, related_ns for
   -- a foreign namespace. All four are in the primary key, so two targets
   -- differing only by namespace are two associations.
+  --
+  -- The primary key leads with record_id, so its implicit index already
+  -- serves every by-record read and delete; the indexes below exist only
+  -- for the filter directions it cannot answer.
   CREATE TABLE IF NOT EXISTS associations (
     record_id     TEXT NOT NULL REFERENCES records(id),
     kind          TEXT NOT NULL CHECK (kind IN ('tag', 'attachment', 'relationship')),
@@ -62,57 +66,65 @@ var RECORD_SCHEMA_SQL = `
     created_at    INTEGER NOT NULL
   ) STRICT;
 
-  -- One row per top-level file-ref content field on a record, kept in sync
-  -- on every content/typeId write. Lets the attachmentFileId query filter
-  -- and deleteAttachment()'s reference check see content-held file
-  -- references, not just attachment associations.
-  CREATE TABLE IF NOT EXISTS file_refs (
-    record_id TEXT NOT NULL REFERENCES records(id),
-    field     TEXT NOT NULL,
-    file_id   TEXT NOT NULL,
-    PRIMARY KEY (record_id, field)
-  ) STRICT;
-
-  -- One row per top-level scalar content field on a record, rewritten
-  -- beside file_refs on every content/typeId write. Exactly one of
-  -- num_value / text_key+text_value is set, by the field's declared kind:
-  -- what a field orders as must not vary with the value a given record
-  -- happens to hold. text_key is the folded form ordering compares
-  -- (@haverstack/core's contentSortKey), text_value the stored one, which
-  -- breaks a tie between two values that fold together.
-  CREATE TABLE IF NOT EXISTS content_sort (
+  -- One row per top-level scalar content field a record holds a value at:
+  -- what it orders as, and the file it references. See
+  -- docs/spec/adapters.md \xA7 Adapter backends and
+  -- docs/spec/data-model.md \xA7 Sorting by a content field.
+  --
+  -- value_rank is 0 for a numeric value and 1 for a text one \u2014 the same
+  -- split as "num_value IS NULL", but non-null, so one index can carry
+  -- the whole ordering. file_id is set only for a 'file-ref' field.
+  CREATE TABLE IF NOT EXISTS content_index (
     record_id  TEXT NOT NULL REFERENCES records(id),
     field      TEXT NOT NULL,
+    value_rank INTEGER NOT NULL CHECK (value_rank IN (0, 1)),
     num_value  REAL,
     text_key   TEXT,
     text_value TEXT,
+    file_id    TEXT,
     PRIMARY KEY (record_id, field)
   ) STRICT;
 
-  -- Indexes
-  CREATE INDEX IF NOT EXISTS idx_records_type_id    ON records(type_id);
-  CREATE INDEX IF NOT EXISTS idx_records_parent_id  ON records(parent_id);
-  CREATE INDEX IF NOT EXISTS idx_records_entity_id  ON records(entity_id);
-  CREATE INDEX IF NOT EXISTS idx_records_app_id     ON records(app_id);
-  CREATE INDEX IF NOT EXISTS idx_records_principal_id ON records(principal_id);
-  CREATE INDEX IF NOT EXISTS idx_records_deleted_at ON records(deleted_at);
-  CREATE INDEX IF NOT EXISTS idx_records_unlisted_at ON records(unlisted_at);
-  CREATE INDEX IF NOT EXISTS idx_records_created_at ON records(created_at);
-  CREATE INDEX IF NOT EXISTS idx_records_updated_at ON records(updated_at);
-  CREATE INDEX IF NOT EXISTS idx_assoc_record_id    ON associations(record_id);
-  CREATE INDEX IF NOT EXISTS idx_assoc_kind_label   ON associations(kind, label);
-  CREATE INDEX IF NOT EXISTS idx_assoc_kind_file_id ON associations(kind, file_id);
-  CREATE INDEX IF NOT EXISTS idx_assoc_related    ON associations(related_scope, related_ns, related_id);
-  CREATE INDEX IF NOT EXISTS idx_types_base_id      ON types(base_id);
-  CREATE INDEX IF NOT EXISTS idx_file_refs_file_id  ON file_refs(file_id);
-  CREATE INDEX IF NOT EXISTS idx_content_sort_num   ON content_sort(field, num_value, record_id);
-  CREATE INDEX IF NOT EXISTS idx_content_sort_text  ON content_sort(field, text_key, text_value, record_id);
+  -- Indexes. Each filter column continues into (created_at, id) \u2014 the
+  -- default ordering and its tiebreak \u2014 because these columns are
+  -- low-cardinality by design, and a narrow index on one leaves the
+  -- planner sorting the whole matching set before it can honor LIMIT.
+  --
+  -- deleted_at and unlisted_at deliberately have none: nothing searches
+  -- for the rows they mark, and an index on a column every query tests
+  -- for IS NULL only lures the planner off the one answering ORDER BY.
+  CREATE INDEX IF NOT EXISTS idx_records_type_id      ON records(type_id, created_at, id);
+  CREATE INDEX IF NOT EXISTS idx_records_parent_id    ON records(parent_id, created_at, id);
+  CREATE INDEX IF NOT EXISTS idx_records_entity_id    ON records(entity_id, created_at, id);
+  CREATE INDEX IF NOT EXISTS idx_records_app_id       ON records(app_id, created_at, id);
+  CREATE INDEX IF NOT EXISTS idx_records_principal_id ON records(principal_id, created_at, id);
+  CREATE INDEX IF NOT EXISTS idx_records_created_at   ON records(created_at, id);
+  CREATE INDEX IF NOT EXISTS idx_records_updated_at   ON records(updated_at, id);
+  CREATE INDEX IF NOT EXISTS idx_records_version      ON records(version, id);
+
+  -- Each association index ends with record_id so the semi-joins in
+  -- query.ts read the matching record ids out of the index alone.
+  -- idx_assoc_related carries related_ns ahead of related_id because a
+  -- record- or entity-scoped target always stores '' there, which
+  -- buildQueryPlan states explicitly to keep the prefix contiguous.
+  CREATE INDEX IF NOT EXISTS idx_assoc_kind_label   ON associations(kind, label, record_id);
+  CREATE INDEX IF NOT EXISTS idx_assoc_kind_file_id ON associations(kind, file_id, record_id);
+  CREATE INDEX IF NOT EXISTS idx_assoc_related      ON associations(kind, related_scope, related_ns, related_id, record_id);
+  CREATE INDEX IF NOT EXISTS idx_types_base_id      ON types(base_id, version);
+
+  -- The whole content ordering, in index order, for one field at a time:
+  -- a content-sorted page is an ordered walk of a slice of this index.
+  CREATE INDEX IF NOT EXISTS idx_content_index_sort
+    ON content_index(field, value_rank, num_value, text_key, text_value, record_id);
+  CREATE INDEX IF NOT EXISTS idx_content_index_file
+    ON content_index(file_id, record_id) WHERE file_id IS NOT NULL;
 `;
 var FTS5_SCHEMA_SQL = `
   CREATE VIRTUAL TABLE IF NOT EXISTS records_fts USING fts5(
     content,
     content='records',
-    content_rowid='rowid'
+    content_rowid='rowid',
+    columnsize=0
   );
 `;
 var PRAGMA_FOREIGN_KEYS_ON = `PRAGMA foreign_keys = ON;`;
@@ -184,14 +196,16 @@ var makeCursor = (record, sort, kindOf) => {
 
 // ../sqlite-shared/dist/fts5.js
 var OUTSIDE_PHRASE_DISALLOWED = /[^\p{L}\p{N}\p{M}_\s()"]/gu;
+var collapseWhitespace = (query) => query.replace(/\s+/g, " ");
 var sanitizeFts5Query = (query, maxDepth = 2) => {
   if (!query)
     return "";
   let clean = query.replace(/[\p{Cc}\p{Cf}]/gu, " ");
   clean = clean.replace(/\*/g, "");
-  clean = clean.replace(/\bNEAR\s*\(\s*([^,)]*)(?:,[^)]*)?\)/gi, "$1");
+  clean = clean.replace(/\bNEAR\s*\(([^,()]*)(?:,[^()]*)?\)/gi, "$1");
   clean = clean.replace(/\bNEAR\s*\(/gi, "(");
   clean = clean.replace(/"[^"]*"|[^"]+/g, (span) => span.startsWith('"') ? span : span.replace(OUTSIDE_PHRASE_DISALLOWED, " "));
+  clean = collapseWhitespace(clean);
   clean = clean.replace(/(?:^|\(\s*)NOT\s+/gi, (m) => m.replace(/NOT\s+/i, ""));
   let currentDepth = 0;
   let inPhrase = false;
@@ -225,12 +239,11 @@ var sanitizeFts5Query = (query, maxDepth = 2) => {
   let prev;
   do {
     prev = result;
-    result = result.replace(/""/g, " ");
-    result = result.replace(/\(\s*\)/g, " ");
+    result = result.replace(/(?:""|\(\s*\))+/g, " ");
     result = dropDanglingOperators(result);
     result = restoreImplicitAnd(result);
   } while (result !== prev);
-  return result.replace(/\s+/g, " ").replace(/\(\s+/g, "(").replace(/\s+\)/g, ")").trim();
+  return collapseWhitespace(result).replace(/\(\s+/g, "(").replace(/\s+\)/g, ")").trim();
 };
 var OPERATOR = String.raw`(?:AND|OR|NOT)`;
 var PHRASE_HOLE = "\uE000";
@@ -241,7 +254,7 @@ var dropDanglingOperators = (query) => withPhrasesMasked(query, (masked) => {
     prev = out;
     out = out.replace(new RegExp(String.raw`\b(${OPERATOR})\b(?:\s+\b${OPERATOR}\b)+`, "gi"), "$1");
     out = out.replace(new RegExp(String.raw`(^|\()\s*\b${OPERATOR}\b\s*`, "gi"), "$1");
-    out = out.replace(new RegExp(String.raw`\s*\b${OPERATOR}\b\s*($|\))`, "gi"), "$1");
+    out = out.replace(new RegExp(String.raw`\b${OPERATOR}\b\s*($|\))`, "gi"), "$1");
   } while (out !== prev);
   return out;
 });
@@ -259,7 +272,7 @@ var isOperator = (word) => /^(?:AND|OR|NOT)$/i.test(word);
 var restoreImplicitAnd = (query) => withPhrasesMasked(query, (masked) => masked.replace(new RegExp(String.raw`\)\s*(?=${OPERAND_CHAR}|\()`, "gu"), (match, offset, whole) => {
   const next = /^\s*([\p{L}\p{N}_]+)/u.exec(whole.slice(offset + match.length));
   return next && isOperator(next[1]) ? match : ") AND ";
-}).replace(new RegExp(String.raw`(${OPERAND_CHAR}+)\s*(?=\()`, "gu"), (match, word) => isOperator(word) ? match : `${word} AND `));
+}).replace(new RegExp(String.raw`(?<!${OPERAND_CHAR})(${OPERAND_CHAR}+)\s*(?=\()`, "gu"), (match, word) => isOperator(word) ? match : `${word} AND `));
 var fts5Strategy = {
   /** Index a record that has no FTS entry yet (used right after an INSERT). */
   insert(exec, recordId, content) {
@@ -284,6 +297,10 @@ var fts5Strategy = {
 };
 
 // ../sqlite-shared/dist/query.js
+var atBudget = (page, rows) => ({
+  sql: page.sql,
+  params: [...page.params, rows]
+});
 var sqlDirection = (query) => {
   const dir = query.sort?.direction ?? "desc";
   if (dir !== "asc" && dir !== "desc") {
@@ -312,49 +329,18 @@ var contentPathExists = (segments, leaf, params, nextAlias) => {
 };
 var equalsLeaf = (alias) => `${alias}.type NOT IN ('object', 'array') AND ${alias}.value = ?`;
 var SORT_ALIAS = "cs";
-var buildFromClause = (query) => {
-  const field = query.sort?.contentField;
-  if (field === void 0)
-    return { sql: "records r", params: [] };
-  return {
-    sql: `records r LEFT JOIN content_sort ${SORT_ALIAS} ON ${SORT_ALIAS}.record_id = r.id AND ${SORT_ALIAS}.field = ?`,
-    params: [field]
-  };
-};
-var assertCursorMatchesSort = (cursor, query) => {
-  const contentField = query.sort?.contentField;
-  if (cursor.kind === "native") {
-    const sortField = getSortField(query);
-    if (contentField !== void 0 || cursor.field !== sortField) {
-      throw new StackQueryError(`Cursor sort field "${cursor.field}" does not match query sort field "${contentField ?? sortField}"`);
-    }
-    return;
-  }
-  if (contentField === void 0 || cursor.field !== contentField) {
-    throw new StackQueryError(`Cursor sort field "${cursor.field}" does not match query sort field "${contentField ?? getSortField(query)}"`);
-  }
+var cursorMismatch = (cursor, field) => new StackQueryError(`Cursor sort field "${cursor.field}" does not match query sort field "${field}"`);
+var nativeCursor = (cursor, field) => {
+  if (cursor.kind !== "native" || cursor.field !== field)
+    throw cursorMismatch(cursor, field);
+  return cursor;
 };
-var contentCursorCondition = (cursor, op, params) => {
-  const ascending = op === ">";
-  const numRank = ascending ? 0 : 1;
-  const textRank = ascending ? 1 : 0;
-  const rank = `CASE WHEN ${SORT_ALIAS}.record_id IS NULL THEN 2 WHEN ${SORT_ALIAS}.num_value IS NULL THEN ${textRank} ELSE ${numRank} END`;
-  const cursorRank = cursor.kind === "absent" ? 2 : cursor.kind === "num" ? numRank : textRank;
-  let tail;
-  if (cursor.kind === "num") {
-    tail = `(${SORT_ALIAS}.num_value ${op} ? OR (${SORT_ALIAS}.num_value = ? AND r.id ${op} ?))`;
-    params.push(cursor.value, cursor.value, cursor.id);
-  } else if (cursor.kind === "text") {
-    const key = contentSortKey(cursor.value);
-    tail = `(${SORT_ALIAS}.text_key ${op} ? OR (${SORT_ALIAS}.text_key = ? AND (${SORT_ALIAS}.text_value ${op} ? OR (${SORT_ALIAS}.text_value = ? AND r.id ${op} ?))))`;
-    params.push(key, key, cursor.value, cursor.value, cursor.id);
-  } else {
-    tail = `r.id ${op} ?`;
-    params.push(cursor.id);
-  }
-  return `((${rank}) > ${cursorRank} OR ((${rank}) = ${cursorRank} AND ${tail}))`;
+var contentCursor = (cursor, field) => {
+  if (cursor.kind === "native" || cursor.field !== field)
+    throw cursorMismatch(cursor, field);
+  return cursor;
 };
-var buildWhereClause = (query) => {
+var recordConditions = (query) => {
   const conditions = ["r.id != '_config'"];
   const params = [];
   const f = query.filter ?? {};
@@ -420,7 +406,7 @@ var buildWhereClause = (query) => {
   }
   if (f.attachmentFileId) {
     conditions.push(`(r.id IN (SELECT a.record_id FROM associations a WHERE a.kind = 'attachment' AND a.file_id = ?)
-        OR r.id IN (SELECT fr.record_id FROM file_refs fr WHERE fr.file_id = ?))`);
+        OR r.id IN (SELECT ci.record_id FROM content_index ci WHERE ci.file_id = ?))`);
     params.push(f.attachmentFileId, f.attachmentFileId);
   }
   if (f.relatedTo) {
@@ -434,11 +420,11 @@ var buildWhereClause = (query) => {
       clauses.push("a.related_scope = ?");
       params.push(target.scope);
       if (target.scope === "record") {
-        clauses.push("a.related_id = ?", "a.related_stack = ?");
-        params.push(target.recordId, target.stackUrl ?? "");
+        clauses.push("a.related_ns = ?", "a.related_id = ?", "a.related_stack = ?");
+        params.push("", target.recordId, target.stackUrl ?? "");
       } else if (target.scope === "entity") {
-        clauses.push("a.related_id = ?");
-        params.push(target.entityId);
+        clauses.push("a.related_ns = ?", "a.related_id = ?");
+        params.push("", target.entityId);
       } else {
         clauses.push("a.related_ns = ?");
         params.push(target.ns);
@@ -482,29 +468,61 @@ var buildWhereClause = (query) => {
       conditions.push("0");
     }
   }
-  if (query.cursor) {
-    const cursor = decodeCursor(query.cursor);
-    assertCursorMatchesSort(cursor, query);
-    const op = sqlDirection(query) === "ASC" ? ">" : "<";
-    if (cursor.kind === "native") {
-      const col = getSortColumn(cursor.field);
-      conditions.push(`(r.${col} ${op} ? OR (r.${col} = ? AND r.id ${op} ?))`);
-      params.push(cursor.value, cursor.value, cursor.id);
-    } else {
-      conditions.push(contentCursorCondition(cursor, op, params));
-    }
+  return { conditions, params };
+};
+var presentCursorCondition = (cursor, op, params) => {
+  if (cursor.kind === "num") {
+    params.push(cursor.value, cursor.value, cursor.id);
+    return `(${SORT_ALIAS}.value_rank ${op} 0 OR (${SORT_ALIAS}.value_rank = 0 AND (${SORT_ALIAS}.num_value ${op} ? OR (${SORT_ALIAS}.num_value = ? AND ${SORT_ALIAS}.record_id ${op} ?))))`;
   }
-  return {
-    sql: conditions.length ? `WHERE ${conditions.join(" AND ")}` : "",
-    params
-  };
+  const key = contentSortKey(cursor.value);
+  params.push(key, key, cursor.value, cursor.value, cursor.id);
+  return `(${SORT_ALIAS}.value_rank ${op} 1 OR (${SORT_ALIAS}.value_rank = 1 AND (${SORT_ALIAS}.text_key ${op} ? OR (${SORT_ALIAS}.text_key = ? AND (${SORT_ALIAS}.text_value ${op} ? OR (${SORT_ALIAS}.text_value = ? AND ${SORT_ALIAS}.record_id ${op} ?))))))`;
 };
-var buildOrderClause = (query) => {
+var statement = (select, from, conditions, params, tail = "") => ({
+  sql: `SELECT ${select} FROM ${from} WHERE ${conditions.join(" AND ")}${tail}`,
+  params
+});
+var buildQueryPlan = (query) => {
   const dir = sqlDirection(query);
-  if (query.sort?.contentField === void 0) {
-    return `ORDER BY r.${getSortColumn(getSortField(query))} ${dir}, r.id ${dir}`;
+  const op = dir === "ASC" ? ">" : "<";
+  const decoded = query.cursor ? decodeCursor(query.cursor) : null;
+  const contentField = query.sort?.contentField;
+  if (contentField === void 0) {
+    const { conditions, params } = recordConditions(query);
+    const col = getSortColumn(getSortField(query));
+    if (decoded) {
+      const cursor2 = nativeCursor(decoded, getSortField(query));
+      conditions.push(`(r.${col} ${op} ? OR (r.${col} = ? AND r.id ${op} ?))`);
+      params.push(cursor2.value, cursor2.value, cursor2.id);
+    }
+    return [
+      statement("r.*", "records r", conditions, params, ` ORDER BY r.${col} ${dir}, r.id ${dir} LIMIT ?`)
+    ];
+  }
+  const cursor = decoded ? contentCursor(decoded, contentField) : null;
+  const pages = [];
+  if (cursor?.kind !== "absent") {
+    const { conditions, params } = recordConditions(query);
+    const from = `content_index ${SORT_ALIAS} JOIN records r ON r.id = ${SORT_ALIAS}.record_id`;
+    conditions.push(`${SORT_ALIAS}.field = ?`);
+    params.push(contentField);
+    if (cursor)
+      conditions.push(presentCursorCondition(cursor, op, params));
+    const order = `${SORT_ALIAS}.value_rank ${dir}, ${SORT_ALIAS}.num_value ${dir}, ${SORT_ALIAS}.text_key ${dir}, ${SORT_ALIAS}.text_value ${dir}, ${SORT_ALIAS}.record_id ${dir}`;
+    pages.push(statement("r.*", from, conditions, params, ` ORDER BY ${order} LIMIT ?`));
+  }
+  {
+    const { conditions, params } = recordConditions(query);
+    conditions.push(`NOT EXISTS (SELECT 1 FROM content_index ${SORT_ALIAS} WHERE ${SORT_ALIAS}.record_id = r.id AND ${SORT_ALIAS}.field = ?)`);
+    params.push(contentField);
+    if (cursor?.kind === "absent") {
+      conditions.push(`r.id ${op} ?`);
+      params.push(cursor.id);
+    }
+    pages.push(statement("r.*", "records r", conditions, params, ` ORDER BY r.id ${dir} LIMIT ?`));
   }
-  return `ORDER BY (${SORT_ALIAS}.record_id IS NULL) ASC, (${SORT_ALIAS}.num_value IS NULL) ${dir}, ${SORT_ALIAS}.num_value ${dir}, ${SORT_ALIAS}.text_key ${dir}, ${SORT_ALIAS}.text_value ${dir}, r.id ${dir}`;
+  return pages;
 };
 
 // ../sqlite-shared/dist/mappers.js
@@ -640,8 +658,7 @@ var asStackQueryError = (query, run) => {
     throw new StackQueryError(`Search text could not be parsed: ${err instanceof Error ? err.message : String(err)}`);
   }
 };
-var fileRefFieldNames = (schema) => Object.keys(schema).filter((field) => schema[field].kind === "file-ref");
-var sortableFieldKinds = (schema) => {
+var indexedFieldKinds = (schema) => {
   const kinds = /* @__PURE__ */ new Map();
   for (const [field, def] of Object.entries(schema)) {
     if (!def.kind || def.kind === "array" || def.kind === "object")
@@ -653,13 +670,12 @@ var sortableFieldKinds = (schema) => {
 var SharedSqlRecordLogic = class {
   deps;
   /**
-   * Per-typeId cache of file-ref field names, so syncFileRefs() doesn't
-   * hit the `types` table and re-parse schema JSON on every write.
-   * Populated eagerly in saveType() and lazily via getFileRefFields().
+   * Per-typeId cache of the fields content_index covers and their declared
+   * kinds, so syncContentIndex() doesn't hit the `types` table and
+   * re-parse schema JSON on every write. Populated eagerly in saveType()
+   * and lazily via getIndexedFields().
    */
-  fileRefFieldsByType = /* @__PURE__ */ new Map();
-  /** Per-typeId cache of sortable field kinds, as fileRefFieldsByType is. */
-  sortFieldsByType = /* @__PURE__ */ new Map();
+  indexedFieldsByType = /* @__PURE__ */ new Map();
   constructor(deps) {
     this.deps = deps;
   }
@@ -740,8 +756,7 @@ var SharedSqlRecordLogic = class {
       this.insertAssociations(record.id, record.associations);
     }
     fts5Strategy.insert(this.exec, record.id, JSON.stringify(record.content));
-    this.syncFileRefs(record.id, record.typeId, record.content);
-    this.syncContentSort(record.id, record.typeId, record.content);
+    this.syncContentIndex(record.id, record.typeId, record.content);
     return record;
   }
   async getRecord(id) {
@@ -786,8 +801,7 @@ var SharedSqlRecordLogic = class {
         id
       ]);
       fts5Strategy.insert(this.exec, id, JSON.stringify(merged));
-      this.syncFileRefs(id, existing.typeId, merged);
-      this.syncContentSort(id, existing.typeId, merged);
+      this.syncContentIndex(id, existing.typeId, merged);
     });
     const updated = await this.getRecord(id);
     if (!updated)
@@ -842,8 +856,7 @@ var SharedSqlRecordLogic = class {
     fts5Strategy.remove(this.exec, id);
     this.exec.run("DELETE FROM associations WHERE record_id = ?", [id]);
     this.exec.run("DELETE FROM versions WHERE record_id = ?", [id]);
-    this.exec.run("DELETE FROM file_refs WHERE record_id = ?", [id]);
-    this.exec.run("DELETE FROM content_sort WHERE record_id = ?", [id]);
+    this.exec.run("DELETE FROM content_index WHERE record_id = ?", [id]);
     this.exec.run("DELETE FROM records WHERE id = ?", [id]);
     return purged;
   }
@@ -930,8 +943,7 @@ var SharedSqlRecordLogic = class {
           this.insertAssociations(id, target.associations);
       }
       fts5Strategy.insert(this.exec, id, JSON.stringify(target.content));
-      this.syncFileRefs(id, target.typeId, target.content);
-      this.syncContentSort(id, target.typeId, target.content);
+      this.syncContentIndex(id, target.typeId, target.content);
     });
     const updated = await this.getRecord(id);
     if (!updated)
@@ -956,8 +968,7 @@ var SharedSqlRecordLogic = class {
         id
       ]);
       fts5Strategy.insert(this.exec, id, JSON.stringify(content));
-      this.syncFileRefs(id, toTypeId, content);
-      this.syncContentSort(id, toTypeId, content);
+      this.syncContentIndex(id, toTypeId, content);
     });
     const updated = await this.getRecord(id);
     if (!updated)
@@ -965,26 +976,25 @@ var SharedSqlRecordLogic = class {
     return updated;
   }
   async queryRecords(query) {
-    const { sql: from, params: fromParams } = buildFromClause(query);
-    const { sql: where, params: whereParams } = buildWhereClause(query);
-    const params = [...fromParams, ...whereParams];
-    const order = buildOrderClause(query);
     const limit = query.limit ?? 50;
-    const rows = asStackQueryError(query, () => this.exec.all(`SELECT r.* FROM ${from} ${where} ${order} LIMIT ?`, [
-      ...params,
-      limit + 1
-    ]));
+    const fetch = limit + 1;
+    const rows = [];
+    for (const page2 of buildQueryPlan(query)) {
+      const budget = fetch - rows.length;
+      if (budget <= 0)
+        break;
+      const statement2 = atBudget(page2, budget);
+      rows.push(...asStackQueryError(query, () => this.exec.all(statement2.sql, statement2.params)));
+    }
     const hasMore = rows.length > limit;
     const page = hasMore ? rows.slice(0, limit) : rows;
     const records = page.map((row) => {
       const associations = this.getAssociationsForRecord(row.id);
       return rowToRecord(row, associations);
     });
-    const countRows = asStackQueryError(query, () => this.exec.all(`SELECT COUNT(*) as total FROM ${from} ${where}`, params));
-    const total = countRows[0]?.total ?? 0;
     const lastRecord = records[records.length - 1];
     const cursor = hasMore && lastRecord ? makeCursor(lastRecord, query.sort, (record, field) => this.sortFieldKind(record, field)) : null;
-    return { records, cursor, total };
+    return { records, cursor };
   }
   /**
    * Atomically verify fileId is unreferenced, then hard-delete its
@@ -997,7 +1007,7 @@ var SharedSqlRecordLogic = class {
     return this.exec.transaction(() => {
       const referenced = this.exec.all(`SELECT 1 as found FROM associations WHERE kind = 'attachment' AND file_id = ?
          UNION ALL
-         SELECT 1 FROM file_refs WHERE file_id = ?
+         SELECT 1 FROM content_index WHERE file_id = ?
          LIMIT 1`, [fileId, fileId]);
       if (referenced.length) {
         throw new StackConflictError("Attachment is still referenced by one or more records");
@@ -1117,8 +1127,7 @@ var SharedSqlRecordLogic = class {
       toMs(type.createdAt)
     ]);
     const schema = type.schema;
-    this.fileRefFieldsByType.set(type.id, fileRefFieldNames(schema));
-    this.sortFieldsByType.set(type.id, sortableFieldKinds(schema));
+    this.indexedFieldsByType.set(type.id, indexedFieldKinds(schema));
   }
   async getType(id) {
     const rows = this.exec.all("SELECT * FROM types WHERE id = ?", [id]);
@@ -1194,67 +1203,49 @@ var SharedSqlRecordLogic = class {
     return rows.map(rowToAssociation);
   }
   /**
-   * File-ref field names for typeId, from the in-memory cache — falling
-   * back to a `types` lookup (and populating the cache) only for a typeId
-   * this process hasn't seen via saveType() yet, e.g. right after open().
-   */
-  getFileRefFields(typeId) {
-    const cached = this.fileRefFieldsByType.get(typeId);
-    if (cached)
-      return cached;
-    const typeRow = this.exec.get("SELECT schema FROM types WHERE id = ?", [
-      typeId
-    ]);
-    const fields = typeRow ? fileRefFieldNames(JSON.parse(typeRow.schema)) : [];
-    this.fileRefFieldsByType.set(typeId, fields);
-    return fields;
-  }
-  /**
-   * Replace a record's file_refs rows with whatever its content currently
-   * holds in top-level file-ref fields, on every write that can change
-   * content or typeId, so the index never drifts. Only top-level scalars
-   * are indexed; the schema lookup is cached (fileRefFieldsByType).
+   * The fields content_index covers for typeId, from the in-memory cache
+   * — falling back to a `types` lookup (and populating the cache) only for
+   * a typeId this process hasn't seen via saveType() yet, e.g. right after
+   * open().
    */
-  getSortFields(typeId) {
-    const cached = this.sortFieldsByType.get(typeId);
+  getIndexedFields(typeId) {
+    const cached = this.indexedFieldsByType.get(typeId);
     if (cached)
       return cached;
     const typeRow = this.exec.get("SELECT schema FROM types WHERE id = ?", [
       typeId
     ]);
-    const fields = typeRow ? sortableFieldKinds(JSON.parse(typeRow.schema)) : /* @__PURE__ */ new Map();
-    this.sortFieldsByType.set(typeId, fields);
+    const fields = typeRow ? indexedFieldKinds(JSON.parse(typeRow.schema)) : /* @__PURE__ */ new Map();
+    this.indexedFieldsByType.set(typeId, fields);
     return fields;
   }
   /**
-   * Replace a record's content_sort rows with what its content currently
-   * holds, on every write that can change content or typeId. A field
-   * holding no orderable value gets no row at all, which is what puts the
-   * record at the end of a sort on that field.
+   * Replace a record's content_index rows with what its content currently
+   * holds, on every write that can change content or typeId, so neither
+   * the ordering nor the file-reference lookup can drift from the record.
+   * A field holding no orderable value gets no row at all, which is what
+   * puts the record at the end of a sort on that field.
    */
-  syncContentSort(recordId, typeId, content) {
-    this.exec.run("DELETE FROM content_sort WHERE record_id = ?", [recordId]);
-    for (const [field, kind] of this.getSortFields(typeId)) {
+  syncContentIndex(recordId, typeId, content) {
+    this.exec.run("DELETE FROM content_index WHERE record_id = ?", [recordId]);
+    for (const [field, kind] of this.getIndexedFields(typeId)) {
       const entry = contentSortEntry(kind, content[field]);
       if (!entry)
         continue;
-      this.exec.run(`INSERT OR IGNORE INTO content_sort (record_id, field, num_value, text_key, text_value)
-         VALUES (?, ?, ?, ?, ?)`, entry.kind === "num" ? [recordId, field, entry.num, null, null] : [recordId, field, null, entry.key, entry.text]);
+      const sql = `INSERT OR IGNORE INTO content_index
+          (record_id, field, value_rank, num_value, text_key, text_value, file_id)
+         VALUES (?, ?, ?, ?, ?, ?, ?)`;
+      if (entry.kind === "num") {
+        this.exec.run(sql, [recordId, field, 0, entry.num, null, null, null]);
+      } else {
+        const fileId = kind === "file-ref" ? entry.text : null;
+        this.exec.run(sql, [recordId, field, 1, null, entry.key, entry.text, fileId]);
+      }
     }
   }
   /** The declared kind of a record's top-level `field`, if it has one. */
   sortFieldKind(record, field) {
-    return this.getSortFields(record.typeId).get(field);
-  }
-  syncFileRefs(recordId, typeId, content) {
-    this.exec.run("DELETE FROM file_refs WHERE record_id = ?", [recordId]);
-    const fields = this.getFileRefFields(typeId);
-    for (const field of fields) {
-      const value = content[field];
-      if (typeof value === "string") {
-        this.exec.run("INSERT OR IGNORE INTO file_refs (record_id, field, file_id) VALUES (?, ?, ?)", [recordId, field, value]);
-      }
-    }
+    return this.getIndexedFields(record.typeId).get(field);
   }
 };
 
@@ -1294,14 +1285,19 @@ var DoSQLiteRecordAdapter = class _DoSQLiteRecordAdapter {
   }
   exec;
   capabilities = {
-    fullTextSearch: true,
-    contentFieldQuery: true,
-    nestedContentQuery: true,
-    contentPresenceQuery: true,
-    contentFieldSort: true,
-    sortableFields: ["createdAt", "updatedAt", "version"],
-    maxAttachmentBytes: null,
-    maxContentBytes: null
+    filter: {
+      content: "path",
+      contentPresent: true,
+      search: true
+    },
+    sort: {
+      fields: ["createdAt", "updatedAt", "version"],
+      contentField: true
+    },
+    limits: {
+      attachmentBytes: null,
+      contentBytes: null
+    }
   };
   ownerEntityId;
   timezone;