@noy-db/hub 0.7.1-pre.0 → 0.8.0

package/dist/capsule/enclave-aes/index.d.ts

@@ -0,0 +1,113 @@
+/**
+ * **capsule/enclave-aes** — the hub's crypto interior, behind one door.
+ *
+ * This barrel is **the fork-swap contract**: a sister project that wants a
+ * different crypto engine (a different KDF, a hardware-backed keystore, a
+ * post-quantum wrap algorithm, …) replaces the entire `capsule/enclave-aes/`
+ * folder wholesale and only has to honor the exports below. Nothing outside
+ * `capsule/enclave-aes/**` may deep-import `crypto.js` or `record-keys/*` directly
+ * — `scripts/check-architecture.mjs`'s `enclave-barrel-only` check enforces
+ * that mechanically. Import sites inside `capsule/enclave-aes/**` keep their
+ * existing relative imports; this door is for everyone else.
+ *
+ * The export list is the OBSERVED contract — exactly the symbols consumed
+ * from outside this folder today — grouped by the module that defines them:
+ *
+ *   - key type       — `crypto.ts`: `EnclaveKey`, the opaque key type every
+ *                       barrel-facing signature traffics in (`= CryptoKey` in
+ *                       noy-db's reference enclave; a fork redefines it to its
+ *                       own key representation — see the type's own doc for
+ *                       the fork contract).
+ *   - crypto ops     — `crypto.ts`: AES-256-GCM encrypt/decrypt (+ bytes, AAD,
+ *                       deterministic variants), SHA-256 / HMAC-SHA-256 hashing.
+ *   - key lifecycle  — `crypto.ts` + `record-keys/lifecycle.ts`: KEK/DEK
+ *                       derivation, AES-KW wrap/unwrap, per-record CEK
+ *                       wrap/unwrap/import + resolution/re-wrap, HKDF-derived
+ *                       presence/sealed-field keys, base64 helpers.
+ *   - record codec   — `record-keys/record-codec.ts`: the per-record
+ *                       encode/decode engine.
+ *   - sealing        — `record-keys/sealing.ts`: the sealed-record grantor
+ *                       primitives (seal/revoke/rotate to an `at-*` host).
+ *   - deterministic  — `record-keys/deterministic.ts`: blind-equality lookup
+ *                       over deterministically-encrypted fields.
+ *   - tombstone      — `record-keys/tombstone.ts`: the erased-record residue.
+ *   - envelope body  — `record-keys/envelope-body.ts`: the C1 protected-body
+ *                       access contract (`openEnvelopeJson`,
+ *                       `writeEnvelopeBody`, `hasPerRecordKey`,
+ *                       `hasSealedBody`, `envelopeBodyForHash`) — the
+ *                       sanctioned door onto
+ *                       `_iv`/`_data`/`_cek`/`_sealed` for everyone outside
+ *                       this folder.
+ *   - reserved envelopes — `plumbing/sealed-slots.ts`: `makeReservedEnvelopes`,
+ *                       the whole-envelope encrypt/decrypt door scoped to a
+ *                       declared collection-name prefix (e.g. `_dict_`) —
+ *                       `kernel/vault.ts` binds it for `DictionaryHandle`
+ *                       (#629 Task 4).
+ *
+ * Additive changes only — removing or renaming an export here is breaking
+ * for any fork. Frozen by `__tests__/enclave-surface-golden.test.ts`.
+ *
+ * **Refusal contract:** the barrel above is frozen — every symbol must
+ * exist in any fork — but the optional groups (sealing, deterministic,
+ * per-record-key lifecycle) MAY throw `EnclaveNotSupportedError` instead
+ * of implementing the reference behavior. The core groups (crypto ops,
+ * record codec, tombstone) MUST NOT throw it — they are load-bearing for
+ * every consumer regardless of which enclave is wired in. noy-db's own
+ * enclave supports every group, so it never throws this error.
+ */
+export type { EnclaveKey, EncryptResult } from './crypto.js';
+export { encrypt, decrypt, encryptBytes, decryptBytes, encryptBytesWithAAD, decryptBytesWithAAD, encryptDeterministic, decryptDeterministic, } from './crypto.js';
+export { deriveKey, deriveSecretKey, generateDEK, generateEphemeralKey, importTransferKey, exportDekSet, importDekSet, wrapKey, unwrapKey, mintCanary, checkCanary, deriveDeterministicKey, deriveSealedFieldKey, deriveSealedFieldKeyFromCek, wrapCek, unwrapCek, importCek, deriveEchoKey, } from './crypto.js';
+export type { SecretKeyUsage } from './crypto.js';
+export { buildRecordAad, recordAadFor, buildRecordEnvelope, isTombstone, isTombstoneShape, buildTombstone, isDeleteMarker, buildDeleteMarker, requireSealedBody, sealedBodyArgs, envelopeBodySize, hasPerRecordKey, envelopeBodyForHash, hasSealedBody, } from '../plumbing/index.js';
+export { sha256Hex, sha256Bytes, hmacSha256Hex, hmacSignHex, hkdfAesGcmKey, deriveBlobAddressKey, derivePresenceKey, derivePresenceTagKey, generateIV, generateSalt, generateRecoverySecret, bufferToBase64, base64ToBuffer, encodeEchoParts, } from '../plumbing/digest.js';
+export type { EchoSecretParts } from '../plumbing/digest.js';
+export type { RecordIdentity, RecordRef } from '../plumbing/index.js';
+import type { RecordCodecBase } from '../plumbing/record-codec.js';
+/**
+ * `RecordCodec` is a VALUE (the capsule-bound subclass, destructured below) and
+ * a TYPE (the module-level generic base). A type ALIAS can coexist with a value
+ * of the same name; a `export type { RecordCodec }` RE-EXPORT cannot, which is
+ * what `TS2323: Cannot redeclare exported variable` was saying.
+ */
+export type RecordCodec<T = Record<string, unknown>> = RecordCodecBase<T>;
+export { buildSealedRecordEnvelope } from '../plumbing/record-envelope.js';
+export type { RecordEnvelopeBody } from '../plumbing/record-envelope.js';
+export type { RewrappedBody } from '../plumbing/lifecycle.js';
+export type { SealedShredSlot } from '../plumbing/record-codec.js';
+export type { SealingContext } from '../plumbing/sealing.js';
+export type { DeterministicContext } from '../plumbing/deterministic.js';
+export declare const openEnvelopeJson: (ref: import("./index.js").RecordRef, env: import("../../index.js").EncryptedEnvelope, key: import("../contract.js").CapsuleKey, opts?: {
+    encrypted?: boolean;
+}) => Promise<string>, writeEnvelopeBody: (identity: import("./index.js").RecordIdentity, json: string, key: import("../contract.js").CapsuleKey, opts?: {
+    encrypted?: boolean;
+    perRecordKey?: boolean;
+}) => Promise<Pick<import("../../index.js").EncryptedEnvelope, "_iv" | "_data" | "_cek">>, verifyRecordIdentity: (ref: import("./index.js").RecordRef, env: import("../../index.js").EncryptedEnvelope, key: import("../contract.js").CapsuleKey) => Promise<boolean>, resolveStableCek: (deps: import("../plumbing/lifecycle.js").StableCekDeps, id: string) => Promise<import("../contract.js").CapsuleKey>, rewrapBodyToDek: (from: import("./index.js").RecordIdentity, to: import("./index.js").RecordIdentity, envelope: Pick<import("../../index.js").EncryptedEnvelope, "_iv" | "_data" | "_cek" | "_tier" | "_by">, fromDek: import("../contract.js").CapsuleKey, toDek: import("../contract.js").CapsuleKey) => Promise<import("./index.js").RewrappedBody>, rewrapEnvelope: (identity: import("./index.js").RecordIdentity, envelope: import("../../index.js").EncryptedEnvelope, fromDek: import("../contract.js").CapsuleKey, toDek: import("../contract.js").CapsuleKey) => Promise<import("../../index.js").EncryptedEnvelope>, applyRewrappedBody: (envelope: import("../../index.js").EncryptedEnvelope, body: import("./index.js").RewrappedBody) => import("../../index.js").EncryptedEnvelope, isRewrappedUnder: (identity: import("./index.js").RecordIdentity, envelope: Pick<import("../../index.js").EncryptedEnvelope, "_iv" | "_data" | "_cek">, dek: import("../contract.js").CapsuleKey) => Promise<boolean>, rekeyEnvelopeToDek: (ref: {
+    readonly collection: string;
+    readonly id: string;
+}, envelope: import("../../index.js").EncryptedEnvelope, oldDek: import("../contract.js").CapsuleKey, newDek: import("../contract.js").CapsuleKey) => Promise<import("../../index.js").EncryptedEnvelope>, rekeyEnvelopeIfNeeded: (ref: {
+    readonly collection: string;
+    readonly id: string;
+}, envelope: import("../../index.js").EncryptedEnvelope, oldDek: import("../contract.js").CapsuleKey, newDek: import("../contract.js").CapsuleKey) => Promise<import("../../index.js").EncryptedEnvelope | null>, envelopeOpensUnderAny: (ref: {
+    readonly collection: string;
+    readonly id: string;
+}, envelope: import("../../index.js").EncryptedEnvelope, keys: readonly import("../contract.js").CapsuleKey[]) => Promise<boolean>, rekeyBlobSet: (adapter: import("../../index.js").NoydbStore, vault: string, oldDek: import("../contract.js").CapsuleKey, newDek: import("../contract.js").CapsuleKey, otherDeks?: readonly import("../contract.js").CapsuleKey[]) => Promise<import("../plumbing/rekey-blob.js").BlobRekeyReport>, RecordCodec: import("../plumbing/record-codec.js").BoundRecordCodec, makeReservedEnvelopes: (dekResolver: import("../plumbing/sealed-slots.js").ReservedEnvelopeDekResolver, declaredPrefixes: readonly string[]) => import("../../kernel/via/index.js").ViaCryptoCtx["reservedEnvelopes"], SEALED_CEK_NS: string, sealRecordToHost: (ctx: import("./index.js").SealingContext, collection: string, id: string, hostSealer: import("../../index.js").RecipientSealer, opts: {
+    expiresAt: string;
+}) => Promise<{
+    pid: string;
+    envelopeKey: string;
+}>, revokeSealedRecord: (ctx: import("./index.js").SealingContext, collection: string, id: string, pid: string, opts?: {
+    hard?: boolean;
+}) => Promise<void>, rotateRecordCek: (ctx: import("./index.js").SealingContext, collection: string, id: string) => Promise<void>, findByDet: <T>(ctx: import("./index.js").DeterministicContext<T>, field: string, value: unknown) => Promise<T | null>, queryByDet: <T>(ctx: import("./index.js").DeterministicContext<T>, field: string, value: unknown) => Promise<T[]>;
+export { deriveVdigSlotKey } from './classify/vdig.js';
+export { pbkdf2VerifyDigest } from './classify/digest.js';
+export { ctEqualTags } from '../plumbing/ct-equal.js';
+export { evaluateKofN } from '../plumbing/kofn.js';
+export { deriveClassifyIndexKey, deriveClassifyIndexSalt, mintBidxTag } from './classify/bidx.js';
+export { computeBidxTarget } from './classify/find.js';
+export { deriveBrokerProofBits, deriveBrokerProofKey, computeBrokerProof, issueChallenge, verifyBrokerProof, } from './broker/proof.js';
+export type { BrokerProofCanonicalParts, VerifyBrokerProofArgs, IssuedChallenge } from './broker/proof.js';
+export { generateSigningKeyPair, signBytes, verifyBytes } from '../plumbing/sign.js';
+export type { EnclaveKeyPair } from './crypto.js';
+export { generateRecipientKeyPair, exportRecipientPublicKeySpki, importRecipientPublicKeySpki, recipientWrap, recipientUnwrap, } from './crypto.js';
+export { capabilities } from './capabilities.js';

package/dist/capsule/enclave-aes/index.js

@@ -0,0 +1,335 @@
+import {
+  computeBidxTarget
+} from "../../chunk-BNWA3WG5.js";
+import {
+  aesCapsule,
+  checkCanary,
+  decrypt,
+  decryptBytes,
+  decryptBytesWithAAD,
+  decryptDeterministic,
+  deriveDeterministicKey,
+  deriveEchoKey,
+  deriveKey,
+  deriveSealedFieldKey,
+  deriveSealedFieldKeyFromCek,
+  deriveSecretKey,
+  deriveVdigSlotKey,
+  encrypt,
+  encryptBytes,
+  encryptBytesWithAAD,
+  encryptDeterministic,
+  exportDekSet,
+  exportRecipientPublicKeySpki,
+  generateDEK,
+  generateEphemeralKey,
+  generateRecipientKeyPair,
+  importCek,
+  importDekSet,
+  importRecipientPublicKeySpki,
+  importTransferKey,
+  mintCanary,
+  recipientUnwrap,
+  recipientWrap,
+  unwrapCek,
+  unwrapKey,
+  wrapCek,
+  wrapKey
+} from "../../chunk-5KC7QYEC.js";
+import {
+  deriveClassifyIndexKey,
+  deriveClassifyIndexSalt,
+  mintBidxTag,
+  pbkdf2VerifyDigest
+} from "../../chunk-EZOAKKTB.js";
+import {
+  generateSigningKeyPair,
+  signBytes,
+  verifyBytes
+} from "../../chunk-Q2XRFWOI.js";
+import {
+  evaluateKofN
+} from "../../chunk-NH2UOV3B.js";
+import {
+  buildDeleteMarker,
+  buildRecordAad,
+  buildRecordEnvelope,
+  buildSealedRecordEnvelope,
+  buildTombstone,
+  ctEqualTags,
+  envelopeBodyForHash,
+  envelopeBodySize,
+  hasPerRecordKey,
+  hasSealedBody,
+  isDeleteMarker,
+  isTombstone,
+  isTombstoneShape,
+  recordAadFor,
+  requireSealedBody,
+  sealedBodyArgs
+} from "../../chunk-42ALPZ2B.js";
+import {
+  base64ToBuffer,
+  bufferToBase64,
+  deriveBlobAddressKey,
+  derivePresenceKey,
+  derivePresenceTagKey,
+  encodeEchoParts,
+  generateIV,
+  generateRecoverySecret,
+  generateSalt,
+  hkdfAesGcmKey,
+  hmacSha256Hex,
+  hmacSignHex,
+  sha256Bytes,
+  sha256Hex
+} from "../../chunk-QMWY2FDS.js";
+import "../../chunk-SV2PM2OY.js";
+import {
+  ValidationError
+} from "../../chunk-37EPTBBR.js";
+
+// src/capsule/enclave-aes/broker/proof.ts
+var subtle = globalThis.crypto.subtle;
+var BROKER_PROOF_DOMAIN = "noydb-broker-proof";
+var BROKER_PROOF_VERSION = "noydb-broker-proof-v1";
+var DEFAULT_CHALLENGE_TTL_MS = 6e4;
+function buildCanonical(vaultId, brokerId, parts) {
+  return JSON.stringify([
+    BROKER_PROOF_VERSION,
+    vaultId,
+    parts.endpointOrigin,
+    brokerId,
+    parts.profile ?? "",
+    parts.instancePid ?? "",
+    parts.challenge,
+    parts.expiresAt
+  ]);
+}
+async function deriveBrokerProofBits(seed, vaultId, brokerId) {
+  const hkdfKey = await subtle.importKey("raw", seed, "HKDF", false, ["deriveBits"]);
+  const salt = new TextEncoder().encode(BROKER_PROOF_DOMAIN);
+  const info = new TextEncoder().encode(JSON.stringify([BROKER_PROOF_DOMAIN, vaultId, brokerId]));
+  const bits = await subtle.deriveBits({ name: "HKDF", hash: "SHA-256", salt, info }, hkdfKey, 256);
+  return new Uint8Array(bits);
+}
+async function deriveBrokerProofKey(seed, vaultId, brokerId) {
+  const proofBits = await deriveBrokerProofBits(seed, vaultId, brokerId);
+  try {
+    return await subtle.importKey("raw", proofBits, { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
+  } finally {
+    proofBits.fill(0);
+  }
+}
+async function computeBrokerProof(seed, vaultId, brokerId, canonicalParts) {
+  try {
+    if (canonicalParts.instancePid === "") {
+      throw new ValidationError(
+        "computeBrokerProof: instancePid must not be an empty string \u2014 omit the field entirely for 'no instance' (F7); '' would alias onto a registered instance."
+      );
+    }
+    const canonical = buildCanonical(vaultId, brokerId, canonicalParts);
+    const key = await deriveBrokerProofKey(seed, vaultId, brokerId);
+    const mac = await subtle.sign("HMAC", key, new TextEncoder().encode(canonical));
+    return bufferToBase64(new Uint8Array(mac));
+  } finally {
+    seed.fill(0);
+  }
+}
+function issueChallenge(opts) {
+  const ttlMs = opts?.ttlMs ?? DEFAULT_CHALLENGE_TTL_MS;
+  const bytes = globalThis.crypto.getRandomValues(new Uint8Array(32));
+  return {
+    challenge: bufferToBase64(bytes),
+    expiresAt: new Date(Date.now() + ttlMs).toISOString()
+  };
+}
+async function verifyBrokerProof(args) {
+  const fresh = await args.consumeChallenge(args.challenge);
+  if (!fresh) return false;
+  if (args.instancePid === "") return false;
+  const canonical = buildCanonical(args.vaultId, args.brokerId, {
+    endpointOrigin: args.endpointOrigin,
+    profile: args.profile,
+    instancePid: args.instancePid,
+    challenge: args.challenge,
+    expiresAt: args.expiresAt
+  });
+  const key = await subtle.importKey(
+    "raw",
+    args.registeredProofKey,
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["verify"]
+  );
+  const ok = await subtle.verify(
+    "HMAC",
+    key,
+    base64ToBuffer(args.proof),
+    new TextEncoder().encode(canonical)
+  );
+  if (!ok) return false;
+  return Date.now() < Date.parse(args.expiresAt);
+}
+
+// src/capsule/enclave-aes/capabilities.ts
+function sealedSet(items) {
+  const set = new Set(items);
+  const refuse = () => {
+    throw new TypeError(
+      "capabilities() is immutable \u2014 a capsule's declared groups cannot be edited by a caller"
+    );
+  };
+  set.add = refuse;
+  set.delete = refuse;
+  set.clear = refuse;
+  return Object.freeze(set);
+}
+var ALL = sealedSet([
+  "authenticate",
+  "seal",
+  "cipher",
+  "digest",
+  "sign",
+  "codec",
+  "sealing",
+  "deterministic",
+  "classify"
+]);
+function capabilities() {
+  return ALL;
+}
+
+// src/capsule/enclave-aes/index.ts
+var {
+  // envelope body
+  openEnvelopeJson,
+  writeEnvelopeBody,
+  verifyRecordIdentity,
+  // key lifecycle
+  resolveStableCek,
+  rewrapBodyToDek,
+  rewrapEnvelope,
+  applyRewrappedBody,
+  isRewrappedUnder,
+  // rekey
+  rekeyEnvelopeToDek,
+  rekeyEnvelopeIfNeeded,
+  envelopeOpensUnderAny,
+  rekeyBlobSet,
+  // record codec
+  RecordCodec,
+  // sealed slots — ONLY `makeReservedEnvelopes` is part of the frozen surface.
+  // The other seven are capsule-internal; destructuring the whole capsule here
+  // leaked them and widened the golden by 8 names. A surface is a contract, so
+  // the fix is to narrow the barrel, not to re-baseline the golden.
+  makeReservedEnvelopes,
+  // sealing
+  SEALED_CEK_NS,
+  sealRecordToHost,
+  revokeSealedRecord,
+  rotateRecordCek,
+  // deterministic
+  findByDet,
+  queryByDet
+} = aesCapsule;
+export {
+  RecordCodec,
+  SEALED_CEK_NS,
+  applyRewrappedBody,
+  base64ToBuffer,
+  bufferToBase64,
+  buildDeleteMarker,
+  buildRecordAad,
+  buildRecordEnvelope,
+  buildSealedRecordEnvelope,
+  buildTombstone,
+  capabilities,
+  checkCanary,
+  computeBidxTarget,
+  computeBrokerProof,
+  ctEqualTags,
+  decrypt,
+  decryptBytes,
+  decryptBytesWithAAD,
+  decryptDeterministic,
+  deriveBlobAddressKey,
+  deriveBrokerProofBits,
+  deriveBrokerProofKey,
+  deriveClassifyIndexKey,
+  deriveClassifyIndexSalt,
+  deriveDeterministicKey,
+  deriveEchoKey,
+  deriveKey,
+  derivePresenceKey,
+  derivePresenceTagKey,
+  deriveSealedFieldKey,
+  deriveSealedFieldKeyFromCek,
+  deriveSecretKey,
+  deriveVdigSlotKey,
+  encodeEchoParts,
+  encrypt,
+  encryptBytes,
+  encryptBytesWithAAD,
+  encryptDeterministic,
+  envelopeBodyForHash,
+  envelopeBodySize,
+  envelopeOpensUnderAny,
+  evaluateKofN,
+  exportDekSet,
+  exportRecipientPublicKeySpki,
+  findByDet,
+  generateDEK,
+  generateEphemeralKey,
+  generateIV,
+  generateRecipientKeyPair,
+  generateRecoverySecret,
+  generateSalt,
+  generateSigningKeyPair,
+  hasPerRecordKey,
+  hasSealedBody,
+  hkdfAesGcmKey,
+  hmacSha256Hex,
+  hmacSignHex,
+  importCek,
+  importDekSet,
+  importRecipientPublicKeySpki,
+  importTransferKey,
+  isDeleteMarker,
+  isRewrappedUnder,
+  isTombstone,
+  isTombstoneShape,
+  issueChallenge,
+  makeReservedEnvelopes,
+  mintBidxTag,
+  mintCanary,
+  openEnvelopeJson,
+  pbkdf2VerifyDigest,
+  queryByDet,
+  recipientUnwrap,
+  recipientWrap,
+  recordAadFor,
+  rekeyBlobSet,
+  rekeyEnvelopeIfNeeded,
+  rekeyEnvelopeToDek,
+  requireSealedBody,
+  resolveStableCek,
+  revokeSealedRecord,
+  rewrapBodyToDek,
+  rewrapEnvelope,
+  rotateRecordCek,
+  sealRecordToHost,
+  sealedBodyArgs,
+  sha256Bytes,
+  sha256Hex,
+  signBytes,
+  unwrapCek,
+  unwrapKey,
+  verifyBrokerProof,
+  verifyBytes,
+  verifyRecordIdentity,
+  wrapCek,
+  wrapKey,
+  writeEnvelopeBody
+};
+//# sourceMappingURL=index.js.map

package/dist/capsule/enclave-aes/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/capsule/enclave-aes/broker/proof.ts","../../../src/capsule/enclave-aes/capabilities.ts","../../../src/capsule/enclave-aes/index.ts"],"sourcesContent":["/**\n * Credential-broker proof crypto (#479, credential-broker spec §3).\n *\n * The `_broker` seed (32 random bytes, decrypted from `_broker/<brokerId>` by\n * the party layer) is never transmitted. Instead, a **proof key** is\n * HKDF-derived from it, domain-separated per `(vaultId, brokerId)`, and the\n * derived bits are registered with the broker host once at enrol. Steady\n * state, the client re-derives the same key from the seed and signs a\n * **canonical** string binding the request's identity/context, so the broker\n * can verify a fresh HMAC on every mint without ever holding the seed itself.\n *\n * ## Derivation (spec §3, follow verbatim)\n *\n * ```\n * hkdf      = importKey('raw', seed, 'HKDF', false, ['deriveBits'])\n * proofBits = deriveBits({ name:'HKDF', hash:'SHA-256',\n *                          salt: utf8(BROKER_PROOF_DOMAIN),\n *                          info: utf8(JSON.stringify([BROKER_PROOF_DOMAIN, vaultId, brokerId])) },\n *                        hkdf, 256)\n * proofKey  = importKey('raw', proofBits, { name:'HMAC', hash:'SHA-256' }, false, ['sign'])\n * proof     = base64(sign('HMAC', proofKey, utf8(canonical)))\n * ```\n *\n * `BROKER_PROOF_DOMAIN` is both the HKDF salt and the first `info` array\n * element (the injective-JSON-array convention `deriveClassifyIndexKey`\n * established — see `classify/bidx.ts`). `BROKER_PROOF_VERSION` is the\n * separate MAC version tag, the first element of the `canonical` array.\n *\n * ## Canonical (spec §2 step 3)\n *\n * `JSON.stringify([BROKER_PROOF_VERSION, vaultId, endpointOrigin, brokerId,\n * profile ?? '', instancePid ?? '', challenge, expiresAt])` — every binding\n * field folded into ONE MAC input:\n *  - `vaultId` (V1), `challenge` (V3), `expiresAt` (V4) — verbatim strings,\n *    never reparsed/reformatted (F8): a byte-identical ISO string is\n *    required, so e.g. `Z` vs `+00:00` for the same instant fails.\n *  - `profile ?? ''` (F1) — a proof captured at one profile cannot be\n *    replayed at another.\n *  - `endpointOrigin` (F4) — a proof cannot be relayed to a different broker\n *    endpoint reusing the same `brokerId`.\n *  - `instancePid ?? ''` (F7) — an EMPTY STRING `instancePid` is forbidden in\n *    both {@link computeBrokerProof} and {@link verifyBrokerProof}: absent\n *    (the field omitted) and `''` must stay distinguishable, or `?? ''`\n *    would alias \"no instance\" onto a real registered instance.\n *\n * ## Verify order (spec §3, non-negotiable, F2/F6)\n *\n * {@link verifyBrokerProof} MUST, in this exact order: (1) burn the challenge\n * via `consumeChallenge` FIRST and short-circuit `false` before any MAC work\n * (F2 — burn-on-presentation, not burn-on-success); (2) recompute the\n * canonical and compare with `crypto.subtle.verify('HMAC', …)` — portable,\n * constant-time, never a manual byte compare or Node `timingSafeEqual` (F6);\n * (3) assert `now < expiresAt` — the client clock is never trusted, so this\n * check only matters once the MAC (which covers `expiresAt`) has verified.\n *\n * ## Zeroing (F5)\n *\n * `seed` and the transient HKDF output are raw, durable secret material —\n * the `recovery.ts:276-307` `try{}finally{secret.fill(0)}` discipline, not\n * the ephemeral-CEK happy-path zeroing elsewhere. {@link computeBrokerProof}\n * zeroes the `seed` argument in a `finally` on every path including a throw;\n * {@link deriveBrokerProofKey} zeroes its own transient HKDF-output bytes the\n * same way. {@link deriveBrokerProofBits} does not zero `seed` — it exists\n * so the party layer can register the raw bits at one-time enrol (the value\n * that must survive the call to be base64-encoded and POSTed).\n *\n * @module\n */\nimport type { EnclaveKey } from '../crypto.js'\nimport { base64ToBuffer, bufferToBase64 } from '../../plumbing/digest.js'\nimport { ValidationError } from '../../../kernel/errors.js'\n\nconst subtle = globalThis.crypto.subtle\n\n/** HKDF salt domain for the broker proof key — also the first `info` array element. */\nexport const BROKER_PROOF_DOMAIN = 'noydb-broker-proof'\n\n/** MAC version tag — the first element of the `canonical` array signed/verified. */\nexport const BROKER_PROOF_VERSION = 'noydb-broker-proof-v1'\n\n/** Default challenge TTL (spec §2 step 2: \"TTL ≤ 60 s\"). */\nconst DEFAULT_CHALLENGE_TTL_MS = 60_000\n\n/** The canonical-binding fields a client supplies alongside `vaultId`/`brokerId` (spec §2 step 3). */\nexport interface BrokerProofCanonicalParts {\n  readonly endpointOrigin: string\n  readonly profile?: string | undefined\n  readonly instancePid?: string | undefined\n  readonly challenge: string\n  readonly expiresAt: string\n}\n\n/** A freshly-minted, server-random single-use challenge (spec §2 step 2). */\nexport interface IssuedChallenge {\n  readonly challenge: string\n  readonly expiresAt: string\n}\n\n/** Arguments the broker host passes to verify a submitted proof (spec §3). */\nexport interface VerifyBrokerProofArgs {\n  /**\n   * Atomically test-and-delete the challenge, returning whether it was still\n   * fresh (unconsumed and unexpired-from-the-store's-perspective). MUST burn\n   * on presentation, not on successful verification (F2).\n   */\n  readonly consumeChallenge: (challenge: string) => Promise<boolean>\n  /** The registered proof key's raw bytes, already KMS-unwrapped by the host (§7). */\n  readonly registeredProofKey: Uint8Array\n  readonly vaultId: string\n  readonly endpointOrigin: string\n  readonly brokerId: string\n  readonly profile?: string | undefined\n  readonly instancePid?: string | undefined\n  readonly challenge: string\n  readonly expiresAt: string\n  /** base64(HMAC-SHA-256(proofKey, canonical)), as submitted by the client. */\n  readonly proof: string\n}\n\n/** Build the canonical MAC input verbatim — never reparses/reformats a field (F8). */\nfunction buildCanonical(vaultId: string, brokerId: string, parts: BrokerProofCanonicalParts): string {\n  return JSON.stringify([\n    BROKER_PROOF_VERSION,\n    vaultId,\n    parts.endpointOrigin,\n    brokerId,\n    parts.profile ?? '',\n    parts.instancePid ?? '',\n    parts.challenge,\n    parts.expiresAt,\n  ])\n}\n\n/**\n * The HKDF step: derive the 256-bit proof bits from the `_broker` seed,\n * domain-separated per `(vaultId, brokerId)`. Returns the raw bits — the\n * value registered with the broker host once at enrol (spec §2 step 2/3).\n * Does not mutate or zero `seed`; the caller owns the seed's lifecycle.\n */\nexport async function deriveBrokerProofBits(\n  seed: Uint8Array,\n  vaultId: string,\n  brokerId: string,\n): Promise<Uint8Array> {\n  const hkdfKey = await subtle.importKey('raw', seed as BufferSource, 'HKDF', false, ['deriveBits'])\n  const salt = new TextEncoder().encode(BROKER_PROOF_DOMAIN)\n  const info = new TextEncoder().encode(JSON.stringify([BROKER_PROOF_DOMAIN, vaultId, brokerId]))\n  const bits = await subtle.deriveBits({ name: 'HKDF', hash: 'SHA-256', salt, info }, hkdfKey, 256)\n  return new Uint8Array(bits)\n}\n\n/**\n * Derive the steady-state, non-extractable `['sign']` HMAC proof key from\n * the `_broker` seed. Zeroes the transient HKDF-output bytes in a `finally`\n * once the key has been imported (F5) — the raw bits never leave this\n * function in usable form after import.\n */\nexport async function deriveBrokerProofKey(\n  seed: Uint8Array,\n  vaultId: string,\n  brokerId: string,\n): Promise<EnclaveKey> {\n  const proofBits = await deriveBrokerProofBits(seed, vaultId, brokerId)\n  try {\n    return await subtle.importKey('raw', proofBits as BufferSource, { name: 'HMAC', hash: 'SHA-256' }, false, ['sign'])\n  } finally {\n    proofBits.fill(0)\n  }\n}\n\n/**\n * Compose derive + sign for the client: re-derive the proof key from the\n * seed and sign the canonical over `canonicalParts` (spec §2 step 3).\n *\n * Rejects an empty-string `instancePid` (F7 — absent is fine, `''` is not).\n * Zeroes the `seed` argument in a `finally` on EVERY path including a throw\n * (F5, durable-secret discipline) — the transient HKDF bits are zeroed one\n * layer down, inside {@link deriveBrokerProofKey}.\n */\nexport async function computeBrokerProof(\n  seed: Uint8Array,\n  vaultId: string,\n  brokerId: string,\n  canonicalParts: BrokerProofCanonicalParts,\n): Promise<string> {\n  try {\n    if (canonicalParts.instancePid === '') {\n      throw new ValidationError(\n        \"computeBrokerProof: instancePid must not be an empty string — omit the field entirely for \" +\n          \"'no instance' (F7); '' would alias onto a registered instance.\",\n      )\n    }\n    const canonical = buildCanonical(vaultId, brokerId, canonicalParts)\n    const key = await deriveBrokerProofKey(seed, vaultId, brokerId)\n    const mac = await subtle.sign('HMAC', key, new TextEncoder().encode(canonical) as BufferSource)\n    return bufferToBase64(new Uint8Array(mac))\n  } finally {\n    seed.fill(0)\n  }\n}\n\n/**\n * Host-side nonce mint: 32 random bytes, base64-encoded, plus an ISO\n * `expiresAt` at most `ttlMs` (default 60 s) in the future. The caller\n * (the broker host) persists both returned strings **verbatim** and MACs\n * those exact bytes on verify — never a reparsed/reformatted copy (F8).\n */\nexport function issueChallenge(opts?: { ttlMs?: number }): IssuedChallenge {\n  const ttlMs = opts?.ttlMs ?? DEFAULT_CHALLENGE_TTL_MS\n  const bytes = globalThis.crypto.getRandomValues(new Uint8Array(32))\n  return {\n    challenge: bufferToBase64(bytes),\n    expiresAt: new Date(Date.now() + ttlMs).toISOString(),\n  }\n}\n\n/**\n * Verify a submitted broker proof. Order is NON-NEGOTIABLE (spec §3):\n *\n * 1. `await consumeChallenge(challenge)` FIRST — burn-and-check-fresh; a\n *    not-fresh (already-consumed or unknown) challenge short-circuits to\n *    `false` before any MAC work (F2).\n * 2. Empty-string `instancePid` is rejected (F7), then the canonical is\n *    recomputed over the verbatim `endpointOrigin`/`brokerId`/`profile`/\n *    `instancePid`/`challenge`/`expiresAt` and compared via\n *    `crypto.subtle.verify('HMAC', …)` — portable, constant-time, never a\n *    manual compare or Node `timingSafeEqual` (F6).\n * 3. `now < expiresAt` — the client clock is never trusted; `expiresAt`\n *    rides inside the already-verified MAC (F4/F8).\n */\nexport async function verifyBrokerProof(args: VerifyBrokerProofArgs): Promise<boolean> {\n  const fresh = await args.consumeChallenge(args.challenge)\n  if (!fresh) return false\n\n  if (args.instancePid === '') return false\n\n  const canonical = buildCanonical(args.vaultId, args.brokerId, {\n    endpointOrigin: args.endpointOrigin,\n    profile: args.profile,\n    instancePid: args.instancePid,\n    challenge: args.challenge,\n    expiresAt: args.expiresAt,\n  })\n  const key = await subtle.importKey(\n    'raw',\n    args.registeredProofKey as BufferSource,\n    { name: 'HMAC', hash: 'SHA-256' },\n    false,\n    ['verify'],\n  )\n  const ok = await subtle.verify(\n    'HMAC',\n    key,\n    base64ToBuffer(args.proof) as BufferSource,\n    new TextEncoder().encode(canonical) as BufferSource,\n  )\n  if (!ok) return false\n\n  return Date.now() < Date.parse(args.expiresAt)\n}\n","import type { CapsuleGroup } from '../contract.js'\n\n/**\n * `enclave-aes` supports every group. It is the REFERENCE capsule — the\n * behaviour every other implementation is compared against, and the one hub\n * ships so that `npm install @noy-db/hub` alone is a working noy-db.\n *\n * An `exclave-*` refuses `authenticate` and `seal` (no secret, no key\n * hierarchy — the store's own IAM is the authority) and may refuse the\n * optional groups. That asymmetry is what the prefix means, and the\n * conformance suite asserts it from the package name rather than trusting a\n * declaration.\n *\n * Frozen so a caller cannot edit what a capsule claims to support: a mutable\n * set would let a service \"enable\" a group by adding to it, which is exactly\n * the confidently-wrong failure the typed refusal exists to prevent.\n */\n/**\n * ⛔ `Object.freeze` does NOT make a Set immutable — it guards own properties,\n * not internal slots, so `frozen.add(x)` still succeeds. Measured 2026-09-12,\n * against a test that asserted otherwise and failed. The mutators are replaced\n * so the refusal is real at runtime, not just in the type.\n *\n * Why it has to be real: a caller holding a mutable capability set can \"enable\"\n * a group the capsule does not implement, and the next thing that happens is a\n * primitive being called on a capsule that has none. `ReadonlySet` alone is a\n * compile-time claim, and a JS consumer never sees it.\n */\nfunction sealedSet<T>(items: readonly T[]): ReadonlySet<T> {\n  const set = new Set<T>(items)\n  const refuse = (): never => {\n    throw new TypeError(\n      'capabilities() is immutable — a capsule\\'s declared groups cannot be edited by a caller',\n    )\n  }\n  set.add = refuse as never\n  set.delete = refuse as never\n  set.clear = refuse as never\n  return Object.freeze(set)\n}\n\nconst ALL: ReadonlySet<CapsuleGroup> = sealedSet<CapsuleGroup>([\n  'authenticate',\n  'seal',\n  'cipher',\n  'digest',\n  'sign',\n  'codec',\n  'sealing',\n  'deterministic',\n  'classify',\n])\n\nexport function capabilities(): ReadonlySet<CapsuleGroup> {\n  return ALL\n}\n","/**\n * **capsule/enclave-aes** — the hub's crypto interior, behind one door.\n *\n * This barrel is **the fork-swap contract**: a sister project that wants a\n * different crypto engine (a different KDF, a hardware-backed keystore, a\n * post-quantum wrap algorithm, …) replaces the entire `capsule/enclave-aes/`\n * folder wholesale and only has to honor the exports below. Nothing outside\n * `capsule/enclave-aes/**` may deep-import `crypto.js` or `record-keys/*` directly\n * — `scripts/check-architecture.mjs`'s `enclave-barrel-only` check enforces\n * that mechanically. Import sites inside `capsule/enclave-aes/**` keep their\n * existing relative imports; this door is for everyone else.\n *\n * The export list is the OBSERVED contract — exactly the symbols consumed\n * from outside this folder today — grouped by the module that defines them:\n *\n *   - key type       — `crypto.ts`: `EnclaveKey`, the opaque key type every\n *                       barrel-facing signature traffics in (`= CryptoKey` in\n *                       noy-db's reference enclave; a fork redefines it to its\n *                       own key representation — see the type's own doc for\n *                       the fork contract).\n *   - crypto ops     — `crypto.ts`: AES-256-GCM encrypt/decrypt (+ bytes, AAD,\n *                       deterministic variants), SHA-256 / HMAC-SHA-256 hashing.\n *   - key lifecycle  — `crypto.ts` + `record-keys/lifecycle.ts`: KEK/DEK\n *                       derivation, AES-KW wrap/unwrap, per-record CEK\n *                       wrap/unwrap/import + resolution/re-wrap, HKDF-derived\n *                       presence/sealed-field keys, base64 helpers.\n *   - record codec   — `record-keys/record-codec.ts`: the per-record\n *                       encode/decode engine.\n *   - sealing        — `record-keys/sealing.ts`: the sealed-record grantor\n *                       primitives (seal/revoke/rotate to an `at-*` host).\n *   - deterministic  — `record-keys/deterministic.ts`: blind-equality lookup\n *                       over deterministically-encrypted fields.\n *   - tombstone      — `record-keys/tombstone.ts`: the erased-record residue.\n *   - envelope body  — `record-keys/envelope-body.ts`: the C1 protected-body\n *                       access contract (`openEnvelopeJson`,\n *                       `writeEnvelopeBody`, `hasPerRecordKey`,\n *                       `hasSealedBody`, `envelopeBodyForHash`) — the\n *                       sanctioned door onto\n *                       `_iv`/`_data`/`_cek`/`_sealed` for everyone outside\n *                       this folder.\n *   - reserved envelopes — `plumbing/sealed-slots.ts`: `makeReservedEnvelopes`,\n *                       the whole-envelope encrypt/decrypt door scoped to a\n *                       declared collection-name prefix (e.g. `_dict_`) —\n *                       `kernel/vault.ts` binds it for `DictionaryHandle`\n *                       (#629 Task 4).\n *\n * Additive changes only — removing or renaming an export here is breaking\n * for any fork. Frozen by `__tests__/enclave-surface-golden.test.ts`.\n *\n * **Refusal contract:** the barrel above is frozen — every symbol must\n * exist in any fork — but the optional groups (sealing, deterministic,\n * per-record-key lifecycle) MAY throw `EnclaveNotSupportedError` instead\n * of implementing the reference behavior. The core groups (crypto ops,\n * record codec, tombstone) MUST NOT throw it — they are load-bearing for\n * every consumer regardless of which enclave is wired in. noy-db's own\n * enclave supports every group, so it never throws this error.\n */\n\nimport { aesCapsule } from './bound.js'\n\n// ─── key type ──────────────────────────────────────────────────────\nexport type { EnclaveKey, EncryptResult } from './crypto.js'\n\n// ─── crypto ops ────────────────────────────────────────────────────\nexport {\n  encrypt,\n  decrypt,\n  encryptBytes,\n  decryptBytes,\n  encryptBytesWithAAD,\n  decryptBytesWithAAD,\n  encryptDeterministic,\n  decryptDeterministic,\n} from './crypto.js'\n\n// ─── key lifecycle ─────────────────────────────────────────────────\nexport {\n  deriveKey,\n  deriveSecretKey,\n  generateDEK,\n  generateEphemeralKey,\n  importTransferKey,\n  exportDekSet,\n  importDekSet,\n  wrapKey,\n  unwrapKey,\n  mintCanary,\n  checkCanary,\n  deriveDeterministicKey,\n  deriveSealedFieldKey,\n  deriveSealedFieldKeyFromCek,\n  wrapCek,\n  unwrapCek,\n  importCek,\n  deriveEchoKey,\n} from './crypto.js'\nexport type { SecretKeyUsage } from './crypto.js'\n// ─── shared plumbing ───────────────────────────────────────────────\n//\n// Everything from here to the end of this block used to be twelve modules\n// under `./record-keys/`. They now live once in `../plumbing/`, and this\n// capsule is one of two callers of `makeCapsule()`.\n//\n// The split below is not cosmetic. The cipher-FREE half is re-exported\n// straight from its module: it inspects envelope fields and derives hash\n// input, so there is nothing to bind and every capsule gets the identical\n// function. The cipher-BOUND half is destructured off `aesCapsule`, which is\n// `makeCapsule(aesPrimitives)` — one binding for the whole capsule, so a value\n// exported here and a value used inside `classify/**` are the SAME object.\nexport {\n  buildRecordAad,\n  recordAadFor,\n  buildRecordEnvelope,\n  isTombstone,\n  isTombstoneShape,\n  buildTombstone,\n  isDeleteMarker,\n  buildDeleteMarker,\n  requireSealedBody,\n  sealedBodyArgs,\n  envelopeBodySize,\n  hasPerRecordKey,\n  envelopeBodyForHash,\n  hasSealedBody,\n} from '../plumbing/index.js'\n// ─── digest group ──────────────────────────────────────────────────\n// Shared, not AES-specific: the seam design marks `digest` \"as today\" for every\n// capsule. Re-exported here so the barrel's surface is unchanged.\nexport {\n  sha256Hex,\n  sha256Bytes,\n  hmacSha256Hex,\n  hmacSignHex,\n  hkdfAesGcmKey,\n  deriveBlobAddressKey,\n  derivePresenceKey,\n  derivePresenceTagKey,\n  generateIV,\n  generateSalt,\n  generateRecoverySecret,\n  bufferToBase64,\n  base64ToBuffer,\n  encodeEchoParts,\n} from '../plumbing/digest.js'\nexport type { EchoSecretParts } from '../plumbing/digest.js'\nexport type { RecordIdentity, RecordRef } from '../plumbing/index.js'\nimport type { RecordCodecBase } from '../plumbing/record-codec.js'\n/**\n * `RecordCodec` is a VALUE (the capsule-bound subclass, destructured below) and\n * a TYPE (the module-level generic base). A type ALIAS can coexist with a value\n * of the same name; a `export type { RecordCodec }` RE-EXPORT cannot, which is\n * what `TS2323: Cannot redeclare exported variable` was saying.\n */\nexport type RecordCodec<T = Record<string, unknown>> = RecordCodecBase<T>\nexport { buildSealedRecordEnvelope } from '../plumbing/record-envelope.js'\nexport type { RecordEnvelopeBody } from '../plumbing/record-envelope.js'\nexport type { RewrappedBody } from '../plumbing/lifecycle.js'\nexport type { SealedShredSlot } from '../plumbing/record-codec.js'\nexport type { SealingContext } from '../plumbing/sealing.js'\nexport type { DeterministicContext } from '../plumbing/deterministic.js'\n\nexport const {\n  // envelope body\n  openEnvelopeJson,\n  writeEnvelopeBody,\n  verifyRecordIdentity,\n  // key lifecycle\n  resolveStableCek,\n  rewrapBodyToDek,\n  rewrapEnvelope,\n  applyRewrappedBody,\n  isRewrappedUnder,\n  // rekey\n  rekeyEnvelopeToDek,\n  rekeyEnvelopeIfNeeded,\n  envelopeOpensUnderAny,\n  rekeyBlobSet,\n  // record codec\n  RecordCodec,\n  // sealed slots — ONLY `makeReservedEnvelopes` is part of the frozen surface.\n  // The other seven are capsule-internal; destructuring the whole capsule here\n  // leaked them and widened the golden by 8 names. A surface is a contract, so\n  // the fix is to narrow the barrel, not to re-baseline the golden.\n  makeReservedEnvelopes,\n  // sealing\n  SEALED_CEK_NS,\n  sealRecordToHost,\n  revokeSealedRecord,\n  rotateRecordCek,\n  // deterministic\n  findByDet,\n  queryByDet,\n} = aesCapsule\n\n// ─── reserved envelopes (ViaCryptoCtx.reservedEnvelopes capability) ──\n\n// ─── classify (stage-2 verify oracle primitives) ────────────────────\n// ADDITIVE per Enclave Contract v1. A fork must provide these four; the\n// verify/matchGroup orchestration (classify/verify.ts) sits behind the\n// with-shape dynamic-import seam and is not part of the fork contract.\nexport { deriveVdigSlotKey } from './classify/vdig.js'\nexport { pbkdf2VerifyDigest } from './classify/digest.js'\nexport { ctEqualTags } from '../plumbing/ct-equal.js'\nexport { evaluateKofN } from '../plumbing/kofn.js'\n\n// ─── classify (slice-2b equatable blind index) ──────────────────────\n// ADDITIVE per Enclave Contract v1. A fork must provide these four; the\n// findByDigest orchestration (collection.ts) sits behind the with-shape\n// dynamic-import seam and is not part of the fork contract.\nexport { deriveClassifyIndexKey, deriveClassifyIndexSalt, mintBidxTag } from './classify/bidx.js'\nexport { computeBidxTarget } from './classify/find.js'\n\n// ─── broker (proof derivation + challenge/verify, #479 slice 2) ─────\n// ADDITIVE per Enclave Contract v1. A fork must provide these five; the\n// seed lifecycle + network/cache orchestration (with-party/broker/**) sits\n// behind its own dynamic-import seam and is not part of the fork contract.\nexport {\n  deriveBrokerProofBits,\n  deriveBrokerProofKey,\n  computeBrokerProof,\n  issueChallenge,\n  verifyBrokerProof,\n} from './broker/proof.js'\nexport type { BrokerProofCanonicalParts, VerifyBrokerProofArgs, IssuedChallenge } from './broker/proof.js'\n\n// ─── sign ─────────────────────────────────────────────────────────────\nexport { generateSigningKeyPair, signBytes, verifyBytes } from '../plumbing/sign.js'\n\n// ─── recipient sealing ────────────────────────────────────────────────\nexport type { EnclaveKeyPair } from './crypto.js'\nexport {\n  generateRecipientKeyPair,\n  exportRecipientPublicKeySpki,\n  importRecipientPublicKeySpki,\n  recipientWrap,\n  recipientUnwrap,\n} from './crypto.js'\n\n// ─── capabilities ─────────────────────────────────────────────────────\n// What THIS capsule supports. Part of the contract every capsule implements,\n// not an enclave-aes detail — an alternative declares its own, and a service\n// asserts against it at createNoydb() rather than failing on first write.\nexport { capabilities } from './capabilities.js'\n"],"mappings":"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","names":[]}

package/dist/capsule/enclave-aes/primitives.d.ts

@@ -0,0 +1,29 @@
+/**
+ * `enclave-aes` as a {@link CapsulePrimitives} — the 13 functions the shared
+ * plumbing binds to.
+ *
+ * ⭐ THE ASSIGNMENT BELOW IS A TEST, and it is the reason this file exists as
+ * a file rather than an inline object at the `makeCapsule()` call. Declaring
+ * the seam type and implementing it are two different acts; nothing checks a
+ * hand-written interface against the module it claims to describe unless
+ * something binds one to the other. This binding caught two errors in the
+ * declaration within minutes of it being written:
+ *
+ *   - `deriveDeterministicKey` was declared `(dek, context)`. It takes ONE
+ *     argument — the AES capsule derives the context into the IV, not the key.
+ *   - `bufferToBase64` was declared `(bytes: Uint8Array)`. It also accepts an
+ *     `ArrayBuffer`, which is what its callers actually pass.
+ *
+ * Both would have compiled here and failed at the far end of the refactor,
+ * where the cause is no longer visible. (The same lesson as `#16`: a
+ * structural declaration drifts silently from its implementation until an
+ * assignment pins the two together.)
+ *
+ * ⚠️ Method shorthand in `CapsulePrimitives` is checked BIVARIANTLY, so this
+ * assignment does NOT catch parameter-arity drift — that is exactly how the
+ * `deriveDeterministicKey` mistake survived the type and was caught by a call
+ * site instead. Keep the conformance kit's call-site coverage; this assignment
+ * is necessary, not sufficient.
+ */
+import type { CapsulePrimitives } from '../contract.js';
+export declare const aesPrimitives: CapsulePrimitives;

package/dist/capsule/index.d.ts

@@ -0,0 +1,27 @@
+/**
+ * THE DOOR. This is the ONLY hub file that may import the bound capsule.
+ * Everything else in hub imports THIS file.
+ *
+ * Enforced by `capsule-door-only` in `scripts/check-architecture.mjs`, which
+ * fails any other file naming `#capsule`. A door nothing enforces is not a
+ * door — the enclave barrel it replaces was reached around 38 times before a
+ * check existed.
+ *
+ * `#capsule` resolves through hub's `imports` map: `capsule/enclave-aes/` by
+ * default, or an alternative package when a consumer sets a build condition.
+ *
+ * ⛔ THE RE-EXPORTS BELOW ARE EXPLICIT, AND MUST STAY THAT WAY.
+ * `export * from '#capsule'` is the obvious spelling and it does not build:
+ * `#capsule` is EXTERNAL (it has to be, or the capsule choice bakes in at hub's
+ * build time), and esbuild cannot enumerate an external module's exports. Every
+ * named import through the door then fails with "No matching export". Measured
+ * 2026-09-12.
+ *
+ * Generated from `__tests__/enclave-surface.golden.json` — the same artefact
+ * the surface test freezes, so the door and the golden cannot drift. Adding a
+ * capsule primitive means adding it to the golden and regenerating.
+ */
+export { RecordCodec, SEALED_CEK_NS, applyRewrappedBody, base64ToBuffer, bufferToBase64, buildDeleteMarker, buildRecordAad, buildRecordEnvelope, buildSealedRecordEnvelope, buildTombstone, capabilities, checkCanary, computeBidxTarget, computeBrokerProof, ctEqualTags, decrypt, decryptBytes, decryptBytesWithAAD, decryptDeterministic, deriveBlobAddressKey, deriveBrokerProofBits, deriveBrokerProofKey, deriveClassifyIndexKey, deriveClassifyIndexSalt, deriveDeterministicKey, deriveEchoKey, deriveKey, derivePresenceKey, derivePresenceTagKey, deriveSealedFieldKey, deriveSealedFieldKeyFromCek, deriveSecretKey, deriveVdigSlotKey, encodeEchoParts, encrypt, encryptBytes, encryptBytesWithAAD, encryptDeterministic, envelopeBodyForHash, envelopeBodySize, envelopeOpensUnderAny, evaluateKofN, exportDekSet, exportRecipientPublicKeySpki, findByDet, generateDEK, generateEphemeralKey, generateIV, generateRecipientKeyPair, generateRecoverySecret, generateSalt, generateSigningKeyPair, hasPerRecordKey, hasSealedBody, requireSealedBody, sealedBodyArgs, hkdfAesGcmKey, hmacSha256Hex, hmacSignHex, importCek, importDekSet, importRecipientPublicKeySpki, importTransferKey, isDeleteMarker, isRewrappedUnder, isTombstone, isTombstoneShape, issueChallenge, makeReservedEnvelopes, mintBidxTag, mintCanary, openEnvelopeJson, pbkdf2VerifyDigest, queryByDet, recipientUnwrap, recipientWrap, recordAadFor, rekeyBlobSet, rekeyEnvelopeIfNeeded, rekeyEnvelopeToDek, resolveStableCek, revokeSealedRecord, rewrapBodyToDek, rewrapEnvelope, rotateRecordCek, sealRecordToHost, sha256Bytes, sha256Hex, signBytes, unwrapCek, unwrapKey, verifyBrokerProof, verifyBytes, verifyRecordIdentity, wrapCek, wrapKey, writeEnvelopeBody, } from '#capsule';
+export type { BrokerProofCanonicalParts, DeterministicContext, EchoSecretParts, EnclaveKey, EnclaveKeyPair, EncryptResult, IssuedChallenge, RecordEnvelopeBody, RecordIdentity, RecordRef, RewrappedBody, SealedShredSlot, SealingContext, SecretKeyUsage, VerifyBrokerProofArgs, } from '#capsule';
+export type { CapsuleKey, CapsuleKeyPair, CapsuleGroup } from './contract.js';
+export { CapsuleNotSupportedError } from './contract.js';

package/dist/capsule/plumbing/ct-equal.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Constant-time 32-byte tag comparison.
+ *
+ * Pure — no WebCrypto, no key material — so it is plumbing rather than a
+ * capsule primitive. It lived in `enclave-aes/classify/compare.ts` only
+ * because that is where its first caller was; leaving it there would have made
+ * `@noy-db/hub/capsule` import the AES capsule to reach it, which is precisely
+ * the coupling the seam exists to remove.
+ */
+/** Compare exactly-32-byte tags. XOR-accumulate over all 32 bytes, no early exit. */
+export declare function ctEqualTags(a: Uint8Array, b: Uint8Array): boolean;

package/dist/{kernel/enclave/record-keys → capsule/plumbing}/deterministic.d.ts

@@ -16,10 +16,10 @@
  *
  * Internal service — not exported as a `@noy-db/hub/*` subpath.
  */
-import { type EnclaveKey } from '../crypto.js';
-import type { NoydbStore } from '../../types.js';
-import type { RecordCodec } from './record-codec.js';
+import type { NoydbStore } from '../../kernel/types.js';
+import type { RecordCodec } from './index.js';
 /** Everything the moving deterministic-index methods touched on `this.*`. */
+import type { CapsuleKey, CapsulePrimitives } from '../contract.js';
 export interface DeterministicContext<T> {
     /** Collection name — the deterministic-encryption AAD scope. */
     readonly name: string;
@@ -32,24 +32,11 @@ export interface DeterministicContext<T> {
     /** False on plaintext collections — det lookups are encrypted-only. */
     readonly storeCiphertext: boolean;
     /** The collection DEK resolver. */
-    getDEK(): Promise<EnclaveKey>;
+    getDEK(): Promise<CapsuleKey>;
     /** The record codec — decrypts a matched envelope to T. */
     readonly codec: RecordCodec<T>;
 }
-/**
- * Find the first record whose deterministic field matches the given plaintext.
- * Returns `null` when no match exists.
- *
- * Reads every envelope via the adapter and compares the stored `_det[field]` to
- * a freshly computed deterministic ciphertext — no record bodies are decrypted
- * during the search.
- *
- * Throws when the field is not declared in `deterministicFields`, so a typo
- * fails loudly at the call site rather than silently returning null forever.
- */
-export declare function findByDet<T>(ctx: DeterministicContext<T>, field: string, value: unknown): Promise<T | null>;
-/**
- * Return every record whose deterministic field matches. Same semantics as
- * {@link findByDet} but without the short-circuit.
- */
-export declare function queryByDet<T>(ctx: DeterministicContext<T>, field: string, value: unknown): Promise<T[]>;
+export declare function makeDeterministic(p: CapsulePrimitives): {
+    findByDet: <T>(ctx: DeterministicContext<T>, field: string, value: unknown) => Promise<T | null>;
+    queryByDet: <T>(ctx: DeterministicContext<T>, field: string, value: unknown) => Promise<T[]>;
+};