@3sln/trove 0.0.2

package/packages/core/src/metadata/cursor.js

@@ -0,0 +1,73 @@
+// Page cursors for listing a collection.
+//
+// An OFFSET cursor is wrong for a live drive. `nextCursor = offset + limit` assumes the
+// rows before the cut don't move, and in a shared collection they do: delete or rename
+// an item that sorts early, or let someone else's upload land there, and the next page
+// starts one row late — an item is skipped entirely, or served twice. With no folders,
+// "load more" is the ONLY way to reach item 501, so a skipped file is invisible until a
+// full refresh, and nothing tells the user it happened.
+//
+// A keyset cursor remembers WHERE the last page ended rather than how many rows it
+// counted: "everything after (name, id)". Rows inserted before that point don't shift
+// it, and rows removed from before it don't either. `id` is the tiebreaker, so a sort
+// column with duplicates (two files the same size) still yields a total order.
+
+/** Encode the last row of a page as the cursor for the next one. */
+export function encodeCursor(sort, node) {
+  if (!node) return null;
+  return base64url(JSON.stringify(['k', sort, node[sort] ?? null, node.id]));
+}
+
+/**
+ * Decode a cursor into `{ value, id }`, or null.
+ *
+ * A cursor from a different sort order is discarded rather than misapplied: sorting by
+ * name and resuming from a size is a comparison against the wrong axis, which would
+ * silently drop most of the collection. Returning null restarts the listing, which is
+ * the honest answer to "your bookmark no longer means anything".
+ */
+export function decodeCursor(sort, cursor) {
+  if (!cursor) return null;
+  try {
+    const parsed = JSON.parse(unbase64url(String(cursor)));
+    if (!Array.isArray(parsed) || parsed[0] !== 'k' || parsed[1] !== sort) return null;
+    return { value: parsed[2], id: parsed[3] };
+  } catch {
+    return null;
+  }
+}
+
+/** Is `node` strictly after the cursor position, under this sort direction? */
+export function afterCursor(node, sort, at, desc) {
+  const a = node[sort];
+  const b = at.value;
+  const cmp = compareValues(a, b);
+  if (cmp !== 0) return desc ? cmp < 0 : cmp > 0;
+  return desc ? node.id < at.id : node.id > at.id;
+}
+
+export function compareValues(a, b) {
+  // Text compares case-insensitively to match the stores' NOCASE ordering; anything
+  // else compares naturally.
+  if (typeof a === 'string' && typeof b === 'string') {
+    const la = a.toLowerCase();
+    const lb = b.toLowerCase();
+    return la < lb ? -1 : la > lb ? 1 : 0;
+  }
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+
+// base64url without padding, over UTF-8, working in both Node and the browser.
+function base64url(str) {
+  const bytes = new TextEncoder().encode(str);
+  let bin = '';
+  for (const b of bytes) bin += String.fromCharCode(b);
+  return btoa(bin).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
+}
+function unbase64url(str) {
+  const b64 = str.replace(/-/g, '+').replace(/_/g, '/');
+  const bin = atob(b64 + '='.repeat((4 - (b64.length % 4)) % 4));
+  const bytes = new Uint8Array(bin.length);
+  for (let i = 0; i < bin.length; i++) bytes[i] = bin.charCodeAt(i);
+  return new TextDecoder().decode(bytes);
+}

package/packages/core/src/metadata/interface.js

@@ -0,0 +1,244 @@
+// MetadataStore — the source of truth for every item in the drive. It maps items to
+// storage keys (so the blob store never sees a user-visible name), and holds each
+// item's *contributions*: what indexers (and the user) attach to it, namespaced by
+// contributor id so they never clobber one another and can be removed independently.
+//
+// THERE IS NO HIERARCHY. A collection is a flat set of uniquely-named items. Structure
+// comes from items linking to each other (`trove:` URIs — see ../links.js) and from
+// search, not from containers: a markdown document that links its sources does what a
+// folder did, except it can say why those things belong together, an item can appear in
+// as many of them as it likes, and the grouping is searchable content rather than an
+// invisible box. So there is no parentId, no path, and no folder node.
+//
+// A contributor (an indexer, or the reserved 'user' scope) writes up to three
+// things per node: semantic search text (which lives in SearchService, not here),
+// `tags` (filterable key/values), and `metadata` (arbitrary — e.g. an audiobook's
+// chapter index). This store holds the tags + metadata:
+//
+//   {
+//     id, collectionId, name,
+//     size, contentType, storageKey|null, etag, createdAt, updatedAt,
+//     meta: {},   // user-facing scalar metadata (description…)
+//     contributions: { [contributorId]: { tags?: {}, metadata?: {} } },
+//     tags: {}    // all contributors' tags merged (this is what filtering queries)
+//   }
+//
+// Internally the two are stored together in one JSON column with a reserved
+// '#tags' key holding the merged view (denormalized so filtering stays a simple
+// json_extract). Implement this interface over anything (Memory/Sqlite/D1/…).
+
+import { TroveError } from '../errors.js';
+
+// The reserved key under which the merged, queryable tag view is denormalized
+// alongside the per-contributor namespaces.
+export const MERGED_TAGS = '#tags';
+
+// The links indexer's contributor id, and the key it stores outbound `trove:` links
+// under. Backlink queries read exactly this, so it lives beside the tag view rather
+// than being a string repeated across the stores.
+export const LINKS_CONTRIBUTOR = 'core.links';
+export const LINKS_KEY = 'links';
+
+/** The outbound trove: links recorded on a node, or []. */
+export function outboundLinks(node) {
+  const c = node?.contributions?.[LINKS_CONTRIBUTOR]?.metadata?.[LINKS_KEY];
+  return Array.isArray(c) ? c : [];
+}
+
+/** Merge every contributor's `tags` into one flat map (dropping null/removed). */
+export function mergeContributionTags(raw) {
+  const merged = {};
+  for (const [key, c] of Object.entries(raw || {})) {
+    if (key === MERGED_TAGS) continue;
+    if (c && c.tags) for (const [k, v] of Object.entries(c.tags)) merged[k] = v;
+  }
+  for (const k of Object.keys(merged)) if (merged[k] == null) delete merged[k];
+  return merged;
+}
+
+/** Split the raw stored JSON into the node's exposed `contributions` + `tags`. */
+export function splitContributions(raw) {
+  const contributions = {};
+  for (const [k, v] of Object.entries(raw || {})) if (k !== MERGED_TAGS) contributions[k] = v;
+  return { contributions, tags: (raw && raw[MERGED_TAGS]) || {} };
+}
+
+/** Reconstruct the raw contributions JSON from a node object (accepts the exposed
+ * `contributions`+`tags` shape or a legacy raw `facets` field). */
+export function rawFacetsFromNode(node) {
+  if (node.facets) return node.facets;
+  const raw = { ...(node.contributions || {}) };
+  if (node.tags && Object.keys(node.tags).length) raw[MERGED_TAGS] = node.tags;
+  return raw;
+}
+
+/** Apply a `{ tags, metadata }` contribution onto the raw map and re-merge tags. */
+export function applyContribution(raw, contributorId, { tags, metadata } = {}) {
+  const next = { ...(raw || {}) };
+  const cur = next[contributorId] || {};
+  const merged = { ...cur };
+  if (tags) merged.tags = { ...(cur.tags || {}), ...tags };
+  if (metadata) merged.metadata = { ...(cur.metadata || {}), ...metadata };
+  next[contributorId] = merged;
+  next[MERGED_TAGS] = mergeContributionTags(next);
+  return next;
+}
+
+export class MetadataStore {
+  /** Prepare storage (schema/migrations); call once at startup. */
+  async init() {}
+
+  /** @returns {Promise<object|null>} */
+  async getById(id) {
+    throw TroveError.unsupported('getById not implemented');
+  }
+  /**
+   * Resolve an item by its name within a collection. Names are unique per collection,
+   * which is what lets a `trove:<collection>?name=…` link address exactly one thing.
+   * @returns {Promise<object|null>}
+   */
+  async getByName(collectionId, name) {
+    throw TroveError.unsupported('getByName not implemented');
+  }
+  /**
+   * The items in a collection.
+   * @param {string} collectionId
+   * @param {{sort?: 'name'|'size'|'updatedAt', order?: 'asc'|'desc', limit?: number, cursor?: string}} [opts]
+   * @returns {Promise<{items: object[], nextCursor: string|null}>}
+   */
+  async listItems(collectionId, opts) {
+    throw TroveError.unsupported('listItems not implemented');
+  }
+  /** Insert an item. Rejects ALREADY_EXISTS on a (collectionId,name) collision. */
+  async create(node) {
+    throw TroveError.unsupported('create not implemented');
+  }
+  /** Shallow-merge a patch into an item (name changes go through rename). */
+  async update(id, patch) {
+    throw TroveError.unsupported('update not implemented');
+  }
+  /** PERMANENTLY delete a single item. The trash lives above this, in the Vfs. */
+  async remove(id) {
+    throw TroveError.unsupported('remove not implemented');
+  }
+  /**
+   * Move an item to the trash: still stored, no longer part of the drive.
+   *
+   * Optional — a store that doesn't implement it makes deletes permanent, which is a
+   * legitimate choice for an ephemeral or append-only backend. Where it IS implemented,
+   * every read path must exclude trashed rows, and name uniqueness must apply only to
+   * live ones; otherwise deleting `notes.md` would prevent ever creating another.
+   */
+  async softDelete(id, at) {
+    throw TroveError.unsupported('softDelete not implemented');
+  }
+  /**
+   * Bring a trashed item back, optionally under a different name. The rename is part of
+   * the restore rather than a separate step, so a name freed for a replacement can be
+   * resolved without a window where the item is live under a colliding name.
+   * Rejects ALREADY_EXISTS if the name is taken.
+   */
+  async restore(id, newName) {
+    throw TroveError.unsupported('restore not implemented');
+  }
+  /** Trashed items, newest first. @returns {Promise<object[]>} */
+  async listTrash(collectionId, opts) {
+    throw TroveError.unsupported('listTrash not implemented');
+  }
+  /** Trashed before `cutoff` — what the retention sweep collects. */
+  async trashedBefore(cutoff, limit) {
+    throw TroveError.unsupported('trashedBefore not implemented');
+  }
+  /**
+   * The storage keys of TRASHED items in a collection.
+   *
+   * The scanner needs these and cannot get them from `listItems`, which is live-only by
+   * design. Without them a trashed file's object looks like one that arrived from
+   * outside, so a scan adopts it a second time — resurrecting the deleted file under a
+   * new id that shares the original's storage key, at which point emptying the trash
+   * deletes the live copy's bytes.
+   *
+   * Keys rather than rows because that is all the caller needs, and a collection's whole
+   * trash as full records is a lot of memory for a set membership test.
+   * @returns {Promise<Set<string>>}
+   */
+  async trashedStorageKeys(collectionId) {
+    throw TroveError.unsupported('trashedStorageKeys not implemented');
+  }
+  /** Rename an item. Rejects ALREADY_EXISTS if the name is taken in its collection. */
+  async rename(id, newName) {
+    throw TroveError.unsupported('rename not implemented');
+  }
+  /**
+   * Merge a contributor's `{ tags, metadata }` onto a node (namespaced by
+   * `contributorId`), and update the merged tag view. Either field is optional.
+   */
+  async setContribution(id, contributorId, contribution) {
+    throw TroveError.unsupported('setContribution not implemented');
+  }
+  /** Remove a contributor's entire namespace (tags + metadata) from a node. */
+  async clearContribution(id, contributorId) {
+    throw TroveError.unsupported('clearContribution not implemented');
+  }
+  /** Simple substring/name search fallback (SearchService may do better). */
+  async searchByName(query, opts) {
+    throw TroveError.unsupported('searchByName not implemented');
+  }
+  /**
+   * Page through EVERY item across all collections in stable id order, for drive-wide
+   * sweeps (indexer backfill/purge). Distinct from listItems, which is one collection's
+   * contents for a reader: this one ignores collections and ordering preferences, and
+   * exists so a sweep can resume from `afterId` without holding the drive in memory.
+   * @returns {Promise<object[]>}
+   */
+  async scanItems({ afterId = null, limit = 200 } = {}) {
+    throw TroveError.unsupported('scanItems not implemented');
+  }
+  /**
+   * How many items the drive holds, across all collections. Optional: it exists so a
+   * drive-wide sweep can show real progress ("142 of 3,100") instead of a spinner. A
+   * store that can't answer cheaply should return null rather than guess — the caller
+   * falls back to an indeterminate indicator, which is honest.
+   * @returns {Promise<number|null>}
+   */
+  async countItems(collectionId) {
+    return null;
+  }
+  /**
+   * How many items a collection holds and how many bytes they occupy.
+   *
+   * Separate from `listItems` because a page is not a drive: a client that reports the
+   * length of the page it received tells the user their 3,000-file drive holds 500
+   * files, which is not a rounding error but a wrong number. Optional; a store that
+   * can't answer returns null and the UI says nothing rather than guessing.
+   * @returns {Promise<{items: number, bytes: number}|null>}
+   */
+  async collectionStats(collectionId) {
+    return null;
+  }
+  /**
+   * Drive-wide tag/property query. `filters` is a list of
+   * `{ key, present } | { key, op, value }` (op ∈ = != < <= > >=), matched against
+   * a node's merged `tags` (+ meta). `opts`: { q (name substring), collectionIds,
+   * limit }. Returns matching nodes newest-first.
+   */
+  async findByTags(filters, opts) {
+    throw TroveError.unsupported('findByTags not implemented');
+  }
+  /**
+   * Items that link TO any of `uris` — the backlinks of an item, and the reason a
+   * flat drive stays navigable: without them you can follow a document's links out
+   * but never discover what gathers a given item up.
+   *
+   * `uris` are canonical `trove:` URIs (an item is addressable by name AND by id, so
+   * the caller passes both forms). Matched against the links contribution written by
+   * the links indexer.
+   * @param {string[]} uris
+   * @param {{limit?: number, collectionIds?: string[]}} [opts]
+   */
+  async findLinksTo(uris, opts) {
+    throw TroveError.unsupported('findLinksTo not implemented');
+  }
+
+  async close() {}
+}

package/packages/core/src/metadata/memory.js

@@ -0,0 +1,270 @@
+// In-memory MetadataStore. Reference implementation + test double. Nodes live in a
+// Map keyed by id, with one secondary index on (collectionId, name) — which is the
+// whole shape of the namespace now that there is no hierarchy: a collection is a flat
+// set of uniquely-named items, and structure comes from `trove:` links between them.
+
+import {
+  MetadataStore, MERGED_TAGS, LINKS_CONTRIBUTOR, LINKS_KEY,
+  mergeContributionTags, splitContributions, applyContribution, rawFacetsFromNode,
+} from './interface.js';
+import { TroveError } from '../errors.js';
+import { newId } from '../util.js';
+import { decodeCursor, encodeCursor, afterCursor, compareValues } from './cursor.js';
+import { matchTagFilters } from '../search/tagMatch.js';
+
+export class MemoryStore extends MetadataStore {
+  constructor() {
+    super();
+    this.nodes = new Map(); // id -> node
+    this.byName = new Map(); // `${collectionId}\0${name}` -> id
+  }
+
+  async init() {}
+
+  #key(collectionId, name) {
+    return `${collectionId}\0${name}`;
+  }
+  #index(node) {
+    this.nodes.set(node.id, node);
+    this.byName.set(this.#key(node.collectionId, node.name), node.id);
+  }
+  #deindex(node) {
+    this.nodes.delete(node.id);
+    const key = this.#key(node.collectionId, node.name);
+    // Only when the name still resolves to THIS node. `softDelete` deliberately frees
+    // the name so a replacement can take it, so by the time the trash is emptied that
+    // key belongs to a different, LIVE file. Deleting it blindly made that live file
+    // unreachable by name — `trove:default?name=notes.md` stopped resolving, and the
+    // uniqueness check stopped seeing it, so the next upload created a second row
+    // under the same name.
+    if (this.byName.get(key) === node.id) this.byName.delete(key);
+  }
+  /** Live rows only. A trashed item keeps its row but must not answer as itself. */
+  #live() {
+    return [...this.nodes.values()].filter((n) => !n.deletedAt);
+  }
+
+  async getById(id) {
+    return clone(this.nodes.get(id));
+  }
+  async getByName(collectionId = 'default', name) {
+    const id = this.byName.get(this.#key(collectionId, name));
+    const node = id ? this.nodes.get(id) : null;
+    return node && !node.deletedAt ? clone(node) : null;
+  }
+
+  async listItems(collectionId = 'default', opts = {}) {
+    // Same resolution as the sqlite store — an unknown sort falls back to `name` in
+    // both, and the cursor is keyed by the RESOLVED field so the two never disagree.
+    const sort = ['name', 'size', 'updatedAt'].includes(opts.sort) ? opts.sort : 'name';
+    const desc = opts.order === 'desc';
+    const dir = desc ? -1 : 1;
+    const items = this.#live().filter((n) => n.collectionId === collectionId);
+    // `id` breaks ties, so two files of the same size still have one stable order — the
+    // cursor below depends on the ordering being total.
+    // The SAME comparison the cursor uses. This sorted with raw `<`/`>` — code-unit and
+    // case-sensitive — while `afterCursor` lowercases both sides, so on mixed-case names
+    // the two orders disagreed and items fell straight through the page boundary, never
+    // returned by any page. Worse through the scanner, which pages `listItems` to learn
+    // what it already has: the files it never saw were adopted again on every scan, one
+    // duplicate per run, all sharing one storage key.
+    items.sort((a, b) => compareForSort(a, b, sort, dir));
+    const limit = opts.limit ?? 500;
+    const at = decodeCursor(sort, opts.cursor);
+    const rest = at ? items.filter((n) => afterCursor(n, sort, at, desc)) : items;
+    const page = rest.slice(0, limit);
+    return {
+      items: page.map(clone),
+      nextCursor: rest.length > limit ? encodeCursor(sort, page[page.length - 1]) : null,
+    };
+  }
+
+  async create(node) {
+    const collectionId = node.collectionId || 'default';
+    if (!node.name) throw TroveError.invalid('An item needs a name');
+    if (this.byName.has(this.#key(collectionId, node.name))) throw TroveError.alreadyExists(node.name);
+    const now = Date.now();
+    const full = {
+      id: node.id || newId('itm'),
+      collectionId, name: node.name,
+      size: node.size ?? 0, contentType: node.contentType ?? null,
+      storageKey: node.storageKey ?? null, etag: node.etag ?? null,
+      createdAt: now, updatedAt: now, meta: node.meta ?? {}, facets: rawFacetsFromNode(node),
+    };
+    this.#index(full);
+    return clone(full);
+  }
+
+  async update(id, patch) {
+    const node = this.nodes.get(id);
+    if (!node) throw TroveError.notFound('Item');
+    for (const k of ['size', 'contentType', 'storageKey', 'etag', 'meta']) {
+      if (k in patch) node[k] = patch[k];
+    }
+    node.updatedAt = Date.now();
+    return clone(node);
+  }
+
+  /** Permanently forget an item. The trash is a VFS concern; this is the real delete. */
+  async remove(id) {
+    const node = this.nodes.get(id);
+    if (!node) return;
+    this.#deindex(node);
+  }
+
+  async softDelete(id, at = Date.now()) {
+    const node = this.nodes.get(id);
+    if (!node) throw TroveError.notFound('Item');
+    node.deletedAt = at;
+    node.updatedAt = at;
+    // Free the name so a replacement can take it — otherwise the trash holds the name
+    // hostage and you can never re-create what you just deleted.
+    this.byName.delete(this.#key(node.collectionId, node.name));
+    return clone(node);
+  }
+
+  async restore(id, newName = null) {
+    const node = this.nodes.get(id);
+    if (!node) throw TroveError.notFound('Item');
+    const name = newName || node.name;
+    if (this.byName.has(this.#key(node.collectionId, name))) throw TroveError.alreadyExists(name);
+    delete node.deletedAt;
+    node.name = name;
+    node.updatedAt = Date.now();
+    this.byName.set(this.#key(node.collectionId, name), node.id);
+    return clone(node);
+  }
+
+  async listTrash(collectionId, { limit = 200, before = null } = {}) {
+    return [...this.nodes.values()]
+      .filter((n) => n.deletedAt && (!collectionId || n.collectionId === collectionId) && (!before || n.deletedAt < before))
+      .sort((a, b) => b.deletedAt - a.deletedAt)
+      .slice(0, limit)
+      .map(clone);
+  }
+
+  async trashedStorageKeys(collectionId) {
+    const keys = new Set();
+    for (const n of this.nodes.values()) {
+      if (n.deletedAt && n.storageKey && (!collectionId || n.collectionId === collectionId)) keys.add(n.storageKey);
+    }
+    return keys;
+  }
+
+  async trashedBefore(cutoff, limit = 500) {
+    return [...this.nodes.values()]
+      .filter((n) => n.deletedAt && n.deletedAt < cutoff)
+      .sort((a, b) => a.deletedAt - b.deletedAt)
+      .slice(0, limit)
+      .map(clone);
+  }
+
+  async rename(id, newName) {
+    const node = this.nodes.get(id);
+    if (!node || node.deletedAt) throw TroveError.notFound('Item');
+    if (!newName) throw TroveError.invalid('An item needs a name');
+    if (newName === node.name) return clone(node);
+    if (this.byName.has(this.#key(node.collectionId, newName))) throw TroveError.alreadyExists(newName);
+    this.#deindex(node);
+    node.name = newName;
+    node.updatedAt = Date.now();
+    this.#index(node);
+    return clone(node);
+  }
+
+  async setContribution(id, contributorId, contribution) {
+    const node = this.nodes.get(id);
+    if (!node) throw TroveError.notFound('Item');
+    node.facets = applyContribution(node.facets, contributorId, contribution);
+    node.updatedAt = Date.now();
+    return clone(node);
+  }
+  async clearContribution(id, contributorId) {
+    const node = this.nodes.get(id);
+    if (!node) return;
+    const { [contributorId]: _drop, ...rest } = node.facets;
+    node.facets = { ...rest, [MERGED_TAGS]: mergeContributionTags(rest) };
+  }
+
+  async searchByName(query, opts = {}) {
+    const q = query.toLowerCase();
+    return this.#live()
+      .filter((n) => n.name.toLowerCase().includes(q))
+      .filter((n) => !opts.collectionId || n.collectionId === opts.collectionId)
+      .slice(0, opts.limit ?? 50)
+      .map(clone);
+  }
+
+  async scanItems({ afterId = null, limit = 200 } = {}) {
+    const files = this.#live().sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+    const start = afterId ? files.findIndex((n) => n.id > afterId) : 0;
+    const from = start === -1 ? files.length : start;
+    return files.slice(from, from + limit).map(clone);
+  }
+
+  async countItems(collectionId) {
+    const live = this.#live();
+    return collectionId ? live.filter((n) => n.collectionId === collectionId).length : live.length;
+  }
+
+  async collectionStats(collectionId = 'default') {
+    let items = 0;
+    let bytes = 0;
+    let trashed = 0;
+    for (const node of this.nodes.values()) {
+      if (node.collectionId !== collectionId) continue;
+      if (node.deletedAt) { trashed++; continue; }
+      items++;
+      bytes += node.size || 0;
+    }
+    return { items, bytes, trashed };
+  }
+
+  async findByTags(filters = [], opts = {}) {
+    const q = opts.q ? opts.q.toLowerCase() : null;
+    const out = [];
+    for (const node of this.#live()) {
+      if (opts.collectionIds && !opts.collectionIds.includes(node.collectionId)) continue;
+      if (q && !node.name.toLowerCase().includes(q)) continue;
+      if (matchTags(node, filters)) out.push(node);
+    }
+    out.sort((a, b) => b.updatedAt - a.updatedAt);
+    return out.slice(0, opts.limit ?? 100).map(clone);
+  }
+
+  async findLinksTo(uris = [], opts = {}) {
+    if (!uris.length) return [];
+    const want = new Set(uris);
+    const out = [];
+    for (const node of this.#live()) {
+      if (opts.collectionIds && !opts.collectionIds.includes(node.collectionId)) continue;
+      const links = node.facets?.[LINKS_CONTRIBUTOR]?.metadata?.[LINKS_KEY];
+      if (Array.isArray(links) && links.some((l) => want.has(l))) out.push(node);
+    }
+    out.sort((a, b) => b.updatedAt - a.updatedAt);
+    return out.slice(0, opts.limit ?? 100).map(clone);
+  }
+}
+
+// Split the internal raw facets into the exposed contributions + tags on read.
+function clone(n) {
+  if (!n) return n;
+  const copy = JSON.parse(JSON.stringify(n));
+  const { contributions, tags } = splitContributions(copy.facets || {});
+  copy.contributions = contributions;
+  copy.tags = tags;
+  delete copy.facets;
+  return copy;
+}
+
+// One matcher, shared with the transformer, the browser and (in SQL) the sqlite store.
+function matchTags(node, filters) {
+  return matchTagFilters(node, filters, mergeContributionTags(node.facets || {}));
+}
+
+// One ordering, shared with the cursor. `id` breaks ties so the order is total.
+function compareForSort(a, b, sort, dir) {
+  const c = compareValues(a[sort], b[sort]);
+  if (c !== 0) return c * dir;
+  return a.id < b.id ? -1 * dir : a.id > b.id ? dir : 0;
+}