@tinycloud/sdk-services 3.7.0-beta.3 → 3.7.0

package/dist/types-BGRzS1ob.d.ts

@@ -0,0 +1,328 @@
+import { P as PermissionHint } from './types-DAOyIbXu.js';
+
+/**
+ * Canonical JSON serialization and content hashing for TinyCloud
+ * encryption requests/responses.
+ *
+ * The node and SDK must agree byte-for-byte on the canonical form so
+ * that body-hash bindings (`bodyHash`, `encryptedSymmetricKeyHash`,
+ * `receiverPublicKeyHash`) verify on both sides.
+ *
+ * Canonical rules:
+ * - Object keys are sorted lexicographically by code point.
+ * - Strings are encoded with the JSON.stringify default (RFC 8259).
+ * - Numbers are emitted via JSON.stringify; callers should restrict to
+ *   integers or use string fields for high-precision values.
+ * - `undefined` properties are dropped. `null` is preserved.
+ * - Arrays preserve element order.
+ *
+ * Hashing uses SHA-256 supplied by the caller (via an `EncryptionCrypto`
+ * binding) so this module stays platform-agnostic.
+ */
+type Json = null | boolean | number | string | Json[] | {
+    [key: string]: Json | undefined;
+};
+/**
+ * Produce the canonical JSON string for {@link value}. Object keys are
+ * sorted, `undefined` properties are dropped, and primitive types are
+ * encoded by `JSON.stringify`.
+ */
+declare function canonicalize(value: Json | undefined): string;
+declare function hexEncode(bytes: Uint8Array): string;
+declare function hexDecode(hex: string): Uint8Array;
+declare function base64Encode(bytes: Uint8Array): string;
+declare function base64Decode(s: string): Uint8Array;
+declare function utf8Encode(s: string): Uint8Array;
+declare function utf8Decode(b: Uint8Array): string;
+/**
+ * Compute `hexEncode(sha256(canonicalize(value)))`. The SHA-256 binding
+ * is injected so the module remains usable in both the WASM and pure-JS
+ * paths.
+ */
+declare function canonicalHashHex(sha256: (bytes: Uint8Array) => Uint8Array, value: Json): string;
+
+/**
+ * Type definitions for TinyCloud one-of-one encryption.
+ *
+ * Wire shapes mirror the protocol described in the encryption
+ * architecture: inline envelopes carry the encrypted symmetric key
+ * alongside the ciphertext; decrypt requests are short-lived UCAN
+ * invocations against a target node plus networkId.
+ */
+
+/** Default ciphersuite identifier for v1 envelopes. */
+declare const DEFAULT_ENCRYPTION_ALG: "x25519-aes256gcm/v1";
+/** Inline-envelope schema version. */
+declare const ENVELOPE_VERSION: 1;
+/** Default key version on freshly-created networks. */
+declare const DEFAULT_KEY_VERSION: 1;
+/** Decrypt-invocation fact type. */
+declare const DECRYPT_FACT_TYPE: "tinycloud.encryption.decrypt/v1";
+/** Decrypt response type. */
+declare const DECRYPT_RESULT_TYPE: "tinycloud.encryption.decrypt-result/v1";
+/** Encryption service identifier (manifest long form). */
+declare const ENCRYPTION_SERVICE: "tinycloud.encryption";
+/** Short form used in recap/abilities maps. */
+declare const ENCRYPTION_SERVICE_SHORT: "encryption";
+/** Decrypt ability URN. */
+declare const DECRYPT_ACTION: "tinycloud.encryption/decrypt";
+/**
+ * Inline encrypted envelope persisted in KV/SQL records.
+ *
+ * - `encryptedSymmetricKey` is opaque to the SDK; only the network can
+ *   unwrap it.
+ * - `encryptedSymmetricKeyHash` is the canonical hash of the wrapped key
+   *   bytes (hex-encoded sha-256 of the base64 string's canonical JSON
+   *   form). The node recomputes this on every decrypt request.
+ * - `ciphertext` and `aad` are payload bytes only; the node never sees
+ *   them.
+ */
+interface InlineEncryptedEnvelope {
+    /** Schema version. */
+    v: typeof ENVELOPE_VERSION;
+    /** Network id URN. */
+    networkId: string;
+    /** Ciphersuite identifier. */
+    alg: string;
+    /** Network key version that was used to wrap the symmetric key. */
+    keyVersion: number;
+    /** Base64-encoded wrapped symmetric key / capsule. */
+    encryptedSymmetricKey: string;
+    /** Hex sha-256 of the canonical encryptedSymmetricKey string. */
+    encryptedSymmetricKeyHash: string;
+    /** Base64-encoded payload ciphertext. */
+    ciphertext: string;
+    /** Base64-encoded associated data, if any. */
+    aad?: string;
+    /** Caller-supplied metadata. Not authenticated against the node. */
+    metadata?: Record<string, string>;
+}
+/**
+ * Node-published network descriptor. The node DB is authoritative; a
+ * cached copy may also live under
+ * `.well-known/encryption/network/<name>` in the owner's account
+ * space (a discovery record only).
+ */
+interface NetworkDescriptor {
+    networkId: string;
+    ownerDid: string;
+    name: string;
+    members: ReadonlyArray<{
+        nodeId: string;
+        role: "primary" | "share";
+    }>;
+    threshold: {
+        n: number;
+        t: number;
+    };
+    state: "pending" | "generating" | "active" | "rotating" | "revoked" | "failed";
+    /** Base64-encoded network public key. */
+    publicEncryptionKey: string;
+    alg: string;
+    keyVersion: number;
+    keyBackend: "local-one-of-one" | "dstack" | "threshold";
+    createdAt: string;
+    updatedAt: string;
+}
+/**
+ * Decrypt-request body sent over the wire. Hashed (canonically) and
+ * bound to the UCAN invocation via `facts.bodyHash`.
+ */
+interface DecryptRequestBody {
+    type: typeof DECRYPT_FACT_TYPE;
+    targetNode: string;
+    networkId: string;
+    alg: string;
+    keyVersion: number;
+    /** Base64-encoded wrapped symmetric key from the envelope. */
+    encryptedSymmetricKey: string;
+    /** Recomputed hash of the wrapped key. */
+    encryptedSymmetricKeyHash: string;
+    /** Base64-encoded per-request receiver public key. */
+    receiverPublicKey: string;
+    /** Hash of the receiver public key. */
+    receiverPublicKeyHash: string;
+}
+/**
+ * Decrypt-response body returned by the node. The SDK verifies the
+ * signature, recomputes hashes, then unwraps `wrappedKey` with the
+ * per-request receiver private key before decrypting the payload.
+ */
+interface DecryptResponseBody {
+    type: typeof DECRYPT_RESULT_TYPE;
+    targetNode: string;
+    networkId: string;
+    invocationCid: string;
+    encryptedSymmetricKeyHash: string;
+    receiverPublicKeyHash: string;
+    /** Base64-encoded symmetric key re-encrypted to receiverPublicKey. */
+    wrappedKey: string;
+    alg: string;
+    keyVersion: number;
+    requestHash: string;
+    nodeId: string;
+    /** Base64-encoded ed25519 signature over canonical(response - signature field). */
+    nodeSignature: string;
+}
+/**
+ * Decrypt-invocation facts attached to the UCAN. Verifiers recompute
+ * `bodyHash`, `encryptedSymmetricKeyHash`, and `receiverPublicKeyHash`
+ * from the request body and reject any mismatch.
+ */
+interface DecryptInvocationFact {
+    type: typeof DECRYPT_FACT_TYPE;
+    targetNode: string;
+    networkId: string;
+    bodyHash: string;
+    encryptedSymmetricKeyHash: string;
+    receiverPublicKeyHash: string;
+    alg: string;
+    keyVersion: number;
+}
+/**
+ * Per-request receiver key pair (x25519). The private key never
+ * leaves the SDK; the public key is sent to the node so the node can
+ * rewrap the symmetric key.
+ */
+interface ReceiverKeyPair {
+    publicKey: Uint8Array;
+    privateKey: Uint8Array;
+}
+/**
+ * Crypto primitives injected into the encryption module. The SDK
+ * provides these via WASM bindings; tests provide simple in-memory
+ * implementations.
+ */
+interface EncryptionCrypto {
+    /** SHA-256 → 32-byte digest. */
+    sha256(data: Uint8Array): Uint8Array;
+    /** Cryptographically secure random bytes. */
+    randomBytes(length: number): Uint8Array;
+    /** Derive an x25519 key pair from a 32-byte seed. */
+    x25519FromSeed(seed: Uint8Array): ReceiverKeyPair;
+    /** Compute the x25519 ECDH shared secret. */
+    x25519Dh(privateKey: Uint8Array, publicKey: Uint8Array): Uint8Array;
+    /** Authenticated symmetric encryption (the node's symmetric scheme). */
+    authEncrypt(key: Uint8Array, plaintext: Uint8Array, aad?: Uint8Array): Uint8Array;
+    /** Authenticated symmetric decryption (matched to authEncrypt). */
+    authDecrypt(key: Uint8Array, ciphertext: Uint8Array, aad?: Uint8Array): Uint8Array;
+    /**
+     * Wrap a symmetric key for the network's public encryption key using
+     * a sealed-box / hpke / x25519+symmetric construction. Implementation
+     * is opaque; only the node can unwrap.
+     */
+    sealToNetworkKey(networkPublicKey: Uint8Array, symmetricKey: Uint8Array): Uint8Array;
+    /**
+     * Open a wrapped symmetric key that was re-encrypted to the
+     * per-request receiver public key. The matching private key must be
+     * supplied here; the SDK never sends it to the node.
+     */
+    openWithReceiverKey(receiverPrivateKey: Uint8Array, wrappedKey: Uint8Array): Uint8Array;
+    /**
+     * Verify an ed25519 signature over `message` produced by the node
+     * identified by `nodeId` (the public-key DID).
+     */
+    verifyNodeSignature(nodeId: string, message: Uint8Array, signature: Uint8Array): boolean;
+}
+/**
+ * Signer interface used to derive a receiver key pair from a wallet or
+ * session signer. The signature is HKDF-extracted into the receiver
+ * seed so the public key is reproducible given the same context.
+ */
+interface ReceiverKeySigner {
+    signMessage(message: string): Promise<string>;
+}
+/** Capability proof material accompanying a decrypt invocation. */
+interface DecryptCapabilityProof {
+    /** Delegation chain CIDs rooted at the network owner DID. */
+    proofs: ReadonlyArray<string>;
+    /** Optional Authorization header value to use instead of building one. */
+    authorization?: string;
+}
+/**
+ * Inputs to the decrypt invocation builder.
+ */
+interface BuildDecryptInvocationInput {
+    /** Target node DID — also the UCAN audience. */
+    targetNode: string;
+    /** Network id URN — also the recap resource. */
+    networkId: string;
+    /** Canonical body that will be POSTed. */
+    body: DecryptRequestBody;
+    /** Facts include hashes bound to the canonical body. */
+    facts: DecryptInvocationFact;
+    /** Capability proof chain. */
+    proof: DecryptCapabilityProof;
+    /** Optional `nbf` UCAN field as an ISO date string. */
+    notBefore?: string;
+    /** Optional `exp` UCAN field as an ISO date string. */
+    expiration?: string;
+}
+/**
+ * The output of {@link buildDecryptInvocation}.
+ */
+interface BuiltDecryptInvocation {
+    /** HTTP `Authorization` header value. */
+    authorization: string;
+    /** CID of the invocation (used by the node response binding). */
+    invocationCid: string;
+    /** Canonical body string the node will hash. */
+    canonicalBody: string;
+}
+/**
+ * Signer interface for producing the decrypt invocation. WASM bindings
+ * implement this with the same session signer used for KV/SQL
+ * invocations; tests can stub it.
+ */
+interface DecryptInvocationSigner {
+    signDecryptInvocation(input: BuildDecryptInvocationInput): Promise<BuiltDecryptInvocation>;
+}
+/**
+ * Errors thrown / returned from the encryption module.
+ */
+type EncryptionErrorInput = {
+    code: "NETWORK_NOT_FOUND";
+    networkId?: string;
+    name?: string;
+    message?: string;
+} | {
+    code: "NETWORK_NOT_ACTIVE";
+    state: string;
+    message?: string;
+} | {
+    code: "INVALID_NETWORK_ID";
+    message: string;
+} | {
+    code: "INVALID_ENVELOPE";
+    message: string;
+} | {
+    code: "DECRYPT_DENIED";
+    message: string;
+    permissionHint?: PermissionHint;
+} | {
+    code: "INVALID_RESPONSE";
+    message: string;
+} | {
+    code: "RESPONSE_SIGNATURE_INVALID";
+    message?: string;
+} | {
+    code: "RESPONSE_BINDING_MISMATCH";
+    field: string;
+    message?: string;
+} | {
+    code: "TRANSPORT_ERROR";
+    cause: Error;
+    message?: string;
+} | {
+    code: "INVALID_INPUT";
+    message: string;
+};
+type EncryptionError = EncryptionErrorInput & {
+    service: "encryption";
+    message: string;
+};
+declare function encryptionError(input: EncryptionErrorInput): EncryptionError;
+/** Re-export for ergonomic typing of canonical payloads. */
+type CanonicalJson = Json;
+
+export { type BuildDecryptInvocationInput as B, type CanonicalJson as C, type DecryptCapabilityProof as D, type EncryptionCrypto as E, type InlineEncryptedEnvelope as I, type Json as J, type NetworkDescriptor as N, type ReceiverKeyPair as R, type BuiltDecryptInvocation as a, DECRYPT_ACTION as b, DECRYPT_FACT_TYPE as c, DECRYPT_RESULT_TYPE as d, DEFAULT_ENCRYPTION_ALG as e, DEFAULT_KEY_VERSION as f, type DecryptInvocationFact as g, type DecryptInvocationSigner as h, type DecryptRequestBody as i, type DecryptResponseBody as j, ENCRYPTION_SERVICE as k, ENCRYPTION_SERVICE_SHORT as l, ENVELOPE_VERSION as m, type EncryptionError as n, type EncryptionErrorInput as o, type ReceiverKeySigner as p, base64Decode as q, base64Encode as r, canonicalHashHex as s, canonicalize as t, encryptionError as u, hexDecode as v, hexEncode as w, utf8Decode as x, utf8Encode as y };

package/dist/types-B_rbS4XE.d.cts

@@ -0,0 +1,328 @@
+import { P as PermissionHint } from './types-DAOyIbXu.cjs';
+
+/**
+ * Canonical JSON serialization and content hashing for TinyCloud
+ * encryption requests/responses.
+ *
+ * The node and SDK must agree byte-for-byte on the canonical form so
+ * that body-hash bindings (`bodyHash`, `encryptedSymmetricKeyHash`,
+ * `receiverPublicKeyHash`) verify on both sides.
+ *
+ * Canonical rules:
+ * - Object keys are sorted lexicographically by code point.
+ * - Strings are encoded with the JSON.stringify default (RFC 8259).
+ * - Numbers are emitted via JSON.stringify; callers should restrict to
+ *   integers or use string fields for high-precision values.
+ * - `undefined` properties are dropped. `null` is preserved.
+ * - Arrays preserve element order.
+ *
+ * Hashing uses SHA-256 supplied by the caller (via an `EncryptionCrypto`
+ * binding) so this module stays platform-agnostic.
+ */
+type Json = null | boolean | number | string | Json[] | {
+    [key: string]: Json | undefined;
+};
+/**
+ * Produce the canonical JSON string for {@link value}. Object keys are
+ * sorted, `undefined` properties are dropped, and primitive types are
+ * encoded by `JSON.stringify`.
+ */
+declare function canonicalize(value: Json | undefined): string;
+declare function hexEncode(bytes: Uint8Array): string;
+declare function hexDecode(hex: string): Uint8Array;
+declare function base64Encode(bytes: Uint8Array): string;
+declare function base64Decode(s: string): Uint8Array;
+declare function utf8Encode(s: string): Uint8Array;
+declare function utf8Decode(b: Uint8Array): string;
+/**
+ * Compute `hexEncode(sha256(canonicalize(value)))`. The SHA-256 binding
+ * is injected so the module remains usable in both the WASM and pure-JS
+ * paths.
+ */
+declare function canonicalHashHex(sha256: (bytes: Uint8Array) => Uint8Array, value: Json): string;
+
+/**
+ * Type definitions for TinyCloud one-of-one encryption.
+ *
+ * Wire shapes mirror the protocol described in the encryption
+ * architecture: inline envelopes carry the encrypted symmetric key
+ * alongside the ciphertext; decrypt requests are short-lived UCAN
+ * invocations against a target node plus networkId.
+ */
+
+/** Default ciphersuite identifier for v1 envelopes. */
+declare const DEFAULT_ENCRYPTION_ALG: "x25519-aes256gcm/v1";
+/** Inline-envelope schema version. */
+declare const ENVELOPE_VERSION: 1;
+/** Default key version on freshly-created networks. */
+declare const DEFAULT_KEY_VERSION: 1;
+/** Decrypt-invocation fact type. */
+declare const DECRYPT_FACT_TYPE: "tinycloud.encryption.decrypt/v1";
+/** Decrypt response type. */
+declare const DECRYPT_RESULT_TYPE: "tinycloud.encryption.decrypt-result/v1";
+/** Encryption service identifier (manifest long form). */
+declare const ENCRYPTION_SERVICE: "tinycloud.encryption";
+/** Short form used in recap/abilities maps. */
+declare const ENCRYPTION_SERVICE_SHORT: "encryption";
+/** Decrypt ability URN. */
+declare const DECRYPT_ACTION: "tinycloud.encryption/decrypt";
+/**
+ * Inline encrypted envelope persisted in KV/SQL records.
+ *
+ * - `encryptedSymmetricKey` is opaque to the SDK; only the network can
+ *   unwrap it.
+ * - `encryptedSymmetricKeyHash` is the canonical hash of the wrapped key
+   *   bytes (hex-encoded sha-256 of the base64 string's canonical JSON
+   *   form). The node recomputes this on every decrypt request.
+ * - `ciphertext` and `aad` are payload bytes only; the node never sees
+ *   them.
+ */
+interface InlineEncryptedEnvelope {
+    /** Schema version. */
+    v: typeof ENVELOPE_VERSION;
+    /** Network id URN. */
+    networkId: string;
+    /** Ciphersuite identifier. */
+    alg: string;
+    /** Network key version that was used to wrap the symmetric key. */
+    keyVersion: number;
+    /** Base64-encoded wrapped symmetric key / capsule. */
+    encryptedSymmetricKey: string;
+    /** Hex sha-256 of the canonical encryptedSymmetricKey string. */
+    encryptedSymmetricKeyHash: string;
+    /** Base64-encoded payload ciphertext. */
+    ciphertext: string;
+    /** Base64-encoded associated data, if any. */
+    aad?: string;
+    /** Caller-supplied metadata. Not authenticated against the node. */
+    metadata?: Record<string, string>;
+}
+/**
+ * Node-published network descriptor. The node DB is authoritative; a
+ * cached copy may also live under
+ * `.well-known/encryption/network/<name>` in the owner's account
+ * space (a discovery record only).
+ */
+interface NetworkDescriptor {
+    networkId: string;
+    ownerDid: string;
+    name: string;
+    members: ReadonlyArray<{
+        nodeId: string;
+        role: "primary" | "share";
+    }>;
+    threshold: {
+        n: number;
+        t: number;
+    };
+    state: "pending" | "generating" | "active" | "rotating" | "revoked" | "failed";
+    /** Base64-encoded network public key. */
+    publicEncryptionKey: string;
+    alg: string;
+    keyVersion: number;
+    keyBackend: "local-one-of-one" | "dstack" | "threshold";
+    createdAt: string;
+    updatedAt: string;
+}
+/**
+ * Decrypt-request body sent over the wire. Hashed (canonically) and
+ * bound to the UCAN invocation via `facts.bodyHash`.
+ */
+interface DecryptRequestBody {
+    type: typeof DECRYPT_FACT_TYPE;
+    targetNode: string;
+    networkId: string;
+    alg: string;
+    keyVersion: number;
+    /** Base64-encoded wrapped symmetric key from the envelope. */
+    encryptedSymmetricKey: string;
+    /** Recomputed hash of the wrapped key. */
+    encryptedSymmetricKeyHash: string;
+    /** Base64-encoded per-request receiver public key. */
+    receiverPublicKey: string;
+    /** Hash of the receiver public key. */
+    receiverPublicKeyHash: string;
+}
+/**
+ * Decrypt-response body returned by the node. The SDK verifies the
+ * signature, recomputes hashes, then unwraps `wrappedKey` with the
+ * per-request receiver private key before decrypting the payload.
+ */
+interface DecryptResponseBody {
+    type: typeof DECRYPT_RESULT_TYPE;
+    targetNode: string;
+    networkId: string;
+    invocationCid: string;
+    encryptedSymmetricKeyHash: string;
+    receiverPublicKeyHash: string;
+    /** Base64-encoded symmetric key re-encrypted to receiverPublicKey. */
+    wrappedKey: string;
+    alg: string;
+    keyVersion: number;
+    requestHash: string;
+    nodeId: string;
+    /** Base64-encoded ed25519 signature over canonical(response - signature field). */
+    nodeSignature: string;
+}
+/**
+ * Decrypt-invocation facts attached to the UCAN. Verifiers recompute
+ * `bodyHash`, `encryptedSymmetricKeyHash`, and `receiverPublicKeyHash`
+ * from the request body and reject any mismatch.
+ */
+interface DecryptInvocationFact {
+    type: typeof DECRYPT_FACT_TYPE;
+    targetNode: string;
+    networkId: string;
+    bodyHash: string;
+    encryptedSymmetricKeyHash: string;
+    receiverPublicKeyHash: string;
+    alg: string;
+    keyVersion: number;
+}
+/**
+ * Per-request receiver key pair (x25519). The private key never
+ * leaves the SDK; the public key is sent to the node so the node can
+ * rewrap the symmetric key.
+ */
+interface ReceiverKeyPair {
+    publicKey: Uint8Array;
+    privateKey: Uint8Array;
+}
+/**
+ * Crypto primitives injected into the encryption module. The SDK
+ * provides these via WASM bindings; tests provide simple in-memory
+ * implementations.
+ */
+interface EncryptionCrypto {
+    /** SHA-256 → 32-byte digest. */
+    sha256(data: Uint8Array): Uint8Array;
+    /** Cryptographically secure random bytes. */
+    randomBytes(length: number): Uint8Array;
+    /** Derive an x25519 key pair from a 32-byte seed. */
+    x25519FromSeed(seed: Uint8Array): ReceiverKeyPair;
+    /** Compute the x25519 ECDH shared secret. */
+    x25519Dh(privateKey: Uint8Array, publicKey: Uint8Array): Uint8Array;
+    /** Authenticated symmetric encryption (the node's symmetric scheme). */
+    authEncrypt(key: Uint8Array, plaintext: Uint8Array, aad?: Uint8Array): Uint8Array;
+    /** Authenticated symmetric decryption (matched to authEncrypt). */
+    authDecrypt(key: Uint8Array, ciphertext: Uint8Array, aad?: Uint8Array): Uint8Array;
+    /**
+     * Wrap a symmetric key for the network's public encryption key using
+     * a sealed-box / hpke / x25519+symmetric construction. Implementation
+     * is opaque; only the node can unwrap.
+     */
+    sealToNetworkKey(networkPublicKey: Uint8Array, symmetricKey: Uint8Array): Uint8Array;
+    /**
+     * Open a wrapped symmetric key that was re-encrypted to the
+     * per-request receiver public key. The matching private key must be
+     * supplied here; the SDK never sends it to the node.
+     */
+    openWithReceiverKey(receiverPrivateKey: Uint8Array, wrappedKey: Uint8Array): Uint8Array;
+    /**
+     * Verify an ed25519 signature over `message` produced by the node
+     * identified by `nodeId` (the public-key DID).
+     */
+    verifyNodeSignature(nodeId: string, message: Uint8Array, signature: Uint8Array): boolean;
+}
+/**
+ * Signer interface used to derive a receiver key pair from a wallet or
+ * session signer. The signature is HKDF-extracted into the receiver
+ * seed so the public key is reproducible given the same context.
+ */
+interface ReceiverKeySigner {
+    signMessage(message: string): Promise<string>;
+}
+/** Capability proof material accompanying a decrypt invocation. */
+interface DecryptCapabilityProof {
+    /** Delegation chain CIDs rooted at the network owner DID. */
+    proofs: ReadonlyArray<string>;
+    /** Optional Authorization header value to use instead of building one. */
+    authorization?: string;
+}
+/**
+ * Inputs to the decrypt invocation builder.
+ */
+interface BuildDecryptInvocationInput {
+    /** Target node DID — also the UCAN audience. */
+    targetNode: string;
+    /** Network id URN — also the recap resource. */
+    networkId: string;
+    /** Canonical body that will be POSTed. */
+    body: DecryptRequestBody;
+    /** Facts include hashes bound to the canonical body. */
+    facts: DecryptInvocationFact;
+    /** Capability proof chain. */
+    proof: DecryptCapabilityProof;
+    /** Optional `nbf` UCAN field as an ISO date string. */
+    notBefore?: string;
+    /** Optional `exp` UCAN field as an ISO date string. */
+    expiration?: string;
+}
+/**
+ * The output of {@link buildDecryptInvocation}.
+ */
+interface BuiltDecryptInvocation {
+    /** HTTP `Authorization` header value. */
+    authorization: string;
+    /** CID of the invocation (used by the node response binding). */
+    invocationCid: string;
+    /** Canonical body string the node will hash. */
+    canonicalBody: string;
+}
+/**
+ * Signer interface for producing the decrypt invocation. WASM bindings
+ * implement this with the same session signer used for KV/SQL
+ * invocations; tests can stub it.
+ */
+interface DecryptInvocationSigner {
+    signDecryptInvocation(input: BuildDecryptInvocationInput): Promise<BuiltDecryptInvocation>;
+}
+/**
+ * Errors thrown / returned from the encryption module.
+ */
+type EncryptionErrorInput = {
+    code: "NETWORK_NOT_FOUND";
+    networkId?: string;
+    name?: string;
+    message?: string;
+} | {
+    code: "NETWORK_NOT_ACTIVE";
+    state: string;
+    message?: string;
+} | {
+    code: "INVALID_NETWORK_ID";
+    message: string;
+} | {
+    code: "INVALID_ENVELOPE";
+    message: string;
+} | {
+    code: "DECRYPT_DENIED";
+    message: string;
+    permissionHint?: PermissionHint;
+} | {
+    code: "INVALID_RESPONSE";
+    message: string;
+} | {
+    code: "RESPONSE_SIGNATURE_INVALID";
+    message?: string;
+} | {
+    code: "RESPONSE_BINDING_MISMATCH";
+    field: string;
+    message?: string;
+} | {
+    code: "TRANSPORT_ERROR";
+    cause: Error;
+    message?: string;
+} | {
+    code: "INVALID_INPUT";
+    message: string;
+};
+type EncryptionError = EncryptionErrorInput & {
+    service: "encryption";
+    message: string;
+};
+declare function encryptionError(input: EncryptionErrorInput): EncryptionError;
+/** Re-export for ergonomic typing of canonical payloads. */
+type CanonicalJson = Json;
+
+export { type BuildDecryptInvocationInput as B, type CanonicalJson as C, type DecryptCapabilityProof as D, type EncryptionCrypto as E, type InlineEncryptedEnvelope as I, type Json as J, type NetworkDescriptor as N, type ReceiverKeyPair as R, type BuiltDecryptInvocation as a, DECRYPT_ACTION as b, DECRYPT_FACT_TYPE as c, DECRYPT_RESULT_TYPE as d, DEFAULT_ENCRYPTION_ALG as e, DEFAULT_KEY_VERSION as f, type DecryptInvocationFact as g, type DecryptInvocationSigner as h, type DecryptRequestBody as i, type DecryptResponseBody as j, ENCRYPTION_SERVICE as k, ENCRYPTION_SERVICE_SHORT as l, ENVELOPE_VERSION as m, type EncryptionError as n, type EncryptionErrorInput as o, type ReceiverKeySigner as p, base64Decode as q, base64Encode as r, canonicalHashHex as s, canonicalize as t, encryptionError as u, hexDecode as v, hexEncode as w, utf8Decode as x, utf8Encode as y };