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

package/dist/post-register-JTH76BLY.js

@@ -0,0 +1,60 @@
+import {
+  hashFields
+} from "./chunk-ZAJAVEXY.js";
+import {
+  SatelliteConfigError
+} from "./chunk-BIOUI4HL.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-MVFCGEQE.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-VAHONCID.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-H2BJTLUI.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-JTH76BLY.js.map

package/dist/post-register-JTH76BLY.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/public-envelope-B4KNWVUA.js

@@ -0,0 +1,32 @@
+import {
+  DEFAULT_PUBLIC_ENVELOPE_SCHEMA,
+  PUBLIC_ENVELOPE_FIELDS,
+  resolveSchema
+} from "./chunk-WXSYDNBT.js";
+import {
+  PUBLIC_ENVELOPE_RECORD_ID,
+  isPublicEnvelope,
+  loadPublicEnvelope,
+  pickLocale,
+  readPublicEnvelope,
+  resolveLocale,
+  savePublicEnvelope,
+  validatePublicEnvelopeInput
+} from "./chunk-X3YYQWOQ.js";
+import "./chunk-JNAI2HN2.js";
+import "./chunk-BIOUI4HL.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  DEFAULT_PUBLIC_ENVELOPE_SCHEMA,
+  PUBLIC_ENVELOPE_FIELDS,
+  PUBLIC_ENVELOPE_RECORD_ID,
+  isPublicEnvelope,
+  loadPublicEnvelope,
+  pickLocale,
+  readPublicEnvelope,
+  resolveLocale,
+  resolveSchema,
+  savePublicEnvelope,
+  validatePublicEnvelopeInput
+};
+//# sourceMappingURL=public-envelope-B4KNWVUA.js.map

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

@@ -7,10 +7,10 @@ import {
   buildLiveQuery,
   executePlan,
   resetJoinWarnings
-} from "../chunk-7HAPHVRJ.js";
+} from "../chunk-454JXE57.js";
 import {
   CollectionIndexes
-} from "../chunk-5GAX2QOH.js";
+} from "../chunk-KPZS5QAQ.js";
 import {
   Aggregation,
   GROUPBY_MAX_CARDINALITY,
@@ -31,14 +31,14 @@ import {
   reducerBuilder,
   resetGroupByWarnings,
   sum
-} from "../chunk-2XE6LIXT.js";
+} from "../chunk-LXEXBTKL.js";
 import {
   evaluateClause,
   evaluateFieldClause,
   readPath
-} from "../chunk-KCG3BHFG.js";
-import "../chunk-3C5CKXFI.js";
-import "../chunk-6G2SCQYS.js";
+} from "../chunk-IGJCYUT5.js";
+import "../chunk-6JTIAGHD.js";
+import "../chunk-4VNQOLML.js";
 import {
   CrossJoinSourceUnknownError,
   CrossJoinTooLargeError,
@@ -48,7 +48,7 @@ import {
   IndexRequiredError,
   IndexWriteFailureError,
   JoinTooLargeError
-} from "../chunk-CU62BBRB.js";
+} from "../chunk-BIOUI4HL.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-VAHONCID.js

@@ -0,0 +1,23 @@
+import {
+  persistClassifiedMarker,
+  persistSatelliteMarker,
+  persistSchemaIfNeeded
+} from "./chunk-2NVOWNI3.js";
+import "./chunk-W22IKJE2.js";
+import "./chunk-VZRODIM3.js";
+import "./chunk-XDYREZWE.js";
+import "./chunk-7DSTRQIJ.js";
+import "./chunk-HB3RFQSC.js";
+import "./chunk-JKJOGPZN.js";
+import "./chunk-5M5DVGV7.js";
+import "./chunk-LP7BEXCT.js";
+import "./chunk-CIE2BASH.js";
+import "./chunk-JNAI2HN2.js";
+import "./chunk-BIOUI4HL.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  persistClassifiedMarker,
+  persistSatelliteMarker,
+  persistSchemaIfNeeded
+};
+//# sourceMappingURL=register-VAHONCID.js.map

package/dist/registry-7MLVD3VO.js

@@ -0,0 +1,19 @@
+import {
+  MaterializedViewRegistry,
+  wrapDbWithPredicates
+} from "./chunk-KSKBRKGJ.js";
+import "./chunk-XDYREZWE.js";
+import "./chunk-7DSTRQIJ.js";
+import "./chunk-HB3RFQSC.js";
+import "./chunk-JKJOGPZN.js";
+import "./chunk-5M5DVGV7.js";
+import "./chunk-LP7BEXCT.js";
+import "./chunk-CIE2BASH.js";
+import "./chunk-JNAI2HN2.js";
+import "./chunk-BIOUI4HL.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  MaterializedViewRegistry,
+  wrapDbWithPredicates
+};
+//# sourceMappingURL=registry-7MLVD3VO.js.map

package/dist/registry-EPKPD5SM.js

@@ -0,0 +1,18 @@
+import {
+  DerivationRegistry
+} from "./chunk-RCVJZMFE.js";
+import "./chunk-HTJQYHZP.js";
+import "./chunk-XDYREZWE.js";
+import "./chunk-7DSTRQIJ.js";
+import "./chunk-HB3RFQSC.js";
+import "./chunk-JKJOGPZN.js";
+import "./chunk-5M5DVGV7.js";
+import "./chunk-LP7BEXCT.js";
+import "./chunk-CIE2BASH.js";
+import "./chunk-JNAI2HN2.js";
+import "./chunk-BIOUI4HL.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  DerivationRegistry
+};
+//# sourceMappingURL=registry-EPKPD5SM.js.map

package/dist/registry-P5T7PS2U.js

@@ -0,0 +1,9 @@
+import {
+  OverlayedViewRegistry
+} from "./chunk-3B5VVCNY.js";
+import "./chunk-BIOUI4HL.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  OverlayedViewRegistry
+};
+//# sourceMappingURL=registry-P5T7PS2U.js.map

package/dist/request-withdrawal-TI3A5WPS.js

@@ -0,0 +1,31 @@
+import {
+  WITHDRAWAL_REQUESTS_COLLECTION,
+  WithdrawalRequestError,
+  approveWithdrawal,
+  listWithdrawalRequests,
+  rejectWithdrawal,
+  requestWithdrawal
+} from "./chunk-BDVFPG6Y.js";
+import "./chunk-IU6SNYX6.js";
+import "./chunk-F64IRYG3.js";
+import "./chunk-FHS2HQSH.js";
+import "./chunk-X3YYQWOQ.js";
+import "./chunk-XDYREZWE.js";
+import "./chunk-7DSTRQIJ.js";
+import "./chunk-HB3RFQSC.js";
+import "./chunk-JKJOGPZN.js";
+import "./chunk-5M5DVGV7.js";
+import "./chunk-LP7BEXCT.js";
+import "./chunk-CIE2BASH.js";
+import "./chunk-JNAI2HN2.js";
+import "./chunk-BIOUI4HL.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  WITHDRAWAL_REQUESTS_COLLECTION,
+  WithdrawalRequestError,
+  approveWithdrawal,
+  listWithdrawalRequests,
+  rejectWithdrawal,
+  requestWithdrawal
+};
+//# sourceMappingURL=request-withdrawal-TI3A5WPS.js.map

package/dist/reveal-DIBHLUZX.js

@@ -0,0 +1,38 @@
+import {
+  isTombstone
+} from "./chunk-7DSTRQIJ.js";
+import {
+  dualReadSealedSlot
+} from "./chunk-JKJOGPZN.js";
+import "./chunk-CIE2BASH.js";
+import "./chunk-JNAI2HN2.js";
+import {
+  ClassifiedRevealError
+} from "./chunk-BIOUI4HL.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-DIBHLUZX.js.map

package/dist/reveal-DIBHLUZX.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-FDRD6GRW.js

@@ -0,0 +1,24 @@
+import {
+  getRevokedDocIdsCore,
+  publishRevocationListCore,
+  revokeDocCore,
+  unrevokeDocCore
+} from "./chunk-YFXZEAYK.js";
+import "./chunk-EXK7QRWF.js";
+import "./chunk-XDYREZWE.js";
+import "./chunk-7DSTRQIJ.js";
+import "./chunk-HB3RFQSC.js";
+import "./chunk-JKJOGPZN.js";
+import "./chunk-5M5DVGV7.js";
+import "./chunk-LP7BEXCT.js";
+import "./chunk-CIE2BASH.js";
+import "./chunk-JNAI2HN2.js";
+import "./chunk-BIOUI4HL.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  getRevokedDocIdsCore,
+  publishRevocationListCore,
+  revokeDocCore,
+  unrevokeDocCore
+};
+//# sourceMappingURL=revoke-FDRD6GRW.js.map

package/dist/satellites/index.js

@@ -1,6 +1,6 @@
 import {
   SatelliteConfigError
-} from "../chunk-CU62BBRB.js";
+} from "../chunk-BIOUI4HL.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-QLWMEXCT.js";
+import "../chunk-XDYREZWE.js";
+import "../chunk-7DSTRQIJ.js";
+import "../chunk-HB3RFQSC.js";
+import "../chunk-JKJOGPZN.js";
+import "../chunk-5M5DVGV7.js";
 import "../chunk-LP7BEXCT.js";
 import {
   base64ToBuffer,
   decrypt,
   importCek
-} from "../chunk-AUR7MRHA.js";
-import "../chunk-UNJU345Q.js";
+} from "../chunk-CIE2BASH.js";
+import "../chunk-JNAI2HN2.js";
 import {
   SealedRecordExpiredError,
   SealedRecordMismatchError,
   SealedRecordNotEnabledError
-} from "../chunk-CU62BBRB.js";
+} from "../chunk-BIOUI4HL.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-AP3I5W7O.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-AP3I5W7O.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-AP3I5W7O.js");
       return rotateRecordCek(ctx, collection, id);
     }
   };

package/dist/seed-Q6M2IZFL.js

@@ -0,0 +1,231 @@
+import {
+  BROKER_COLLECTION,
+  ensureCollectionDEK
+} from "./chunk-J2ZX2XUV.js";
+import "./chunk-4JBYV75E.js";
+import {
+  computeBrokerProof,
+  deriveBrokerProofBits,
+  openEnvelopeJson,
+  writeEnvelopeBody
+} from "./chunk-XDYREZWE.js";
+import "./chunk-7DSTRQIJ.js";
+import "./chunk-HB3RFQSC.js";
+import "./chunk-JKJOGPZN.js";
+import "./chunk-5M5DVGV7.js";
+import "./chunk-LP7BEXCT.js";
+import {
+  base64ToBuffer,
+  bufferToBase64
+} from "./chunk-CIE2BASH.js";
+import {
+  NOYDB_FORMAT_VERSION
+} from "./chunk-JNAI2HN2.js";
+import {
+  BrokerEnrolmentError,
+  BrokerProofError,
+  ConflictError,
+  NetworkError,
+  PermissionDeniedError,
+  ValidationError
+} from "./chunk-BIOUI4HL.js";
+import "./chunk-PZ5AY32C.js";
+
+// src/with-party/broker/seed.ts
+function requireAdminAccess(keyring) {
+  if (keyring.role !== "owner" && keyring.role !== "admin") {
+    throw new PermissionDeniedError(
+      `Credential-broker operations require owner or admin role. Current role: "${keyring.role}"`
+    );
+  }
+}
+var inFlightDekByStore = /* @__PURE__ */ new WeakMap();
+async function brokerDek(store, vault, keyring) {
+  const existing = keyring.deks.get(BROKER_COLLECTION);
+  if (existing) return existing;
+  let perStore = inFlightDekByStore.get(store);
+  if (!perStore) {
+    perStore = /* @__PURE__ */ new Map();
+    inFlightDekByStore.set(store, perStore);
+  }
+  const pending = perStore.get(vault);
+  if (pending) return pending;
+  const promise = (async () => {
+    try {
+      const getDek = await ensureCollectionDEK(store, vault, keyring);
+      return await getDek(BROKER_COLLECTION);
+    } catch (err) {
+      if (err instanceof ValidationError) {
+        throw new BrokerEnrolmentError(
+          "enroll()/rotate() need the KEK to provision the _broker DEK on first use \u2014 re-authenticate at tier 1 (passphrase) before enrolling. Using an already-enrolled seed (credentialSource()) needs only the DEK."
+        );
+      }
+      throw err;
+    }
+  })();
+  perStore.set(vault, promise);
+  try {
+    return await promise;
+  } finally {
+    perStore.delete(vault);
+  }
+}
+async function readRecord(store, vault, brokerId, dek) {
+  const envelope = await store.get(vault, BROKER_COLLECTION, brokerId);
+  if (!envelope) return null;
+  const record = JSON.parse(await openEnvelopeJson(envelope, dek));
+  return { envelope, record };
+}
+async function persistRecord(store, vault, keyring, dek, record, expectedVersion) {
+  const body = await writeEnvelopeBody(JSON.stringify(record), dek);
+  const envelope = {
+    _noydb: NOYDB_FORMAT_VERSION,
+    _v: expectedVersion + 1,
+    _ts: (/* @__PURE__ */ new Date()).toISOString(),
+    ...body,
+    _by: keyring.userId
+  };
+  await store.put(vault, BROKER_COLLECTION, record.brokerId, envelope, expectedVersion);
+}
+async function ensureSeedRecord(store, vault, keyring, config) {
+  requireAdminAccess(keyring);
+  const dek = await brokerDek(store, vault, keyring);
+  const existing = await readRecord(store, vault, config.brokerId, dek);
+  if (existing) {
+    return { seedBytes: base64ToBuffer(existing.record.seed), record: existing.record, dek, version: existing.envelope._v };
+  }
+  const seedBytes = globalThis.crypto.getRandomValues(new Uint8Array(32));
+  const record = {
+    brokerId: config.brokerId,
+    seed: bufferToBase64(seedBytes),
+    endpoint: config.endpoint,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    registered: false
+  };
+  try {
+    await persistRecord(store, vault, keyring, dek, record, 0);
+    return { seedBytes, record, dek, version: 1 };
+  } catch (err) {
+    if (!(err instanceof ConflictError)) throw err;
+    const winner = await readRecord(store, vault, config.brokerId, dek);
+    if (!winner) throw err;
+    return { seedBytes: base64ToBuffer(winner.record.seed), record: winner.record, dek, version: winner.envelope._v };
+  }
+}
+async function postEnroll(config, vault, proofBits) {
+  const fetchFn = config.fetch ?? globalThis.fetch;
+  const attestation = config.attestation ? await config.attestation() : void 0;
+  let res;
+  try {
+    res = await fetchFn(`${config.endpoint}/enroll`, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        ...attestation !== void 0 ? { authorization: `Bearer ${attestation}` } : {}
+      },
+      body: JSON.stringify({ vaultId: vault, brokerId: config.brokerId, proofKey: bufferToBase64(proofBits) })
+    });
+  } catch (err) {
+    throw new BrokerEnrolmentError(`broker /enroll request failed: ${err.message}`);
+  }
+  if (!res.ok) {
+    throw new BrokerEnrolmentError(`broker refused enrolment (status ${res.status}) \u2014 attestation likely missing or invalid`);
+  }
+}
+async function enrollSeed(ctx) {
+  const { store, vault, keyring, config } = ctx;
+  const { seedBytes, record, dek, version } = await ensureSeedRecord(store, vault, keyring, config);
+  if (record.registered) {
+    seedBytes.fill(0);
+    return;
+  }
+  const proofBits = await deriveBrokerProofBits(seedBytes, vault, config.brokerId);
+  seedBytes.fill(0);
+  try {
+    await postEnroll(config, vault, proofBits);
+  } finally {
+    proofBits.fill(0);
+  }
+  try {
+    await persistRecord(store, vault, keyring, dek, { ...record, registered: true }, version);
+  } catch (err) {
+    if (err instanceof ConflictError) {
+      const latest = await readRecord(store, vault, config.brokerId, dek);
+      if (latest?.record.registered) return;
+    }
+    throw err;
+  }
+}
+async function rotateSeed(ctx) {
+  const { store, vault, keyring, config } = ctx;
+  requireAdminAccess(keyring);
+  const dek = await brokerDek(store, vault, keyring);
+  const existing = await readRecord(store, vault, config.brokerId, dek);
+  if (!existing) {
+    await enrollSeed(ctx);
+    return;
+  }
+  const newSeedBytes = globalThis.crypto.getRandomValues(new Uint8Array(32));
+  const newProofBits = await deriveBrokerProofBits(newSeedBytes, vault, config.brokerId);
+  try {
+    await postEnroll(config, vault, newProofBits);
+  } finally {
+    newProofBits.fill(0);
+  }
+  const record = {
+    brokerId: config.brokerId,
+    seed: bufferToBase64(newSeedBytes),
+    endpoint: config.endpoint,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    registered: true
+  };
+  newSeedBytes.fill(0);
+  await persistRecord(store, vault, keyring, dek, record, existing.envelope._v);
+}
+async function mintStoreCredentials(ctx, profile) {
+  const { store, vault, keyring, config } = ctx;
+  requireAdminAccess(keyring);
+  const dek = await brokerDek(store, vault, keyring);
+  const found = await readRecord(store, vault, config.brokerId, dek);
+  if (!found) throw new BrokerEnrolmentError(`No _broker seed enrolled for brokerId "${config.brokerId}" \u2014 call enroll() first.`);
+  if (!found.record.registered) {
+    throw new BrokerEnrolmentError(
+      `The _broker seed for "${config.brokerId}" has not completed enrolment with the broker host \u2014 call enroll() again.`
+    );
+  }
+  const fetchFn = config.fetch ?? globalThis.fetch;
+  const endpointOrigin = new URL(config.endpoint).origin;
+  let challengeRes;
+  try {
+    challengeRes = await fetchFn(`${config.endpoint}/challenge`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ vaultId: vault, brokerId: config.brokerId })
+    });
+  } catch (err) {
+    throw new NetworkError(`broker /challenge request failed: ${err.message}`);
+  }
+  if (!challengeRes.ok) throw new NetworkError(`broker /challenge failed with status ${challengeRes.status}`);
+  const { challenge, expiresAt } = await challengeRes.json();
+  const seedBytes = base64ToBuffer(found.record.seed);
+  const proof = await computeBrokerProof(seedBytes, vault, config.brokerId, { endpointOrigin, profile, challenge, expiresAt });
+  let credsRes;
+  try {
+    credsRes = await fetchFn(`${config.endpoint}/credentials`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ vaultId: vault, brokerId: config.brokerId, challenge, proof, ...profile !== void 0 ? { profile } : {} })
+    });
+  } catch (err) {
+    throw new NetworkError(`broker /credentials request failed: ${err.message}`);
+  }
+  if (credsRes.status === 401 || credsRes.status === 403) throw new BrokerProofError("broker rejected the challenge proof");
+  if (!credsRes.ok) throw new NetworkError(`broker /credentials failed with status ${credsRes.status}`);
+  return await credsRes.json();
+}
+export {
+  enrollSeed,
+  mintStoreCredentials,
+  rotateSeed
+};
+//# sourceMappingURL=seed-Q6M2IZFL.js.map