@haverstack/record-adapter-sqlite 0.33.0 → 0.34.0

package/dist/index.js

@@ -1,6 +1,6 @@
 import { existsSync, writeFileSync, unlinkSync, readFileSync } from 'fs';
-import { StackNotFoundError, StackConflictError, applyMergePatch, assertOneSurface, StackVersionConflictError, StackBadRequestError, NATIVE_SORT_FIELDS } from '@haverstack/core';
-import { OwnerMismatchError, contentSortEntry, parseContentFilterKey, contentSortKey } from '@haverstack/core/adapter';
+import { StackConflictError, applyMergePatch, StackNotFoundError, assertOneSurface, StackVersionConflictError, StackBadRequestError, NATIVE_SORT_FIELDS } from '@haverstack/core';
+import { OwnerMismatchError, AUTHORITY_ASSOCIATION_KINDS, contentSortEntry, partitionAssociations, constantSortEntry, contentSortKey, parseContentFilterKey } from '@haverstack/core/adapter';
 import { randomBytes, createHash } from 'crypto';
 
 // src/node-sqlite.ts
@@ -28,39 +28,32 @@ var RECORD_SCHEMA_SQL = `
   ) STRICT;
 
   -- Every edge a record carries, authority and data alike: a permission
-  -- entry has element identity and a delta the same shape as a tag's, so
-  -- it earns the same table and the same durability tier. The permissions
-  -- and associations fields are projections over it, partitioned by
-  -- kind. See docs/spec/access-control.md \xA7 Record-level permissions.
-  --
-  -- A relationship's target is (related_scope, related_id) plus one
-  -- 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. A permission's
-  -- grantee reuses them \u2014 related_scope 'entity' or 'group', related_id the
-  -- DID or group id \u2014 plus related_role, which only a group grantee sets
-  -- and which is in the key because member and admin name two different
-  -- sets of people.
-  --
-  -- attachment_record_id stays out of the primary key: it annotates a
-  -- reference rather than naming one, so re-pointing it updates the row an
-  -- an amendAssociations() add lands on instead of writing a second reference to the same
-  -- file. See docs/spec/attachments.md \xA7 Naming the upload a reference came from.
-  --
-  -- 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.
+  -- has element identity and a delta shaped like a tag's, so it earns the
+  -- same table. The permissions and associations fields are projections
+  -- over it, partitioned by kind.
+  -- See docs/spec/access-control.md \xA7 Record-level permissions.
   CREATE TABLE IF NOT EXISTS associations (
     record_id     TEXT NOT NULL REFERENCES records(id),
     kind          TEXT NOT NULL CHECK (kind IN ('tag', 'attachment', 'relationship', 'permission', 'anyone')),
     label         TEXT NOT NULL,
     file_id       TEXT NOT NULL DEFAULT '',
+    -- A relationship target is (related_scope, related_id) qualified by
+    -- related_ns (a foreign namespace) or related_stack (another stack); a
+    -- permission's grantee reuses scope and id. All are in the key, so
+    -- targets differing only by a qualifier are distinct associations.
     related_scope TEXT NOT NULL DEFAULT '' CHECK (related_scope IN ('', 'record', 'entity', 'external', 'group')),
     related_id    TEXT NOT NULL DEFAULT '',
     related_ns    TEXT NOT NULL DEFAULT '',
     related_stack TEXT NOT NULL DEFAULT '',
+    -- Set only by a group grantee; in the key because member and admin name
+    -- two different sets of people.
     related_role  TEXT NOT NULL DEFAULT '' CHECK (related_role IN ('', 'member', 'admin')),
+    -- Out of the key: it annotates a reference rather than naming one, so
+    -- re-pointing it updates the existing row. See docs/spec/attachments.md
+    -- \xA7 Naming the upload a reference came from.
     attachment_record_id TEXT NOT NULL DEFAULT '',
+    -- Leads with record_id, so its implicit index serves every by-record
+    -- read and delete; the indexes below cover only the filter directions.
     PRIMARY KEY (record_id, kind, label, file_id, related_scope, related_id, related_ns, related_stack, related_role)
   ) STRICT;
 
@@ -123,7 +116,6 @@ var RECORD_SCHEMA_SQL = `
 
   -- 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
@@ -140,14 +132,11 @@ var RECORD_SCHEMA_SQL = `
     PRIMARY KEY (record_id, field)
   ) STRICT;
 
-  -- 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.
+  -- Each filter column continues into (created_at, id), the default order
+  -- and its tiebreak: these columns are low-cardinality, and a narrow index
+  -- leaves the planner sorting every match before it can honor LIMIT.
+  -- deleted_at and unlisted_at get none: an index on a column every query
+  -- tests 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);
@@ -201,71 +190,6 @@ var applyRecordSchema = (exec, opts) => {
   exec.exec(RECORD_SCHEMA_SQL);
   exec.exec(FTS5_SCHEMA_SQL);
 };
-var SORT_FIELDS = NATIVE_SORT_FIELDS;
-var toBase64 = (text) => {
-  const bytes = new TextEncoder().encode(text);
-  let binary = "";
-  for (const byte of bytes)
-    binary += String.fromCharCode(byte);
-  return btoa(binary);
-};
-var fromBase64 = (cursor) => {
-  const binary = atob(cursor);
-  const bytes = new Uint8Array(binary.length);
-  for (let i = 0; i < binary.length; i++)
-    bytes[i] = binary.charCodeAt(i);
-  return new TextDecoder().decode(bytes);
-};
-var encodeCursor = (decoded) => toBase64(JSON.stringify(decoded.kind === "absent" ? { k: decoded.kind, f: decoded.field, i: decoded.id } : { k: decoded.kind, f: decoded.field, i: decoded.id, v: decoded.value }));
-var decodeCursor = (cursor) => {
-  const malformed = () => new StackBadRequestError(`Invalid cursor: malformed "${cursor}"`);
-  let parsed;
-  try {
-    parsed = JSON.parse(fromBase64(cursor));
-  } catch {
-    throw malformed();
-  }
-  if (!parsed || typeof parsed !== "object")
-    throw malformed();
-  const { k, f, i, v } = parsed;
-  if (typeof f !== "string" || !f || typeof i !== "string")
-    throw malformed();
-  if (k === "absent")
-    return { kind: "absent", field: f, id: i };
-  if (k === "text") {
-    if (typeof v !== "string")
-      throw malformed();
-    return { kind: "text", field: f, value: v, id: i };
-  }
-  if (k === "num" || k === "native") {
-    if (typeof v !== "number" || !isFinite(v)) {
-      throw new StackBadRequestError(`Invalid cursor: non-numeric sort value`);
-    }
-    if (k === "native") {
-      if (!SORT_FIELDS.includes(f)) {
-        throw new StackBadRequestError(`Invalid cursor: unknown sort field "${f}"`);
-      }
-      return { kind: "native", field: f, value: v, id: i };
-    }
-    return { kind: "num", field: f, value: v, id: i };
-  }
-  throw malformed();
-};
-var getSortField = (query) => query.sort?.field ?? "createdAt";
-var getSortColumn = (field) => field === "createdAt" ? "created_at" : field === "updatedAt" ? "updated_at" : "version";
-var makeCursor = (record, sort, kindOf) => {
-  const contentField = sort?.contentField;
-  if (contentField === void 0) {
-    const field = getSortField({ sort });
-    const value = field === "updatedAt" ? record.updatedAt.getTime() : field === "version" ? record.version : record.createdAt.getTime();
-    return encodeCursor({ kind: "native", field, value, id: record.id });
-  }
-  const kind = kindOf?.(record, contentField);
-  const entry = kind ? contentSortEntry(kind, record.content[contentField]) : null;
-  if (!entry)
-    return encodeCursor({ kind: "absent", field: contentField, id: record.id });
-  return entry.kind === "num" ? encodeCursor({ kind: "num", field: contentField, value: entry.num, id: record.id }) : encodeCursor({ kind: "text", field: contentField, value: entry.text, id: record.id });
-};
 
 // ../sqlite-shared/dist/fts5.js
 var OUTSIDE_PHRASE_DISALLOWED = /[^\p{L}\p{N}\p{M}_\s()"]/gu;
@@ -279,7 +203,7 @@ var sanitizeFts5Query = (query, maxDepth = 2) => {
   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, ""));
+  clean = clean.replace(/"[^"]*"?|(^|\(\s*)NOT\s+/gi, (m, lead) => lead ?? m);
   let currentDepth = 0;
   let inPhrase = false;
   let result = "";
@@ -346,27 +270,107 @@ var restoreImplicitAnd = (query) => withPhrasesMasked(query, (masked) => masked.
   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})(${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) {
-    exec.run(`INSERT INTO records_fts(rowid, content) SELECT rowid, ? FROM records WHERE id = ?`, [
-      content,
-      recordId
-    ]);
-  },
-  /**
-   * Remove a record's FTS entry. MUST be called before the records row's
-   * content changes or the row is deleted — see the note above.
-   */
-  remove(exec, recordId) {
-    const row = exec.get("SELECT rowid, content FROM records WHERE id = ?", [recordId]);
-    if (!row)
-      return;
-    exec.run(`INSERT INTO records_fts(records_fts, rowid, content) VALUES('delete', ?, ?)`, [
-      row.rowid,
-      row.content
-    ]);
+
+// ../sqlite-shared/dist/executor.js
+var isForeignKeyViolation = (err) => err instanceof Error && err.message.includes("FOREIGN KEY constraint failed");
+var isUniqueConstraintViolation = (err) => err instanceof Error && err.message.includes("UNIQUE constraint failed");
+
+// ../sqlite-shared/dist/config.js
+var CONFIG_ROW_SQL = `SELECT content FROM records WHERE id = '_config'`;
+var insertConfigRecord = (exec, entityId, timezone) => {
+  const now = Date.now();
+  exec.run(`INSERT INTO records (id, type_id, created_at, updated_at, content, version)
+     VALUES ('_config', '_config@1', ?, ?, ?, 1)`, [now, now, JSON.stringify({ entityId, timezone })]);
+  return { entityId, timezone };
+};
+var tryReadStackConfig = (exec) => {
+  const row = exec.get(CONFIG_ROW_SQL);
+  if (!row)
+    return null;
+  const content = JSON.parse(row.content);
+  return { entityId: content.entityId, timezone: content.timezone };
+};
+var readStackConfig = (exec) => {
+  const config = tryReadStackConfig(exec);
+  if (!config)
+    throw new Error("Stack database is missing its config record.");
+  return config;
+};
+var toBase64 = (text) => {
+  const bytes = new TextEncoder().encode(text);
+  let binary = "";
+  for (const byte of bytes)
+    binary += String.fromCharCode(byte);
+  return btoa(binary);
+};
+var fromBase64 = (cursor) => {
+  const binary = atob(cursor);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++)
+    bytes[i] = binary.charCodeAt(i);
+  return new TextDecoder().decode(bytes);
+};
+var encodeCursor = (decoded) => toBase64(JSON.stringify(decoded.kind === "absent" ? { k: decoded.kind, f: decoded.field, i: decoded.id } : { k: decoded.kind, f: decoded.field, i: decoded.id, v: decoded.value }));
+var decodeCursor = (cursor) => {
+  const malformed = () => new StackBadRequestError(`Invalid cursor: malformed "${cursor}"`);
+  let parsed;
+  try {
+    parsed = JSON.parse(fromBase64(cursor));
+  } catch {
+    throw malformed();
   }
+  if (!parsed || typeof parsed !== "object")
+    throw malformed();
+  const { k, f, i, v } = parsed;
+  if (typeof f !== "string" || !f || typeof i !== "string")
+    throw malformed();
+  if (k === "absent")
+    return { kind: "absent", field: f, id: i };
+  if (k === "text") {
+    if (typeof v !== "string")
+      throw malformed();
+    return { kind: "text", field: f, value: v, id: i };
+  }
+  if (k === "num" || k === "native") {
+    if (typeof v !== "number" || !isFinite(v)) {
+      throw new StackBadRequestError(`Invalid cursor: non-numeric sort value`);
+    }
+    if (k === "native") {
+      if (!NATIVE_SORT_FIELDS.includes(f)) {
+        throw new StackBadRequestError(`Invalid cursor: unknown sort field "${f}"`);
+      }
+      return { kind: "native", field: f, value: v, id: i };
+    }
+    return { kind: "num", field: f, value: v, id: i };
+  }
+  throw malformed();
+};
+var byTypeDescriptor = (byType) => JSON.stringify(Object.entries(byType).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0));
+var getSortField = (query) => query.sort?.field ?? "createdAt";
+var getSortColumn = (field) => field === "createdAt" ? "created_at" : field === "updatedAt" ? "updated_at" : "version";
+var makeCursor = (record, sort, kindOf) => {
+  const byType = sort?.contentFieldByType;
+  if (byType) {
+    const field = byTypeDescriptor(byType);
+    const key = Object.hasOwn(byType, record.typeId) ? byType[record.typeId] : void 0;
+    const kind2 = key?.field === void 0 ? void 0 : kindOf?.(record, key.field);
+    const entry2 = key?.field !== void 0 ? kind2 && contentSortEntry(kind2, record.content[key.field]) : key && constantSortEntry(key.value ?? null);
+    return encodeEntry(field, entry2 || null, record.id);
+  }
+  const contentField = sort?.contentField;
+  if (contentField === void 0) {
+    const field = getSortField({ sort });
+    const value = field === "updatedAt" ? record.updatedAt.getTime() : field === "version" ? record.version : record.createdAt.getTime();
+    return encodeCursor({ kind: "native", field, value, id: record.id });
+  }
+  const kind = kindOf?.(record, contentField);
+  const entry = kind ? contentSortEntry(kind, record.content[contentField]) : null;
+  return encodeEntry(contentField, entry, record.id);
+};
+var encodeEntry = (field, entry, id) => {
+  if (!entry)
+    return encodeCursor({ kind: "absent", field, id });
+  return entry.kind === "num" ? encodeCursor({ kind: "num", field, value: entry.num, id }) : encodeCursor({ kind: "text", field, value: entry.text, id });
 };
 
 // ../sqlite-shared/dist/query.js
@@ -413,10 +417,31 @@ var contentCursor = (cursor, field) => {
     throw cursorMismatch(cursor, field);
   return cursor;
 };
+var contentConditions = (predicate, params, nextAlias) => {
+  const conditions = [];
+  for (const [key, value] of Object.entries(predicate.content ?? {})) {
+    const segments = parseContentFilterKey(key);
+    if (value === null || value === void 0) {
+      const isNull = contentPathExists(segments, (a) => `${a}.value IS NULL`, params, nextAlias);
+      const anyValue = contentPathExists(segments, (a) => `${a}.value IS NOT NULL`, params, nextAlias);
+      conditions.push(`(${isNull} OR NOT ${anyValue})`);
+    } else {
+      const match = contentPathExists(segments, equalsLeaf, params, nextAlias);
+      params.push(value);
+      conditions.push(match);
+    }
+  }
+  for (const key of predicate.contentPresent ?? []) {
+    conditions.push(contentPathExists(parseContentFilterKey(key), (a) => `${a}.value IS NOT NULL`, params, nextAlias));
+  }
+  return conditions;
+};
 var recordConditions = (query) => {
   const conditions = ["r.id != '_config'"];
   const params = [];
   const f = query.filter ?? {};
+  let aliasSeq = 0;
+  const nextContentAlias = () => `cp${aliasSeq++}`;
   const inFilter = (column, value) => {
     if (value === void 0)
       return;
@@ -505,28 +530,15 @@ var recordConditions = (query) => {
     }
     conditions.push(hasAssociation("relationship", clauses));
   }
-  if (f.content) {
-    let aliasSeq = 0;
-    const nextAlias = () => `cp${aliasSeq++}`;
-    for (const [key, value] of Object.entries(f.content)) {
-      const segments = parseContentFilterKey(key);
-      if (value === null || value === void 0) {
-        const isNull = contentPathExists(segments, (a) => `${a}.value IS NULL`, params, nextAlias);
-        const anyValue = contentPathExists(segments, (a) => `${a}.value IS NOT NULL`, params, nextAlias);
-        conditions.push(`(${isNull} OR NOT ${anyValue})`);
-      } else {
-        const match = contentPathExists(segments, equalsLeaf, params, nextAlias);
-        params.push(value);
-        conditions.push(match);
-      }
-    }
+  if (f.content || f.contentPresent?.length) {
+    conditions.push(...contentConditions(f, params, nextContentAlias));
   }
-  if (f.contentPresent?.length) {
-    let aliasSeq = 0;
-    const nextAlias = () => `pp${aliasSeq++}`;
-    for (const key of f.contentPresent) {
-      conditions.push(contentPathExists(parseContentFilterKey(key), (a) => `${a}.value IS NOT NULL`, params, nextAlias));
-    }
+  if (f.contentByType) {
+    const arms = Object.entries(f.contentByType).map(([typeId, arm]) => {
+      params.push(typeId);
+      return ["r.type_id = ?", ...contentConditions(arm, params, nextContentAlias)].join(" AND ");
+    });
+    conditions.push(`(${arms.map((arm) => `(${arm})`).join(" OR ")})`);
   }
   if (f.search) {
     const sanitized = sanitizeFts5Query(f.search);
@@ -556,12 +568,16 @@ var buildQueryPlan = (query) => {
   const dir = sqlDirection(query);
   const op = dir === "ASC" ? ">" : "<";
   const decoded = query.cursor ? decodeCursor(query.cursor) : null;
+  if (query.sort?.contentFieldByType) {
+    return byTypePlan(query, query.sort.contentFieldByType, dir, op, decoded);
+  }
   const contentField = query.sort?.contentField;
   if (contentField === void 0) {
     const { conditions, params } = recordConditions(query);
-    const col = getSortColumn(getSortField(query));
+    const field = getSortField(query);
+    const col = getSortColumn(field);
     if (decoded) {
-      const cursor2 = nativeCursor(decoded, getSortField(query));
+      const cursor2 = nativeCursor(decoded, field);
       conditions.push(`(r.${col} ${op} ? OR (r.${col} = ? AND r.id ${op} ?))`);
       params.push(cursor2.value, cursor2.value, cursor2.id);
     }
@@ -593,18 +609,154 @@ var buildQueryPlan = (query) => {
   }
   return pages;
 };
-
-// ../sqlite-shared/dist/mappers.js
+var byTypePlan = (query, byType, dir, op, decoded) => {
+  const cursor = decoded ? contentCursor(decoded, byTypeDescriptor(byType)) : null;
+  const fields = [];
+  const constants = [];
+  for (const [typeId, key] of Object.entries(byType)) {
+    if (key.field !== void 0) {
+      fields.push([typeId, key.field]);
+      continue;
+    }
+    const entry = constantSortEntry(key.value ?? null);
+    if (entry)
+      constants.push([typeId, entry]);
+  }
+  const pages = [];
+  const fieldOf = (alias, record) => fields.map(() => `(${record}.type_id = ? AND ${alias}.field = ?)`).join(" OR ");
+  if (cursor?.kind !== "absent" && fields.length + constants.length > 0) {
+    const sources = [];
+    const sourceParams = [];
+    if (fields.length > 0) {
+      sources.push(`SELECT c.record_id AS record_id, c.value_rank AS value_rank, c.num_value AS num_value, c.text_key AS text_key, c.text_value AS text_value FROM content_index c JOIN records t ON t.id = c.record_id WHERE ${fieldOf("c", "t")}`);
+      for (const [typeId, field] of fields)
+        sourceParams.push(typeId, field);
+    }
+    for (const [typeId, entry] of constants) {
+      sources.push("SELECT t.id AS record_id, ? AS value_rank, ? AS num_value, ? AS text_key, ? AS text_value FROM records t WHERE t.type_id = ?");
+      sourceParams.push(...entry.kind === "num" ? [0, entry.num, null, null] : [1, null, entry.key, entry.text], typeId);
+    }
+    const { conditions, params } = recordConditions(query);
+    if (cursor)
+      conditions.push(presentCursorCondition(cursor, op, params));
+    const from = `(${sources.join(" UNION ALL ")}) ${SORT_ALIAS} JOIN records r ON r.id = ${SORT_ALIAS}.record_id`;
+    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, [...sourceParams, ...params], ` ORDER BY ${order} LIMIT ?`));
+  }
+  {
+    const { conditions, params } = recordConditions(query);
+    if (fields.length > 0) {
+      conditions.push(`NOT EXISTS (SELECT 1 FROM content_index ${SORT_ALIAS} WHERE ${SORT_ALIAS}.record_id = r.id AND (${fieldOf(SORT_ALIAS, "r")}))`);
+      for (const [typeId, field] of fields)
+        params.push(typeId, field);
+    }
+    if (constants.length > 0) {
+      conditions.push(`r.type_id NOT IN (${constants.map(() => "?").join(",")})`);
+      params.push(...constants.map(([typeId]) => typeId));
+    }
+    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 pages;
+};
+var SearchIndex = class {
+  exec;
+  constructor(exec) {
+    this.exec = exec;
+  }
+  /** Index a record that has no FTS entry yet (used right after an INSERT). */
+  insert(recordId, content) {
+    this.exec.run(`INSERT INTO records_fts(rowid, content) SELECT rowid, ? FROM records WHERE id = ?`, [content, recordId]);
+  }
+  /**
+   * Remove a record's FTS entry. MUST be called before the records row's
+   * content changes or the row is deleted — see the note above.
+   */
+  remove(recordId) {
+    const row = this.exec.get("SELECT rowid, content FROM records WHERE id = ?", [recordId]);
+    if (!row)
+      return;
+    this.exec.run(`INSERT INTO records_fts(records_fts, rowid, content) VALUES('delete', ?, ?)`, [
+      row.rowid,
+      row.content
+    ]);
+  }
+};
+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")
+      continue;
+    kinds.set(field, def.kind);
+  }
+  return kinds;
+};
+var ContentIndex = class {
+  exec;
+  fieldsByType = /* @__PURE__ */ new Map();
+  constructor(exec) {
+    this.exec = exec;
+  }
+  /** Prime the cache from a type as it is saved. */
+  rememberType(type) {
+    this.fieldsByType.set(type.id, indexedFieldKinds(type.schema));
+  }
+  /**
+   * Replace a record's 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.
+   */
+  sync(recordId, typeId, content) {
+    this.remove(recordId);
+    for (const [field, kind] of this.fieldsOf(typeId)) {
+      const entry = contentSortEntry(kind, content[field]);
+      if (!entry)
+        continue;
+      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]);
+      }
+    }
+  }
+  remove(recordId) {
+    this.exec.run("DELETE FROM content_index WHERE record_id = ?", [recordId]);
+  }
+  /** The declared kind of a type's top-level `field`, if it has one. */
+  kindOf(typeId, field) {
+    return this.fieldsOf(typeId).get(field);
+  }
+  /**
+   * From the cache, falling back to a `types` lookup only for a typeId this
+   * process hasn't seen via rememberType() yet, e.g. right after open().
+   */
+  fieldsOf(typeId) {
+    const cached = this.fieldsByType.get(typeId);
+    if (cached)
+      return cached;
+    const typeRow = this.exec.get("SELECT schema FROM types WHERE id = ?", [
+      typeId
+    ]);
+    const fields = typeRow ? indexedFieldKinds(JSON.parse(typeRow.schema)) : /* @__PURE__ */ new Map();
+    this.fieldsByType.set(typeId, fields);
+    return fields;
+  }
+};
 var toMs = (d) => d.getTime();
 var actorFromColumns = (subject, principal) => subject == null ? void 0 : {
   subjectId: subject,
   ...principal != null && { principalId: principal }
 };
 var fromMs = (ms) => new Date(ms);
-var partitionAssociations = (associations) => ({
-  associations: associations.filter((a) => a.kind !== "permission" && a.kind !== "anyone"),
-  permissions: associations.filter((a) => a.kind === "permission" || a.kind === "anyone")
-});
 var rowToRecord = (row, associations) => {
   const record = {
     id: row.id,
@@ -748,31 +900,7 @@ var rowToJournalEntry = (row) => {
   return e;
 };
 
-// ../sqlite-shared/dist/executor.js
-var isForeignKeyViolation = (err) => err instanceof Error && err.message.includes("FOREIGN KEY constraint failed");
-var isUniqueConstraintViolation = (err) => err instanceof Error && err.message.includes("UNIQUE constraint failed");
-
-// ../sqlite-shared/dist/config.js
-var CONFIG_ROW_SQL = `SELECT content FROM records WHERE id = '_config'`;
-var insertConfigRecord = (exec, entityId, timezone) => {
-  const now = Date.now();
-  exec.run(`INSERT INTO records (id, type_id, created_at, updated_at, content, version)
-     VALUES ('_config', '_config@1', ?, ?, ?, 1)`, [now, now, JSON.stringify({ entityId, timezone })]);
-  return { entityId, timezone };
-};
-var tryReadStackConfig = (exec) => {
-  const row = exec.get(CONFIG_ROW_SQL);
-  if (!row)
-    return null;
-  const content = JSON.parse(row.content);
-  return { entityId: content.entityId, timezone: content.timezone };
-};
-var readStackConfig = (exec) => {
-  const config = tryReadStackConfig(exec);
-  if (!config)
-    throw new Error("Stack database is missing its config record.");
-  return config;
-};
+// ../sqlite-shared/dist/record-logic.js
 var asStackBadRequestError = (query, run) => {
   try {
     return run();
@@ -783,6 +911,7 @@ var asStackBadRequestError = (query, run) => {
   }
 };
 var versionConflict = (id, expected, actual) => new StackVersionConflictError(`Record "${id}" is at version ${actual}, expected ${expected}`, id, expected, actual);
+var recordNotFound = (id) => new StackNotFoundError(`Record not found: "${id}"`);
 var VERSION_COLUMNS = [
   "type_id",
   "content",
@@ -801,44 +930,20 @@ var versionRowValues = (version) => [
   version.updatedBy?.subjectId ?? null,
   version.updatedBy?.principalId ?? null
 ];
-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")
-      continue;
-    kinds.set(field, def.kind);
-  }
-  return kinds;
-};
-var SharedSqlRecordLogic = class _SharedSqlRecordLogic {
-  deps;
-  /**
-   * 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().
-   */
-  indexedFieldsByType = /* @__PURE__ */ new Map();
-  constructor(deps) {
-    this.deps = deps;
-  }
-  get exec() {
-    return this.deps.exec;
-  }
-  /**
-   * Precondition check for a mutation that has already read the record —
-   * either because it can't fold the check into its own statement
-   * (purgeRecord: children reference the row, so the DELETE can't
-   * carry it), or because it has to settle the precondition *before*
-   * fts5Strategy.remove() runs, which needs the records row still holding
-   * the old content. In the latter case versionedUpdate() re-checks it
-   * inside the statement, and that is the enforcement; this is what lets
-   * the work before it be skipped.
-   */
-  checkExpectedVersion(record, expectedVersion) {
-    if (expectedVersion === void 0 || record.version === expectedVersion)
+var SharedSqlRecordLogic = class {
+  exec;
+  searchIndex;
+  contentIndex;
+  constructor({ exec }) {
+    this.exec = exec;
+    this.searchIndex = new SearchIndex(exec);
+    this.contentIndex = new ContentIndex(exec);
+  }
+  /** Check `ifVersion` against a version read inside the caller's transaction. */
+  checkExpectedVersion(id, actual, expected) {
+    if (expected === void 0 || actual === expected)
       return;
-    throw versionConflict(record.id, expectedVersion, record.version);
+    throw versionConflict(id, expected, actual);
   }
   /**
    * Called after a version-gated statement affected zero rows.
@@ -847,23 +952,31 @@ var SharedSqlRecordLogic = class _SharedSqlRecordLogic {
    * the actual current version for the caller to act on).
    */
   throwVersionConflict(id, expectedVersion) {
-    const row = this.exec.get("SELECT version FROM records WHERE id = ?", [
-      id
-    ]);
+    const version = this.currentVersion(id);
+    if (version === void 0)
+      throw recordNotFound(id);
+    throw versionConflict(id, expectedVersion, version);
+  }
+  currentVersion(id) {
+    return this.exec.get("SELECT version FROM records WHERE id = ?", [id])?.version;
+  }
+  /**
+   * What a mutation builds on, read inside its transaction so nothing can
+   * land between the read and the write: a patch applied to an earlier read
+   * would overwrite whatever changed since. Throws for a missing record or
+   * a failed `ifVersion`.
+   */
+  readForWrite(id, ifVersion) {
+    const row = this.exec.get("SELECT version, type_id, content FROM records WHERE id = ?", [id]);
     if (!row)
-      throw new StackNotFoundError(`Record not found: "${id}"`);
-    throw versionConflict(id, expectedVersion, row.version);
+      throw recordNotFound(id);
+    this.checkExpectedVersion(id, row.version, ifVersion);
+    return { typeId: row.type_id, content: JSON.parse(row.content) };
   }
   /**
-   * The one shape every mutating UPDATE in this class has: whatever columns
-   * the caller is changing, then the version bump and the actor/timestamp
-   * stamp that every mutation owes, gated on the opt-in `ifVersion`
-   * precondition and failing loudly when nothing matched.
-   *
-   * The guard rides in the WHERE clause even where the caller has already
-   * checked the version against a record it read: that read is outside this
-   * statement, so a writer slipping in between the two is caught here
-   * rather than silently overwritten.
+   * Every version-bumping UPDATE. The `ifVersion` guard rides in the WHERE
+   * clause, so a write that reads nothing first (a soft delete, an
+   * undelete) enforces it with no separate read.
    */
   versionedUpdate(id, sets, values, opts, now = toMs(/* @__PURE__ */ new Date())) {
     const guarded = opts.ifVersion !== void 0;
@@ -879,15 +992,9 @@ var SharedSqlRecordLogic = class _SharedSqlRecordLogic {
       this.throwVersionConflict(id, opts.ifVersion);
   }
   /**
-   * Read a record back after its own mutation committed, for the caller to
-   * return. Its absence is not a "not found" for the caller to handle — the
-   * mutation just succeeded against it — so it fails as the invariant
-   * breach it would be.
-   *
-   * Synchronous, via readRecord() rather than getRecord(), so the read
-   * cannot be separated from the commit by anything: an async caller
-   * returning this still hands back a record read in the same tick its
-   * transaction committed. See readRecord() for why that matters.
+   * Read a record back after its own mutation committed. Absence here is an
+   * invariant breach, not a "not found". Synchronous, so nothing can run
+   * between the commit and the read — see readRecord().
    */
   reread(id, verb) {
     const updated = this.readRecord(id);
@@ -899,16 +1006,10 @@ var SharedSqlRecordLogic = class _SharedSqlRecordLogic {
   // Records
   // -------------------------------------------------------
   /**
-   * A duplicate id hits the `records` PK — mapped to StackConflictError
-   * instead of surfacing the raw engine exception, mirroring saveVersion's
-   * collision mapping below.
-   *
-   * One transaction, because a record and the four tables that describe it
-   * are one fact. A half-applied create is worse than a failed one: the
-   * call raises, so the caller believes nothing landed, while the records
-   * row survives to fail their retry on the PK — and the row it leaves is
-   * invisible to `filter.search` and mis-ordered by `sort.contentField`
-   * until something writes it again.
+   * One transaction, because a record and the tables that describe it are
+   * one fact: a half-applied create raises, so the caller believes nothing
+   * landed, while the surviving row fails their retry on the PK and is
+   * missing from both indexes. A duplicate id maps to StackConflictError.
    */
   async createRecord(record, opts = {}) {
     this.exec.transaction(() => {
@@ -942,8 +1043,8 @@ var SharedSqlRecordLogic = class _SharedSqlRecordLogic {
       const edges = [...record.associations ?? [], ...record.permissions ?? []];
       if (edges.length)
         this.insertAssociations(record.id, edges);
-      fts5Strategy.insert(this.exec, record.id, JSON.stringify(record.content));
-      this.syncContentIndex(record.id, record.typeId, record.content);
+      this.searchIndex.insert(record.id, JSON.stringify(record.content));
+      this.contentIndex.sync(record.id, record.typeId, record.content);
       this.appendJournal(record.id, opts.journal);
     });
     return record;
@@ -952,53 +1053,24 @@ var SharedSqlRecordLogic = class _SharedSqlRecordLogic {
     return this.readRecord(id);
   }
   /**
-   * The synchronous read behind getRecord(). Callers inside exec.transaction()
-   * use this one: an `await` inside that callback yields the microtask queue
-   * mid-transaction, and the next operation to run would try to open one of
-   * its own — transaction() requires a synchronous callback for exactly this
-   * reason (see SqlExecutor.transaction).
-   *
-   * The same synchrony is what lets the post-commit reads below report the
-   * version their own mutation produced: reread() calls this directly, so
-   * nothing interleaves between the commit and the read even though the
-   * method returning it is async. A backend that made these reads genuinely
-   * asynchronous would open that window, and a concurrent mutation could be
-   * reported under this one's verb.
+   * The synchronous read behind getRecord(), for use inside
+   * exec.transaction(), whose callback can't await. reread() relies on the
+   * same synchrony: nothing interleaves between a commit and its read, so a
+   * concurrent mutation is never reported under this one's verb.
    */
   readRecord(id) {
     const row = this.exec.get("SELECT * FROM records WHERE id = ?", [id]);
-    if (!row)
-      return null;
-    const associations = this.getAssociationsForRecord(id);
-    return rowToRecord(row, associations);
+    return row ? this.hydrate(row) : null;
+  }
+  /** A records row with its association set attached. */
+  hydrate(row) {
+    return rowToRecord(row, this.getAssociationsForRecord(row.id));
   }
   /**
-   * Apply a change set in one transaction: one UPDATE over the record row
-   * with only the columns the change set names, the association set
-   * replaced when it carries one, and the snapshot written alongside — so
-   * one call is one version whatever it moved.
-   *
-   * `opts.bumpsVersion: false` is a change set that touches only
-   * `associations`, `parentId` and/or `unlisted` — Stack computes this from
-   * which ops the set actually moves. Such a write still lands its columns,
-   * but leaves `version`, `updatedAt` and the actor stamps exactly as they
-   * stood and takes no snapshot. `ifVersion`, if given, is re-checked
-   * synchronously inside the transaction — the CAS guard the bumping path
-   * gets from its UPDATE's WHERE clause, restated as a read because the
-   * UPDATE here carries no version predicate. See
-   * docs/spec/versioning.md § Version history.
-   *
-   * The ifVersion check for a bumping write is standalone rather than
-   * folded into the UPDATE alone, because a content change needs
-   * fts.remove() to run *before* the records-table content changes. The
-   * guard is still in the UPDATE's WHERE, so a writer that slipped in
-   * between the read and the write is caught there rather than overwriting.
+   * One transaction, so one call is one version whatever it moved, and the
+   * patch applies to the content as it stands when the write lands.
    */
   async mutateRecord(id, changes, opts = {}) {
-    const existing = await this.getRecord(id);
-    if (!existing)
-      throw new StackNotFoundError(`Record not found: "${id}"`);
-    this.checkExpectedVersion(existing, opts.ifVersion);
     const now = toMs(/* @__PURE__ */ new Date());
     const sets = [];
     const values = [];
@@ -1010,35 +1082,30 @@ var SharedSqlRecordLogic = class _SharedSqlRecordLogic {
       sets.push("unlisted_at = ?");
       values.push(changes.unlisted ? now : null);
     }
-    if (opts.bumpsVersion === false) {
-      this.exec.transaction(() => {
-        const current = this.readRecord(id);
-        if (!current)
-          throw new StackNotFoundError(`Record not found: "${id}"`);
-        this.checkExpectedVersion(current, opts.ifVersion);
+    this.exec.transaction(() => {
+      const current = this.readForWrite(id, opts.ifVersion);
+      if (opts.bumpsVersion === false) {
         if (sets.length > 0) {
           this.exec.run(`UPDATE records SET ${sets.join(", ")} WHERE id = ?`, [...values, id]);
         }
         this.replaceAssociationHalves(id, changes);
         this.appendJournal(id, opts.journal);
-      });
-      return this.reread(id, "mutateRecord");
-    }
-    const merged = changes.contentPatch ? applyMergePatch(existing.content, changes.contentPatch) : void 0;
-    if (merged !== void 0) {
-      sets.unshift("content = ?");
-      values.unshift(JSON.stringify(merged));
-    }
-    this.exec.transaction(() => {
+        return;
+      }
+      const merged = changes.contentPatch ? applyMergePatch(current.content, changes.contentPatch) : void 0;
+      if (merged !== void 0) {
+        sets.unshift("content = ?");
+        values.unshift(JSON.stringify(merged));
+      }
       if (opts.snapshot)
         this.snapshotBeforeMutation(id, opts.snapshot);
       if (merged !== void 0)
-        fts5Strategy.remove(this.exec, id);
+        this.searchIndex.remove(id);
       this.versionedUpdate(id, sets, values, opts, now);
       this.replaceAssociationHalves(id, changes);
       if (merged !== void 0) {
-        fts5Strategy.insert(this.exec, id, JSON.stringify(merged));
-        this.syncContentIndex(id, existing.typeId, merged);
+        this.searchIndex.insert(id, JSON.stringify(merged));
+        this.contentIndex.sync(id, current.typeId, merged);
       }
       this.appendJournal(id, opts.journal);
     });
@@ -1058,27 +1125,23 @@ var SharedSqlRecordLogic = class _SharedSqlRecordLogic {
     return this.reread(id, "deleteRecord");
   }
   /**
-   * Deletes a record's FTS entry, associations, versions, file-refs, sort
-   * index rows, and row, returning the record as it stood — the last copy that will ever
-   * exist, read here so that nothing can overtake it between the read and
-   * the deletes. Null when there was no such record. No write() call —
-   * callers batch it. ifVersion is checked first so a lost CAS race
-   * leaves nothing touched (children reference the row, so the check can't
-   * fold into the final DELETE).
+   * Delete a record and everything that refers to it, returning the record
+   * as it stood (null if there was none). Read here, inside the caller's
+   * transaction, so nothing can overtake the last copy that will ever exist.
    */
   purgeRecord(id, ifVersion) {
     const purged = this.readRecord(id);
     if (!purged) {
       if (ifVersion !== void 0)
-        throw new StackNotFoundError(`Record not found: "${id}"`);
+        throw recordNotFound(id);
       return null;
     }
-    this.checkExpectedVersion(purged, ifVersion);
-    fts5Strategy.remove(this.exec, id);
+    this.checkExpectedVersion(id, purged.version, ifVersion);
+    this.searchIndex.remove(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 journal WHERE record_id = ?", [id]);
-    this.exec.run("DELETE FROM content_index WHERE record_id = ?", [id]);
+    this.contentIndex.remove(id);
     this.exec.run("DELETE FROM records WHERE id = ?", [id]);
     return purged;
   }
@@ -1092,14 +1155,11 @@ var SharedSqlRecordLogic = class _SharedSqlRecordLogic {
     return this.reread(id, "undelete");
   }
   async restoreVersion(id, version, opts = {}) {
-    const existing = await this.getRecord(id);
-    if (!existing)
-      throw new StackNotFoundError(`Record not found: "${id}"`);
-    this.checkExpectedVersion(existing, opts.ifVersion);
-    const target = await this.getVersion(id, version);
-    if (!target)
-      throw new StackNotFoundError(`Version not found: "${id}"@${version}`);
     this.exec.transaction(() => {
+      this.readForWrite(id, opts.ifVersion);
+      const target = this.readVersion(id, version);
+      if (!target)
+        throw new StackNotFoundError(`Version not found: "${id}"@${version}`);
       if (opts.snapshot)
         this.snapshotBeforeMutation(id, opts.snapshot);
       this.rewriteContent(id, target.typeId, target.content, opts);
@@ -1108,11 +1168,8 @@ var SharedSqlRecordLogic = class _SharedSqlRecordLogic {
     return this.reread(id, "restoreVersion");
   }
   async commitMigration(id, toTypeId, content, opts = {}) {
-    const existing = await this.getRecord(id);
-    if (!existing)
-      throw new StackNotFoundError(`Record not found: "${id}"`);
-    this.checkExpectedVersion(existing, opts.ifVersion);
     this.exec.transaction(() => {
+      this.readForWrite(id, opts.ifVersion);
       if (opts.snapshot)
         this.snapshotBeforeMutation(id, opts.snapshot);
       this.rewriteContent(id, toTypeId, content, opts);
@@ -1121,21 +1178,16 @@ var SharedSqlRecordLogic = class _SharedSqlRecordLogic {
     return this.reread(id, "commitMigration");
   }
   /**
-   * Replace a record's type and content wholesale — what restoreVersion and
-   * commitMigration each do, differing only in where the content came from.
-   *
-   * The order is the constraint: fts5Strategy.remove() has to read the old
-   * content off the records row, so it runs before the UPDATE, and the
-   * re-index runs after. Every caller must already sit inside
-   * exec.transaction() — a failure between the two halves would otherwise
-   * leave the record unindexed.
+   * Replace a record's type and content wholesale. Unindex, write, re-index,
+   * in that order (docs/spec/adapters.md § The search index is unindexed
+   * before the row moves); callers must be inside exec.transaction().
    */
   rewriteContent(id, typeId, content, opts) {
     const json = JSON.stringify(content);
-    fts5Strategy.remove(this.exec, id);
+    this.searchIndex.remove(id);
     this.versionedUpdate(id, ["type_id = ?", "content = ?"], [typeId, json], opts);
-    fts5Strategy.insert(this.exec, id, json);
-    this.syncContentIndex(id, typeId, content);
+    this.searchIndex.insert(id, json);
+    this.contentIndex.sync(id, typeId, content);
   }
   async queryRecords(query) {
     const limit = query.limit ?? 50;
@@ -1150,20 +1202,14 @@ var SharedSqlRecordLogic = class _SharedSqlRecordLogic {
     }
     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 records = page.map((row) => this.hydrate(row));
     const lastRecord = records[records.length - 1];
-    const cursor = hasMore && lastRecord ? makeCursor(lastRecord, query.sort, (record, field) => this.sortFieldKind(record, field)) : null;
+    const cursor = hasMore && lastRecord ? makeCursor(lastRecord, query.sort, (record, field) => this.contentIndex.kindOf(record.typeId, field)) : null;
     return { records, cursor };
   }
   /**
-   * Atomically verify fileId is unreferenced, then purge its
-   * metadata records across every typeId in `metadataTypeIds` (see
-   * deleteUnreferencedAttachmentRecords on the adapter contract). A real
-   * SQL transaction of synchronous calls — no `await` between the check
-   * and the deletes, so nothing interleaves.
+   * The reference check and the purges share one synchronous transaction,
+   * so nothing can add a reference between the two.
    */
   async deleteUnreferencedAttachmentRecords(fileId, metadataTypeIds) {
     return this.exec.transaction(() => {
@@ -1202,6 +1248,9 @@ var SharedSqlRecordLogic = class _SharedSqlRecordLogic {
     return rows.map(rowToVersion);
   }
   async getVersion(id, version) {
+    return this.readVersion(id, version);
+  }
+  readVersion(id, version) {
     const row = this.exec.get("SELECT * FROM versions WHERE record_id = ? AND version = ?", [id, version]);
     return row ? rowToVersion(row) : null;
   }
@@ -1255,10 +1304,7 @@ var SharedSqlRecordLogic = class _SharedSqlRecordLogic {
     } catch (err) {
       if (!(err instanceof StackConflictError))
         throw err;
-      const row = this.exec.get("SELECT version FROM records WHERE id = ?", [
-        id
-      ]);
-      if (!row || row.version !== version.version)
+      if (this.currentVersion(id) !== version.version)
         throw err;
       this.overwriteVersionRow(id, version);
     }
@@ -1267,21 +1313,17 @@ var SharedSqlRecordLogic = class _SharedSqlRecordLogic {
   // Change journal
   // -------------------------------------------------------
   /**
-   * Append one entry, stamping the record-derived half off the row as it
-   * now stands — so every caller must already sit inside the same
-   * transaction as the write it describes, after that write has landed.
-   *
-   * `seq` is allocated here, from the log's own max, rather than computed
-   * by the caller. That is what spares this table the collision healing
-   * versions needs: nothing outside this statement ever holds a seq it
-   * expects to be free. See docs/spec/journal.md § Ordering.
+   * Append one entry, stamped from the row as it now stands, so callers run
+   * this inside their write's transaction, after the write. `seq` is
+   * allocated in the INSERT itself, so no caller ever holds one it expects
+   * to be free. See docs/spec/journal.md § Ordering.
    */
   appendJournal(recordId, entry) {
     if (!entry)
       return;
     const row = this.exec.get("SELECT version, type_id, parent_id FROM records WHERE id = ?", [recordId]);
     if (!row)
-      throw new StackNotFoundError(`Record not found: "${recordId}"`);
+      throw recordNotFound(recordId);
     this.exec.run(`INSERT INTO journal
         (record_id, seq, at, kind, ops, version, type_id, parent_id,
          previous_parent_id, actor, associations)
@@ -1305,7 +1347,7 @@ var SharedSqlRecordLogic = class _SharedSqlRecordLogic {
   }
   async getJournal(id, query = {}) {
     if (!this.exec.get("SELECT 1 FROM records WHERE id = ?", [id])) {
-      throw new StackNotFoundError(`Record not found: "${id}"`);
+      throw recordNotFound(id);
     }
     const conditions = ["record_id = ?"];
     const values = [id];
@@ -1332,8 +1374,7 @@ var SharedSqlRecordLogic = class _SharedSqlRecordLogic {
       type.migratesFrom ?? null,
       toMs(type.createdAt)
     ]);
-    const schema = type.schema;
-    this.indexedFieldsByType.set(type.id, indexedFieldKinds(schema));
+    this.contentIndex.rememberType(type);
   }
   async getType(id) {
     const row = this.exec.get("SELECT * FROM types WHERE id = ?", [id]);
@@ -1348,15 +1389,14 @@ var SharedSqlRecordLogic = class _SharedSqlRecordLogic {
   // -------------------------------------------------------
   /**
    * Never bumps `version`/`updatedAt` and never snapshots — see
-   * StackRecordAdapter.amendAssociations(). The records row is untouched
-   * entirely; only the associations table changes, in one transaction:
-   * removes first, then adds.
+   * StackRecordAdapter.amendAssociations(). Removes apply before adds, so
+   * removing and re-adding one identity in a call leaves it present.
    */
   async amendAssociations(recordId, changes, opts = {}) {
     assertOneSurface(changes);
     this.exec.transaction(() => {
-      if (!this.readRecord(recordId))
-        throw new StackNotFoundError(`Record not found: "${recordId}"`);
+      if (this.currentVersion(recordId) === void 0)
+        throw recordNotFound(recordId);
       for (const change of changes) {
         if (change.op !== "remove")
           continue;
@@ -1379,43 +1419,33 @@ var SharedSqlRecordLogic = class _SharedSqlRecordLogic {
     });
     return this.reread(recordId, "amendAssociations");
   }
-  /** The kinds each change-set key replaces, and nothing else. */
-  static DATA_KINDS = ["tag", "attachment", "relationship"];
-  static AUTHORITY_KINDS = ["permission", "anyone"];
   /**
-   * Apply a change set's two association keys, each replacing only within
-   * its own half of the partition. That partition is the whole reason a
-   * tag write cannot drop an ACL: the `associations` key deletes data
-   * kinds alone, so the authority rows beside them are never in scope.
-   * Caller-transactional, like every write below.
+   * Each key replaces only within its own half of the partition, which is
+   * why a tag write cannot drop an ACL. Caller-transactional.
    * See docs/spec/access-control.md § Record-level permissions.
    */
   replaceAssociationHalves(recordId, changes) {
     if (changes.associations !== void 0) {
-      this.replaceAssociations(recordId, changes.associations, _SharedSqlRecordLogic.DATA_KINDS);
+      this.replaceAssociations(recordId, changes.associations, "data");
     }
     if (changes.permissions !== void 0) {
-      this.replaceAssociations(recordId, changes.permissions, _SharedSqlRecordLogic.AUTHORITY_KINDS);
+      this.replaceAssociations(recordId, changes.permissions, "authority");
     }
   }
   /**
    * Swap one half of a record's association set wholesale — the "replace,
-   * don't merge" semantics a change set's association list carries.
+   * don't merge" semantics a change set's association list carries. The data
+   * half is "not an authority kind", so core's list is the only one.
    */
-  replaceAssociations(recordId, associations, kinds) {
-    this.exec.run(`DELETE FROM associations WHERE record_id = ? AND kind IN (${kinds.map(() => "?").join(", ")})`, [recordId, ...kinds]);
+  replaceAssociations(recordId, associations, half) {
+    this.exec.run(`DELETE FROM associations WHERE record_id = ? AND kind ${half === "data" ? "NOT IN" : "IN"} (${AUTHORITY_ASSOCIATION_KINDS.map(() => "?").join(", ")})`, [recordId, ...AUTHORITY_ASSOCIATION_KINDS]);
     if (associations.length)
       this.insertAssociations(recordId, associations);
   }
   /**
-   * Upserts on association identity: the primary key decides which row a
-   * write lands on, and `attachment_record_id` — outside it — is whatever
-   * the incoming association says, so re-pointing one costs no second row.
-   *
-   * FK enforcement (PRAGMA_FOREIGN_KEYS_ON) means inserting an
-   * association against a record that doesn't exist throws — mapped
-   * here to StackNotFoundError so amendAssociations() on a nonexistent record
-   * fails loudly instead of silently creating an orphan row.
+   * Upserts on association identity, so re-pointing `attachment_record_id`
+   * (outside the key) costs no second row. A missing record trips the
+   * foreign key, reported as StackNotFoundError rather than an orphan row.
    */
   insertAssociations(recordId, associations) {
     for (const assoc of associations) {
@@ -1433,7 +1463,7 @@ var SharedSqlRecordLogic = class _SharedSqlRecordLogic {
         ]);
       } catch (err) {
         if (isForeignKeyViolation(err)) {
-          throw new StackNotFoundError(`Record not found: "${recordId}"`);
+          throw recordNotFound(recordId);
         }
         throw err;
       }
@@ -1443,51 +1473,6 @@ var SharedSqlRecordLogic = class _SharedSqlRecordLogic {
     const rows = this.exec.all("SELECT * FROM associations WHERE record_id = ?", [recordId]);
     return rows.map(rowToAssociation);
   }
-  /**
-   * 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().
-   */
-  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 ? indexedFieldKinds(JSON.parse(typeRow.schema)) : /* @__PURE__ */ new Map();
-    this.indexedFieldsByType.set(typeId, fields);
-    return fields;
-  }
-  /**
-   * 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.
-   */
-  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;
-      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.getIndexedFields(record.typeId).get(field);
-  }
 };
 
 // ../sqlite-shared/dist/record-adapter.js
@@ -1495,11 +1480,15 @@ var SQLITE_RECORD_CAPABILITIES = {
   filter: {
     content: "path",
     contentPresent: true,
+    // Inside SQLite's limits on expression depth and compound selects; see
+    // docs/spec/adapters.md § Adapter capabilities.
+    contentByType: 64,
     search: true
   },
   sort: {
     fields: ["createdAt", "updatedAt", "version"],
-    contentField: true
+    contentField: true,
+    contentFieldByType: 64
   },
   limits: {
     attachmentBytes: null,
@@ -1594,7 +1583,7 @@ var isProcessAlive = (pid) => {
 };
 var acquireLock = (dbPath, force) => {
   const lockPath = lockPathFor(dbPath);
-  const info = existsSync(lockPath) ? readLock(lockPath) : null;
+  const info = readLock(lockPath);
   if (info) {
     const ownedBySelf = info.pid === process.pid;
     if (!ownedBySelf && !force && isProcessAlive(info.pid)) {
@@ -1621,12 +1610,9 @@ var releaseLock = (dbPath) => {
 };
 var hashToken = (token) => createHash("sha256").update(token).digest("hex");
 var SharedTokenLogic = class {
-  deps;
-  constructor(deps) {
-    this.deps = deps;
-  }
-  get exec() {
-    return this.deps.exec;
+  exec;
+  constructor({ exec }) {
+    this.exec = exec;
   }
   async createToken(actor, opts = {}) {
     const id = randomBytes(8).toString("hex");