@noy-db/hub 0.5.0 → 0.6.0-pre.0

package/dist/with-shape/manifest/sync.d.ts

@@ -0,0 +1,135 @@
+/**
+ * Keep the persisted `_manifest/schema` record in sync with the
+ * per-collection `_schemas/<collection>` source of truth (#941 Task 3).
+ *
+ * Called from `persisted-schemas/register.ts`'s `persistSchemaIfNeeded`
+ * right after a `_schemas/<collection>` write succeeds.
+ *
+ * ## Reconciling strict-CAS-refuse with the derived nature of the manifest
+ *
+ * `writer.ts`'s `writeSchemaManifest` is deliberately strict-CAS: a
+ * concurrent *direct* edit to the manifest is refused, never retried (AC
+ * #1). But this call site is not a direct edit — it is a re-derivation
+ * from the source of truth, triggered as a side effect of a `_schemas`
+ * write that has ALREADY succeeded. When N collections are declared
+ * together (one `openVault()` call registering several `persistJsonSchema:
+ * true` collections), their `persistSchemaIfNeeded` calls run CONCURRENTLY
+ * — each one's own `_schemas/<collection>` write lands independently, and
+ * each then calls this function. A single derive-then-write with no
+ * feedback loop is NOT enough here: a call whose `deriveSchemaManifest`
+ * snapshot ran before a sibling's `_schemas` write landed would persist a
+ * manifest that's missing that sibling forever (nothing re-triggers it) —
+ * this was a REAL bug (not a test-isolation artifact — reproduced with 0
+ * shared state, purely from concurrent `_schemas` writes racing the derive
+ * snapshot; see #941 flake fix commit). `syncSchemaManifest` therefore
+ * loops (bounded by {@link MAX_SYNC_ATTEMPTS}):
+ *
+ *   1. Derive fresh, compare to what's persisted. Already converged → done.
+ *   2. Write via strict-CAS. `ManifestConflictError` (another writer moved
+ *      the manifest first) → loop: re-derive against the NEW state and
+ *      retry, exactly like a normal optimistic-CAS retry.
+ *   3. On a successful write, derive ONE more time. If a sibling's
+ *      `_schemas` write landed while we were deriving/writing, the state
+ *      has already moved past what we just wrote — loop again to catch it
+ *      up. If the re-derive matches what we wrote, we're the last writer
+ *      and the manifest is provably converged: return.
+ *
+ * This guarantees that whichever collection's `_schemas` write is the LAST
+ * to land (in real wall-clock order — there is always exactly one, even
+ * though no single caller knows which) ends up running a sync whose own
+ * derive sees every sibling's write already committed, and whose
+ * recheck-after-write confirms nothing moved further — so it converges the
+ * manifest deterministically, regardless of interleaving. If attempts are
+ * exhausted under pathological contention, the loop gives up — with a
+ * `console.warn` (see cap-exhaustion note below), not silently — leaving
+ * the last successful write in place; the manifest is a derivable cache
+ * (not a correctness invariant), so a next schema write or `open()`'s
+ * re-derive still converges it, matching how `persistSchemaIfNeeded`
+ * already treats its own write failures.
+ * Any error OTHER than `ManifestConflictError` (store failure, DEK
+ * resolution failure, etc.) is NOT swallowed — it propagates to the
+ * caller immediately, matching how `persistSchemaIfNeeded` already treats
+ * its own write failures as a visible (not silently discarded) fingerprint
+ * failure.
+ *
+ * ## CRITICAL fix (#941 review): a scoped principal must never write a
+ * partial manifest
+ *
+ * `deriveSchemaManifest` returns `undecodableCollections` for any
+ * `_schemas/<collection>` entry this principal's `lookupDEK` couldn't
+ * resolve — e.g. a member `grant()`-scoped to one collection can decrypt
+ * `_manifest` itself (system-prefixed DEKs propagate to every role) but
+ * NOT a sibling data collection's `_schemas/<sibling>` entry. Before this
+ * fix, `deriveSchemaManifest` silently treated "can't decrypt" the same as
+ * "no derivable content" and omitted the sibling — so a scoped member's
+ * OWN schema declare would derive a manifest missing every collection they
+ * can't see, load the real (complete) persisted manifest as a valid CAS
+ * token, observe a hash mismatch, and OVERWRITE it — permanently dropping
+ * the siblings, silently, ledger-audited as a legitimate migration. The
+ * converging recheck loop above made this WORSE, not better: re-deriving
+ * from the same restricted view just re-confirms the same partial result
+ * and declares it "stable."
+ *
+ * Fix: if `undecodableCollections` is non-empty, `syncSchemaManifest`
+ * `SKIP`s entirely — no read-compare, no write, no audit, no loop. It does
+ * NOT try to merge-preserve the undecodable entries from what's currently
+ * persisted: an `aggregateHash` computed over entries this principal can't
+ * verify would be a hash asserting something it never actually checked,
+ * which is worse than not writing at all. This is safe because:
+ *
+ *   - The source of truth, `_schemas/<their-collection>`, was ALREADY
+ *     updated by their declare — nothing about their own change is lost.
+ *   - The pod-wide `_manifest` cache simply isn't rewritten by a principal
+ *     who'd corrupt it by omission — it stays whatever a full-visibility
+ *     principal (owner/admin/custodian) last wrote.
+ *   - `open()` re-derives from `_schemas` directly (not from the cached
+ *     manifest) for whoever opens it, so a stale cache is never load-bearing.
+ *   - The NEXT full-visibility principal's declare (or any subsequent sync
+ *     by someone with complete access) naturally refreshes the cache,
+ *     including the scoped member's own just-landed change.
+ *
+ * ## Ledger audit (AC #5)
+ *
+ * Schema-generation transitions are not ledger-audited anywhere else today
+ * (neither the `_schemas/<collection>` write in `register.ts` nor the fence
+ * bump in `schema-update/fence-controller.ts#runCutover`). This is the
+ * first ledger-audited signal for a schema change: every manifest write
+ * that actually happens (i.e. every time the derived manifest differs from
+ * what's stored) appends an `op: 'migration'` entry via the optional
+ * `getLedgerOrNull` callback — `null`/absent when the history strategy
+ * isn't opted in, matching every other optional-ledger call site
+ * (`vault._getLedgerOrNull()?.append(...)`, see `liberate.ts`,
+ * `with-audit/periods/vault-facade.ts`). No audit fires on the no-op path
+ * (derived manifest unchanged), on a swallowed conflict (the winning
+ * writer's own sync already audits its write), or on the scoped-principal
+ * SKIP path above (nothing was written).
+ *
+ * @module
+ */
+import type { LedgerStore } from '../../with-commit/history/ledger/store.js';
+import type { NoydbStore } from '../../kernel/types.js';
+import { type LookupDEK } from './derive.js';
+import { type GetManifestDEK } from './storage.js';
+export interface ManifestSyncDeps {
+    /** Resolver for `_manifest`'s OWN DEK — mints if absent (this principal's declare is about to write it). */
+    readonly getDEK: GetManifestDEK;
+    /**
+     * NON-MINTING lookup for every OTHER (sibling data) collection's DEK,
+     * used by `deriveSchemaManifest` to build the index — see `derive.ts`'s
+     * `LookupDEK` doc for why minting here would be actively harmful.
+     */
+    readonly lookupDEK: LookupDEK;
+    /** Optional ledger handle — absent when the history strategy isn't opted in (no-op audit). */
+    readonly getLedgerOrNull?: () => LedgerStore | null;
+}
+/**
+ * Re-derive the schema manifest and write it if it changed, looping until
+ * the write is provably stable against concurrent sibling `_schemas`
+ * writes (see module doc). SKIPS entirely (no write, no audit) when this
+ * principal's view is incomplete (`undecodableCollections` non-empty) —
+ * see the module doc's CRITICAL fix section. Swallows a
+ * {@link ManifestConflictError} by retrying against the fresher state; any
+ * other error propagates. Ledger-audits (`op: 'migration'`) once per
+ * successful write.
+ */
+export declare function syncSchemaManifest(store: NoydbStore, vault: string, deps: ManifestSyncDeps): Promise<void>;

package/dist/with-shape/manifest/types.d.ts

@@ -0,0 +1,49 @@
+/**
+ * The pod-wide **schema manifest** record type (#941).
+ *
+ * This is an INDEX, not a full-inline manifest: `SchemaManifest.collections`
+ * carries per-collection *metadata* (generation / content hash / field ids),
+ * never the JSON Schema body itself. The JSON Schema stays the source of
+ * truth at `_schemas/<collection>`, encrypted under that collection's own
+ * DEK (see `with-shape/persisted-schemas`). Inlining full schemas into one
+ * pod-wide manifest record would either leak every collection's schema to a
+ * principal scoped to a single collection, or force the manifest itself
+ * onto a collection-DEK it has no business holding — the index preserves
+ * per-collection DEK isolation while still giving a single place to answer
+ * "what schema generation is this pod at, and does collection X's stored
+ * schema match its declared content hash."
+ *
+ * `aggregateHash` binds the whole per-collection index's content: it is
+ * `sha256Hex(canonicalJson(collections))`, so any change to any collection's
+ * entry (a new generation, a changed hash, added/renamed field ids) changes
+ * `aggregateHash` too. Canonical JSON (sorted object keys, no whitespace)
+ * makes the hash independent of the map's key insertion order.
+ *
+ * @module
+ */
+/** Per-collection entry inside a {@link SchemaManifest}'s `collections` index. */
+export interface SchemaManifestEntry {
+    /** The vault-wide schema-fence generation this collection's schema was last written at. */
+    readonly generation: number;
+    /** SHA-256 (hex) of the collection's canonicalised JSON Schema (see `persisted-schemas/derive.ts`). */
+    readonly contentHash: string;
+    /** Stable per-field ids (#946), keyed by the field's current name. Absent when the collection has none. */
+    readonly fieldIds?: Record<string, string>;
+}
+/**
+ * The pod-wide schema manifest — one record per pod, stored at
+ * `_manifest/schema` (see `storage.ts`). An INDEX over the per-collection
+ * `_schemas/<collection>` entries, not the schemas themselves.
+ */
+export interface SchemaManifest {
+    readonly v: 1;
+    readonly kind: 'schema';
+    /** Pod-wide schema-fence generation (`FenceDoc.currentSchemaVersion`) as of this manifest's derivation. */
+    readonly generation: number;
+    /** Per-collection index: collection name → its manifest entry. */
+    readonly collections: Record<string, SchemaManifestEntry>;
+    /** `sha256Hex(canonicalJson(collections))` — the pod-wide content binding over the index. */
+    readonly aggregateHash: string;
+}
+/** The record id the schema manifest is stored under inside `_manifest`. */
+export declare const MANIFEST_SCHEMA_RECORD_ID: "schema";

package/dist/with-shape/manifest/writer.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Strict-CAS schema-manifest writer (#941, AC #1).
+ *
+ * Every other reserved-collection writer in the hub (`persisted-schemas`'s
+ * `savePersistedSchema` callers, the classified/satellite marker writers)
+ * retries on a CAS conflict: re-read, re-apply, try again. The schema
+ * manifest deliberately does NOT — two concurrent *direct* edits to the
+ * manifest must be refused and surfaced, never silently merged or
+ * retry-resolved, because a manifest write encodes a specific point-in-time
+ * claim about the pod's schema generation/content-hash set. A caller that
+ * lost the race must re-derive against the fresh state and decide what to
+ * do, not have its stale write quietly re-applied on top of someone else's.
+ *
+ * Ledger audit: this writer does not have a `LedgerStore` handle at this
+ * seam (mirroring `persisted-schemas`, whose `_schemas/<collection>` writes
+ * are likewise not ledger-audited today). Wiring `LedgerStore.append({ op:
+ * 'migration', ... })` around a manifest write belongs at the call site
+ * where a ledger handle is already in scope (the open/write integration —
+ * #941 Task 3/4), not here.
+ *
+ * @module
+ */
+import { type GetManifestDEK } from './storage.js';
+import type { NoydbStore } from '../../kernel/types.js';
+import type { SchemaManifest } from './types.js';
+/**
+ * Write the schema manifest as a strict CAS: `expectedVersion` must match
+ * the stored envelope's `_v` (0 when no manifest exists yet). On a
+ * conflict, throws {@link ManifestConflictError} — this function never
+ * retries.
+ */
+export declare function writeSchemaManifest(store: NoydbStore, vault: string, manifest: SchemaManifest, expectedVersion: number, getDEK: GetManifestDEK): Promise<void>;

package/dist/with-shape/persisted-schemas/field-ids.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Stable field-identifier minting (#946).
+ *
+ * A field's `id` is opaque and permanent — minted once, from randomness
+ * only, with no timestamp and no name-derivation. A name-derived id would
+ * change when the field is renamed, defeating the whole point (identity
+ * must survive a rename). See `PersistedSchemaEnvelope.fieldIds`.
+ *
+ * @module
+ */
+/**
+ * Resolve the `fieldIds` map for a freshly-derived schema against the
+ * previously-stored envelope's map (if any). Existing ids are preserved by
+ * name — a field keeps its id across re-derivation as long as its name is
+ * unchanged; a genuinely new field name mints a fresh id. Returns
+ * `undefined` when the fresh schema has no derivable top-level field set
+ * (e.g. a stub envelope, or a non-object root schema).
+ *
+ * `renamed` (#946 Task 2) — unambiguous rename pairs from
+ * `computeSchemaDelta`'s `SchemaDelta.renamed`. When the fresh name is a
+ * rename target (`to`), the id is looked up under its OLD name (`from`)
+ * instead of the fresh name itself — the whole point of a stable field id
+ * is that it survives exactly this case; without it, a rename would mint a
+ * fresh id for the new name and silently drop the old one.
+ */
+export declare function resolveFieldIds(freshJsonSchema: object | null, priorFieldIds: Record<string, string> | undefined, renamed?: readonly {
+    readonly from: string;
+    readonly to: string;
+}[]): Record<string, string> | undefined;

package/dist/with-shape/persisted-schemas/register.d.ts

@@ -13,6 +13,7 @@
  *
  * @module
  */
+import { type ManifestSyncDeps } from '../manifest/sync.js';
 import type { SchemaUpdateStrategy, UpdateDecision } from '../schema-update/types.js';
 import type { NoydbStore, ClassifiedMarker } from '../../kernel/types.js';
 import type { PersistedSchemaEnvelope } from './types.js';
@@ -35,6 +36,8 @@ export declare function persistSchemaIfNeeded(opts: {
     readonly validator: unknown;
     readonly dek: EnclaveKey;
     readonly strategies?: readonly SchemaUpdateStrategy[];
+    /** #941 Task 3: re-derive + sync the `_manifest/schema` INDEX after a write. Omitted → no sync (e.g. tests that don't care). */
+    readonly manifestSync?: ManifestSyncDeps;
 }): Promise<PersistSchemaResult>;
 /**
  * Persist (or refresh) the C-A / R10 classified marker into the collection's

package/dist/with-shape/persisted-schemas/types.d.ts

@@ -51,4 +51,21 @@ export interface PersistedSchemaEnvelope {
      * the satellite-pair analogue of {@link classified}'s config-drift guard.
      */
     readonly satellite?: PairingMarker;
+    /**
+     * Stable per-field identifiers (#946), keyed by the field's current name
+     * (top-level JSON Schema `properties` key) and mapping to an opaque,
+     * permanent id minted once via `mintFieldId()`. IDs are preserved by name
+     * across re-derivation (a field keeps its id as long as its name is
+     * unchanged) so a field's identity survives a rename — the name is a
+     * label, the id is the stable key. Absent on a legacy (pre-#946) envelope
+     * and on a stub envelope with no derivable field set (`jsonSchema === null`).
+     */
+    readonly fieldIds?: Record<string, string>;
+    /**
+     * The vault-wide schema-fence generation (`FenceDoc.currentSchemaVersion`)
+     * as of this envelope's most recent write. Together with
+     * `FenceDoc.schemaHash`, answers "generation N = which schema content
+     * hash" (#946). Absent on a legacy (pre-#946) envelope.
+     */
+    readonly generation?: number;
 }

package/dist/with-shape/schema-update/fence-controller.d.ts

@@ -17,6 +17,37 @@ import type { TransformFn } from './types.js';
 import { type CoordinationProvider } from '../../port/by/index.js';
 /** Runs one collection's transform; supplied by the Vault (binds to a Collection). */
 export type RunTransform = (collection: string, transform: TransformFn) => Promise<void>;
+/** Structural (no static import — kernel-spine port-layering carve-out, same rationale as
+ *  `kernel/via/dispatch.ts`'s `AuditLedgerLike`) shape of the with-history `LedgerStore.append`
+ *  seam {@link schemaBumpAuditHook} needs. */
+interface AuditLedgerLike {
+    append(input: {
+        readonly op: 'lifecycle';
+        readonly collection: string;
+        readonly id: string;
+        readonly version: number;
+        readonly actor: string;
+        readonly payloadHash: string;
+        readonly reason?: string;
+    }): Promise<unknown>;
+}
+/**
+ * #965 — a bare `runCutover` generation bump (no re-declare, no per-record
+ * migrations) otherwise leaves zero ledger evidence: per-record `migration`
+ * entries only fire from `applyCutoverTransform` when records + a transform
+ * exist. Mirrors `ledgerAuditHook` (`kernel/via/dispatch.ts`): encoded as a
+ * `'lifecycle'` entry (no ciphertext to hash, `payloadHash: ''`), distinct
+ * from the per-record `op: 'migration'` entries via its
+ * `reason: 'schema:generation-bump=<n>'`. Fires once per successful bump,
+ * always — even when the same cutover also produced per-record entries —
+ * so "one bump entry per generation bump" stays a simple, unconditional
+ * invariant to audit against.
+ *
+ * `getLedger` is called lazily (at bump time, not at wiring time) — same
+ * lazy-init contract as `Vault.getLedgerOrNull`; calling it eagerly during
+ * `Vault` construction (before `this.strategies` is assigned) would throw.
+ */
+export declare function schemaBumpAuditHook(getLedger: () => AuditLedgerLike | null, actor: string): (generation: number) => Promise<void>;
 export declare class SchemaFenceController {
     #private;
     constructor(opts: {
@@ -38,6 +69,8 @@ export declare class SchemaFenceController {
             currentSchemaVersion: number;
             fenceState: FenceState;
         }) => void;
+        /** #965 — best-effort ledger audit for a bare (no-record) generation bump. See {@link schemaBumpAuditHook}. */
+        auditBump?: ((generation: number) => Promise<void>) | undefined;
     });
     /** Capture the generation snapshot at vault-open. */
     init(): Promise<void>;
@@ -60,3 +93,4 @@ export declare class SchemaFenceController {
     /** Recover a stuck drain: reset fenceState to normal at the current version (no bump). */
     abort(): Promise<void>;
 }
+export {};

package/dist/with-shape/schema-update/fence.d.ts

@@ -8,6 +8,15 @@ export type FenceState = 'normal' | 'draining' | 'migrating' | 'complete';
 export interface FenceDoc {
     readonly currentSchemaVersion: number;
     readonly fenceState: FenceState;
+    /**
+     * Content hash (`PersistedSchemaEnvelope.hash`) of the schema most
+     * recently persisted while the vault sat at `currentSchemaVersion` —
+     * binds "generation N" to a concrete schema-content hash (#946), so
+     * "which schema is generation N" is answerable from `schemaFenceState()`
+     * alone. Optional: absent on a fresh vault (generation 0, nothing
+     * persisted yet) and on a fence document written before #946.
+     */
+    readonly schemaHash?: string;
 }
 export declare const FENCE_RECORD_ID = "schema-fence";
 export declare const DEFAULT_FENCE: FenceDoc;

package/dist/with-shape/schema-update/strategies.d.ts

@@ -1,11 +1,27 @@
 import type { SchemaUpdateStrategy } from './types.js';
 /** Allow any schema change. Explicit blind / back-compat. */
 export declare function blindUpdate(): SchemaUpdateStrategy;
-/** Allow additive changes; reject non-additive ones. The safety backstop. */
+/**
+ * Allow additive changes; reject non-additive ones. The safety backstop.
+ *
+ * #946: a `renamed` pair is NOT additive-safe *for this gate* — the delta
+ * itself carries no data migration, so an allowed rename would orphan
+ * existing record values under the old key. `computeSchemaDelta` classifies
+ * a pure rename as `kind: 'additive'` (it IS additive-safe as far as the
+ * name-change itself is concerned, and the id-carry through `SchemaDelta.
+ * renamed` is real), but a guard whose whole job is "don't admit anything
+ * that isn't a mechanical additive write" must still block it — the same as
+ * it blocks any other non-additive change — forcing a `coordinatedCutover()`
+ * (or `blindUpdate()`) to actually move the data.
+ */
 export declare function additiveOnly(): SchemaUpdateStrategy;
 /**
  * Reject schema changes. With `fields`, reject only when one of those
- * fields is added/removed/changed; otherwise reject any non-`none` delta.
+ * fields is added/removed/changed/renamed; otherwise reject any non-`none`
+ * delta. #946: a `renamed` pair's `from` AND `to` both count as touching a
+ * locked field — a rename away from a locked name (or onto one) still
+ * violates the lock, and a blanket `lockSchema()` (no `fields`) already
+ * blocks any rename since a pure rename's `kind` is never `'none'`.
  */
 export declare function lockSchema(opts?: {
     readonly fields?: readonly string[];

package/dist/with-shape/schema-update/types.d.ts

@@ -23,6 +23,17 @@ export interface SchemaDelta {
     readonly removed: readonly string[];
     /** Top-level properties present in both but altered. */
     readonly changed: readonly FieldChange[];
+    /**
+     * Unambiguous rename pairs detected by shape-matching a removed name
+     * against an added name (#946) — same field, new label. Present only
+     * when at least one pairing was found; the paired names are excluded
+     * from `added`/`removed` (a pure rename is additive-safe, not a
+     * drop+add). See `computeSchemaDelta`'s doc comment for the pairing rule.
+     */
+    readonly renamed?: readonly {
+        readonly from: string;
+        readonly to: string;
+    }[];
 }
 /** Context handed to a strategy alongside the delta. */
 export interface UpdateContext {

package/dist/with-sync/engine.d.ts

@@ -19,6 +19,10 @@ export declare class SyncEngine {
     private readonly vault;
     readonly role: SyncTargetRole;
     readonly label: string | undefined;
+    /** #948: the resolved policy this engine was constructed with, retained for
+     *  introspection (`Noydb.listSyncTargets()`) — otherwise lost once consumed
+     *  into the scheduler below. */
+    readonly policy: SyncPolicy | undefined;
     private dirty;
     private lastPush;
     private lastPull;

package/dist/with-sync/presence.d.ts

@@ -26,7 +26,14 @@ export interface PresenceHandleOpts {
     vault: string;
     /** Collection name — used as HKDF `info` and channel suffix. */
     collectionName: string;
-    /** Calling user's ID, embedded unencrypted in storage records. */
+    /**
+     * Calling user's ID. In encrypted mode it is encrypted inside the
+     * storage-poll record's `data` field — the record id is an
+     * adapter-opaque HMAC tag, not the userId, so the adapter never learns
+     * peer identities. Unencrypted vaults have no key to tag or encrypt
+     * with, so the userId is used as the record id in cleartext (dev posture
+     * only — identity privacy requires encryption).
+     */
     userId: string;
     /** Whether encryption is active. When false, presence payloads are stored as JSON. */
     encrypted: boolean;
@@ -51,6 +58,7 @@ export declare class PresenceHandle<P> {
     private readonly channel;
     private readonly storageCollection;
     private presenceKey;
+    private presenceTagKey;
     private subscribers;
     private unsubscribePubSub;
     private pollTimer;
@@ -71,6 +79,28 @@ export declare class PresenceHandle<P> {
     /** Stop all listening and clear resources. */
     stop(): void;
     private getPresenceKey;
+    /**
+     * Derive (and cache) the presence-tag key — a non-extractable, sign-only
+     * HMAC-SHA256 key HKDF-derived from the collection DEK, domain-separated
+     * from the presence payload key by {@link PRESENCE_TAG_KEY_DOMAIN}.
+     * Mirrors `deriveClassifyIndexKey` (kernel/enclave/classify/bidx.ts). No
+     * PBKDF2 stretch — the adapter never holds this key, so a plain keyed HMAC
+     * tag is sufficient and deterministic. Returns `null` when unencrypted
+     * (no DEK to derive from).
+     */
+    private getPresenceTagKey;
+    /**
+     * Deterministic, adapter-opaque tag for `userId` — used as the
+     * storage-poll record id in encrypted mode so the adapter never sees the
+     * userId. Falls back to the raw `userId` when unencrypted (no key exists
+     * to tag with — see {@link PresenceHandleOpts.userId}).
+     *
+     * Signs directly via `subtle.sign` (like `bidx.ts`'s `mintAt`) rather than
+     * the barrel's `hmacSha256Hex` helper: that helper re-exports its key
+     * argument's raw bytes internally, which only works for extractable keys
+     * (e.g. an AES-GCM DEK) — `presenceTagKey` is deliberately non-extractable.
+     */
+    private presenceTag;
     private getPubSubAdapter;
     private startListening;
     private stopListening;

package/dist/withdraw-accessible-JSDQHXHE.js

@@ -0,0 +1,28 @@
+import {
+  FROZEN_SNAPSHOTS_COLLECTION,
+  freezeAndDeleteClosure,
+  freezeSnapshotOnly,
+  randomId,
+  withdrawAccessibleData
+} from "./chunk-JSRU5W2M.js";
+import "./chunk-4MQDV3HZ.js";
+import "./chunk-EK7DT5BT.js";
+import "./chunk-CYQOUTMY.js";
+import "./chunk-FY343IZR.js";
+import "./chunk-NQRJ5AJO.js";
+import "./chunk-HXGUIPQB.js";
+import "./chunk-AR2JDFAE.js";
+import "./chunk-747LRSOO.js";
+import "./chunk-LP7BEXCT.js";
+import "./chunk-VCETL77O.js";
+import "./chunk-24ZLWWEO.js";
+import "./chunk-HNGSV2YC.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  FROZEN_SNAPSHOTS_COLLECTION,
+  freezeAndDeleteClosure,
+  freezeSnapshotOnly,
+  randomId,
+  withdrawAccessibleData
+};
+//# sourceMappingURL=withdraw-accessible-JSDQHXHE.js.map

package/dist/withdraw-accessible-JSDQHXHE.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@noy-db/hub",
-  "version": "0.5.0",
+  "version": "0.6.0-pre.0",
   "description": "Zero-knowledge, offline-first, encrypted document store — core library with AES-256-GCM, PBKDF2, multi-user keyring, and sync engine",
   "license": "MIT",
   "author": "vLannaAi <vicio@lanna.ai>",
@@ -208,14 +208,14 @@
     "node": ">=22.0.0"
   },
   "dependencies": {
-    "@noy-db/attestation": "0.5.0"
+    "@noy-db/attestation": "0.6.0-pre.0"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",
     "esbuild": "^0.25.0",
     "zod": "^4.0.0",
     "zod-to-json-schema": "^3.25.2",
-    "@noy-db/on-shamir": "0.5.0"
+    "@noy-db/on-shamir": "0.6.0-pre.0"
   },
   "peerDependencies": {
     "zod-to-json-schema": "^3.25.0"

package/dist/api-M7REIE7H.js

@@ -1,20 +0,0 @@
-import {
-  UserApi,
-  createUserApi
-} from "./chunk-SL3PLML2.js";
-import "./chunk-6PFST3FC.js";
-import "./chunk-623QEHDB.js";
-import "./chunk-EFJAAFBW.js";
-import "./chunk-MYSNNMJ3.js";
-import "./chunk-L67H6FAQ.js";
-import "./chunk-GIGLOQL7.js";
-import "./chunk-LP7BEXCT.js";
-import "./chunk-RPWMDIGK.js";
-import "./chunk-77AEMXFA.js";
-import "./chunk-AR5D76T2.js";
-import "./chunk-PZ5AY32C.js";
-export {
-  UserApi,
-  createUserApi
-};
-//# sourceMappingURL=api-M7REIE7H.js.map

package/dist/backup-ENTZYW37.js.map

@@ -1 +0,0 @@
-{"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 type {\n  NoydbStore,\n  EncryptedEnvelope,\n  VaultBackup,\n  VaultSnapshot,\n  ExportStreamOptions,\n  ExportChunk,\n} from '../kernel/types.js'\nimport type { LedgerStore } from '../with-commit/history/ledger/store.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  /** 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 */\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 = [\n    LEDGER_COLLECTION, LEDGER_DELTAS_COLLECTION, SCHEMAS_COLLECTION, SEQUENCE_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    ...Object.keys(snapshot).flatMap((c) => [`_blob_slots_${c}`, `_blob_versions_${c}`]),\n  ]\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 */\nexport async function loadVault(ctx: BackupContext, backupJson: string): Promise<void> {\n  const backup = JSON.parse(backupJson) as VaultBackup\n\n  // 1. Restore data collections.\n  await ctx.adapter.saveAll(ctx.vault, backup.collections)\n\n  // 2. Restore keyrings.\n  for (const [userId, keyringFile] of Object.entries(backup.keyrings)) {\n    const envelope = {\n      _noydb: 1 as const,\n      _v: 1,\n      _ts: new Date().toISOString(),\n      _iv: '',\n      _data: JSON.stringify(keyringFile),\n    }\n    await ctx.adapter.put(ctx.vault, '_keyring', userId, envelope)\n  }\n\n  // 3. Restore internal collections (`_ledger`, `_ledger_deltas`).\n  //    Required so verifyBackupIntegrity has the chain to walk.\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  // 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  // 5. Run the verification gate. Legacy backups (no ledgerHead)\n  //    skip this with a one-line warning so existing consumers can\n  //    still read them while migrating.\n  if (!backup.ledgerHead) {\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    return\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}\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":[]}