@bitcobblers/wod-wiki-storage 0.0.0-stage → 0.35.2116

package/dist/sql/index.cjs

@@ -0,0 +1,1779 @@
+'use strict';
+
+var wodWikiWql = require('@bitcobblers/wod-wiki-wql');
+var web = require('@libsql/client/web');
+
+// src/sql/errors.ts
+var StorageError = class extends Error {
+  constructor(status, message, code) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.name = "StorageError";
+  }
+  status;
+  code;
+};
+
+// src/sql/connection.ts
+function libsqlRows(result) {
+  return result.rows;
+}
+function libsqlDatabase(client) {
+  let chain = Promise.resolve();
+  const serialize = (fn) => {
+    const next = chain.then(fn, fn);
+    chain = next.then(() => void 0, () => void 0);
+    return next;
+  };
+  return {
+    dialect: "sqlite",
+    query: (sql, params = []) => serialize(() => client.execute({ sql, args: params }).then(libsqlRows)),
+    exec: async (sql, params = []) => {
+      await serialize(() => client.execute({ sql, args: params }));
+    },
+    transaction(fn) {
+      return serialize(async () => {
+        const tx = await client.transaction("write");
+        try {
+          const txConn = {
+            query: (sql, params = []) => tx.execute({ sql, args: params }).then(libsqlRows),
+            exec: async (sql, params = []) => {
+              await tx.execute({ sql, args: params });
+            }
+          };
+          const result = await fn(txConn);
+          await tx.commit();
+          return result;
+        } catch (err) {
+          try {
+            await tx.rollback();
+          } catch {
+          }
+          throw err;
+        } finally {
+          tx.close();
+        }
+      });
+    },
+    close: async () => {
+      await chain;
+      client.close();
+    }
+  };
+}
+
+// src/sql/codec.ts
+var TAG = "$binary";
+var LEN = "$bytes";
+function bytesToBase64(bytes) {
+  let binary = "";
+  const CHUNK = 32768;
+  for (let i = 0; i < bytes.length; i += CHUNK) {
+    binary += String.fromCharCode(...bytes.subarray(i, i + CHUNK));
+  }
+  return btoa(binary);
+}
+function base64ToBytes(base64) {
+  const binary = atob(base64);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+  return bytes;
+}
+function reviveBinary(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return value;
+  const keys = Object.keys(value);
+  if (keys.length !== 2 || !keys.includes(TAG) || !keys.includes(LEN)) return value;
+  const tag = value;
+  if (typeof tag[TAG] !== "string" || typeof tag[LEN] !== "number") return value;
+  const bytes = base64ToBytes(tag[TAG]);
+  if (bytes.length !== tag[LEN]) {
+    throw new Error(`corrupt binary cell: declared ${tag[LEN]} bytes, decoded ${bytes.length}`);
+  }
+  return bytes.buffer;
+}
+function encodeRowJson(value, binaryField) {
+  if (binaryField && value !== null && typeof value === "object" && !Array.isArray(value)) {
+    const row = value;
+    const data = row[binaryField];
+    if (data instanceof ArrayBuffer) {
+      const bytes = new Uint8Array(data);
+      return JSON.stringify({ ...row, [binaryField]: { [TAG]: bytesToBase64(bytes), [LEN]: bytes.length } });
+    }
+  }
+  return JSON.stringify(value);
+}
+function decodeRowJson(text2, binaryField) {
+  const row = JSON.parse(text2);
+  if (binaryField && row !== null && typeof row === "object" && !Array.isArray(row)) {
+    const record = row;
+    const revived = reviveBinary(record[binaryField]);
+    if (revived !== record[binaryField]) record[binaryField] = revived;
+  }
+  return row;
+}
+
+// src/schema.ts
+var DB_VERSION = 28;
+var COLUMN_TYPES = {
+  notes: { date: "number", createdAt: "number" },
+  page: { createdAt: "number" },
+  // page.date is a civil 'YYYY-MM-DD' string → TEXT
+  page_notes: { position: "number", createdAt: "number" },
+  tags: { createdAt: "number" },
+  tag_types: { createdAt: "number" },
+  note_tags: {},
+  segments: {
+    version: "number",
+    position: "number",
+    createdAt: "number",
+    updatedAt: "number",
+    isHistory: "boolean"
+  },
+  sessions: {
+    segmentVersion: "number",
+    version: "number",
+    startTime: "number",
+    endTime: "number",
+    duration: "number",
+    roundsCompleted: "number",
+    totalRounds: "number",
+    repsCompleted: "number",
+    completed: "boolean",
+    createdAt: "number"
+  },
+  attachments: { createdAt: "number" },
+  events: {
+    timestamp: "number",
+    segmentVersion: "number",
+    line: "number",
+    sourceStatementId: "number",
+    stackLevel: "number",
+    "timeSpan.started": "number",
+    "timeSpan.ended": "number"
+  },
+  field_catalog: {},
+  field_sources: {},
+  field_values: {},
+  field_catalog_meta: {},
+  efforts: { "baseAttributes.met": "number" },
+  block_index: {
+    segmentVersion: "number",
+    position: "number",
+    createdAt: "number",
+    isStatic: "boolean"
+  },
+  block_efforts: { createdAt: "number", isStatic: "boolean" },
+  meta: {},
+  memberships: { createdAt: "number" }
+};
+var STORE_DEFS = [
+  // 1. notes
+  { name: "notes", keyPath: ["id"], indexes: [
+    { name: "by-date", keyPath: ["date"] },
+    { name: "by-created", keyPath: ["createdAt"] },
+    { name: "by-user", keyPath: ["userId"] }
+  ] },
+  // 2. page
+  { name: "page", keyPath: ["id"], indexes: [
+    { name: "by-date", keyPath: ["date"], unique: true },
+    { name: "by-slug", keyPath: ["slug"], unique: true },
+    { name: "by-user", keyPath: ["userId"] }
+  ] },
+  // 2b. page_notes (V22)
+  { name: "page_notes", keyPath: ["id"], indexes: [
+    { name: "by-page", keyPath: ["pageId"] },
+    { name: "by-note", keyPath: ["noteId"] },
+    { name: "by-page-note", keyPath: ["pageId", "noteId"], unique: true },
+    { name: "by-user", keyPath: ["userId"] }
+  ] },
+  // 3. tags
+  { name: "tags", keyPath: ["id"], indexes: [
+    { name: "by-label", keyPath: ["label"], unique: true },
+    { name: "by-type", keyPath: ["type"] },
+    { name: "by-user", keyPath: ["userId"] }
+  ] },
+  // 3a. tag_types (V23)
+  { name: "tag_types", keyPath: ["id"], indexes: [
+    { name: "by-name", keyPath: ["name"], unique: true },
+    { name: "by-user", keyPath: ["userId"] }
+  ] },
+  // 4. note_tags
+  { name: "note_tags", keyPath: ["id"], indexes: [
+    { name: "by-note", keyPath: ["noteId"] },
+    { name: "by-tag", keyPath: ["tagId"] },
+    { name: "by-note-tag", keyPath: ["noteId", "tagId"], unique: true },
+    { name: "by-user", keyPath: ["userId"] }
+  ] },
+  // 5. segments
+  { name: "segments", keyPath: ["id", "version"], indexes: [
+    { name: "by-note", keyPath: ["noteId"] },
+    { name: "by-type", keyPath: ["dataType"] },
+    { name: "by-page", keyPath: ["pageId"] },
+    { name: "by-history", keyPath: ["isHistory"] },
+    { name: "by-user", keyPath: ["userId"] }
+  ] },
+  // 6. sessions
+  { name: "sessions", keyPath: ["id"], indexes: [
+    { name: "by-segment", keyPath: ["segmentId"] },
+    { name: "by-note", keyPath: ["noteId"] },
+    { name: "by-completed", keyPath: ["createdAt"] },
+    { name: "by-content", keyPath: ["blockContentId"] },
+    { name: "by-block", keyPath: ["blockId"] },
+    { name: "by-page", keyPath: ["pageId"] },
+    { name: "by-origin", keyPath: ["origin"] },
+    { name: "by-user", keyPath: ["userId"] }
+  ] },
+  // 7. results — removed in V26: legacy alias of sessions. The V26 upgrade
+  // migrates any residual rows into `sessions` (projecting pre-V21 data.logs
+  // into event rows) before dropping the store; no compatibility alias.
+  // 8. attachments
+  { name: "attachments", keyPath: ["id"], indexes: [
+    { name: "by-note", keyPath: ["noteId"] },
+    { name: "by-time", keyPath: ["createdAt"] },
+    { name: "by-page", keyPath: ["pageId"] },
+    { name: "by-result", keyPath: ["resultId"] },
+    { name: "by-user", keyPath: ["userId"] }
+  ] },
+  // 9. events
+  { name: "events", keyPath: ["id"], indexes: [
+    { name: "by-timestamp", keyPath: ["timestamp"] },
+    { name: "by-result-grain", keyPath: ["resultId", "grain"] },
+    { name: "by-content-grain", keyPath: ["blockContentId", "grain"] },
+    { name: "by-effort", keyPath: ["effortSlug"] },
+    { name: "by-outputType", keyPath: ["outputType"] },
+    { name: "by-grain", keyPath: ["grain"] },
+    { name: "by-metric-date", keyPath: ["metricDateKeys"], multiEntry: true },
+    { name: "by-user", keyPath: ["userId"] }
+  ] },
+  // 10. field catalog
+  { name: "field_catalog", keyPath: ["id"], indexes: [
+    { name: "by-path", keyPath: ["path"] }
+  ] },
+  { name: "field_sources", keyPath: ["id"], indexes: [] },
+  { name: "field_values", keyPath: ["key"], indexes: [
+    { name: "by-field", keyPath: ["fieldId"] }
+  ] },
+  { name: "field_catalog_meta", keyPath: ["id"], indexes: [] },
+  // 11. efforts
+  { name: "efforts", keyPath: ["slug"], indexes: [
+    { name: "by-discipline", keyPath: ["baseAttributes.discipline"] },
+    { name: "by-source", keyPath: ["registrySource"] },
+    { name: "by-user", keyPath: ["userId"] }
+  ] },
+  // 12. block_index
+  { name: "block_index", keyPath: ["id"], indexes: [
+    { name: "by-note", keyPath: ["noteId"] },
+    { name: "by-content", keyPath: ["blockContentId"] },
+    { name: "by-type", keyPath: ["dataType"] },
+    { name: "by-source", keyPath: ["sourceId"] },
+    { name: "by-user", keyPath: ["userId"] }
+  ] },
+  // 13. block_efforts
+  { name: "block_efforts", keyPath: ["id"], indexes: [
+    { name: "by-note", keyPath: ["noteId"] },
+    { name: "by-effort", keyPath: ["effortSlug"] },
+    { name: "by-block", keyPath: ["blockContentId"] },
+    { name: "by-user", keyPath: ["userId"] }
+  ] },
+  // 14. meta
+  { name: "meta", keyPath: ["key"], indexes: [] },
+  // 15. memberships (V25, system — survives wipe; truth lives in
+  // localStorage locally, in the SQL table on the API)
+  { name: "memberships", keyPath: ["id"], indexes: [], system: true }
+];
+
+// src/wire.ts
+function isRange(arg) {
+  return arg !== null && typeof arg === "object" && !Array.isArray(arg) && ("only" in arg || "lower" in arg || "upper" in arg || "lowerOpen" in arg || "upperOpen" in arg);
+}
+function extractKeyPart(value, dottedPath) {
+  let cur = value;
+  for (const part of dottedPath.split(".")) {
+    if (cur === null || typeof cur !== "object") return void 0;
+    const row = cur;
+    if (!(part in row)) return void 0;
+    cur = row[part];
+  }
+  if (cur === null || typeof cur === "object" || cur === void 0) return void 0;
+  return cur;
+}
+function keyFromValue(def, value) {
+  const parts = def.keyPath.map((p) => extractKeyPart(value, p));
+  for (const [i, part] of parts.entries()) {
+    if (part === void 0) {
+      throw new Error(`keyFromValue(${def.name}): keyPath part '${def.keyPath[i]}' missing on value`);
+    }
+  }
+  const key = parts;
+  return key.length === 1 ? key[0] : key;
+}
+function rangeFromIDB(query) {
+  if (query === void 0) return void 0;
+  if (!isRange(query)) {
+    const key = query;
+    return { only: key };
+  }
+  if (query.only !== void 0) return query;
+  const wire = {};
+  if (query.lower !== void 0 && query.lower !== null) {
+    wire.lower = query.lower;
+    wire.lowerOpen = query.lowerOpen === true;
+  }
+  if (query.upper !== void 0 && query.upper !== null) {
+    wire.upper = query.upper;
+    wire.upperOpen = query.upperOpen === true;
+  }
+  return wire.lower !== void 0 || wire.upper !== void 0 ? wire : void 0;
+}
+function compareKeys(a, b) {
+  if (Array.isArray(a) || Array.isArray(b)) {
+    if (!Array.isArray(a) || !Array.isArray(b)) return Array.isArray(a) ? 1 : -1;
+    for (let i = 0; i < Math.min(a.length, b.length); i++) {
+      const c = compareKeys(a[i], b[i]);
+      if (c !== 0) return c;
+    }
+    return a.length - b.length;
+  }
+  if (typeof a === "number" && typeof b === "number") {
+    return a < b ? -1 : a > b ? 1 : 0;
+  }
+  if (typeof a === "number" || typeof b === "number") return typeof a === "number" ? -1 : 1;
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+function keyInRange(key, range) {
+  if (range.only !== void 0) return compareKeys(key, range.only) === 0;
+  if (range.lower !== void 0) {
+    const c = compareKeys(key, range.lower);
+    if (c < 0 || c === 0 && range.lowerOpen === true) return false;
+  }
+  if (range.upper !== void 0) {
+    const c = compareKeys(key, range.upper);
+    if (c > 0 || c === 0 && range.upperOpen === true) return false;
+  }
+  return true;
+}
+
+// src/sql/store.ts
+var SCHEMA_TABLE = "_wodwiki_schema";
+var SCHEMA_KEY = "schema";
+var BINARY_FIELD = { attachments: "data" };
+var binaryFieldOf = (def) => BINARY_FIELD[def.name];
+function storeDefinition(name) {
+  const def = STORE_DEFS.find((d) => d.name === name);
+  if (!def) throw new StorageError(404, `unknown store: ${name}`);
+  return def;
+}
+function indexDefinition(def, indexName) {
+  const idx = def.indexes.find((i) => i.name === indexName);
+  if (!idx) throw new StorageError(404, `unknown index: ${def.name}.${indexName}`);
+  return idx;
+}
+function sanitize(name) {
+  return name.replace(/[^A-Za-z0-9_]/g, "_");
+}
+var indexCol = (indexName, part) => `i_${sanitize(indexName)}_${part}`;
+function keyCols(def) {
+  return def.keyPath.map((_, i) => `k${i}`);
+}
+var junctionTable = (def, idx) => `${def.name}__${sanitize(idx.name)}`;
+var multiEntryIndex = (def) => def.indexes.find((i) => i.multiEntry);
+function pathType(def, path) {
+  return COLUMN_TYPES[def.name][path] ?? "text";
+}
+function colSql(dialect, type) {
+  if (dialect === "sqlite") return "";
+  return type === "text" ? ' TEXT COLLATE "C"' : " DOUBLE PRECISION";
+}
+function toSqlScalar(v) {
+  if (v === null || v === void 0) return null;
+  if (typeof v === "boolean") return v ? 1 : 0;
+  if (typeof v === "number" || typeof v === "string") return v;
+  return JSON.stringify(v);
+}
+function validateKey(key) {
+  const scalar = (v) => typeof v === "string" || typeof v === "number" && Number.isFinite(v);
+  if (!scalar(key) && !(Array.isArray(key) && key.length > 0 && key.every(scalar))) {
+    throw new StorageError(400, "key must be a string, finite number, or non-empty scalar tuple");
+  }
+}
+function validateRange(range) {
+  if (range === void 0) return;
+  if (range === null || typeof range !== "object" || Array.isArray(range)) {
+    throw new StorageError(400, "range must be an object");
+  }
+  for (const key of [range.only, range.lower, range.upper]) {
+    if (key !== void 0) validateKey(key);
+  }
+  for (const open of [range.lowerOpen, range.upperOpen]) {
+    if (open !== void 0 && typeof open !== "boolean") {
+      throw new StorageError(400, "range open flags must be boolean");
+    }
+  }
+}
+function toParts(key) {
+  validateKey(key);
+  return Array.isArray(key) ? key : [key];
+}
+function arrayPart(value, dotted) {
+  let cur = value;
+  for (const part of dotted.split(".")) {
+    if (cur === null || typeof cur !== "object") return void 0;
+    const row = cur;
+    cur = row[part];
+  }
+  return Array.isArray(cur) ? cur : void 0;
+}
+function requireKey(def, value) {
+  const parts = def.keyPath.map((p) => extractKeyPart(value, p));
+  for (const [i, part] of parts.entries()) {
+    if (part === void 0) {
+      throw new StorageError(400, `keyPath part '${def.keyPath[i]}' missing on ${def.name} value`);
+    }
+  }
+  const key = parts;
+  return key.length === 1 ? key[0] : key;
+}
+function rangeWhere(cols, range, params) {
+  if (!range) return "";
+  if (range.only !== void 0) {
+    const parts = toParts(range.only);
+    if (parts.length > cols.length) return null;
+    const clauses2 = parts.map((p, i) => {
+      params.push(toSqlScalar(p));
+      return `"${cols[i]}" = ?`;
+    });
+    return ` WHERE ${clauses2.join(" AND ")}`;
+  }
+  const bounds = [];
+  if (range.lower !== void 0 && range.lower !== null) {
+    bounds.push([toParts(range.lower), range.lowerOpen ? ">" : ">="]);
+  }
+  if (range.upper !== void 0 && range.upper !== null) {
+    bounds.push([toParts(range.upper), range.upperOpen ? "<" : "<="]);
+  }
+  const clauses = [];
+  for (const [parts, op] of bounds) {
+    if (parts.length > cols.length) return null;
+    if (parts.length === 1) {
+      params.push(toSqlScalar(parts[0]));
+      clauses.push(`"${cols[0]}" ${op} ?`);
+    } else {
+      const ors = parts.map((p, i) => {
+        const eqs = [];
+        for (let j = 0; j < i; j++) {
+          params.push(toSqlScalar(parts[j]));
+          eqs.push(`"${cols[j]}" = ?`);
+        }
+        params.push(toSqlScalar(p));
+        const cmpOp = i === parts.length - 1 ? op : op[0];
+        eqs.push(`"${cols[i]}" ${cmpOp} ?`);
+        return `(${eqs.join(" AND ")})`;
+      });
+      clauses.push(`(${ors.join(" OR ")})`);
+    }
+  }
+  return clauses.length ? ` WHERE ${clauses.join(" AND ")}` : "";
+}
+function clampLimit(count) {
+  if (count === void 0) return void 0;
+  if (typeof count !== "number" || !Number.isFinite(count)) {
+    throw new StorageError(400, `invalid count: ${String(count)}`);
+  }
+  return Math.max(0, Math.floor(count));
+}
+var limitClause = (count) => count === void 0 ? "" : ` LIMIT ${clampLimit(count)}`;
+function parseRows(rows, binaryField) {
+  return rows.map((r) => decodeRowJson(r.data, binaryField));
+}
+async function scanRows(conn, def, idx, range, limit) {
+  const rows = await conn.query(`SELECT "data" FROM "${def.name}"`);
+  const keyed = [];
+  for (const row of rows) {
+    const value = decodeRowJson(row.data, binaryFieldOf(def));
+    if (idx) {
+      const parts = idx.keyPath.map((p) => extractKeyPart(value, p));
+      if (!parts.every((p) => p !== void 0)) continue;
+      const key = parts.length === 1 ? parts[0] : parts;
+      if (range && !keyInRange(key, range)) continue;
+      keyed.push([key, value]);
+    } else {
+      const key = requireKey(def, value);
+      if (range && !keyInRange(key, range)) continue;
+      keyed.push([key, value]);
+    }
+  }
+  keyed.sort((a, b) => compareKeys(a[0], b[0]));
+  const out = keyed.map(([, v]) => v);
+  return limit === void 0 ? out : out.slice(0, limit);
+}
+async function getRow(conn, def, key) {
+  const parts = toParts(key);
+  if (parts.length !== def.keyPath.length) {
+    throw new StorageError(400, `key arity ${parts.length} != keyPath arity ${def.keyPath.length} for ${def.name}`);
+  }
+  const cond = keyCols(def).map((c) => `"${c}" = ?`).join(" AND ");
+  const rows = await conn.query(
+    `SELECT "data" FROM "${def.name}" WHERE ${cond}`,
+    parts.map(toSqlScalar)
+  );
+  return rows[0] ? decodeRowJson(rows[0].data, binaryFieldOf(def)) : void 0;
+}
+async function listRows(conn, def, range, count, indexName) {
+  validateRange(range);
+  const idx = indexName ? indexDefinition(def, indexName) : void 0;
+  const binaryField = binaryFieldOf(def);
+  if (idx?.multiEntry) {
+    const only = range?.only;
+    if (only === void 0 || typeof only === "object") {
+      throw new StorageError(400, `multi-entry index ${def.name}.${idx.name} supports exact-match queries only`);
+    }
+    const joinOn = keyCols(def).map((c) => `j."${c}" = e."${c}"`).join(" AND ");
+    const order2 = ['j."v"', ...keyCols(def).map((c) => `j."${c}"`)].join(", ");
+    const rows2 = await conn.query(
+      `SELECT e."data" AS "data" FROM "${def.name}" e JOIN "${junctionTable(def, idx)}" j ON ${joinOn} WHERE j."v" = ? ORDER BY ${order2}${limitClause(count)}`,
+      [JSON.stringify(only)]
+    );
+    return parseRows(rows2, binaryField);
+  }
+  const cols = idx ? idx.keyPath.map((_, part) => indexCol(idx.name, part)) : keyCols(def);
+  const params = [];
+  const where = rangeWhere(cols, range, params);
+  if (where === null) return scanRows(conn, def, idx, range, clampLimit(count));
+  const notNull = cols.map((c) => `"${c}" IS NOT NULL`).join(" AND ");
+  const cond = where ? `${where} AND ${notNull}` : ` WHERE ${notNull}`;
+  const keyNames = keyCols(def).filter((k) => !cols.includes(k));
+  const order = ` ORDER BY ${[...cols, ...keyNames].map((c) => `"${c}"`).join(", ")}`;
+  const rows = await conn.query(
+    `SELECT "data" FROM "${def.name}"${cond}${order}${limitClause(count)}`,
+    params
+  );
+  return parseRows(rows, binaryField);
+}
+async function countRows(conn, def, range, indexName) {
+  validateRange(range);
+  const idx = indexName ? indexDefinition(def, indexName) : void 0;
+  if (idx?.multiEntry) {
+    const only = range?.only;
+    if (only === void 0 || typeof only === "object") {
+      throw new StorageError(400, `multi-entry index ${def.name}.${idx.name} supports exact-match queries only`);
+    }
+    const joinOn = keyCols(def).map((c) => `j."${c}" = e."${c}"`).join(" AND ");
+    const rows2 = await conn.query(
+      `SELECT COUNT(*) AS "n" FROM "${def.name}" e JOIN "${junctionTable(def, idx)}" j ON ${joinOn} WHERE j."v" = ?`,
+      [JSON.stringify(only)]
+    );
+    return Number(rows2[0]?.n ?? 0);
+  }
+  const cols = idx ? idx.keyPath.map((_, part) => indexCol(idx.name, part)) : keyCols(def);
+  const params = [];
+  const where = rangeWhere(cols, range, params);
+  if (where === null) {
+    const all = await scanRows(conn, def, idx, range, void 0);
+    return all.length;
+  }
+  const cond = idx ? where ? `${where} AND ${cols.map((c) => `"${c}" IS NOT NULL`).join(" AND ")}` : ` WHERE ${cols.map((c) => `"${c}" IS NOT NULL`).join(" AND ")}` : where;
+  const rows = await conn.query(`SELECT COUNT(*) AS "n" FROM "${def.name}"${cond}`, params);
+  return Number(rows[0]?.n ?? 0);
+}
+async function putRow(conn, def, value) {
+  const key = requireKey(def, value);
+  const keyParts = toParts(key).map(toSqlScalar);
+  const keys = keyCols(def);
+  const cols = [...keys];
+  const vals = [...keyParts];
+  for (const idx of def.indexes) {
+    if (idx.multiEntry) continue;
+    idx.keyPath.forEach((path, part) => {
+      cols.push(indexCol(idx.name, part));
+      vals.push(toSqlScalar(extractKeyPart(value, path) ?? null));
+    });
+  }
+  cols.push("data");
+  vals.push(encodeRowJson(value, binaryFieldOf(def)));
+  const keySet = new Set(keys);
+  const updates = cols.filter((c) => !keySet.has(c)).map((c) => `"${c}" = excluded."${c}"`).join(", ");
+  const collist = cols.map((c) => `"${c}"`).join(", ");
+  const placeholders = cols.map(() => "?").join(", ");
+  const pk = keys.map((k) => `"${k}"`).join(", ");
+  await conn.exec(
+    `INSERT INTO "${def.name}" (${collist}) VALUES (${placeholders}) ON CONFLICT (${pk}) DO UPDATE SET ${updates}`,
+    vals
+  );
+  const multi = multiEntryIndex(def);
+  if (multi) {
+    const jt = junctionTable(def, multi);
+    const cond = keys.map((c) => `"${c}" = ?`).join(" AND ");
+    await conn.exec(`DELETE FROM "${jt}" WHERE ${cond}`, keyParts);
+    const items = arrayPart(value, multi.keyPath[0]);
+    if (Array.isArray(items)) {
+      const jcols = [...keys, "v"];
+      const jcollist = jcols.map((c) => `"${c}"`).join(", ");
+      const jph = jcols.map(() => "?").join(", ");
+      for (const item of items) {
+        await conn.exec(
+          `INSERT INTO "${jt}" (${jcollist}) VALUES (${jph}) ON CONFLICT DO NOTHING`,
+          [...keyParts, JSON.stringify(item)]
+        );
+      }
+    }
+  }
+  return key;
+}
+async function deleteRows(conn, def, keyOrRange) {
+  const multi = multiEntryIndex(def);
+  if (!isRange(keyOrRange)) {
+    const parts = toParts(keyOrRange);
+    if (parts.length > def.keyPath.length) {
+      throw new StorageError(400, `key arity ${parts.length} > keyPath arity ${def.keyPath.length} for ${def.name}`);
+    }
+    const n = Math.min(parts.length, def.keyPath.length);
+    const cond = keyCols(def).slice(0, n).map((c) => `"${c}" = ?`).join(" AND ");
+    const params2 = parts.slice(0, n).map(toSqlScalar);
+    if (multi) await conn.exec(`DELETE FROM "${junctionTable(def, multi)}" WHERE ${cond}`, params2);
+    await conn.exec(`DELETE FROM "${def.name}" WHERE ${cond}`, params2);
+    return;
+  }
+  validateRange(keyOrRange);
+  const cols = keyCols(def);
+  const params = [];
+  const where = rangeWhere(cols, keyOrRange, params);
+  if (where === null) {
+    for (const row of await listRows(conn, def, keyOrRange)) {
+      await deleteRows(conn, def, requireKey(def, row));
+    }
+    return;
+  }
+  const collist = cols.map((c) => `"${c}"`).join(", ");
+  if (multi) {
+    await conn.exec(
+      `DELETE FROM "${junctionTable(def, multi)}" WHERE (${collist}) IN (SELECT ${collist} FROM "${def.name}"${where})`,
+      params
+    );
+  }
+  await conn.exec(`DELETE FROM "${def.name}"${where}`, params);
+}
+async function clearRows(conn, def) {
+  const multi = multiEntryIndex(def);
+  if (multi) await conn.exec(`DELETE FROM "${junctionTable(def, multi)}"`);
+  await conn.exec(`DELETE FROM "${def.name}"`);
+}
+async function wipeRows(conn) {
+  for (const def of STORE_DEFS) {
+    if (!def.system) await clearRows(conn, def);
+  }
+}
+function tableListSql(dialect) {
+  return dialect === "sqlite" ? `SELECT "name" FROM "sqlite_master" WHERE "type" = 'table'` : `SELECT "table_name" FROM "information_schema"."tables" WHERE "table_schema" = current_schema()`;
+}
+async function ensureStoreTables(conn, dialect, def) {
+  const keys = keyCols(def);
+  const cols = keys.map((k, i) => [k, colSql(dialect, pathType(def, def.keyPath[i]))]);
+  for (const idx of def.indexes) {
+    if (idx.multiEntry) continue;
+    idx.keyPath.forEach((path, part) => {
+      cols.push([indexCol(idx.name, part), colSql(dialect, pathType(def, path))]);
+    });
+  }
+  cols.push(["data", " TEXT NOT NULL"]);
+  const colDefs = cols.map(([c, t]) => `"${c}"${t}`);
+  await conn.exec(
+    `CREATE TABLE IF NOT EXISTS "${def.name}" (${colDefs.join(", ")}, PRIMARY KEY (${keys.map((k) => `"${k}"`).join(", ")}))`
+  );
+  for (const idx of def.indexes) {
+    if (idx.multiEntry) continue;
+    const parts = idx.keyPath.map((_, part) => `"${indexCol(idx.name, part)}"`).join(", ");
+    await conn.exec(
+      `CREATE ${idx.unique ? "UNIQUE " : ""}INDEX IF NOT EXISTS "${def.name}__${sanitize(idx.name)}" ON "${def.name}" (${parts})`
+    );
+  }
+  const multi = multiEntryIndex(def);
+  if (multi) {
+    const jt = junctionTable(def, multi);
+    const jkeys = keys.map((k, i) => `"${k}"${colSql(dialect, pathType(def, def.keyPath[i]))}`);
+    await conn.exec(
+      `CREATE TABLE IF NOT EXISTS "${jt}" (${jkeys.join(", ")}, "v"${colSql(dialect, "text")}, PRIMARY KEY (${[...keys, '"v"'].join(", ")}))`
+    );
+    await conn.exec(`CREATE INDEX IF NOT EXISTS "${jt}__v" ON "${jt}" ("v")`);
+  }
+}
+async function initializeStore(db) {
+  await db.transaction(async (tx) => {
+    await tx.exec(
+      `CREATE TABLE IF NOT EXISTS "${SCHEMA_TABLE}" ("key" TEXT PRIMARY KEY, "value" TEXT NOT NULL)`
+    );
+    const storeTables = new Set(STORE_DEFS.map((d) => d.name));
+    const tableNames = new Set(
+      (await tx.query(tableListSql(db.dialect))).map((r) => String(Object.values(r)[0]))
+    );
+    const guardRows = await tx.query(`SELECT "value" FROM "${SCHEMA_TABLE}" WHERE "key" = ?`, [SCHEMA_KEY]);
+    let stored;
+    if (guardRows[0]) {
+      const guard = JSON.parse(String(guardRows[0].value));
+      if (typeof guard.version !== "number") {
+        throw new StorageError(500, `corrupt ${SCHEMA_TABLE} guard row`, "bad_schema_guard");
+      }
+      stored = guard.version;
+      if (stored !== DB_VERSION) {
+        throw new StorageError(
+          500,
+          `database schema v${stored} does not match this server (v${DB_VERSION}); use a compatible server or migrate a backed-up database`,
+          "schema_incompatible"
+        );
+      }
+    } else if ([...tableNames].some((name) => storeTables.has(name))) {
+      throw new StorageError(
+        500,
+        "database contains store tables but no wod-wiki schema guard; refusing to adopt a foreign database \u2014 point SQLITE_PATH/DATABASE_URL at a fresh database",
+        "foreign_database"
+      );
+    }
+    for (const def of STORE_DEFS) await ensureStoreTables(tx, db.dialect, def);
+    if (stored !== DB_VERSION) {
+      await tx.exec(
+        `INSERT INTO "${SCHEMA_TABLE}" ("key", "value") VALUES (?, ?) ON CONFLICT ("key") DO UPDATE SET "value" = excluded."value"`,
+        [SCHEMA_KEY, JSON.stringify({ version: DB_VERSION })]
+      );
+    }
+  });
+}
+
+// src/domain.ts
+var DOMAIN_PROJECTION_VERSION = 1;
+var TABLES = ["domain_note", "query_block", "segment_head"];
+var PROJECTION_GUARD_KEY = "domain_projection";
+function sourceItem(row) {
+  const item = {};
+  for (const key of ["id", "noteId", "sourceId", "type", "seedOrigin", "seedChunkId", "sourcePath", "catalog"]) {
+    const value = row[key];
+    if (typeof value === "string") item[key] = value;
+    else if (value != null) throw new StorageError(400, `${key} must be a string`);
+  }
+  return item;
+}
+var num = (v) => typeof v === "number" && Number.isFinite(v) ? v : null;
+var text = (v) => typeof v === "string" ? v : null;
+var T = (v) => text(v) ?? null;
+var N = (v) => num(v) ?? 0;
+function ensureDdl(db) {
+  const n = db.dialect === "postgres" ? " DOUBLE PRECISION" : "";
+  const t = db.dialect === "postgres" ? ' TEXT COLLATE "C"' : " TEXT";
+  const ddl = [
+    `CREATE TABLE IF NOT EXISTS "domain_note" ("note_id"${t} PRIMARY KEY NOT NULL, "note_type"${t}, "catalog"${t}, "source_id"${t}, "source_path"${t}, "title"${t} NOT NULL, "created_at"${n} NOT NULL, "date"${n}, "text_search"${t} NOT NULL, "journal"${n} NOT NULL, "payload"${t} NOT NULL)`,
+    `CREATE INDEX IF NOT EXISTS "idx_domain_note_date" ON "domain_note" ("date", "note_id")`,
+    `CREATE INDEX IF NOT EXISTS "idx_domain_note_created" ON "domain_note" ("created_at", "note_id")`,
+    `CREATE INDEX IF NOT EXISTS "idx_domain_note_source_path" ON "domain_note" ("source_path")`,
+    `CREATE TABLE IF NOT EXISTS "query_block" ("occurrence_id"${t} PRIMARY KEY NOT NULL, "source_note_id"${t}, "parent_note_id"${t}, "content_id"${t}, "section_key"${t}, "ordinal"${n}, "data_type"${t}, "source_id"${t}, "source_path"${t}, "catalog"${t}, "effective_date"${n} NOT NULL, "created_at"${n} NOT NULL, "note_title"${t}, "normalized_text"${t} NOT NULL, "journal"${n} NOT NULL, "payload"${t} NOT NULL)`,
+    `CREATE INDEX IF NOT EXISTS "idx_query_block_type" ON "query_block" ("data_type", "effective_date", "occurrence_id")`,
+    `CREATE INDEX IF NOT EXISTS "idx_query_block_parent" ON "query_block" ("parent_note_id", "ordinal")`,
+    `CREATE INDEX IF NOT EXISTS "idx_query_block_content" ON "query_block" ("content_id")`,
+    `CREATE INDEX IF NOT EXISTS "idx_query_block_source_path" ON "query_block" ("source_path")`,
+    `CREATE INDEX IF NOT EXISTS "idx_query_block_source_note" ON "query_block" ("source_note_id")`,
+    `CREATE TABLE IF NOT EXISTS "segment_head" ("id"${t} PRIMARY KEY NOT NULL, "note_id"${t} NOT NULL, "current_version"${n} NOT NULL, "position"${n}, "search_text"${t} NOT NULL)`,
+    `CREATE INDEX IF NOT EXISTS "idx_segment_head_note" ON "segment_head" ("note_id", "id")`
+  ];
+  return db.transaction(async (tx) => {
+    for (const sql of ddl) await tx.exec(sql);
+  });
+}
+async function upsertDomainNote(conn, note) {
+  const id = text(note.id);
+  if (!id) return;
+  const source = sourceItem(note);
+  await conn.exec(
+    `INSERT INTO "domain_note" ("note_id","note_type","catalog","source_id","source_path","title","created_at","date","text_search","journal","payload")
+     VALUES (?,?,?,?,?,?,?,?,?,?,?)
+     ON CONFLICT ("note_id") DO UPDATE SET "note_type"=excluded."note_type","catalog"=excluded."catalog","source_id"=excluded."source_id",
+       "source_path"=excluded."source_path","title"=excluded."title","created_at"=excluded."created_at","date"=excluded."date",
+       "text_search"=excluded."text_search","journal"=excluded."journal","payload"=excluded."payload"`,
+    [
+      id,
+      T(note.type),
+      T(wodWikiWql.catalogOfItem(source)),
+      T(note.sourceId),
+      T(note.sourcePath),
+      T(note.title) ?? "",
+      N(note.createdAt),
+      num(note.date),
+      (text(note.title) ?? "").toLowerCase(),
+      wodWikiWql.sourceMatches(source, "journal") ? 1 : 0,
+      encodeRowJson(note)
+    ]
+  );
+}
+async function healQueryBlocksForNote(conn, note) {
+  const id = text(note.id);
+  if (!id) return;
+  const rows = await conn.query(
+    `SELECT "occurrence_id" FROM "query_block"
+     WHERE "source_note_id" = ? OR ("source_path" IS NOT NULL AND "source_path" = ?)`,
+    [id, T(note.sourcePath)]
+  );
+  for (const row of rows) await refreshBlock(conn, String(row.occurrence_id));
+}
+async function upsertSegmentHead(conn, id, head) {
+  await conn.exec(
+    `INSERT INTO "segment_head" ("id","note_id","current_version","position","search_text")
+     VALUES (?,?,?,?,?)
+     ON CONFLICT ("id") DO UPDATE SET "note_id"=excluded."note_id","current_version"=excluded."current_version",
+       "position"=excluded."position","search_text"=excluded."search_text"`,
+    [
+      id,
+      T(head.noteId) ?? "",
+      N(head.version),
+      // Local latest-segments order is position ?? createdAt — same fallback here.
+      num(head.position) ?? num(head.createdAt),
+      (text(head.rawContent) ?? "").toLowerCase()
+    ]
+  );
+}
+async function identityBy(conn, col, val) {
+  const rows = await conn.query(
+    `SELECT "note_id", "date", "created_at" FROM "domain_note" WHERE "${col}" = ?`,
+    [val]
+  );
+  return rows.map((r) => ({
+    note_id: String(r.note_id),
+    date: num(r.date),
+    created_at: num(r.created_at) ?? 0
+  }));
+}
+async function resolveParent(conn, block) {
+  const byPath = async (sp2) => {
+    const rows = await identityBy(conn, "source_path", sp2);
+    return rows.length === 1 ? rows[0] : void 0;
+  };
+  const nid = text(block.noteId);
+  if (nid) {
+    const rows = await identityBy(conn, "note_id", nid);
+    if (rows.length === 1) return rows[0];
+    if (rows.length > 1) return void 0;
+  }
+  const sp = text(block.sourcePath);
+  return sp ? byPath(sp) : void 0;
+}
+async function upsertQueryBlock(conn, block) {
+  const id = text(block.id);
+  if (!id) return;
+  const source = sourceItem(block);
+  const createdAt = N(block.createdAt);
+  const parent = await resolveParent(conn, block);
+  const effective = parent ? parent.date ?? parent.created_at : createdAt;
+  await conn.exec(
+    `INSERT INTO "query_block" ("occurrence_id","source_note_id","parent_note_id","content_id","section_key","ordinal",
+       "data_type","source_id","source_path","catalog","effective_date","created_at","note_title","normalized_text","journal","payload")
+     VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)
+     ON CONFLICT ("occurrence_id") DO UPDATE SET "source_note_id"=excluded."source_note_id","parent_note_id"=excluded."parent_note_id",
+       "content_id"=excluded."content_id","section_key"=excluded."section_key","ordinal"=excluded."ordinal",
+       "data_type"=excluded."data_type","source_id"=excluded."source_id","source_path"=excluded."source_path",
+       "catalog"=excluded."catalog","effective_date"=excluded."effective_date","created_at"=excluded."created_at",
+       "note_title"=excluded."note_title","normalized_text"=excluded."normalized_text","journal"=excluded."journal",
+       "payload"=excluded."payload"`,
+    [
+      id,
+      T(block.noteId),
+      parent?.note_id ?? null,
+      T(block.blockContentId),
+      T(block.segmentId),
+      num(block.position),
+      T(block.dataType),
+      T(block.sourceId),
+      T(block.sourcePath),
+      T(wodWikiWql.catalogOfItem(source)),
+      effective,
+      createdAt,
+      T(block.noteTitle),
+      (text(block.rawContent) ?? "").toLowerCase(),
+      wodWikiWql.sourceMatches(source, "journal") ? 1 : 0,
+      encodeRowJson(block)
+    ]
+  );
+}
+var keyHead = (key) => Array.isArray(key) ? key[0] : key;
+async function refreshNote(conn, id) {
+  const k = keyHead(id);
+  const rows = await conn.query(`SELECT "data" FROM "notes" WHERE "k0" = ?`, [k]);
+  const note = rows[0] ? decodeRowJson(String(rows[0].data)) : void 0;
+  if (note) {
+    await upsertDomainNote(conn, note);
+    await healQueryBlocksForNote(conn, note);
+  } else {
+    const orphans = await conn.query(
+      `SELECT "occurrence_id" FROM "query_block" WHERE "parent_note_id" = ? OR "source_note_id" = ?`,
+      [k, k]
+    );
+    await conn.exec(`DELETE FROM "domain_note" WHERE "note_id" = ?`, [k]);
+    for (const row of orphans) await refreshBlock(conn, String(row.occurrence_id));
+  }
+}
+async function refreshSegment(conn, id) {
+  const k = keyHead(id);
+  const rows = await conn.query(`SELECT "data" FROM "segments" WHERE "k0" = ?`, [k]);
+  let head;
+  let headVersion = -Infinity;
+  for (const row of rows) {
+    const seg = decodeRowJson(String(row.data));
+    const v = num(seg.version) ?? 0;
+    if (!head || v > headVersion) {
+      head = seg;
+      headVersion = v;
+    }
+  }
+  if (head) await upsertSegmentHead(conn, k, head);
+  else await conn.exec(`DELETE FROM "segment_head" WHERE "id" = ?`, [k]);
+}
+async function refreshBlock(conn, id) {
+  const k = keyHead(id);
+  const rows = await conn.query(`SELECT "data" FROM "block_index" WHERE "k0" = ?`, [k]);
+  if (rows[0]) await upsertQueryBlock(conn, decodeRowJson(String(rows[0].data)));
+  else await conn.exec(`DELETE FROM "query_block" WHERE "occurrence_id" = ?`, [k]);
+}
+var TRACKED = {
+  notes: "notes",
+  segments: "segments",
+  block_index: "blocks"
+};
+async function deleteTargetKeys(conn, def, target) {
+  if (!isRange(target)) return [target];
+  const rows = await listRows(conn, def, target);
+  return rows.map((row) => keyFromValue(def, row));
+}
+async function refreshDomain(conn, ops, opts = {}) {
+  const impact = {
+    notes: [],
+    segments: [],
+    blocks: [],
+    notesClear: false,
+    segmentsClear: false,
+    blocksClear: false
+  };
+  const results = [];
+  for (const op of ops) {
+    if (op === null || typeof op !== "object" || Array.isArray(op)) {
+      throw new StorageError(400, "tx op must be an object");
+    }
+    const store = "store" in op ? op.store : void 0;
+    const def = storeDefinition(typeof store === "string" ? store : String(store));
+    const kind = typeof op.op === "string" ? op.op : void 0;
+    if (op.op === "put") {
+      const key = await putRow(conn, def, op.value);
+      const slot = TRACKED[def.name];
+      if (slot) impact[slot].push(key);
+      results.push(key);
+    } else if (op.op === "delete") {
+      const slot = TRACKED[def.name];
+      if (slot) {
+        for (const key of await deleteTargetKeys(conn, def, op.key)) impact[slot].push(key);
+      }
+      await deleteRows(conn, def, op.key);
+      results.push(null);
+    } else if (op.op === "clear") {
+      await clearRows(conn, def);
+      if (def.name === "notes") impact.notesClear = true;
+      else if (def.name === "segments") impact.segmentsClear = true;
+      else if (def.name === "block_index") impact.blocksClear = true;
+      results.push(null);
+    } else {
+      throw new StorageError(400, `tx op must be put | delete | clear, got: ${String(kind)}`);
+    }
+  }
+  if (!opts.deferProjection) await refresh(conn, impact);
+  return results;
+}
+async function refresh(conn, impact) {
+  if (impact.notesClear) {
+    await conn.exec(`DELETE FROM "domain_note"`);
+    await conn.exec(`UPDATE "query_block" SET "parent_note_id" = NULL`);
+  }
+  if (impact.segmentsClear) await conn.exec(`DELETE FROM "segment_head"`);
+  if (impact.blocksClear) await conn.exec(`DELETE FROM "query_block"`);
+  for (const id of impact.notes) await refreshNote(conn, id);
+  for (const key of impact.segments) await refreshSegment(conn, key);
+  for (const id of impact.blocks) await refreshBlock(conn, id);
+}
+async function rebuildProjections(conn) {
+  await conn.exec(
+    `CREATE TABLE IF NOT EXISTS "${SCHEMA_TABLE}" ("key" TEXT PRIMARY KEY, "value" TEXT NOT NULL)`
+  );
+  for (const t of TABLES) await conn.exec(`DELETE FROM "${t}"`);
+  const notes = await conn.query(`SELECT "data" FROM "notes"`);
+  for (const row of notes) await upsertDomainNote(conn, decodeRowJson(String(row.data)));
+  const segments = await conn.query(`SELECT "k0", "data" FROM "segments"`);
+  const heads = /* @__PURE__ */ new Map();
+  for (const row of segments) {
+    const seg = decodeRowJson(String(row.data));
+    const v = num(seg.version) ?? 0;
+    const prev = heads.get(String(row.k0));
+    if (!prev || v > prev.version) heads.set(String(row.k0), { id: row.k0, row: seg, version: v });
+  }
+  for (const head of heads.values()) await upsertSegmentHead(conn, head.id, head.row);
+  const blocks = await conn.query(`SELECT "data" FROM "block_index"`);
+  for (const row of blocks) await upsertQueryBlock(conn, decodeRowJson(String(row.data)));
+  await conn.exec(
+    `INSERT INTO "${SCHEMA_TABLE}" ("key", "value") VALUES (?, ?) ON CONFLICT ("key") DO UPDATE SET "value" = excluded."value"`,
+    [PROJECTION_GUARD_KEY, JSON.stringify({ version: DOMAIN_PROJECTION_VERSION })]
+  );
+}
+async function initializeDomain(db) {
+  await ensureDdl(db);
+  await db.transaction(async (tx) => {
+    await tx.exec(
+      `CREATE TABLE IF NOT EXISTS "${SCHEMA_TABLE}" ("key" TEXT PRIMARY KEY, "value" TEXT NOT NULL)`
+    );
+    const guardRows = await tx.query(`SELECT "value" FROM "${SCHEMA_TABLE}" WHERE "key" = ?`, [PROJECTION_GUARD_KEY]);
+    let guard;
+    if (guardRows[0]) {
+      try {
+        guard = JSON.parse(String(guardRows[0].value));
+      } catch {
+        guard = void 0;
+      }
+    }
+    if (guard?.version === DOMAIN_PROJECTION_VERSION) return;
+    await rebuildProjections(tx);
+  });
+}
+async function wipeDomain(conn) {
+  for (const t of TABLES) await conn.exec(`DELETE FROM "${t}"`);
+}
+var MAX_BODY = 64 * 1024;
+var MAX_CLAUSES = 32;
+var MAX_VALUES = 64;
+var MAX_VALUE_LEN = 256;
+var MAX_ORDER = 4;
+var listFields = ["id", "noteId", "type", "catalog", "source", "tags", "effort"];
+var onlyKeys = (obj, allowed) => Object.keys(obj).every((k) => allowed.includes(k));
+function bad(msg) {
+  return new StorageError(400, msg);
+}
+function strArray(v, what) {
+  if (!Array.isArray(v) || v.length < 1 || v.length > MAX_VALUES) {
+    throw bad(`${what} needs 1..=${MAX_VALUES} values`);
+  }
+  return v.map((x) => {
+    if (typeof x !== "string" || x.length < 1 || x.length > MAX_VALUE_LEN) {
+      throw bad(`${what} values must be 1..=${MAX_VALUE_LEN} chars`);
+    }
+    return x;
+  });
+}
+function parsePredicate(v, plan) {
+  if (v === null || typeof v !== "object" || Array.isArray(v)) throw bad("predicate must be an object");
+  const obj = v;
+  const field = obj.field;
+  if (typeof field !== "string") throw bad("predicate.field required");
+  let negate = false;
+  if ("negate" in obj) {
+    if (typeof obj.negate !== "boolean") throw bad("predicate.negate must be boolean");
+    negate = obj.negate;
+  }
+  if (listFields.includes(field)) {
+    if (!onlyKeys(obj, ["field", "values", "negate"])) {
+      throw bad(`predicate ${field} accepts only field/values/negate`);
+    }
+    return { field, values: strArray(obj.values, `predicate ${field}.values`), ...negate ? { negate } : {} };
+  }
+  if (field === "text") {
+    if (!onlyKeys(obj, ["field", "value"]) || negate) throw bad("predicate text accepts only {field, value}");
+    if (typeof obj.value !== "string" || obj.value.length < 1 || obj.value.length > MAX_VALUE_LEN) {
+      throw bad("predicate text.value must be 1..=256 chars");
+    }
+    return { field: "text", value: obj.value };
+  }
+  if (field === "date") {
+    if (!onlyKeys(obj, ["field", "start", "end", "endExclusive"])) {
+      throw bad("predicate date accepts only field/start/end/endExclusive");
+    }
+    const n = (k) => {
+      if (typeof obj[k] !== "number" || !Number.isFinite(obj[k])) throw bad(`predicate date.${k} must be a finite number`);
+      return obj[k];
+    };
+    if ("endExclusive" in obj && typeof obj.endExclusive !== "boolean") {
+      throw bad("predicate date.endExclusive must be boolean");
+    }
+    return { field: "date", start: n("start"), end: n("end"), ...obj.endExclusive === true ? { endExclusive: true } : {} };
+  }
+  if (field === "page") {
+    if (plan === "blocks") throw bad("predicate page does not apply to the blocks plan");
+    if (!onlyKeys(obj, ["field", "value"])) throw bad("predicate page accepts only {field, value}");
+    if (typeof obj.value !== "boolean") throw bad("predicate page.value must be boolean");
+    return { field: "page", value: obj.value };
+  }
+  if (field === "sourceFence") {
+    if (!onlyKeys(obj, ["field"])) throw bad("predicate sourceFence accepts only {field}");
+    return { field: "sourceFence" };
+  }
+  if (field === "defaultNotes") {
+    if (plan === "blocks") throw bad("predicate defaultNotes does not apply to the blocks plan");
+    if (!onlyKeys(obj, ["field", "feeds"])) throw bad("predicate defaultNotes accepts only {field, feeds}");
+    if (typeof obj.feeds !== "boolean") throw bad("predicate defaultNotes.feeds must be boolean");
+    return { field: "defaultNotes", feeds: obj.feeds };
+  }
+  throw bad(`unknown predicate field: ${field}`);
+}
+function parseClauses(v, plan, what) {
+  if (v === void 0) return [];
+  if (!Array.isArray(v)) throw bad(`${what} must be an array`);
+  if (v.length > MAX_CLAUSES) throw bad(`${what} supports at most ${MAX_CLAUSES} clauses`);
+  return v.map((p) => parsePredicate(p, plan));
+}
+function orderCols(field, plan) {
+  if (field === "id" || field === "createdAt") return field;
+  if (plan === "blocks") {
+    if (field === "noteTitle" || field === "dataType" || field === "position") return field;
+    throw bad(field === "date" || field === "title" ? `order ${field} does not apply to the blocks plan` : `unknown order field: ${field}`);
+  }
+  if (field === "date" || field === "title") return field;
+  throw bad(
+    field === "noteTitle" || field === "dataType" || field === "position" ? `order ${field} only applies to the blocks plan` : `unknown order field: ${field}`
+  );
+}
+function parseQuery(body) {
+  if (body === null || typeof body !== "object" || Array.isArray(body)) throw bad("body must be a DomainQuery object");
+  const obj = body;
+  const plan = obj.plan;
+  if (plan !== "notes" && plan !== "blocks" && plan !== "entries") {
+    throw bad("body.plan must be notes | blocks | entries");
+  }
+  for (const k of Object.keys(obj)) {
+    if (!["plan", "selection", "filters", "order", "offset", "limit"].includes(k)) {
+      throw bad(`unknown DomainQuery field: ${k}`);
+    }
+  }
+  const order = [];
+  if (obj.order !== void 0) {
+    if (!Array.isArray(obj.order)) throw bad("order must be an array");
+    if (obj.order.length > MAX_ORDER) throw bad(`order supports at most ${MAX_ORDER} keys`);
+    for (const entry of obj.order) {
+      if (entry === null || typeof entry !== "object" || Array.isArray(entry)) throw bad("order entries must be objects");
+      const e = entry;
+      if (typeof e.field !== "string") throw bad("order.field required");
+      if (!onlyKeys(e, ["field", "direction"])) throw bad("order entries accept only field/direction");
+      if (e.direction !== void 0 && e.direction !== "asc" && e.direction !== "desc") {
+        throw bad("order.direction must be asc | desc");
+      }
+      order.push({ field: orderCols(e.field, plan), desc: e.direction === "desc" });
+    }
+  }
+  const intIn = (k) => {
+    const v = obj[k];
+    if (v === void 0 || v === null) return void 0;
+    if (typeof v !== "number" || !Number.isInteger(v)) throw bad(`${k} must be an integer`);
+    if (v < 0) throw bad(`${k} must be >= 0`);
+    return v;
+  };
+  return {
+    plan,
+    selection: parseClauses(obj.selection, plan, "selection"),
+    filters: parseClauses(obj.filters, plan, "filters"),
+    order,
+    offset: intIn("offset") ?? 0,
+    limit: intIn("limit")
+  };
+}
+var Sql = class {
+  constructor(pg) {
+    this.pg = pg;
+  }
+  pg;
+  params = [];
+  bind(v) {
+    this.params.push(v);
+    return "?";
+  }
+  /** Literal substring over a lowercased materialized column — no wildcards. */
+  contains(col, needle) {
+    const p = this.bind(needle.toLowerCase());
+    return this.pg ? `strpos(${col}, ${p}) > 0` : `instr(${col}, ${p}) > 0`;
+  }
+  inList(col, values) {
+    return `${col} IN (${values.map((v) => this.bind(v)).join(", ")})`;
+  }
+};
+var SOURCE_ALL_KINDS = ["journal", "feeds", "guides", "playground", "dashboards", "efforts"];
+function sourceKindSql(ctx, kind, sid, typeExpr, journalCol) {
+  switch (kind) {
+    case "journal":
+      return `(${journalCol} = 1)`;
+    case "feed":
+    case "feeds":
+      return `(substr(${sid}, 1, 11) = 'collection:' OR substr(${sid}, 1, 16) = 'page:collection:')`;
+    case "page":
+    case "pages":
+      return `(${sid} = 'page' OR substr(${sid}, 1, 5) = 'page:' OR substr(${sid}, 1, 7) = 'guides:')`;
+    case "guide":
+    case "guides":
+      return `(substr(${sid}, 1, 7) = 'guides:')`;
+    case "playground":
+      return typeExpr ? `(${sid} = 'playground' OR (${typeExpr} IS NOT NULL AND ${typeExpr} = 'playground'))` : `(${sid} = 'playground')`;
+    default:
+      return `(${sid} = ${ctx.bind(kind)})`;
+  }
+}
+function sourcePredicateSql(ctx, values, negate, sid, typeExpr, journalCol) {
+  const matched = values.map((v) => sourceKindSql(ctx, v, sid, typeExpr, journalCol)).join(" OR ");
+  return negate ? `NOT COALESCE((${matched}), FALSE)` : matched;
+}
+var wrap = (negate, matchSql) => negate ? `NOT COALESCE ((${matchSql}), FALSE)` : matchSql;
+function predicateSql(ctx, p, plan) {
+  const blocks = plan === "blocks";
+  const id = blocks ? 'q."occurrence_id"' : 'n."note_id"';
+  const sid = blocks ? 'q."source_id"' : 'n."source_id"';
+  const typeExpr = blocks ? null : 'n."note_type"';
+  const typeCol = blocks ? 'q."data_type"' : 'n."note_type"';
+  const catalogCol = blocks ? 'q."catalog"' : 'n."catalog"';
+  const journalCol = blocks ? 'q."journal"' : 'n."journal"';
+  const noteId = blocks ? 'q."source_note_id"' : 'n."note_id"';
+  switch (p.field) {
+    case "id":
+      return wrap(p.negate === true, ctx.inList(id, p.values));
+    case "noteId":
+      return wrap(p.negate === true, ctx.inList(noteId, p.values));
+    case "type":
+      return wrap(p.negate === true, ctx.inList(typeCol, p.values));
+    case "catalog":
+      return wrap(p.negate === true, ctx.inList(catalogCol, p.values));
+    case "source":
+      return sourcePredicateSql(ctx, p.values, p.negate === true, sid, typeExpr, journalCol);
+    case "tags":
+      return wrap(
+        p.negate === true,
+        `EXISTS (SELECT 1 FROM "note_tags" nt JOIN "tags" t ON t."k0" = nt."i_by_tag_0" WHERE nt."i_by_note_0" = ${noteId} AND t."i_by_label_0" IN (${p.values.map((v) => ctx.bind(v)).join(", ")}))`
+      );
+    case "effort":
+      return wrap(
+        p.negate === true,
+        blocks ? `(q."content_id" IS NOT NULL AND EXISTS (SELECT 1 FROM "block_efforts" be WHERE be."i_by_block_0" = q."content_id" AND be."i_by_effort_0" IN (${p.values.map((v) => ctx.bind(v)).join(", ")})))` : `EXISTS (SELECT 1 FROM "block_efforts" be WHERE be."i_by_note_0" = ${noteId} AND be."i_by_effort_0" IN (${p.values.map((v) => ctx.bind(v)).join(", ")}))`
+      );
+    case "text": {
+      const textCol = blocks ? 'q."normalized_text"' : 'n."text_search"';
+      const title = ctx.contains(textCol, p.value);
+      if (plan !== "entries") return title;
+      const body = ctx.contains('h."search_text"', p.value);
+      return `(${title} OR EXISTS (SELECT 1 FROM "segment_head" h JOIN "segments" s ON s."k0" = h."id" AND s."k1" = h."current_version" WHERE h."note_id" = ${noteId} AND COALESCE(s."i_by_history_0", 0) = 0 AND ${body}))`;
+    }
+    case "date": {
+      const expr = blocks ? 'q."effective_date"' : 'COALESCE(n."date", n."created_at")';
+      const lo = ctx.bind(p.start);
+      const hi = ctx.bind(p.end);
+      const cmp = p.endExclusive ? "<" : "<=";
+      return `(${expr} >= ${lo} AND ${expr} ${cmp} ${hi})`;
+    }
+    case "page":
+      return p.value ? `n."note_type" = 'page'` : `(n."note_type" IS NULL OR n."note_type" <> 'page')`;
+    case "sourceFence": {
+      const all = SOURCE_ALL_KINDS.map((k) => sourceKindSql(ctx, k, sid, typeExpr, journalCol)).join(" OR ");
+      return `(${sid} IS NULL OR ${sid} = '' OR ${all})`;
+    }
+    case "defaultNotes":
+      return p.feeds ? `(n."note_type" IS NULL OR n."note_type" <> 'page')` : `(n."note_type" = 'note' OR (substr(COALESCE(n."source_id", ''), 1, 5) <> 'page:' AND substr(COALESCE(n."source_id", ''), 1, 7) <> 'guides:' AND COALESCE(n."note_type", '') NOT IN ('feed','syntax','behavior','analytics','dashboard','home','page')))`;
+  }
+}
+function clausesSql(ctx, clauses, plan) {
+  if (clauses.length === 0) return "";
+  return ` WHERE ${clauses.map((p) => predicateSql(ctx, p, plan)).join(" AND ")}`;
+}
+function orderSql(order, plan) {
+  const idCol = plan === "blocks" ? 'q."occurrence_id"' : 'n."note_id"';
+  const cols = plan === "blocks" ? { id: 'q."occurrence_id"', createdAt: 'q."created_at"', noteTitle: 'q."note_title"', dataType: 'q."data_type"', position: 'q."ordinal"' } : { id: 'n."note_id"', createdAt: 'n."created_at"', date: 'n."date"', title: 'n."title"' };
+  const parts = order.map(
+    ({ field, desc }) => desc ? `${cols[field]} DESC NULLS FIRST` : `${cols[field]} ASC NULLS LAST`
+  );
+  if (!order.some((o) => o.field === "id")) parts.push(`${idCol} ASC`);
+  return parts.join(", ");
+}
+function pagingSql(q, pg) {
+  let s = "";
+  if (q.limit !== void 0) s += ` LIMIT ${q.limit}`;
+  else if (q.offset > 0 && !pg) s += " LIMIT -1";
+  if (q.offset > 0) s += ` OFFSET ${q.offset}`;
+  return s;
+}
+async function gate(conn) {
+  const rows = await conn.query(`SELECT COUNT(*) AS "n" FROM "query_block" WHERE "parent_note_id" IS NULL`);
+  const stale = Number(rows[0]?.n ?? 0);
+  if (stale > 0) {
+    throw new StorageError(
+      409,
+      `domain projections stale: ${stale} block rows have unresolved static parents`,
+      "domain_projection_unavailable"
+    );
+  }
+}
+function planTable(plan) {
+  return plan === "blocks" ? '"query_block" q' : '"domain_note" n';
+}
+async function execute(conn, q, pg) {
+  const plan = q.plan;
+  const table = planTable(plan);
+  const selCtx = new Sql(pg);
+  const selWhere = clausesSql(selCtx, q.selection, plan);
+  const filterCtx = new Sql(pg);
+  const filterWhere = clausesSql(filterCtx, q.filters, plan);
+  const allParams = [...selCtx.params, ...filterCtx.params];
+  const fullWhere = selWhere && filterWhere ? `${selWhere} AND ${filterWhere.replace(/^ WHERE /, "")}` : selWhere || filterWhere;
+  const count = async (where, params) => Number((await conn.query(`SELECT COUNT(*) AS "n" FROM ${table}${where}`, params))[0]?.n ?? 0);
+  const selectedCount = await count(selWhere, selCtx.params);
+  const matchedCount = await count(fullWhere, allParams);
+  const ordering = orderSql(q.order, plan);
+  const paging = pagingSql(q, pg);
+  if (plan !== "entries") {
+    const pageSql2 = `SELECT "payload" FROM ${table}${fullWhere} ORDER BY ${ordering}${paging}`;
+    const rows2 = (await conn.query(pageSql2, allParams)).map((r) => decodeRowJson(String(r.payload)));
+    const result2 = { projectionVersion: DOMAIN_PROJECTION_VERSION, selectedCount, matchedCount, plan, rows: rows2 };
+    return result2;
+  }
+  const pageSql = `SELECT "note_id", "payload" FROM ${table}${fullWhere} ORDER BY ${ordering}${paging}`;
+  const noteRows = await conn.query(pageSql, allParams);
+  const relations = [
+    `SELECT h."note_id" AS "note_id", s."data" AS "payload" FROM selected n
+     JOIN "segment_head" h ON h."note_id" = n."note_id"
+     JOIN "segments" s ON s."k0" = h."id" AND s."k1" = h."current_version"
+     WHERE COALESCE(s."i_by_history_0", 0) = 0
+     ORDER BY h."position" ASC NULLS LAST, s."k0"`,
+    `SELECT nt."i_by_note_0" AS "note_id", t."data" AS "payload" FROM selected n
+     JOIN "note_tags" nt ON nt."i_by_note_0" = n."note_id"
+     JOIN "tags" t ON t."k0" = nt."i_by_tag_0" ORDER BY t."k0"`,
+    `SELECT p."i_by_note_0" AS "note_id", p."data" AS "payload" FROM selected n
+     JOIN "page_notes" p ON p."i_by_note_0" = n."note_id" ORDER BY p."k0"`,
+    `SELECT DISTINCT p."i_by_note_0" AS "note_id", pg."data" AS "payload" FROM selected n
+     JOIN "page_notes" p ON p."i_by_note_0" = n."note_id"
+     JOIN "page" pg ON pg."k0" = p."i_by_page_0" ORDER BY pg."data"`
+  ];
+  const buckets = noteRows.map(() => [[], [], [], []]);
+  const index = /* @__PURE__ */ new Map();
+  noteRows.forEach((r, i) => index.set(String(r.note_id), i));
+  for (const [rel, relation] of relations.entries()) {
+    for (const row of await conn.query(`WITH selected AS (${pageSql}) ${relation}`, allParams)) {
+      const i = index.get(String(row.note_id));
+      if (i !== void 0) buckets[i][rel].push(decodeRowJson(String(row.payload)));
+    }
+  }
+  const rows = noteRows.map((r, i) => {
+    const [segments, tags, links, pages] = buckets[i];
+    return { note: decodeRowJson(String(r.payload)), segments, tags, links, pages };
+  });
+  const result = { projectionVersion: DOMAIN_PROJECTION_VERSION, selectedCount, matchedCount, plan, rows };
+  return result;
+}
+async function handleDomainQuery(db, body) {
+  const query = parseQuery(body);
+  return db.transaction(async (tx) => {
+    if (db.dialect === "postgres") await tx.exec("SET TRANSACTION ISOLATION LEVEL REPEATABLE READ READ ONLY");
+    await gate(tx);
+    return execute(tx, query, db.dialect === "postgres");
+  });
+}
+
+// src/membership.ts
+var USER_OWNED_STORES = [
+  "notes",
+  "page",
+  "page_notes",
+  "tags",
+  "tag_types",
+  "note_tags",
+  "segments",
+  "sessions",
+  "attachments",
+  "events",
+  "efforts",
+  "block_index",
+  "block_efforts"
+];
+var STAMPABLE = Object.fromEntries(
+  USER_OWNED_STORES.map((s) => [s, true])
+);
+function stampUserOwned(store, value, userId) {
+  if (!STAMPABLE[store]) return value;
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return value;
+  const row = value;
+  if (row.seedOrigin === "seed") return value;
+  if (row.userId === userId) return value;
+  return { ...row, userId };
+}
+
+// src/overlay.ts
+var bufferSlot = (store, key) => `${store}\0${JSON.stringify(key)}`;
+function isDirty(store, buffer, cleared) {
+  if (cleared?.has(store)) return true;
+  if (!buffer) return false;
+  const prefix = `${store}\0`;
+  for (const slot of buffer.keys()) {
+    if (slot.startsWith(prefix)) return true;
+  }
+  return false;
+}
+function bufferedGet(store, key, buffer) {
+  if (!buffer) return void 0;
+  const entry = buffer.get(bufferSlot(store, key));
+  if (!entry) return void 0;
+  return entry.kind === "put" ? { hit: true, value: entry.value } : { hit: false };
+}
+function overlayRows(def, store, buffer, cleared, rows, count, range, indexName) {
+  if (!buffer || !isDirty(store, buffer, cleared)) return count !== void 0 ? rows.slice(0, count) : rows;
+  const out = /* @__PURE__ */ new Map();
+  if (!cleared?.has(store)) {
+    for (const row of rows) out.set(JSON.stringify(keyFromValue(def, row)), row);
+  }
+  const prefix = `${store}\0`;
+  for (const [slot, entry] of buffer) {
+    if (!slot.startsWith(prefix)) continue;
+    if (entry.kind === "put") out.set(slot.slice(prefix.length), entry.value);
+    else out.delete(slot.slice(prefix.length));
+  }
+  const index = indexName ? def.indexes.find((i) => i.name === indexName) : void 0;
+  if (indexName && !index) throw new Error(`unknown index '${indexName}' for ${store}`);
+  const keyOf = (row) => {
+    if (!index) return keyFromValue(def, row);
+    const parts = index.keyPath.map((path) => extractKeyPart(row, path));
+    if (parts.some((part) => part === void 0)) return void 0;
+    const keys = parts.filter((part) => part !== void 0);
+    return keys.length === 1 ? keys[0] : keys;
+  };
+  const matches = (row) => {
+    if (index?.multiEntry) {
+      let values = row;
+      for (const part of index.keyPath[0].split(".")) {
+        if (values === null || typeof values !== "object" || !(part in values)) return false;
+        values = Reflect.get(values, part);
+      }
+      return Array.isArray(values) && values.some((value) => (typeof value === "string" || typeof value === "number") && (!range || keyInRange(value, range)));
+    }
+    const key = keyOf(row);
+    return key !== void 0 && (!range || keyInRange(key, range));
+  };
+  const merged = [...out.values()].filter(matches);
+  merged.sort((a, b) => {
+    const primary = compareKeys(keyFromValue(def, a), keyFromValue(def, b));
+    if (index?.multiEntry) return primary;
+    const ak = keyOf(a), bk = keyOf(b);
+    return ak !== void 0 && bk !== void 0 ? compareKeys(ak, bk) || primary : primary;
+  });
+  return count !== void 0 ? merged.slice(0, count) : merged;
+}
+function bufferToOps(storeNames, buffer, cleared) {
+  const known = new Set(storeNames);
+  const ops = [];
+  for (const store of cleared) {
+    if (known.has(store)) ops.push({ op: "clear", store });
+  }
+  for (const [slot, entry] of buffer) {
+    const sep = slot.indexOf("\0");
+    const store = slot.slice(0, sep);
+    if (!known.has(store)) continue;
+    if (entry.kind === "put") ops.push({ op: "put", store, value: entry.value });
+    else ops.push({ op: "delete", store, key: JSON.parse(slot.slice(sep + 1)) });
+  }
+  return ops;
+}
+var SqlStorage = class {
+  db;
+  options;
+  defs;
+  readyPromise;
+  constructor(db, options = {}) {
+    this.db = db;
+    this.options = options;
+    this.defs = Object.fromEntries(STORE_DEFS.map((d) => [d.name, d]));
+  }
+  /**
+   * Idempotent schema + projection initialization. Cheap when already
+   * compatible (both initializers are guard-protected); a failed attempt
+   * clears the memo so the next call retries instead of caching the error.
+   */
+  ready() {
+    this.readyPromise ??= (async () => {
+      try {
+        await initializeStore(this.db);
+        await initializeDomain(this.db);
+      } catch (e) {
+        this.readyPromise = void 0;
+        throw e;
+      }
+    })();
+    return this.readyPromise;
+  }
+  /** Every store operation starts here, so views created before (or during)
+   * an in-flight ready() block until initialization actually succeeded. */
+  ensureReady() {
+    return this.ready();
+  }
+  def(store) {
+    const def = this.defs[store];
+    if (!def) throw new StorageError(404, `SqlStorage: unknown store '${store}'`);
+    return def;
+  }
+  makeView(store, conn, mutable, buffer, cleared) {
+    return new SqlStore(this, this.def(store), store, conn, mutable, buffer, cleared);
+  }
+  readonly(store) {
+    return this.makeView(store, this.db, false);
+  }
+  readwrite(store) {
+    return this.makeView(store, this.db, true);
+  }
+  async queryDomain(query) {
+    await this.ensureReady();
+    try {
+      return await handleDomainQuery(this.db, query);
+    } catch (e) {
+      if (e instanceof StorageError && e.code === "domain_projection_unavailable") return void 0;
+      throw e;
+    }
+  }
+  async transaction(stores, mode, fn) {
+    await this.ensureReady();
+    return this.runTx(stores, mode === "readwrite", fn, false);
+  }
+  /**
+   * Bulk load for migration destinations: like transaction(), but the
+   * buffered writes skip per-key projection refresh and derived state is
+   * rebuilt once — everything inside one SQL transaction (throw → rollback).
+   */
+  async bulkTransaction(stores, fn) {
+    await this.ensureReady();
+    return this.runTx(stores, true, fn, true);
+  }
+  runTx(stores, mutableMode, fn, deferProjection) {
+    const scoped = new Set(stores);
+    const buffer = /* @__PURE__ */ new Map();
+    const cleared = /* @__PURE__ */ new Set();
+    return this.db.transaction(async (conn) => {
+      const checkScope = (store) => {
+        if (!scoped.has(store)) {
+          throw new StorageError(400, `store '${store}' is outside this transaction's scope`, "store_out_of_scope");
+        }
+      };
+      const tx = {
+        readonly: (store) => {
+          checkScope(store);
+          return this.makeView(store, conn, false, buffer, cleared);
+        },
+        readwrite: (store) => {
+          checkScope(store);
+          if (!mutableMode) {
+            throw new StorageError(403, "transaction was opened readonly", "read_only_transaction");
+          }
+          return this.makeView(store, conn, true, buffer, cleared);
+        }
+      };
+      const result = await fn(tx);
+      const ops = bufferToOps(STORE_DEFS.map((d) => d.name), buffer, cleared);
+      if (ops.length > 0) {
+        await refreshDomain(conn, ops, deferProjection ? { deferProjection: true } : {});
+        if (deferProjection) await rebuildProjections(conn);
+      }
+      return result;
+    });
+  }
+  /**
+   * Proves the backend accepts writes: one real INSERT into `meta` inside a
+   * transaction that is then deliberately rolled back — zero rows committed.
+   * A read-only backend, bad token or transport failure rejects here.
+   */
+  async verifyWritable() {
+    await this.ensureReady();
+    const sentinel = new Error("verifyWritable: deliberate rollback sentinel");
+    try {
+      await this.db.transaction(async (conn) => {
+        await putRow(conn, this.def("meta"), {
+          key: `__wodwiki_write_check_${crypto.randomUUID()}`,
+          value: ""
+        });
+        throw sentinel;
+      });
+    } catch (e) {
+      if (e !== sentinel) throw e;
+    }
+  }
+  async wipe() {
+    await this.ensureReady();
+    await this.db.transaction(async (tx) => {
+      await wipeRows(tx);
+      await wipeDomain(tx);
+    });
+  }
+  async close() {
+    await this.db.close();
+  }
+  // Internal seam for SqlStore views (same module): immediate op application
+  // and write stamping.
+  async applyOps(ops) {
+    await this.db.transaction((tx) => refreshDomain(tx, ops));
+  }
+  stamp(store, value) {
+    const userId = this.options.getUserId?.();
+    return userId ? stampUserOwned(store, value, userId) : value;
+  }
+};
+var SqlStore = class {
+  constructor(owner, def, store, conn, mutable, buffer, cleared) {
+    this.owner = owner;
+    this.def = def;
+    this.store = store;
+    this.conn = conn;
+    this.mutable = mutable;
+    this.buffer = buffer;
+    this.cleared = cleared;
+  }
+  owner;
+  def;
+  store;
+  conn;
+  mutable;
+  buffer;
+  cleared;
+  assertMutable() {
+    if (!this.mutable) {
+      throw new StorageError(403, `${this.store} is opened read-only`, "read_only_view");
+    }
+  }
+  async get(key) {
+    await this.owner.ensureReady();
+    const k = this.pointKey(key);
+    const state = bufferedGet(this.store, k, this.buffer);
+    if (state) return state.hit ? state.value : void 0;
+    if (this.cleared?.has(this.store)) return void 0;
+    return getRow(this.conn, this.def, k);
+  }
+  async getAll(query, count) {
+    await this.owner.ensureReady();
+    const range = rangeFromIDB(query);
+    const rows = await listRows(this.conn, this.def, range, isDirty(this.store, this.buffer, this.cleared) ? void 0 : count);
+    return overlayRows(this.def, this.store, this.buffer, this.cleared, rows, count, range);
+  }
+  async getAllFromIndex(indexName, query, count) {
+    await this.owner.ensureReady();
+    const range = rangeFromIDB(query);
+    const rows = await listRows(this.conn, this.def, range, isDirty(this.store, this.buffer, this.cleared) ? void 0 : count, indexName);
+    return overlayRows(this.def, this.store, this.buffer, this.cleared, rows, count, range, indexName);
+  }
+  async count(query) {
+    await this.owner.ensureReady();
+    const range = rangeFromIDB(query);
+    if (!isDirty(this.store, this.buffer, this.cleared)) return countRows(this.conn, this.def, range);
+    const rows = await listRows(this.conn, this.def, range);
+    return overlayRows(this.def, this.store, this.buffer, this.cleared, rows, void 0, range).length;
+  }
+  async countFromIndex(indexName, query) {
+    await this.owner.ensureReady();
+    const range = rangeFromIDB(query);
+    if (!isDirty(this.store, this.buffer, this.cleared)) return countRows(this.conn, this.def, range, indexName);
+    const rows = await listRows(this.conn, this.def, range, void 0, indexName);
+    return overlayRows(this.def, this.store, this.buffer, this.cleared, rows, void 0, range, indexName).length;
+  }
+  async put(value, _key) {
+    await this.owner.ensureReady();
+    this.assertMutable();
+    const stored = this.owner.stamp(this.store, value);
+    const key = keyFromValue(this.def, stored);
+    if (this.buffer) {
+      this.buffer.set(bufferSlot(this.store, key), { kind: "put", value: stored });
+      return key;
+    }
+    await this.owner.applyOps([{ op: "put", store: this.store, value: stored }]);
+    return key;
+  }
+  async delete(key) {
+    await this.owner.ensureReady();
+    this.assertMutable();
+    const range = isRange(key) ? key : void 0;
+    const target = range ?? key;
+    if (this.buffer) {
+      if (range) {
+        for (const row of await this.getAll(range)) {
+          const rowKey = keyFromValue(this.def, row);
+          this.buffer.set(bufferSlot(this.store, rowKey), { kind: "delete", key: rowKey });
+        }
+        return;
+      }
+      const point = target;
+      this.buffer.set(bufferSlot(this.store, point), { kind: "delete", key: point });
+      return;
+    }
+    await this.owner.applyOps([{ op: "delete", store: this.store, key: target }]);
+  }
+  async clear() {
+    await this.owner.ensureReady();
+    this.assertMutable();
+    if (this.buffer) {
+      this.cleared?.add(this.store);
+      const prefix = `${this.store}\0`;
+      for (const slot of [...this.buffer.keys()]) {
+        if (slot.startsWith(prefix)) this.buffer.delete(slot);
+      }
+      return;
+    }
+    await this.owner.applyOps([{ op: "clear", store: this.store }]);
+  }
+  /** Normalizes get() arguments to a wire key (bounded ranges match no row). */
+  pointKey(key) {
+    if (isRange(key)) {
+      if (key.only === void 0) {
+        throw new StorageError(400, "get() needs a plain key or {only}; bounded ranges match no single row");
+      }
+      return key.only;
+    }
+    return key;
+  }
+};
+function validateTursoUrl(url) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    throw new StorageError(400, "invalid Turso URL", "bad_turso_url");
+  }
+  if (url.includes("?") || url.includes("#")) {
+    throw new StorageError(400, "Turso URL must not carry a query or fragment; pass options/secrets via authToken", "bad_turso_url");
+  }
+  if (parsed.username || parsed.password) {
+    throw new StorageError(400, "Turso URL must not embed credentials; pass them via authToken", "bad_turso_url");
+  }
+  const loopback = parsed.hostname === "127.0.0.1" || parsed.hostname === "localhost" || parsed.hostname === "[::1]";
+  if (parsed.protocol === "http:") {
+    if (!loopback) {
+      throw new StorageError(400, "refusing plain http Turso URL (token would traverse the network unencrypted); use libsql:/https:", "bad_turso_url");
+    }
+    return url;
+  }
+  if (parsed.protocol !== "libsql:" && parsed.protocol !== "https:" && parsed.protocol !== "wss:") {
+    throw new StorageError(400, `unsupported Turso URL scheme ${parsed.protocol} (expected libsql:, https:, wss:)`, "bad_turso_url");
+  }
+  return url;
+}
+var BrowserTursoStorage = class extends SqlStorage {
+  constructor(settings, options = {}) {
+    super(
+      libsqlDatabase(web.createClient({ url: validateTursoUrl(settings.url), authToken: settings.authToken })),
+      options
+    );
+  }
+};
+
+exports.BrowserTursoStorage = BrowserTursoStorage;
+exports.MAX_BODY = MAX_BODY;
+exports.SCHEMA_TABLE = SCHEMA_TABLE;
+exports.SqlStorage = SqlStorage;
+exports.StorageError = StorageError;
+exports.clearRows = clearRows;
+exports.countRows = countRows;
+exports.decodeRowJson = decodeRowJson;
+exports.deleteRows = deleteRows;
+exports.encodeRowJson = encodeRowJson;
+exports.getRow = getRow;
+exports.handleDomainQuery = handleDomainQuery;
+exports.initializeDomain = initializeDomain;
+exports.initializeStore = initializeStore;
+exports.libsqlDatabase = libsqlDatabase;
+exports.listRows = listRows;
+exports.putRow = putRow;
+exports.rebuildProjections = rebuildProjections;
+exports.refreshDomain = refreshDomain;
+exports.storeDefinition = storeDefinition;
+exports.validateTursoUrl = validateTursoUrl;
+exports.wipeDomain = wipeDomain;
+exports.wipeRows = wipeRows;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map