@byok-sdk/core 0.30.0 → 0.30.2

package/dist/sealed-payload/index.d.ts

@@ -10,11 +10,13 @@
 export { SEALED_CATEGORIES, SEALED_CONTENT_SUITE, SEALED_CONTENT_VERSION, SEALED_DIRECTIONS, SealedContentHeaderV1Schema, openSealedContent, sealContent, } from './sealed-content';
 export type { OpenSealedContentInput, SealContentInput, SealedBinding, SealedCategory, SealedContent, SealedContentHeaderV1, SealedContentOpenFailure, SealedContentOpenResult, SealedDirection, SealedScopePolicy, } from './sealed-content';
 export { deriveScopeKeyId, generateScopeKey, openScopeKeyPackage, sealScopeKeyPackage } from './scope-key';
-export type { OpenScopeKeyPackageInput, ScopeKeyPackageOpenResult, ScopeKeyPackageV1, SealScopeKeyPackageInput, } from './scope-key';
+export type { OpenScopeKeyPackageInput, ScopeKeyPackage, ScopeKeyPackageOpenResult, ScopeKeyPackageV1, ScopeKeyPackageV2, SealScopeKeyPackageInput, } from './scope-key';
 export { MEMBER_CHAIN_OPS, deriveMemberId, memberChainEntryHash, signMemberChainEntry, verifyMemberChainEntry, } from './member-chain';
 export type { MemberChainEntryV1, MemberChainEntryVerifyResult, MemberChainOp, UnsignedMemberChainEntryV1, } from './member-chain';
 export { MEMBER_KEY_BUNDLE_VERSION, createMemberKeyBundle, parseMemberKeyBundle, verifyMemberKem } from './member-bundle';
 export type { CreateMemberKeyBundleInput, MemberKeyBundleV1 } from './member-bundle';
+export { beginMemberKemRotation, finishMemberKemRotation, generateMemberKeyRecord, openMemberKeyRecord, } from './member-key-record';
+export type { MemberKemKey, MemberKeyBinding, MemberKeyStore, MemberKeys } from './member-key-record';
 export { MEMBER_FINGERPRINT_DOMAIN, memberApprovalCode, memberFingerprint } from './member-fingerprint';
 export type { MemberFingerprintInput } from './member-fingerprint';
 export { CLIENT_PAIRING_MAC_DOMAIN, DEVICE_PAIRING_MAC_DOMAIN, PAIRING_VERIFICATION_SECRET_BYTES, computeClientPairingMac, computeDevicePairingMac, decodePairingVerificationSecret, encodePairingVerificationSecret, formatPairingInput, generatePairingVerificationSecret, parsePairingInput, verifyClientPairingMac, verifyDevicePairingMac, } from './pairing-verification';

package/dist/sealed-payload/index.js

@@ -679,6 +679,87 @@ async function verifyMemberChainEntry(entry, signerPublicJwk) {
   }
   return { ok: true, entry: parsed.data, hash: `sha256:${hex(await sha256(input))}` };
 }
+var MEMBER_KEY_BUNDLE_VERSION = 1;
+var MEMBER_KEM_DOMAIN_PREFIX = "byok-member-kem-v1\n";
+var KemEpochSchema = z.number().int().positive().max(Number.MAX_SAFE_INTEGER);
+var KemSigSchema = base64UrlBytes(64);
+var MemberKeyBundleV1Schema = z.strictObject({
+  v: z.literal(MEMBER_KEY_BUNDLE_VERSION),
+  memberId: z.string().regex(MEMBER_ID_PATTERN),
+  signingPublicJwk: P256PublicJwkSchema,
+  kemPublicJwk: P256PublicJwkSchema,
+  kemEpoch: KemEpochSchema,
+  kemSig: KemSigSchema,
+  deviceId: z.string().min(1).optional()
+});
+var CreateInputSchema = z.object({
+  signingPublicJwk: P256PublicJwkSchema,
+  signingPrivateKey: z.custom(),
+  kemPublicJwk: P256PublicJwkSchema,
+  kemEpoch: KemEpochSchema,
+  deviceId: z.string().min(1).optional()
+});
+var KemSignerSchema = z.object({ memberId: z.string().regex(MEMBER_ID_PATTERN), signingPublicJwk: P256PublicJwkSchema });
+var KemStatementSchema = z.object({ kemPublicJwk: P256PublicJwkSchema, kemEpoch: KemEpochSchema, kemSig: KemSigSchema });
+function memberKemSigningInput(memberId, kemPublicJwk, kemEpoch) {
+  return concat2(
+    utf82(MEMBER_KEM_DOMAIN_PREFIX),
+    canonicalizeJsonBytes({ memberId, kemPublicKey: { x: kemPublicJwk.x, y: kemPublicJwk.y }, kemEpoch })
+  );
+}
+async function createMemberKeyBundle(input) {
+  const parsed = safeParseTotal(CreateInputSchema, input);
+  if (!parsed.success) throw invalidInput("Member key bundle input is invalid");
+  const { signingPublicJwk, signingPrivateKey, kemPublicJwk, kemEpoch, deviceId } = parsed.data;
+  const memberId = await deriveMemberId(signingPublicJwk);
+  if (!await isValidMemberKemKey(kemPublicJwk, signingPublicJwk)) throw invalidInput("Member KEM key is invalid");
+  const kemSig = await ecdsaSign(signingPublicJwk, signingPrivateKey, memberKemSigningInput(memberId, kemPublicJwk, kemEpoch));
+  return {
+    v: MEMBER_KEY_BUNDLE_VERSION,
+    memberId,
+    signingPublicJwk,
+    kemPublicJwk,
+    kemEpoch,
+    kemSig,
+    ...deviceId === void 0 ? {} : { deviceId }
+  };
+}
+async function isValidMemberKemKey(kemPublicJwk, signingPublicJwk) {
+  if (kemPublicJwk.x === signingPublicJwk.x && kemPublicJwk.y === signingPublicJwk.y) return false;
+  try {
+    await p256PublicKeyBytes(kemPublicJwk);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function verifyMemberKem(member, kem) {
+  const signer = safeParseTotal(KemSignerSchema, member);
+  const statement = safeParseTotal(KemStatementSchema, kem);
+  if (!signer.success || !statement.success) return false;
+  const { memberId, signingPublicJwk } = signer.data;
+  const { kemPublicJwk, kemEpoch, kemSig } = statement.data;
+  if (!await isValidMemberKemKey(kemPublicJwk, signingPublicJwk)) return false;
+  try {
+    return await ecdsaVerify(signingPublicJwk, kemSig, memberKemSigningInput(memberId, kemPublicJwk, kemEpoch));
+  } catch {
+    return false;
+  }
+}
+async function parseMemberKeyBundle(value) {
+  const parsed = safeParseTotal(MemberKeyBundleV1Schema, value);
+  if (!parsed.success) return void 0;
+  const bundle = parsed.data;
+  try {
+    if (await deriveMemberId(bundle.signingPublicJwk) !== bundle.memberId) return void 0;
+  } catch {
+    return void 0;
+  }
+  if (!await verifyMemberKem(bundle, bundle)) return void 0;
+  return bundle;
+}
+
+// src/sealed-payload/scope-key.ts
 var SCOPE_KEY_BYTES = 32;
 var SCOPE_KEY_ID_PATTERN = /^[A-Za-z0-9_-]{22}$/u;
 var KEY_ID_MESSAGE = "byok-scope-key-id-v1";
@@ -688,6 +769,9 @@ var SEALED_SALT_BYTES = 32;
 var SCOPE_KEY_PACKAGE_VERSION = 1;
 var SCOPE_KEY_HPKE_INFO = "byok-sdk.scope-key.v1";
 var SCOPE_KEY_PACKAGE_DOMAIN_PREFIX = "byok-scope-key-package-v1\n";
+var SCOPE_KEY_PACKAGE_V2 = 2;
+var SCOPE_KEY_HPKE_INFO_V2 = "byok-sdk.scope-key.v2";
+var SCOPE_KEY_PACKAGE_V2_DOMAIN_PREFIX = "byok-scope-key-package-v2\n";
 var P256_POINT_BYTES = 65;
 var AEAD_TAG_BYTES = 16;
 function assertScopeKey(scopeKey) {
@@ -722,49 +806,35 @@ var ScopeKeyPackageV1Schema = z.strictObject({
   ciphertext: base64UrlBytes(SCOPE_KEY_BYTES + AEAD_TAG_BYTES),
   sig: base64UrlBytes(64)
 });
-function packageAad(identity) {
-  return canonicalizeJsonBytes({
-    v: identity.v,
-    tenantId: identity.tenantId,
-    scopeId: identity.scopeId,
-    epoch: identity.epoch,
-    keyId: identity.keyId,
-    recipient: identity.recipient,
-    sender: identity.sender
-  });
+var ScopeKeyPackageV2Schema = z.strictObject({
+  ...ScopeKeyPackageV1Schema.shape,
+  v: z.literal(SCOPE_KEY_PACKAGE_V2),
+  recipientKemEpoch: KemEpochSchema
+});
+var ScopeKeyPackageSchema = z.union([ScopeKeyPackageV1Schema, ScopeKeyPackageV2Schema]);
+function packageAad({ enc: _enc, ciphertext: _ciphertext, sig: _sig, ...identity }) {
+  return canonicalizeJsonBytes(identity);
 }
-function packageSigningInput(pkg) {
-  return concat2(
-    utf82(SCOPE_KEY_PACKAGE_DOMAIN_PREFIX),
-    canonicalizeJsonBytes({
-      v: pkg.v,
-      tenantId: pkg.tenantId,
-      scopeId: pkg.scopeId,
-      epoch: pkg.epoch,
-      keyId: pkg.keyId,
-      recipient: pkg.recipient,
-      sender: pkg.sender,
-      enc: pkg.enc,
-      ciphertext: pkg.ciphertext
-    })
-  );
+function packageSigningInput({ sig: _sig, ...pkg }) {
+  return concat2(utf82(pkg.v === SCOPE_KEY_PACKAGE_V2 ? SCOPE_KEY_PACKAGE_V2_DOMAIN_PREFIX : SCOPE_KEY_PACKAGE_DOMAIN_PREFIX), canonicalizeJsonBytes(pkg));
 }
-var PackageIdentitySchema = ScopeKeyPackageV1Schema.omit({ enc: true, ciphertext: true, sig: true });
+var PackageIdentitySchema = ScopeKeyPackageV2Schema.omit({ enc: true, ciphertext: true, sig: true });
 async function sealScopeKeyPackage(input) {
   const parsed = safeParseTotal(PackageIdentitySchema, {
-    v: SCOPE_KEY_PACKAGE_VERSION,
+    v: SCOPE_KEY_PACKAGE_V2,
     tenantId: input.tenantId,
     scopeId: input.scopeId,
     epoch: input.epoch,
     keyId: await deriveScopeKeyId(input.scopeKey),
     recipient: input.recipient.memberId,
+    recipientKemEpoch: input.recipient.kemEpoch,
     sender: await deriveMemberId(input.sender.signingPublicJwk)
   });
   if (!parsed.success) throw invalidInput("Scope key package input is invalid");
   const identity = parsed.data;
   const { enc, ciphertext } = await hpkeSealBase({
     recipientPublicKey: await p256PublicKeyBytes(input.recipient.kemPublicJwk),
-    info: utf82(SCOPE_KEY_HPKE_INFO),
+    info: utf82(SCOPE_KEY_HPKE_INFO_V2),
     aad: packageAad(identity),
     plaintext: input.scopeKey
   });
@@ -772,10 +842,10 @@ async function sealScopeKeyPackage(input) {
   return { ...unsigned, sig: await ecdsaSign(input.sender.signingPublicJwk, input.sender.signingPrivateKey, packageSigningInput(unsigned)) };
 }
 async function openScopeKeyPackage(input) {
-  const parsed = safeParseTotal(ScopeKeyPackageV1Schema, input.package);
+  const parsed = safeParseTotal(ScopeKeyPackageSchema, input.package);
   if (!parsed.success) return { ok: false, reason: "key_package_invalid" };
   const pkg = parsed.data;
-  if (pkg.recipient !== input.recipient.memberId || pkg.tenantId !== input.expected.tenantId || pkg.scopeId !== input.expected.scopeId || pkg.epoch !== input.expected.epoch || pkg.sender !== await deriveMemberId(input.senderSigningPublicJwk)) {
+  if (pkg.recipient !== input.recipient.memberId || pkg.v === SCOPE_KEY_PACKAGE_V2 && pkg.recipientKemEpoch !== input.recipient.kemEpoch || pkg.tenantId !== input.expected.tenantId || pkg.scopeId !== input.expected.scopeId || pkg.epoch !== input.expected.epoch || pkg.sender !== await deriveMemberId(input.senderSigningPublicJwk)) {
     return { ok: false, reason: "key_package_invalid" };
   }
   if (!await ecdsaVerify(input.senderSigningPublicJwk, pkg.sig, packageSigningInput(pkg))) {
@@ -787,7 +857,7 @@ async function openScopeKeyPackage(input) {
       recipientPrivateKey: input.recipient.kemPrivateKey,
       recipientPublicKey: await p256PublicKeyBytes(input.recipient.kemPublicJwk),
       enc: decodeBase64Url(pkg.enc, "enc"),
-      info: utf82(SCOPE_KEY_HPKE_INFO),
+      info: utf82(pkg.v === SCOPE_KEY_PACKAGE_V2 ? SCOPE_KEY_HPKE_INFO_V2 : SCOPE_KEY_HPKE_INFO),
       aad: packageAad(pkg),
       ciphertext: decodeBase64Url(pkg.ciphertext, "ciphertext")
     });
@@ -1086,84 +1156,114 @@ async function openSealedContent(input) {
     frame.fill(0);
   }
 }
-var MEMBER_KEY_BUNDLE_VERSION = 1;
-var MEMBER_KEM_DOMAIN_PREFIX = "byok-member-kem-v1\n";
-var KemEpochSchema = z.number().int().positive().max(Number.MAX_SAFE_INTEGER);
-var KemSigSchema = base64UrlBytes(64);
-var MemberKeyBundleV1Schema = z.strictObject({
-  v: z.literal(MEMBER_KEY_BUNDLE_VERSION),
-  memberId: z.string().regex(MEMBER_ID_PATTERN),
-  signingPublicJwk: P256PublicJwkSchema,
-  kemPublicJwk: P256PublicJwkSchema,
-  kemEpoch: KemEpochSchema,
-  kemSig: KemSigSchema,
-  deviceId: z.string().min(1).optional()
-});
-var CreateInputSchema = z.object({
-  signingPublicJwk: P256PublicJwkSchema,
-  signingPrivateKey: z.custom(),
-  kemPublicJwk: P256PublicJwkSchema,
-  kemEpoch: KemEpochSchema,
-  deviceId: z.string().min(1).optional()
+var MEMBER_KEY_RECORD_VERSION = 1;
+var PrivateJwkSchema = z.strictObject({
+  kty: z.literal("EC"),
+  crv: z.literal("P-256"),
+  x: base64UrlBytes(32),
+  y: base64UrlBytes(32),
+  d: base64UrlBytes(32)
 });
-var KemSignerSchema = z.object({ memberId: z.string().regex(MEMBER_ID_PATTERN), signingPublicJwk: P256PublicJwkSchema });
-var KemStatementSchema = z.object({ kemPublicJwk: P256PublicJwkSchema, kemEpoch: KemEpochSchema, kemSig: KemSigSchema });
-function memberKemSigningInput(memberId, kemPublicJwk, kemEpoch) {
-  return concat2(
-    utf82(MEMBER_KEM_DOMAIN_PREFIX),
-    canonicalizeJsonBytes({ memberId, kemPublicKey: { x: kemPublicJwk.x, y: kemPublicJwk.y }, kemEpoch })
-  );
+var KemEpochSchema2 = z.number().int().positive().max(Number.MAX_SAFE_INTEGER);
+var MemberKeyRecordV1Schema = z.strictObject({
+  v: z.literal(MEMBER_KEY_RECORD_VERSION),
+  tenantId: z.string().min(1),
+  deviceId: z.string().min(1).optional(),
+  signingJwk: PrivateJwkSchema,
+  kemEpoch: KemEpochSchema2,
+  kemJwk: PrivateJwkSchema,
+  nextKem: z.strictObject({ epoch: KemEpochSchema2, jwk: PrivateJwkSchema }).optional()
+}).refine((record) => record.nextKem === void 0 || record.nextKem.epoch === record.kemEpoch + 1);
+var BindingSchema = z.object({ tenantId: z.string().min(1), deviceId: z.string().min(1).optional() });
+function keySubtle() {
+  return webCryptoSubtle();
 }
-async function createMemberKeyBundle(input) {
-  const parsed = safeParseTotal(CreateInputSchema, input);
-  if (!parsed.success) throw invalidInput("Member key bundle input is invalid");
-  const { signingPublicJwk, signingPrivateKey, kemPublicJwk, kemEpoch, deviceId } = parsed.data;
-  const memberId = await deriveMemberId(signingPublicJwk);
-  if (!await isValidMemberKemKey(kemPublicJwk, signingPublicJwk)) throw invalidInput("Member KEM key is invalid");
-  const kemSig = await ecdsaSign(signingPublicJwk, signingPrivateKey, memberKemSigningInput(memberId, kemPublicJwk, kemEpoch));
-  return {
-    v: MEMBER_KEY_BUNDLE_VERSION,
-    memberId,
-    signingPublicJwk,
-    kemPublicJwk,
-    kemEpoch,
-    kemSig,
-    ...deviceId === void 0 ? {} : { deviceId }
-  };
+var ECDSA_P2562 = { name: "ECDSA", namedCurve: "P-256" };
+var ECDSA_SHA2562 = { name: "ECDSA", hash: "SHA-256" };
+var ECDH_P256 = { name: "ECDH", namedCurve: "P-256" };
+async function generatePrivateJwk(algorithm, usages) {
+  const pair = await keySubtle().generateKey(algorithm, true, usages);
+  const { kty, crv, x, y, d } = await keySubtle().exportKey("jwk", pair.privateKey);
+  return PrivateJwkSchema.parse({ kty, crv, x, y, d });
+}
+async function generateMemberKeyRecord(binding) {
+  const parsed = safeParseTotal(BindingSchema, binding);
+  if (!parsed.success) throw invalidInput("Member key binding is invalid");
+  const { tenantId, deviceId } = parsed.data;
+  return canonicalizeJson({
+    v: MEMBER_KEY_RECORD_VERSION,
+    tenantId,
+    ...deviceId === void 0 ? {} : { deviceId },
+    signingJwk: await generatePrivateJwk(ECDSA_P2562, ["sign", "verify"]),
+    kemEpoch: 1,
+    kemJwk: await generatePrivateJwk(ECDH_P256, ["deriveBits"])
+  });
 }
-async function isValidMemberKemKey(kemPublicJwk, signingPublicJwk) {
-  if (kemPublicJwk.x === signingPublicJwk.x && kemPublicJwk.y === signingPublicJwk.y) return false;
+function publicJwkOf(jwk) {
+  return P256PublicJwkSchema.parse({ kty: jwk.kty, crv: jwk.crv, x: jwk.x, y: jwk.y });
+}
+function bytesEqual(left, right) {
+  const a = new Uint8Array(left);
+  const b = new Uint8Array(right);
+  return a.length === b.length && a.every((byte, index) => byte === b[index]);
+}
+async function importSigningKey(jwk) {
+  const subtle = keySubtle();
+  const publicJwk = publicJwkOf(jwk);
+  const privateKey = await subtle.importKey("jwk", { ...jwk, ext: false }, ECDSA_P2562, false, ["sign"]);
+  const publicKey = await subtle.importKey("jwk", publicJwk, ECDSA_P2562, true, ["verify"]);
+  const probe = randomBytes(32);
+  if (!await subtle.verify(ECDSA_SHA2562, publicKey, await subtle.sign(ECDSA_SHA2562, privateKey, probe), probe)) {
+    throw new TypeError("signing scalar does not match its public point");
+  }
+  return { publicJwk, privateKey };
+}
+async function importKemKey(jwk) {
+  const subtle = keySubtle();
+  const publicJwk = publicJwkOf(jwk);
+  const privateKey = await subtle.importKey("jwk", { ...jwk, ext: false }, ECDH_P256, false, ["deriveBits"]);
+  const publicKey = await subtle.importKey("jwk", publicJwk, ECDH_P256, true, []);
+  const probe = await subtle.generateKey(ECDH_P256, false, ["deriveBits"]);
+  const viaMember = await subtle.deriveBits({ name: "ECDH", public: probe.publicKey }, privateKey, 256);
+  const viaProbe = await subtle.deriveBits({ name: "ECDH", public: publicKey }, probe.privateKey, 256);
+  if (!bytesEqual(viaMember, viaProbe)) throw new TypeError("KEM scalar does not match its public point");
+  return { publicJwk, privateKey };
+}
+async function openMemberKeyRecord(text) {
+  const record = parseRecord(text);
+  if (record === void 0) return void 0;
   try {
-    await p256PublicKeyBytes(kemPublicJwk);
-    return true;
+    const signing = await importSigningKey(record.signingJwk);
+    const kem = { epoch: record.kemEpoch, ...await importKemKey(record.kemJwk) };
+    const binding = record.deviceId === void 0 ? { tenantId: record.tenantId } : { tenantId: record.tenantId, deviceId: record.deviceId };
+    if (record.nextKem === void 0) return { binding, signing, kem };
+    return { binding, signing, kem, nextKem: { epoch: record.nextKem.epoch, ...await importKemKey(record.nextKem.jwk) } };
   } catch {
-    return false;
+    return void 0;
   }
 }
-async function verifyMemberKem(member, kem) {
-  const signer = safeParseTotal(KemSignerSchema, member);
-  const statement = safeParseTotal(KemStatementSchema, kem);
-  if (!signer.success || !statement.success) return false;
-  const { memberId, signingPublicJwk } = signer.data;
-  const { kemPublicJwk, kemEpoch, kemSig } = statement.data;
-  if (!await isValidMemberKemKey(kemPublicJwk, signingPublicJwk)) return false;
-  try {
-    return await ecdsaVerify(signingPublicJwk, kemSig, memberKemSigningInput(memberId, kemPublicJwk, kemEpoch));
-  } catch {
-    return false;
-  }
+async function beginMemberKemRotation(text) {
+  const record = parseRecord(text);
+  if (record === void 0) throw invalidInput("Member key record is invalid");
+  if (record.nextKem !== void 0) return text;
+  return canonicalizeJson({ ...record, nextKem: { epoch: record.kemEpoch + 1, jwk: await generatePrivateJwk(ECDH_P256, ["deriveBits"]) } });
 }
-async function parseMemberKeyBundle(value) {
-  const parsed = safeParseTotal(MemberKeyBundleV1Schema, value);
-  if (!parsed.success) return void 0;
-  const bundle = parsed.data;
+function finishMemberKemRotation(text, epoch) {
+  const record = parseRecord(text);
+  if (record === void 0) throw invalidInput("Member key record is invalid");
+  if (record.nextKem === void 0) return record.kemEpoch === epoch ? text : void 0;
+  if (record.nextKem.epoch !== epoch) return void 0;
+  const { nextKem, ...rest } = record;
+  return canonicalizeJson({ ...rest, kemEpoch: nextKem.epoch, kemJwk: nextKem.jwk });
+}
+function parseRecord(text) {
+  if (typeof text !== "string") return void 0;
   try {
-    if (await deriveMemberId(bundle.signingPublicJwk) !== bundle.memberId) return void 0;
+    const parsed = safeParseTotal(MemberKeyRecordV1Schema, JSON.parse(text));
+    return parsed.success && canonicalizeJson(parsed.data) === text ? parsed.data : void 0;
   } catch {
     return void 0;
   }
-  if (!await verifyMemberKem(bundle, bundle)) return void 0;
-  return bundle;
 }
 var MEMBER_FINGERPRINT_DOMAIN = "byok-member-fingerprint-v1\n";
 var FINGERPRINT_GROUPS = 5;
@@ -1481,6 +1581,6 @@ async function verifyMemberChainFromAnchor(input) {
   return { ok: true, state: outcome.state, anchorSeq: anchor.seq };
 }
 
-export { CLIENT_PAIRING_MAC_DOMAIN, DEVICE_PAIRING_MAC_DOMAIN, MEMBER_CHAIN_OPS, MEMBER_FINGERPRINT_DOMAIN, MEMBER_KEY_BUNDLE_VERSION, PAIRING_VERIFICATION_SECRET_BYTES, SEALED_CATEGORIES, SEALED_CONTENT_SUITE, SEALED_CONTENT_VERSION, SEALED_DIRECTIONS, SealedContentHeaderV1Schema, applyMemberChainEntries, computeClientPairingMac, computeDevicePairingMac, createMemberKeyBundle, decodePairingVerificationSecret, deriveMemberId, deriveScopeKeyId, emptyMemberChainState, encodePairingVerificationSecret, formatPairingInput, generatePairingVerificationSecret, generateScopeKey, memberApprovalCode, memberChainEntryHash, memberChainScopeRecipients, memberFingerprint, openScopeKeyPackage, openSealedContent, parseMemberKeyBundle, parsePairingInput, sealContent, sealScopeKeyPackage, signMemberChainEntry, verifyClientPairingMac, verifyDevicePairingMac, verifyMemberChainEntry, verifyMemberChainFromAnchor, verifyMemberKem };
+export { CLIENT_PAIRING_MAC_DOMAIN, DEVICE_PAIRING_MAC_DOMAIN, MEMBER_CHAIN_OPS, MEMBER_FINGERPRINT_DOMAIN, MEMBER_KEY_BUNDLE_VERSION, PAIRING_VERIFICATION_SECRET_BYTES, SEALED_CATEGORIES, SEALED_CONTENT_SUITE, SEALED_CONTENT_VERSION, SEALED_DIRECTIONS, SealedContentHeaderV1Schema, applyMemberChainEntries, beginMemberKemRotation, computeClientPairingMac, computeDevicePairingMac, createMemberKeyBundle, decodePairingVerificationSecret, deriveMemberId, deriveScopeKeyId, emptyMemberChainState, encodePairingVerificationSecret, finishMemberKemRotation, formatPairingInput, generateMemberKeyRecord, generatePairingVerificationSecret, generateScopeKey, memberApprovalCode, memberChainEntryHash, memberChainScopeRecipients, memberFingerprint, openMemberKeyRecord, openScopeKeyPackage, openSealedContent, parseMemberKeyBundle, parsePairingInput, sealContent, sealScopeKeyPackage, signMemberChainEntry, verifyClientPairingMac, verifyDevicePairingMac, verifyMemberChainEntry, verifyMemberChainFromAnchor, verifyMemberKem };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map