@private.me/xbind 1.3.5 → 3.0.0

package/dist-standalone/timeouts.d.ts

@@ -0,0 +1,275 @@
+/**
+ * @module timeouts
+ * Configurable request timeouts for xBind operations
+ *
+ * Provides centralized timeout management with:
+ * - Per-operation timeout configuration
+ * - Default timeouts for registry, gateway, transport
+ * - Timeout inheritance and overrides
+ * - Timeout error messages with context
+ * - Integration with AbortController/cancellation tokens
+ *
+ * @example
+ * ```typescript
+ * import { TimeoutConfig, withTimeout, createTimeoutController } from '@private.me/xbind';
+ *
+ * // Create timeout configuration
+ * const config = new TimeoutConfig({
+ *   registry: 10000,
+ *   gateway: 15000,
+ *   transport: 30000,
+ * });
+ *
+ * // Use timeout with fetch
+ * const controller = createTimeoutController(config.registry);
+ * const response = await fetch(url, { signal: controller.signal });
+ *
+ * // Wrap async operation with timeout
+ * const result = await withTimeout(
+ *   async () => performOperation(),
+ *   5000,
+ *   'Operation description'
+ * );
+ * ```
+ */
+import type { Result } from '@private.me/shared';
+/**
+ * Timeout configuration for different operation types.
+ * All values in milliseconds.
+ */
+export interface TimeoutConfigOptions {
+    /**
+     * Timeout for registry operations (lookup, register, update).
+     * Default: 10000ms (10 seconds)
+     */
+    readonly registry?: number;
+    /**
+     * Timeout for gateway operations (send, poll, status).
+     * Default: 15000ms (15 seconds)
+     */
+    readonly gateway?: number;
+    /**
+     * Timeout for transport operations (HTTP/HTTPS requests).
+     * Default: 30000ms (30 seconds)
+     */
+    readonly transport?: number;
+    /**
+     * Default timeout for operations without specific category.
+     * Default: 30000ms (30 seconds)
+     */
+    readonly default?: number;
+    /**
+     * Override timeout for specific operation.
+     * Takes precedence over category timeouts.
+     */
+    readonly override?: number;
+}
+/**
+ * Timeout error with operation context.
+ */
+export declare class TimeoutError extends Error {
+    readonly code: "TIMEOUT";
+    readonly operation: string;
+    readonly timeoutMs: number;
+    readonly timestamp: number;
+    constructor(operation: string, timeoutMs: number);
+    /**
+     * Create timeout error with additional context.
+     */
+    static withContext(operation: string, timeoutMs: number, context?: Record<string, unknown>): TimeoutError;
+}
+/**
+ * Default timeout values (milliseconds).
+ */
+export declare const DEFAULT_TIMEOUTS: {
+    readonly registry: 10000;
+    readonly gateway: 15000;
+    readonly transport: 30000;
+    readonly default: 30000;
+};
+/**
+ * Timeout configuration manager.
+ * Provides timeout values with inheritance and override support.
+ */
+export declare class TimeoutConfig {
+    private readonly registry;
+    private readonly gateway;
+    private readonly transport;
+    private readonly default;
+    constructor(options?: TimeoutConfigOptions);
+    /**
+     * Get timeout for registry operations.
+     * @param override - Optional override timeout
+     */
+    getRegistry(override?: number): number;
+    /**
+     * Get timeout for gateway operations.
+     * @param override - Optional override timeout
+     */
+    getGateway(override?: number): number;
+    /**
+     * Get timeout for transport operations.
+     * @param override - Optional override timeout
+     */
+    getTransport(override?: number): number;
+    /**
+     * Get default timeout.
+     * @param override - Optional override timeout
+     */
+    getDefault(override?: number): number;
+    /**
+     * Get timeout for specific operation category.
+     * @param category - Operation category
+     * @param override - Optional override timeout
+     */
+    get(category: 'registry' | 'gateway' | 'transport' | 'default', override?: number): number;
+    /**
+     * Create new config with overrides.
+     * @param overrides - Timeout overrides
+     */
+    with(overrides: TimeoutConfigOptions): TimeoutConfig;
+    /**
+     * Validate timeout value.
+     */
+    private validateTimeout;
+    /**
+     * Export configuration as plain object.
+     */
+    toJSON(): TimeoutConfigOptions;
+}
+/**
+ * Operation timeout controller with cancellation support.
+ * Wraps AbortController with timeout semantics.
+ */
+export declare class OperationTimeoutController {
+    readonly signal: AbortSignal;
+    readonly timeoutMs: number;
+    readonly operation: string;
+    private readonly controller;
+    private readonly timer;
+    private timedOut;
+    constructor(timeoutMs: number, operation?: string);
+    /**
+     * Cancel the operation (clear timeout).
+     */
+    cancel(): void;
+    /**
+     * Clear timeout if operation completed successfully.
+     * Call this when operation finishes to prevent unnecessary abort.
+     */
+    clear(): void;
+    /**
+     * Check if controller timed out (vs manual cancellation).
+     */
+    didTimeout(): boolean;
+    /**
+     * Get timeout error if operation timed out.
+     */
+    getTimeoutError(): TimeoutError | null;
+}
+/**
+ * Create timeout controller for operation.
+ * @param timeoutMs - Timeout in milliseconds
+ * @param operation - Operation description for error messages
+ */
+export declare function createTimeoutController(timeoutMs: number, operation?: string): OperationTimeoutController;
+/**
+ * Wrap async operation with timeout.
+ * Rejects with TimeoutError if operation exceeds timeout.
+ *
+ * @param fn - Async operation to execute
+ * @param timeoutMs - Timeout in milliseconds
+ * @param operation - Operation description for error messages
+ * @returns Result of operation or timeout error
+ *
+ * @example
+ * ```typescript
+ * const result = await withTimeout(
+ *   async () => fetch('https://api.example.com'),
+ *   5000,
+ *   'API request'
+ * );
+ * ```
+ */
+export declare function withTimeout<T>(fn: () => Promise<T>, timeoutMs: number, operation?: string): Promise<T>;
+/**
+ * Wrap async operation with timeout (Result-based).
+ * Returns ok(result) or err('TIMEOUT') without throwing.
+ *
+ * @param fn - Async operation to execute
+ * @param timeoutMs - Timeout in milliseconds
+ * @param operation - Operation description for error messages
+ * @returns Result with operation result or timeout error
+ *
+ * @example
+ * ```typescript
+ * const result = await withTimeoutResult(
+ *   async () => fetch('https://api.example.com'),
+ *   5000,
+ *   'API request'
+ * );
+ * if (result.ok) {
+ *   console.log('Success:', result.value);
+ * } else {
+ *   console.error('Timeout:', result.error);
+ * }
+ * ```
+ */
+export declare function withTimeoutResult<T>(fn: () => Promise<T>, timeoutMs: number, operation?: string): Promise<Result<T, 'TIMEOUT'>>;
+/**
+ * Create timeout signal for use with fetch/AbortController APIs.
+ *
+ * @param timeoutMs - Timeout in milliseconds
+ * @param operation - Operation description
+ * @returns AbortSignal that aborts after timeout
+ *
+ * @example
+ * ```typescript
+ * const signal = createOperationTimeoutSignal(5000, 'fetch request');
+ * const response = await fetch(url, { signal });
+ * ```
+ */
+export declare function createOperationTimeoutSignal(timeoutMs: number, operation?: string): AbortSignal;
+/**
+ * Timeout helper for operations with cancellation token.
+ * Returns controller that can be passed to fetch, agent.send, etc.
+ *
+ * @param config - Timeout configuration
+ * @param category - Operation category
+ * @param operation - Operation description
+ * @param override - Optional timeout override
+ * @returns Timeout controller
+ *
+ * @example
+ * ```typescript
+ * const controller = createOperationTimeout(config, 'registry', 'lookup DID');
+ * const response = await fetch(url, { signal: controller.signal });
+ * controller.clear(); // Clear timeout on success
+ * ```
+ */
+export declare function createOperationTimeout(config: TimeoutConfig, category: 'registry' | 'gateway' | 'transport' | 'default', operation: string, override?: number): OperationTimeoutController;
+/**
+ * Check if error is a timeout error.
+ */
+export declare function isTimeoutError(error: unknown): error is TimeoutError;
+/**
+ * Extract timeout from error if it's a timeout error.
+ * Returns timeout in milliseconds or undefined.
+ */
+export declare function getTimeoutFromError(error: unknown): number | undefined;
+/**
+ * Create timeout configuration from environment variables.
+ * Looks for:
+ * - XBIND_TIMEOUT_REGISTRY
+ * - XBIND_TIMEOUT_GATEWAY
+ * - XBIND_TIMEOUT_TRANSPORT
+ * - XBIND_TIMEOUT_DEFAULT
+ *
+ * Falls back to default values if not set.
+ */
+export declare function createTimeoutConfigFromEnv(): TimeoutConfig;
+/**
+ * Global default timeout configuration.
+ * Can be overridden by setting environment variables.
+ */
+export declare const globalTimeoutConfig: TimeoutConfig;

package/dist-standalone/timeouts.js

@@ -0,0 +1 @@
+import{err,ok}from"./_deps/shared/index.js";export class TimeoutError extends Error{code="TIMEOUT";operation;timeoutMs;timestamp;constructor(t,e){super(`Operation '${t}' timed out after ${e}ms. Actions: (1) Check network connectivity, (2) Increase timeout threshold, (3) Verify service availability, (4) Implement retry with exponential backoff.`),this.name="TimeoutError",this.operation=t,this.timeoutMs=e,this.timestamp=Date.now()}static withContext(t,e,r){const i=new TimeoutError(t,e);return r&&Object.assign(i,{context:r}),i}}export const DEFAULT_TIMEOUTS={registry:1e4,gateway:15e3,transport:3e4,default:3e4};export class TimeoutConfig{registry;gateway;transport;default;constructor(t={}){this.registry=t.registry??DEFAULT_TIMEOUTS.registry,this.gateway=t.gateway??DEFAULT_TIMEOUTS.gateway,this.transport=t.transport??DEFAULT_TIMEOUTS.transport,this.default=t.default??DEFAULT_TIMEOUTS.default,this.validateTimeout("registry",this.registry),this.validateTimeout("gateway",this.gateway),this.validateTimeout("transport",this.transport),this.validateTimeout("default",this.default)}getRegistry(t){return t??this.registry}getGateway(t){return t??this.gateway}getTransport(t){return t??this.transport}getDefault(t){return t??this.default}get(t,e){switch(t){case"registry":return this.getRegistry(e);case"gateway":return this.getGateway(e);case"transport":return this.getTransport(e);case"default":return this.getDefault(e)}}with(t){return new TimeoutConfig({registry:t.registry??this.registry,gateway:t.gateway??this.gateway,transport:t.transport??this.transport,default:t.default??this.default})}validateTimeout(t,e){if(!Number.isFinite(e)||e<=0)throw new Error(`Invalid timeout for '${t}': ${e}. Must be positive finite number.`);e>3e5&&console.warn(`[xbind:timeout] Large timeout for '${t}': ${e}ms. Consider reducing to avoid indefinite hangs.`)}toJSON(){return{registry:this.registry,gateway:this.gateway,transport:this.transport,default:this.default}}}export class OperationTimeoutController{signal;timeoutMs;operation;controller;timer;timedOut=!1;constructor(t,e="operation"){this.controller=new AbortController,this.signal=this.controller.signal,this.timeoutMs=t,this.operation=e,this.timer=setTimeout(()=>{this.timedOut=!0,this.controller.abort()},t)}cancel(){clearTimeout(this.timer),this.controller.signal.aborted||this.controller.abort()}clear(){clearTimeout(this.timer)}didTimeout(){return this.timedOut}getTimeoutError(){return this.timedOut?new TimeoutError(this.operation,this.timeoutMs):null}}export function createTimeoutController(t,e="operation"){return new OperationTimeoutController(t,e)}export async function withTimeout(t,e,r="operation"){const i=createTimeoutController(e,r);try{const o=await Promise.race([t(),new Promise((t,o)=>{i.signal.addEventListener("abort",()=>{o(new TimeoutError(r,e))})})]);return i.clear(),o}catch(t){throw i.clear(),t}}export async function withTimeoutResult(t,e,r="operation"){try{const i=await withTimeout(t,e,r);return ok(i)}catch(t){if(t instanceof TimeoutError)return err("TIMEOUT");throw t}}export function createOperationTimeoutSignal(t,e="operation"){return createTimeoutController(t,e).signal}export function createOperationTimeout(t,e,r,i){return createTimeoutController(t.get(e,i),r)}export function isTimeoutError(t){return t instanceof TimeoutError}export function getTimeoutFromError(t){return isTimeoutError(t)?t.timeoutMs:void 0}export function createTimeoutConfigFromEnv(){const t={},e=process.env.XBIND_TIMEOUT_REGISTRY;if(e){const r=parseInt(e,10);isNaN(r)||(t.registry=r)}const r=process.env.XBIND_TIMEOUT_GATEWAY;if(r){const e=parseInt(r,10);isNaN(e)||(t.gateway=e)}const i=process.env.XBIND_TIMEOUT_TRANSPORT;if(i){const e=parseInt(i,10);isNaN(e)||(t.transport=e)}const o=process.env.XBIND_TIMEOUT_DEFAULT;if(o){const e=parseInt(o,10);isNaN(e)||(t.default=e)}return new TimeoutConfig(t)}export const globalTimeoutConfig=createTimeoutConfigFromEnv();

package/dist-standalone/trace-context.d.ts

@@ -0,0 +1,252 @@
+/**
+ * @module trace-context
+ * W3C Trace Context implementation for distributed tracing
+ *
+ * Implements the W3C Trace Context specification for distributed tracing across
+ * xBind agent operations, enabling correlation of requests across service boundaries.
+ *
+ * Standard: https://www.w3.org/TR/trace-context/
+ *
+ * Headers:
+ * - `traceparent`: Required header with version, trace-id, parent-id, and trace-flags
+ * - `tracestate`: Optional vendor-specific state
+ *
+ * Format: `{version}-{trace-id}-{parent-id}-{trace-flags}`
+ * Example: `00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01`
+ *
+ * Usage:
+ * ```typescript
+ * import { TraceContext } from '@private.me/xbind';
+ *
+ * // Create a new trace context
+ * const ctx = TraceContext.create();
+ *
+ * // Attach to request headers
+ * const headers = new Headers();
+ * ctx.inject(headers);
+ *
+ * // Extract from incoming headers
+ * const incomingCtx = TraceContext.extract(headers);
+ *
+ * // Create child span
+ * const childCtx = incomingCtx.createChild();
+ * ```
+ */
+/**
+ * W3C Trace Context specification constants
+ */
+export declare const TRACEPARENT_HEADER = "traceparent";
+export declare const TRACESTATE_HEADER = "tracestate";
+/**
+ * Trace context version (currently only 00 is supported)
+ */
+export declare const TRACE_VERSION = "00";
+/**
+ * Trace flags
+ */
+export declare enum TraceFlags {
+    /** Not sampled */
+    NONE = 0,
+    /** Sampled */
+    SAMPLED = 1
+}
+/**
+ * Trace state key-value pair
+ */
+export interface TraceStateEntry {
+    key: string;
+    value: string;
+}
+/**
+ * Parsed traceparent header components
+ */
+export interface TraceparentSpec {
+    version: string;
+    traceId: string;
+    parentId: string;
+    traceFlags: number;
+}
+/**
+ * W3C Trace Context implementation
+ *
+ * Represents a single point in a distributed trace with parent-child relationships.
+ */
+export declare class TraceContext {
+    /** W3C version (always '00' for now) */
+    readonly version: string;
+    /** Trace ID (32 hex characters, 16 bytes) */
+    readonly traceId: string;
+    /** Parent span ID (16 hex characters, 8 bytes) */
+    readonly parentId: string;
+    /** Trace flags (8-bit field) */
+    readonly traceFlags: number;
+    /** Vendor-specific trace state */
+    readonly traceState: TraceStateEntry[];
+    /**
+     * Create a trace context
+     *
+     * @param traceId - 32-character hex trace ID
+     * @param parentId - 16-character hex parent span ID
+     * @param traceFlags - 8-bit trace flags
+     * @param traceState - Optional vendor-specific state
+     */
+    constructor(traceId: string, parentId: string, traceFlags?: number, traceState?: TraceStateEntry[]);
+    /**
+     * Create a new root trace context
+     *
+     * Generates a new trace ID and parent ID for a new trace.
+     *
+     * @param sampled - Whether this trace should be sampled
+     * @returns New trace context
+     *
+     * @example
+     * ```typescript
+     * const ctx = TraceContext.create();
+     * console.log(ctx.traceId); // => "4bf92f3577b34da6a3ce929d0e0e4736"
+     * ```
+     */
+    static create(sampled?: boolean): TraceContext;
+    /**
+     * Extract trace context from headers
+     *
+     * Parses the traceparent and tracestate headers according to W3C spec.
+     *
+     * @param headers - Headers object or plain object
+     * @returns Trace context if found, null otherwise
+     *
+     * @example
+     * ```typescript
+     * const headers = new Headers({
+     *   traceparent: '00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01'
+     * });
+     * const ctx = TraceContext.extract(headers);
+     * ```
+     */
+    static extract(headers: Headers | Record<string, string>): TraceContext | null;
+    /**
+     * Inject trace context into headers
+     *
+     * Adds traceparent and tracestate headers to the provided headers object.
+     *
+     * @param headers - Headers to modify
+     * @returns Modified headers
+     *
+     * @example
+     * ```typescript
+     * const ctx = TraceContext.create();
+     * const headers = new Headers();
+     * ctx.inject(headers);
+     * ```
+     */
+    inject<T extends Headers | Record<string, string>>(headers: T): T;
+    /**
+     * Create a child trace context
+     *
+     * Generates a new parent ID (span ID) while keeping the same trace ID.
+     * This represents a new span in the same trace.
+     *
+     * @param sampled - Override sampling decision (defaults to parent's decision)
+     * @returns New child trace context
+     *
+     * @example
+     * ```typescript
+     * const parent = TraceContext.create();
+     * const child = parent.createChild();
+     * console.log(parent.traceId === child.traceId); // => true
+     * console.log(parent.parentId === child.parentId); // => false
+     * ```
+     */
+    createChild(sampled?: boolean): TraceContext;
+    /**
+     * Format as traceparent header value
+     *
+     * @returns traceparent string
+     */
+    toTraceparent(): string;
+    /**
+     * Format as tracestate header value
+     *
+     * @returns tracestate string
+     */
+    toTracestate(): string;
+    /**
+     * Check if this trace is sampled
+     *
+     * @returns True if sampled
+     */
+    isSampled(): boolean;
+    /**
+     * Add or update tracestate entry
+     *
+     * @param key - Vendor key (format: vendor[@system])
+     * @param value - State value
+     * @returns New trace context with updated state
+     *
+     * @example
+     * ```typescript
+     * const ctx = TraceContext.create();
+     * const updated = ctx.withTracestate('private.me', 'did:key:z6Mk...');
+     * ```
+     */
+    withTracestate(key: string, value: string): TraceContext;
+    /**
+     * Get tracestate value by key
+     *
+     * @param key - Vendor key
+     * @returns State value or undefined
+     */
+    getTracestate(key: string): string | undefined;
+    /**
+     * Convert to plain object
+     *
+     * @returns Plain object representation
+     */
+    toObject(): {
+        version: string;
+        traceId: string;
+        parentId: string;
+        traceFlags: number;
+        traceState: TraceStateEntry[];
+        sampled: boolean;
+    };
+}
+/**
+ * Generate a random trace ID (32 hex characters)
+ *
+ * @returns 32-character hex string
+ */
+export declare function generateTraceId(): string;
+/**
+ * Generate a random span ID (16 hex characters)
+ *
+ * @returns 16-character hex string
+ */
+export declare function generateSpanId(): string;
+/**
+ * Validate trace ID format
+ *
+ * @param traceId - Trace ID to validate
+ * @returns True if valid
+ */
+export declare function validateTraceId(traceId: string): boolean;
+/**
+ * Validate span ID format
+ *
+ * @param spanId - Span ID to validate
+ * @returns True if valid
+ */
+export declare function validateSpanId(spanId: string): boolean;
+/**
+ * Parse traceparent header value
+ *
+ * @param traceparent - Header value
+ * @returns Parsed components or null if invalid
+ */
+export declare function parseTraceparent(traceparent: string): TraceparentSpec | null;
+/**
+ * Parse tracestate header value
+ *
+ * @param tracestate - Header value
+ * @returns Array of key-value pairs
+ */
+export declare function parseTracestate(tracestate: string): TraceStateEntry[];

package/dist-standalone/trace-context.js

@@ -0,0 +1 @@
+export const TRACEPARENT_HEADER="traceparent";export const TRACESTATE_HEADER="tracestate";export const TRACE_VERSION="00";export var TraceFlags;!function(t){t[t.NONE=0]="NONE",t[t.SAMPLED=1]="SAMPLED"}(TraceFlags||(TraceFlags={}));export class TraceContext{version;traceId;parentId;traceFlags;traceState;constructor(t,e,r=TraceFlags.SAMPLED,a=[]){if(!validateTraceId(t))throw new Error(`Invalid trace ID: ${t}. Must be 32 hex characters.`);if(!validateSpanId(e))throw new Error(`Invalid parent ID: ${e}. Must be 16 hex characters.`);if(r<0||r>255)throw new Error(`Invalid trace flags: ${r}. Must be 0-255.`);this.version="00",this.traceId=t,this.parentId=e,this.traceFlags=r,this.traceState=a}static create(t=!0){const e=generateTraceId(),r=generateSpanId(),a=t?TraceFlags.SAMPLED:TraceFlags.NONE;return new TraceContext(e,r,a)}static extract(t){const e=t instanceof Headers?t.get("traceparent"):t.traceparent;if(!e)return null;const r=parseTraceparent(e);if(!r)return null;const a=t instanceof Headers?t.get("tracestate"):t.tracestate,n=a?parseTracestate(a):[];return new TraceContext(r.traceId,r.parentId,r.traceFlags,n)}inject(t){const e=this.toTraceparent();return t instanceof Headers?(t.set("traceparent",e),this.traceState.length>0&&t.set("tracestate",this.toTracestate())):(t.traceparent=e,this.traceState.length>0&&(t.tracestate=this.toTracestate())),t}createChild(t){const e=generateSpanId(),r=void 0!==t?t?TraceFlags.SAMPLED:TraceFlags.NONE:this.traceFlags;return new TraceContext(this.traceId,e,r,this.traceState)}toTraceparent(){const t=this.traceFlags.toString(16).padStart(2,"0");return`${this.version}-${this.traceId}-${this.parentId}-${t}`}toTracestate(){return this.traceState.map(({key:t,value:e})=>`${t}=${e}`).join(",")}isSampled(){return(this.traceFlags&TraceFlags.SAMPLED)===TraceFlags.SAMPLED}withTracestate(t,e){const r=this.traceState.filter(e=>e.key!==t);return r.unshift({key:t,value:e}),new TraceContext(this.traceId,this.parentId,this.traceFlags,r)}getTracestate(t){const e=this.traceState.find(e=>e.key===t);return e?.value}toObject(){return{version:this.version,traceId:this.traceId,parentId:this.parentId,traceFlags:this.traceFlags,traceState:[...this.traceState],sampled:this.isSampled()}}}export function generateTraceId(){return generateRandomHex(32)}export function generateSpanId(){return generateRandomHex(16)}export function validateTraceId(t){return"string"==typeof t&&(32===t.length&&(!!/^[a-f0-9]{32}$/.test(t)&&"00000000000000000000000000000000"!==t))}export function validateSpanId(t){return"string"==typeof t&&(16===t.length&&(!!/^[a-f0-9]{16}$/.test(t)&&"0000000000000000"!==t))}export function parseTraceparent(t){if("string"!=typeof t)return null;const e=t.split("-");if(4!==e.length)return null;const[r,a,n,s]=e;if("00"!==r)return null;if(!validateTraceId(a??""))return null;if(!validateSpanId(n??""))return null;if(!s||2!==s.length)return null;if(!/^[a-f0-9]{2}$/.test(s))return null;return{version:r??"00",traceId:a??"",parentId:n??"",traceFlags:parseInt(s,16)}}export function parseTracestate(t){if(!t)return[];const e=[],r=t.split(",");for(const t of r){const r=t.trim(),a=r.indexOf("=");if(-1===a)continue;const n=r.substring(0,a).trim(),s=r.substring(a+1).trim();n&&s&&e.push({key:n,value:s})}return e}function generateRandomHex(t){const e=Math.ceil(t/2);if("undefined"!=typeof crypto&&crypto.getRandomValues){const r=new Uint8Array(e);return crypto.getRandomValues(r),Array.from(r).map(t=>t.toString(16).padStart(2,"0")).join("").substring(0,t)}try{return require("node:crypto").randomBytes(e).toString("hex").substring(0,t)}catch{throw new Error("Cryptographic random generation unavailable. Install crypto polyfill or use environment with crypto support.")}}