@request-seal/core 0.1.0 → 0.2.0

package/dist/constants.js

@@ -1,59 +1,119 @@
-export const VERSION = '0.1.0';
+/** The public package version. */
+export const VERSION = '0.2.0';
+/** The immutable public conformance corpus release and index digest. */
 export const CORPUS_PIN = Object.freeze({ tag: 'v0.4.0', commit: 'b2392871933d99641a7cb2ca2726aefd20081dee', indexSha256: 'f37435eca377666ab45c2b8f580287263145268e03d9224c76e324e4afaded6f' });
 // RequestSeal.StructuredFields ceilings at v0.4.0 (b239287).
+/** Default bounded Structured Fields parser limits. */
 export const STRUCTURED_FIELDS_LIMITS = Object.freeze({ maxBytes: 65_536, maxMembers: 1024, maxInnerItems: 256, maxParameters: 256, maxKeyBytes: 256, maxValueBytes: 16_384, maxNodes: 4096 });
 // RequestSeal.JOSE.Support: 16,384 bytes, four containers deep, 64 entries per container.
 // String bytes are bounded by the same complete-header byte ceiling.
+/** Default bounded JSON parser limits. */
 export const JSON_LIMITS = Object.freeze({ maxBytes: 16_384, maxDepth: 4, maxMembers: 64, maxArrayLength: 64, maxStringBytes: 16_384 });
+/** Maximum compact JOSE wire bytes. */
 export const JOSE_MAX_COMPACT_BYTES = 1_048_576; // RequestSeal.JOSE.Support.bytes compact wire ceiling.
+/** Maximum JOSE plaintext bytes. */
 export const JOSE_MAX_PLAINTEXT_BYTES = 1_048_576; // RequestSeal.JOSE.Support.
+/** Default maximum retained body bytes. */
 export const BODY_MAX_BYTES = 1_048_576; // RequestSeal.Body default retention.
+/** Default maximum digest input bytes. */
 export const DIGEST_MAX_BYTES = 16_777_216; // RequestSeal.Digest default work ceiling.
+/** Fixed maximum cryptographic input byte limit. */
+export const CRYPTO_MAX_BYTES_CEILING = 16_777_216; // RequestSeal.Crypto.max_bytes_ceiling at v0.4.1.
+/** Default cryptographic input byte limit. */
+export const CRYPTO_DEFAULT_MAX_BYTES = 1_048_576; // Independent of the fixed SignatureBase ceiling.
+/** Maximum signature-base bytes. */
 export const SIGNATURE_BASE_MAX_BYTES = 1_048_576; // RequestSeal.SignatureBase.
+/** Maximum covered signature-base components. */
 export const SIGNATURE_BASE_MAX_COMPONENTS = 256; // RequestSeal.SignatureBase.
+/** Maximum encoded signature or nonce bytes. */
 export const SIGNATURE_MAX_BYTES = 1024; // RequestSeal.SignatureFields (signature and nonce).
+/** Maximum raw HTTP target bytes. */
 export const MESSAGE_MAX_TARGET_BYTES = 16_384; // RequestSeal.Message.
+/** Maximum bytes in one HTTP field. */
 export const MESSAGE_MAX_FIELD_BYTES = 65_536; // RequestSeal.Message.Validation.
+/** Maximum total HTTP field bytes. */
 export const MESSAGE_MAX_FIELDS_BYTES = 1_048_576; // RequestSeal.Message.
+/** Maximum quorum evaluation nodes. */
 export const QUORUM_MAX_NODES = 131_072; // RequestSeal.Quorum.Evaluation.
+/** Maximum signatures evaluated by a quorum. */
 export const QUORUM_MAX_SIGNATURES = 64; // RequestSeal.Quorum.
+/** Default maximum discovery response bytes. */
 export const DISCOVERY_DEFAULT_MAX_BYTES = 65_536; // RequestSeal.Discovery.Source.
+/** Fixed maximum discovery response bytes. */
 export const DISCOVERY_MAX_BYTES = 1_048_576; // RequestSeal.Discovery.Source maximum.
+/** Maximum supported Unix timestamp in seconds. */
 export const CLOCK_MAX_SECONDS = 253_402_300_799; // Shared port contract, end of year 9999.
+/** Maximum operation timeout in milliseconds. */
 export const TIMEOUT_MAX_MS = 300_000; // RequestSeal.Custody and JOSE.Support.
+/** Default operation timeout in milliseconds. */
 export const TIMEOUT_DEFAULT_MS = 5000; // RequestSeal.Custody and JOSE.Support.
+/** Maximum absolute Structured Fields integer value. */
 export const SF_MAX_INTEGER = 999_999_999_999_999; // RequestSeal.StructuredFields, RFC 9651.
+/** Maximum profile metadata members. */
 export const PROFILE_MAX_MEMBERS = 8; // RequestSeal.Profile.
+/** Maximum profile metadata value bytes. */
 export const PROFILE_MAX_VALUE_BYTES = 256; // RequestSeal.Profile.
+/** Maximum profile name or key code points. */
+export const PROFILE_MAX_ATOM_CODE_POINTS = 255; // BEAM atom limit for profile names and keys.
+/** Maximum explicitly permitted discovery addresses. */
 export const DISCOVERY_MAX_PERMITTED_ADDRESSES = 16; // RequestSeal.Discovery.Source.
+/** Fixed maximum discovery keys per source. */
 export const DISCOVERY_MAX_KEYS = 256; // RequestSeal.Discovery.Source.
+/** Default maximum discovery keys per source. */
 export const DISCOVERY_DEFAULT_MAX_KEYS = 32; // RequestSeal.Discovery.Source.
+/** Maximum discovery redirect hops. */
 export const DISCOVERY_MAX_REDIRECTS = 3; // RequestSeal.Discovery.Source.
+/** Maximum discovery cache lifetime in seconds. */
 export const DISCOVERY_MAX_TTL_SECONDS = 604_800; // RequestSeal.Discovery.Source.
+/** Maximum negative discovery cache lifetime in seconds. */
 export const DISCOVERY_MAX_NEGATIVE_TTL_SECONDS = 300; // RequestSeal.Discovery.Source.
+/** Maximum client metadata document bytes. */
 export const DISCOVERY_CIMD_MAX_BYTES = 5120; // RequestSeal.Discovery.Source.
 // RequestSeal.PublicKey and Custody.Local container/component ceilings at v0.4.0 (b239287).
+/** Maximum encoded key container bytes. */
 export const KEY_MAX_BYTES = 16_384;
+/** Maximum key container members. */
 export const KEY_MAX_MEMBERS = 32;
+/** Maximum encoded public key component bytes. */
 export const KEY_COMPONENT_MAX_ENCODED_BYTES = 21_846;
+/** Maximum encoded RSA component bytes. */
 export const RSA_COMPONENT_MAX_ENCODED_BYTES = 1366;
+/** Minimum permitted RSA modulus bits. */
 export const RSA_MIN_BITS = 2048;
+/** Maximum permitted RSA modulus bits. */
 export const RSA_MAX_BITS = 8192;
+/** Maximum permitted RSA public exponent. */
 export const RSA_MAX_EXPONENT = 0xffff_ffff;
+/** Maximum caller-supplied key identity bytes. */
 export const KEY_IDENTITY_MAX_BYTES = 256;
+/** Minimum HMAC secret bytes. */
 export const HMAC_MIN_BYTES = 32;
+/** Maximum HMAC secret bytes. */
 export const HMAC_MAX_BYTES = 16_384;
 // Owned codec traversal ceilings; complete container bytes remain bounded above.
+/** Maximum DER container nesting depth. */
 export const DER_MAX_DEPTH = 32;
+/** Maximum DER traversal nodes. */
 export const DER_MAX_NODES = 4096;
+/** Maximum JWK algorithm identifier bytes. */
 export const JWK_ALGORITHM_MAX_BYTES = 64;
+/** Maximum JWK operation identifiers. */
 export const JWK_MAX_OPERATIONS = 8;
+/** Maximum custody signature bytes. */
 export const CUSTODY_SIGNATURE_MAX_BYTES = 16_384; // RequestSeal.Custody verify and successful signature bounds.
+/** Maximum combined HTTP header and trailer occurrences. */
 export const MESSAGE_MAX_OCCURRENCES = 1024; // Headers and trailers combined.
+/** Maximum HTTP method or field-name bytes. */
 export const MESSAGE_MAX_TOKEN_BYTES = 256; // Method and field names.
+/** Maximum HTTP scheme bytes. */
 export const MESSAGE_MAX_SCHEME_BYTES = 64;
+/** Maximum HTTP authority bytes. */
 export const MESSAGE_MAX_AUTHORITY_BYTES = 1024;
+/** Maximum combined HTTP URL bytes. */
 export const MESSAGE_MAX_URL_BYTES = MESSAGE_MAX_TARGET_BYTES + MESSAGE_MAX_AUTHORITY_BYTES + MESSAGE_MAX_SCHEME_BYTES + 8;
+/** Default maximum signature dictionary members. */
 export const SIGNATURE_DEFAULT_MAX_MEMBERS = 16; // RequestSeal.Authentication signing dictionary ceiling.
+/** Maximum freshness clock skew in seconds. */
 export const FRESHNESS_MAX_SKEW_SECONDS = 86_400; // RequestSeal.Policy.
+/** Random nonce bytes generated during signing. */
 export const SIGNING_NONCE_BYTES = 32; // RequestSeal.Signing entropy length.

package/dist/context.d.ts

@@ -1,12 +1,16 @@
 import { type Result } from './result.ts';
+/** A branded deadline and cancellation signal for an operation. */
 export type Context = Readonly<{
     deadline: number;
     signal: AbortSignal;
 }>;
+/** Check the private brand of an operation context. */
 export declare function isContext(value: unknown): value is Context;
+/** Create a bounded context from timeout, parent, and cancellation options. */
 export declare function withDeadline(options?: unknown): Result<Context>;
 /** Internal ownership release for a settled child; never releases its parent. */
 export declare function releaseContext(context: Context): void;
+/** Return the context's remaining time, or zero after cancellation. */
 export declare function remainingMs(context: Context): number;
 /** Runs share the absolute deadline. Each run holds a referenced timer until it
  * settles or the deadline passes, so a callback that never settles still ends with

package/dist/context.js

@@ -20,9 +20,11 @@ function then(promise, fulfilled, rejected) {
 }
 const contexts = new WeakSet();
 const lifetimes = new WeakMap();
+/** Check the private brand of an operation context. */
 export function isContext(value) {
     return typeof value === 'object' && value !== null && contexts.has(value);
 }
+/** Create a bounded context from timeout, parent, and cancellation options. */
 export function withDeadline(options = {}) {
     try {
         const snapshot = snapshotOptions(options, ['signal', 'timeoutMs', 'parent']);
@@ -129,6 +131,7 @@ export function withDeadline(options = {}) {
 export function releaseContext(context) {
     lifetimes.get(context)?.dispose();
 }
+/** Return the context's remaining time, or zero after cancellation. */
 export function remainingMs(context) {
     return isContext(context) && !context.signal.aborted ? Math.max(0, context.deadline - now()) : 0;
 }

package/dist/crypto/algorithm.d.ts

@@ -1,12 +1,17 @@
 import { type Result } from '../result.ts';
+/** Supported HTTP message signature algorithm tokens. */
 export type HttpAlgorithm = 'rsa-pss-sha512' | 'rsa-v1_5-sha256' | 'hmac-sha256' | 'ecdsa-p256-sha256' | 'ecdsa-p384-sha384' | 'ed25519';
+/** Supported JOSE signing algorithm identifiers. */
 export type JwsAlgorithm = 'RS256' | 'PS256' | 'PS384' | 'PS512' | 'HS256' | 'ES256' | 'ES384' | 'EdDSA';
+/** An HTTP algorithm token or an explicit JWS algorithm selector. */
 export type SigningAlgorithm = HttpAlgorithm | Readonly<{
     jws: JwsAlgorithm;
 }>;
+/** An explicit RSA-OAEP JWE unwrapping selector. */
 export type UnwrapAlgorithm = Readonly<{
     jwe: 'RSA-OAEP' | 'RSA-OAEP-256';
 }>;
+/** A signing or key-unwrapping algorithm selector. */
 export type CustodyAlgorithm = SigningAlgorithm | UnwrapAlgorithm;
 export type Spec = Readonly<{
     id: string;

package/dist/crypto/index.d.ts

@@ -1,9 +1,19 @@
 import { type Result } from '../result.ts';
 import { algorithms } from './algorithm.ts';
-export declare function sign(algorithm: unknown, key: unknown, data: unknown): Promise<Result<Uint8Array<ArrayBuffer>>>;
-export declare function verify(algorithm: unknown, key: unknown, signature: unknown, data: unknown): Promise<Result<true>>;
+/** Sign bounded bytes with a branded custody handle. */
+export declare function sign(algorithm: unknown, key: unknown, data: unknown, options?: unknown): Promise<Result<Uint8Array<ArrayBuffer>>>;
+/** Verify a signature using a branded key or custody handle. */
+export declare function verify(algorithm: unknown, key: unknown, signature: unknown, data: unknown, options?: unknown): Promise<Result<true>>;
+/** Return the fixed maximum cryptographic input byte limit. */
+export declare function maxBytesCeiling(): number;
+/** Bounded cryptographic signing and verification operations. */
 export declare const Crypto: Readonly<{
+    /** List supported HTTP signature algorithm tokens. */
     algorithms: typeof algorithms;
+    /** Sign bounded bytes with a branded custody handle. */
     sign: typeof sign;
+    /** Verify a signature using a branded key or custody handle. */
     verify: typeof verify;
+    /** Return the fixed maximum cryptographic input byte limit. */
+    maxBytesCeiling: typeof maxBytesCeiling;
 }>;

package/dist/crypto/index.js

@@ -1,11 +1,12 @@
-import { SIGNATURE_MAX_BYTES } from '../constants.js';
+import { byteLimit } from './options.js';
+import { CRYPTO_MAX_BYTES_CEILING, SIGNATURE_MAX_BYTES } from '../constants.js';
 import { err } from '../result.js';
 import { cryptoError } from '../errors/types.js';
 import { isKeyHandle, verifyHandle } from '../key_handle.js';
 import { isPublicKey, verifyPublicKey, bindPublicKey } from '../public_key.js';
 import { withDeadline } from '../context.js';
 import { resolveAlgorithm, algorithms } from './algorithm.js';
-import { dataBytes } from './primitive.js';
+import { dataBytes, boundedData, boundedBinary } from './primitive.js';
 function normalize(r) {
     if (r.ok)
         return r;
@@ -17,6 +18,7 @@ function normalize(r) {
         'unsupported_algorithm',
         'unsupported_format',
         'invalid_key',
+        'invalid_options',
         'key_mismatch',
         'invalid_data',
         'invalid_signature',
@@ -24,22 +26,32 @@ function normalize(r) {
         ? reason
         : 'invalid_key'));
 }
-export async function sign(algorithm, key, data) {
+/** Sign bounded bytes with a branded custody handle. */
+export async function sign(algorithm, key, data, options = {}) {
+    const maximum = byteLimit(options);
+    if (!maximum.ok)
+        return maximum;
     const spec = resolveAlgorithm(algorithm);
     if (!spec.ok)
         return spec;
+    if (!boundedData(data, maximum.value))
+        return err(cryptoError('invalid_data'));
     if (!isKeyHandle(key))
         return err(cryptoError('invalid_key'));
     const c = withDeadline();
     if (!c.ok)
         return err(cryptoError('invalid_key'));
-    return normalize(await key.sign(algorithm, data, c.value));
+    return normalize(await key.sign(algorithm, data, c.value, { maxBytes: maximum.value }));
 }
-export async function verify(algorithm, key, signature, data) {
+/** Verify a signature using a branded key or custody handle. */
+export async function verify(algorithm, key, signature, data, options = {}) {
+    const maximum = byteLimit(options);
+    if (!maximum.ok)
+        return maximum;
     const spec = resolveAlgorithm(algorithm);
     if (!spec.ok)
         return spec;
-    const bytes = dataBytes(data);
+    const bytes = dataBytes(data, maximum.value);
     if (!bytes.ok)
         return bytes;
     try {
@@ -55,15 +67,14 @@ export async function verify(algorithm, key, signature, data) {
         }
         else
             return err(cryptoError('invalid_key'));
-        if (!(signature instanceof Uint8Array) ||
-            signature.length > SIGNATURE_MAX_BYTES)
+        if (!boundedBinary(signature, SIGNATURE_MAX_BYTES))
             return err(cryptoError('invalid_signature'));
         if (isPublicKey(key))
-            return await verifyPublicKey(key, algorithm, signature, bytes.value);
+            return await verifyPublicKey(key, algorithm, signature, bytes.value, maximum.value);
         const c = withDeadline();
         if (!c.ok)
             return c;
-        return normalize(await verifyHandle(key, algorithm, signature, bytes.value, c.value));
+        return normalize(await verifyHandle(key, algorithm, signature, bytes.value, c.value, { maxBytes: maximum.value }));
     }
     catch {
         return err(cryptoError('invalid_signature'));
@@ -72,4 +83,16 @@ export async function verify(algorithm, key, signature, data) {
         bytes.value.fill(0);
     }
 }
-export const Crypto = Object.freeze({ algorithms, sign, verify });
+/** Return the fixed maximum cryptographic input byte limit. */
+export function maxBytesCeiling() { return CRYPTO_MAX_BYTES_CEILING; }
+/** Bounded cryptographic signing and verification operations. */
+export const Crypto = Object.freeze({
+    /** List supported HTTP signature algorithm tokens. */
+    algorithms,
+    /** Sign bounded bytes with a branded custody handle. */
+    sign,
+    /** Verify a signature using a branded key or custody handle. */
+    verify,
+    /** Return the fixed maximum cryptographic input byte limit. */
+    maxBytesCeiling
+});

package/dist/crypto/options.d.ts

@@ -0,0 +1,3 @@
+import { type Result } from '../result.ts';
+/** Read caller-owned operation options once, before algorithm or key resolution. */
+export declare function byteLimit(options: unknown): Result<number>;

package/dist/crypto/options.js

@@ -0,0 +1,15 @@
+import { snapshotOptions } from '../brand.js';
+import { CRYPTO_MAX_BYTES_CEILING, CRYPTO_DEFAULT_MAX_BYTES } from '../constants.js';
+import { cryptoError } from '../errors/types.js';
+import { err, ok } from '../result.js';
+/** Read caller-owned operation options once, before algorithm or key resolution. */
+export function byteLimit(options) {
+    const snapshot = snapshotOptions(options, ['maxBytes']);
+    if (!snapshot.ok)
+        return err(cryptoError('invalid_options'));
+    const value = Object.hasOwn(snapshot.value, 'maxBytes')
+        ? snapshot.value.maxBytes : CRYPTO_DEFAULT_MAX_BYTES;
+    return typeof value === 'number' && Number.isInteger(value) &&
+        value >= 1 && value <= CRYPTO_MAX_BYTES_CEILING
+        ? ok(value) : err(cryptoError('invalid_options'));
+}

package/dist/crypto/primitive.d.ts

@@ -1,6 +1,10 @@
 import { type Result } from '../result.ts';
 import { type Spec } from './algorithm.ts';
-export declare function dataBytes(input: unknown): Result<Uint8Array<ArrayBuffer>>;
+export declare function binaryByteLength(input: Uint8Array): number;
+export declare function boundedBinary(input: unknown, maximum: number): input is Uint8Array;
+/** Check the octet-string or intrinsic binary size without allocating a copy. */
+export declare function boundedData(input: unknown, maximum: number): boolean;
+export declare function dataBytes(input: unknown, maximum?: number): Result<Uint8Array<ArrayBuffer>>;
 export declare function unsigned(bytes: Uint8Array, little?: boolean): bigint;
-export declare function signKey(spec: Spec, key: CryptoKey, input: unknown): Promise<Result<Uint8Array<ArrayBuffer>>>;
-export declare function verifyKey(spec: Spec, key: CryptoKey, signature: unknown, input: unknown): Promise<Result<true>>;
+export declare function signKey(spec: Spec, key: CryptoKey, input: unknown, maximum?: number): Promise<Result<Uint8Array<ArrayBuffer>>>;
+export declare function verifyKey(spec: Spec, key: CryptoKey, signature: unknown, input: unknown, maximum?: number): Promise<Result<true>>;

package/dist/crypto/primitive.js

@@ -1,16 +1,41 @@
 import { byteString } from '../bytes.js';
-import { SIGNATURE_BASE_MAX_BYTES, SIGNATURE_MAX_BYTES } from '../constants.js';
+import { CRYPTO_DEFAULT_MAX_BYTES, SIGNATURE_MAX_BYTES } from '../constants.js';
 import { cryptoError } from '../errors/types.js';
 import { err, ok } from '../result.js';
 import { CURVE_ORDERS, ED25519_ORDER, operationParameters, } from './algorithm.js';
 import * as subtle from './subtle.js';
-export function dataBytes(input) {
+// Caller properties can shadow length and byteLength; capture the shared TypedArray getter.
+// Uint16Array reaches that intrinsic even when Uint8Array allocations are instrumented.
+const byteLength = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(Uint16Array.prototype), 'byteLength').get;
+export function binaryByteLength(input) {
+    return byteLength.call(input);
+}
+export function boundedBinary(input, maximum) {
+    try {
+        return input instanceof Uint8Array && binaryByteLength(input) <= maximum;
+    }
+    catch {
+        return false;
+    }
+}
+/** Check the octet-string or intrinsic binary size without allocating a copy. */
+export function boundedData(input, maximum) {
+    if (typeof input !== 'string')
+        return boundedBinary(input, maximum);
+    if (input.length > maximum)
+        return false;
+    // Mirrors byteString's octet-string rule without allocating the copy it makes.
+    for (let i = 0; i < input.length; i++)
+        if (input.charCodeAt(i) > 255)
+            return false;
+    return true;
+}
+export function dataBytes(input, maximum = CRYPTO_DEFAULT_MAX_BYTES) {
     try {
-        if ((!(input instanceof Uint8Array) && typeof input !== 'string') ||
-            input.length > SIGNATURE_BASE_MAX_BYTES)
+        if (!boundedData(input, maximum))
             return err(cryptoError('invalid_data'));
         const r = byteString(input);
-        return r.ok ? r : err(cryptoError('invalid_data'));
+        return r.ok && r.value.length <= maximum ? r : err(cryptoError('invalid_data'));
     }
     catch {
         return err(cryptoError('invalid_data'));
@@ -37,7 +62,8 @@ function signatureValid(spec, key, bytes) {
     const width = spec.family === 'rsa'
         ? Math.ceil(key.algorithm.modulusLength / 8)
         : spec.width;
-    if (bytes.length !== width || bytes.length > SIGNATURE_MAX_BYTES)
+    const size = binaryByteLength(bytes);
+    if (size !== width || size > SIGNATURE_MAX_BYTES)
         return false;
     if (spec.family === 'ec') {
         const r = unsigned(bytes.subarray(0, width / 2)), s = unsigned(bytes.subarray(width / 2)), order = CURVE_ORDERS[spec.curve];
@@ -47,8 +73,8 @@ function signatureValid(spec, key, bytes) {
         return unsigned(bytes.subarray(32), true) < ED25519_ORDER;
     return true;
 }
-export async function signKey(spec, key, input) {
-    const data = dataBytes(input);
+export async function signKey(spec, key, input, maximum = CRYPTO_DEFAULT_MAX_BYTES) {
+    const data = dataBytes(input, maximum);
     if (!data.ok)
         return data;
     try {
@@ -66,8 +92,8 @@ export async function signKey(spec, key, input) {
         data.value.fill(0);
     }
 }
-export async function verifyKey(spec, key, signature, input) {
-    const data = dataBytes(input);
+export async function verifyKey(spec, key, signature, input, maximum = CRYPTO_DEFAULT_MAX_BYTES) {
+    const data = dataBytes(input, maximum);
     if (!data.ok)
         return data;
     try {

package/dist/custody/content_key.d.ts

@@ -1,9 +1,13 @@
 import { type Context } from '../context.ts';
 import { type Result } from '../result.ts';
+/** A confined AES decryption capability without an exported key. */
 export type UnwrappedKey = Readonly<{
     length: 128 | 256;
+    /** Authenticate and decrypt content using confined key material. */
     decrypt: (ciphertext: unknown, options: unknown, context: Context) => Promise<Result<Uint8Array<ArrayBuffer>>>;
+    /** Release retained custody and invalidate the capability. */
     release: () => Promise<Result<true>>;
 }>;
+/** Check the private brand of an unwrapped content key. */
 export declare function isUnwrappedKey(value: unknown): value is UnwrappedKey;
 export declare function confineContentKey(key: CryptoKey): UnwrappedKey;

package/dist/custody/content_key.js

@@ -1,3 +1,4 @@
+import { denoInspection } from '../brand.js';
 import { snapshotOptions } from '../brand.js';
 import { isContext, remainingMs, run } from '../context.js';
 import { JOSE_MAX_PLAINTEXT_BYTES, JOSE_MAX_COMPACT_BYTES, } from '../constants.js';
@@ -6,6 +7,7 @@ import { err, ok } from '../result.js';
 import * as subtle from '../crypto/subtle.js';
 const keys = new WeakSet();
 const token = Object.freeze({});
+/** Check the private brand of an unwrapped content key. */
 export function isUnwrappedKey(value) {
     return typeof value === 'object' && value !== null && keys.has(value);
 }
@@ -88,8 +90,8 @@ class ContentKey {
     [Symbol.for('nodejs.util.inspect.custom')]() {
         return this.toJSON();
     }
-    [Symbol.for('Deno.customInspect')]() {
-        return this.toJSON();
+    [Symbol.for('Deno.customInspect')](render) {
+        return denoInspection(render, this.toJSON());
     }
 }
 export function confineContentKey(key) {

package/dist/custody/index.d.ts

@@ -1,4 +1,6 @@
 import { local } from './local.ts';
+/** Caller-owned local cryptographic custody constructors. */
 export declare const Custody: Readonly<{
+    /** Import caller-owned local key material into a confined capability. */
     local: typeof local;
 }>;

package/dist/custody/index.js

@@ -1,2 +1,6 @@
 import { local } from './local.js';
-export const Custody = Object.freeze({ local });
+/** Caller-owned local cryptographic custody constructors. */
+export const Custody = Object.freeze({
+    /** Import caller-owned local key material into a confined capability. */
+    local
+});

package/dist/custody/local.d.ts

@@ -1,4 +1,20 @@
 import { type Result } from '../result.ts';
-import { type KeyHandle } from '../key_handle.ts';
+import { type Context } from '../context.ts';
+import { type KeyHandle, type Custodian } from '../key_handle.ts';
+import { KeyIdentity } from '../key_identity.ts';
+import { PublicKey } from '../public_key.ts';
+import { type Spec } from '../crypto/algorithm.ts';
+import { type UnwrappedKey } from './content_key.ts';
+/** @internal Direct custodian implementation; use the public factory for handles. */
+export declare class LocalPort implements Custodian {
+    #private;
+    constructor(key: CryptoKey, verify: CryptoKey | undefined, publicKey: PublicKey | undefined, identity: KeyIdentity, spec: Spec);
+    sign(_algorithm: unknown, data: unknown, _context: Context): Promise<Result<Uint8Array<ArrayBuffer>>>;
+    verify(_algorithm: unknown, signature: unknown, data: unknown, _context: Context): Promise<Result<true>>;
+    publicKey(): Promise<Result<PublicKey>>;
+    identity(): Promise<Result<KeyIdentity>>;
+    unwrap(_algorithm: unknown, wrappedKey: unknown, _context: Context, options?: unknown): Promise<Result<UnwrappedKey>>;
+    release(): Promise<Result<true>>;
+}
 /** Import explicitly owned material. All persistent CryptoKey references stay in private fields. */
 export declare function local(algorithm: unknown, material: unknown, options?: unknown): Promise<Result<KeyHandle>>;

package/dist/custody/local.js

@@ -1,5 +1,5 @@
 import { snapshotOptions } from '../brand.js';
-import { HMAC_MIN_BYTES, HMAC_MAX_BYTES, KEY_MAX_BYTES, SIGNATURE_MAX_BYTES, } from '../constants.js';
+import { CRYPTO_MAX_BYTES_CEILING, HMAC_MIN_BYTES, HMAC_MAX_BYTES, KEY_MAX_BYTES, SIGNATURE_MAX_BYTES, } from '../constants.js';
 import { custodyError } from '../errors/types.js';
 import { err, ok } from '../result.js';
 import { withDeadline, run } from '../context.js';
@@ -7,12 +7,13 @@ import { createKeyHandle, } from '../key_handle.js';
 import { KeyIdentity } from '../key_identity.js';
 import { PublicKey } from '../public_key.js';
 import { resolveAlgorithm, selection, importParameters, } from '../crypto/algorithm.js';
-import { signKey, verifyKey } from '../crypto/primitive.js';
+import { boundedBinary, signKey, verifyKey } from '../crypto/primitive.js';
 import * as subtle from '../crypto/subtle.js';
 import { decodeKey, publicSpki } from './der.js';
 import { component, snapshotJwk, publicMembers, publicMetadata, compatible, permitted, } from './jwk.js';
 import { confineContentKey } from './content_key.js';
-class LocalPort {
+/** @internal Direct custodian implementation; use the public factory for handles. */
+export class LocalPort {
     #key;
     #verify;
     #public;
@@ -27,13 +28,17 @@ class LocalPort {
         Object.freeze(this);
     }
     async sign(_algorithm, data, _context) {
+        if (!boundedBinary(data, CRYPTO_MAX_BYTES_CEILING))
+            return err(custodyError('invalid_data'));
         return this.#key
-            ? signKey(this.#spec, this.#key, data)
+            ? signKey(this.#spec, this.#key, data, CRYPTO_MAX_BYTES_CEILING)
             : err(custodyError('key_not_found'));
     }
     async verify(_algorithm, signature, data, _context) {
+        if (!boundedBinary(data, CRYPTO_MAX_BYTES_CEILING))
+            return err(custodyError('invalid_data'));
         return this.#verify
-            ? verifyKey(this.#spec, this.#verify, signature, data)
+            ? verifyKey(this.#spec, this.#verify, signature, data, CRYPTO_MAX_BYTES_CEILING)
             : err(custodyError('key_not_found'));
     }
     async publicKey() {

package/dist/custody/ssh-agent/index.d.ts

@@ -2,6 +2,8 @@ import { type KeyHandle } from "../../key_handle.ts";
 import { type Result } from "../../result.ts";
 /** Caller-selected local socket and trusted public components; no environment discovery. */
 export declare function createSshAgent(algorithm: unknown, socketPath: unknown, publicKey: unknown, options?: unknown): Promise<Result<KeyHandle>>;
+/** Caller-selected OpenSSH agent custody construction. */
 export declare const SSHAgent: Readonly<{
+    /** Bind an algorithm and public key to a caller-selected OpenSSH agent socket. */
     create: typeof createSshAgent;
 }>;