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

package/dist/{chunk-HTRLQ4ZZ.js → chunk-I4S7IZSS.js}

@@ -1,135 +1,24 @@
 import {
-  normalizeForVerify
-} from "./chunk-EPPAEGH5.js";
+  buildRecordAad,
+  buildRecordEnvelope,
+  isDeleteMarker,
+  isTombstone,
+  makeEnvelopeBody,
+  recordAadFor,
+  sealedBodyArgs
+} from "./chunk-XWWDZKLS.js";
 import {
   NOYDB_FORMAT_VERSION,
   SealedHandle
-} from "./chunk-URGHKZPL.js";
+} from "./chunk-CR5UPYIJ.js";
 import {
   ClassifiedConfigError,
   DebugReservedFieldError,
-  MissingEnvelopeBodyError,
+  NoydbError,
   RecordCekNotFoundError,
   SchemaValidationError,
   ValidationError
-} from "./chunk-2RH5SEY7.js";
-
-// src/capsule/plumbing/record-aad.ts
-var SCHEME = "noydb-aad/2";
-var encoder = new TextEncoder();
-function buildRecordAad(identity) {
-  if (!Number.isFinite(identity.version)) {
-    throw new TypeError(
-      `record AAD: version must be a finite number for "${identity.collection}/${identity.id}", received ${String(identity.version)}. Sealing without one produces a record no reader can open.`
-    );
-  }
-  for (const [field, value] of [["collection", identity.collection], ["id", identity.id]]) {
-    if (typeof value !== "string") {
-      throw new TypeError(
-        `record AAD: ${field} must be a string, received ${String(value)} (${typeof value}). Sealing against a coerced address produces a record no reader can open, and the failure surfaces on the READ path.`
-      );
-    }
-  }
-  const parts = [encoder.encode(SCHEME)];
-  const pushField = (value) => {
-    const bytes = encoder.encode(value);
-    const len = new Uint8Array(4);
-    new DataView(len.buffer).setUint32(0, bytes.length, false);
-    parts.push(len, bytes);
-  };
-  pushField(identity.collection);
-  pushField(identity.id);
-  pushField(String(identity.tier ?? 0));
-  parts.push(new Uint8Array([identity.by === void 0 ? 0 : 1]));
-  if (identity.by !== void 0) pushField(identity.by);
-  pushField(String(identity.version));
-  const total = parts.reduce((n, p) => n + p.length, 0);
-  const out = new Uint8Array(total);
-  let offset = 0;
-  for (const p of parts) {
-    out.set(p, offset);
-    offset += p.length;
-  }
-  return out;
-}
-function recordAadFor(ref, envelope) {
-  return buildRecordAad({
-    collection: ref.collection,
-    id: ref.id,
-    version: envelope._v,
-    tier: envelope._tier,
-    by: envelope._by
-  });
-}
-
-// src/capsule/plumbing/envelope-body.ts
-function requireSealedBody(env, where) {
-  if (env._iv === void 0 || env._data === void 0) throw new MissingEnvelopeBodyError(where);
-  return { iv: env._iv, data: env._data };
-}
-function sealedBodyArgs(env, where) {
-  const { iv, data } = requireSealedBody(env, where);
-  return [iv, data];
-}
-function envelopeBodySize(env) {
-  return (env._data?.length ?? 0) + (env._iv?.length ?? 0);
-}
-function hasPerRecordKey(env) {
-  return env._cek !== void 0;
-}
-function envelopeBodyForHash(env) {
-  const data = env._data ?? "";
-  if (env._sealed === void 0 && env._vdig === void 0 && env._bidx === void 0) return data;
-  const mapPart = (key, map) => {
-    const parts = Object.keys(map).sort().map(
-      (k) => `${JSON.stringify(k)}:${JSON.stringify(map[k])}`
-    );
-    return `${JSON.stringify(key)}:{${parts.join(",")}}`;
-  };
-  const segments = [`"_data":${JSON.stringify(data)}`];
-  if (env._sealed !== void 0) segments.push(mapPart("_sealed", env._sealed));
-  if (env._vdig !== void 0) segments.push(mapPart("_vdig", env._vdig));
-  if (env._bidx !== void 0) segments.push(mapPart("_bidx", env._bidx));
-  return `{${segments.join(",")}}`;
-}
-function hasSealedBody(env) {
-  return env._iv !== void 0 && env._iv !== "";
-}
-function makeEnvelopeBody(p) {
-  const { encrypt, decrypt, generateDEK, wrapCek, unwrapCek } = p;
-  async function openEnvelopeJson(ref, env, key, opts) {
-    if (opts?.encrypted === false) return env._data ?? "";
-    const aad = recordAadFor(ref, env);
-    const { iv, data } = requireSealedBody(env, "openEnvelopeJson");
-    if (env._cek !== void 0) {
-      const cek = await unwrapCek(env._cek, key);
-      return decrypt(iv, data, cek, aad);
-    }
-    return decrypt(iv, data, key, aad);
-  }
-  async function writeEnvelopeBody(identity, json, key, opts) {
-    if (opts?.encrypted === false) return { _iv: "", _data: json };
-    const aad = buildRecordAad(identity);
-    if (opts?.perRecordKey === true) {
-      const cek = await generateDEK();
-      const { iv: iv2, data: data2 } = await encrypt(json, cek, aad);
-      const wrapped = await wrapCek(cek, key);
-      return { _iv: iv2, _data: data2, _cek: wrapped };
-    }
-    const { iv, data } = await encrypt(json, key, aad);
-    return { _iv: iv, _data: data };
-  }
-  async function verifyRecordIdentity(ref, env, key) {
-    if (!hasSealedBody(env)) return true;
-    try {
-      await openEnvelopeJson(ref, env, key);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  return { openEnvelopeJson, writeEnvelopeBody, verifyRecordIdentity };
-}
+} from "./chunk-ISIXU45J.js";
 
 // src/capsule/plumbing/sealed-slot.ts
 function parseSealedSlot(blob) {
@@ -153,97 +42,6 @@ function makeSealedSlot(p) {
   return { dualReadSealedSlot };
 }
 
-// src/capsule/plumbing/record-envelope.ts
-function buildRecordEnvelope(identity, body) {
-  return {
-    _noydb: NOYDB_FORMAT_VERSION,
-    _v: identity.version,
-    _ts: body.ts ?? (/* @__PURE__ */ new Date()).toISOString(),
-    _iv: body.iv,
-    _data: body.data,
-    ...identity.by !== void 0 ? { _by: identity.by } : {},
-    ...identity.tier !== void 0 && identity.tier > 0 ? { _tier: identity.tier } : {},
-    ...body.cek !== void 0 ? { _cek: body.cek } : {},
-    ...body.provenance !== void 0 ? { _source: body.provenance.source, _sourceTs: body.provenance.sourceTs } : {},
-    ...body.extra ?? {}
-  };
-}
-async function buildSealedRecordEnvelope(identity, seal, body) {
-  const sealed = await seal(identity);
-  const { iv, data } = requireSealedBody(sealed, "buildSealedRecordEnvelope");
-  return buildRecordEnvelope(identity, {
-    ...body,
-    iv,
-    data,
-    cek: sealed._cek
-  });
-}
-
-// src/capsule/plumbing/tombstone.ts
-function isTombstoneShape(envelope) {
-  return envelope._data === "" && envelope._cek === void 0 && envelope._del !== true;
-}
-function isTombstone(envelope, encrypted) {
-  if (!encrypted) return false;
-  return isTombstoneShape(envelope);
-}
-function buildTombstone(ref, version, actor) {
-  return buildRecordEnvelope(
-    { ...ref, version, ...actor ? { by: actor } : {} },
-    { iv: "", data: "" }
-  );
-}
-function isDeleteMarker(envelope) {
-  return envelope._del === true;
-}
-function buildDeleteMarker(ref, version, actor) {
-  return {
-    ...buildRecordEnvelope(
-      { ...ref, version, ...actor ? { by: actor } : {} },
-      { iv: "", data: "" }
-    ),
-    _del: true
-  };
-}
-
-// src/kernel/schema.ts
-async function validateSchemaInput(schema, value, context) {
-  const result = await schema["~standard"].validate(value);
-  if (result.issues !== void 0 && result.issues.length > 0) {
-    throw new SchemaValidationError(
-      `Schema validation failed on ${context}: ${summarizeIssues(result.issues)}`,
-      result.issues,
-      "input"
-    );
-  }
-  return result.value;
-}
-async function validateSchemaOutput(schema, value, context) {
-  const result = await schema["~standard"].validate(value);
-  if (result.issues !== void 0 && result.issues.length > 0) {
-    throw new SchemaValidationError(
-      `Stored data for ${context} does not match the current schema \u2014 schema drift? ${summarizeIssues(result.issues)}`,
-      result.issues,
-      "output"
-    );
-  }
-  return result.value;
-}
-function summarizeIssues(issues) {
-  const shown = issues.slice(0, 3).map((issue) => {
-    const pathStr = formatPath(issue.path);
-    return `${pathStr}: ${issue.message}`;
-  });
-  const suffix = issues.length > 3 ? ` (+${issues.length - 3} more)` : "";
-  return shown.join("; ") + suffix;
-}
-function formatPath(path) {
-  if (!path || path.length === 0) return "root";
-  return path.map(
-    (segment) => typeof segment === "object" && segment !== null ? String(segment.key) : String(segment)
-  ).join(".");
-}
-
 // src/capsule/plumbing/sealed-slots.ts
 function makeSealedSlots(p, sealedSlot) {
   const { decrypt, deriveSealedFieldKey, deriveSealedFieldKeyFromCek, encrypt } = p;
@@ -340,6 +138,51 @@ function makeSealedSlots(p, sealedSlot) {
   return { sealFields, unsealOneField, makeHandleProducer, unsealFields, makeSealedSlotCapability, makeReservedEnvelopes };
 }
 
+// src/capsule/plumbing/normalize.ts
+function normalizeForVerify(mode, value) {
+  const nfc = value.normalize("NFC");
+  if (mode === "password") return nfc;
+  return nfc.toLowerCase().normalize("NFC").trim().replace(/\s+/g, " ");
+}
+
+// src/kernel/schema.ts
+async function validateSchemaInput(schema, value, context) {
+  const result = await schema["~standard"].validate(value);
+  if (result.issues !== void 0 && result.issues.length > 0) {
+    throw new SchemaValidationError(
+      `Schema validation failed on ${context}: ${summarizeIssues(result.issues)}`,
+      result.issues,
+      "input"
+    );
+  }
+  return result.value;
+}
+async function validateSchemaOutput(schema, value, context) {
+  const result = await schema["~standard"].validate(value);
+  if (result.issues !== void 0 && result.issues.length > 0) {
+    throw new SchemaValidationError(
+      `Stored data for ${context} does not match the current schema \u2014 schema drift? ${summarizeIssues(result.issues)}`,
+      result.issues,
+      "output"
+    );
+  }
+  return result.value;
+}
+function summarizeIssues(issues) {
+  const shown = issues.slice(0, 3).map((issue) => {
+    const pathStr = formatPath(issue.path);
+    return `${pathStr}: ${issue.message}`;
+  });
+  const suffix = issues.length > 3 ? ` (+${issues.length - 3} more)` : "";
+  return shown.join("; ") + suffix;
+}
+function formatPath(path) {
+  if (!path || path.length === 0) return "root";
+  return path.map(
+    (segment) => typeof segment === "object" && segment !== null ? String(segment.key) : String(segment)
+  ).join(".");
+}
+
 // src/capsule/plumbing/record-codec.ts
 var RecordCodecBase = class _RecordCodecBase {
   constructor(caps, ctx) {
@@ -1123,9 +966,9 @@ function makeRekeyBlob(p) {
 
 // src/capsule/plumbing/sealing.ts
 function makeSealing(p, sealedSlot) {
-  const { openVdigPayload, sealVdigPayload, bufferToBase64, decrypt, deriveSealedFieldKeyFromCek, encrypt, generateDEK, unwrapCek, wrapCek } = p;
+  const { openVdigPayload, sealVdigPayload, bufferToBase64: bufferToBase642, decrypt, deriveSealedFieldKeyFromCek, encrypt, generateDEK, unwrapCek, wrapCek } = p;
   const { dualReadSealedSlot } = sealedSlot;
-  const subtle = globalThis.crypto.subtle;
+  const subtle3 = globalThis.crypto.subtle;
   const SEALED_CEK_NS = "_sealed_cek";
   async function sealRecordToHost(ctx, collection, id, hostSealer, opts) {
     if (collection.includes("/")) throw new ValidationError(`sealRecordToHost: collection "${collection}" must not contain "/"`);
@@ -1139,8 +982,8 @@ function makeSealing(p, sealedSlot) {
     }
     const dek = await ctx.getDEK(collection);
     const cek = await unwrapCek(live._cek, dek);
-    const rawCek = await subtle.exportKey("raw", cek);
-    const cekB64 = bufferToBase64(rawCek);
+    const rawCek = await subtle3.exportKey("raw", cek);
+    const cekB64 = bufferToBase642(rawCek);
     const hint = await hostSealer.publishRecipientHint();
     if (hint.pid.includes("/")) throw new ValidationError(`sealRecordToHost: recipient pid "${hint.pid}" must not contain "/"`);
     const binding = {
@@ -1157,7 +1000,7 @@ function makeSealing(p, sealedSlot) {
       v: 1,
       _noydb_sealed_cek: 1,
       pid: hint.pid,
-      payload: bufferToBase64(sealed),
+      payload: bufferToBase642(sealed),
       expiresAt: opts.expiresAt
     };
     const envelopeKey = `${collection}/${id}/${hint.pid}`;
@@ -1325,7 +1168,17 @@ function makeCapsule(p) {
   const envelopeBody = makeEnvelopeBody(p);
   const sealedSlots = makeSealedSlots(p, sealedSlot);
   const codec = makeRecordCodec(p, sealedSlots);
+  const classify = {
+    pbkdf2VerifyDigest: p.pbkdf2VerifyDigest,
+    blindedEqual: p.blindedEqual,
+    openVdigPayload: p.openVdigPayload,
+    dualReadSealedSlot: sealedSlot.dualReadSealedSlot
+  };
   return {
+    revealSealedField: (ctx, id, field) => import("./classify-reveal-YSJKJEIR.js").then((m) => m.revealSealedField(classify, ctx, id, field)),
+    verifyDigestField: (ctx, id, field, candidate, policy) => import("./classify-verify-ZCTKYQ43.js").then((m) => m.verifyDigestField(classify, ctx, id, field, candidate, policy)),
+    verifyTextField: (ctx, id, field, candidate, normalize) => import("./classify-verify-ZCTKYQ43.js").then((m) => m.verifyTextField(classify, ctx, id, field, candidate, normalize)),
+    matchGroupFields: (ctx, id, answers, members, opts) => import("./classify-verify-ZCTKYQ43.js").then((m) => m.matchGroupFields(classify, ctx, id, answers, members, opts)),
     ...envelopeBody,
     ...sealedSlot,
     ...sealedSlots,
@@ -1338,6 +1191,161 @@ function makeCapsule(p) {
   };
 }
 
+// src/capsule/plumbing/digest.ts
+var subtle = globalThis.crypto.subtle;
+var KEY_BITS = 256;
+var SALT_BYTES = 32;
+var IV_BYTES = 12;
+var RECOVERY_SECRET_BYTES = 32;
+var PRESENCE_TAG_KEY_DOMAIN = "noydb.presence.tag.v1";
+var ECHO_KDF_CONTEXT = new Uint8Array([255, ...new TextEncoder().encode("noydb-echo-secret-v1")]);
+function encodeEchoParts(parts) {
+  for (const name of ["prompt", "echo", "key"]) {
+    if (typeof parts?.[name] !== "string") {
+      throw new ValidationError("echo secret parts must be three strings: prompt, echo, key");
+    }
+  }
+  const enc = new TextEncoder();
+  const segments = [parts.prompt, parts.echo, parts.key].map((p) => enc.encode(p));
+  const total = ECHO_KDF_CONTEXT.length + segments.reduce((n, s) => n + 4 + s.length, 0);
+  const out = new Uint8Array(total);
+  out.set(ECHO_KDF_CONTEXT, 0);
+  let offset = ECHO_KDF_CONTEXT.length;
+  for (const s of segments) {
+    new DataView(out.buffer).setUint32(offset, s.length, false);
+    out.set(s, offset + 4);
+    offset += 4 + s.length;
+  }
+  return out;
+}
+async function sha256Hex(data) {
+  const hash = await subtle.digest("SHA-256", data);
+  return Array.from(new Uint8Array(hash)).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+async function sha256Bytes(data) {
+  return new Uint8Array(await subtle.digest("SHA-256", data));
+}
+async function deriveBlobAddressKey(root, tier) {
+  const rawRoot = await subtle.exportKey("raw", root);
+  const hkdfKey = await subtle.importKey("raw", rawRoot, "HKDF", false, ["deriveBits"]);
+  const salt = new TextEncoder().encode("noydb-blob-address");
+  const info = new TextEncoder().encode(`tier:${tier}`);
+  const bits = await subtle.deriveBits({ name: "HKDF", hash: "SHA-256", salt, info }, hkdfKey, KEY_BITS);
+  return subtle.importKey("raw", bits, { name: "AES-GCM" }, true, ["encrypt", "decrypt"]);
+}
+async function hmacSha256Hex(key, data) {
+  const rawKey = await subtle.exportKey("raw", key);
+  const hmacKey = await subtle.importKey(
+    "raw",
+    rawKey,
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  const sig = await subtle.sign("HMAC", hmacKey, data);
+  return Array.from(new Uint8Array(sig)).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+async function derivePresenceKey(dek, collectionName) {
+  const rawDek = await subtle.exportKey("raw", dek);
+  const hkdfKey = await subtle.importKey(
+    "raw",
+    rawDek,
+    "HKDF",
+    false,
+    ["deriveBits"]
+  );
+  const salt = new TextEncoder().encode("noydb-presence");
+  const info = new TextEncoder().encode(collectionName);
+  const bits = await subtle.deriveBits(
+    { name: "HKDF", hash: "SHA-256", salt, info },
+    hkdfKey,
+    KEY_BITS
+  );
+  return subtle.importKey(
+    "raw",
+    bits,
+    { name: "AES-GCM", length: KEY_BITS },
+    false,
+    ["encrypt", "decrypt"]
+  );
+}
+async function derivePresenceTagKey(dek, collectionName) {
+  const rawDek = await subtle.exportKey("raw", dek);
+  const hkdfKey = await subtle.importKey("raw", rawDek, "HKDF", false, ["deriveBits"]);
+  const salt = new TextEncoder().encode(PRESENCE_TAG_KEY_DOMAIN);
+  const info = new TextEncoder().encode(collectionName);
+  const bits = await subtle.deriveBits({ name: "HKDF", hash: "SHA-256", salt, info }, hkdfKey, KEY_BITS);
+  return subtle.importKey("raw", bits, { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
+}
+async function hmacSignHex(key, data) {
+  const sig = await subtle.sign("HMAC", key, data);
+  return Array.from(new Uint8Array(sig)).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+async function hkdfAesGcmKey(ikm, salt, info) {
+  const key = await subtle.importKey("raw", ikm, "HKDF", false, ["deriveKey"]);
+  return subtle.deriveKey(
+    { name: "HKDF", hash: "SHA-256", salt, info },
+    key,
+    { name: "AES-GCM", length: KEY_BITS },
+    false,
+    ["encrypt", "decrypt"]
+  );
+}
+function generateIV() {
+  return globalThis.crypto.getRandomValues(new Uint8Array(IV_BYTES));
+}
+function generateSalt() {
+  return globalThis.crypto.getRandomValues(new Uint8Array(SALT_BYTES));
+}
+function generateRecoverySecret() {
+  return globalThis.crypto.getRandomValues(new Uint8Array(RECOVERY_SECRET_BYTES));
+}
+function bufferToBase64(buffer) {
+  const bytes = buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer);
+  let binary = "";
+  for (let i = 0; i < bytes.length; i++) {
+    binary += String.fromCharCode(bytes[i]);
+  }
+  return btoa(binary);
+}
+function base64ToBuffer(base64) {
+  const binary = atob(base64);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
+}
+
+// src/capsule/plumbing/sign.ts
+var ALG = "Ed25519";
+var subtle2 = globalThis.crypto.subtle;
+function toB64url(bytes) {
+  return bufferToBase64(bytes).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function fromB64url(s) {
+  const pad = s.length % 4 === 0 ? "" : "=".repeat(4 - s.length % 4);
+  return base64ToBuffer(s.replace(/-/g, "+").replace(/_/g, "/") + pad);
+}
+async function generateSigningKeyPair() {
+  const kp = await subtle2.generateKey(ALG, true, ["sign", "verify"]);
+  const rawPub = new Uint8Array(await subtle2.exportKey("raw", kp.publicKey));
+  const pkcs8 = new Uint8Array(await subtle2.exportKey("pkcs8", kp.privateKey));
+  return { publicKeyB64: toB64url(rawPub), privateKeyPkcs8B64: toB64url(pkcs8) };
+}
+async function signBytes(privateKeyPkcs8B64, message) {
+  const key = await subtle2.importKey("pkcs8", fromB64url(privateKeyPkcs8B64), ALG, false, ["sign"]);
+  return toB64url(new Uint8Array(await subtle2.sign(ALG, key, message)));
+}
+async function verifyBytes(publicKeyB64, sigB64url, message) {
+  try {
+    const key = await subtle2.importKey("raw", fromB64url(publicKeyB64), ALG, false, ["verify"]);
+    return await subtle2.verify(ALG, key, fromB64url(sigB64url), message);
+  } catch {
+    return false;
+  }
+}
+
 // src/capsule/plumbing/ct-equal.ts
 function ctEqualTags(a, b) {
   if (a.length !== 32 || b.length !== 32) {
@@ -1350,26 +1358,104 @@ function ctEqualTags(a, b) {
   return diff === 0;
 }
 
+// src/capsule/plumbing/kofn.ts
+function evaluateKofN(results, min) {
+  if (!Number.isInteger(min) || min < 1 || min > results.length) {
+    throw new Error(
+      `evaluateKofN: min ${min} out of range 1..${results.length} \u2014 caller bug (matchGroup validates bounds up front, before any PBKDF2)`
+    );
+  }
+  let count = 0;
+  for (const r of results) {
+    if (r) count += 1;
+  }
+  return count >= min;
+}
+
+// src/capsule/contract.ts
+var PRIMITIVE_GROUPS = {
+  // ─── cipher: the capsule's actual encryption ────────────────────────
+  encrypt: "cipher",
+  decrypt: "cipher",
+  encryptBytesWithAAD: "cipher",
+  decryptBytesWithAAD: "cipher",
+  generateDEK: "cipher",
+  // ─── codec: encoding, identical for every capsule ───────────────────
+  bufferToBase64: "codec",
+  // ─── sealing: per-field key derivation ──────────────────────────────
+  deriveSealedFieldKey: "sealing",
+  deriveSealedFieldKeyFromCek: "sealing",
+  // ─── deterministic: equality search needs a key ─────────────────────
+  encryptDeterministic: "deterministic",
+  deriveDeterministicKey: "deterministic",
+  // ─── per-record keys: the CEK lifecycle ─────────────────────────────
+  wrapCek: "per-record-keys",
+  unwrapCek: "per-record-keys",
+  // ─── classify: the verify/blind-index group ─────────────────────────
+  mintVdigSlot: "classify",
+  mintBidxTag: "classify",
+  openVdigPayload: "classify",
+  sealVdigPayload: "classify",
+  pbkdf2VerifyDigest: "classify",
+  blindedEqual: "classify"
+};
+var GROUPS_WITHOUT_PRIMITIVES = {
+  authenticate: "posture group \u2014 asserted from the enclave-/exclave- package name, not from a primitive",
+  seal: "posture group \u2014 asserted from the enclave-/exclave- package name, not from a primitive",
+  digest: "plumbing \u2014 plumbing/digest.ts is shared verbatim; hashes are not secrets",
+  sign: "plumbing \u2014 plumbing/sign.ts is shared verbatim"
+};
+var PRIMITIVES_NOT_ON_THE_DOOR = ["mintVdigSlot", "openVdigPayload", "sealVdigPayload"];
+function assertCapsuleSupports(caps, group, requirer) {
+  if (!caps.has(group)) throw new CapsuleNotSupportedError(group, requirer);
+}
+var CapsuleNotSupportedError = class extends NoydbError {
+  constructor(group, requirer) {
+    super(
+      "CAPSULE_NOT_SUPPORTED",
+      `Capsule does not support the "${group}" group, which "${requirer}" requires. A capsule declares its groups at build time: "authenticate" and "seal" are the POSTURE groups an exclave refuses by design, and the shipped exclave also refuses "per-record-keys", "deterministic", "sealing" and "classify" \u2014 six in all, declaring only cipher/digest/sign/codec. Check capabilities(), and either drop what needs this group or bind a capsule that has it.`
+    );
+    this.group = group;
+    this.requirer = requirer;
+    this.name = "CapsuleNotSupportedError";
+  }
+  group;
+  requirer;
+};
+var VDIG_ITERATIONS = 6e5;
+
 export {
-  buildRecordAad,
-  recordAadFor,
-  requireSealedBody,
-  sealedBodyArgs,
-  envelopeBodySize,
-  hasPerRecordKey,
-  envelopeBodyForHash,
-  hasSealedBody,
   parseSealedSlot,
-  buildRecordEnvelope,
-  buildSealedRecordEnvelope,
-  isTombstoneShape,
-  isTombstone,
-  buildTombstone,
-  isDeleteMarker,
-  buildDeleteMarker,
+  normalizeForVerify,
   validateSchemaInput,
   validateSchemaOutput,
+  KEY_BITS,
+  IV_BYTES,
+  encodeEchoParts,
+  sha256Hex,
+  sha256Bytes,
+  deriveBlobAddressKey,
+  hmacSha256Hex,
+  derivePresenceKey,
+  derivePresenceTagKey,
+  hmacSignHex,
+  hkdfAesGcmKey,
+  generateIV,
+  generateSalt,
+  generateRecoverySecret,
+  bufferToBase64,
+  base64ToBuffer,
+  evaluateKofN,
   makeCapsule,
-  ctEqualTags
+  generateSigningKeyPair,
+  signBytes,
+  verifyBytes,
+  ctEqualTags,
+  PRIMITIVE_GROUPS,
+  GROUPS_WITHOUT_PRIMITIVES,
+  PRIMITIVES_NOT_ON_THE_DOOR,
+  assertCapsuleSupports,
+  CapsuleNotSupportedError,
+  VDIG_ITERATIONS
 };
-//# sourceMappingURL=chunk-HTRLQ4ZZ.js.map
+//# sourceMappingURL=chunk-I4S7IZSS.js.map