@noy-db/hub 0.10.0-pre.1 → 0.10.0-pre.2

package/dist/{chunk-LFUID7OW.js → chunk-7VJ2SIEI.js}

@@ -8,17 +8,22 @@ async function diffVault(vault, candidate, options = {}) {
   const filter = options.collections ? new Set(options.collections) : null;
   const compareFn = options.compareFn ?? ((a, b) => diff(a, b).length === 0);
   const live = /* @__PURE__ */ new Map();
+  const skipped = [];
+  const byHubId = isVaultCandidate(candidate);
   for await (const chunk of vault.exportStream({ granularity: "collection" })) {
     if (filter && !filter.has(chunk.collection)) continue;
     const collection = live.get(chunk.collection) ?? /* @__PURE__ */ new Map();
-    for (const record of chunk.records) {
-      const id = readIdField(record, idKey);
-      if (!id) continue;
+    chunk.records.forEach((record, i) => {
+      const id = byHubId ? chunk.ids?.[i] ?? "" : readIdField(record, idKey);
+      if (!id) {
+        skipped.push({ collection: chunk.collection, side: "vault", index: i });
+        return;
+      }
       collection.set(id, record);
-    }
+    });
     live.set(chunk.collection, collection);
   }
-  const cand = await normaliseCandidate(candidate, idKey, filter);
+  const cand = await normaliseCandidate(candidate, idKey, filter, byHubId, skipped);
   const added = [];
   const modified = [];
   const deleted = [];
@@ -60,30 +65,38 @@ async function diffVault(vault, candidate, options = {}) {
     add: added.length,
     modify: modified.length,
     delete: deleted.length,
-    total: added.length + modified.length + deleted.length
+    total: added.length + modified.length + deleted.length,
+    skipped: skipped.length
   };
   return {
     added,
     modified,
     deleted,
     unchanged,
+    skipped,
     summary,
     format(opts) {
       return formatDiff(opts?.detail ?? "full", { added, modified, deleted, summary });
     }
   };
 }
-async function normaliseCandidate(candidate, idKey, filter) {
+function isVaultCandidate(candidate) {
+  return typeof candidate === "object" && candidate !== null && "exportStream" in candidate && typeof candidate.exportStream === "function";
+}
+async function normaliseCandidate(candidate, idKey, filter, byHubId, skipped) {
   const out = /* @__PURE__ */ new Map();
-  if (typeof candidate === "object" && candidate !== null && "exportStream" in candidate && typeof candidate.exportStream === "function") {
+  if (byHubId) {
     for await (const chunk of candidate.exportStream({ granularity: "collection" })) {
       if (filter && !filter.has(chunk.collection)) continue;
       const collection = out.get(chunk.collection) ?? /* @__PURE__ */ new Map();
-      for (const record of chunk.records) {
-        const id = readIdField(record, idKey);
-        if (!id) continue;
+      chunk.records.forEach((record, i) => {
+        const id = chunk.ids?.[i] ?? "";
+        if (!id) {
+          skipped.push({ collection: chunk.collection, side: "candidate", index: i });
+          return;
+        }
         collection.set(id, record);
-      }
+      });
       out.set(chunk.collection, collection);
     }
     return out;
@@ -97,11 +110,11 @@ async function normaliseCandidate(candidate, idKey, filter) {
         `diffVault: candidate string is not valid JSON (${err.message})`
       );
     }
-    return collectionsFromObject(parsed, idKey, filter);
+    return collectionsFromObject(parsed, idKey, filter, skipped);
   }
-  return collectionsFromObject(candidate, idKey, filter);
+  return collectionsFromObject(candidate, idKey, filter, skipped);
 }
-function collectionsFromObject(raw, idKey, filter) {
+function collectionsFromObject(raw, idKey, filter, skipped) {
   const out = /* @__PURE__ */ new Map();
   if (raw === null || typeof raw !== "object") {
     throw new Error("diffVault: candidate must be a Vault, an object, or a JSON string");
@@ -111,12 +124,18 @@ function collectionsFromObject(raw, idKey, filter) {
     if (filter && !filter.has(key)) continue;
     if (!Array.isArray(value)) continue;
     const collection = /* @__PURE__ */ new Map();
-    for (const record of value) {
-      if (record === null || typeof record !== "object") continue;
+    value.forEach((record, i) => {
+      if (record === null || typeof record !== "object") {
+        skipped.push({ collection: key, side: "candidate", index: i });
+        return;
+      }
       const id = readIdField(record, idKey);
-      if (!id) continue;
+      if (!id) {
+        skipped.push({ collection: key, side: "candidate", index: i });
+        return;
+      }
       collection.set(id, record);
-    }
+    });
     out.set(key, collection);
   }
   return out;
@@ -137,9 +156,10 @@ function readIdField(record, idKey) {
   return "";
 }
 function formatDiff(detail, b) {
-  const head = `${b.summary.add} added \xB7 ${b.summary.modify} modified \xB7 ${b.summary.delete} deleted`;
+  const skipNote = b.summary.skipped > 0 ? ` \xB7 ${b.summary.skipped} SKIPPED (unkeyable)` : "";
+  const head = `${b.summary.add} added \xB7 ${b.summary.modify} modified \xB7 ${b.summary.delete} deleted${skipNote}`;
   if (detail === "count") return head;
-  if (b.summary.total === 0) return head + "\n(no changes)";
+  if (b.summary.total === 0) return head + (b.summary.skipped > 0 ? "" : "\n(no changes)");
   if (detail === "one-line") return head;
   const rows = [head, ""];
   for (const e of b.added) rows.push(`${e.collection}/${e.id}	added`);
@@ -160,4 +180,4 @@ function shortJSON(value) {
 export {
   diffVault
 };
-//# sourceMappingURL=chunk-LFUID7OW.js.map
+//# sourceMappingURL=chunk-7VJ2SIEI.js.map

package/dist/chunk-7VJ2SIEI.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/with-cargo/vault-diff.ts"],"sourcesContent":["/**\n * Vault-level diff orchestrator.\n *\n * Compares a live `Vault`'s plaintext state against a candidate state\n * (another vault, a plain `{ collection: records[] }` map, or a vault\n * dump JSON) and returns a structured `VaultDiff` plan listing the\n * records that would be added, modified, or deleted to bring the live\n * vault into the candidate's shape.\n *\n * Builds on two existing record-level helpers:\n *\n *   1. `diff(a, b)` from `./history/diff.ts` — emits dot-pathed\n *      `DiffEntry[]` with `type: 'added' | 'removed' | 'changed'` for\n *      each changed field of two records. Used here for the\n *      `fieldDiffs` of every `modified` entry, and (with empty result)\n *      as the default deep-equal check.\n *\n *   2. `Vault.exportStream()` from `./vault.ts` — the canonical\n *      decrypt-and-stream-records iterator. Used to walk both sides\n *      when the candidate is itself a `Vault`. ACL-scoped: collections\n *      the caller can't read silently drop out, the same way every\n *      other plaintext-emitting export pipeline filters them.\n *\n * The new orchestration is the **vault-level** enumeration: bucket\n * each record id into added (only in candidate), deleted (only in\n * vault), or modified (in both with field changes); leave the\n * field-level granularity to the existing `diff()`.\n *\n * Use cases:\n *\n *   - Import preview (`@noy-db/as-*` `fromString` returns a plan\n *     whose body is a `VaultDiff`).\n *   - Backup verification (\"does this `.noydb` bundle from yesterday\n *     match the current vault?\").\n *   - Two-vault reconciliation (\"what's different between Office A\n *     and Office B before we sync?\").\n *   - Test assertions (golden-file testing with one-liner\n *     `expect(plan.summary).toEqual(...)`).\n *\n * @module\n */\n\nimport type { Vault } from '../kernel/vault.js'\nimport { diff as fieldDiff, type DiffEntry as FieldDiffEntry } from '../with-commit/history/diff.js'\n\n// ─── Public types ──────────────────────────────────────────────────────\n\n/** Per-record entry shape — added and deleted records carry only the record value. */\nexport interface VaultDiffEntry<T = unknown> {\n  readonly collection: string\n  readonly id: string\n  readonly record: T\n  /**\n   * Unencrypted envelope metadata for the RECEIVER-side record.\n   * Populated only when `diffVault` is called with `{includeMetadata: true}`.\n   * Default: `undefined` (zero extra reads, no behavior change).\n   *\n   * Populated for `modified` (the CURRENT receiver state, before the candidate\n   * is applied) and `deleted` (the receiver envelope of the record being\n   * removed). `added` entries have no receiver envelope at diff time, so their\n   * `metadata` is always absent.\n   */\n  readonly metadata?: {\n    readonly version: number\n    readonly timestamp: string\n    readonly by?: string\n    readonly source?: string\n    readonly sourceTs?: string\n  }\n}\n\n/** Modified records carry both halves of the diff plus the field-level breakdown. */\nexport interface VaultDiffModifiedEntry<T = unknown> extends VaultDiffEntry<T> {\n  /** The record as it stands in the live vault. */\n  readonly before: T\n  /** Top-level keys whose values differ between `before` and `record`. */\n  readonly fieldsChanged: readonly string[]\n  /**\n   * Field-level diff entries from `diff(before, record)`. Reuses the\n   * existing per-record diff helper so consumers can render git-style\n   * `path: from → to` rows without re-walking the records.\n   */\n  readonly fieldDiffs: readonly FieldDiffEntry[]\n}\n\nexport interface VaultDiff<T = unknown> {\n  readonly added: readonly VaultDiffEntry<T>[]\n  readonly modified: readonly VaultDiffModifiedEntry<T>[]\n  readonly deleted: readonly VaultDiffEntry<T>[]\n  /** Only populated when `options.includeUnchanged: true`. */\n  readonly unchanged: readonly VaultDiffEntry<T>[] | undefined\n  readonly summary: {\n    readonly add: number\n    readonly modify: number\n    readonly delete: number\n    readonly total: number\n    /** family#151 — `skipped.length`, so a caller reading only the summary sees it. */\n    readonly skipped: number\n  }\n  /**\n   * Records this diff could not key, and therefore says nothing about\n   * (family#151). Empty for a vault-to-vault diff. ⚠️ A non-empty value means\n   * the diff is INCOMPLETE — an importer walking only the buckets will not\n   * write these rows, which used to happen silently.\n   */\n  readonly skipped: readonly VaultDiffSkipped[]\n  /**\n   * Format the diff as a human-readable string.\n   *\n   *   - `'count'`   — one line, just the numbers (`12 added · 3 modified · 0 deleted`)\n   *   - `'one-line'` — count plus a single overview line\n   *   - `'full'`    — count + one row per added/modified/deleted record (default)\n   */\n  format(opts?: { detail?: 'count' | 'one-line' | 'full' }): string\n}\n\nexport interface DiffOptions {\n  /** Restrict the diff to a subset of collections. */\n  readonly collections?: readonly string[]\n  /** Field on each record that carries its id. Defaults to `'id'`. */\n  readonly idKey?: string\n  /** Override the default deep-equal check for \"modified vs unchanged\". */\n  readonly compareFn?: (a: unknown, b: unknown) => boolean\n  /** If true, include unchanged records in the diff (off by default to save memory). */\n  readonly includeUnchanged?: boolean\n  /**\n   * When `true`, each entry in `added`, `modified`, and `deleted` will carry a\n   * `metadata` field with the RECEIVER-side envelope metadata\n   * (`version`, `timestamp`, `by?`, `source?`, `sourceTs?`).\n   *\n   * Off by default — no extra adapter reads, no behavior change for existing callers.\n   */\n  readonly includeMetadata?: boolean\n}\n\n/**\n * Candidate state to diff the vault against:\n *\n *   - A `Vault` instance — both sides are walked via `exportStream()`.\n *   - A `Record<collection, records[]>` map — same shape `as-json.toObject()`\n *     produces. Useful for diffing parsed file content against the live vault.\n *   - A `VaultDump` (output of `vault.dump()`) — a JSON string carrying the\n *     full vault state. Parsed and reduced to the map shape above.\n */\n/**\n * A record neither side could key, and therefore one this diff does NOT report\n * on (family#151).\n *\n * ⛔ IT EXISTS BECAUSE THE SKIP WAS SILENT. A record with no `idKey` field was\n * dropped from the map on both sides, so it appeared in no bucket — and\n * `@noy-db/hub/as`'s `plan().apply()` walks only `added`/`modified`/`deleted`.\n * An import therefore did not write it, with no error and no count. A diff that\n * omits a record is reporting a difference it did not find.\n *\n * ⚠️ Only reachable on the object/string candidate path. A vault-to-vault diff\n * keys both sides by the hub id, which every record has.\n */\nexport interface VaultDiffSkipped {\n  readonly collection: string\n  readonly side: 'vault' | 'candidate'\n  /** Position within that side's record list for the collection. */\n  readonly index: number\n}\n\nexport type DiffCandidate<T = unknown> =\n  | Vault\n  | Record<string, readonly T[]>\n  | string\n\n// ─── Implementation ────────────────────────────────────────────────────\n\n/**\n * Compute the diff between a live vault and a candidate state.\n *\n * Ungated shared import/merge infrastructure: the `as-*` exporters call this\n * internally from their `fromString`/import merge logic, so it is always\n * available (not behind `withCargo()`). Only `extractPartition` is a gated\n * cargo capability.\n *\n * Returns a fully buffered `VaultDiff` — no streaming. Memory cost is\n * O(n + m) in the row count of vault + candidate. For documented\n * 1K-50K-record vaults this is fine; a streaming variant lands as a\n * follow-up if a > 100K-record consumer arrives.\n */\nexport async function diffVault<T = unknown>(\n  vault: Vault,\n  candidate: DiffCandidate<T>,\n  options: DiffOptions = {},\n): Promise<VaultDiff<T>> {\n  const idKey = options.idKey ?? 'id'\n  const filter = options.collections ? new Set(options.collections) : null\n  const compareFn =\n    options.compareFn ?? ((a: unknown, b: unknown) => fieldDiff(a, b).length === 0)\n\n  // Side A — walk the live vault via exportStream(). Each chunk arrives\n  // already decrypted and ACL-scoped, so collections the caller can't\n  // read silently drop out. exportStream's records are typed `unknown[]`\n  // — diffVault is the type-erasure boundary; the caller asserts the\n  // record shape via the function's `<T>` generic.\n  const live = new Map<string, Map<string, T>>()\n  const skipped: VaultDiffSkipped[] = []\n  // ⭐ family#151 — key by the HUB ID when the candidate can supply one too.\n  // A record need not carry an `id` field: hub's id is the store key, not a\n  // property of the plaintext. Keying both sides on a FIELD meant every id-less\n  // record was dropped from BOTH maps by the `continue` below — so it landed in\n  // no bucket, and `as`'s `apply()` walks only the buckets. An import silently\n  // did not write it: no error, no count, nothing.\n  //\n  // ⛔ ONLY WHEN BOTH SIDES CAN. A `Record<collection, records[]>` or a\n  // `dump()` string carries no hub ids at all, so keying the live side by hub\n  // id against a field-keyed candidate would mismatch EVERY record and report\n  // the whole vault added-and-deleted. That asymmetry is the real blocker for\n  // round-tripping an id-less record through `/as`, and it is a format question\n  // (`exportVaultJSON` emits `records: [...]`, dropping the id), not one\n  // `diffVault` can answer. Reported, not papered over.\n  const byHubId = isVaultCandidate(candidate)\n  for await (const chunk of vault.exportStream({ granularity: 'collection' })) {\n    if (filter && !filter.has(chunk.collection)) continue\n    const collection = live.get(chunk.collection) ?? new Map<string, T>()\n    chunk.records.forEach((record, i) => {\n      const id = byHubId ? (chunk.ids?.[i] ?? '') : readIdField(record, idKey)\n      if (!id) {\n        skipped.push({ collection: chunk.collection, side: 'vault', index: i })\n        return\n      }\n      collection.set(id, record as T)\n    })\n    live.set(chunk.collection, collection)\n  }\n\n  // Side B — normalise the candidate into the same shape.\n  const cand = await normaliseCandidate<T>(candidate, idKey, filter, byHubId, skipped)\n\n  // Walk every (collection, id) on either side and bucket.\n  const added: VaultDiffEntry<T>[] = []\n  const modified: VaultDiffModifiedEntry<T>[] = []\n  const deleted: VaultDiffEntry<T>[] = []\n  const unchanged: VaultDiffEntry<T>[] | undefined = options.includeUnchanged ? [] : undefined\n\n  const collectionNames = new Set([...live.keys(), ...cand.keys()])\n  for (const collection of [...collectionNames].sort()) {\n    const liveColl = live.get(collection) ?? new Map<string, T>()\n    const candColl = cand.get(collection) ?? new Map<string, T>()\n    const allIds = new Set([...liveColl.keys(), ...candColl.keys()])\n\n    for (const id of [...allIds].sort()) {\n      const before = liveColl.get(id)\n      const after = candColl.get(id)\n\n      if (before === undefined && after !== undefined) {\n        // added: record only in candidate — no receiver envelope\n        added.push({ collection, id, record: after })\n      } else if (before !== undefined && after === undefined) {\n        // deleted: record only in receiver — attach metadata if requested\n        const metadata = options.includeMetadata\n          ? (await vault.collection(collection).getMetadata(id)) ?? undefined\n          : undefined\n        deleted.push({ collection, id, record: before, ...(metadata !== undefined ? { metadata } : {}) })\n      } else if (before !== undefined && after !== undefined) {\n        if (compareFn(before, after)) {\n          unchanged?.push({ collection, id, record: after })\n        } else {\n          // modified: record in both — attach receiver-side metadata if requested\n          const metadata = options.includeMetadata\n            ? (await vault.collection(collection).getMetadata(id)) ?? undefined\n            : undefined\n          const fieldDiffs = fieldDiff(before, after)\n          const fieldsChanged = uniqueTopLevelKeys(fieldDiffs)\n          modified.push({\n            collection,\n            id,\n            record: after,\n            before,\n            fieldsChanged,\n            fieldDiffs,\n            ...(metadata !== undefined ? { metadata } : {}),\n          })\n        }\n      }\n    }\n  }\n\n  const summary = {\n    add: added.length,\n    modify: modified.length,\n    delete: deleted.length,\n    total: added.length + modified.length + deleted.length,\n    skipped: skipped.length,\n  }\n\n  return {\n    added,\n    modified,\n    deleted,\n    unchanged,\n    skipped,\n    summary,\n    format(opts) {\n      return formatDiff(opts?.detail ?? 'full', { added, modified, deleted, summary })\n    },\n  }\n}\n\n// ─── Internals ─────────────────────────────────────────────────────────\n\n/**\n * Is the candidate a live `Vault`? Duck-typed via `exportStream` — matching\n * vault.ts's structural shape without an `instanceof` that would import the\n * class and risk a circular dep.\n *\n * ⚠️ Hoisted out of `normaliseCandidate` by family#151 because the ANSWER\n * decides how the LIVE side is keyed, which is computed before the candidate is\n * normalised. The two sides must agree or every record mismatches.\n */\nfunction isVaultCandidate(candidate: unknown): boolean {\n  return typeof candidate === 'object'\n    && candidate !== null\n    && 'exportStream' in candidate\n    && typeof (candidate as Vault).exportStream === 'function'\n}\n\nasync function normaliseCandidate<T>(\n  candidate: DiffCandidate<T>,\n  idKey: string,\n  filter: Set<string> | null,\n  byHubId: boolean,\n  skipped: VaultDiffSkipped[],\n): Promise<Map<string, Map<string, T>>> {\n  const out = new Map<string, Map<string, T>>()\n\n  if (byHubId) {\n    for await (const chunk of (candidate as Vault).exportStream({ granularity: 'collection' })) {\n      if (filter && !filter.has(chunk.collection)) continue\n      const collection = out.get(chunk.collection) ?? new Map<string, T>()\n      chunk.records.forEach((record, i) => {\n        const id = chunk.ids?.[i] ?? ''\n        if (!id) {\n          skipped.push({ collection: chunk.collection, side: 'candidate', index: i })\n          return\n        }\n        collection.set(id, record as T)\n      })\n      out.set(chunk.collection, collection)\n    }\n    return out\n  }\n\n  // String — assume a vault.dump() JSON string. Parse and reduce to the map shape.\n  if (typeof candidate === 'string') {\n    let parsed: unknown\n    try {\n      parsed = JSON.parse(candidate)\n    } catch (err) {\n      throw new Error(\n        `diffVault: candidate string is not valid JSON (${(err as Error).message})`,\n      )\n    }\n    return collectionsFromObject<T>(parsed, idKey, filter, skipped)\n  }\n\n  // Plain object — `Record<collection, records[]>` (same shape as-json.toObject() returns).\n  return collectionsFromObject<T>(candidate, idKey, filter, skipped)\n}\n\nfunction collectionsFromObject<T>(\n  raw: unknown,\n  idKey: string,\n  filter: Set<string> | null,\n  skipped: VaultDiffSkipped[],\n): Map<string, Map<string, T>> {\n  const out = new Map<string, Map<string, T>>()\n  if (raw === null || typeof raw !== 'object') {\n    throw new Error('diffVault: candidate must be a Vault, an object, or a JSON string')\n  }\n  // A vault dump JSON has a top-level shape like { _compartment, _keyring, <coll>: <records[]> }.\n  // We accept both: keys starting with `_` are skipped (they're metadata), the rest are collections.\n  for (const [key, value] of Object.entries(raw)) {\n    if (key.startsWith('_')) continue\n    if (filter && !filter.has(key)) continue\n    if (!Array.isArray(value)) continue\n    const collection = new Map<string, T>()\n    ;(value as readonly T[]).forEach((record, i) => {\n      // family#151 — RECORDED, not dropped. A candidate row with no `idKey`\n      // field lands in no bucket, and `as`'s `apply()` walks only the buckets,\n      // so the row was silently never imported. This path cannot key by hub id\n      // (a plain object carries none), so the honest fix is to make the skip\n      // observable instead of pretending the row did not exist.\n      if (record === null || typeof record !== 'object') {\n        skipped.push({ collection: key, side: 'candidate', index: i })\n        return\n      }\n      const id = readIdField(record, idKey)\n      if (!id) {\n        skipped.push({ collection: key, side: 'candidate', index: i })\n        return\n      }\n      collection.set(id, record)\n    })\n    out.set(key, collection)\n  }\n  return out\n}\n\nfunction uniqueTopLevelKeys(diffs: readonly FieldDiffEntry[]): readonly string[] {\n  const keys = new Set<string>()\n  for (const d of diffs) {\n    // path is dot-separated; the top-level key is everything before the\n    // first `.` or `[`. (`a.b.c` → `a`, `tags[0]` → `tags`, `(root)` → `(root)`).\n    const m = /^[^.[]+/.exec(d.path)\n    if (m) keys.add(m[0])\n  }\n  return [...keys]\n}\n\n/**\n * Pull the id field off a record without going through `String(obj)`,\n * which would emit `[object Object]` for nested objects and silently\n * collapse rows that share the same parent. Only string and number ids\n * are accepted; anything else returns the empty string and the record\n * is skipped at the call site.\n */\nfunction readIdField(record: unknown, idKey: string): string {\n  if (record === null || typeof record !== 'object') return ''\n  const v = (record as Record<string, unknown>)[idKey]\n  if (typeof v === 'string') return v\n  if (typeof v === 'number' && Number.isFinite(v)) return String(v)\n  return ''\n}\n\ninterface FormatBuckets<T> {\n  readonly added: readonly VaultDiffEntry<T>[]\n  readonly modified: readonly VaultDiffModifiedEntry<T>[]\n  readonly deleted: readonly VaultDiffEntry<T>[]\n  readonly summary: VaultDiff<T>['summary']\n}\n\nfunction formatDiff<T>(\n  detail: 'count' | 'one-line' | 'full',\n  b: FormatBuckets<T>,\n): string {\n  // family#151 — a skip is in EVERY detail level, including 'count'. The whole\n  // defect was that these rows were invisible, and `format()` is what a human\n  // reads before approving an import; \"0 added\" with rows quietly unimportable\n  // is the sentence this is meant to stop being printable.\n  const skipNote = b.summary.skipped > 0 ? ` · ${b.summary.skipped} SKIPPED (unkeyable)` : ''\n  const head = `${b.summary.add} added · ${b.summary.modify} modified · ${b.summary.delete} deleted${skipNote}`\n  if (detail === 'count') return head\n  if (b.summary.total === 0) return head + (b.summary.skipped > 0 ? '' : '\\n(no changes)')\n  if (detail === 'one-line') return head\n\n  const rows: string[] = [head, '']\n  for (const e of b.added) rows.push(`${e.collection}/${e.id}\\tadded`)\n  for (const e of b.modified) {\n    const fields = e.fieldDiffs\n      .map((f) => `${f.path}: ${shortJSON(f.from)} → ${shortJSON(f.to)}`)\n      .join(', ')\n    rows.push(`${e.collection}/${e.id}\\tmodified\\t${fields}`)\n  }\n  for (const e of b.deleted) rows.push(`${e.collection}/${e.id}\\tdeleted`)\n  return rows.join('\\n')\n}\n\nfunction shortJSON(value: unknown): string {\n  if (value === undefined) return 'undefined'\n  const s = JSON.stringify(value)\n  // JSON.stringify returns string for any JSON value except `undefined`\n  // (handled above), `function`, and `symbol`. Fall back to a static\n  // tag for those — never let an arbitrary object hit the default\n  // stringifier (which the lint rule explicitly bans).\n  if (typeof s !== 'string') return '<unrepresentable>'\n  return s.length > 60 ? s.slice(0, 57) + '...' : s\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-U2N7DH4S.js → chunk-AHA7UALU.js}

@@ -1,13 +1,13 @@
 import {
   envelopePayloadHash
-} from "./chunk-QHG7GQKM.js";
+} from "./chunk-5JNEDW7I.js";
 import {
   NOYDB_FORMAT_VERSION
-} from "./chunk-VUBRHJ4H.js";
+} from "./chunk-CR5UPYIJ.js";
 import {
   DictKeyMissingError,
   PermissionDeniedError
-} from "./chunk-JGYCKX56.js";
+} from "./chunk-ISIXU45J.js";
 
 // src/via/lookup/handle.ts
 function isDeleteMarker(envelope) {
@@ -392,4 +392,4 @@ export {
   dictCollectionName,
   LookupHandle
 };
-//# sourceMappingURL=chunk-U2N7DH4S.js.map
+//# sourceMappingURL=chunk-AHA7UALU.js.map