@noy-db/hub 0.3.0-pre.9 → 0.4.0-pre.0

package/dist/port/with/write-hooks.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Hub-level write lifecycle hooks. `onBeforeWrite` may abort (throw);
+ * `onAfterWrite` is awaited and its errors are warned, not thrown. A
+ * re-entrancy flag suppresses nested firing so a handler that writes can't
+ * loop. Held on the Noydb instance, threaded into every Collection.
+ */
+export interface WriteEvent {
+    readonly op: 'create' | 'update' | 'delete';
+    readonly vault: string;
+    readonly collection: string;
+    readonly docId: string;
+    readonly before: unknown;
+    readonly after: unknown;
+    readonly baseVersion: number;
+    readonly version: number;
+    readonly userId: string;
+    readonly timestamp: number;
+    readonly txId: string;
+}
+export type WriteHook = (event: WriteEvent) => void | Promise<void>;
+export type Unsubscribe = () => void;
+export declare class WriteHookRegistry {
+    #private;
+    /** True while handlers are running — used by the write path to skip nested firing. */
+    get suppressed(): boolean;
+    /** True when any hook is registered (cheap gate for the write path). */
+    get hasHandlers(): boolean;
+    onBeforeWrite(handler: WriteHook): Unsubscribe;
+    onAfterWrite(handler: WriteHook): Unsubscribe;
+    /** Run before-hooks (awaited, in order). A throw propagates and aborts the write. */
+    runBefore(event: WriteEvent): Promise<void>;
+    /** Run after-hooks (awaited, in order). Per-handler errors are warned, not thrown. */
+    runAfter(event: WriteEvent): Promise<void>;
+}

package/dist/portability/index.js

@@ -1,36 +1,36 @@
 import {
   NO_PORTABILITY
-} from "../chunk-5TZZUL5X.js";
+} from "../chunk-M75ZZHSR.js";
 import {
   PortabilityNotEnabledError
-} from "../chunk-CU62BBRB.js";
+} from "../chunk-W2OG6JOL.js";
 import "../chunk-PZ5AY32C.js";
 
 // src/with-audit/portability/active.ts
 function withPortability() {
   return {
     async exportAccessibleData(vault, opts) {
-      const { exportAccessibleData } = await import("../export-accessible-O55RKAGC.js");
+      const { exportAccessibleData } = await import("../export-accessible-LKW3QV22.js");
       return exportAccessibleData(vault, opts);
     },
     async withdrawAccessibleData(vault, opts) {
-      const { withdrawAccessibleData } = await import("../withdraw-accessible-6J2UH3IN.js");
+      const { withdrawAccessibleData } = await import("../withdraw-accessible-TZDATQVR.js");
       return withdrawAccessibleData(vault, opts);
     },
     async requestWithdrawal(vault, opts) {
-      const { requestWithdrawal } = await import("../request-withdrawal-27O77D2V.js");
+      const { requestWithdrawal } = await import("../request-withdrawal-DI3H5WUI.js");
       return requestWithdrawal(vault, opts);
     },
     async listWithdrawalRequests(vault, opts) {
-      const { listWithdrawalRequests } = await import("../request-withdrawal-27O77D2V.js");
+      const { listWithdrawalRequests } = await import("../request-withdrawal-DI3H5WUI.js");
       return listWithdrawalRequests(vault, opts);
     },
     async approveWithdrawal(vault, requestId, opts) {
-      const { approveWithdrawal } = await import("../request-withdrawal-27O77D2V.js");
+      const { approveWithdrawal } = await import("../request-withdrawal-DI3H5WUI.js");
       return approveWithdrawal(vault, requestId, opts);
     },
     async rejectWithdrawal(vault, requestId, opts) {
-      const { rejectWithdrawal } = await import("../request-withdrawal-27O77D2V.js");
+      const { rejectWithdrawal } = await import("../request-withdrawal-DI3H5WUI.js");
       return rejectWithdrawal(vault, requestId, opts);
     }
   };

package/dist/post-register-2YHSADFI.js

@@ -0,0 +1,60 @@
+import {
+  hashFields
+} from "./chunk-2PCAVW2I.js";
+import {
+  SatelliteConfigError
+} from "./chunk-W2OG6JOL.js";
+import "./chunk-PZ5AY32C.js";
+
+// src/with-shape/satellites/marker.ts
+async function ensureSatelliteMarker(store, vaultName, spec, dek) {
+  const next = {
+    base: spec.base,
+    fieldsHash: hashFields(spec.fields),
+    joined: spec.joined,
+    epoch: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const { loadPersistedSchema } = await import("./storage-3MEJUENZ.js");
+  const persisted = await loadPersistedSchema(store, vaultName, spec.satellite, dek);
+  const prior = persisted?.satellite;
+  if (prior) {
+    if (prior.base !== next.base || prior.fieldsHash !== next.fieldsHash || (prior.joined ?? null) !== (next.joined ?? null)) {
+      throw new SatelliteConfigError(
+        `R-S9: satellite "${spec.satellite}" re-declared divergently from its persisted pairing marker (persisted base="${prior.base}" fieldsHash=${prior.fieldsHash}; declared base="${next.base}" fieldsHash=${next.fieldsHash}). Evolve the marker deliberately, don't redeclare.`
+      );
+    }
+    return;
+  }
+  const { persistSatelliteMarker } = await import("./register-PAM3ASRZ.js");
+  await persistSatelliteMarker({ store, vault: vaultName, collectionName: spec.satellite, dek, marker: next });
+}
+
+// src/with-shape/satellites/post-register.ts
+async function postRegister(store, vaultName, spec, getDEK, baseSchema, registry) {
+  try {
+    await ensureSatelliteMarker(store, vaultName, spec, await getDEK(spec.satellite));
+  } catch (err) {
+    registry.poison(spec.satellite, err.message);
+    return;
+  }
+  if (baseSchema !== void 0) {
+    try {
+      const { derivePersistedSchema } = await import("./derive-6RWU4EOA.js");
+      const envelope = await derivePersistedSchema(baseSchema);
+      const properties = envelope.jsonSchema?.["properties"];
+      const baseFields = Object.keys(properties ?? {});
+      const overlap = spec.fields.filter((f) => baseFields.includes(f));
+      if (overlap.length > 0) {
+        registry.poison(
+          spec.satellite,
+          `R-S1: satellite "${spec.satellite}" fields overlap the base schema: ${overlap.join(", ")} \u2014 routing must be unambiguous.`
+        );
+      }
+    } catch {
+    }
+  }
+}
+export {
+  postRegister
+};
+//# sourceMappingURL=post-register-2YHSADFI.js.map

package/dist/post-register-2YHSADFI.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/with-shape/satellites/marker.ts","../src/with-shape/satellites/post-register.ts"],"sourcesContent":["import type { NoydbStore } from '../../kernel/types.js'\nimport type { EnclaveKey } from '../../kernel/enclave/index.js'\nimport { SatelliteConfigError } from '../../kernel/errors.js'\nimport { hashFields } from './validate.js'\nimport type { PairingMarker, SatelliteSpec } from './types.js'\n\n/**\n * Persist-or-reconcile the pairing marker in `_schemas/<satellite>`.\n * First declaration writes { base, fieldsHash, joined }; later declarations\n * must match exactly or are refused (R-S9). Lazy imports keep the satellite\n * spine tree-shakeable (config-drift.ts pattern).\n */\nexport async function ensureSatelliteMarker(\n  store: NoydbStore, vaultName: string, spec: SatelliteSpec, dek: EnclaveKey,\n): Promise<void> {\n  // #597: `epoch` only matters the first time this marker is ever persisted —\n  // when a `prior` marker already exists below we return without ever using\n  // it, so re-declaring a LIVE collection never mints (or compares) a new\n  // epoch; the persisted one is carried forward untouched. Stamped here as a\n  // timestamp (mirrors `derivedAt` in persisted-schemas/register.ts) rather\n  // than a counter, since there's nothing to count from yet.\n  const next: PairingMarker = {\n    base: spec.base, fieldsHash: hashFields(spec.fields), joined: spec.joined,\n    epoch: new Date().toISOString(),\n  }\n  const { loadPersistedSchema } = await import('../persisted-schemas/storage.js')\n  const persisted = await loadPersistedSchema(store, vaultName, spec.satellite, dek)\n  const prior = persisted?.satellite\n  if (prior) {\n    if (prior.base !== next.base || prior.fieldsHash !== next.fieldsHash || (prior.joined ?? null) !== (next.joined ?? null)) {\n      throw new SatelliteConfigError(\n        `R-S9: satellite \"${spec.satellite}\" re-declared divergently from its persisted pairing marker ` +\n        `(persisted base=\"${prior.base}\" fieldsHash=${prior.fieldsHash}; declared base=\"${next.base}\" fieldsHash=${next.fieldsHash}). ` +\n        `Evolve the marker deliberately, don't redeclare.`,\n      )\n    }\n    return\n  }\n  const { persistSatelliteMarker } = await import('../persisted-schemas/register.js')\n  await persistSatelliteMarker({ store, vault: vaultName, collectionName: spec.satellite, dek, marker: next })\n}\n","import type { NoydbStore } from '../../kernel/types.js'\nimport type { EnclaveKey } from '../../kernel/enclave/index.js'\nimport type { SatelliteSpec } from './types.js'\nimport type { SatelliteRegistry } from './registry.js'\nimport { ensureSatelliteMarker } from './marker.js'\n\n/** Async post-registration: R-S9 marker reconcile + R-S1/R-S5 derivable-schema cross-check. Failures poison, never throw. */\nexport async function postRegister(\n  store: NoydbStore, vaultName: string, spec: SatelliteSpec,\n  getDEK: (collectionName: string) => Promise<EnclaveKey>,\n  baseSchema: unknown, registry: SatelliteRegistry,\n): Promise<void> {\n  try {\n    await ensureSatelliteMarker(store, vaultName, spec, await getDEK(spec.satellite))\n  } catch (err) {\n    registry.poison(spec.satellite, (err as Error).message); return\n  }\n  if (baseSchema !== undefined) {\n    try {\n      const { derivePersistedSchema } = await import('../persisted-schemas/derive.js')\n      const envelope = await derivePersistedSchema(baseSchema)\n      const properties = (envelope.jsonSchema as Record<string, unknown> | null)?.['properties'] as Record<string, unknown> | undefined\n      const baseFields: string[] = Object.keys(properties ?? {})\n      const overlap = spec.fields.filter(f => baseFields.includes(f))\n      if (overlap.length > 0) {\n        registry.poison(spec.satellite,\n          `R-S1: satellite \"${spec.satellite}\" fields overlap the base schema: ${overlap.join(', ')} — routing must be unambiguous.`)\n      }\n    } catch { /* non-derivable validator → cross-check unavailable, by design (spec R-S5) */ }\n  }\n}\n"],"mappings":";;;;;;;;;AAYA,eAAsB,sBACpB,OAAmB,WAAmB,MAAqB,KAC5C;AAOf,QAAM,OAAsB;AAAA,IAC1B,MAAM,KAAK;AAAA,IAAM,YAAY,WAAW,KAAK,MAAM;AAAA,IAAG,QAAQ,KAAK;AAAA,IACnE,QAAO,oBAAI,KAAK,GAAE,YAAY;AAAA,EAChC;AACA,QAAM,EAAE,oBAAoB,IAAI,MAAM,OAAO,uBAAiC;AAC9E,QAAM,YAAY,MAAM,oBAAoB,OAAO,WAAW,KAAK,WAAW,GAAG;AACjF,QAAM,QAAQ,WAAW;AACzB,MAAI,OAAO;AACT,QAAI,MAAM,SAAS,KAAK,QAAQ,MAAM,eAAe,KAAK,eAAe,MAAM,UAAU,WAAW,KAAK,UAAU,OAAO;AACxH,YAAM,IAAI;AAAA,QACR,oBAAoB,KAAK,SAAS,gFACd,MAAM,IAAI,gBAAgB,MAAM,UAAU,oBAAoB,KAAK,IAAI,gBAAgB,KAAK,UAAU;AAAA,MAE5H;AAAA,IACF;AACA;AAAA,EACF;AACA,QAAM,EAAE,uBAAuB,IAAI,MAAM,OAAO,wBAAkC;AAClF,QAAM,uBAAuB,EAAE,OAAO,OAAO,WAAW,gBAAgB,KAAK,WAAW,KAAK,QAAQ,KAAK,CAAC;AAC7G;;;ACjCA,eAAsB,aACpB,OAAmB,WAAmB,MACtC,QACA,YAAqB,UACN;AACf,MAAI;AACF,UAAM,sBAAsB,OAAO,WAAW,MAAM,MAAM,OAAO,KAAK,SAAS,CAAC;AAAA,EAClF,SAAS,KAAK;AACZ,aAAS,OAAO,KAAK,WAAY,IAAc,OAAO;AAAG;AAAA,EAC3D;AACA,MAAI,eAAe,QAAW;AAC5B,QAAI;AACF,YAAM,EAAE,sBAAsB,IAAI,MAAM,OAAO,sBAAgC;AAC/E,YAAM,WAAW,MAAM,sBAAsB,UAAU;AACvD,YAAM,aAAc,SAAS,aAAgD,YAAY;AACzF,YAAM,aAAuB,OAAO,KAAK,cAAc,CAAC,CAAC;AACzD,YAAM,UAAU,KAAK,OAAO,OAAO,OAAK,WAAW,SAAS,CAAC,CAAC;AAC9D,UAAI,QAAQ,SAAS,GAAG;AACtB,iBAAS;AAAA,UAAO,KAAK;AAAA,UACnB,oBAAoB,KAAK,SAAS,qCAAqC,QAAQ,KAAK,IAAI,CAAC;AAAA,QAAiC;AAAA,MAC9H;AAAA,IACF,QAAQ;AAAA,IAAiF;AAAA,EAC3F;AACF;","names":[]}

package/dist/purge-scope-FGNNLWHD.js

@@ -0,0 +1,24 @@
+import "./chunk-PZ5AY32C.js";
+
+// src/with-audit/forget/purge-scope.ts
+function partitionSealedCekKeys(keys, prefix, scopedPurge, declared) {
+  const matches = keys.filter((key) => key.startsWith(prefix));
+  if (!scopedPurge || declared) return { toPurge: matches, skippedCount: 0 };
+  return { toPurge: [], skippedCount: matches.length };
+}
+function shouldSkipBlobScan(scopedPurge, declared) {
+  return scopedPurge && !declared;
+}
+function bumpResidueCount(map, collection, count) {
+  if (count > 0) map.set(collection, (map.get(collection) ?? 0) + count);
+}
+function residueNoticesFromMap(map, reason) {
+  return [...map].map(([collection, count]) => ({ reason, collection, count }));
+}
+export {
+  bumpResidueCount,
+  partitionSealedCekKeys,
+  residueNoticesFromMap,
+  shouldSkipBlobScan
+};
+//# sourceMappingURL=purge-scope-FGNNLWHD.js.map

package/dist/purge-scope-FGNNLWHD.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/with-audit/forget/purge-scope.ts"],"sourcesContent":["/**\n * #633 — scoped-purge partitioning for the opt-in `scopedPurge` forget-strategy\n * knob (`strategy.ts`'s `SubjectDeclaration.scopedPurge`). Pure helpers only —\n * no store I/O, no `Vault`/`Collection` imports — kept out of `kernel/vault.ts`\n * (exact zero-slack `kernel-surface` ceiling) and free of any circular-import\n * risk with the kernel spine.\n *\n * The two `forget()` purge sites (`_sealed_cek` listing, blob shred) stay\n * UNCONDITIONAL by default (byte-identical to pre-#633 behavior); when\n * `scopedPurge` is `true`, each site calls into this module to decide what to\n * purge vs. what to leave in place + report as residue, keyed off a\n * per-collection declaration signal the caller (vault.ts) resolves itself:\n *   - sealed-CEK arm: `coll._via?.hasAtRestHooks === true` — the classified\n *     via binding's at-rest hooks (the \"richer\" declaration; a bare\n *     `sensitive` collection with NO classified binder does not count — it can\n *     still call `sealRecordToHost()` ad hoc, which is exactly the\n *     under-approximation #633 calls out).\n *   - blob arm: `this.blobFieldsRegistry.has(ref.collection)` — a collection\n *     can call `.blob(id)` regardless of this declaration (same\n *     under-approximation), which is why the default stays unconditional.\n *\n * @module\n */\nimport type { ScopedPurgeResidueReason } from './strategy.js'\n\n/**\n * Partitions an already-fetched vault-wide `_sealed_cek` key listing into\n * keys to purge vs. a skipped count, for ONE ref's `<collection>/<id>/`\n * prefix. No new store call — `keys` is the SAME listing the unconditional\n * path already fetched. Default parity: when `scopedPurge` is false, or\n * `declared` is true, every matching key is returned for purge and\n * `skippedCount` is 0 — byte-identical to the unconditional behavior.\n */\nexport function partitionSealedCekKeys(\n  keys: readonly string[],\n  prefix: string,\n  scopedPurge: boolean,\n  declared: boolean,\n): { readonly toPurge: readonly string[]; readonly skippedCount: number } {\n  const matches = keys.filter((key) => key.startsWith(prefix))\n  if (!scopedPurge || declared) return { toPurge: matches, skippedCount: 0 }\n  return { toPurge: [], skippedCount: matches.length }\n}\n\n/**\n * True when the blob arm should skip `ref.collection` entirely — no\n * `.blob(id).shredAllForRecord()` call AND no `_blob_slots_<collection>`\n * residue-detection `list()` call either (the perf win: scoped mode never\n * pays for a per-collection scan on a collection that never declared\n * `blobFields`).\n */\nexport function shouldSkipBlobScan(scopedPurge: boolean, declared: boolean): boolean {\n  return scopedPurge && !declared\n}\n\n/** Adds `count` (if positive) to `collection`'s running total in `map` — the\n *  per-collection residue accumulator both purge sites share. */\nexport function bumpResidueCount(map: Map<string, number>, collection: string, count: number): void {\n  if (count > 0) map.set(collection, (map.get(collection) ?? 0) + count)\n}\n\n/** Flattens an accumulated per-collection count map into `ForgetResult.scopedPurgeResidue` notices\n *  tagged with `reason`. Empty map → empty array (the unconditional-default case). */\nexport function residueNoticesFromMap(\n  map: ReadonlyMap<string, number>,\n  reason: ScopedPurgeResidueReason,\n): { readonly reason: ScopedPurgeResidueReason; readonly collection: string; readonly count: number }[] {\n  return [...map].map(([collection, count]) => ({ reason, collection, count }))\n}\n"],"mappings":";;;AAiCO,SAAS,uBACd,MACA,QACA,aACA,UACwE;AACxE,QAAM,UAAU,KAAK,OAAO,CAAC,QAAQ,IAAI,WAAW,MAAM,CAAC;AAC3D,MAAI,CAAC,eAAe,SAAU,QAAO,EAAE,SAAS,SAAS,cAAc,EAAE;AACzE,SAAO,EAAE,SAAS,CAAC,GAAG,cAAc,QAAQ,OAAO;AACrD;AASO,SAAS,mBAAmB,aAAsB,UAA4B;AACnF,SAAO,eAAe,CAAC;AACzB;AAIO,SAAS,iBAAiB,KAA0B,YAAoB,OAAqB;AAClG,MAAI,QAAQ,EAAG,KAAI,IAAI,aAAa,IAAI,IAAI,UAAU,KAAK,KAAK,KAAK;AACvE;AAIO,SAAS,sBACd,KACA,QACsG;AACtG,SAAO,CAAC,GAAG,GAAG,EAAE,IAAI,CAAC,CAAC,YAAY,KAAK,OAAO,EAAE,QAAQ,YAAY,MAAM,EAAE;AAC9E;","names":[]}

package/dist/query/index.js

@@ -1,16 +1,18 @@
 import {
   DEFAULT_CROSS_JOIN_MAX_ROWS,
-  DEFAULT_JOIN_MAX_ROWS,
   Query,
   ScanBuilder,
-  applyJoins,
   buildLiveQuery,
-  executePlan,
+  executePlan
+} from "../chunk-A5BDDEXK.js";
+import {
+  DEFAULT_JOIN_MAX_ROWS,
+  applyJoins,
   resetJoinWarnings
-} from "../chunk-7HAPHVRJ.js";
+} from "../chunk-RA5VTXXG.js";
 import {
   CollectionIndexes
-} from "../chunk-5GAX2QOH.js";
+} from "../chunk-KPZS5QAQ.js";
 import {
   Aggregation,
   GROUPBY_MAX_CARDINALITY,
@@ -31,14 +33,14 @@ import {
   reducerBuilder,
   resetGroupByWarnings,
   sum
-} from "../chunk-2XE6LIXT.js";
+} from "../chunk-TAGR72IR.js";
 import {
   evaluateClause,
   evaluateFieldClause,
   readPath
-} from "../chunk-KCG3BHFG.js";
-import "../chunk-3C5CKXFI.js";
-import "../chunk-6G2SCQYS.js";
+} from "../chunk-IGJCYUT5.js";
+import "../chunk-GULTLPFB.js";
+import "../chunk-JVBO4SZL.js";
 import {
   CrossJoinSourceUnknownError,
   CrossJoinTooLargeError,
@@ -48,7 +50,7 @@ import {
   IndexRequiredError,
   IndexWriteFailureError,
   JoinTooLargeError
-} from "../chunk-CU62BBRB.js";
+} from "../chunk-W2OG6JOL.js";
 import "../chunk-PZ5AY32C.js";
 export {
   Aggregation,

package/dist/read-only-facade-CHCKSEPD.js

@@ -0,0 +1,8 @@
+import {
+  ReadOnlyVaultFacade
+} from "./chunk-JK733I5V.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  ReadOnlyVaultFacade
+};
+//# sourceMappingURL=read-only-facade-CHCKSEPD.js.map

package/dist/register-PAM3ASRZ.js

@@ -0,0 +1,23 @@
+import {
+  persistClassifiedMarker,
+  persistSatelliteMarker,
+  persistSchemaIfNeeded
+} from "./chunk-GDG5VVYG.js";
+import "./chunk-BOKIKJJB.js";
+import "./chunk-CJ5KKU6X.js";
+import "./chunk-W4TCUGQR.js";
+import "./chunk-A4FXFAKF.js";
+import "./chunk-IY23KFNZ.js";
+import "./chunk-N6WF5PKC.js";
+import "./chunk-6HY2X62D.js";
+import "./chunk-LP7BEXCT.js";
+import "./chunk-HOONYZY2.js";
+import "./chunk-VCTXU4AT.js";
+import "./chunk-W2OG6JOL.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  persistClassifiedMarker,
+  persistSatelliteMarker,
+  persistSchemaIfNeeded
+};
+//# sourceMappingURL=register-PAM3ASRZ.js.map

package/dist/registry-4S2U2TR4.js

@@ -0,0 +1,19 @@
+import {
+  MaterializedViewRegistry,
+  wrapDbWithPredicates
+} from "./chunk-S3BFKGET.js";
+import "./chunk-W4TCUGQR.js";
+import "./chunk-A4FXFAKF.js";
+import "./chunk-IY23KFNZ.js";
+import "./chunk-N6WF5PKC.js";
+import "./chunk-6HY2X62D.js";
+import "./chunk-LP7BEXCT.js";
+import "./chunk-HOONYZY2.js";
+import "./chunk-VCTXU4AT.js";
+import "./chunk-W2OG6JOL.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  MaterializedViewRegistry,
+  wrapDbWithPredicates
+};
+//# sourceMappingURL=registry-4S2U2TR4.js.map

package/dist/registry-NPOWJHC4.js

@@ -0,0 +1,9 @@
+import {
+  OverlayedViewRegistry
+} from "./chunk-GWKAVKHI.js";
+import "./chunk-W2OG6JOL.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  OverlayedViewRegistry
+};
+//# sourceMappingURL=registry-NPOWJHC4.js.map

package/dist/registry-VZ3CCI2R.js

@@ -0,0 +1,18 @@
+import {
+  DerivationRegistry
+} from "./chunk-DDHM2TLX.js";
+import "./chunk-3ELCWU56.js";
+import "./chunk-W4TCUGQR.js";
+import "./chunk-A4FXFAKF.js";
+import "./chunk-IY23KFNZ.js";
+import "./chunk-N6WF5PKC.js";
+import "./chunk-6HY2X62D.js";
+import "./chunk-LP7BEXCT.js";
+import "./chunk-HOONYZY2.js";
+import "./chunk-VCTXU4AT.js";
+import "./chunk-W2OG6JOL.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  DerivationRegistry
+};
+//# sourceMappingURL=registry-VZ3CCI2R.js.map

package/dist/request-withdrawal-DI3H5WUI.js

@@ -0,0 +1,31 @@
+import {
+  WITHDRAWAL_REQUESTS_COLLECTION,
+  WithdrawalRequestError,
+  approveWithdrawal,
+  listWithdrawalRequests,
+  rejectWithdrawal,
+  requestWithdrawal
+} from "./chunk-H2KSZMIX.js";
+import "./chunk-JFCV5QIK.js";
+import "./chunk-WKGF2TJR.js";
+import "./chunk-FXZDAV62.js";
+import "./chunk-XUW3PXHU.js";
+import "./chunk-W4TCUGQR.js";
+import "./chunk-A4FXFAKF.js";
+import "./chunk-IY23KFNZ.js";
+import "./chunk-N6WF5PKC.js";
+import "./chunk-6HY2X62D.js";
+import "./chunk-LP7BEXCT.js";
+import "./chunk-HOONYZY2.js";
+import "./chunk-VCTXU4AT.js";
+import "./chunk-W2OG6JOL.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  WITHDRAWAL_REQUESTS_COLLECTION,
+  WithdrawalRequestError,
+  approveWithdrawal,
+  listWithdrawalRequests,
+  rejectWithdrawal,
+  requestWithdrawal
+};
+//# sourceMappingURL=request-withdrawal-DI3H5WUI.js.map

package/dist/reveal-HWO4YMTJ.js

@@ -0,0 +1,38 @@
+import {
+  isTombstone
+} from "./chunk-A4FXFAKF.js";
+import {
+  dualReadSealedSlot
+} from "./chunk-N6WF5PKC.js";
+import "./chunk-HOONYZY2.js";
+import "./chunk-VCTXU4AT.js";
+import {
+  ClassifiedRevealError
+} from "./chunk-W2OG6JOL.js";
+import "./chunk-PZ5AY32C.js";
+
+// src/kernel/enclave/classify/reveal.ts
+async function revealSealedField(ctx, id, field) {
+  const env = await ctx.getEnvelope(id);
+  if (env === null || isTombstone(env, ctx.encrypted) || (env._tier ?? 0) > 0) {
+    throw new ClassifiedRevealError(ctx.collection, field, `record "${id}" not found in "${ctx.collection}"`);
+  }
+  if (!ctx.encrypted) {
+    const record = JSON.parse(env._data || "{}");
+    if (!(field in record)) {
+      throw new ClassifiedRevealError(ctx.collection, field, `no stored value for "${field}"`);
+    }
+    return record[field];
+  }
+  const blob = env._sealed?.[field];
+  if (blob === void 0) {
+    throw new ClassifiedRevealError(ctx.collection, field, `no sealed value stored for "${field}"`);
+  }
+  const cek = await ctx.resolveCek(env);
+  const dek = await ctx.getDEK();
+  return JSON.parse(await dualReadSealedSlot(blob, field, ctx.collection, cek, dek));
+}
+export {
+  revealSealedField
+};
+//# sourceMappingURL=reveal-HWO4YMTJ.js.map

package/dist/reveal-HWO4YMTJ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/kernel/enclave/classify/reveal.ts"],"sourcesContent":["/**\n * Single-point audited reveal, stage-2 rework (I6): decrypt ONE sealed slot\n * from the raw envelope — no full record view, no collection.get(), so no\n * spurious 'get' consent entry. Fail-closed gates (b)/(c) live here; gate\n * (a) (storage:'never') fires in collection.reveal before any strategy call.\n * @module\n */\nimport { dualReadSealedSlot } from '../record-keys/sealed-slot.js'\nimport { isTombstone } from '../record-keys/tombstone.js'\nimport { ClassifiedRevealError } from '../../errors.js'\nimport type { EncryptedEnvelope } from '../../types.js'\nimport type { EnclaveKey } from '../crypto.js'\n\nexport interface RevealEngineCtx {\n  readonly collection: string\n  readonly encrypted: boolean\n  getEnvelope(id: string): Promise<EncryptedEnvelope | null>\n  resolveCek(env: EncryptedEnvelope): Promise<EnclaveKey | undefined>\n  getDEK(): Promise<EnclaveKey>\n}\n\nexport async function revealSealedField(ctx: RevealEngineCtx, id: string, field: string): Promise<unknown> {\n  const env = await ctx.getEnvelope(id)\n  if (env === null || isTombstone(env, ctx.encrypted) || (env._tier ?? 0) > 0) {\n    throw new ClassifiedRevealError(ctx.collection, field, `record \"${id}\" not found in \"${ctx.collection}\"`)\n  }\n  if (!ctx.encrypted) {\n    // Plaintext collection: nothing is sealed; the value sits in the open body.\n    const record = JSON.parse(env._data || '{}') as Record<string, unknown>\n    if (!(field in record)) {\n      throw new ClassifiedRevealError(ctx.collection, field, `no stored value for \"${field}\"`)\n    }\n    return record[field]\n  }\n  const blob = env._sealed?.[field]\n  if (blob === undefined) {\n    // Gate (c): fail-closed error, never parseSealedSlot(undefined)'s TypeError.\n    throw new ClassifiedRevealError(ctx.collection, field, `no sealed value stored for \"${field}\"`)\n  }\n  const cek = await ctx.resolveCek(env)\n  const dek = await ctx.getDEK()\n  return JSON.parse(await dualReadSealedSlot(blob, field, ctx.collection, cek, dek))\n}\n"],"mappings":";;;;;;;;;;;;;;AAqBA,eAAsB,kBAAkB,KAAsB,IAAY,OAAiC;AACzG,QAAM,MAAM,MAAM,IAAI,YAAY,EAAE;AACpC,MAAI,QAAQ,QAAQ,YAAY,KAAK,IAAI,SAAS,MAAM,IAAI,SAAS,KAAK,GAAG;AAC3E,UAAM,IAAI,sBAAsB,IAAI,YAAY,OAAO,WAAW,EAAE,mBAAmB,IAAI,UAAU,GAAG;AAAA,EAC1G;AACA,MAAI,CAAC,IAAI,WAAW;AAElB,UAAM,SAAS,KAAK,MAAM,IAAI,SAAS,IAAI;AAC3C,QAAI,EAAE,SAAS,SAAS;AACtB,YAAM,IAAI,sBAAsB,IAAI,YAAY,OAAO,wBAAwB,KAAK,GAAG;AAAA,IACzF;AACA,WAAO,OAAO,KAAK;AAAA,EACrB;AACA,QAAM,OAAO,IAAI,UAAU,KAAK;AAChC,MAAI,SAAS,QAAW;AAEtB,UAAM,IAAI,sBAAsB,IAAI,YAAY,OAAO,+BAA+B,KAAK,GAAG;AAAA,EAChG;AACA,QAAM,MAAM,MAAM,IAAI,WAAW,GAAG;AACpC,QAAM,MAAM,MAAM,IAAI,OAAO;AAC7B,SAAO,KAAK,MAAM,MAAM,mBAAmB,MAAM,OAAO,IAAI,YAAY,KAAK,GAAG,CAAC;AACnF;","names":[]}

package/dist/revoke-R5CZSVUT.js

@@ -0,0 +1,24 @@
+import {
+  getRevokedDocIdsCore,
+  publishRevocationListCore,
+  revokeDocCore,
+  unrevokeDocCore
+} from "./chunk-ZXEZCY6F.js";
+import "./chunk-WOM2HTML.js";
+import "./chunk-W4TCUGQR.js";
+import "./chunk-A4FXFAKF.js";
+import "./chunk-IY23KFNZ.js";
+import "./chunk-N6WF5PKC.js";
+import "./chunk-6HY2X62D.js";
+import "./chunk-LP7BEXCT.js";
+import "./chunk-HOONYZY2.js";
+import "./chunk-VCTXU4AT.js";
+import "./chunk-W2OG6JOL.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  getRevokedDocIdsCore,
+  publishRevocationListCore,
+  revokeDocCore,
+  unrevokeDocCore
+};
+//# sourceMappingURL=revoke-R5CZSVUT.js.map

package/dist/satellites/index.js

@@ -1,6 +1,6 @@
 import {
   SatelliteConfigError
-} from "../chunk-CU62BBRB.js";
+} from "../chunk-W2OG6JOL.js";
 import "../chunk-PZ5AY32C.js";
 export {
   SatelliteConfigError

package/dist/sealed-record/index.js

@@ -1,38 +1,38 @@
 import {
   NO_SEALED_RECORD
-} from "../chunk-2HVUKRNE.js";
-import "../chunk-XHD3L3JO.js";
-import "../chunk-Z5YFRMG5.js";
-import "../chunk-XQ7UYPVN.js";
-import "../chunk-6MWUANRF.js";
-import "../chunk-2KOSJTMU.js";
+} from "../chunk-RDXW3OBQ.js";
+import "../chunk-W4TCUGQR.js";
+import "../chunk-A4FXFAKF.js";
+import "../chunk-IY23KFNZ.js";
+import "../chunk-N6WF5PKC.js";
+import "../chunk-6HY2X62D.js";
 import "../chunk-LP7BEXCT.js";
 import {
   base64ToBuffer,
   decrypt,
   importCek
-} from "../chunk-AUR7MRHA.js";
-import "../chunk-UNJU345Q.js";
+} from "../chunk-HOONYZY2.js";
+import "../chunk-VCTXU4AT.js";
 import {
   SealedRecordExpiredError,
   SealedRecordMismatchError,
   SealedRecordNotEnabledError
-} from "../chunk-CU62BBRB.js";
+} from "../chunk-W2OG6JOL.js";
 import "../chunk-PZ5AY32C.js";
 
 // src/with-audit/sealed-record/active.ts
 function withSealedRecord() {
   return {
     async sealRecordToHost(ctx, collection, id, hostSealer, opts) {
-      const { sealRecordToHost } = await import("../enclave-EUBEJGPG.js");
+      const { sealRecordToHost } = await import("../enclave-TKPN2G2U.js");
       return sealRecordToHost(ctx, collection, id, hostSealer, opts);
     },
     async revokeSealedRecord(ctx, collection, id, pid, opts) {
-      const { revokeSealedRecord } = await import("../enclave-EUBEJGPG.js");
+      const { revokeSealedRecord } = await import("../enclave-TKPN2G2U.js");
       return revokeSealedRecord(ctx, collection, id, pid, opts);
     },
     async rotateRecordCek(ctx, collection, id) {
-      const { rotateRecordCek } = await import("../enclave-EUBEJGPG.js");
+      const { rotateRecordCek } = await import("../enclave-TKPN2G2U.js");
       return rotateRecordCek(ctx, collection, id);
     }
   };