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

package/dist/index.cjs

@@ -0,0 +1,623 @@
+'use strict';
+
+// src/schema.ts
+var DB_VERSION = 28;
+var COLUMN_TYPES = {
+  notes: { date: "number", createdAt: "number" },
+  page: { createdAt: "number" },
+  // page.date is a civil 'YYYY-MM-DD' string → TEXT
+  page_notes: { position: "number", createdAt: "number" },
+  tags: { createdAt: "number" },
+  tag_types: { createdAt: "number" },
+  note_tags: {},
+  segments: {
+    version: "number",
+    position: "number",
+    createdAt: "number",
+    updatedAt: "number",
+    isHistory: "boolean"
+  },
+  sessions: {
+    segmentVersion: "number",
+    version: "number",
+    startTime: "number",
+    endTime: "number",
+    duration: "number",
+    roundsCompleted: "number",
+    totalRounds: "number",
+    repsCompleted: "number",
+    completed: "boolean",
+    createdAt: "number"
+  },
+  attachments: { createdAt: "number" },
+  events: {
+    timestamp: "number",
+    segmentVersion: "number",
+    line: "number",
+    sourceStatementId: "number",
+    stackLevel: "number",
+    "timeSpan.started": "number",
+    "timeSpan.ended": "number"
+  },
+  field_catalog: {},
+  field_sources: {},
+  field_values: {},
+  field_catalog_meta: {},
+  efforts: { "baseAttributes.met": "number" },
+  block_index: {
+    segmentVersion: "number",
+    position: "number",
+    createdAt: "number",
+    isStatic: "boolean"
+  },
+  block_efforts: { createdAt: "number", isStatic: "boolean" },
+  meta: {},
+  memberships: { createdAt: "number" }
+};
+var STORE_DEFS = [
+  // 1. notes
+  { name: "notes", keyPath: ["id"], indexes: [
+    { name: "by-date", keyPath: ["date"] },
+    { name: "by-created", keyPath: ["createdAt"] },
+    { name: "by-user", keyPath: ["userId"] }
+  ] },
+  // 2. page
+  { name: "page", keyPath: ["id"], indexes: [
+    { name: "by-date", keyPath: ["date"], unique: true },
+    { name: "by-slug", keyPath: ["slug"], unique: true },
+    { name: "by-user", keyPath: ["userId"] }
+  ] },
+  // 2b. page_notes (V22)
+  { name: "page_notes", keyPath: ["id"], indexes: [
+    { name: "by-page", keyPath: ["pageId"] },
+    { name: "by-note", keyPath: ["noteId"] },
+    { name: "by-page-note", keyPath: ["pageId", "noteId"], unique: true },
+    { name: "by-user", keyPath: ["userId"] }
+  ] },
+  // 3. tags
+  { name: "tags", keyPath: ["id"], indexes: [
+    { name: "by-label", keyPath: ["label"], unique: true },
+    { name: "by-type", keyPath: ["type"] },
+    { name: "by-user", keyPath: ["userId"] }
+  ] },
+  // 3a. tag_types (V23)
+  { name: "tag_types", keyPath: ["id"], indexes: [
+    { name: "by-name", keyPath: ["name"], unique: true },
+    { name: "by-user", keyPath: ["userId"] }
+  ] },
+  // 4. note_tags
+  { name: "note_tags", keyPath: ["id"], indexes: [
+    { name: "by-note", keyPath: ["noteId"] },
+    { name: "by-tag", keyPath: ["tagId"] },
+    { name: "by-note-tag", keyPath: ["noteId", "tagId"], unique: true },
+    { name: "by-user", keyPath: ["userId"] }
+  ] },
+  // 5. segments
+  { name: "segments", keyPath: ["id", "version"], indexes: [
+    { name: "by-note", keyPath: ["noteId"] },
+    { name: "by-type", keyPath: ["dataType"] },
+    { name: "by-page", keyPath: ["pageId"] },
+    { name: "by-history", keyPath: ["isHistory"] },
+    { name: "by-user", keyPath: ["userId"] }
+  ] },
+  // 6. sessions
+  { name: "sessions", keyPath: ["id"], indexes: [
+    { name: "by-segment", keyPath: ["segmentId"] },
+    { name: "by-note", keyPath: ["noteId"] },
+    { name: "by-completed", keyPath: ["createdAt"] },
+    { name: "by-content", keyPath: ["blockContentId"] },
+    { name: "by-block", keyPath: ["blockId"] },
+    { name: "by-page", keyPath: ["pageId"] },
+    { name: "by-origin", keyPath: ["origin"] },
+    { name: "by-user", keyPath: ["userId"] }
+  ] },
+  // 7. results — removed in V26: legacy alias of sessions. The V26 upgrade
+  // migrates any residual rows into `sessions` (projecting pre-V21 data.logs
+  // into event rows) before dropping the store; no compatibility alias.
+  // 8. attachments
+  { name: "attachments", keyPath: ["id"], indexes: [
+    { name: "by-note", keyPath: ["noteId"] },
+    { name: "by-time", keyPath: ["createdAt"] },
+    { name: "by-page", keyPath: ["pageId"] },
+    { name: "by-result", keyPath: ["resultId"] },
+    { name: "by-user", keyPath: ["userId"] }
+  ] },
+  // 9. events
+  { name: "events", keyPath: ["id"], indexes: [
+    { name: "by-timestamp", keyPath: ["timestamp"] },
+    { name: "by-result-grain", keyPath: ["resultId", "grain"] },
+    { name: "by-content-grain", keyPath: ["blockContentId", "grain"] },
+    { name: "by-effort", keyPath: ["effortSlug"] },
+    { name: "by-outputType", keyPath: ["outputType"] },
+    { name: "by-grain", keyPath: ["grain"] },
+    { name: "by-metric-date", keyPath: ["metricDateKeys"], multiEntry: true },
+    { name: "by-user", keyPath: ["userId"] }
+  ] },
+  // 10. field catalog
+  { name: "field_catalog", keyPath: ["id"], indexes: [
+    { name: "by-path", keyPath: ["path"] }
+  ] },
+  { name: "field_sources", keyPath: ["id"], indexes: [] },
+  { name: "field_values", keyPath: ["key"], indexes: [
+    { name: "by-field", keyPath: ["fieldId"] }
+  ] },
+  { name: "field_catalog_meta", keyPath: ["id"], indexes: [] },
+  // 11. efforts
+  { name: "efforts", keyPath: ["slug"], indexes: [
+    { name: "by-discipline", keyPath: ["baseAttributes.discipline"] },
+    { name: "by-source", keyPath: ["registrySource"] },
+    { name: "by-user", keyPath: ["userId"] }
+  ] },
+  // 12. block_index
+  { name: "block_index", keyPath: ["id"], indexes: [
+    { name: "by-note", keyPath: ["noteId"] },
+    { name: "by-content", keyPath: ["blockContentId"] },
+    { name: "by-type", keyPath: ["dataType"] },
+    { name: "by-source", keyPath: ["sourceId"] },
+    { name: "by-user", keyPath: ["userId"] }
+  ] },
+  // 13. block_efforts
+  { name: "block_efforts", keyPath: ["id"], indexes: [
+    { name: "by-note", keyPath: ["noteId"] },
+    { name: "by-effort", keyPath: ["effortSlug"] },
+    { name: "by-block", keyPath: ["blockContentId"] },
+    { name: "by-user", keyPath: ["userId"] }
+  ] },
+  // 14. meta
+  { name: "meta", keyPath: ["key"], indexes: [] },
+  // 15. memberships (V25, system — survives wipe; truth lives in
+  // localStorage locally, in the SQL table on the API)
+  { name: "memberships", keyPath: ["id"], indexes: [], system: true }
+];
+
+// src/membership.ts
+var DEFAULT_MEMBERSHIP_ID = "default";
+function createDefaultMembership(now = Date.now()) {
+  return { id: DEFAULT_MEMBERSHIP_ID, displayName: "Anonymous", createdAt: now };
+}
+var USER_OWNED_STORES = [
+  "notes",
+  "page",
+  "page_notes",
+  "tags",
+  "tag_types",
+  "note_tags",
+  "segments",
+  "sessions",
+  "attachments",
+  "events",
+  "efforts",
+  "block_index",
+  "block_efforts"
+];
+var STAMPABLE = Object.fromEntries(
+  USER_OWNED_STORES.map((s) => [s, true])
+);
+function stampUserOwned(store, value, userId) {
+  if (!STAMPABLE[store]) return value;
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return value;
+  const row = value;
+  if (row.seedOrigin === "seed") return value;
+  if (row.userId === userId) return value;
+  return { ...row, userId };
+}
+
+// src/wire.ts
+function isRange(arg) {
+  return arg !== null && typeof arg === "object" && !Array.isArray(arg) && ("only" in arg || "lower" in arg || "upper" in arg || "lowerOpen" in arg || "upperOpen" in arg);
+}
+function extractKeyPart(value, dottedPath) {
+  let cur = value;
+  for (const part of dottedPath.split(".")) {
+    if (cur === null || typeof cur !== "object") return void 0;
+    const row = cur;
+    if (!(part in row)) return void 0;
+    cur = row[part];
+  }
+  if (cur === null || typeof cur === "object" || cur === void 0) return void 0;
+  return cur;
+}
+function keyFromValue(def, value) {
+  const parts = def.keyPath.map((p) => extractKeyPart(value, p));
+  for (const [i, part] of parts.entries()) {
+    if (part === void 0) {
+      throw new Error(`keyFromValue(${def.name}): keyPath part '${def.keyPath[i]}' missing on value`);
+    }
+  }
+  const key = parts;
+  return key.length === 1 ? key[0] : key;
+}
+function encodeKey(key) {
+  return encodeURIComponent(JSON.stringify(key));
+}
+function rangeFromIDB(query) {
+  if (query === void 0) return void 0;
+  if (!isRange(query)) {
+    const key = query;
+    return { only: key };
+  }
+  if (query.only !== void 0) return query;
+  const wire = {};
+  if (query.lower !== void 0 && query.lower !== null) {
+    wire.lower = query.lower;
+    wire.lowerOpen = query.lowerOpen === true;
+  }
+  if (query.upper !== void 0 && query.upper !== null) {
+    wire.upper = query.upper;
+    wire.upperOpen = query.upperOpen === true;
+  }
+  return wire.lower !== void 0 || wire.upper !== void 0 ? wire : void 0;
+}
+function compareKeys(a, b) {
+  if (Array.isArray(a) || Array.isArray(b)) {
+    if (!Array.isArray(a) || !Array.isArray(b)) return Array.isArray(a) ? 1 : -1;
+    for (let i = 0; i < Math.min(a.length, b.length); i++) {
+      const c = compareKeys(a[i], b[i]);
+      if (c !== 0) return c;
+    }
+    return a.length - b.length;
+  }
+  if (typeof a === "number" && typeof b === "number") {
+    return a < b ? -1 : a > b ? 1 : 0;
+  }
+  if (typeof a === "number" || typeof b === "number") return typeof a === "number" ? -1 : 1;
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+function keyInRange(key, range) {
+  if (range.only !== void 0) return compareKeys(key, range.only) === 0;
+  if (range.lower !== void 0) {
+    const c = compareKeys(key, range.lower);
+    if (c < 0 || c === 0 && range.lowerOpen === true) return false;
+  }
+  if (range.upper !== void 0) {
+    const c = compareKeys(key, range.upper);
+    if (c > 0 || c === 0 && range.upperOpen === true) return false;
+  }
+  return true;
+}
+
+// src/domain.ts
+var DOMAIN_PROJECTION_VERSION = 1;
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function optionalStrings(row, fields) {
+  return fields.every((field) => row[field] === void 0 || typeof row[field] === "string");
+}
+function finiteNumbers(row, fields) {
+  return fields.every((field) => typeof row[field] === "number" && Number.isFinite(row[field]));
+}
+function isNote(value) {
+  return isObject(value) && typeof value.id === "string" && typeof value.title === "string" && finiteNumbers(value, ["createdAt"]) && (value.date === void 0 || finiteNumbers(value, ["date"])) && optionalStrings(value, ["type", "sourceId", "catalog", "sourcePath", "seedOrigin", "seedChunkId"]) && (value.tags === void 0 || Array.isArray(value.tags) && value.tags.every((tag) => typeof tag === "string"));
+}
+function isBlock(value) {
+  return isObject(value) && typeof value.id === "string" && typeof value.noteId === "string" && typeof value.segmentId === "string" && finiteNumbers(value, ["segmentVersion", "createdAt"]) && typeof value.dataType === "string" && typeof value.rawContent === "string" && typeof value.noteTitle === "string" && optionalStrings(value, ["blockContentId", "sourceId", "sourcePath", "routeId"]) && (value.position === void 0 || finiteNumbers(value, ["position"])) && (value.isStatic === void 0 || typeof value.isStatic === "boolean");
+}
+function isSegment(value) {
+  return isObject(value) && typeof value.id === "string" && typeof value.noteId === "string" && finiteNumbers(value, ["version", "createdAt"]) && typeof value.dataType === "string" && typeof value.rawContent === "string" && (value.data === null || isObject(value.data)) && optionalStrings(value, ["sourceContent", "pageId"]) && (value.position === void 0 || finiteNumbers(value, ["position"])) && (value.isHistory === void 0 || typeof value.isHistory === "boolean");
+}
+function isTag(value) {
+  return isObject(value) && typeof value.id === "string" && typeof value.label === "string" && finiteNumbers(value, ["createdAt"]) && optionalStrings(value, ["type"]);
+}
+function isPage(value) {
+  return isObject(value) && typeof value.id === "string" && finiteNumbers(value, ["createdAt"]) && optionalStrings(value, ["date", "slug", "title"]);
+}
+function isLink(value) {
+  return isObject(value) && typeof value.id === "string" && typeof value.noteId === "string" && typeof value.pageId === "string" && finiteNumbers(value, ["createdAt"]) && (value.position === void 0 || finiteNumbers(value, ["position"]));
+}
+function isEntry(value) {
+  return isObject(value) && isNote(value.note) && Array.isArray(value.segments) && value.segments.every(isSegment) && Array.isArray(value.tags) && value.tags.every(isTag) && Array.isArray(value.links) && value.links.every(isLink) && Array.isArray(value.pages) && value.pages.every(isPage);
+}
+function parseDomainQueryResult(value, plan) {
+  if (!isObject(value) || value.projectionVersion !== DOMAIN_PROJECTION_VERSION || value.plan !== plan || !Array.isArray(value.rows) || typeof value.selectedCount !== "number" || !Number.isSafeInteger(value.selectedCount) || value.selectedCount < 0 || typeof value.matchedCount !== "number" || !Number.isSafeInteger(value.matchedCount) || value.matchedCount < 0 || value.matchedCount > value.selectedCount || value.rows.length > value.matchedCount) {
+    throw new Error("ApiStorage: invalid or stale domain projection response");
+  }
+  const counts = { projectionVersion: DOMAIN_PROJECTION_VERSION, selectedCount: value.selectedCount, matchedCount: value.matchedCount };
+  switch (plan) {
+    case "notes":
+      if (value.rows.every(isNote)) return { ...counts, plan, rows: value.rows };
+      break;
+    case "blocks":
+      if (value.rows.every(isBlock)) return { ...counts, plan, rows: value.rows };
+      break;
+    case "entries":
+      if (value.rows.every(isEntry)) return { ...counts, plan, rows: value.rows };
+      break;
+  }
+  throw new Error("ApiStorage: invalid domain query rows");
+}
+
+// src/overlay.ts
+var bufferSlot = (store, key) => `${store}\0${JSON.stringify(key)}`;
+function isDirty(store, buffer, cleared) {
+  if (cleared?.has(store)) return true;
+  if (!buffer) return false;
+  const prefix = `${store}\0`;
+  for (const slot of buffer.keys()) {
+    if (slot.startsWith(prefix)) return true;
+  }
+  return false;
+}
+function bufferedGet(store, key, buffer) {
+  if (!buffer) return void 0;
+  const entry = buffer.get(bufferSlot(store, key));
+  if (!entry) return void 0;
+  return entry.kind === "put" ? { hit: true, value: entry.value } : { hit: false };
+}
+function overlayRows(def, store, buffer, cleared, rows, count, range, indexName) {
+  if (!buffer || !isDirty(store, buffer, cleared)) return count !== void 0 ? rows.slice(0, count) : rows;
+  const out = /* @__PURE__ */ new Map();
+  if (!cleared?.has(store)) {
+    for (const row of rows) out.set(JSON.stringify(keyFromValue(def, row)), row);
+  }
+  const prefix = `${store}\0`;
+  for (const [slot, entry] of buffer) {
+    if (!slot.startsWith(prefix)) continue;
+    if (entry.kind === "put") out.set(slot.slice(prefix.length), entry.value);
+    else out.delete(slot.slice(prefix.length));
+  }
+  const index = indexName ? def.indexes.find((i) => i.name === indexName) : void 0;
+  if (indexName && !index) throw new Error(`unknown index '${indexName}' for ${store}`);
+  const keyOf = (row) => {
+    if (!index) return keyFromValue(def, row);
+    const parts = index.keyPath.map((path) => extractKeyPart(row, path));
+    if (parts.some((part) => part === void 0)) return void 0;
+    const keys = parts.filter((part) => part !== void 0);
+    return keys.length === 1 ? keys[0] : keys;
+  };
+  const matches = (row) => {
+    if (index?.multiEntry) {
+      let values = row;
+      for (const part of index.keyPath[0].split(".")) {
+        if (values === null || typeof values !== "object" || !(part in values)) return false;
+        values = Reflect.get(values, part);
+      }
+      return Array.isArray(values) && values.some((value) => (typeof value === "string" || typeof value === "number") && (!range || keyInRange(value, range)));
+    }
+    const key = keyOf(row);
+    return key !== void 0 && (!range || keyInRange(key, range));
+  };
+  const merged = [...out.values()].filter(matches);
+  merged.sort((a, b) => {
+    const primary = compareKeys(keyFromValue(def, a), keyFromValue(def, b));
+    if (index?.multiEntry) return primary;
+    const ak = keyOf(a), bk = keyOf(b);
+    return ak !== void 0 && bk !== void 0 ? compareKeys(ak, bk) || primary : primary;
+  });
+  return count !== void 0 ? merged.slice(0, count) : merged;
+}
+function bufferToOps(storeNames, buffer, cleared) {
+  const known = new Set(storeNames);
+  const ops = [];
+  for (const store of cleared) {
+    if (known.has(store)) ops.push({ op: "clear", store });
+  }
+  for (const [slot, entry] of buffer) {
+    const sep = slot.indexOf("\0");
+    const store = slot.slice(0, sep);
+    if (!known.has(store)) continue;
+    if (entry.kind === "put") ops.push({ op: "put", store, value: entry.value });
+    else ops.push({ op: "delete", store, key: JSON.parse(slot.slice(sep + 1)) });
+  }
+  return ops;
+}
+
+// src/api.ts
+async function request(http, method, path, init) {
+  const qs = init?.params?.toString();
+  const res = await http.fetchImpl(`${http.baseUrl}/v1${path}${qs ? `?${qs}` : ""}`, {
+    method,
+    headers: init?.body !== void 0 ? { "content-type": "application/json" } : void 0,
+    body: init?.body !== void 0 ? JSON.stringify(init.body) : void 0
+  });
+  if (!res.ok) throw new Error(`ApiStorage: ${method} /v1${path} \u2192 ${res.status}`);
+  return res;
+}
+async function remoteGet(http, store, key) {
+  const res = await http.fetchImpl(`${http.baseUrl}/v1/${store}/get?key=${encodeKey(key)}`);
+  if (res.status === 404) return void 0;
+  if (!res.ok) throw new Error(`ApiStorage: GET /v1/${store}/get \u2192 ${res.status}`);
+  return await res.json();
+}
+async function remoteList(http, store, path, range, count) {
+  const params = new URLSearchParams();
+  if (range) params.set("range", JSON.stringify(range));
+  if (count !== void 0) params.set("count", String(count));
+  const res = await request(http, "GET", `/${store}/${path}`, { params });
+  return await res.json();
+}
+async function remoteCount(http, store, range, indexName) {
+  const params = new URLSearchParams();
+  if (range) params.set("range", JSON.stringify(range));
+  if (indexName !== void 0) params.set("index", indexName);
+  const res = await request(http, "GET", `/${store}/count`, { params });
+  return (await res.json()).count;
+}
+async function remoteDelete(http, store, keyOrRange) {
+  await request(http, "DELETE", `/${store}`, { params: new URLSearchParams({ key: JSON.stringify(keyOrRange) }) });
+}
+var ApiStorage = class {
+  http;
+  defs;
+  /** Injected identity: user-owned rows are stamped with this on write. */
+  getUserId;
+  constructor(baseUrl = "/api", fetchImpl = globalThis.fetch.bind(globalThis), options = {}) {
+    this.http = { baseUrl, fetchImpl };
+    this.getUserId = options.getUserId;
+    this.defs = Object.fromEntries(STORE_DEFS.map((d) => [d.name, d]));
+  }
+  def(store) {
+    const def = this.defs[store];
+    if (!def) throw new Error(`ApiStorage: unknown store '${store}'`);
+    return def;
+  }
+  makeView(store, buffer, cleared) {
+    return new ApiStore(this.http, this.def(store), store, buffer, cleared, this.getUserId);
+  }
+  readonly(store) {
+    return this.makeView(store);
+  }
+  readwrite(store) {
+    return this.makeView(store);
+  }
+  async queryDomain(query) {
+    const res = await this.http.fetchImpl(`${this.http.baseUrl}/v1/query`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(query)
+    });
+    if (res.status === 409) {
+      const error = await res.json();
+      if (typeof error === "object" && error !== null && "code" in error && error.code === "domain_projection_unavailable") return void 0;
+    }
+    if (!res.ok) throw new Error(`ApiStorage: POST /v1/query \u2192 ${res.status}`);
+    return parseDomainQueryResult(await res.json(), query.plan);
+  }
+  async transaction(_stores, _mode, fn) {
+    const buffer = /* @__PURE__ */ new Map();
+    const cleared = /* @__PURE__ */ new Set();
+    const tx = {
+      readonly: (store) => this.makeView(store, buffer, cleared),
+      readwrite: (store) => this.makeView(store, buffer, cleared)
+    };
+    const result = await fn(tx);
+    await this.flush(buffer, cleared);
+    return result;
+  }
+  /** Sends buffered ops as one server-side SQL transaction. */
+  async flush(buffer, cleared) {
+    const ops = bufferToOps(STORE_DEFS.map((d) => d.name), buffer, cleared);
+    if (ops.length > 0) await request(this.http, "POST", "/tx", { body: { ops } });
+  }
+  async wipe() {
+    await request(this.http, "POST", "/wipe");
+  }
+  async close() {
+  }
+};
+var ApiStore = class {
+  constructor(http, def, store, buffer, cleared, getUserId) {
+    this.http = http;
+    this.def = def;
+    this.store = store;
+    this.buffer = buffer;
+    this.cleared = cleared;
+    this.getUserId = getUserId;
+  }
+  http;
+  def;
+  store;
+  buffer;
+  cleared;
+  getUserId;
+  /** True when this tx has buffered writes for this store. */
+  dirty() {
+    return isDirty(this.store, this.buffer, this.cleared);
+  }
+  async get(key) {
+    const range = isRange(key) ? key : void 0;
+    let k;
+    if (range) {
+      if (range.only === void 0) {
+        throw new Error("ApiStorage.get: needs a plain key or {only}; bounded ranges match no single row");
+      }
+      k = range.only;
+    } else {
+      k = key;
+    }
+    const state = bufferedGet(this.store, k, this.buffer);
+    if (state) return state.hit ? state.value : void 0;
+    if (this.cleared?.has(this.store)) return void 0;
+    return remoteGet(this.http, this.store, k);
+  }
+  async getAll(query, count) {
+    const range = rangeFromIDB(query);
+    return this.overlay(await this.serverRows("all", range, this.dirty() ? void 0 : count), count, range);
+  }
+  async getAllFromIndex(indexName, query, count) {
+    const range = rangeFromIDB(query);
+    return this.overlay(await this.serverRows(`index/${encodeURIComponent(indexName)}`, range, this.dirty() ? void 0 : count), count, range, indexName);
+  }
+  async count(query) {
+    const range = rangeFromIDB(query);
+    if (!this.dirty()) return remoteCount(this.http, this.store, range);
+    return this.overlay(await this.serverRows("all", range), void 0, range).length;
+  }
+  async countFromIndex(indexName, query) {
+    const range = rangeFromIDB(query);
+    if (!this.dirty()) return remoteCount(this.http, this.store, range, indexName);
+    return this.overlay(await this.serverRows(`index/${encodeURIComponent(indexName)}`, range), void 0, range, indexName).length;
+  }
+  /** Server rows for a list path, or none when this tx cleared the store. */
+  serverRows(path, range, count) {
+    if (this.cleared?.has(this.store)) return Promise.resolve([]);
+    return remoteList(this.http, this.store, path, range, count);
+  }
+  /** Applies buffered puts and deletes before range filtering, ordering and paging. */
+  overlay(rows, count, range, indexName) {
+    return overlayRows(this.def, this.store, this.buffer, this.cleared, rows, count, range, indexName);
+  }
+  async put(value, _key) {
+    const userId = this.getUserId?.();
+    const stored = userId ? stampUserOwned(this.store, value, userId) : value;
+    const key = keyFromValue(this.def, stored);
+    if (this.buffer) {
+      this.buffer.set(bufferSlot(this.store, key), { kind: "put", value: stored });
+      return key;
+    }
+    await request(this.http, "POST", "/tx", { body: { ops: [{ op: "put", store: this.store, value: stored }] } });
+    return key;
+  }
+  async delete(key) {
+    const range = isRange(key) ? key : void 0;
+    if (range) {
+      if (this.buffer) {
+        const rows = await this.getAll(range);
+        for (const row of rows) {
+          const key2 = keyFromValue(this.def, row);
+          this.buffer.set(bufferSlot(this.store, key2), { kind: "delete", key: key2 });
+        }
+        return;
+      }
+      await remoteDelete(this.http, this.store, range);
+      return;
+    }
+    const k = key;
+    if (this.buffer) {
+      this.buffer.set(bufferSlot(this.store, k), { kind: "delete", key: k });
+      return;
+    }
+    await remoteDelete(this.http, this.store, k);
+  }
+  async clear() {
+    if (this.buffer) {
+      this.cleared?.add(this.store);
+      const prefix = `${this.store}\0`;
+      for (const slot of [...this.buffer.keys()]) {
+        if (slot.startsWith(prefix)) this.buffer.delete(slot);
+      }
+      return;
+    }
+    await request(this.http, "POST", "/tx", { body: { ops: [{ op: "clear", store: this.store }] } });
+  }
+};
+
+exports.ApiStorage = ApiStorage;
+exports.COLUMN_TYPES = COLUMN_TYPES;
+exports.DB_VERSION = DB_VERSION;
+exports.DEFAULT_MEMBERSHIP_ID = DEFAULT_MEMBERSHIP_ID;
+exports.DOMAIN_PROJECTION_VERSION = DOMAIN_PROJECTION_VERSION;
+exports.STORE_DEFS = STORE_DEFS;
+exports.USER_OWNED_STORES = USER_OWNED_STORES;
+exports.compareKeys = compareKeys;
+exports.createDefaultMembership = createDefaultMembership;
+exports.encodeKey = encodeKey;
+exports.extractKeyPart = extractKeyPart;
+exports.isRange = isRange;
+exports.keyFromValue = keyFromValue;
+exports.keyInRange = keyInRange;
+exports.parseDomainQueryResult = parseDomainQueryResult;
+exports.rangeFromIDB = rangeFromIDB;
+exports.stampUserOwned = stampUserOwned;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map