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

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

@@ -16,24 +16,33 @@
  *
  * Internal service — not exported as a `@noy-db/hub/*` subpath.
  */
-import { type EnclaveKey } from '../crypto.js';
-import { type EncryptedEnvelope, type CrdtMode, type CrdtStrategy, type VdigFieldPolicy, type SealedHandle } from '../../types.js';
-import { type RecordIdentity, type RecordRef } from '../record-aad.js';
-import { type StandardSchemaV1 } from '../../schema.js';
-import type { Lru } from '../../cache/index.js';
-import type { ViaCryptoCtx } from '../../via/index.js';
-import type { ViaPipeline } from '../../via/pipeline.js';
+import { type EncryptedEnvelope, type CrdtMode, type CrdtStrategy, type VdigFieldPolicy, type SealedHandle } from '../../kernel/types.js';
+import { type RecordIdentity, type RecordRef } from './record-aad.js';
+import { type StandardSchemaV1 } from '../../kernel/schema.js';
+import type { Lru } from '../../kernel/cache/index.js';
+import type { ViaCryptoCtx } from '../../kernel/via/index.js';
+import type { ViaPipeline } from '../../kernel/via/pipeline.js';
 /**
- * One classified per-slot verdict from {@link RecordCodec.classifySealedShred}.
+ * One classified per-slot verdict from {@link RecordCodecBase.classifySealedShred}.
  * `shreddable` — CEK-only, tombstone makes it undecryptable. `dekResidue` —
  * collection-DEK-keyed, survives in synced/backup copies. The third class is
  * BOTH: a `_bidx` blind-index tag is live-dropped by the tombstone yet retained
  * under the surviving DEK in any pre-forget backup (honest dual accounting).
  */
+import type { CapsuleKey, CapsulePrimitives } from '../contract.js';
+import type { makeSealedSlots } from './sealed-slots.js';
 export type SealedShredSlot = {
     readonly field: string;
     readonly class: 'shreddable' | 'dekResidue' | 'live-shreddable+dekResidue-in-backups';
 };
+/**
+ * The record codec, bound to a capsule.
+ *
+ * ⚠️ `RecordCodec` is a CLASS declared inside this factory, so the NAME is no
+ * longer a module-level type. Hub names it in ~40 places as a type, which is
+ * why `plumbing/index.ts` re-exports an `InstanceType<…>` alias under the same
+ * name — the type keeps working unchanged for every existing consumer.
+ */
 /** Everything the moving crypto methods touched on `this.*`, as a flat context. */
 export interface RecordCodecContext<T> {
     /** Collection name — the crypto AAD scope and schema-error context. */
@@ -75,13 +84,13 @@ export interface RecordCodecContext<T> {
      * `_dict_status` collection) so a binding's at-rest hook can address a
      * different collection's DEK without ever holding the resolver itself.
      */
-    getDEK(collection?: string): Promise<EnclaveKey>;
+    getDEK(collection?: string): Promise<CapsuleKey>;
     /**
      * The collection's per-record CEK cache (SHARED reference, not a copy).
      * Ownership/lifetime stays on Collection; codec reads+writes it in
      * resolveEnvelopeCek exactly as the inline code did. `null` → no caching.
      */
-    readonly cekCache: Lru<string, EnclaveKey> | null;
+    readonly cekCache: Lru<string, CapsuleKey> | null;
     /**
      * Compiled Via pipeline (money, i18n, …), or undefined for a collection
      * with none declared. `encryptRecord`/`decryptRecord` consult
@@ -92,7 +101,7 @@ export interface RecordCodecContext<T> {
      *
      * Mutable (not `readonly`, #638 Task 3): `Collection.via` can be
      * reassigned post-construction (the taint overlay, `via/graph-wiring.ts#
-     * applyTaintOverlay`) — `RecordCodec.setVia` below keeps this in sync so
+     * applyTaintOverlay`) — `RecordCodecBase.setVia` below keeps this in sync so
      * at-rest hooks read the LIVE pipeline, not a stale construction-time
      * snapshot.
      */
@@ -110,9 +119,27 @@ export interface RecordCodecContext<T> {
      */
     readonly onDecrypt?: ((id: string) => void) | undefined;
 }
-export declare class RecordCodec<T> {
+/**
+ * The codec's capsule-provided surface: the 15 primitives + sealed-slot helpers
+ * its methods call.
+ */
+export type CapsuleBinding = CapsulePrimitives & ReturnType<typeof makeSealedSlots>;
+/**
+ * ⚠️ MODULE-LEVEL AND GENERIC ON PURPOSE. The obvious shape — declaring the
+ * class inside `makeRecordCodec` and exporting `InstanceType<…>` — compiles and
+ * silently DROPS `T`: `RecordCodec<Invoice>` degrades to `RecordCodec<unknown>`
+ * at the six places hub parameterises it, turning typed records into `unknown`
+ * with no error anywhere.
+ *
+ * The other way to keep `T` would be a hand-written `interface RecordCodec<T>`
+ * that the class implements — i.e. a second declaration of 15 signatures that
+ * nothing checks against the first. That is exactly the drift #16 was, so it
+ * was not done twice. A base class has one declaration and cannot drift.
+ */
+export declare class RecordCodecBase<T> {
+    protected readonly caps: CapsuleBinding;
     private readonly ctx;
-    constructor(ctx: RecordCodecContext<T>);
+    constructor(caps: CapsuleBinding, ctx: RecordCodecContext<T>);
     /**
      * @internal Update the live Via pipeline this codec's at-rest hooks read
      * (#638 Task 3) — called by `via/graph-wiring.ts#applyTaintOverlay` right
@@ -195,7 +222,7 @@ export declare class RecordCodec<T> {
      * the choice must be made before AAD is switched on, not inferred from this
      * migration.
      */
-    encryptJsonString(ref: RecordRef, json: string, version: number, cek?: EnclaveKey, source?: string, sourceTs?: string): Promise<EncryptedEnvelope>;
+    encryptJsonString(ref: RecordRef, json: string, version: number, cek?: CapsuleKey, source?: string, sourceTs?: string): Promise<EncryptedEnvelope>;
     /**
      * `ref` is FIRST and required (#1051). It was previously a trailing optional
      * `id?: string`, which TypeScript cannot promote to required because it sits
@@ -207,7 +234,7 @@ export declare class RecordCodec<T> {
      * compile on the hottest write path. Carries the collection too — see
      * {@link encryptJsonString} for why the codec must not assume its own.
      */
-    encryptRecord(ref: RecordRef, record: T, version: number, cek?: EnclaveKey, source?: string, sourceTs?: string, vdig?: {
+    encryptRecord(ref: RecordRef, record: T, version: number, cek?: CapsuleKey, source?: string, sourceTs?: string, vdig?: {
         readonly id: string;
         readonly prev: EncryptedEnvelope | null;
     }): Promise<EncryptedEnvelope>;
@@ -219,7 +246,7 @@ export declare class RecordCodec<T> {
      * ({@link decryptJsonString}) and the sealed-field path ({@link decryptRecord}
      * / {@link toCacheRecord}) so both agree on the record's key.
      */
-    resolveEnvelopeCek(envelope: EncryptedEnvelope, id?: string): Promise<EnclaveKey | undefined>;
+    resolveEnvelopeCek(envelope: EncryptedEnvelope, id?: string): Promise<CapsuleKey | undefined>;
     /**
      * Low-level: decrypt an envelope and return the raw JSON string.
      *
@@ -262,7 +289,7 @@ export declare class RecordCodec<T> {
      * {@link Sealed} handle's `reveal()` — so the on-demand reveal and the eager
      * materialisation always agree byte-for-byte.
      */
-    unsealField(field: string, blob: string, cek?: EnclaveKey): Promise<unknown>;
+    unsealField(field: string, blob: string, cek?: CapsuleKey): Promise<unknown>;
     /**
      * Build the `ViaCryptoCtx` for forget()'s per-ref via-erase fold (#629
      * Task 10) — resolves the live envelope's CEK exactly like
@@ -291,7 +318,7 @@ export declare class RecordCodec<T> {
      * may sit in the working-set cache (or be logged/serialised) without
      * exposing the value, which decrypts only on `reveal()`.
      */
-    makeSealedHandle(field: string, blob: string, cek?: EnclaveKey): SealedHandle<unknown>;
+    makeSealedHandle(field: string, blob: string, cek?: CapsuleKey): SealedHandle<unknown>;
     /**
      * Replace every field the just-written envelope actually sealed with a
      * {@link Sealed} handle, leaving every other field as its plaintext value.
@@ -333,7 +360,7 @@ export declare class RecordCodec<T> {
      * never a tier DEK (tier writes don't seal fields; `_sealed` reaches a
      * tiered envelope only via a tier-0 write later elevated).
      */
-    applySealedSlots(record: T, sealed: Record<string, string>, cek: EnclaveKey | undefined, opts?: {
+    applySealedSlots(record: T, sealed: Record<string, string>, cek: CapsuleKey | undefined, opts?: {
         id?: string;
         sealedAsHandles?: boolean;
     }): Promise<T>;
@@ -363,7 +390,7 @@ export declare class RecordCodec<T> {
      * output-recompute path, not the public per-record read surface schema
      * validation guards.
      */
-    decryptRecordAtDek(ref: RecordRef, envelope: EncryptedEnvelope, dek: EnclaveKey): Promise<T | null>;
+    decryptRecordAtDek(ref: RecordRef, envelope: EncryptedEnvelope, dek: CapsuleKey): Promise<T | null>;
     /**
      * Decrypt an envelope into a record of type `T`.
      *
@@ -384,3 +411,11 @@ export declare class RecordCodec<T> {
         sealedAsHandles?: boolean;
     }): Promise<T | null>;
 }
+/**
+ * The capsule-bound codec constructor: same shape callers have always used
+ * (`new RecordCodec(ctx)`), with the capsule already closed over.
+ */
+export type BoundRecordCodec = (new <T>(ctx: RecordCodecContext<T>) => RecordCodecBase<T>) & Omit<typeof RecordCodecBase, never>;
+export declare function makeRecordCodec(p: CapsulePrimitives, slots: ReturnType<typeof makeSealedSlots>): {
+    RecordCodec: BoundRecordCodec;
+};

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

@@ -1,4 +1,4 @@
-import type { EncryptedEnvelope } from '../types.js';
+import type { EncryptedEnvelope } from '../../kernel/types.js';
 import type { RecordIdentity } from './record-aad.js';
 /** The body an envelope carries, independent of who is writing it. */
 export interface RecordEnvelopeBody {

package/dist/capsule/plumbing/rekey-blob.d.ts

@@ -0,0 +1,33 @@
+import type { NoydbStore } from '../../kernel/types.js';
+/** Blob metadata envelopes, keyed by eTag. owner: with-shape/blobs/blob-set.ts */
+import type { CapsuleKey, CapsulePrimitives } from '../contract.js';
+/**
+ * What a rotation did to the blob set.
+ *
+ * Deliberately NOT on the enclave barrel: no caller outside this module binds
+ * it, and that surface is the fork-swap trust boundary, so exporting a type
+ * nobody consumes is pure widening.
+ *
+ * It is a return value rather than a log line because `foreign` and `blobs`
+ * are the only way to tell "left alone, correctly" from "left alone, because
+ * the caller passed a wrong `otherDeks` set". Both re-key nothing and both
+ * return successfully. `rotate-preserves-blobs.test.ts` asserts these counts
+ * against a direct call for exactly that reason.
+ */
+export interface BlobRekeyReport {
+    /** Index envelopes moved onto the new DEK. */
+    readonly blobs: number;
+    /** Chunk envelopes re-encrypted under the new DEK. */
+    readonly chunks: number;
+    /**
+     * Index envelopes left alone because they open under a DEK the caller holds
+     * for a DIFFERENT slot — an elevated blob, sealed under `_blob#<tier>`. Those
+     * are that slot's rotation to do, not this one's.
+     */
+    readonly foreign: number;
+    /** Index envelopes already under the new DEK — a resumed rotation. */
+    readonly alreadyMoved: number;
+}
+export declare function makeRekeyBlob(p: CapsulePrimitives): {
+    rekeyBlobSet: (adapter: NoydbStore, vault: string, oldDek: CapsuleKey, newDek: CapsuleKey, otherDeks?: readonly CapsuleKey[]) => Promise<BlobRekeyReport>;
+};

package/dist/capsule/plumbing/rekey.d.ts

@@ -0,0 +1,44 @@
+import type { EncryptedEnvelope } from '../../kernel/types.js';
+/**
+ * Produce the envelope `envelope` becomes once its collection's DEK rotates
+ * from `oldDek` to `newDek`.
+ *
+ * **Every slot is carried forward except `_bidx`.** The previous inline version
+ * built a fresh literal holding only `_noydb/_v/_ts/_iv/_data`, silently
+ * discarding `_by`, `_tier`, `_cek`, `_sealed`, `_vdig` and `_source`. Losing
+ * `_tier` was the worst of those: tier-0 reads treat elevated as missing, so an
+ * elevated record did not error after a rotation — it simply disappeared.
+ *
+ * `_bidx` is dropped deliberately. It is a DEK-rooted equality tag, so a tag
+ * carried across a DEK rotation can never be re-derived to match a query again
+ * while still leaking the old equality partition. Index coverage regrows
+ * per-record on the next `put()` under the new DEK.
+ *
+ * Two shapes, and picking the wrong one is why this needed a helper:
+ *
+ * - **per-record CEK** (`_cek` present) — the body is sealed under the CEK and
+ *   the CEK is wrapped under the collection DEK, so rotation re-wraps the CEK
+ *   and leaves the body **untouched**. The old inline code instead ran
+ *   `decrypt(body, oldDek)` on these, which throws: rotation could not complete
+ *   on a collection containing any CEK record.
+ * - **bare** — body sealed directly under the DEK, so decrypt and re-encrypt.
+ *
+ * Idempotence is the caller's problem, not this function's: it assumes
+ * `envelope` is still under `oldDek`. A resumable rotation must know which side
+ * of the migration each record is on before calling.
+ */
+import type { CapsuleKey, CapsulePrimitives } from '../contract.js';
+export declare function makeRekey(p: CapsulePrimitives): {
+    rekeyEnvelopeToDek: (ref: {
+        readonly collection: string;
+        readonly id: string;
+    }, envelope: EncryptedEnvelope, oldDek: CapsuleKey, newDek: CapsuleKey) => Promise<EncryptedEnvelope>;
+    rekeyEnvelopeIfNeeded: (ref: {
+        readonly collection: string;
+        readonly id: string;
+    }, envelope: EncryptedEnvelope, oldDek: CapsuleKey, newDek: CapsuleKey) => Promise<EncryptedEnvelope | null>;
+    envelopeOpensUnderAny: (ref: {
+        readonly collection: string;
+        readonly id: string;
+    }, envelope: EncryptedEnvelope, keys: readonly CapsuleKey[]) => Promise<boolean>;
+};

package/dist/capsule/plumbing/sealed-slot.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Sealed-slot (`iv:data`) parsing + the CEK/DEK dual-read, factored out so the
+ * three callers that decrypt a `_sealed[field]` slot share ONE implementation
+ * with no coupling between them:
+ *
+ *   - {@link RecordCodec.unsealField} / `classifySealedShred` (read + classify),
+ *   - `record-keys/sealing.ts:rotateRecordCek` (re-seal under a new CEK).
+ *
+ * These are pure helpers over an explicit `(cek, dek)` pair — NOT a context
+ * object — so `sealing.ts` (which holds only the DEK) can import them without
+ * pulling in the whole codec, avoiding a codec↔sealing dependency cycle.
+ */
+import type { CapsulePrimitives } from '../contract.js';
+/** Parse an `iv:data` sealed slot (split on the FIRST `:`). Cipher-free, so it
+ *  needs no primitives and stays a plain module-level export. */
+export declare function parseSealedSlot(blob: string): {
+    iv: string;
+    data: string;
+};
+export declare function makeSealedSlot(p: CapsulePrimitives): {
+    dualReadSealedSlot: (blob: string, field: string, collection: string, cek: CryptoKey | undefined, dek: CryptoKey) => Promise<string>;
+};

package/dist/capsule/plumbing/sealed-slots.d.ts

@@ -0,0 +1,37 @@
+import { SealedHandle } from '../../kernel/types.js';
+import type { ViaCryptoCtx } from '../../kernel/via/index.js';
+/**
+ * Key material for one collection's sealed-field derivation. `cek`, when
+ * supplied, is preferred (record-scoped); `getDEK` is the fallback (and,
+ * for legacy/no-CEK collections, the only key) — mirrors the dual-read
+ * `RecordCodec` has always done.
+ */
+import type { CapsuleKey, CapsulePrimitives } from '../contract.js';
+export interface SealKeyMaterial {
+    readonly collection: string;
+    readonly cek?: CapsuleKey;
+    getDEK(): Promise<CapsuleKey>;
+}
+export interface SealFieldsResult {
+    readonly openRecord: Record<string, unknown>;
+    readonly sealed: Record<string, string> | undefined;
+}
+/** What {@link makeSealedSlotCapability} needs — a subset of `RecordCodecContext`. */
+export interface SealedSlotCapabilityCtx {
+    readonly name: string;
+    getDEK(): Promise<CapsuleKey>;
+}
+/** Resolve the DEK for an arbitrary (possibly synthetic, e.g. `_dict_en`) collection name. */
+export type ReservedEnvelopeDekResolver = (collection: string) => Promise<CapsuleKey>;
+export declare function makeSealedSlots(p: CapsulePrimitives, sealedSlot: {
+    dualReadSealedSlot: (blob: string, field: string, collection: string, cek: CapsuleKey | undefined, dek: CapsuleKey) => Promise<string>;
+}): {
+    sealFields: (record: Record<string, unknown>, sensitiveFields: ReadonlySet<string>, keyMaterial: SealKeyMaterial) => Promise<SealFieldsResult>;
+    unsealOneField: (field: string, blob: string, keyMaterial: SealKeyMaterial) => Promise<unknown>;
+    makeHandleProducer: (keyMaterial: SealKeyMaterial) => (field: string, blob: string) => SealedHandle<unknown>;
+    unsealFields: (record: Record<string, unknown>, sealed: Record<string, string>, keyMaterial: SealKeyMaterial, opts?: {
+        asHandles?: boolean;
+    }) => Promise<Record<string, unknown>>;
+    makeSealedSlotCapability: (ctx: SealedSlotCapabilityCtx, recordId: string, cek?: CapsuleKey) => ViaCryptoCtx["sealedSlots"];
+    makeReservedEnvelopes: (dekResolver: ReservedEnvelopeDekResolver, declaredPrefixes: readonly string[]) => ViaCryptoCtx["reservedEnvelopes"];
+};

package/dist/capsule/plumbing/sealing.d.ts

@@ -0,0 +1,29 @@
+import { type NoydbStore, type RecipientSealer } from '../../kernel/types.js';
+import type { CapsuleKey, CapsulePrimitives } from '../contract.js';
+/** What the grantor functions need from their `Vault`. */
+export interface SealingContext {
+    readonly adapter: NoydbStore;
+    /** Vault id (the adapter's first coordinate). */
+    readonly vault: string;
+    /** Resolve the DEK a record's CEK is wrapped under. */
+    getDEK(collection: string): Promise<CapsuleKey>;
+    /** Actor id stamped on `_by` (empty string → omit). */
+    readonly actor: string;
+    /** Evict the per-record CEK cache + decrypted-record cache after a rotation. */
+    invalidateRecordCaches(collection: string, id: string): Promise<void>;
+}
+export declare function makeSealing(p: CapsulePrimitives, sealedSlot: {
+    dualReadSealedSlot: (blob: string, field: string, collection: string, cek: CapsuleKey | undefined, dek: CapsuleKey) => Promise<string>;
+}): {
+    SEALED_CEK_NS: string;
+    sealRecordToHost: (ctx: SealingContext, collection: string, id: string, hostSealer: RecipientSealer, opts: {
+        expiresAt: string;
+    }) => Promise<{
+        pid: string;
+        envelopeKey: string;
+    }>;
+    revokeSealedRecord: (ctx: SealingContext, collection: string, id: string, pid: string, opts?: {
+        hard?: boolean;
+    }) => Promise<void>;
+    rotateRecordCek: (ctx: SealingContext, collection: string, id: string) => Promise<void>;
+};

package/dist/capsule/plumbing/sign.d.ts

@@ -0,0 +1,9 @@
+export declare function generateSigningKeyPair(): Promise<{
+    /** base64url raw (32 bytes) — non-secret, publishable */
+    publicKeyB64: string;
+    /** base64url pkcs8 — secret, wrap before persisting */
+    privateKeyPkcs8B64: string;
+}>;
+export declare function signBytes(privateKeyPkcs8B64: string, message: Uint8Array): Promise<string>;
+/** Fails closed: any malformed input is `false`, never a throw. */
+export declare function verifyBytes(publicKeyB64: string, sigB64url: string, message: Uint8Array): Promise<boolean>;

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

@@ -15,8 +15,8 @@
  * (`_writeTombstone`) and drives `vault.forget()` lives with the collection /
  * vault; it calls into these.
  */
-import { type EncryptedEnvelope } from '../../types.js';
-import type { RecordRef } from '../record-aad.js';
+import { type EncryptedEnvelope } from '../../kernel/types.js';
+import type { RecordRef } from './record-aad.js';
 /**
  * Shape-only tombstone recognition for layers that have no per-collection
  * context (the sync engine, #590): a tombstone carries an empty `_data` and

package/dist/capsule-VOLX3QRQ.js

@@ -0,0 +1,209 @@
+import {
+  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
+} from "./chunk-EZGV6F47.js";
+import {
+  CapsuleNotSupportedError
+} from "./chunk-OIEO4WDL.js";
+import "./chunk-Q2XRFWOI.js";
+import "./chunk-NH2UOV3B.js";
+import "./chunk-42ALPZ2B.js";
+import "./chunk-QMWY2FDS.js";
+import "./chunk-SV2PM2OY.js";
+import "./chunk-37EPTBBR.js";
+export {
+  CapsuleNotSupportedError,
+  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=capsule-VOLX3QRQ.js.map