@bitcobblers/wod-wiki-storage 0.39.2142 → 0.40.2144

package/dist/chunk-IFLOX2TK.mjs

@@ -0,0 +1,874 @@
+import { STORE_DEFS, extractKeyPart, validateStorageRow, isRange, DB_VERSION, COLUMN_TYPES, keyFromValue, rowsEqual, keyInRange, compareKeys } from './chunk-IMNG2HY5.mjs';
+import { StorageError } from './chunk-XRQKLSOT.mjs';
+
+// 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;
+}
+var canonicalJson = (_key, value) => {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return value;
+  return Object.fromEntries(Object.keys(value).sort().map((key) => [key, Reflect.get(value, key)]));
+};
+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 } }, canonicalJson);
+    }
+  }
+  return JSON.stringify(value, canonicalJson);
+}
+function decodeRowJson(text, binaryField) {
+  const row = JSON.parse(text);
+  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/sql/store.ts
+var SCHEMA_TABLE = "_wodwiki_schema";
+var SCHEMA_KEY = "schema";
+var ADDED_STORES_BY_VERSION = {
+  31: ["equipment", "block_equipment"]
+};
+function additiveStoresSince(stored) {
+  const added = /* @__PURE__ */ new Set();
+  for (const [version, names] of Object.entries(ADDED_STORES_BY_VERSION)) {
+    if (Number(version) > stored) for (const name of names) added.add(name);
+  }
+  return added;
+}
+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 getRows(conn, def, keys) {
+  const found = /* @__PURE__ */ new Map();
+  for (const part of chunks(keys, 50)) {
+    const params = [];
+    const conditions = part.map((key) => {
+      const parts = toParts(key);
+      if (parts.length !== def.keyPath.length) throw new StorageError(400, "invalid compound key arity");
+      params.push(...parts.map(toSqlScalar));
+      return `(${keyCols(def).map((col) => `"${col}" = ?`).join(" AND ")})`;
+    });
+    for (const row of await conn.query(`SELECT "data" FROM "${def.name}" WHERE ${conditions.join(" OR ")}`, params)) {
+      const value = decodeRowJson(String(row.data), binaryFieldOf(def));
+      found.set(JSON.stringify(requireKey(def, value)), value);
+    }
+  }
+  return keys.map((key) => found.get(JSON.stringify(key)));
+}
+async function listRowsFromIndexMany(conn, def, indexName, keys) {
+  const idx = indexDefinition(def, indexName);
+  if (idx.multiEntry) {
+    const out = [];
+    for (const key of keys) out.push(await listRows(conn, def, { only: key }, void 0, indexName));
+    return out;
+  }
+  const found = /* @__PURE__ */ new Map();
+  for (const part of chunks(keys, 50)) {
+    const params = [];
+    const conditions = part.map((key) => {
+      const parts = toParts(key);
+      if (parts.length !== idx.keyPath.length) throw new StorageError(400, "invalid index key arity");
+      params.push(...parts.map(toSqlScalar));
+      return `(${parts.map((_, i) => `"${indexCol(idx.name, i)}" = ?`).join(" AND ")})`;
+    });
+    for (const row of await conn.query(`SELECT "data" FROM "${def.name}" WHERE ${conditions.join(" OR ")} ORDER BY ${keyCols(def).map((col) => `"${col}"`).join(", ")}`, params)) {
+      const value = decodeRowJson(String(row.data), binaryFieldOf(def));
+      const parts = idx.keyPath.map((path) => extractKeyPart(value, path));
+      const key = JSON.stringify(parts.length === 1 ? parts[0] : parts);
+      const bucket = found.get(key);
+      if (bucket) bucket.push(value);
+      else found.set(key, [value]);
+    }
+  }
+  return keys.map((key) => found.get(JSON.stringify(key)) ?? []);
+}
+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);
+}
+var PARAM_BUDGET = 2e4;
+var ROW_CAP = 100;
+var chunks = (arr, size) => {
+  const out = [];
+  for (let i = 0; i < arr.length; i += size) out.push(arr.slice(i, i + size));
+  return out;
+};
+async function batchInsert(conn, table, cols, rows, onConflict) {
+  if (rows.length === 0) return;
+  const collist = cols.map((c) => `"${c}"`).join(", ");
+  const tuple = `(${cols.map(() => "?").join(", ")})`;
+  const per = Math.max(1, Math.min(ROW_CAP, Math.floor(PARAM_BUDGET / cols.length)));
+  const statements = chunks(rows, per).map((part) => ({
+    sql: `INSERT INTO "${table}" (${collist}) VALUES ${part.map(() => tuple).join(", ")} ${onConflict}`,
+    params: part.flat()
+  }));
+  if (conn.batch) await conn.batch(statements);
+  else for (const statement of statements) await conn.exec(statement.sql, statement.params);
+}
+async function deleteIn(conn, table, col, vals) {
+  for (const part of chunks(vals, 500)) {
+    if (part.length === 0) continue;
+    await conn.exec(`DELETE FROM "${table}" WHERE "${col}" IN (${part.map(() => "?").join(", ")})`, part);
+  }
+}
+async function putRows(conn, def, values, changedKeys) {
+  if (values.length === 0) return [];
+  for (const value of values) validateStorageRow(def.name, value);
+  const keys = keyCols(def);
+  const cols = [...keys];
+  for (const idx of def.indexes) {
+    if (idx.multiEntry) continue;
+    idx.keyPath.forEach((_, part) => cols.push(indexCol(idx.name, part)));
+  }
+  cols.push("data");
+  const keySet = new Set(keys);
+  const updates = cols.filter((c) => !keySet.has(c)).map((c) => `"${c}" = excluded."${c}"`).join(", ");
+  const pk = keys.map((k) => `"${k}"`).join(", ");
+  const rows = [];
+  const out = [];
+  const junction = [];
+  const multi = multiEntryIndex(def);
+  for (const value of values) {
+    const k = requireKey(def, value);
+    const keyParts = toParts(k).map(toSqlScalar);
+    const vals = [...keyParts];
+    for (const idx of def.indexes) {
+      if (idx.multiEntry) continue;
+      idx.keyPath.forEach((path) => vals.push(toSqlScalar(extractKeyPart(value, path) ?? null)));
+    }
+    vals.push(encodeRowJson(value, binaryFieldOf(def)));
+    rows.push(vals);
+    out.push(k);
+    if (multi) {
+      const items = arrayPart(value, multi.keyPath[0]);
+      if (Array.isArray(items)) {
+        for (const item of items) junction.push([...keyParts, JSON.stringify(item)]);
+      }
+    }
+  }
+  const tuple = `(${cols.map(() => "?").join(", ")})`;
+  const per = Math.max(1, Math.min(ROW_CAP, Math.floor(PARAM_BUDGET / cols.length)));
+  const statements = chunks(rows, per).map((part) => ({
+    sql: `INSERT INTO "${def.name}" (${cols.map((col) => `"${col}"`).join(", ")}) VALUES ${part.map(() => tuple).join(", ")} ` + (def.name === "block_revisions" ? `ON CONFLICT (${pk}) DO NOTHING` : `ON CONFLICT (${pk}) DO UPDATE SET ${updates} WHERE "${def.name}"."data" <> excluded."data"`) + ` RETURNING ${keys.map((col) => `"${col}"`).join(", ")}`,
+    params: part.flat()
+  }));
+  let returned;
+  try {
+    if (conn.batch) returned = await conn.batch(statements);
+    else {
+      returned = [];
+      for (const statement of statements) returned.push(await conn.query(statement.sql, statement.params));
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    for (const code of ["revision_conflict", "transaction_conflict", "invalid_session_pin"]) {
+      if (message.includes(code)) throw new StorageError(409, message, code);
+    }
+    throw error;
+  }
+  const changed = returned.flat().map((row) => {
+    const parts = keys.map((col) => row[col]);
+    return parts.length === 1 ? parts[0] : parts;
+  });
+  changedKeys?.push(...changed);
+  if (multi) {
+    const jt = junctionTable(def, multi);
+    const changedSet = new Set(changed.map((key) => JSON.stringify(key)));
+    const deletes = values.flatMap((value) => {
+      const key = requireKey(def, value);
+      if (!changedSet.has(JSON.stringify(key))) return [];
+      const items = arrayPart(value, multi.keyPath[0]) ?? [];
+      return [{
+        sql: `DELETE FROM "${jt}" WHERE ${keys.map((col) => `"${col}" = ?`).join(" AND ")}` + (items.length ? ` AND "v" NOT IN (${items.map(() => "?").join(", ")})` : ""),
+        params: [...toParts(key).map(toSqlScalar), ...items.map((item) => JSON.stringify(item))]
+      }];
+    });
+    if (conn.batch && deletes.length) await conn.batch(deletes);
+    else for (const statement of deletes) await conn.exec(statement.sql, statement.params);
+    await batchInsert(conn, jt, [...keys, "v"], junction.filter((row) => changedSet.has(JSON.stringify(keys.length === 1 ? row[0] : row.slice(0, keys.length)))), "ON CONFLICT DO NOTHING");
+  }
+  return out;
+}
+async function putRow(conn, def, value) {
+  return (await putRows(conn, def, [value]))[0];
+}
+async function deleteRows(conn, def, keyOrRange) {
+  if (def.name === "block_revisions") throw new StorageError(409, "block history may only be removed by explicit wipe", "revision_conflict");
+  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, wipe = false) {
+  if (def.name === "block_revisions" && !wipe) throw new StorageError(409, "block history may only be removed by explicit wipe", "revision_conflict");
+  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, true);
+  }
+}
+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")`);
+  }
+  if (def.name === "notes" && dialect === "sqlite") {
+    await conn.exec(`CREATE TRIGGER IF NOT EXISTS "notes_revision_guard" BEFORE UPDATE ON "notes"
+      WHEN json_extract(NEW."data", '$.sourceRevision') < json_extract(OLD."data", '$.sourceRevision')
+      OR ((json_extract(NEW."data", '$.rawContent') IS NOT json_extract(OLD."data", '$.rawContent')
+        OR json_extract(NEW."data", '$.blocks') IS NOT json_extract(OLD."data", '$.blocks'))
+        AND json_extract(NEW."data", '$.sourceRevision') <= json_extract(OLD."data", '$.sourceRevision'))
+      BEGIN SELECT RAISE(ABORT, 'transaction_conflict: stale Note source revision'); END`);
+  }
+  if (def.name === "block_revisions" && dialect === "sqlite") {
+    await conn.exec(`CREATE TRIGGER IF NOT EXISTS "block_revision_guard" BEFORE INSERT ON "block_revisions"
+      WHEN EXISTS (SELECT 1 FROM "block_revisions" old WHERE old."k0" = NEW."k0" AND old."k1" = NEW."k1" AND old."k2" = NEW."k2" AND old."data" <> NEW."data")
+      BEGIN SELECT RAISE(ABORT, 'revision_conflict: immutable block revision collision'); END`);
+  }
+  if (def.name === "sessions" && dialect === "sqlite") {
+    await conn.exec(`CREATE TRIGGER IF NOT EXISTS "session_pin_guard" BEFORE UPDATE ON "sessions"
+      WHEN json_extract(NEW."data", '$.noteId') IS NOT json_extract(OLD."data", '$.noteId')
+        OR json_extract(NEW."data", '$.blockId') IS NOT json_extract(OLD."data", '$.blockId')
+        OR json_extract(NEW."data", '$.blockVersion') IS NOT json_extract(OLD."data", '$.blockVersion')
+      BEGIN SELECT RAISE(ABORT, 'invalid_session_pin: Session pin is immutable'); END`);
+  }
+  if (dialect === "postgres" && ["notes", "block_revisions", "sessions"].includes(def.name)) {
+    const condition = def.name === "block_revisions" ? `EXISTS (SELECT 1 FROM "block_revisions" saved WHERE saved."k0" = NEW."k0" AND saved."k1" = NEW."k1" AND saved."k2" = NEW."k2" AND saved."data" <> NEW."data")` : def.name === "notes" ? `(NEW."data"::jsonb->>'sourceRevision')::bigint < (OLD."data"::jsonb->>'sourceRevision')::bigint OR ((NEW."data"::jsonb->'rawContent' IS DISTINCT FROM OLD."data"::jsonb->'rawContent' OR NEW."data"::jsonb->'blocks' IS DISTINCT FROM OLD."data"::jsonb->'blocks') AND (NEW."data"::jsonb->>'sourceRevision')::bigint <= (OLD."data"::jsonb->>'sourceRevision')::bigint)` : `NEW."data"::jsonb->'noteId' IS DISTINCT FROM OLD."data"::jsonb->'noteId' OR NEW."data"::jsonb->'blockId' IS DISTINCT FROM OLD."data"::jsonb->'blockId' OR NEW."data"::jsonb->'blockVersion' IS DISTINCT FROM OLD."data"::jsonb->'blockVersion'`;
+    const code = def.name === "block_revisions" ? "revision_conflict" : def.name === "notes" ? "transaction_conflict" : "invalid_session_pin";
+    const guard = `${def.name}_guard`;
+    await conn.exec(`CREATE OR REPLACE FUNCTION "${guard}"() RETURNS trigger LANGUAGE plpgsql AS $$ BEGIN IF ${condition} THEN RAISE EXCEPTION '${code}'; END IF; RETURN NEW; END; $$`);
+    await conn.exec(`DROP TRIGGER IF EXISTS "${guard}" ON "${def.name}"`);
+    await conn.exec(`CREATE TRIGGER "${guard}" BEFORE ${def.name === "block_revisions" ? "INSERT" : "UPDATE"} ON "${def.name}" FOR EACH ROW EXECUTE FUNCTION "${guard}"()`);
+  }
+}
+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 ignored = (name) => name.startsWith("_wodwiki_") || name.startsWith("sqlite_") || name === "domain_note" || name === "query_block";
+    const storeTables = new Set(STORE_DEFS.map((d) => d.name));
+    for (const def of STORE_DEFS) {
+      const multi = def.indexes.find((i) => i.multiEntry);
+      if (multi) storeTables.add(junctionTable(def, multi));
+    }
+    const tableNames = new Set(
+      (await tx.query(tableListSql(db.dialect))).map((r) => String(Object.values(r)[0])).filter((n) => !ignored(n))
+    );
+    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" || !Number.isSafeInteger(guard.version) || guard.version < 0) {
+        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} is newer than this server supports (v${DB_VERSION}); refusing to downgrade`,
+          "schema_incompatible"
+        );
+      }
+      if (stored < DB_VERSION) {
+        const missing = [...storeTables].filter((name) => !tableNames.has(name));
+        const unexpected = [...tableNames].filter((name) => name !== SCHEMA_TABLE && !storeTables.has(name));
+        const additive = additiveStoresSince(stored);
+        if (stored < 30 || unexpected.length > 0 || missing.some((name) => !additive.has(name))) {
+          throw new StorageError(
+            500,
+            `database schema v${stored} is incompatible with v${DB_VERSION} (missing tables: ${missing.join(", ") || "none"}; unrecognized tables: ${unexpected.join(", ") || "none"}); recreation required using an explicitly disposable 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/sql/sync.ts
+var SYNC_OPS_TABLE = "_wodwiki_sync_ops";
+var SYNC_STATE_TABLE = "_wodwiki_sync_state";
+var BINARY_FIELD2 = { attachments: "data" };
+var STORE_NAMES = Object.fromEntries(STORE_DEFS.map((d) => [d.name, true]));
+var STATE_KEY = "meta";
+function isSafeInt(value) {
+  return typeof value === "number" && Number.isSafeInteger(value);
+}
+function isScalar(value) {
+  return typeof value === "string" || typeof value === "number" && Number.isFinite(value);
+}
+function assertKey(key, what) {
+  if (isScalar(key)) return;
+  if (Array.isArray(key) && key.length > 0 && key.every(isScalar)) return;
+  throw new StorageError(400, `${what} must be a string, finite number, or non-empty scalar tuple`, "bad_sync_key");
+}
+function validateMutation(raw) {
+  if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+    throw new StorageError(400, "sync mutation must be an object", "bad_sync_mutation");
+  }
+  const mutation = raw;
+  if (mutation.op === "wipe") return { op: "wipe" };
+  if (typeof mutation.store !== "string" || !STORE_NAMES[mutation.store]) {
+    throw new StorageError(400, `sync mutation has unknown store ${String(mutation.store)}`, "bad_sync_mutation");
+  }
+  const store = mutation.store;
+  if (mutation.op === "clear") return { op: "clear", store };
+  if (mutation.op === "delete") {
+    assertKey(mutation.key, "sync delete key");
+    return { op: "delete", store, key: mutation.key };
+  }
+  if (mutation.op === "put") {
+    assertKey(mutation.key, "sync put key");
+    if (mutation.value === null || typeof mutation.value !== "object" || Array.isArray(mutation.value)) {
+      throw new StorageError(400, "sync put value must be an object row", "bad_sync_mutation");
+    }
+    const def = STORE_DEFS.find((def2) => def2.name === store);
+    const valueKey = keyFromValue(def, mutation.value);
+    assertKey(valueKey, "sync row key");
+    if (!rowsEqual(mutation.key, valueKey)) {
+      throw new StorageError(400, "sync put key differs from row key", "bad_sync_key");
+    }
+    return { op: "put", store, key: mutation.key, value: mutation.value };
+  }
+  throw new StorageError(400, `sync mutation has unknown op ${String(mutation.op)}`, "bad_sync_mutation");
+}
+function validateEntry(entry) {
+  if (typeof entry.id !== "string" || entry.id.length === 0 || entry.id.length > 200) {
+    throw new StorageError(400, "sync entry id must be a non-empty string", "bad_sync_entry");
+  }
+  if (!isSafeInt(entry.at) || entry.at < 0) {
+    throw new StorageError(400, "sync entry at must be a non-negative safe integer", "bad_sync_entry");
+  }
+  if (!Array.isArray(entry.ops) || entry.ops.length === 0) {
+    throw new StorageError(400, "sync entry ops must be a non-empty array", "bad_sync_entry");
+  }
+  for (const op of entry.ops) validateMutation(op);
+}
+async function runStatements(tx, statements) {
+  if (statements.length === 0) return [];
+  if (tx.batch) return tx.batch(statements);
+  const results = [];
+  for (const statement of statements) {
+    results.push(await tx.query(statement.sql, statement.params ?? []));
+  }
+  return results;
+}
+async function tableExists(conn, dialect, name) {
+  const sql = dialect === "postgres" ? `SELECT table_name FROM information_schema.tables WHERE table_schema = 'public' AND table_name = $1` : `SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?`;
+  return (await conn.query(sql, [name])).length > 0;
+}
+async function readSyncState(tx) {
+  const rows = await tx.query(`SELECT "value" FROM "${SYNC_STATE_TABLE}" WHERE "key" = ?`, [STATE_KEY]);
+  if (!rows[0]) throw new StorageError(409, "sync target is not initialized", "sync_not_initialized");
+  let parsed;
+  try {
+    parsed = JSON.parse(String(rows[0].value));
+  } catch {
+    throw new StorageError(400, "malformed sync state row", "bad_sync_state");
+  }
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new StorageError(400, "malformed sync state row", "bad_sync_state");
+  }
+  const state = parsed;
+  if (!isSafeInt(state.schema) || state.schema < 0 || !isSafeInt(state.rev) || state.rev < 0) {
+    throw new StorageError(400, "sync state schema/rev must be non-negative safe integers", "bad_sync_state");
+  }
+  return { schema: state.schema, rev: state.rev };
+}
+async function probeSyncTarget(db) {
+  if (await tableExists(db, db.dialect, SYNC_STATE_TABLE)) {
+    const state = await readSyncState(db);
+    return { kind: "current", schemaVersion: state.schema, rev: state.rev };
+  }
+  if (await tableExists(db, db.dialect, SCHEMA_TABLE)) {
+    const rows = await db.query(`SELECT "value" FROM "${SCHEMA_TABLE}" WHERE "key" = 'schema'`);
+    if (rows[0]) {
+      const guard = JSON.parse(String(rows[0].value));
+      if (typeof guard.version === "number" && Number.isSafeInteger(guard.version) && guard.version >= 0) {
+        return { kind: "legacy", schemaVersion: guard.version };
+      }
+    }
+    return { kind: "legacy", schemaVersion: 0 };
+  }
+  const others = await db.query(
+    db.dialect === "postgres" ? `SELECT table_name FROM information_schema.tables WHERE table_schema = 'public'` : `SELECT name FROM sqlite_master WHERE type = 'table'`
+  );
+  const internal = (name) => name.startsWith("_wodwiki_") || name.startsWith("sqlite_");
+  return others.some((row) => !internal(String(Object.values(row)[0]))) ? { kind: "unknown" } : "empty";
+}
+async function initSyncTarget(db, schemaVersion) {
+  await db.transaction(async (tx) => {
+    await tx.exec(`CREATE TABLE IF NOT EXISTS "${SYNC_STATE_TABLE}" ("key" TEXT PRIMARY KEY, "value" TEXT NOT NULL)`);
+    await tx.exec(
+      `CREATE TABLE IF NOT EXISTS "${SYNC_OPS_TABLE}" ("op_id" TEXT PRIMARY KEY, "rev" INTEGER NOT NULL, "idx" INTEGER NOT NULL, "at" INTEGER NOT NULL, "data" TEXT NOT NULL)`
+    );
+    await tx.exec(
+      `CREATE INDEX IF NOT EXISTS "${SYNC_OPS_TABLE}_rev" ON "${SYNC_OPS_TABLE}" ("rev", "idx")`
+    );
+    await tx.exec(
+      `INSERT INTO "${SYNC_STATE_TABLE}" ("key", "value") VALUES (?, ?) ON CONFLICT ("key") DO NOTHING`,
+      [STATE_KEY, JSON.stringify({ schema: schemaVersion, rev: 0 })]
+    );
+  });
+}
+function encodeMutation(mutation) {
+  if (mutation.op !== "put") return JSON.stringify(mutation);
+  const encoded = encodeRowJson(mutation.value, BINARY_FIELD2[mutation.store]);
+  return `{"key":${JSON.stringify(mutation.key)},"op":"put","store":${JSON.stringify(mutation.store)},"value":${encoded}}`;
+}
+function decodeMutation(data) {
+  if (typeof data !== "string") {
+    throw new StorageError(400, "sync op data must be a string", "bad_sync_mutation");
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(data);
+  } catch {
+    throw new StorageError(400, "sync op data is not valid JSON", "bad_sync_mutation");
+  }
+  const mutation = validateMutation(parsed);
+  if (mutation.op !== "put") return mutation;
+  return {
+    op: "put",
+    store: mutation.store,
+    key: mutation.key,
+    value: decodeRowJson(JSON.stringify(mutation.value), BINARY_FIELD2[mutation.store])
+  };
+}
+async function applySyncBatch(db, entries, opts = {}) {
+  if (entries.length === 0) return 0;
+  for (const entry of entries) validateEntry(entry);
+  return db.transaction(async (tx) => {
+    const state = await readSyncState(tx);
+    if (opts.expectSchema !== void 0 && state.schema !== opts.expectSchema) {
+      throw new StorageError(
+        409,
+        `sync target schema changed from v${opts.expectSchema} to v${state.schema} between probe and write \u2014 retry the cycle`,
+        "sync_schema_conflict"
+      );
+    }
+    const firstIds = entries.map((entry) => `${entry.id}:0`);
+    const present = /* @__PURE__ */ new Set();
+    for (let i = 0; i < firstIds.length; i += 100) {
+      const chunk = firstIds.slice(i, i + 100);
+      const rows = await tx.query(
+        `SELECT "op_id" FROM "${SYNC_OPS_TABLE}" WHERE "op_id" IN (${chunk.map(() => "?").join(", ")})`,
+        chunk
+      );
+      for (const row of rows) present.add(String(row.op_id));
+    }
+    const statements = [];
+    let rev = state.rev;
+    let committed = 0;
+    for (const entry of entries) {
+      if (present.has(`${entry.id}:0`)) continue;
+      rev += 1;
+      committed += 1;
+      entry.ops.forEach((mutation, idx) => {
+        statements.push({
+          sql: `INSERT INTO "${SYNC_OPS_TABLE}" ("op_id", "rev", "idx", "at", "data") VALUES (?, ?, ?, ?, ?) ON CONFLICT ("op_id") DO NOTHING`,
+          params: [`${entry.id}:${idx}`, rev, idx, entry.at, encodeMutation(mutation)]
+        });
+      });
+    }
+    statements.push({
+      sql: `UPDATE "${SYNC_STATE_TABLE}" SET "value" = ? WHERE "key" = ?`,
+      params: [JSON.stringify({ schema: state.schema, rev }), STATE_KEY]
+    });
+    await runStatements(tx, statements);
+    return committed;
+  });
+}
+async function fetchSyncOps(db, afterRev, limit) {
+  if (!isSafeInt(afterRev) || afterRev < 0) {
+    throw new StorageError(400, "fetchSyncOps cursor must be a non-negative safe integer", "bad_sync_cursor");
+  }
+  const bounded = Math.min(Math.max(1, Math.floor(limit)), 4294967295);
+  const revRows = await db.query(
+    `SELECT DISTINCT "rev" FROM (SELECT "rev" FROM "${SYNC_OPS_TABLE}" WHERE "rev" > ? ORDER BY "rev" ASC LIMIT ?)`,
+    [afterRev, bounded]
+  );
+  const revs = revRows.map((row) => {
+    const rev = Number(row.rev);
+    if (!Number.isSafeInteger(rev) || rev < 0) {
+      throw new StorageError(400, "sync op rev must be a non-negative safe integer", "bad_sync_row");
+    }
+    return rev;
+  });
+  if (revs.length === 0) return [];
+  const rows = await db.query(
+    `SELECT "op_id", "rev", "idx", "at", "data" FROM "${SYNC_OPS_TABLE}" WHERE "rev" IN (${revs.map(() => "?").join(", ")}) ORDER BY "rev", "idx"`,
+    revs
+  );
+  return rows.map((row, at) => {
+    const opId = row.op_id;
+    const rev = Number(row.rev);
+    const idx = Number(row.idx);
+    const atMs = Number(row.at);
+    if (typeof opId !== "string" || opId.length === 0 || !Number.isSafeInteger(rev) || rev < 0 || !Number.isSafeInteger(idx) || idx < 0 || !Number.isSafeInteger(atMs) || atMs < 0) {
+      throw new StorageError(400, `sync op row ${at} has malformed shape`, "bad_sync_row");
+    }
+    return { opId, rev, idx, at: atMs, mutation: decodeMutation(row.data) };
+  });
+}
+async function readRawSyncOps(db) {
+  const rows = await db.query(`SELECT "rev", "idx", "data" FROM "${SYNC_OPS_TABLE}" ORDER BY "rev", "idx"`);
+  return rows.map((row) => {
+    const rev = Number(row.rev);
+    const idx = Number(row.idx);
+    if (!Number.isSafeInteger(rev) || rev < 0 || !Number.isSafeInteger(idx) || idx < 0 || typeof row.data !== "string") {
+      throw new StorageError(400, "sync op row has malformed shape", "bad_sync_row");
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(row.data);
+    } catch {
+      throw new StorageError(400, "sync op data is not valid JSON", "bad_sync_row");
+    }
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      throw new StorageError(400, "sync op data must be an object", "bad_sync_row");
+    }
+    const mutation = parsed;
+    if (mutation.op === "wipe") return { op: "wipe" };
+    if (typeof mutation.store !== "string") {
+      throw new StorageError(400, "sync op must carry a string store", "bad_sync_row");
+    }
+    if (mutation.op === "clear") return { op: "clear", store: mutation.store };
+    if (mutation.op === "delete") return { op: "delete", store: mutation.store, key: mutation.key };
+    if (mutation.op !== "put" || mutation.value === null || typeof mutation.value !== "object" || Array.isArray(mutation.value)) {
+      throw new StorageError(400, "sync op has an unknown operation or invalid row", "bad_sync_row");
+    }
+    return {
+      op: "put",
+      store: mutation.store,
+      key: mutation.key,
+      value: decodeRowJson(JSON.stringify(mutation.value), BINARY_FIELD2[mutation.store])
+    };
+  });
+}
+async function readLegacyRows(db, table) {
+  if (!await tableExists(db, db.dialect, table)) return [];
+  const rows = await db.query(`SELECT "data" FROM "${table}"`);
+  return rows.map((row) => decodeRowJson(String(row.data), BINARY_FIELD2[table]));
+}
+
+export { SCHEMA_TABLE, SYNC_OPS_TABLE, SYNC_STATE_TABLE, applySyncBatch, batchInsert, clearRows, countRows, decodeRowJson, deleteIn, deleteRows, encodeRowJson, fetchSyncOps, getRow, getRows, initSyncTarget, initializeStore, listRows, listRowsFromIndexMany, probeSyncTarget, putRow, putRows, readLegacyRows, readRawSyncOps, storeDefinition, wipeRows };
+//# sourceMappingURL=chunk-IFLOX2TK.mjs.map
+//# sourceMappingURL=chunk-IFLOX2TK.mjs.map