@noy-db/hub 0.9.0-pre.0 → 0.9.0-pre.2

package/CHANGELOG.md

@@ -1,5 +1,44 @@
 # Changelog — hub
 
+## 0.9.0-pre.2
+
+**A small, deliberate release: two keyring correctness items and the removal of six shim packages.** No format change, no new surface.
+
+⛔ **A keyring CREATE is now race-safe** (core#134, completing core#132). `writeKeyringFile` writes with `expectedVersion: 0`. core#132 made keyring writes CAS against the version they were computed from, which caught concurrent **updates** to one member; the **create** race stayed open, so two concurrent grants of the same new `userId` both succeeded and the second silently replaced the first — a member who appeared granted, holding a keyring nobody else's view agreed with.
+
+⭐ That limit had been attributed to the store contract being unable to express *"write only if absent"*. Measured, the claim was **wrong**: hub never stores a version below 1, so `expectedVersion: 0` lets the first create through and conflicts every later one — an exact must-not-exist, with **no sentinel added to `put`'s signature and no seventh method on the six-method store contract**. Both were costed; neither was needed. What was missing was an **assertion**, not a mechanism: `@noy-db/ports/to` now holds the absent case (core#138), and `noy-db/to` ran it green across **19 adapters** before this line changed.
+
+⚠️ **Adapter authors:** the contracted answer is that the FIRST create SUCCEEDS. Do not implement absence by throwing — if your backend's conditional write rejects a missing item, OR in an existence check the way `to-aws-dynamo` does. The kit case asserts both halves, so that failure mode reddens rather than passing as "safe".
+
+⛔ **Not closable here: a mixed fleet.** An older hub writes keyrings at `_v: 1` with no `expectedVersion` at all, so it clobbers a new hub's CAS — create or update alike. The guarantee is real only once every writer is a new hub.
+
+**`KeyringTamperedError`'s re-seed guidance leads with PRESERVE** (core#143). It used to say *remove the vault from this device first*. That is safe on a local store — a hostile local store means the device is already owned — but on a **remote, separately administered** store the identical error can mean the store altered the keyring, and deleting the local copy destroys the only evidence; on a thin client there is nothing local to remove at all. The remedy now leads with preserving a copy of the raw store contents and names the remote case explicitly. Deliberately **not** conditioned on the store type: the branch that most needs the warning is the one hub cannot classify. No behaviour change; the test's property is now the ORDER of the two instructions.
+
+⛔ **The six `@noy-db/test-*-conformance` re-export shims are removed** (family#39 step 5). They were 8-line `export * from '@noy-db/ports/<port>'` packages kept published while the family's satellites moved off them; `to`, `as`, `on`, `at` and `daemon` all bind `@noy-db/ports/<port>` directly as of 2026-09-25.
+
+⚠️ **Already-published versions are unaffected.** `@noy-db/test-adapter-conformance@0.9.0-pre.1` and every earlier version stay installable; what stops is the publication of *new* ones. A consumer still pinning a shim keeps resolving it, and should migrate to the matching `@noy-db/ports` subpath — `/to`, `/as`, `/at`, `/on`, `/by`, `/capsule`.
+
+## 0.9.0-pre.1
+
+**A correctness release on the 0.9 line. The headline is a keyring race that surfaced as a tamper alarm on the user's own data** (core#132) — everything else is additive.
+
+⛔ **`_keyring` writes are now compare-and-swap.** Two sessions putting to a new collection each minted a DEK, one write silently lost, and a cold session then failed to authenticate **both** rows — reported as tampering, on data the user had just written themselves. A keyring write is now CAS'd against the version it was computed from, and a session that loses a mint **adopts the winner's DEK** instead of keeping its own. If you held data written by two concurrent first-writers on `0.9.0-pre.0`, this is the release that stops it recurring; it does not retroactively repair a pair of rows already minted under different DEKs.
+
+**Sync — three fixes pilot-1 witnessed against real DynamoDB** (core#107, core#108).
+- An arbiter now **replicates its admission refusals**, so the writer finds out at all. A refusal made on another device arrives as `origin: 'arbiter'` and is **report-only** — the local record is untouched, and `readmit()` is meaningless for it.
+- A dirty record **re-runs this device's own gates before pushing**, so a record refused on the way out (`origin: 'push-recheck'`) stays local and dirty and pushes itself once it passes again.
+- `RecordRejection` carries `recordAt` alongside `at`: an arbiter judges at **pull** time, so a record legitimately written while a period was open can be refused later. With both timestamps a UI can say *written then, refused now* rather than *your push was wrong*.
+
+**Backup and restore** (core#76, core#77, core#101, core#103, core#111, core#122). Reads can carry ids, the restore path is exported rather than inferred, and ⭐ **a restore now rewinds the ledger too** — previously the pod came back but the ledger did not, so the next pull reverted it. ⚠️ Delete markers persist across a restore; `vault.compact()` will not remove them, being blob compaction and cache-budget eviction that happens to share the word.
+
+**Presence binds the primary sync target, not `targets[0]`** (core#139). With `sync: [{cloud, role:'backup'}, {daemon, role:'sync-peer'}]` records synced with the daemon while presence published to a **push-only archive** target. The two selectors now agree.
+
+**`expectedVersion: 0` means "must not exist", and `@noy-db/ports/to` now asserts it** (core#134). The conformance kit holds the agreement instead of relying on it, and the adapter census found the divergence core#136 warned about is not present in this family.
+
+**Surface and docs.** The restore/pod types are exported with an invariant so it is the last time (core#101, core#54). `@internal` is not the surface — the golden is (core#128). The KEK gate that keeps the keyring inbox drain unreachable is pinned in a test (core#130), recorded as an accepted risk rather than a fix. `enrollWebAuthn`'s documented slot `meta` now records `rpId`, which the rotation ceremony falls back to (core#140).
+
+⚠️ **`@noy-db/ports` still carries `latest` on a prerelease**, because npm sets `latest` on a package's first publish regardless of `--tag`. Corrected at the `0.9.0` stable cut; there is no stable version to point it at yet.
+
 ## 0.9.0-pre.0
 
 **The line moves to 0.9.0 on this pre-release: a new package, a milestone, three seam widenings, and fourteen fewer names.** Everything below is additive unless marked ⛔.

package/dist/api-H4B7ZQXP.js

@@ -0,0 +1,18 @@
+import {
+  UserApi,
+  createUserApi
+} from "./chunk-S2ORTQGS.js";
+import "./chunk-6BEBWHNL.js";
+import "./chunk-WRLWEYHY.js";
+import "./chunk-O6VOR4NH.js";
+import "./chunk-VZFTON37.js";
+import "./chunk-NH2UOV3B.js";
+import "./chunk-HTRLQ4ZZ.js";
+import "./chunk-EPPAEGH5.js";
+import "./chunk-URGHKZPL.js";
+import "./chunk-2RH5SEY7.js";
+export {
+  UserApi,
+  createUserApi
+};
+//# sourceMappingURL=api-H4B7ZQXP.js.map

package/dist/as/index.js

@@ -1,5 +1,5 @@
 import "../chunk-2DX4JCRI.js";
-import "../chunk-EMAWOGVH.js";
+import "../chunk-654RE5YC.js";
 import {
   applyListProjection
 } from "../chunk-VG2ZSFYD.js";
@@ -9,19 +9,19 @@ import {
 import "../chunk-RXLYKVTF.js";
 import "../chunk-QJNAHPVT.js";
 import "../chunk-VYYM3MEN.js";
-import "../chunk-J4KAPKBJ.js";
+import "../chunk-UORWAG7K.js";
 import "../chunk-Y2NBBT6K.js";
-import "../chunk-H3YM66EI.js";
-import "../chunk-4J3MNVVX.js";
-import "../chunk-ZBUAX4EF.js";
-import "../chunk-SPPOUJLN.js";
+import "../chunk-IF2M43G4.js";
+import "../chunk-WRLWEYHY.js";
+import "../chunk-O6VOR4NH.js";
+import "../chunk-VZFTON37.js";
 import "../chunk-NH2UOV3B.js";
-import "../chunk-OM3SEDI4.js";
-import "../chunk-PUBI455O.js";
-import "../chunk-2ELOCEXE.js";
+import "../chunk-HTRLQ4ZZ.js";
+import "../chunk-EPPAEGH5.js";
+import "../chunk-URGHKZPL.js";
 import {
   ValidationError
-} from "../chunk-VSUQI5Q6.js";
+} from "../chunk-2RH5SEY7.js";
 
 // src/port/as/active.ts
 function redactChunk(chunk, ctx, redact) {

package/dist/at/index.js

@@ -3,15 +3,15 @@ import {
   MemorySealer,
   SEALED_SECRET_RECORD_ID,
   parseSealedEnvelope
-} from "../chunk-XKBTJGFP.js";
-import "../chunk-4J3MNVVX.js";
-import "../chunk-ZBUAX4EF.js";
-import "../chunk-SPPOUJLN.js";
+} from "../chunk-GU6QXHPZ.js";
+import "../chunk-WRLWEYHY.js";
+import "../chunk-O6VOR4NH.js";
+import "../chunk-VZFTON37.js";
 import "../chunk-NH2UOV3B.js";
-import "../chunk-OM3SEDI4.js";
-import "../chunk-PUBI455O.js";
-import "../chunk-2ELOCEXE.js";
-import "../chunk-VSUQI5Q6.js";
+import "../chunk-HTRLQ4ZZ.js";
+import "../chunk-EPPAEGH5.js";
+import "../chunk-URGHKZPL.js";
+import "../chunk-2RH5SEY7.js";
 export {
   MemoryRecipientSealer,
   MemorySealer,

package/dist/attestation/index.js

@@ -1,19 +1,19 @@
 import {
   issueAttestationCore
-} from "../chunk-QDHHHI5Q.js";
+} from "../chunk-5SMCBPJ2.js";
 import {
   getRevokedDocIdsCore,
   publishRevocationListCore,
   revokeDocCore,
   unrevokeDocCore
-} from "../chunk-K7RW7FI4.js";
-import "../chunk-5XONHAFD.js";
+} from "../chunk-UADW5NOU.js";
+import "../chunk-B6EWMGFX.js";
 import {
   ATTESTATIONS_COLLECTION
-} from "../chunk-D5A3GCZ4.js";
+} from "../chunk-IPF5ORDI.js";
 import {
   NO_ATTESTATION
-} from "../chunk-6QLCS7ET.js";
+} from "../chunk-LZN6DTFI.js";
 import {
   decodeQr,
   isRevoked,
@@ -22,27 +22,27 @@ import {
   verifyRevocationList
 } from "../chunk-GMKGGY7V.js";
 import "../chunk-4AOERLTV.js";
-import "../chunk-4J3MNVVX.js";
-import "../chunk-ZBUAX4EF.js";
-import "../chunk-SPPOUJLN.js";
+import "../chunk-WRLWEYHY.js";
+import "../chunk-O6VOR4NH.js";
+import "../chunk-VZFTON37.js";
 import "../chunk-NH2UOV3B.js";
-import "../chunk-OM3SEDI4.js";
-import "../chunk-PUBI455O.js";
-import "../chunk-2ELOCEXE.js";
+import "../chunk-HTRLQ4ZZ.js";
+import "../chunk-EPPAEGH5.js";
+import "../chunk-URGHKZPL.js";
 import {
   AttestationError,
   AttestationNotEnabledError
-} from "../chunk-VSUQI5Q6.js";
+} from "../chunk-2RH5SEY7.js";
 
 // src/with-audit/attestation/active.ts
 function withAttestation() {
   return {
     async issueAttestation(ctx, args) {
-      const { issueAttestationCore: issueAttestationCore2 } = await import("../issue-LPEEEMPP.js");
+      const { issueAttestationCore: issueAttestationCore2 } = await import("../issue-5ZHXK4HJ.js");
       return issueAttestationCore2(ctx, args);
     },
     async getDocumentSigningPublicKey(deps) {
-      const { loadSigner, loadOrCreateSigner } = await import("../signer-IUIYR3CX.js");
+      const { loadSigner, loadOrCreateSigner } = await import("../signer-TW5MAQJP.js");
       const existing = await loadSigner(deps.adapter, deps.vault, deps.getDEK);
       if (existing) return { keyId: existing.keyId, publicKeyB64: existing.publicKeyB64 };
       if (deps.role !== "owner") {
@@ -52,19 +52,19 @@ function withAttestation() {
       return { keyId: signer.keyId, publicKeyB64: signer.publicKeyB64 };
     },
     async revokeAttestation(ctx, docId) {
-      const { revokeDocCore: revokeDocCore2 } = await import("../revoke-G2KXJQA5.js");
+      const { revokeDocCore: revokeDocCore2 } = await import("../revoke-6AFVXTWF.js");
       return revokeDocCore2(ctx, docId);
     },
     async unrevokeAttestation(ctx, docId) {
-      const { unrevokeDocCore: unrevokeDocCore2 } = await import("../revoke-G2KXJQA5.js");
+      const { unrevokeDocCore: unrevokeDocCore2 } = await import("../revoke-6AFVXTWF.js");
       return unrevokeDocCore2(ctx, docId);
     },
     async getRevokedDocIds(ctx) {
-      const { getRevokedDocIdsCore: getRevokedDocIdsCore2 } = await import("../revoke-G2KXJQA5.js");
+      const { getRevokedDocIdsCore: getRevokedDocIdsCore2 } = await import("../revoke-6AFVXTWF.js");
       return getRevokedDocIdsCore2(ctx);
     },
     async publishRevocationList(ctx) {
-      const { publishRevocationListCore: publishRevocationListCore2 } = await import("../revoke-G2KXJQA5.js");
+      const { publishRevocationListCore: publishRevocationListCore2 } = await import("../revoke-6AFVXTWF.js");
       return publishRevocationListCore2(ctx);
     }
   };

package/dist/{backup-7RKNZMQO.js → backup-E3GBMNDA.js}

@@ -3,50 +3,40 @@ import {
 } from "./chunk-EPFF7LOX.js";
 import {
   SCHEMAS_COLLECTION
-} from "./chunk-H3YM66EI.js";
+} from "./chunk-IF2M43G4.js";
 import {
   PERIODS_COLLECTION,
   PERIOD_ARCHIVES_COLLECTION,
   PERIOD_FREEZES_COLLECTION,
   PERIOD_REOPENS_COLLECTION,
   PERIOD_TARGET_PURGES_COLLECTION
-} from "./chunk-6WS35E6X.js";
+} from "./chunk-A52BK5AY.js";
 import {
   SEQUENCE_COLLECTION
-} from "./chunk-BYHCKX73.js";
+} from "./chunk-CLOSXHR4.js";
 import {
   LEDGER_COLLECTION,
   LEDGER_DELTAS_COLLECTION
 } from "./chunk-I7FD46FF.js";
 import {
   buildRecordEnvelope
-} from "./chunk-4J3MNVVX.js";
-import "./chunk-ZBUAX4EF.js";
-import "./chunk-SPPOUJLN.js";
+} from "./chunk-WRLWEYHY.js";
+import "./chunk-O6VOR4NH.js";
+import "./chunk-VZFTON37.js";
 import "./chunk-NH2UOV3B.js";
-import "./chunk-OM3SEDI4.js";
-import "./chunk-PUBI455O.js";
+import "./chunk-HTRLQ4ZZ.js";
+import "./chunk-EPPAEGH5.js";
 import {
   NOYDB_BACKUP_VERSION
-} from "./chunk-2ELOCEXE.js";
+} from "./chunk-URGHKZPL.js";
 import {
   BackupCorruptedError,
   BackupLedgerError
-} from "./chunk-VSUQI5Q6.js";
+} from "./chunk-2RH5SEY7.js";
 
 // src/with-pod/backup.ts
-async function dumpVault(ctx) {
-  const snapshot = await ctx.adapter.loadAll(ctx.vault);
-  const keyringIds = await ctx.adapter.list(ctx.vault, "_keyring");
-  const keyrings = {};
-  for (const keyringId of keyringIds) {
-    const envelope = await ctx.adapter.get(ctx.vault, "_keyring", keyringId);
-    if (envelope) {
-      keyrings[keyringId] = JSON.parse(envelope._data ?? "");
-    }
-  }
-  const internalSnapshot = {};
-  const internalNames = [
+function internalCollectionNames(dataCollections) {
+  return [
     LEDGER_COLLECTION,
     LEDGER_DELTAS_COLLECTION,
     SCHEMAS_COLLECTION,
@@ -87,8 +77,21 @@ async function dumpVault(ctx) {
     // old eTag may not exist in the destination, so it must be stripped
     // there instead. Asymmetry: backup = same-vault-resumable = carry;
     // partition = cross-vault = strip-breadcrumb-carry-marker.
-    ...Object.keys(snapshot).flatMap((c) => [`_blob_slots_${c}`, `_blob_versions_${c}`])
+    ...dataCollections.flatMap((c) => [`_blob_slots_${c}`, `_blob_versions_${c}`])
   ];
+}
+async function dumpVault(ctx) {
+  const snapshot = await ctx.adapter.loadAll(ctx.vault);
+  const keyringIds = await ctx.adapter.list(ctx.vault, "_keyring");
+  const keyrings = {};
+  for (const keyringId of keyringIds) {
+    const envelope = await ctx.adapter.get(ctx.vault, "_keyring", keyringId);
+    if (envelope) {
+      keyrings[keyringId] = JSON.parse(envelope._data ?? "");
+    }
+  }
+  const internalSnapshot = {};
+  const internalNames = internalCollectionNames(Object.keys(snapshot));
   for (const internalName of internalNames) {
     const ids = await ctx.adapter.list(ctx.vault, internalName);
     if (ids.length === 0) continue;
@@ -119,9 +122,52 @@ async function dumpVault(ctx) {
   };
   return JSON.stringify(backup);
 }
-async function loadVault(ctx, backupJson) {
+async function reconcileCollection(ctx, collection, podRows) {
+  let written = 0, skipped = 0, deleted = 0;
+  for (const [id, envelope] of Object.entries(podRows)) {
+    const local = await ctx.adapter.get(ctx.vault, collection, id);
+    if (local && local._v === envelope._v) {
+      skipped++;
+      continue;
+    }
+    await ctx.adapter.put(ctx.vault, collection, id, envelope);
+    written++;
+  }
+  for (const id of await ctx.adapter.list(ctx.vault, collection)) {
+    if (id in podRows) continue;
+    await ctx.adapter.delete(ctx.vault, collection, id);
+    deleted++;
+  }
+  return { written, skipped, deleted };
+}
+function podReport(mode, per) {
+  let written = 0, skipped = 0, deleted = 0;
+  for (const r of Object.values(per)) {
+    written += r.written;
+    skipped += r.skipped;
+    deleted += r.deleted;
+  }
+  return { mode, written, skipped, deleted, collections: per };
+}
+async function loadVault(ctx, backupJson, options) {
   const backup = JSON.parse(backupJson);
-  await ctx.adapter.saveAll(ctx.vault, backup.collections);
+  const mode = options?.mode ?? "replace";
+  const per = {};
+  if (mode === "incremental" && backup._compartment !== ctx.vault) {
+    throw new BackupLedgerError(
+      `Incremental load refused: this pod was taken from vault "${backup._compartment}" and is being loaded into "${ctx.vault}". Incremental mode reconciles a vault against its OWN pod; use mode: 'replace' to overwrite this vault with a foreign pod.`
+    );
+  }
+  if (mode === "incremental") {
+    const localData = await ctx.adapter.loadAll(ctx.vault);
+    const names = /* @__PURE__ */ new Set([...Object.keys(backup.collections), ...Object.keys(localData)]);
+    for (const name of names) {
+      const r = await reconcileCollection(ctx, name, backup.collections[name] ?? {});
+      if (r.written || r.skipped || r.deleted) per[name] = r;
+    }
+  } else {
+    await ctx.adapter.saveAll(ctx.vault, backup.collections);
+  }
   for (const [userId, keyringFile] of Object.entries(backup.keyrings)) {
     const envelope = buildRecordEnvelope(
       { collection: "_keyring", id: userId, version: 1 },
@@ -129,16 +175,30 @@ async function loadVault(ctx, backupJson) {
     );
     await ctx.adapter.put(ctx.vault, "_keyring", userId, envelope);
   }
-  if (backup._internal) {
-    for (const [internalName, records] of Object.entries(backup._internal)) {
-      for (const [id, envelope] of Object.entries(records)) {
-        await ctx.adapter.put(ctx.vault, internalName, id, envelope);
+  const internalNamesToLoad = internalCollectionNames(Object.keys(backup.collections));
+  if (mode === "incremental") {
+    for (const internalName of internalNamesToLoad) {
+      const r = await reconcileCollection(ctx, internalName, backup._internal?.[internalName] ?? {});
+      if (r.written || r.skipped || r.deleted) per[internalName] = r;
+    }
+  } else {
+    for (const internalName of internalNamesToLoad) {
+      for (const id of await ctx.adapter.list(ctx.vault, internalName)) {
+        await ctx.adapter.delete(ctx.vault, internalName, id);
+      }
+    }
+    if (backup._internal) {
+      for (const [internalName, records] of Object.entries(backup._internal)) {
+        for (const [id, envelope] of Object.entries(records)) {
+          await ctx.adapter.put(ctx.vault, internalName, id, envelope);
+        }
       }
     }
   }
   await ctx.reloadKeyringAndRebuildDEK();
   ctx.clearCollectionCache();
   ctx.resetLedgerStore();
+  await ctx.resetSync?.();
   if (!backup.ledgerHead) {
     if (ctx.getLedgerOrNull()) {
       console.warn(
@@ -149,7 +209,7 @@ async function loadVault(ctx, backupJson) {
         `[noy-db] Loaded a backup with no ledgerHead \u2014 this pod is not integrity-checked. This reader has no ledger enabled (withHistory() is not configured), so nothing is stale: enable the ledger on both the exporter and this reader if tamper detection is wanted.`
       );
     }
-    return;
+    return podReport(mode, per);
   }
   const result = await verifyBackupIntegrity(ctx);
   if (!result.ok) {
@@ -167,6 +227,7 @@ async function loadVault(ctx, backupJson) {
       `Backup ledger head mismatch: embedded "${backup.ledgerHead.hash}" but reconstructed "${result.head}".`
     );
   }
+  return podReport(mode, per);
 }
 async function verifyBackupIntegrity(ctx) {
   const ledgerForVerify = ctx.getLedgerOrNull();
@@ -266,4 +327,4 @@ export {
   loadVault,
   verifyBackupIntegrity
 };
-//# sourceMappingURL=backup-7RKNZMQO.js.map
+//# sourceMappingURL=backup-E3GBMNDA.js.map

package/dist/backup-E3GBMNDA.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/with-pod/backup.ts"],"sourcesContent":["/**\n * Vault backup / restore / integrity.\n *\n * Holds `dump()` (verifiable encrypted JSON backup, including the blob\n * collections so blob \"covers\" travel in the bundle), `load()` (restore +\n * post-load integrity gate), `verifyBackupIntegrity()` (chain + data-envelope\n * cross-check), and `exportJSON()` (plaintext per-collection export, built on\n * the vault's `exportStream`). Behaviour is byte-identical to the inline\n * `Vault` methods these functions replaced — every dependency the moving code\n * touched on `this.*` arrives via {@link BackupContext}. `Vault` keeps the\n * public methods as thin delegators.\n *\n * Internal — reached through `vault.dump()` / `vault.load()` / etc.\n */\nimport { NOYDB_BACKUP_VERSION } from '../kernel/types.js'\nimport { BackupLedgerError, BackupCorruptedError } from '../kernel/errors.js'\nimport { LEDGER_COLLECTION, LEDGER_DELTAS_COLLECTION } from '../with-commit/history/ledger/constants.js'\nimport { SCHEMAS_COLLECTION } from '../with-shape/persisted-schemas/storage.js'\nimport { SEQUENCE_COLLECTION } from '../with-commit/sequence/index.js'\nimport { MANIFEST_COLLECTION } from '../with-shape/manifest/reserved-collections.js'\n// #1025 — imported from the dependency-light `window.ts`, not `periods.ts`: that\n// module exists precisely so a consumer can name the period collections without\n// dragging the ledger hash-chain machinery (`sha256Hex`/`canonicalJson`) into a\n// bundle that opted out of the periods service. Same reason the sync engine's\n// period-scoped pull imports it.\nimport {\n  PERIODS_COLLECTION,\n  PERIOD_FREEZES_COLLECTION,\n  PERIOD_ARCHIVES_COLLECTION,\n  PERIOD_TARGET_PURGES_COLLECTION,\n  PERIOD_REOPENS_COLLECTION,\n} from '../with-audit/periods/window.js'\nimport type {\n  NoydbStore,\n  EncryptedEnvelope,\n  VaultBackup,\n  VaultSnapshot,\n  LoadPodOptions,\n  LoadPodResult,\n  ExportStreamOptions,\n  ExportChunk,\n} from '../kernel/types.js'\nimport type { LedgerStore } from '../with-commit/history/ledger/store.js'\nimport { buildRecordEnvelope } from '../capsule/index.js'\n\n/** Everything the moving backup methods touched on the vault's `this.*`. */\nexport interface BackupContext {\n  /** The ciphertext store. */\n  readonly adapter: NoydbStore\n  /** Vault namespace name. */\n  readonly vault: string\n  /** The invoking keyring's user id (read fresh per call). */\n  userId(): string\n  /** The vault's ledger store, or null when history is off. */\n  getLedgerOrNull(): LedgerStore | null\n  /** Recompute an envelope's `payloadHash` (bound `historyStrategy.envelopePayloadHash`). */\n  envelopePayloadHash(envelope: EncryptedEnvelope): Promise<string>\n  /**\n   * Refresh the in-memory keyring from the freshly-loaded keyring file and\n   * rebuild the DEK resolver. No-op when the vault has no `reloadKeyring`\n   * callback (plaintext vaults / test constructions).\n   */\n  reloadKeyringAndRebuildDEK(): Promise<void>\n  /**\n   * core#71 — reset every sync engine attached to the vault after a restore:\n   * the dirty log, the watermarks, the adopted epoch. A restore is a new base;\n   * the pre-restore dirty entries refer to records the load just replaced.\n   * Absent on test constructions without sync.\n   */\n  resetSync?(): Promise<void>\n  /** Clear the vault's collection cache (post-load). */\n  clearCollectionCache(): void\n  /** Reset the ledger store so the next `ledger()` rebuilds its head cache. */\n  resetLedgerStore(): void\n  /** The vault's decrypt+ACL export stream (used by `exportJSON`). */\n  exportStream(opts: ExportStreamOptions): AsyncIterableIterator<ExportChunk>\n}\n\n/** Result of {@link verifyBackupIntegrity}. */\nexport type VerifyBackupResult =\n  | { readonly ok: true; readonly head: string; readonly length: number }\n  | {\n      readonly ok: false\n      readonly kind: 'chain'\n      readonly divergedAt: number\n      readonly message: string\n    }\n  | {\n      readonly ok: false\n      readonly kind: 'data'\n      readonly collection: string\n      readonly id: string\n      readonly message: string\n    }\n\n/**\n * Dump vault as a verifiable encrypted JSON backup string.\n *\n * backups embed the current ledger head and the full `_ledger` +\n * `_ledger_deltas` internal collections so the receiver can run\n * `verifyBackupIntegrity()` after `load()` and detect any tampering between\n * dump and restore. Backups produced without a ledger skip the integrity check\n * with a warning — both modes round-trip cleanly.\n */\n/**\n * core#111 — the internal collections a pod carries, derived from its DATA\n * collection names. ⭐ ONE definition, used by the dump AND by the load's\n * clear step: they must agree or a restore leaves rows behind that the pod\n * says should not exist.\n *\n * ⛔ The load side CANNOT just clear what the pod carries. The dump skips a\n * collection with no rows (`if (ids.length === 0) continue`), so a pod taken\n * while `_periods` was empty does not mention `_periods` at all — and a store\n * that has since closed a period would keep those rows through a restore.\n * Absence in a pod means \"empty at dump time\", never \"leave whatever is there\".\n */\nfunction internalCollectionNames(dataCollections: readonly string[]): string[] {\n  return [\n    LEDGER_COLLECTION, LEDGER_DELTAS_COLLECTION, SCHEMAS_COLLECTION, SEQUENCE_COLLECTION,\n    MANIFEST_COLLECTION, // #941: the pod's manifest-set record(s) travel in the bundle too\n    // #1025: the accounting-period close state + its companions. The bundle is\n    // the backup/restore path, so without these a restore discarded the\n    // hash-chained evidence that a month was ever closed — the artifact\n    // `closePeriod` exists to produce — and dropped the write gate with it, so\n    // the restored vault silently accepted back-dated writes into a sealed\n    // month. The companions matter as much as the close: a bounded reopen\n    // window (`reopenPeriod({ until })`) is state a restore must not lose.\n    PERIODS_COLLECTION,\n    PERIOD_REOPENS_COLLECTION,\n    PERIOD_FREEZES_COLLECTION,\n    PERIOD_ARCHIVES_COLLECTION,\n    PERIOD_TARGET_PURGES_COLLECTION,\n    '_history', // full-snapshot version history — so history()/getVersion()/diff() survive the bundle\n    '_blob_index', '_blob_chunks', '_blob_eviction_audit',\n    // #753 spec §7 Q3: `_blob_intent` markers travel too — restoring mid-op\n    // state (a blob row without its marker) would reproduce the ambiguity\n    // the journal exists to prevent. Note: `_mv_stale` does NOT travel\n    // today (a pre-existing, separate gap) — observed here, tracked on\n    // #761, not fixed in this pass.\n    '_blob_intent',\n    // #769: `_blob_slots_<c>` envelopes travel verbatim (raw ciphertext,\n    // same DEK, same vault) — including any `SlotRecord.pendingRelease`\n    // resume breadcrumb they carry. This is INTENTIONALLY the opposite of\n    // `extract-partition`'s `reKeyBlobs`, which STRIPS `pendingRelease`:\n    // a full-vault backup restores into the SAME vault it was taken from,\n    // so a breadcrumb taken mid-rehome (together with its `_blob_intent`\n    // marker, carried above) is resumable on restore — carry-and-resume is\n    // correct here. A partition extraction crosses vaults: the breadcrumb's\n    // old eTag may not exist in the destination, so it must be stripped\n    // there instead. Asymmetry: backup = same-vault-resumable = carry;\n    // partition = cross-vault = strip-breadcrumb-carry-marker.\n    ...dataCollections.flatMap((c) => [`_blob_slots_${c}`, `_blob_versions_${c}`]),\n  ]\n}\n\nexport async function dumpVault(ctx: BackupContext): Promise<string> {\n  const snapshot = await ctx.adapter.loadAll(ctx.vault)\n\n  // Load keyrings (separate path because loadAll filters them out\n  // along with all other underscore-prefixed internal collections).\n  const keyringIds = await ctx.adapter.list(ctx.vault, '_keyring')\n  const keyrings: Record<string, unknown> = {}\n  for (const keyringId of keyringIds) {\n    const envelope = await ctx.adapter.get(ctx.vault, '_keyring', keyringId)\n    if (envelope) {\n      keyrings[keyringId] = JSON.parse(envelope._data ?? '')\n    }\n  }\n\n  // Load the ledger entries + deltas so the receiver can replay\n  // the chain after restore. Without this, `load()` would have an\n  // empty ledger and `verifyBackupIntegrity()` would have nothing\n  // to compare against.\n  //\n  // Also enumerate the blob collections so blob content (\"covers\")\n  // travels in the bundle (the blob DEK already travels in `_keyring`).\n  // Literals are inlined (not imported from blobs/blob-set.ts) to keep\n  // the blob runtime out of this kernel hot path — they mirror\n  // BLOB_INDEX/CHUNKS/EVICTION_AUDIT_COLLECTION and SLOTS/VERSIONS_PREFIX.\n  // The collect-loop skips empty ids, so this no-ops without blobs.\n  const internalSnapshot: VaultSnapshot = {}\n  const internalNames = internalCollectionNames(Object.keys(snapshot))\n  for (const internalName of internalNames) {\n    const ids = await ctx.adapter.list(ctx.vault, internalName)\n    if (ids.length === 0) continue\n    const records: Record<string, EncryptedEnvelope> = {}\n    for (const id of ids) {\n      const envelope = await ctx.adapter.get(ctx.vault, internalName, id)\n      if (envelope) records[id] = envelope\n    }\n    internalSnapshot[internalName] = records\n  }\n\n  // Embed the ledger head if there's a chain. An empty ledger\n  // (fresh vault) leaves `ledgerHead` undefined, which\n  // load() treats the same as a legacy backup (no integrity\n  // check, console warning). If history is not opted in,\n  // `getLedgerOrNull` returns null and we skip embedding entirely\n  // — the backup is still valid, just without the integrity head.\n  const ledgerForHead = ctx.getLedgerOrNull()\n  const head = ledgerForHead ? await ledgerForHead.head() : null\n  const backup: VaultBackup = {\n    _noydb_backup: NOYDB_BACKUP_VERSION,\n    _compartment: ctx.vault,\n    _exported_at: new Date().toISOString(),\n    _exported_by: ctx.userId(),\n    keyrings: keyrings as VaultBackup['keyrings'],\n    collections: snapshot,\n    ...(Object.keys(internalSnapshot).length > 0\n      ? { _internal: internalSnapshot }\n      : {}),\n    ...(head\n      ? {\n          ledgerHead: {\n            hash: head.hash,\n            index: head.entry.index,\n            ts: head.entry.ts,\n          },\n        }\n      : {}),\n  }\n\n  return JSON.stringify(backup)\n}\n\n/**\n * Restore a vault from a verifiable backup. After loading, runs\n * `verifyBackupIntegrity()` to confirm the hash chain, the embedded head, and\n * every data envelope's payload hash. Legacy backups (no `ledgerHead`) load\n * with a console warning and skip the integrity check.\n */\n/**\n * core#77 — reconcile ONE collection against the pod's rows: write what\n * differs, delete what the pod does not carry, leave the rest untouched.\n *\n * Identity is `(id, _v)`, not a content hash — chunk rows are not\n * content-addressed today. That is enough to avoid rewriting 10 GB that has\n * not changed; it is NOT enough to dedupe across records, and nothing here\n * claims otherwise.\n *\n * ⛔ The DELETE half is what keeps this a restore rather than a merge: an id\n * the store holds and the pod does not is removed, exactly as `saveAll`\n * removes it in replace mode (core#111 — a restore rewinds).\n */\nasync function reconcileCollection(\n  ctx: BackupContext,\n  collection: string,\n  podRows: Record<string, EncryptedEnvelope>,\n): Promise<{ written: number; skipped: number; deleted: number }> {\n  let written = 0, skipped = 0, deleted = 0\n  for (const [id, envelope] of Object.entries(podRows)) {\n    const local = await ctx.adapter.get(ctx.vault, collection, id)\n    if (local && local._v === envelope._v) { skipped++; continue }\n    await ctx.adapter.put(ctx.vault, collection, id, envelope)\n    written++\n  }\n  for (const id of await ctx.adapter.list(ctx.vault, collection)) {\n    if (id in podRows) continue\n    await ctx.adapter.delete(ctx.vault, collection, id)\n    deleted++\n  }\n  return { written, skipped, deleted }\n}\n\n/** Fold the per-collection counters into the returned report. */\nfunction podReport(mode: 'replace' | 'incremental', per: Record<string, { written: number; skipped: number; deleted: number }>): LoadPodResult {\n  let written = 0, skipped = 0, deleted = 0\n  for (const r of Object.values(per)) { written += r.written; skipped += r.skipped; deleted += r.deleted }\n  return { mode, written, skipped, deleted, collections: per }\n}\n\nexport async function loadVault(\n  ctx: BackupContext,\n  backupJson: string,\n  options?: LoadPodOptions,\n): Promise<LoadPodResult> {\n  const backup = JSON.parse(backupJson) as VaultBackup\n  const mode = options?.mode ?? 'replace'\n  const per: Record<string, { written: number; skipped: number; deleted: number }> = {}\n\n  // core#77 — a pod from ANOTHER vault is refused in incremental mode. In\n  // replace mode `saveAll` overwrites wholesale and the result is at least\n  // coherent; \"write only the differences\" between unrelated vaults is not a\n  // restore, it is a silent union of two histories, and the keyrings that\n  // arrive with it would not open what is already here.\n  if (mode === 'incremental' && backup._compartment !== ctx.vault) {\n    throw new BackupLedgerError(\n      `Incremental load refused: this pod was taken from vault \"${backup._compartment}\" ` +\n      `and is being loaded into \"${ctx.vault}\". Incremental mode reconciles a vault against ` +\n      `its OWN pod; use mode: 'replace' to overwrite this vault with a foreign pod.`,\n    )\n  }\n\n  // 1. Restore data collections.\n  if (mode === 'incremental') {\n    const localData = await ctx.adapter.loadAll(ctx.vault)\n    const names = new Set([...Object.keys(backup.collections), ...Object.keys(localData)])\n    for (const name of names) {\n      const r = await reconcileCollection(ctx, name, backup.collections[name] ?? {})\n      if (r.written || r.skipped || r.deleted) per[name] = r\n    }\n  } else {\n    await ctx.adapter.saveAll(ctx.vault, backup.collections)\n  }\n\n  // 2. Restore keyrings.\n  for (const [userId, keyringFile] of Object.entries(backup.keyrings)) {\n    // ⛔ core#132 — NO CAS HERE, deliberately. A pod restore is state\n    // REPLACEMENT (core#111 made the internal collections wholesale too): the\n    // pod is authoritative and there is no \"version this was based on\" to\n    // compare against. CASing a restore would make it fail precisely when the\n    // store has drifted, which is the case it exists to fix.\n    const envelope = buildRecordEnvelope({ collection: '_keyring', id: userId, version: 1 },\n      { iv: '', data: JSON.stringify(keyringFile) })\n    await ctx.adapter.put(ctx.vault, '_keyring', userId, envelope)\n  }\n\n  // 3. Restore internal collections (`_ledger`, `_ledger_deltas`, history,\n  //    periods, blobs). Required so verifyBackupIntegrity has the chain to walk.\n  //\n  // ⛔⛔ CLEAR FIRST (core#111). This used to `put` the pod's rows id by id and\n  // leave everything else, so entries written AFTER the pod survived the\n  // restore. With history on that is not a cosmetic leftover: the ledger chain\n  // still named `notes/n2`, whose envelope `saveAll` had just removed, and the\n  // integrity check refused the restore outright —\n  //   BackupCorruptedError: Ledger expects data record \"notes/n2\" to exist …\n  // which made restoring an OLDER pod possible only onto a store whose ledger\n  // had not moved. That is never the case that matters: a restore is a step\n  // BACK (core#71/#72).\n  //\n  // ⭐ A restore rewinds the ledger too, and now says so. The internal\n  // collections are replaced wholesale, the way `saveAll` already treats the\n  // data ones — anything else asks the chain to describe a store it does not\n  // match. The names come from `internalCollectionNames`, NOT from the pod's\n  // own keys: see the ⛔ on that function for why absence in a pod cannot mean\n  // \"leave it alone\".\n  //\n  // ⚠️ Known residue, deliberately not chased here: `_blob_slots_<c>` /\n  // `_blob_versions_<c>` for a DATA collection the pod does not carry are not\n  // cleared, because the names are derived from the pod's collections and the\n  // store contract has no way to enumerate `_`-prefixed collections\n  // (`loadAll` skips them). Those rows are already orphaned — `saveAll` has\n  // just removed the collection they describe — so they are unreachable\n  // rather than misleading.\n  //\n  // core#77 — in INCREMENTAL mode the same names are reconciled instead of\n  // cleared and rewritten. ⭐ This is the half that matters for the 10 GB\n  // case: `_blob_chunks` is an internal collection, so a clear-and-rewrite\n  // here would re-upload every chunk and leave \"incremental\" saving only the\n  // record envelopes. Reconciling reaches the SAME end state — extras are\n  // still deleted, so the restore still rewinds — at a cost proportional to\n  // what actually differs.\n  const internalNamesToLoad = internalCollectionNames(Object.keys(backup.collections))\n  if (mode === 'incremental') {\n    for (const internalName of internalNamesToLoad) {\n      const r = await reconcileCollection(ctx, internalName, backup._internal?.[internalName] ?? {})\n      if (r.written || r.skipped || r.deleted) per[internalName] = r\n    }\n  } else {\n    for (const internalName of internalNamesToLoad) {\n      for (const id of await ctx.adapter.list(ctx.vault, internalName)) {\n        await ctx.adapter.delete(ctx.vault, internalName, id)\n      }\n    }\n    if (backup._internal) {\n      for (const [internalName, records] of Object.entries(backup._internal)) {\n        for (const [id, envelope] of Object.entries(records)) {\n          await ctx.adapter.put(ctx.vault, internalName, id, envelope)\n        }\n      }\n    }\n  }\n\n  // 4. Refresh the in-memory keyring from the freshly-loaded\n  //    keyring file. Without this, the Vault's getDEK\n  //    closure still holds the OLD session's DEKs, and every\n  //    decrypt of a loaded ledger entry / data envelope fails\n  //    with TamperedError because the DEK doesn't match the\n  //    ciphertext that was encrypted with the SOURCE user's DEK.\n  //    Skipped for plaintext vaults and for tests that\n  //    construct Vault without a reloadKeyring callback.\n  await ctx.reloadKeyringAndRebuildDEK()\n\n  // 5. Clear collection cache + reset the ledger store so the\n  //    next ledger() call rebuilds its head cache from the\n  //    freshly-loaded entries.\n  ctx.clearCollectionCache()\n  ctx.resetLedgerStore()\n\n  // 6. core#71 — a restore is a new base for sync: the pre-restore dirty log\n  //    named records the load replaced, and the watermarks described a state\n  //    that is gone. `replaceRemote` (core#72) is the explicit act that makes\n  //    the restore authoritative on the target; without it, `load()` stays a\n  //    local view — and now says so in `syncTargetStatus()` instead of pushing\n  //    stale entries.\n  await ctx.resetSync?.()\n\n  // 5. Run the verification gate. A backup with no ledgerHead cannot be\n  //    integrity-checked, and skipping silently would collapse\n  //    *unverifiable* into *clean* — so it always warns. But the REMEDY\n  //    depends on the reader, not the pod (#1303): the pod cannot say\n  //    whether its exporter predates the ledger or never enabled it, and\n  //    the reader knows its own configuration.\n  //\n  //    - Reader HAS the ledger: the pod is behind it. \"Re-export\" is\n  //      actionable; keep the migration wording.\n  //    - Reader has NO ledger: nothing is stale and nothing is migrating —\n  //      the consumer priced the ledger (#1248 measured ~2.4x) and declined.\n  //      Prescribing a re-export is advice they should not take, and\n  //      repeating it on every read trains people to filter the one line\n  //      that also fires on a genuinely stale pod. State the consequence,\n  //      name the discriminator, prescribe nothing.\n  if (!backup.ledgerHead) {\n    if (ctx.getLedgerOrNull()) {\n      console.warn(\n        `[noy-db] Loaded a legacy backup with no ledgerHead — ` +\n        `verifiable-backup integrity check skipped. ` +\n        `Re-export with a ledger-aware build to get tamper detection.`,\n      )\n    } else {\n      console.warn(\n        `[noy-db] Loaded a backup with no ledgerHead — this pod is not integrity-checked. ` +\n        `This reader has no ledger enabled (withHistory() is not configured), so nothing is stale: ` +\n        `enable the ledger on both the exporter and this reader if tamper detection is wanted.`,\n      )\n    }\n    return podReport(mode, per)\n  }\n\n  const result = await verifyBackupIntegrity(ctx)\n  if (!result.ok) {\n    // Surface the most specific error class we can. The result\n    // shape carries enough info for callers to inspect.\n    if (result.kind === 'data') {\n      throw new BackupCorruptedError(\n        result.collection,\n        result.id,\n        result.message,\n      )\n    }\n    throw new BackupLedgerError(result.message, result.divergedAt)\n  }\n\n  // 6. Cross-check: the freshly-verified head must match the\n  //    value embedded at dump time. A mismatch means someone\n  //    truncated or extended the chain after dump.\n  if (result.head !== backup.ledgerHead.hash) {\n    throw new BackupLedgerError(\n      `Backup ledger head mismatch: embedded \"${backup.ledgerHead.hash}\" ` +\n      `but reconstructed \"${result.head}\".`,\n    )\n  }\n  return podReport(mode, per)\n}\n\n/**\n * End-to-end backup integrity check: `ledger.verify()` (hash chain) plus a data\n * envelope cross-check (every current record's `_data` hash must match the\n * latest `put` entry's `payloadHash`). Returns a discriminated union so callers\n * can distinguish chain vs data failures.\n */\nexport async function verifyBackupIntegrity(ctx: BackupContext): Promise<VerifyBackupResult> {\n  // Step 1: chain verification. Without the history strategy there\n  // is no ledger; an unaudited backup verifies trivially as `ok`\n  // because there's nothing to diverge from.\n  const ledgerForVerify = ctx.getLedgerOrNull()\n  if (!ledgerForVerify) {\n    return { ok: true, head: '', length: 0 }\n  }\n  const chainResult = await ledgerForVerify.verify()\n  if (!chainResult.ok) {\n    return {\n      ok: false,\n      kind: 'chain',\n      divergedAt: chainResult.divergedAt,\n      message:\n        `Ledger chain diverged at index ${chainResult.divergedAt}: ` +\n        `expected prevHash \"${chainResult.expected}\" but found \"${chainResult.actual}\".`,\n    }\n  }\n\n  // Step 2: data envelope cross-check. Walk every entry in the\n  // ledger and, for the LATEST `put` per (collection, id), recompute\n  // the data envelope's payloadHash and compare. Earlier puts of the\n  // same id are skipped because the data collection only holds the\n  // current version — historical envelopes live in the deltas\n  // collection (which is itself protected by the chain).\n  // Reuse the ledger we already resolved in step 1.\n  const allEntries = await ledgerForVerify.loadAllEntries()\n\n  // Find the latest non-delete entry per (collection, id). Walk\n  // the entries in reverse so we hit the latest first; mark each\n  // (collection, id) as seen and skip subsequent entries.\n  const seen = new Set<string>()\n  const latest = new Map<\n    string,\n    { collection: string; id: string; expectedHash: string }\n  >()\n  for (let i = allEntries.length - 1; i >= 0; i--) {\n    const entry = allEntries[i]\n    if (!entry) continue\n    // Amendment entries are multi-record audit entries whose\n    // `collection` and `id` are empty strings — building a `\"/\"`\n    // key here would mark that synthetic slot as seen and falsely\n    // trip the data check on a record that never existed. Skip\n    // them BEFORE the key/seen bookkeeping so they neither\n    // tombstone real entries nor enter the latest map.\n    if (entry.op === 'amendment' || entry.op === 'lifecycle') continue\n    const key = `${entry.collection}/${entry.id}`\n    if (seen.has(key)) continue\n    seen.add(key)\n    // For deletes the data collection should NOT have the record,\n    // so we skip — there's nothing to cross-check. Marking the key\n    // as seen above ensures any earlier `put` of the same id is\n    // also skipped (the record was subsequently deleted).\n    if (entry.op === 'delete') continue\n    latest.set(key, {\n      collection: entry.collection,\n      id: entry.id,\n      expectedHash: entry.payloadHash,\n    })\n  }\n\n  for (const { collection, id, expectedHash } of latest.values()) {\n    const envelope = await ctx.adapter.get(ctx.vault, collection, id)\n    if (!envelope) {\n      return {\n        ok: false,\n        kind: 'data',\n        collection,\n        id,\n        message:\n          `Ledger expects data record \"${collection}/${id}\" to exist, ` +\n          `but the adapter has no envelope for it.`,\n      }\n    }\n    const actualHash = await ctx.envelopePayloadHash(envelope)\n    if (actualHash !== expectedHash) {\n      return {\n        ok: false,\n        kind: 'data',\n        collection,\n        id,\n        message:\n          `Data envelope \"${collection}/${id}\" has been tampered with: ` +\n          `expected payloadHash \"${expectedHash}\", got \"${actualHash}\".`,\n      }\n    }\n  }\n\n  return {\n    ok: true,\n    head: chainResult.head,\n    length: chainResult.length,\n  }\n}\n\n/**\n * Plaintext per-collection export, built on the vault's `exportStream`. Forces\n * collection granularity (record-by-record output makes no sense in a single\n * string) and merges dictionary snapshots across collections.\n */\nexport async function exportVaultJSON(ctx: BackupContext, opts: ExportStreamOptions = {}): Promise<string> {\n  // Force per-collection granularity regardless of caller setting:\n  // record-by-record output doesn't make sense in a single string.\n  const collections: Record<\n    string,\n    {\n      schema: null\n      refs: Record<string, { target: string; mode: 'strict' | 'warn' | 'cascade' }>\n      records: unknown[]\n    }\n  > = {}\n  let ledgerHead: ExportChunk['ledgerHead'] | undefined\n  // Merged dictionary snapshot across all collections.\n  // Only populated when `resolveLabels` is not set.\n  const allDictionaries: Record<\n    string, // collection name\n    Record<string, Record<string, Record<string, string>>>\n  > = {}\n\n  for await (const chunk of ctx.exportStream({\n    granularity: 'collection',\n    withLedgerHead: opts.withLedgerHead === true,\n    // Thread the export locale so records are read at the\n    // `export` layer (i18nText collapsed + dictKey/staticDict labels resolved).\n    ...(opts.resolveLabels !== undefined ? { resolveLabels: opts.resolveLabels } : {}),\n  })) {\n    collections[chunk.collection] = {\n      schema: null, // Standard Schema validators are not JSON-serializable\n      refs: chunk.refs,\n      records: chunk.records,\n    }\n    if (chunk.ledgerHead) ledgerHead = chunk.ledgerHead\n    // Collect dictionary snapshots unless resolveLabels is set\n    if (!opts.resolveLabels && chunk.dictionaries) {\n      allDictionaries[chunk.collection] = chunk.dictionaries\n    }\n  }\n\n  const hasDictionaries = Object.keys(allDictionaries).length > 0\n  return JSON.stringify({\n    _noydb_export: 1,\n    _compartment: ctx.vault,\n    _exported_at: new Date().toISOString(),\n    _exported_by: ctx.userId(),\n    collections,\n    ...(hasDictionaries ? { _dictionaries: allDictionaries } : {}),\n    ...(ledgerHead ? { ledgerHead } : {}),\n  })\n}\n"],"mappings":"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","names":[]}

package/dist/blobs/index.js

@@ -10,7 +10,7 @@ import {
   createExportBlobsHandle,
   reportOrphanBlobChunks,
   runCompaction
-} from "../chunk-G5EDYVSE.js";
+} from "../chunk-ZK2WT532.js";
 import {
   BLOB_CHUNKS_COLLECTION,
   BLOB_COLLECTION,
@@ -25,20 +25,20 @@ import {
   detectMimeType,
   isPreCompressed,
   memoryBlobPinStore
-} from "../chunk-QXJXG7DN.js";
-import "../chunk-PTJY5R3O.js";
-import "../chunk-UHFGK6YA.js";
-import "../chunk-RIZTZJX6.js";
-import "../chunk-4J3MNVVX.js";
-import "../chunk-ZBUAX4EF.js";
-import "../chunk-SPPOUJLN.js";
+} from "../chunk-7IV7GVOS.js";
+import "../chunk-PIO6NW7O.js";
+import "../chunk-XQGKS4OW.js";
+import "../chunk-LJ744WXU.js";
+import "../chunk-WRLWEYHY.js";
+import "../chunk-O6VOR4NH.js";
+import "../chunk-VZFTON37.js";
 import "../chunk-NH2UOV3B.js";
-import "../chunk-OM3SEDI4.js";
-import "../chunk-PUBI455O.js";
-import "../chunk-2ELOCEXE.js";
+import "../chunk-HTRLQ4ZZ.js";
+import "../chunk-EPPAEGH5.js";
+import "../chunk-URGHKZPL.js";
 import {
   BlobOfflineError
-} from "../chunk-VSUQI5Q6.js";
+} from "../chunk-2RH5SEY7.js";
 
 // src/via/blob/active.ts
 function withBlobs(options = {}) {

package/dist/broker/index.js

@@ -1,21 +1,21 @@
 import {
   NO_BROKER
-} from "../chunk-72XBVN4J.js";
+} from "../chunk-FVKQ5QUC.js";
 import {
   issueChallenge,
   verifyBrokerProof
-} from "../chunk-4J3MNVVX.js";
-import "../chunk-ZBUAX4EF.js";
-import "../chunk-SPPOUJLN.js";
+} from "../chunk-WRLWEYHY.js";
+import "../chunk-O6VOR4NH.js";
+import "../chunk-VZFTON37.js";
 import "../chunk-NH2UOV3B.js";
-import "../chunk-OM3SEDI4.js";
-import "../chunk-PUBI455O.js";
-import "../chunk-2ELOCEXE.js";
+import "../chunk-HTRLQ4ZZ.js";
+import "../chunk-EPPAEGH5.js";
+import "../chunk-URGHKZPL.js";
 import {
   BrokerEnrolmentError,
   BrokerNotEnabledError,
   BrokerProofError
-} from "../chunk-VSUQI5Q6.js";
+} from "../chunk-2RH5SEY7.js";
 
 // src/with-party/broker/active.ts
 var DEFAULT_SKEW_MS = 6e4;
@@ -28,7 +28,7 @@ function withBroker(config) {
   const cache = /* @__PURE__ */ new Map();
   return {
     async enroll(ctx) {
-      const { enrollSeed } = await import("../seed-JMQTRKRE.js");
+      const { enrollSeed } = await import("../seed-BVYDPVIW.js");
       return enrollSeed({ ...ctx, config });
     },
     async rotate(ctx) {
@@ -37,15 +37,15 @@ function withBroker(config) {
       const inFlight = scoped.map(([, e]) => e.inFlight).filter((p) => p !== void 0);
       await Promise.allSettled(inFlight);
       for (const [key] of scoped) cache.delete(key);
-      const { rotateSeed } = await import("../seed-JMQTRKRE.js");
+      const { rotateSeed } = await import("../seed-BVYDPVIW.js");
       return rotateSeed({ ...ctx, config });
     },
     async enrolMember(ctx, member) {
-      const { enrolMemberSeed } = await import("../seed-JMQTRKRE.js");
+      const { enrolMemberSeed } = await import("../seed-BVYDPVIW.js");
       return enrolMemberSeed({ ...ctx, config }, member);
     },
     async revokeMember(ctx, userId) {
-      const { revokeMemberSeed } = await import("../seed-JMQTRKRE.js");
+      const { revokeMemberSeed } = await import("../seed-BVYDPVIW.js");
       return revokeMemberSeed({ ...ctx, config }, userId);
     },
     credentialSource(ctx, profile) {
@@ -62,7 +62,7 @@ function withBroker(config) {
         const skewMs = config.skewMs ?? DEFAULT_SKEW_MS;
         const capturedEntry = entry;
         const inFlight = (async () => {
-          const { mintStoreCredentials } = await import("../seed-JMQTRKRE.js");
+          const { mintStoreCredentials } = await import("../seed-BVYDPVIW.js");
           const creds = await mintStoreCredentials({ ...ctx, config }, profile);
           capturedEntry.cached = { creds, validUntil: cacheFloor(creds, skewMs) };
           return creds;

package/dist/by/index.js

@@ -1,8 +1,8 @@
 import {
   isQuorum,
   runDrainBarrier
-} from "../chunk-UNSQZSZP.js";
-import "../chunk-VSUQI5Q6.js";
+} from "../chunk-PWAMX5KU.js";
+import "../chunk-2RH5SEY7.js";
 export {
   isQuorum,
   runDrainBarrier