@bitcobblers/wod-wiki-storage 0.39.2142 → 0.40.2144

package/dist/idb/index.cjs

@@ -0,0 +1,1462 @@
+'use strict';
+
+var idb = require('idb');
+var wodWikiCore = require('@bitcobblers/wod-wiki-core');
+var wodWikiWql = require('@bitcobblers/wod-wiki-wql');
+
+// src/idb/index.ts
+
+// src/schema.ts
+var DB_VERSION = 32;
+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"] }
+  ] },
+  { name: "block_revisions", keyPath: ["noteId", "blockId", "version"], indexes: [
+    { name: "by-note", keyPath: ["noteId"] },
+    { name: "by-block", keyPath: ["noteId", "blockId"] }
+  ] },
+  // 6. sessions
+  { name: "sessions", keyPath: ["id"], indexes: [
+    { 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"] }
+  ] },
+  // 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"] }
+  ] },
+  // 11b. equipment (V31) — canonical equipment definitions, keyed by slug
+  { name: "equipment", keyPath: ["slug"], indexes: [
+    { 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"] }
+  ] },
+  // 13b. block_equipment (V31) — containment links, mirroring block_efforts
+  { name: "block_equipment", keyPath: ["id"], indexes: [
+    { name: "by-note", keyPath: ["noteId"] },
+    { name: "by-equipment", keyPath: ["equipmentSlug"] },
+    { 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/membership.ts
+var USER_OWNED_STORES = [
+  "notes",
+  "page",
+  "page_notes",
+  "tags",
+  "tag_types",
+  "note_tags",
+  "sessions",
+  "attachments",
+  "events",
+  "efforts",
+  "block_index",
+  "block_efforts",
+  "equipment",
+  "block_equipment"
+];
+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/wire.ts
+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;
+}
+
+// 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/validation.ts
+function rowsEqual(left, right) {
+  if (Object.is(left, right)) return true;
+  if (left instanceof ArrayBuffer && right instanceof ArrayBuffer) {
+    const a2 = new Uint8Array(left), b2 = new Uint8Array(right);
+    return a2.length === b2.length && a2.every((value, i) => value === b2[i]);
+  }
+  if (typeof left !== "object" || left === null || typeof right !== "object" || right === null) return false;
+  if (Array.isArray(left) || Array.isArray(right)) return Array.isArray(left) && Array.isArray(right) && left.length === right.length && left.every((value, i) => rowsEqual(value, right[i]));
+  const a = Object.keys(left).filter((key) => Reflect.get(left, key) !== void 0);
+  const b = Object.keys(right).filter((key) => Reflect.get(right, key) !== void 0);
+  return a.length === b.length && a.every((key) => Object.hasOwn(right, key) && rowsEqual(Reflect.get(left, key), Reflect.get(right, key)));
+}
+function record(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) throw new StorageError(400, "storage row must be an object");
+  return value;
+}
+function validateStorageRow(store, value) {
+  if (store !== "notes" && store !== "block_revisions" && store !== "sessions" && store !== "block_index") return;
+  const row = record(value);
+  const positive = (field) => typeof row[field] === "number" && Number.isSafeInteger(row[field]) && row[field] > 0;
+  const required = (field) => typeof row[field] === "string" && row[field].length > 0;
+  if (store === "notes") {
+    if (!required("id") || typeof row.title !== "string" || typeof row.rawContent !== "string" || !positive("sourceRevision") || typeof row.createdAt !== "number" || !Number.isFinite(row.createdAt) || "segments" in row || "segmentIds" in row || row.date !== void 0 && (typeof row.date !== "number" || !Number.isFinite(row.date)) || row.seedOrigin !== void 0 && row.seedOrigin !== "seed" && row.seedOrigin !== "user" || row.seedVersion !== void 0 && !(typeof row.seedVersion === "number" && Number.isSafeInteger(row.seedVersion) && row.seedVersion >= 0) || row.tags !== void 0 && (!Array.isArray(row.tags) || !row.tags.every((tag) => typeof tag === "string")) || ["type", "sourceId", "sourcePath", "catalog", "notebookId", "seedChunkId"].some((field) => row[field] !== void 0 && typeof row[field] !== "string")) {
+      throw new StorageError(400, "invalid whole Note", "invalid_note_blocks");
+    }
+    try {
+      wodWikiCore.validateNoteBlocks(row.rawContent, record(row.blocks), row.sourceRevision);
+    } catch (error) {
+      throw new StorageError(400, error instanceof Error ? error.message : "invalid block map", "invalid_note_blocks");
+    }
+  } else if (store === "block_revisions") {
+    if (!required("noteId") || !required("blockId") || !positive("version") || typeof row.rawContent !== "string" || typeof row.savedAt !== "number" || !Number.isFinite(row.savedAt) || !["wod", "query", "widget", "embed"].includes(String(row.kind)) || (row.kind === "wod" ? row.dialect !== "time" && row.dialect !== "log" : row.dialect !== void 0 || row.sport !== void 0) || row.sport !== void 0 && typeof row.sport !== "string") throw new StorageError(400, "invalid block revision", "invalid_note_blocks");
+    try {
+      wodWikiCore.validateNoteBlocks(row.rawContent, { [String(row.blockId)]: {
+        id: String(row.blockId),
+        kind: row.kind,
+        version: row.version,
+        sourceRevision: 1,
+        from: 0,
+        to: row.rawContent.length,
+        ...row.dialect === void 0 ? {} : { dialect: row.dialect },
+        ...row.sport === void 0 ? {} : { sport: row.sport }
+      } }, 1);
+    } catch (error) {
+      throw new StorageError(400, error instanceof Error ? error.message : "invalid revision source", "invalid_note_blocks");
+    }
+  } else if (store === "sessions") {
+    if (!required("noteId") || !required("blockId") || !positive("blockVersion") || ["segmentId", "segmentVersion", "version", "rawContent", "script", "serializedScript", "source", "data", "logs"].some((field) => field in row)) {
+      throw new StorageError(400, "Session requires immutable block pin", "invalid_session_pin");
+    }
+  } else if (!required("noteId") || !required("blockId") || !positive("blockVersion") || !positive("sourceRevision") || row.id !== `${row.noteId}:${row.blockId}` || !Number.isSafeInteger(row.from) || !Number.isSafeInteger(row.to) || "segmentId" in row || "segmentVersion" in row || !["wod", "query", "widget", "embed"].includes(String(row.dataType)) || typeof row.rawContent !== "string" || typeof row.noteTitle !== "string" || typeof row.from !== "number" || typeof row.to !== "number" || row.from < 0 || row.to <= row.from) {
+    throw new StorageError(400, "invalid actionable block projection", "invalid_note_blocks");
+  }
+}
+function validateNoteWrite(previous, value) {
+  if (previous === void 0 || rowsEqual(previous, value)) return;
+  const before = record(previous), after = record(value);
+  if (typeof before.sourceRevision !== "number" || typeof after.sourceRevision !== "number" || after.sourceRevision < before.sourceRevision || (!rowsEqual(before.blocks, after.blocks) || before.rawContent !== after.rawContent) && after.sourceRevision <= before.sourceRevision) throw new StorageError(409, "stale Note source revision", "transaction_conflict");
+}
+function validateSessionWrite(previous, value) {
+  if (previous === void 0) return;
+  const before = record(previous), after = record(value);
+  if (before.noteId !== after.noteId || before.blockId !== after.blockId || before.blockVersion !== after.blockVersion)
+    throw new StorageError(409, "Session pin is immutable", "invalid_session_pin");
+}
+async function validateStoredPins(notes, sessions, getRevisions) {
+  const keys = [];
+  for (const note of notes) for (const block of Object.values(note.blocks)) keys.push([note.id, block.id, block.version]);
+  for (const session of sessions) keys.push([session.noteId, session.blockId, session.blockVersion]);
+  const revisions = await getRevisions(keys);
+  let i = 0;
+  for (const note of notes) for (const block of Object.values(note.blocks)) {
+    const revision = revisions[i++];
+    if (!revision || revision.kind !== block.kind || revision.rawContent !== note.rawContent.slice(block.from, block.to) || revision.dialect !== block.dialect || revision.sport !== block.sport) throw new StorageError(409, "Note block has no matching immutable revision", "invalid_note_blocks");
+  }
+  for (let sessionIndex = 0; sessionIndex < sessions.length; sessionIndex++) {
+    const revision = revisions[i++];
+    if (!revision || revision.kind !== "wod") throw new StorageError(409, "Session pin must reference a saved workout revision", "invalid_session_pin");
+  }
+}
+
+// src/policy.ts
+var USER_DELETED_SEED_PREFIX = "user-deleted-seed:";
+function isSeedMetaKey(key) {
+  return typeof key === "string" && key.startsWith("seed:");
+}
+function collectUserScopeContext(notes) {
+  const seedNoteIds = /* @__PURE__ */ new Set();
+  for (const row of notes) {
+    if (row !== null && typeof row === "object" && "seedOrigin" in row && row.seedOrigin === "seed" && "id" in row && typeof row.id === "string") {
+      seedNoteIds.add(row.id);
+    }
+  }
+  return { seedNoteIds };
+}
+function isUserOwnedRow(store, row, ctx) {
+  if (row === null || typeof row !== "object") return true;
+  switch (store) {
+    case "notes":
+      return !("seedOrigin" in row && row.seedOrigin === "seed");
+    case "block_index":
+    case "block_efforts":
+    case "block_equipment":
+      return !("isStatic" in row && row.isStatic === true && "noteId" in row && typeof row.noteId === "string" && ctx.seedNoteIds.has(row.noteId));
+    case "efforts":
+    case "equipment":
+      return !("registrySource" in row && row.registrySource === "bundled");
+    case "meta":
+      return !isSeedMetaKey("key" in row ? row.key : void 0);
+    default:
+      return true;
+  }
+}
+
+// src/sql/codec.ts
+var TAG = "$binary";
+var LEN = "$bytes";
+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 decodeRowJson(text, binaryField) {
+  const row = JSON.parse(text);
+  if (binaryField && row !== null && typeof row === "object" && !Array.isArray(row)) {
+    const record2 = row;
+    const revived = reviveBinary(record2[binaryField]);
+    if (revived !== record2[binaryField]) record2[binaryField] = revived;
+  }
+  return row;
+}
+
+// src/sql/sync.ts
+var SYNC_OPS_TABLE = "_wodwiki_sync_ops";
+var BINARY_FIELD = { attachments: "data" };
+Object.fromEntries(STORE_DEFS.map((d) => [d.name, true]));
+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 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_FIELD[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_FIELD[table]));
+}
+var IDB_DB_NAME = "wodwiki-db";
+var OUTBOX_STORE = "sync_outbox";
+var SYNC_STATE_STORE = "sync_state";
+var LOCAL_SYNC_STORES = [
+  { name: OUTBOX_STORE, keyPath: "seq", autoIncrement: true },
+  { name: SYNC_STATE_STORE, keyPath: "key" }
+];
+var BOOTSTRAP_RUN_PREFIX = "bootstrap-run:";
+var NON_SYSTEM_STORES = STORE_DEFS.filter((def) => !def.system).map((def) => def.name);
+var BOOTSTRAP_MAX_OPS = 500;
+var BOOTSTRAP_MAX_BYTES = 1e6;
+var BINARY_SYNC_FIELDS = { attachments: "data" };
+var LEGACY_EXTRA_TABLES = [
+  { name: "segments", keyPath: ["id", "version"] },
+  { name: "results", keyPath: "id" }
+];
+var TxJournal = class {
+  ops = [];
+  ctx;
+};
+var outboxListeners = /* @__PURE__ */ new Set();
+function subscribeOutboxWrites(listener) {
+  outboxListeners.add(listener);
+  return () => {
+    outboxListeners.delete(listener);
+  };
+}
+function notifyOutboxCommit() {
+  for (const listener of outboxListeners) listener();
+}
+function isKeyRange(key) {
+  return key !== null && typeof key === "object" && !Array.isArray(key) && ("lower" in key || "upper" in key || "lowerOpen" in key || "upperOpen" in key);
+}
+function mutationBytes(op) {
+  if (op.op !== "put") return 32;
+  let bytes = 32;
+  const field = BINARY_SYNC_FIELDS[op.store];
+  const value = op.value;
+  const data = field && value !== null && typeof value === "object" && !Array.isArray(value) && field in value ? Reflect.get(value, field) : void 0;
+  bytes += typeof data === "string" ? data.length : data instanceof ArrayBuffer ? Math.ceil(data.byteLength / 3) * 4 + 64 : JSON.stringify(op.value)?.length ?? 0;
+  return bytes;
+}
+var SNAPSHOT_OP_ORDER = [
+  "block_revisions",
+  "notes",
+  "sessions",
+  ...NON_SYSTEM_STORES.filter(
+    (name) => name !== "block_revisions" && name !== "notes" && name !== "sessions"
+  )
+];
+async function policySnapshotOps(readAll) {
+  const ctx = collectUserScopeContext(await readAll("notes"));
+  const ops = [];
+  for (const store of SNAPSHOT_OP_ORDER) {
+    const def = STORE_DEFS.find((candidate) => candidate.name === store);
+    for (const row of await readAll(store)) {
+      if (!isUserOwnedRow(store, row, ctx)) continue;
+      ops.push({ op: "put", store, key: keyFromValue(def, row), value: row });
+    }
+  }
+  return ops;
+}
+var IDBStore = class _IDBStore {
+  constructor(owner, name, tx, mutable = false, touched, journal) {
+    this.owner = owner;
+    this.name = name;
+    this.tx = tx;
+    this.mutable = mutable;
+    this.touched = touched;
+    this.journal = journal;
+  }
+  owner;
+  name;
+  tx;
+  mutable;
+  touched;
+  journal;
+  async get(key) {
+    if (this.tx) return this.tx.objectStore(this.name).get(key);
+    return (await this.owner.open()).get(this.name, key);
+  }
+  async getMany(keys) {
+    if (this.tx) return Promise.all(keys.map((key) => this.tx.objectStore(this.name).get(key)));
+    return this.owner.transaction([this.name], "readonly", (tx) => tx.readonly(this.name).getMany(keys));
+  }
+  async getAll(query, count) {
+    if (this.tx) return this.tx.objectStore(this.name).getAll(query, count);
+    return (await this.owner.open()).getAll(this.name, query, count);
+  }
+  async getAllFromIndex(index, query, count) {
+    if (this.tx) return this.tx.objectStore(this.name).index(index).getAll(query, count);
+    return (await this.owner.open()).getAllFromIndex(this.name, index, query, count);
+  }
+  async getAllFromIndexMany(index, keys) {
+    if (this.tx) return Promise.all(keys.map((key) => this.tx.objectStore(this.name).index(index).getAll(key)));
+    return this.owner.transaction([this.name], "readonly", (tx) => tx.readonly(this.name).getAllFromIndexMany(index, keys));
+  }
+  async count(query) {
+    if (this.tx) return this.tx.objectStore(this.name).count(query);
+    return (await this.owner.open()).count(this.name, query);
+  }
+  async countFromIndex(index, query) {
+    if (this.tx) return this.tx.objectStore(this.name).index(index).count(query);
+    return (await this.owner.open()).countFromIndex(this.name, index, query);
+  }
+  async put(value, _key) {
+    if (!this.mutable) throw new Error("read-only store");
+    if (!this.tx) {
+      const scope = this.name === "notes" ? [this.name, "block_revisions"] : [this.name, "block_revisions", "notes"];
+      return this.owner.transaction([...scope], "readwrite", (tx) => tx.readwrite(this.name).put(value));
+    }
+    const stored = this.owner.stamp(this.name, value);
+    validateStorageRow(this.name, stored);
+    const def = STORE_DEFS.find((def2) => def2.name === this.name);
+    const key = keyFromValue(def, stored);
+    const store = this.tx.objectStore(this.name);
+    const previous = await store.get(key);
+    if (this.name === "block_revisions" && previous !== void 0 && !rowsEqual(previous, stored)) throw new Error("immutable block revision collision");
+    if (this.name === "notes") validateNoteWrite(previous, stored);
+    if (this.name === "sessions") validateSessionWrite(previous, stored);
+    if (rowsEqual(previous, stored)) return key;
+    const result = await store.put(stored);
+    if (!def.system && this.journal) {
+      const ctx = this.name === "notes" ? void 0 : await (this.journal.ctx ??= this.owner.policyContext(this.tx));
+      const wasUser = previous !== void 0 && isUserOwnedRow(this.name, previous, ctx ?? collectUserScopeContext([]));
+      const isUser = isUserOwnedRow(this.name, stored, ctx ?? collectUserScopeContext([]));
+      if (isUser) {
+        if (this.name === "notes" && stored !== null && typeof stored === "object" && "id" in stored) {
+          for (const revision of await this.tx.objectStore("block_revisions").index("by-note").getAll(String(stored.id))) {
+            this.journal.ops.push({ op: "put", store: "block_revisions", key: [revision.noteId, revision.blockId, revision.version], value: revision });
+          }
+        } else if (this.name === "sessions" && stored !== null && typeof stored === "object" && "noteId" in stored && "blockId" in stored && "blockVersion" in stored) {
+          const revisionKey = [stored.noteId, stored.blockId, stored.blockVersion];
+          const revision = await this.tx.objectStore("block_revisions").get(revisionKey);
+          if (revision) this.journal.ops.push({ op: "put", store: "block_revisions", key: revisionKey, value: revision });
+        }
+        this.journal.ops.push({ op: "put", store: this.name, key, value: stored });
+      } else if (wasUser) this.journal.ops.push({ op: "delete", store: this.name, key });
+      if (this.name === "notes") this.journal.ctx = void 0;
+    }
+    if (this.name === "notes") this.touched?.notes.add(String(key));
+    if (this.name === "sessions") this.touched?.sessions.add(String(key));
+    return result;
+  }
+  async putMany(values, keys) {
+    if (keys && keys.length !== values.length) throw new Error("putMany key count mismatch");
+    if (!this.tx) {
+      const scope = this.name === "notes" ? [this.name, "block_revisions"] : [this.name, "block_revisions", "notes"];
+      return this.owner.transaction([...scope], "readwrite", (tx) => tx.readwrite(this.name).putMany(values, keys));
+    }
+    const out = [];
+    for (let i = 0; i < values.length; i++) out.push(await this.put(values[i], keys?.[i]));
+    return out;
+  }
+  async delete(key) {
+    if (!this.mutable) throw new Error("read-only store");
+    if (this.name === "block_revisions") throw new Error("block history requires explicit wipe");
+    if (!this.tx) {
+      const scope = this.name === "notes" ? [this.name] : [this.name, "notes"];
+      return this.owner.transaction([...scope], "readwrite", (tx) => tx.readwrite(this.name).delete(key));
+    }
+    if (this.name === "notes") {
+      for (const note of await this.tx.objectStore("notes").getAll(key)) {
+        for (const name of ["block_index", "block_efforts", "block_equipment"]) {
+          const store = this.tx.objectStore(name);
+          for (const id of await store.index("by-note").getAllKeys(note.id)) {
+            const projection = new _IDBStore(this.owner, name, this.tx, true, this.touched, this.journal);
+            await projection.delete(id);
+          }
+        }
+      }
+    }
+    await this.recordDelete(key);
+    await this.tx.objectStore(this.name).delete(key);
+  }
+  /** Journal a delete as per-key tombstones (ranges expand to their keys).
+   *  Journal-time ownership: only deletes of USER-scope rows ship — a seed
+   *  row's removal is re-imported remotely, not a user mutation (deleting a
+   *  seed NOTE carries intent via the user-deleted-seed meta tombstone the
+   *  caller writes in the same transaction). */
+  async recordDelete(key) {
+    if (!this.journal) return;
+    const store = this.tx.objectStore(this.name);
+    const keys = isKeyRange(key) ? await store.getAllKeys(key) : [key];
+    const ctx = this.name === "notes" ? void 0 : await (this.journal.ctx ??= this.owner.policyContext(this.tx));
+    for (const k of keys) {
+      const previous = await store.get(k);
+      if (previous !== void 0 && !isUserOwnedRow(this.name, previous, ctx ?? collectUserScopeContext([]))) continue;
+      this.journal.ops.push({ op: "delete", store: this.name, key: k });
+    }
+  }
+  /**
+   * User-scope clear: expands to per-key deletes of user-owned rows,
+   * journaled the same way so replay preserves exactly what the local clear
+   * preserved — seed content (re-importable), pinned revision history
+   * (block_revisions requires explicit wipe) and seed-deletion tombstones
+   * survive a clear. A journaled `{op:'clear'}` would wipe seed rows on
+   * every replaying device.
+   */
+  async clear() {
+    if (!this.mutable) throw new Error("read-only store");
+    if (this.name === "block_revisions") throw new Error("block history requires explicit wipe");
+    if (!this.tx) {
+      const scope = this.name === "notes" ? ["notes", "block_index", "block_efforts"] : [this.name, "notes"];
+      return this.owner.transaction([...scope], "readwrite", (tx) => tx.readwrite(this.name).clear());
+    }
+    const store = this.tx.objectStore(this.name);
+    const rows = await store.getAll();
+    const notes = this.name === "notes" ? rows : await this.tx.objectStore("notes").getAll();
+    const ctx = collectUserScopeContext(notes);
+    for (const row of rows) {
+      const key = keyFromValue(STORE_DEFS.find((def) => def.name === this.name), row);
+      if (!isUserOwnedRow(this.name, row, ctx)) continue;
+      if (this.name === "meta" && typeof key === "string" && key.startsWith(USER_DELETED_SEED_PREFIX)) continue;
+      if (this.name === "notes" && typeof key === "string") {
+        for (const name of ["block_index", "block_efforts", "block_equipment"]) {
+          const projections = this.tx.objectStore(name);
+          for (const id of await projections.index("by-note").getAllKeys(key)) {
+            this.journal?.ops.push({ op: "delete", store: name, key: id });
+            await projections.delete(id);
+          }
+        }
+      }
+      await this.recordDelete(key);
+      await store.delete(key);
+    }
+  }
+};
+var SEGMENT_TO_BLOCK_KIND = { script: "wod", wod: "wod" };
+function legacyDialect(rawContent) {
+  const first = rawContent.slice(0, rawContent.indexOf("\n"));
+  return wodWikiCore.matchDialectFence(first.trim()) ?? {};
+}
+var IndexedDBStorage = class {
+  constructor(options = {}) {
+    this.options = options;
+  }
+  options;
+  opening;
+  open() {
+    if (typeof indexedDB === "undefined") return Promise.reject(new Error("IndexedDB is unavailable in this environment"));
+    if (!this.opening) {
+      let newer = false;
+      let pre20 = 0;
+      let migrationError;
+      this.opening = idb.openDB(this.options.dbName ?? IDB_DB_NAME, DB_VERSION, {
+        upgrade: async (db, oldVersion, _version, tx) => {
+          void tx.done.catch(() => {
+          });
+          if (oldVersion > DB_VERSION) {
+            newer = true;
+            tx.abort();
+            return;
+          }
+          if (oldVersion !== 0 && oldVersion < 20) {
+            pre20 = oldVersion;
+            tx.abort();
+            return;
+          }
+          try {
+            createMissingStores(db, tx);
+            if (oldVersion !== 0 && oldVersion < DB_VERSION) this.options.onUpgradeStart?.(oldVersion);
+            await migrateSchema(db, oldVersion, tx);
+          } catch (error) {
+            migrationError = error instanceof Error ? error : new Error(String(error));
+            try {
+              tx.abort();
+            } catch {
+            }
+          }
+        },
+        blocking: () => {
+          void this.close();
+        }
+      }).catch((error) => {
+        this.opening = void 0;
+        if (migrationError) throw migrationError;
+        if (pre20 !== 0) {
+          throw new Error(
+            `local database schema v${pre20} predates the supported migration chain (v20+). Open this browser profile in an intermediate app version to export your data, or clear site data to start fresh \u2014 the old database was left untouched.`
+          );
+        }
+        throw newer || error instanceof DOMException && error.name === "VersionError" ? new Error(`database schema is newer than this client supports (v${DB_VERSION}); refusing to downgrade`) : error;
+      });
+    }
+    return this.opening;
+  }
+  stamp(store, value) {
+    const userId = this.options.getUserId?.();
+    return userId ? stampUserOwned(store, value, userId) : value;
+  }
+  /** User-scope context (proven seed note ids) from the notes of `tx` —
+   *  journal-time ownership classification reads it INSIDE the same
+   *  transaction, so a seed import's note writes are visible to the link
+   *  writes that follow in the same commit. Internal seam for IDBStore. */
+  async policyContext(tx) {
+    const notes = tx ? await tx.objectStore("notes").getAll() : await (await this.open()).getAll("notes");
+    return collectUserScopeContext(notes);
+  }
+  readonly(store) {
+    return new IDBStore(this, store);
+  }
+  readwrite(store) {
+    return new IDBStore(this, store, void 0, true);
+  }
+  async transaction(stores, mode, fn) {
+    const db = await this.open();
+    const journal = mode === "readwrite" ? new TxJournal() : void 0;
+    const scope = new Set(stores);
+    if (mode === "readwrite") {
+      scope.add("block_revisions");
+      scope.add(OUTBOX_STORE);
+      scope.add("notes");
+      if (scope.has("notes")) {
+        scope.add("block_index");
+        scope.add("block_efforts");
+        scope.add("block_equipment");
+      }
+    }
+    const native = db.transaction([...scope], mode);
+    const done = native.done;
+    void done.catch(() => {
+    });
+    const touched = { notes: /* @__PURE__ */ new Set(), sessions: /* @__PURE__ */ new Set() };
+    const adapter = {
+      readonly: (name) => {
+        if (!scope.has(name)) throw new Error("store outside transaction scope");
+        return new IDBStore(this, name, native);
+      },
+      readwrite: (name) => {
+        if (mode !== "readwrite") throw new Error("read-only transaction");
+        if (!scope.has(name)) throw new Error("store outside transaction scope");
+        return new IDBStore(this, name, native, true, touched, journal);
+      }
+    };
+    try {
+      const result = await fn(adapter);
+      const notes = (await Promise.all([...touched.notes].map((id) => native.objectStore("notes").get(id)))).filter(Boolean);
+      const sessions = (await Promise.all([...touched.sessions].map((id) => native.objectStore("sessions").get(id)))).filter(Boolean);
+      await validateStoredPins(notes, sessions, (keys) => Promise.all(keys.map((key) => native.objectStore("block_revisions").get(key))));
+      if (journal && journal.ops.length > 0) {
+        await native.objectStore(OUTBOX_STORE).put({ id: crypto.randomUUID(), at: Date.now(), ops: journal.ops });
+      }
+      await done;
+      if (journal && journal.ops.length > 0) notifyOutboxCommit();
+      return result;
+    } catch (error) {
+      try {
+        native.abort();
+      } catch {
+      }
+      await done.catch(() => {
+      });
+      throw error;
+    }
+  }
+  async wipeUserData() {
+    const names = STORE_DEFS.filter((def) => !def.system && def.name !== "block_revisions").map((def) => def.name);
+    await this.transaction(names, "readwrite", async (tx) => {
+      for (const name of names) await tx.readwrite(name).clear();
+    });
+  }
+  async wipe() {
+    const db = await this.open();
+    const names = STORE_DEFS.filter((def) => !def.system).map((def) => def.name);
+    const tx = db.transaction([...names, OUTBOX_STORE], "readwrite");
+    await Promise.all(names.map((name) => tx.objectStore(name).clear()));
+    await tx.objectStore(OUTBOX_STORE).put({ id: crypto.randomUUID(), at: Date.now(), ops: [{ op: "wipe" }] });
+    await tx.done;
+    notifyOutboxCommit();
+  }
+  // -----------------------------------------------------------------------
+  // Sync seams (Turso backup engine only — not part of IStorage).
+  // -----------------------------------------------------------------------
+  /** Pending committed transaction groups, in commit order. */
+  async readOutbox(afterSeq, limit) {
+    const db = await this.open();
+    const range = IDBKeyRange.lowerBound(afterSeq, true);
+    return await db.getAll(OUTBOX_STORE, range, Math.min(limit, 4294967295));
+  }
+  /** Drop acknowledged groups. Callers pass only the contiguous acked
+   *  watermark — a failed upload never truncates pending writes. */
+  async ackOutbox(upToSeq) {
+    const db = await this.open();
+    const keys = await db.getAllKeys(OUTBOX_STORE, IDBKeyRange.upperBound(upToSeq));
+    const tx = db.transaction(OUTBOX_STORE, "readwrite");
+    await Promise.all(keys.map((key) => tx.store.delete(key)));
+    await tx.done;
+  }
+  async getSyncState(key) {
+    const row = await (await this.open()).get(SYNC_STATE_STORE, key);
+    return row?.value;
+  }
+  async setSyncState(key, value) {
+    await (await this.open()).put(SYNC_STATE_STORE, { key, value });
+  }
+  /**
+   * Freeze ONE durable bootstrap run for `key` (per backup target): a
+   * policy-compliant snapshot of the current rows, chunked into ≤500-op /
+   * ≤~1MB entries with a unique run UUID and stable chunk ids, persisted in
+   * `sync_state[key]` in the SAME readwrite transaction that reads the data
+   * — so a retry returns the byte-identical frozen entries (idempotent
+   * remote replays), and a crash before the commit freezes nothing. No
+   * network happens here.
+   *
+   * Pending outbox groups are read INSIDE the same transaction: their
+   * touched keys/stores are excluded from the snapshot so the journal (which
+   * ships after the bootstrap, in commit order) stays the last writer and
+   * nothing ships twice. A pending wipe freezes an empty run — the journal
+   * wipe itself still ships and decides the remote's end state.
+   *
+   * The engine deletes the frozen run (`db.delete('sync_state', key)`) only
+   * after the remote commit; until then every retry replays these entries.
+   */
+  async captureSyncBootstrap(key) {
+    const db = await this.open();
+    const tx = db.transaction([...NON_SYSTEM_STORES, OUTBOX_STORE, SYNC_STATE_STORE], "readwrite");
+    const state = tx.objectStore(SYNC_STATE_STORE);
+    const frozen = await state.get(key);
+    if (frozen !== void 0 && Array.isArray(frozen.value)) {
+      await tx.done;
+      return frozen.value;
+    }
+    const pendingKeys = /* @__PURE__ */ new Set();
+    const clearedStores = /* @__PURE__ */ new Set();
+    let wiped = false;
+    for (const group of await tx.objectStore(OUTBOX_STORE).getAll()) {
+      for (const op of group.ops) {
+        if (op.op === "put" || op.op === "delete") pendingKeys.add(`${op.store}:${JSON.stringify(op.key)}`);
+        else if (op.op === "clear") clearedStores.add(op.store);
+        else wiped = true;
+      }
+    }
+    const run = crypto.randomUUID();
+    const entries = [];
+    if (!wiped) {
+      let ops = [];
+      let bytes = 0;
+      const flush = () => {
+        if (ops.length === 0) return;
+        entries.push({ id: `bootstrap:${run}:${entries.length}`, at: Date.now(), ops });
+        ops = [];
+        bytes = 0;
+      };
+      for (const op of await policySnapshotOps((store) => tx.objectStore(store).getAll())) {
+        if (clearedStores.has(op.store)) continue;
+        if (op.store !== "block_revisions" && pendingKeys.has(`${op.store}:${JSON.stringify(op.key)}`)) continue;
+        const size = mutationBytes(op);
+        if (ops.length > 0 && (ops.length >= BOOTSTRAP_MAX_OPS || bytes + size > BOOTSTRAP_MAX_BYTES)) flush();
+        ops.push(op);
+        bytes += size;
+      }
+      flush();
+    }
+    await state.put({ key, value: entries });
+    await tx.done;
+    return entries;
+  }
+  /**
+   * Validate every stored pin (note blocks + session pins against
+   * block_revisions) in ONE consistent readonly read — the post-restore
+   * gate: a replayed backup with missing history fails loudly here instead
+   * of surfacing later as broken sessions.
+   */
+  async validateSyncState() {
+    const db = await this.open();
+    const tx = db.transaction(["notes", "sessions", "block_revisions"], "readonly");
+    const notes = await tx.objectStore("notes").getAll();
+    const sessions = await tx.objectStore("sessions").getAll();
+    const revisions = tx.objectStore("block_revisions");
+    await validateStoredPins(
+      notes,
+      sessions,
+      (keys) => Promise.all(keys.map((key) => revisions.get(key)))
+    );
+    await tx.done;
+  }
+  /**
+   * Apply remotely committed mutations locally (pull/replay) WITHOUT
+   * journaling — a pulled mutation must never re-enter the outbox. Runs in
+   * one native transaction together with the cursor update.
+   *
+   * Unsent-edit overlay: pending outbox groups (committed local writes not
+   * yet acknowledged remotely) are read INSIDE the same transaction and
+   * replayed after the remote rows — a local edit/delete/clear/wipe that
+   * committed while the pull was on the network stays the visible state;
+   * the remote row is backed up locally, not clobbered over the user.
+   *
+   * Conflict policy (deterministic, history-preserving):
+   *  - notes: an incoming row with a LOWER sourceRevision than the existing
+   *    row is stale — skipped, never clobbers newer history.
+   *  - block_revisions: same key with different contents keeps BOTH rows —
+   *    the incoming version is re-keyed to the next free version for that
+   *    block. Immutable history is never silently replaced.
+   *  - memberships (system): remote mutations are skipped — identity truth
+   *    stays local and snapshot/upload never include them.
+   *
+   * Returns committed-boundary counts of canonical consumer records (notes +
+   *  efforts only; internal/journal rows never reach the sync toast).
+   * `cursorKey` keeps cursors per backup target.
+   */
+  async applySyncMutations(mutations, cursorRev, cursorKey = "cursor") {
+    const defsByName = new Map(STORE_DEFS.map((def) => [def.name, def]));
+    for (const mutation of mutations) {
+      if (mutation.op === "clear" || mutation.op === "wipe") continue;
+      const def = defsByName.get(mutation.store);
+      if (!def) throw new Error(`unknown store in sync mutation: ${String(mutation.store)}`);
+      if (mutation.op === "put" || mutation.op === "delete") {
+        const parts = Array.isArray(mutation.key) ? mutation.key : [mutation.key];
+        if (parts.length !== def.keyPath.length || !parts.every((part) => typeof part === "string" || typeof part === "number")) {
+          throw new Error(`sync ${mutation.op} key arity/shape mismatch for ${mutation.store}`);
+        }
+      }
+      if (mutation.op === "put") validateStorageRow(mutation.store, mutation.value);
+    }
+    const db = await this.open();
+    const names = NON_SYSTEM_STORES;
+    const tx = db.transaction([...names, OUTBOX_STORE, SYNC_STATE_STORE], "readwrite");
+    const canonical = (store) => store === "notes" || store === "efforts";
+    const touched = /* @__PURE__ */ new Map();
+    for (const mutation of mutations) {
+      if (mutation.op === "clear" || mutation.op === "wipe") continue;
+      if (!canonical(mutation.store)) continue;
+      const id = `${mutation.store}:${JSON.stringify(mutation.key)}`;
+      if (touched.has(id)) continue;
+      const key = mutation.key;
+      const before = await tx.objectStore(mutation.store).get(key);
+      touched.set(id, { store: mutation.store, key, before, beforeExists: before !== void 0 });
+    }
+    const applyOne = async (mutation, preferLocal) => {
+      if (mutation.op === "wipe") {
+        for (const name of names) await tx.objectStore(name).clear();
+        return;
+      }
+      if (mutation.store === "memberships") return;
+      if (mutation.op === "clear") {
+        if (mutation.store === "block_revisions") return;
+        const store2 = tx.objectStore(mutation.store);
+        const ctx = collectUserScopeContext(await tx.objectStore("notes").getAll());
+        for (const row of await store2.getAll()) {
+          if (!isUserOwnedRow(mutation.store, row, ctx)) continue;
+          const key = keyFromValue(defsByName.get(mutation.store), row);
+          if (mutation.store === "meta" && typeof key === "string" && key.startsWith(USER_DELETED_SEED_PREFIX)) continue;
+          await applyOne({ op: "delete", store: mutation.store, key }, preferLocal);
+        }
+        return;
+      }
+      if (mutation.op === "delete") {
+        if (mutation.store === "notes") {
+          const noteId = String(Array.isArray(mutation.key) ? mutation.key[0] : mutation.key);
+          for (const name of ["block_index", "block_efforts", "block_equipment"]) {
+            const store2 = tx.objectStore(name);
+            for (const id of await store2.index("by-note").getAllKeys(noteId)) await store2.delete(id);
+          }
+        }
+        if (mutation.store !== "block_revisions") await tx.objectStore(mutation.store).delete(mutation.key);
+        return;
+      }
+      const store = tx.objectStore(mutation.store);
+      if (mutation.store === "block_revisions") {
+        const existing = await store.get(mutation.key);
+        if (existing !== void 0 && !rowsEqual(existing, mutation.value) && !preferLocal) {
+          const incoming = mutation.value;
+          const existingRow = existing;
+          let version = existingRow.version + 1;
+          while (await store.get([incoming.noteId, incoming.blockId, version]) !== void 0) version += 1;
+          await store.put({ ...incoming, version });
+          return;
+        }
+        if (existing === void 0 || !rowsEqual(existing, mutation.value)) await store.put(mutation.value);
+        return;
+      }
+      if (mutation.store === "notes" && !preferLocal) {
+        const existing = await store.get(mutation.key);
+        if (existing !== void 0) {
+          const existingNote = existing;
+          const incomingNote = mutation.value;
+          if (existingNote.sourceRevision > incomingNote.sourceRevision) return;
+        }
+      }
+      await store.put(mutation.value);
+    };
+    for (const mutation of mutations) await applyOne(mutation, false);
+    const pending = (await tx.objectStore(OUTBOX_STORE).getAll()).sort((a, b) => a.seq - b.seq);
+    for (const group of pending) {
+      for (const op of group.ops) await applyOne(op, true);
+    }
+    let added = 0;
+    let updated = 0;
+    for (const entry of touched.values()) {
+      const final = await tx.objectStore(entry.store).get(entry.key);
+      if (final === void 0) continue;
+      if (!entry.beforeExists) added += 1;
+      else if (!rowsEqual(entry.before, final)) updated += 1;
+    }
+    if (cursorRev !== null) await tx.objectStore(SYNC_STATE_STORE).put({ key: cursorKey, value: { rev: cursorRev } });
+    await tx.done;
+    return { added, updated };
+  }
+  /**
+   * Consistent atomic snapshot, policy-compliant (shared user policy): only
+   * user-scope rows of the non-system stores, read in ONE readonly
+   * transaction — the backup never mixes the pre/post state of a concurrent
+   * local commit. System stores (memberships) are excluded: they never sync.
+   * Use `snapshotAllRows` for the lossless (unfiltered) form.
+   */
+  async snapshotRows() {
+    const db = await this.open();
+    const defs = STORE_DEFS.filter((def) => !def.system);
+    const tx = db.transaction(defs.map((def) => def.name), "readonly");
+    const ctx = collectUserScopeContext(await tx.objectStore("notes").getAll());
+    const out = await Promise.all(
+      defs.map(async (def) => ({
+        store: def.name,
+        rows: (await tx.objectStore(def.name).getAll()).filter((row) => isUserOwnedRow(def.name, row, ctx))
+      }))
+    );
+    await tx.done;
+    return out;
+  }
+  /** Lossless snapshot of every NON-SYSTEM store (meta included) in one
+   *  readonly transaction — local export / restore emptiness checks. A
+   *  freshly initialized database may hold a default membership, so the
+   *  system store is excluded from both uses. */
+  async snapshotAllRows() {
+    const db = await this.open();
+    const defs = STORE_DEFS.filter((def) => !def.system);
+    const tx = db.transaction(defs.map((def) => def.name), "readonly");
+    const out = await Promise.all(
+      defs.map(async (def) => ({ store: def.name, rows: await tx.objectStore(def.name).getAll() }))
+    );
+    await tx.done;
+    return out;
+  }
+  async close() {
+    const opening = this.opening;
+    this.opening = void 0;
+    (await opening?.catch(() => void 0))?.close();
+  }
+};
+var SCRATCH_TABLES = [
+  ...STORE_DEFS.map((def) => ({ name: def.name, keyPath: def.keyPath })),
+  ...LEGACY_EXTRA_TABLES.map((table) => ({ name: table.name, keyPath: Array.isArray(table.keyPath) ? table.keyPath : [table.keyPath] }))
+];
+var SCRATCH_TABLE_BY_NAME = Object.fromEntries(
+  SCRATCH_TABLES.map((table) => [table.name, table.keyPath])
+);
+function assertKnownStore(store) {
+  if (!SCRATCH_TABLE_BY_NAME[store]) throw new Error(`unknown store "${store}" in source op log; copy aborted`);
+}
+function rowKey(table, row) {
+  const parts = [];
+  for (const part of SCRATCH_TABLE_BY_NAME[table]) {
+    const value = row[part];
+    if (typeof value !== "string" && typeof value !== "number" && !(value instanceof Date)) {
+      throw new Error(`row for store "${table}" is missing keyPath field "${part}"; copy aborted`);
+    }
+    parts.push(value);
+  }
+  return parts.length === 1 ? parts[0] : parts;
+}
+function isIdbKey(value) {
+  return typeof value === "string" || typeof value === "number" || value instanceof Date || Array.isArray(value) && value.length > 0 && value.every(isIdbKey);
+}
+function arrayBuffersEqual(a, b) {
+  if (a.byteLength !== b.byteLength) return false;
+  const left = new Uint8Array(a);
+  const right = new Uint8Array(b);
+  return left.every((byte, i) => byte === right[i]);
+}
+function deleteIdbDatabase(name) {
+  const idb = globalThis.indexedDB;
+  if (!idb) return Promise.resolve();
+  return new Promise((resolve, reject) => {
+    const request = idb.deleteDatabase(name);
+    request.onsuccess = () => {
+      resolve();
+    };
+    request.onerror = () => {
+      reject(request.error ?? new Error(`failed to delete ${name}`));
+    };
+    request.onblocked = () => {
+      resolve();
+    };
+  });
+}
+async function buildScratch(name, version, ops) {
+  const db = await idb.openDB(name, version, {
+    upgrade(scratch) {
+      for (const table of SCRATCH_TABLES) {
+        if (!scratch.objectStoreNames.contains(table.name)) {
+          scratch.createObjectStore(table.name, { keyPath: table.keyPath.length === 1 ? table.keyPath[0] : table.keyPath });
+        }
+      }
+    }
+  });
+  try {
+    for (const op of ops) {
+      if (!db.objectStoreNames.contains(op.table)) {
+        throw new Error(`unknown store "${op.table}" in source; copy aborted`);
+      }
+      if (op.kind === "put") await db.transaction(op.table, "readwrite").objectStore(op.table).put(op.row);
+      else if (op.kind === "delete") await db.transaction(op.table, "readwrite").objectStore(op.table).delete(op.key);
+      else await db.transaction(op.table, "readwrite").objectStore(op.table).clear();
+    }
+  } finally {
+    db.close();
+  }
+}
+async function assertBinaryPreserved(sourceOps, converted) {
+  const source = /* @__PURE__ */ new Map();
+  for (const op of sourceOps) {
+    if (op.kind === "clear") {
+      if (op.table === "attachments") source.clear();
+    } else if (op.kind === "put" && op.table === "attachments") {
+      if (op.row === null || typeof op.row !== "object" || Array.isArray(op.row) || !("id" in op.row)) {
+        throw new Error("malformed attachment row in source; copy aborted");
+      }
+      source.set(String(op.row.id), op.row);
+    } else if (op.kind === "delete" && op.table === "attachments") {
+      source.delete(String(op.key));
+    }
+  }
+  if (source.size === 0) return;
+  const rows = await converted.readonly("attachments").getAll();
+  const byId = new Map(rows.map((row) => [row.id, row]));
+  for (const [id, row] of source) {
+    const restored = byId.get(id);
+    if (!restored) throw new Error(`attachment ${id} missing after conversion; copy aborted, source untouched`);
+    const before = row.data;
+    const after = restored.data;
+    if (typeof before === "string" || typeof after === "string") {
+      if (before !== after) throw new Error(`attachment ${id} payload changed during conversion; copy aborted, source untouched`);
+    } else if (!(before instanceof ArrayBuffer) || !(after instanceof ArrayBuffer) || !arrayBuffersEqual(before, after)) {
+      throw new Error(`attachment ${id} payload changed during conversion; copy aborted, source untouched`);
+    }
+  }
+}
+async function convertSyncSource(db, fromVersion, legacy) {
+  if (!Number.isSafeInteger(fromVersion) || fromVersion < 20) {
+    throw new Error(
+      `Backup database schema v${fromVersion} predates the supported migration chain (v20+); the source was left untouched. Restore it with an intermediate app version, or point this app at a fresh backup database.`
+    );
+  }
+  if (fromVersion > DB_VERSION) {
+    throw new Error(`Backup database schema is newer than this converter supports (v${fromVersion} > v${DB_VERSION}); refusing to downgrade.`);
+  }
+  const raw = [];
+  if (legacy) {
+    for (const table of [...NON_SYSTEM_STORES, ...LEGACY_EXTRA_TABLES.map((table2) => table2.name)]) {
+      for (const row of await readLegacyRows(db, table)) raw.push({ kind: "put", table, row });
+    }
+  } else {
+    for (const op of await readRawSyncOps(db)) {
+      if (op.op === "wipe") {
+        for (const name of [...NON_SYSTEM_STORES, ...LEGACY_EXTRA_TABLES.map((table) => table.name)]) {
+          raw.push({ kind: "clear", table: name });
+        }
+      } else if (op.op === "clear") {
+        assertKnownStore(op.store);
+        raw.push({ kind: "clear", table: op.store });
+      } else if (op.op === "put") {
+        assertKnownStore(op.store);
+        if (op.value === void 0 || op.value === null || typeof op.value !== "object" || Array.isArray(op.value)) {
+          throw new Error(`malformed put payload for store "${op.store}" in source op log; copy aborted`);
+        }
+        if (JSON.stringify(rowKey(op.store, op.value)) !== JSON.stringify(op.key)) {
+          throw new Error(`put key ${JSON.stringify(op.key)} does not match store "${op.store}" keyPath fields; copy aborted`);
+        }
+        raw.push({ kind: "put", table: op.store, row: op.value });
+      } else if (op.op === "delete") {
+        assertKnownStore(op.store);
+        if (!isIdbKey(op.key)) {
+          throw new Error(`malformed delete key for store "${op.store}" in source op log; copy aborted`);
+        }
+        raw.push({ kind: "delete", table: op.store, key: op.key });
+      } else {
+        throw new Error(`unknown op "${String(op.op)}" in source op log; copy aborted`);
+      }
+    }
+  }
+  const scratch = `wodwiki-convert-${crypto.randomUUID()}`;
+  const converted = new IndexedDBStorage({ dbName: scratch });
+  try {
+    await buildScratch(scratch, fromVersion, raw);
+    await converted.open();
+    await converted.validateSyncState();
+    await assertBinaryPreserved(raw, converted);
+    return await policySnapshotOps((store) => converted.readonly(store).getAll());
+  } finally {
+    await converted.close();
+    await deleteIdbDatabase(scratch).catch(() => void 0);
+  }
+}
+function createMissingStores(db, tx) {
+  for (const def of STORE_DEFS) {
+    if (db.objectStoreNames.contains(def.name)) {
+      const existing = tx.objectStore(def.name);
+      for (const index of def.indexes) {
+        if (!existing.indexNames.contains(index.name)) existing.createIndex(index.name, index.keyPath.length === 1 ? index.keyPath[0] : index.keyPath, { unique: index.unique, multiEntry: index.multiEntry });
+      }
+      continue;
+    }
+    const store = db.createObjectStore(def.name, { keyPath: def.keyPath.length === 1 ? def.keyPath[0] : def.keyPath });
+    for (const index of def.indexes) store.createIndex(index.name, index.keyPath.length === 1 ? index.keyPath[0] : index.keyPath, { unique: index.unique, multiEntry: index.multiEntry });
+  }
+  for (const local of LOCAL_SYNC_STORES) {
+    if (db.objectStoreNames.contains(local.name)) continue;
+    db.createObjectStore(local.name, { keyPath: local.keyPath, autoIncrement: "autoIncrement" in local ? local.autoIncrement : false });
+  }
+}
+async function migrateSchema(db, oldVersion, tx) {
+  const store = (name) => tx.objectStore(name);
+  if (oldVersion === 20 && db.objectStoreNames.contains("sessions")) {
+    const sessionsStore = store("sessions");
+    const eventsStore = store("events");
+    for await (const cursor of sessionsStore) {
+      const legacy = cursor.value;
+      const logs = legacy.data?.logs ?? [];
+      let alreadyProjected = false;
+      for await (const _ev of eventsStore.index("by-result-grain").iterate(IDBKeyRange.bound([legacy.id, ""], [legacy.id, []]))) {
+        alreadyProjected = true;
+        break;
+      }
+      if (!alreadyProjected && logs.length > 0) {
+        const identity = {
+          noteId: legacy.noteId,
+          resultId: legacy.id,
+          segmentId: legacy.segmentId,
+          segmentVersion: legacy.segmentVersion,
+          blockContentId: legacy.blockContentId,
+          origin: legacy.origin,
+          pageId: legacy.pageId,
+          workoutTimestamp: legacy.data?.endTime ?? legacy.createdAt
+        };
+        for (const row of wodWikiWql.toEventRows(logs, identity)) await eventsStore.put(row);
+        for (const row of wodWikiWql.toSummaryEventRows(logs, identity)) await eventsStore.put(row);
+      }
+      const flat = {
+        ...legacy,
+        startTime: legacy.data?.startTime ?? legacy.createdAt,
+        endTime: legacy.data?.endTime ?? legacy.createdAt,
+        duration: legacy.data?.duration ?? 0,
+        completed: legacy.data?.completed ?? true,
+        roundsCompleted: legacy.data?.roundsCompleted,
+        totalRounds: legacy.data?.totalRounds,
+        repsCompleted: legacy.data?.repsCompleted
+      };
+      delete flat.data;
+      await cursor.update(flat);
+    }
+  }
+  if (oldVersion === 21 && db.objectStoreNames.contains("meta")) {
+    await store("meta").delete("seed");
+  }
+  if (oldVersion < 25) {
+    for (const name of USER_OWNED_STORES) {
+      if (!db.objectStoreNames.contains(name)) continue;
+      const s = store(name);
+      if (!s.indexNames.contains("by-user")) s.createIndex("by-user", "userId");
+    }
+  }
+  if (db.objectStoreNames.contains("results")) {
+    const sessionsStore = store("sessions");
+    const resultsStore = store("results");
+    const eventsStore = store("events");
+    for await (const cursor of resultsStore) {
+      const { data: legacyData, ...legacyRow } = cursor.value;
+      const logs = legacyData?.logs ?? [];
+      if (logs.length > 0) {
+        const identity = {
+          noteId: legacyRow.noteId,
+          resultId: legacyRow.id,
+          segmentId: legacyRow.segmentId,
+          segmentVersion: legacyRow.segmentVersion,
+          blockContentId: legacyRow.blockContentId,
+          origin: legacyRow.origin,
+          pageId: legacyRow.pageId,
+          workoutTimestamp: legacyData?.endTime ?? legacyRow.createdAt
+        };
+        for (const row of wodWikiWql.toEventRows(logs, identity)) {
+          if (await eventsStore.get(row.id) === void 0) await eventsStore.put(row);
+        }
+        for (const row of wodWikiWql.toSummaryEventRows(logs, identity)) {
+          if (await eventsStore.get(row.id) === void 0) await eventsStore.put(row);
+        }
+      }
+      if (await sessionsStore.getKey(legacyRow.id) !== void 0) continue;
+      await sessionsStore.put({
+        ...legacyRow,
+        startTime: legacyData?.startTime ?? legacyRow.startTime ?? legacyRow.createdAt,
+        endTime: legacyData?.endTime ?? legacyRow.endTime ?? legacyRow.createdAt,
+        duration: legacyData?.duration ?? legacyRow.duration ?? 0,
+        completed: legacyData?.completed ?? legacyRow.completed ?? true,
+        roundsCompleted: legacyData?.roundsCompleted ?? legacyRow.roundsCompleted,
+        totalRounds: legacyData?.totalRounds ?? legacyRow.totalRounds,
+        repsCompleted: legacyData?.repsCompleted ?? legacyRow.repsCompleted
+      });
+    }
+    db.deleteObjectStore("results");
+  }
+  if (db.objectStoreNames.contains("block_index") && !store("block_index").indexNames.contains("by-source")) {
+    store("block_index").createIndex("by-source", "sourceId");
+  }
+  if (db.objectStoreNames.contains("notes") && !store("notes").indexNames.contains("by-created")) {
+    store("notes").createIndex("by-created", "createdAt");
+  }
+  if (db.objectStoreNames.contains("efforts") && !store("efforts").indexNames.contains("by-source")) {
+    store("efforts").createIndex("by-source", "registrySource");
+  }
+  if (db.objectStoreNames.contains("note_tags") && !store("note_tags").indexNames.contains("by-note-tag")) {
+    const noteTags = store("note_tags");
+    const winnerByPair = /* @__PURE__ */ new Map();
+    const dupes = [];
+    for await (const cursor of noteTags) {
+      const row = cursor.value;
+      const pair = `${row.noteId}${row.tagId}`;
+      const winner = winnerByPair.get(pair);
+      if (winner === void 0 || row.id < winner) {
+        winnerByPair.set(pair, row.id);
+        if (winner !== void 0) dupes.push(winner);
+      } else {
+        dupes.push(row.id);
+      }
+    }
+    for (const id of dupes) await noteTags.delete(id);
+    noteTags.createIndex("by-note-tag", ["noteId", "tagId"], { unique: true });
+  }
+  if (db.objectStoreNames.contains("notes") && db.objectStoreNames.contains("segments")) {
+    const segments = store("segments");
+    const notes = store("notes");
+    const repaired = /* @__PURE__ */ new Set();
+    for await (const cursor of segments) {
+      const segment = cursor.value;
+      if (segment.dataType !== "frontmatter" || repaired.has(segment.noteId)) continue;
+      if (!/(^|\n)dashboard:\s*["']?true["']?\s*(\n|$)/.test(segment.rawContent)) continue;
+      repaired.add(segment.noteId);
+      const note = await notes.get(segment.noteId);
+      if (!note || note.type === "dashboard" && note.sourceId === "dashboards") continue;
+      await notes.put({ ...note, type: "dashboard", sourceId: note.sourceId ?? "dashboards" });
+    }
+  }
+  if (db.objectStoreNames.contains("segments")) {
+    await migrateSegmentsToBlocks(db, tx);
+  }
+  if (oldVersion >= 30 && oldVersion < 32 && db.objectStoreNames.contains(OUTBOX_STORE)) {
+    const outbox = store(OUTBOX_STORE);
+    const ops = [];
+    for (const group of await outbox.getAll()) {
+      for (const mutation of group.ops) {
+        if (mutation.op === "wipe") {
+          for (const name of NON_SYSTEM_STORES) {
+            if (name !== "block_revisions") ops.push({ op: "clear", store: name });
+          }
+        } else if (mutation.op !== "put" && mutation.store !== "memberships" && mutation.store !== "block_revisions") {
+          ops.push(mutation);
+        }
+      }
+    }
+    ops.push(...await policySnapshotOps((name) => store(name).getAll()));
+    await outbox.clear();
+    if (ops.length > 0) await outbox.put({ id: crypto.randomUUID(), at: Date.now(), ops });
+    if (db.objectStoreNames.contains(SYNC_STATE_STORE)) {
+      const state = store(SYNC_STATE_STORE);
+      for (const key of await state.getAllKeys()) {
+        if (typeof key === "string" && key.startsWith(BOOTSTRAP_RUN_PREFIX)) await state.delete(key);
+      }
+    }
+  }
+}
+async function migrateSegmentsToBlocks(db, tx) {
+  const store = (name) => tx.objectStore(name);
+  const segments = await store("segments").getAll();
+  const notesStore = store("notes");
+  const revisionsStore = store("block_revisions");
+  const byNote = /* @__PURE__ */ new Map();
+  for (const segment of segments) {
+    const list = byNote.get(segment.noteId);
+    if (list) list.push(segment);
+    else byNote.set(segment.noteId, [segment]);
+  }
+  const blockIdBySegment = /* @__PURE__ */ new Map();
+  const blockById = /* @__PURE__ */ new Map();
+  for (const [noteId, noteSegments] of byNote) {
+    const latestById = /* @__PURE__ */ new Map();
+    for (const segment of noteSegments) {
+      const current = latestById.get(segment.id);
+      if (!current || segment.version > current.version) latestById.set(segment.id, segment);
+    }
+    const latest = [...latestById.values()].sort((a, b) => (a.position ?? Number.MAX_SAFE_INTEGER) - (b.position ?? Number.MAX_SAFE_INTEGER) || a.id.localeCompare(b.id));
+    const rawContent = latest.map((segment) => segment.sourceContent ?? `${segment.rawContent}
+`).join("");
+    const note = await notesStore.get(noteId);
+    if (!note) continue;
+    const sections = wodWikiCore.parseDocumentSections(rawContent, { registeredWidgets: wodWikiCore.KNOWN_SECTION_WIDGETS });
+    const actionableSections = sections.filter((section) => wodWikiCore.actionableSectionKind(section) !== null);
+    const legacyActionable = latest.filter((segment) => segment.dataType in SEGMENT_TO_BLOCK_KIND);
+    const blocks = {};
+    actionableSections.forEach((section, index) => {
+      const kind = wodWikiCore.actionableSectionKind(section);
+      const legacy2 = legacyActionable[index];
+      let id = legacy2?.id ?? `migrated-${index}`;
+      while (Object.hasOwn(blocks, id)) id = `${id}-${index}`;
+      const dialect = kind === "wod" && (section.type === "time" || section.type === "log") ? { dialect: section.type, ...section.sport ? { sport: section.sport } : {} } : {};
+      blocks[id] = { id, kind, version: legacy2?.version ?? 1, sourceRevision: 1, from: section.from, to: section.to, ...dialect };
+      if (legacy2) blockIdBySegment.set(`${noteId}${legacy2.id}`, id);
+      blockById.set(`${noteId}${id}`, { noteId, from: section.from, to: section.to, version: blocks[id].version });
+    });
+    const legacy = note;
+    delete legacy.segments;
+    delete legacy.segmentIds;
+    await notesStore.put({ ...legacy, rawContent, sourceRevision: 1, blocks });
+    const revisioned = new Set(legacyActionable.map((segment) => segment.id));
+    for (const segment of noteSegments) {
+      if (!revisioned.has(segment.id)) continue;
+      const dialect = legacyDialect(segment.rawContent);
+      await revisionsStore.put({
+        noteId,
+        blockId: segment.id,
+        version: segment.version,
+        kind: "wod",
+        rawContent: segment.rawContent,
+        savedAt: segment.createdAt,
+        ...dialect
+      });
+    }
+  }
+  const sessionsStore = store("sessions");
+  for (const row of await sessionsStore.getAll()) {
+    if (row.segmentId === void 0 && row.segmentVersion === void 0 && row.version === void 0) continue;
+    const { segmentId, segmentVersion, version, ...rest } = row;
+    await sessionsStore.put({
+      ...rest,
+      blockId: rest.blockId ?? segmentId ?? "",
+      blockVersion: rest.blockVersion ?? segmentVersion ?? version ?? 1
+    });
+  }
+  const eventsStore = store("events");
+  for (const row of await eventsStore.getAll()) {
+    if (row.segmentVersion === void 0 && row.segmentId === void 0) continue;
+    const { segmentVersion, segmentId, ...rest } = row;
+    await eventsStore.put({
+      ...rest,
+      ...rest.blockId === void 0 && segmentId !== void 0 ? { blockId: segmentId } : {},
+      ...rest.blockVersion === void 0 && segmentVersion !== void 0 ? { blockVersion: segmentVersion } : {}
+    });
+  }
+  const blockIndex = store("block_index");
+  for (const row of await blockIndex.getAll()) {
+    const mapped = blockIdBySegment.get(`${row.noteId}${row.segmentId}`) ?? row.segmentId;
+    const block = blockById.get(`${row.noteId}${mapped}`);
+    const next = {
+      ...row,
+      id: `${row.noteId}:${mapped}`,
+      blockId: mapped,
+      blockVersion: block?.version ?? row.segmentVersion ?? 1,
+      sourceRevision: 1,
+      ...block ? { from: block.from, to: block.to } : {},
+      dataType: row.dataType === "script" ? "wod" : row.dataType
+    };
+    delete next.segmentId;
+    delete next.segmentVersion;
+    if (next.id !== row.id) await blockIndex.delete(row.id);
+    await blockIndex.put(next);
+  }
+  db.deleteObjectStore("segments");
+}
+
+exports.IDB_DB_NAME = IDB_DB_NAME;
+exports.IndexedDBStorage = IndexedDBStorage;
+exports.convertSyncSource = convertSyncSource;
+exports.subscribeOutboxWrites = subscribeOutboxWrites;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map