@private.me/xbind 1.3.0 → 2.3.4

package/dist-standalone/_deps/crypto/cjs/tlv.js

@@ -1,199 +0,0 @@
-"use strict";
-/**
- * TLV (Type-Length-Value) serialization for Xail messages.
- *
- * Format: [Type: 1 byte][Length: 4 bytes uint32 BE][Value: Length bytes]
- *
- * Serialization order: MESSAGE_UUID, SENDER_ID, TIMESTAMP, CONTENT_TYPE,
- * MESSAGE_BODY, ATTACHMENT(s).
- *
- * HMAC key/signature and per-share metadata are NOT in the TLV payload —
- * they travel in the share envelope.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.serializeMessage = serializeMessage;
-exports.deserializeMessage = deserializeMessage;
-const shared_1 = require("../../shared/index.js");
-const uuid_js_1 = require("./uuid.js");
-const TEXT_ENCODER = new TextEncoder();
-const TEXT_DECODER = new TextDecoder();
-/**
- * Serialize a XailMessage into a TLV byte stream.
- *
- * @param message - Message to serialize
- * @returns TLV-encoded byte array
- */
-function serializeMessage(message) {
-    const parts = [];
-    // MESSAGE_UUID
-    parts.push(encodeTlv(shared_1.TLV_TYPE.MESSAGE_UUID, (0, uuid_js_1.uuidToBytes)(message.uuid)));
-    // SENDER_ID
-    parts.push(encodeTlv(shared_1.TLV_TYPE.SENDER_ID, TEXT_ENCODER.encode(message.sender.name)));
-    // SENDER_EMAIL (optional — preserves sender's email across reconstruction)
-    const senderEmail = message.sender.channels[0]?.email;
-    if (senderEmail) {
-        parts.push(encodeTlv(shared_1.TLV_TYPE.SENDER_EMAIL, TEXT_ENCODER.encode(senderEmail)));
-    }
-    // TIMESTAMP (8 bytes, uint64 big-endian)
-    const tsBuf = new Uint8Array(8);
-    const tsView = new DataView(tsBuf.buffer);
-    // Split into high 32 and low 32 bits
-    tsView.setUint32(0, Math.floor(message.timestamp / 0x100000000));
-    tsView.setUint32(4, message.timestamp >>> 0);
-    parts.push(encodeTlv(shared_1.TLV_TYPE.TIMESTAMP, tsBuf));
-    // CONTENT_TYPE
-    parts.push(encodeTlv(shared_1.TLV_TYPE.CONTENT_TYPE, TEXT_ENCODER.encode(message.contentType)));
-    // MESSAGE_SUBJECT (optional)
-    if (message.subject) {
-        parts.push(encodeTlv(shared_1.TLV_TYPE.MESSAGE_SUBJECT, TEXT_ENCODER.encode(message.subject)));
-    }
-    // MESSAGE_BODY
-    parts.push(encodeTlv(shared_1.TLV_TYPE.MESSAGE_BODY, TEXT_ENCODER.encode(message.body)));
-    // ATTACHMENTs
-    for (const att of message.attachments) {
-        parts.push(encodeTlv(shared_1.TLV_TYPE.ATTACHMENT, encodeAttachment(att)));
-    }
-    // Concatenate all parts
-    const totalLen = parts.reduce((sum, p) => sum + p.length, 0);
-    const result = new Uint8Array(totalLen);
-    let offset = 0;
-    for (const part of parts) {
-        result.set(part, offset);
-        offset += part.length;
-    }
-    return result;
-}
-/**
- * Deserialize a TLV byte stream into a XailMessage.
- *
- * @param data - TLV-encoded byte array
- * @returns Deserialized message, or SerializationError if invalid
- */
-function deserializeMessage(data) {
-    let uuid = '';
-    let senderName = '';
-    let senderEmail = '';
-    let subject = '';
-    let timestamp = 0;
-    let contentType = 'text/plain';
-    let body = '';
-    const attachments = [];
-    let offset = 0;
-    while (offset < data.length) {
-        if (offset + 5 > data.length) {
-            return (0, shared_1.err)({ code: 'INVALID_TLV', message: 'Truncated TLV header' });
-        }
-        const type = data[offset];
-        const view = new DataView(data.buffer, data.byteOffset + offset + 1, 4);
-        const length = view.getUint32(0);
-        offset += 5;
-        if (offset + length > data.length) {
-            return (0, shared_1.err)({ code: 'BUFFER_OVERFLOW', message: `TLV value exceeds data length at type 0x${type.toString(16)}` });
-        }
-        const value = data.slice(offset, offset + length);
-        offset += length;
-        switch (type) {
-            case shared_1.TLV_TYPE.MESSAGE_UUID:
-                if (value.length !== 16) {
-                    return (0, shared_1.err)({ code: 'INVALID_TLV', message: 'UUID must be 16 bytes' });
-                }
-                uuid = (0, uuid_js_1.bytesToUuid)(value);
-                break;
-            case shared_1.TLV_TYPE.SENDER_ID:
-                senderName = TEXT_DECODER.decode(value);
-                break;
-            case shared_1.TLV_TYPE.SENDER_EMAIL:
-                senderEmail = TEXT_DECODER.decode(value);
-                break;
-            case shared_1.TLV_TYPE.TIMESTAMP: {
-                if (value.length !== 8) {
-                    return (0, shared_1.err)({ code: 'INVALID_TLV', message: 'Timestamp must be 8 bytes' });
-                }
-                const tsView = new DataView(value.buffer, value.byteOffset, 8);
-                const hi = tsView.getUint32(0);
-                const lo = tsView.getUint32(4);
-                timestamp = hi * 0x100000000 + lo;
-                break;
-            }
-            case shared_1.TLV_TYPE.CONTENT_TYPE: {
-                const ct = TEXT_DECODER.decode(value);
-                if (ct === 'text/plain' || ct === 'text/html') {
-                    contentType = ct;
-                }
-                break;
-            }
-            case shared_1.TLV_TYPE.MESSAGE_SUBJECT:
-                subject = TEXT_DECODER.decode(value);
-                break;
-            case shared_1.TLV_TYPE.MESSAGE_BODY:
-                body = TEXT_DECODER.decode(value);
-                break;
-            case shared_1.TLV_TYPE.ATTACHMENT:
-                attachments.push(decodeAttachment(value));
-                break;
-            default:
-                // Unknown type — skip (forward compatibility)
-                break;
-        }
-    }
-    if (!uuid) {
-        return (0, shared_1.err)({ code: 'MISSING_FIELD', message: 'Missing MESSAGE_UUID' });
-    }
-    return (0, shared_1.ok)({
-        uuid,
-        sender: {
-            name: senderName,
-            channels: senderEmail
-                ? [{ provider: 'imap', email: senderEmail }]
-                : [],
-            securityTier: null,
-            isEnterprise: false,
-        },
-        recipients: [],
-        ...(subject ? { subject } : {}),
-        body,
-        contentType,
-        attachments,
-        timestamp,
-        messageType: 'secure',
-    });
-}
-/** Encode a single TLV entry. */
-function encodeTlv(type, value) {
-    const entry = new Uint8Array(5 + value.length);
-    entry[0] = type;
-    const view = new DataView(entry.buffer, 1, 4);
-    view.setUint32(0, value.length);
-    entry.set(value, 5);
-    return entry;
-}
-/**
- * Encode an attachment: filename (null-terminated, up to 255 bytes) + content.
- */
-function encodeAttachment(att) {
-    const nameBytes = TEXT_ENCODER.encode(att.filename);
-    const mimeBytes = TEXT_ENCODER.encode(att.mimeType);
-    // Format: [nameLen:1][name][mimeLen:1][mime][data]
-    const result = new Uint8Array(1 + nameBytes.length + 1 + mimeBytes.length + att.data.length);
-    let off = 0;
-    result[off++] = nameBytes.length;
-    result.set(nameBytes, off);
-    off += nameBytes.length;
-    result[off++] = mimeBytes.length;
-    result.set(mimeBytes, off);
-    off += mimeBytes.length;
-    result.set(att.data, off);
-    return result;
-}
-/** Decode an attachment from the encoded format. */
-function decodeAttachment(data) {
-    let off = 0;
-    const nameLen = data[off++];
-    const filename = TEXT_DECODER.decode(data.slice(off, off + nameLen));
-    off += nameLen;
-    const mimeLen = data[off++];
-    const mimeType = TEXT_DECODER.decode(data.slice(off, off + mimeLen));
-    off += mimeLen;
-    const content = data.slice(off);
-    return { filename, mimeType, data: content };
-}

package/dist-standalone/_deps/crypto/cjs/uuid.js

@@ -1,61 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateUUID = generateUUID;
-exports.uuidToBytes = uuidToBytes;
-exports.bytesToUuid = bytesToUuid;
-/**
- * Generate a RFC 4122 Version 4 UUID (128-bit random).
- * Uses crypto.randomUUID() when available, otherwise constructs manually
- * from crypto.getRandomValues() with proper version/variant bits.
- *
- * @returns UUID string in standard 8-4-4-4-12 hex format
- */
-function generateUUID() {
-    if (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function') {
-        return crypto.randomUUID();
-    }
-    const bytes = new Uint8Array(16);
-    crypto.getRandomValues(bytes);
-    // Set version 4 (bits 12-15 of time_hi_and_version)
-    bytes[6] = (bytes[6] & 0x0f) | 0x40;
-    // Set variant 10xx (bits 6-7 of clock_seq_hi_and_reserved)
-    bytes[8] = (bytes[8] & 0x3f) | 0x80;
-    const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, '0')).join('');
-    return [
-        hex.slice(0, 8),
-        hex.slice(8, 12),
-        hex.slice(12, 16),
-        hex.slice(16, 20),
-        hex.slice(20, 32),
-    ].join('-');
-}
-/**
- * Parse a UUID string into its raw 16 bytes.
- *
- * @param uuid - UUID string in 8-4-4-4-12 hex format
- * @returns 16-byte Uint8Array
- */
-function uuidToBytes(uuid) {
-    const hex = uuid.replace(/-/g, '');
-    const bytes = new Uint8Array(16);
-    for (let i = 0; i < 16; i++) {
-        bytes[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
-    }
-    return bytes;
-}
-/**
- * Convert raw 16 UUID bytes to the standard string format.
- *
- * @param bytes - 16-byte Uint8Array
- * @returns UUID string in 8-4-4-4-12 hex format
- */
-function bytesToUuid(bytes) {
-    const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, '0')).join('');
-    return [
-        hex.slice(0, 8),
-        hex.slice(8, 12),
-        hex.slice(12, 16),
-        hex.slice(16, 20),
-        hex.slice(20, 32),
-    ].join('-');
-}

package/dist-standalone/_deps/crypto/cjs/verify.js

@@ -1,24 +0,0 @@
-"use strict";
-/**
- * @module verify
- * Lightweight sub-path export for verification-only use cases.
- *
- * Import as `@private.me/crypto/verify` for tree-shaking:
- * ```ts
- * import { verifyHMAC, fromBase64, isSupported } from '@private.me/crypto/verify';
- * ```
- *
- * This module re-exports only HMAC verification, base64 decoding,
- * and the capability check — no splitting, no reconstruction, no padding.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isSupported = exports.toBase64Url = exports.fromBase64Url = exports.toBase64 = exports.fromBase64 = exports.verifyHMAC = void 0;
-var hmac_js_1 = require("./hmac.js");
-Object.defineProperty(exports, "verifyHMAC", { enumerable: true, get: function () { return hmac_js_1.verifyHMAC; } });
-var base64_js_1 = require("./base64.js");
-Object.defineProperty(exports, "fromBase64", { enumerable: true, get: function () { return base64_js_1.fromBase64; } });
-Object.defineProperty(exports, "toBase64", { enumerable: true, get: function () { return base64_js_1.toBase64; } });
-Object.defineProperty(exports, "fromBase64Url", { enumerable: true, get: function () { return base64_js_1.fromBase64Url; } });
-Object.defineProperty(exports, "toBase64Url", { enumerable: true, get: function () { return base64_js_1.toBase64Url; } });
-var index_js_1 = require("./index.js");
-Object.defineProperty(exports, "isSupported", { enumerable: true, get: function () { return index_js_1.isSupported; } });

package/dist-standalone/_deps/crypto/cjs/xorida.js

@@ -1,221 +0,0 @@
-"use strict";
-/**
- * XorIDA Threshold Secret Sharing over GF(2).
- *
- * Proprietary, patent-protected (k,n)-threshold secret sharing construction.
- *
- * All arithmetic is XOR (GF(2)). The generator matrix is constructed from a cyclic
- * index formula using NextOddPrime(n). Any k-of-n shares reconstruct the original
- * message via Gaussian elimination on the restricted generator matrix.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.nextOddPrime = nextOddPrime;
-exports.splitXorIDA = splitXorIDA;
-exports.splitWithRandom = splitWithRandom;
-exports.reconstructXorIDA = reconstructXorIDA;
-/**
- * Find the smallest odd prime >= n.
- * Used to determine the cyclic group Z_p for generator matrix construction.
- *
- * @param n - Total number of shares
- * @returns Smallest odd prime >= n
- */
-function nextOddPrime(n) {
-    let i = n;
-    while (true) {
-        if (i >= 2 && isOddPrime(i))
-            return i;
-        i++;
-    }
-}
-/** Max bytes per crypto.getRandomValues call (Web Crypto API limit). */
-const MAX_RANDOM_CHUNK = 65536;
-/** Fill a Uint8Array with cryptographic random bytes, chunked to respect API limits. */
-function fillRandom(arr) {
-    for (let offset = 0; offset < arr.length; offset += MAX_RANDOM_CHUNK) {
-        const end = Math.min(offset + MAX_RANDOM_CHUNK, arr.length);
-        crypto.getRandomValues(arr.subarray(offset, end));
-    }
-}
-/** Check if a number is an odd prime. */
-function isOddPrime(n) {
-    if (n < 2)
-        return false;
-    if (n === 2)
-        return false; // even
-    if (n === 3)
-        return true;
-    if (n % 2 === 0)
-        return false;
-    for (let d = 3; d * d <= n; d += 2) {
-        if (n % d === 0)
-            return false;
-    }
-    return true;
-}
-/**
- * Split a padded message into n shares using XorIDA threshold sharing.
- *
- * The message length must be a multiple of b = NextOddPrime(n) - 1.
- * Each share is the same length as the input message.
- *
- * @param paddedMessage - PKCS#7-padded message (length must be multiple of b)
- * @param n - Total number of shares to produce
- * @param k - Threshold: minimum shares needed for reconstruction
- * @returns Array of n shares, each the same length as paddedMessage
- */
-function splitXorIDA(paddedMessage, n, k) {
-    const p = nextOddPrime(n);
-    const b = p - 1;
-    if (paddedMessage.length === 0 || paddedMessage.length % b !== 0) {
-        throw new Error(`Message length ${paddedMessage.length} is not a multiple of block size ${b}`);
-    }
-    return splitWithRandom(paddedMessage, n, k, p, b);
-}
-/**
- * Split with externally provided random source arrays (for testing with known vectors).
- * @internal Exported for testing only.
- */
-function splitWithRandom(paddedMessage, n, k, p, b, randomArrays) {
-    const msgLen = paddedMessage.length;
-    const numBlocks = msgLen / b;
-    // Step 1: Create k source arrays — (k-1) random + message
-    const sourceArrays = [];
-    for (let i = 0; i < k - 1; i++) {
-        const provided = randomArrays?.[i];
-        if (provided) {
-            sourceArrays.push(provided);
-        }
-        else {
-            const rand = new Uint8Array(msgLen);
-            fillRandom(rand);
-            sourceArrays.push(rand);
-        }
-    }
-    sourceArrays.push(paddedMessage);
-    // Step 2: Construct each share using the generator matrix index formula
-    const shares = [];
-    for (let shareIdx = 0; shareIdx < n; shareIdx++) {
-        const share = new Uint8Array(msgLen);
-        for (let blockIdx = 0; blockIdx < numBlocks; blockIdx++) {
-            const blockOffset = blockIdx * b;
-            for (let destRow = 0; destRow < b; destRow++) {
-                for (let srcCol = 0; srcCol < k; srcCol++) {
-                    const srcRow = (destRow + shareIdx * srcCol) % p;
-                    if (srcRow < b) {
-                        share[blockOffset + destRow] ^=
-                            sourceArrays[srcCol][blockOffset + srcRow];
-                    }
-                }
-            }
-        }
-        shares.push(share);
-    }
-    return shares;
-}
-/**
- * Reconstruct the padded message from k shares via GF(2) Gaussian elimination.
- *
- * @param shares - Array of k share byte arrays
- * @param indices - Original indices (0-based) of the provided shares
- * @param n - Total number of shares that were produced
- * @param k - Threshold used during splitting
- * @returns Reconstructed padded message
- */
-function reconstructXorIDA(shares, indices, n, k) {
-    if (shares.length !== k || indices.length !== k) {
-        throw new Error(`Expected ${k} shares, got ${shares.length}`);
-    }
-    const p = nextOddPrime(n);
-    const b = p - 1;
-    const shareLen = shares[0].length;
-    const numBlocks = shareLen / b;
-    // Step 1: Build restricted generator matrix G (k*b rows × k*b cols)
-    const numRows = k * b;
-    const numCols = k * b;
-    const recoveryMatrix = buildAndSolve(indices, k, p, b, numRows, numCols);
-    // Step 2: Apply recovery matrix to extract message bytes
-    const result = new Uint8Array(shareLen);
-    for (let blockIdx = 0; blockIdx < numBlocks; blockIdx++) {
-        const blockOffset = blockIdx * b;
-        for (let destByte = 0; destByte < b; destByte++) {
-            // Skip random rows, use message rows: row index = (k-1)*b + destByte
-            const recoveryRow = (k - 1) * b + destByte;
-            let val = 0;
-            for (let c = 0; c < numRows; c++) {
-                if (recoveryMatrix[recoveryRow][c]) {
-                    const localShareIdx = Math.floor(c / b);
-                    const byteInBlock = c % b;
-                    val ^= shares[localShareIdx][blockOffset + byteInBlock];
-                }
-            }
-            result[blockOffset + destByte] = val;
-        }
-    }
-    return result;
-}
-/**
- * Build the restricted generator matrix and solve via Gaussian elimination.
- * Returns the recovery matrix (right portion of [G|I] after elimination).
- */
-function buildAndSolve(shareIndices, k, p, b, numRows, numCols) {
-    // Build augmented matrix [G | I] using Uint8Array rows
-    const totalCols = numCols + numRows;
-    const aug = [];
-    for (let i = 0; i < k; i++) {
-        const shareIdx = shareIndices[i];
-        for (let rowInShare = 0; rowInShare < b; rowInShare++) {
-            const row = new Uint8Array(totalCols);
-            const destRow = i * b + rowInShare;
-            // Fill generator matrix portion
-            for (let srcCol = 0; srcCol < k; srcCol++) {
-                const srcRow = (rowInShare + shareIdx * srcCol) % p;
-                if (srcRow < b) {
-                    row[srcCol * b + srcRow] = 1;
-                }
-            }
-            // Fill identity portion
-            row[numCols + destRow] = 1;
-            aug.push(row);
-        }
-    }
-    // Gaussian elimination over GF(2)
-    let pivotRow = 0;
-    for (let col = 0; col < numCols; col++) {
-        // Find pivot
-        let found = -1;
-        for (let r = pivotRow; r < numRows; r++) {
-            if (aug[r][col]) {
-                found = r;
-                break;
-            }
-        }
-        if (found === -1)
-            continue;
-        // Swap
-        if (found !== pivotRow) {
-            const tmp = aug[found];
-            aug[found] = aug[pivotRow];
-            aug[pivotRow] = tmp;
-        }
-        // Eliminate
-        for (let r = 0; r < numRows; r++) {
-            if (r !== pivotRow && aug[r][col]) {
-                xorRow(aug[r], aug[pivotRow]);
-            }
-        }
-        pivotRow++;
-    }
-    // Extract recovery matrix (right portion)
-    const recovery = [];
-    for (let r = 0; r < numRows; r++) {
-        recovery.push(aug[r].slice(numCols));
-    }
-    return recovery;
-}
-/** XOR row b into row a (in-place). */
-function xorRow(a, b) {
-    for (let i = 0; i < a.length; i++) {
-        a[i] ^= b[i];
-    }
-}

package/dist-standalone/_deps/crypto/errors.d.ts

@@ -1,51 +0,0 @@
-/**
- * @module errors
- * Named error class hierarchy for @private.me/crypto.
- *
- * Provides structured error types for XorIDA threshold sharing,
- * HMAC integrity verification, PKCS#7 padding, and TLV serialization.
- */
-/** Base error class for all crypto operations. */
-export declare class CryptoError extends Error {
-    readonly code: string;
-    readonly subCode?: string;
-    readonly docUrl?: string;
-    constructor(code: string, message: string, docUrl?: string);
-}
-/** Error thrown during XorIDA split or reconstruction operations. */
-export declare class CryptoSplitError extends CryptoError {
-    constructor(code: string, message: string);
-}
-/** Error thrown when HMAC integrity verification fails. */
-export declare class CryptoIntegrityError extends CryptoError {
-    constructor(code: string, message: string);
-}
-/** Error thrown for PKCS#7 padding issues. */
-export declare class CryptoPaddingError extends CryptoError {
-    constructor(code: string, message: string);
-}
-/** Error thrown during TLV serialization or deserialization. */
-export declare class CryptoSerializationError extends CryptoError {
-    constructor(code: string, message: string);
-}
-/** Human-readable messages for each error code. */
-export declare const ERROR_MESSAGES: Record<string, string>;
-/**
- * Detailed descriptions for each error code.
- * Maps error codes to comprehensive explanations including cause and resolution.
- */
-export declare const ERROR_DETAILS: Record<string, string>;
-/**
- * Convert an unknown error into a CryptoError.
- *
- * @param error - The unknown error to convert
- * @returns A CryptoError instance
- */
-export declare function toCryptoError(error: unknown): CryptoError;
-/**
- * Type guard to check if an error is a CryptoError.
- *
- * @param error - The value to check
- * @returns true if the value is a CryptoError instance
- */
-export declare function isCryptoError(error: unknown): error is CryptoError;

package/dist-standalone/_deps/crypto/errors.js

@@ -1,109 +0,0 @@
-/**
- * @module errors
- * Named error class hierarchy for @private.me/crypto.
- *
- * Provides structured error types for XorIDA threshold sharing,
- * HMAC integrity verification, PKCS#7 padding, and TLV serialization.
- */
-const DOC_BASE = 'https://private.me/docs/packages/crypto';
-/** Base error class for all crypto operations. */
-export class CryptoError extends Error {
-    code;
-    subCode;
-    docUrl;
-    constructor(code, message, docUrl) {
-        super(message);
-        this.name = 'CryptoError';
-        const parts = code.split(':');
-        this.code = parts[0] ?? code;
-        this.subCode = parts.length > 1 ? parts.slice(1).join(':') : undefined;
-        this.docUrl = docUrl;
-    }
-}
-/** Error thrown during XorIDA split or reconstruction operations. */
-export class CryptoSplitError extends CryptoError {
-    constructor(code, message) {
-        super(code, message, `${DOC_BASE}#splitting`);
-        this.name = 'CryptoSplitError';
-    }
-}
-/** Error thrown when HMAC integrity verification fails. */
-export class CryptoIntegrityError extends CryptoError {
-    constructor(code, message) {
-        super(code, message, `${DOC_BASE}#integrity`);
-        this.name = 'CryptoIntegrityError';
-    }
-}
-/** Error thrown for PKCS#7 padding issues. */
-export class CryptoPaddingError extends CryptoError {
-    constructor(code, message) {
-        super(code, message, `${DOC_BASE}#padding`);
-        this.name = 'CryptoPaddingError';
-    }
-}
-/** Error thrown during TLV serialization or deserialization. */
-export class CryptoSerializationError extends CryptoError {
-    constructor(code, message) {
-        super(code, message, `${DOC_BASE}#serialization`);
-        this.name = 'CryptoSerializationError';
-    }
-}
-/** Human-readable messages for each error code. */
-export const ERROR_MESSAGES = {
-    SPLIT_FAILED: 'XorIDA split operation failed',
-    RECONSTRUCTION_FAILED: 'XorIDA reconstruction failed',
-    INSUFFICIENT_SHARES: 'Not enough shares provided for reconstruction',
-    INVALID_SHARES: 'Shares have inconsistent UUID, n, or k values',
-    INVALID_INDEX: 'Share index is out of range or duplicated',
-    HMAC_FAILURE: 'HMAC integrity verification failed -- data may be corrupted',
-    UUID_MISMATCH: 'Envelope UUID does not match TLV payload UUID',
-    INVALID_PADDING: 'PKCS#7 padding is invalid or corrupted',
-    INVALID_TLV: 'TLV buffer is malformed or truncated',
-    BUFFER_OVERFLOW: 'TLV value length exceeds buffer bounds',
-    MISSING_FIELD: 'Required TLV field is missing from serialized data',
-    INVALID_CONFIG: 'Split configuration is invalid (n < 2, k < 2, or k > n)',
-};
-/**
- * Detailed descriptions for each error code.
- * Maps error codes to comprehensive explanations including cause and resolution.
- */
-export const ERROR_DETAILS = {
-    INVALID_PADDING: 'PKCS#7 padding bytes are invalid or inconsistent. Data may be corrupted.',
-    HMAC_FAILURE: 'HMAC-SHA256 verification failed during reconstruction. One or more shares have been tampered with.',
-    INVALID_SHARES: 'Shares have inconsistent lengths, duplicate indices, or mismatched parameters.',
-    INSUFFICIENT_SHARES: 'Fewer shares provided than the required threshold k.',
-    INVALID_INDEX: 'A share index is out of range (must be 0 to n-1).',
-    UUID_MISMATCH: 'Shares reference different message UUIDs and cannot be combined.',
-    INVALID_TLV: 'TLV data is malformed or truncated.',
-    BUFFER_OVERFLOW: 'TLV length field exceeds available data.',
-    MISSING_FIELD: 'A required TLV field (e.g., MESSAGE_UUID) is absent.',
-    INVALID_TYPE: 'An unrecognized TLV type tag was encountered in a required position.',
-    HMAC_MISMATCH: 'Standalone HMAC verification failed. Data or key is incorrect.',
-    KEY_ERROR: 'HMAC key import failed (invalid length or format).',
-    SPLIT_FAILED: 'XorIDA split operation failed due to invalid input or configuration.',
-    RECONSTRUCTION_FAILED: 'XorIDA reconstruction failed. Check share integrity and parameters.',
-    INVALID_CONFIG: 'Split configuration is invalid. Requires n >= 2, k >= 2, and k <= n.',
-};
-/**
- * Convert an unknown error into a CryptoError.
- *
- * @param error - The unknown error to convert
- * @returns A CryptoError instance
- */
-export function toCryptoError(error) {
-    if (error instanceof CryptoError)
-        return error;
-    if (error instanceof Error) {
-        return new CryptoError('SPLIT_FAILED', error.message);
-    }
-    return new CryptoError('SPLIT_FAILED', String(error));
-}
-/**
- * Type guard to check if an error is a CryptoError.
- *
- * @param error - The value to check
- * @returns true if the value is a CryptoError instance
- */
-export function isCryptoError(error) {
-    return error instanceof CryptoError;
-}