@hyperfrontend/features 0.1.0 → 0.2.0

package/bundle/hostee/index.umd.js

@@ -4,120 +4,26 @@
     (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.HyperfrontendFeaturesHostee = {}));
 })(this, (function (exports) { 'use strict';
 
-    /**
-     * Safe copies of Error built-ins via factory functions.
-     *
-     * Since constructors cannot be safely captured via Object.assign, this module
-     * provides factory functions that use Reflect.construct internally.
-     *
-     * These references are captured at module initialization time to protect against
-     * prototype pollution attacks. Import only what you need for tree-shaking.
-     *
-     * @module @hyperfrontend/immutable-api-utils/built-in-copy/error
-     */
     const _Error = globalThis.Error;
-    const _Reflect$9 = globalThis.Reflect;
-    /**
-     * (Safe copy) Creates a new Error using the captured Error constructor.
-     * Use this instead of `new Error()`.
-     *
-     * @param message - Optional error message.
-     * @param options - Optional error options.
-     * @returns A new Error instance.
-     *
-     * @example Creating Error instances
-     * ```typescript
-     * const error = createError('Operation failed')
-     * // With cause for error chaining
-     * const wrapped = createError('Request failed', { cause: originalError })
-     * ```
-     */
-    const createError = (message, options) => _Reflect$9.construct(_Error, [message, options]);
-
-    /**
-     * Safe copies of Object built-in methods.
-     *
-     * These references are captured at module initialization time to protect against
-     * prototype pollution attacks. Import only what you need for tree-shaking.
-     *
-     * @module @hyperfrontend/immutable-api-utils/built-in-copy/object
-     */
+    const _Reflect$a = globalThis.Reflect;
+    const createError = (message, options) => _Reflect$a.construct(_Error, [message, options]);
+
     const _Object = globalThis.Object;
-    const _Reflect$8 = globalThis.Reflect;
+    const _Reflect$9 = globalThis.Reflect;
     const _ObjectPrototype = _Object.prototype;
     const _hasOwnProperty = _ObjectPrototype.hasOwnProperty;
-    /**
-     * (Safe copy) Prevents modification of existing property attributes and values,
-     * and prevents the addition of new properties.
-     */
     const freeze = _Object.freeze;
-    /**
-     * (Safe copy) Returns the names of the enumerable string properties and methods of an object.
-     */
     const keys = _Object.keys;
-    /**
-     * (Safe copy) Returns an array of key/values of the enumerable own properties of an object.
-     */
     const entries = _Object.entries;
-    /**
-     * (Safe copy) Adds a property to an object, or modifies attributes of an existing property.
-     */
+    const values = _Object.values;
     const defineProperty = _Object.defineProperty;
-    /**
-     * (Safe copy) Sets the prototype of a specified object o to object proto or null.
-     */
     const setPrototypeOf = _Object.setPrototypeOf;
-    /**
-     * (Safe copy) Safe wrapper for Object.prototype.hasOwnProperty.call().
-     * Checks if an object has a property as its own (not inherited) property.
-     *
-     * @param obj - The object to check.
-     * @param key - The property key to check.
-     * @returns True if the object has the property as its own property.
-     *
-     * @example Checking own properties
-     * ```typescript
-     * const user = { name: 'Alice' }
-     * hasOwn(user, 'name') // => true
-     * hasOwn(user, 'toString') // => false (inherited from prototype)
-     * ```
-     */
-    const hasOwn = (obj, key) => _Reflect$8.apply(_hasOwnProperty, obj, [key]);
-
-    /**
-     * Safe copies of Math built-in methods.
-     *
-     * These references are captured at module initialization time to protect against
-     * prototype pollution attacks. Import only what you need for tree-shaking.
-     *
-     * @module @hyperfrontend/immutable-api-utils/built-in-copy/math
-     */
+    const hasOwn = (obj, key) => _Reflect$9.apply(_hasOwnProperty, obj, [key]);
+
     const _Math = globalThis.Math;
-    /**
-     * (Safe copy) Returns the absolute value of a number.
-     */
     const abs = _Math.abs;
-    /**
-     * (Safe copy) Returns a pseudo-random number between 0 and 1.
-     * Note: This is NOT cryptographically secure. For secure random values,
-     * use crypto.getRandomValues().
-     */
     const random = _Math.random;
 
-    /**
-     * Generates a version 4 UUID.
-     *
-     * @returns a version 4 UUID.
-     *
-     * @example Creating unique identifiers for entities
-     * ```typescript
-     * const userId = uuidV4()
-     * // => 'a1b2c3d4-e5f6-4a7b-8c9d-0e1f2a3b4c5d'
-     *
-     * const sessionId = uuidV4()
-     * // => '9f8e7d6c-5b4a-4321-8765-4321fedcba98'
-     * ```
-     */
     function uuidV4() {
         return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (char) => {
             const randomHex = (random() * 16) | 0;
@@ -126,17 +32,7 @@
         });
     }
 
-    /**
-     * Protocol prefix for all action types.
-     * This is the Nexus protocol identifier.
-     */
     const PROTOCOL = 'nexus';
-    /**
-     * Action type string literals for the Nexus protocol.
-     *
-     * These define the wire format for all connection lifecycle actions.
-     * The connection flow behavior is 1:1 with the proven legacy implementation.
-     */
     const ACTION_TYPES = {
         INVALID_REQUEST: `[${PROTOCOL}] invalid-request`,
         REQUEST_CONNECTION: `[${PROTOCOL}] connection-request`,
@@ -150,66 +46,10 @@
         OPEN_CONNECTION: `[${PROTOCOL}] connection-opened`,
         NEW_MESSAGE: `[${PROTOCOL}] new-message`,
     };
-    /**
-     * Type guards for specific action types
-     *
-     * @param action - The action to check
-     * @returns True if action contains a contract property
-     *
-     * @example Checking for contract property
-     * ```typescript
-     * if (isActionWithContract(action)) {
-     *   console.log(action.contract)
-     * }
-     * ```
-     */
     const isActionWithContract = (action) => 'contract' in action;
-    /**
-     * Type guard for actions with data property.
-     *
-     * @param action - The action to check
-     * @returns True if action contains a data property
-     *
-     * @example Checking for data property
-     * ```typescript
-     * if (isActionWithData(action)) {
-     *   processData(action.data)
-     * }
-     * ```
-     */
     const isActionWithData = (action) => 'data' in action;
-    /**
-     * Type guard for actions with processId property.
-     *
-     * @param action - The action to check
-     * @returns True if action contains a processId property
-     *
-     * @example Checking for processId property
-     * ```typescript
-     * if (isActionWithProcess(action)) {
-     *   trackProcess(action.processId)
-     * }
-     * ```
-     */
     const isActionWithProcess = (action) => 'processId' in action;
 
-    /**
-     * Creates ACCEPT_CONNECTION action
-     *
-     * @param deps - Action dependencies (getBrokerId, getContract)
-     * @returns Function that takes processId and optional security response, returns frozen action
-     *
-     * @example Creating accept connection actions
-     * ```typescript
-     * // Without security
-     * const action = acceptConnection(deps)('process-123')
-     *
-     * // With security negotiation response
-     * const secureAction = acceptConnection(deps)('process-123', {
-     *   negotiated: 'v2'
-     * })
-     * ```
-     */
     const acceptConnection = (deps) => (processId, security) => {
         const base = {
             type: ACTION_TYPES.ACCEPT_CONNECTION,
@@ -223,57 +63,18 @@
         return freeze(base);
     };
 
-    /**
-     * Creates a cancel connection action.
-     *
-     * @param deps - Action dependencies containing broker ID
-     * @returns A function that creates a cancel connection action for a process
-     *
-     * @example Creating cancel connection actions
-     * ```typescript
-     * const createCancelAction = cancelConnection({ getBrokerId: () => 'broker-1' })
-     * const action = createCancelAction('process-123')
-     * // => { type: 'CANCEL_CONNECTION', processId: 'process-123', senderId: 'broker-1' }
-     * ```
-     */
     const cancelConnection = (deps) => (processId) => freeze({
         type: ACTION_TYPES.CANCEL_CONNECTION,
         processId,
         senderId: deps.getBrokerId(),
     });
 
-    /**
-     * Creates a close connection action.
-     *
-     * @param deps - Action dependencies containing broker ID
-     * @returns A function that creates a close connection action for a process
-     *
-     * @example Creating close connection actions
-     * ```typescript
-     * const createCloseAction = closeConnection({ getBrokerId: () => 'broker-1' })
-     * const action = createCloseAction('process-123')
-     * // => { type: 'CLOSE_CONNECTION', processId: 'process-123', senderId: 'broker-1' }
-     * ```
-     */
     const closeConnection = (deps) => (processId) => freeze({
         type: ACTION_TYPES.CLOSE_CONNECTION,
         processId,
         senderId: deps.getBrokerId(),
     });
 
-    /**
-     * Creates a deny connection action with an error message.
-     *
-     * @param deps - Action dependencies containing broker ID
-     * @returns A function that creates a deny connection action for a process
-     *
-     * @example Creating deny connection actions
-     * ```typescript
-     * const createDenyAction = denyConnection({ getBrokerId: () => 'broker-1' })
-     * const action = createDenyAction('process-123', 'Origin not allowed')
-     * // => { type: 'DENY_CONNECTION', processId: 'process-123', senderId: 'broker-1', error: 'Origin not allowed' }
-     * ```
-     */
     const denyConnection = (deps) => (processId, error) => freeze({
         type: ACTION_TYPES.DENY_CONNECTION,
         processId,
@@ -281,37 +82,11 @@
         error,
     });
 
-    /**
-     * Creates a destroy connection action.
-     *
-     * @param deps - Action dependencies containing broker ID
-     * @returns A function that creates a destroy connection action
-     *
-     * @example Creating destroy connection actions
-     * ```typescript
-     * const createDestroyAction = destroyConnection({ getBrokerId: () => 'broker-1' })
-     * const action = createDestroyAction()
-     * // => { type: 'DESTROY_CONNECTION', senderId: 'broker-1' }
-     * ```
-     */
     const destroyConnection = (deps) => () => freeze({
         type: ACTION_TYPES.DESTROY_CONNECTION,
         senderId: deps.getBrokerId(),
     });
 
-    /**
-     * Creates an invalid request action with an error message.
-     *
-     * @param deps - Action dependencies containing broker ID
-     * @returns A function that creates an invalid request action for a process
-     *
-     * @example Creating invalid request actions
-     * ```typescript
-     * const createInvalidAction = invalidRequest({ getBrokerId: () => 'broker-1' })
-     * const action = createInvalidAction('process-123', 'Malformed payload')
-     * // => { type: 'INVALID_REQUEST', processId: 'process-123', senderId: 'broker-1', error: 'Malformed payload' }
-     * ```
-     */
     const invalidRequest = (deps) => (processId, error) => freeze({
         type: ACTION_TYPES.INVALID_REQUEST,
         processId,
@@ -319,43 +94,12 @@
         error,
     });
 
-    /**
-     * Creates a new message action with data payload.
-     *
-     * @param deps - Action dependencies containing broker ID
-     * @returns A function that creates a new message action with data
-     *
-     * @example Creating message actions with data
-     * ```typescript
-     * const createMessageAction = newMessage({ getBrokerId: () => 'broker-1' })
-     * const action = createMessageAction({ userId: 123, event: 'login' })
-     * // => { type: 'NEW_MESSAGE', senderId: 'broker-1', data: { userId: 123, event: 'login' } }
-     * ```
-     */
-    const newMessage = (deps) => (data) => freeze({
+    const newMessage = (deps) => (message) => freeze({
         type: ACTION_TYPES.NEW_MESSAGE,
         senderId: deps.getBrokerId(),
-        data,
+        data: message,
     });
 
-    /**
-     * Creates OPEN_CONNECTION action
-     *
-     * @param deps - Action dependencies (getBrokerId, getContract)
-     * @returns Function that takes processId and optional security confirmation, returns frozen action
-     *
-     * @example Creating open connection actions
-     * ```typescript
-     * // Without security
-     * const action = openConnection(deps)('process-123')
-     *
-     * // With security confirmation
-     * const secureAction = openConnection(deps)('process-123', {
-     *   active: true,
-     *   protocol: 'v2'
-     * })
-     * ```
-     */
     const openConnection = (deps) => (processId, security) => {
         const base = {
             type: ACTION_TYPES.OPEN_CONNECTION,
@@ -368,24 +112,6 @@
         return freeze(base);
     };
 
-    /**
-     * Creates REQUEST_CONNECTION action
-     *
-     * @param deps - Action dependencies (getBrokerId, getContract)
-     * @returns Function that takes processId and optional security request, returns frozen action
-     *
-     * @example Creating request connection actions
-     * ```typescript
-     * // Without security
-     * const action = requestConnection(deps)('process-123')
-     *
-     * // With security negotiation
-     * const secureAction = requestConnection(deps)('process-123', {
-     *   supported: ['v2', 'v1', 'none'],
-     *   preferred: 'v2'
-     * })
-     * ```
-     */
     const requestConnection = (deps) => (processId, security) => {
         const base = {
             type: ACTION_TYPES.REQUEST_CONNECTION,
@@ -399,21 +125,6 @@
         return freeze(base);
     };
 
-    /**
-     * Creates all action creators bound to the provided dependencies
-     *
-     * @param deps - Action dependencies (getBrokerId, getContract)
-     * @returns Frozen object containing all action creator functions
-     *
-     * @example Creating action creators
-     * ```typescript
-     * const actions = createActionCreators({
-     *   getBrokerId: () => 'broker-123',
-     *   getContract: () => myContract
-     * })
-     * const action = actions.requestConnection('process-456')
-     * ```
-     */
     const createActionCreators = (deps) => freeze({
         requestConnection: requestConnection(deps),
         acceptConnection: acceptConnection(deps),
@@ -426,102 +137,26 @@
         invalidRequest: invalidRequest(deps),
     });
 
-    /**
-     * Safe Map factory with optional groupBy for ES2024+.
-     *
-     * @module @hyperfrontend/immutable-api-utils/built-in-copy/map
-     */
-    /* eslint-disable workspace/lib-require-jsdoc-example */
     const _Map = globalThis.Map;
-    const _Reflect$7 = globalThis.Reflect;
-    /**
-     * (Safe copy) Creates a new Map using the captured Map constructor.
-     * Use this instead of `new Map()`.
-     *
-     * @param iterable - Optional iterable of key-value pairs.
-     * @returns A new Map instance.
-     */
-    const createMap = (iterable) => _Reflect$7.construct(_Map, iterable ? [iterable] : []);
-
-    /**
-     * Clears all processes from the registry
-     *
-     * @param processes - Map storing process to channel mappings
-     * @returns Function that clears all processes
-     *
-     * @example Clearing all processes
-     * ```typescript
-     * const clear = clearProcesses(processMap)
-     * clear() // All processes removed
-     * ```
-     */
+    const _Reflect$8 = globalThis.Reflect;
+    const createMap = (iterable) => _Reflect$8.construct(_Map, iterable ? [iterable] : []);
+
     const clearProcesses = (processes) => () => {
         processes.clear();
     };
 
-    /**
-     * Creates a process ID and registers the channel
-     *
-     * @param processes - Map storing process to channel mappings
-     * @returns Function that takes a channel and returns new process ID
-     *
-     * @example Registering a channel process
-     * ```typescript
-     * const create = createProcess(processMap)
-     * const processId = create(myChannel)
-     * ```
-     */
     const createProcess = (processes) => (channel) => {
         const processId = uuidV4();
         processes.set(processId, channel);
         return processId;
     };
 
-    /**
-     * Gets a channel by its process ID
-     *
-     * @param processes - Map storing process to channel mappings
-     * @returns Function that takes processId and returns channel or undefined
-     *
-     * @example Looking up channel by process ID
-     * ```typescript
-     * const processes = new Map([['proc-1', channelHandle]])
-     * const findChannel = getChannel(processes)
-     * const channel = findChannel('proc-1')
-     * // => channelHandle or undefined
-     * ```
-     */
     const getChannel$1 = (processes) => (processId) => processes.get(processId);
 
-    /**
-     * Removes a process ID from the registry
-     *
-     * @param processes - Map storing process to channel mappings
-     * @returns Function that takes processId and removes it
-     *
-     * @example Removing a process
-     * ```typescript
-     * const remove = removeProcess(processMap)
-     * remove('some-process-id')
-     * ```
-     */
     const removeProcess = (processes) => (processId) => {
         processes.delete(processId);
     };
 
-    /**
-     * Creates a process manager for tracking process IDs to channel mappings
-     *
-     * @returns Object with process management methods
-     *
-     * @example Managing channel processes
-     * ```typescript
-     * const processManager = createProcessManager()
-     * const processId = processManager.create(channel)
-     * const found = processManager.get(processId)
-     * processManager.remove(processId)
-     * ```
-     */
     const createProcessManager = () => {
         const processes = createMap();
         return freeze({
@@ -529,98 +164,27 @@
             get: getChannel$1(processes),
             remove: removeProcess(processes),
             clear: clearProcesses(processes),
-            /**
-             * Track an existing process ID with a channel.
-             * Useful when receiving a process ID from the remote side that needs to be associated
-             * with a local channel instance.
-             *
-             * @param processId - The process ID to track
-             * @param channel - The channel handle to associate with the process ID
-             */
             track: (processId, channel) => {
                 processes.set(processId, channel);
             },
-            /**
-             * Check if a process ID exists in the manager.
-             *
-             * @param processId - The process ID to check
-             * @returns True if the process ID exists, false otherwise
-             */
             has: (processId) => {
                 return processes.has(processId);
             },
         });
     };
 
-    /**
-     * Safe copies of Array built-in static methods.
-     *
-     * These references are captured at module initialization time to protect against
-     * prototype pollution attacks. Import only what you need for tree-shaking.
-     *
-     * @module @hyperfrontend/immutable-api-utils/built-in-copy/array
-     */
     const _Array = globalThis.Array;
-    /**
-     * (Safe copy) Determines whether the passed value is an Array.
-     */
     const isArray = _Array.isArray;
-    /**
-     * (Safe copy) Creates an array from an array-like or iterable object.
-     */
     const from = _Array.from;
 
-    /**
-     * Safe Set factory for protected set construction.
-     *
-     * @module @hyperfrontend/immutable-api-utils/built-in-copy/set
-     */
-    /* eslint-disable workspace/lib-require-jsdoc-example */
     const _Set = globalThis.Set;
-    const _Reflect$6 = globalThis.Reflect;
-    /**
-     * (Safe copy) Creates a new Set using the captured Set constructor.
-     * Use this instead of `new Set()`.
-     *
-     * @param iterable - Optional iterable of values.
-     * @returns A new Set instance.
-     */
-    const createSet = (iterable) => _Reflect$6.construct(_Set, iterable ? [iterable] : []);
-
-    /**
-     * Safe WeakMap factory for protected weak map construction.
-     *
-     * @module @hyperfrontend/immutable-api-utils/built-in-copy/weak-map
-     */
-    /* eslint-disable workspace/lib-require-jsdoc-example */
+    const _Reflect$7 = globalThis.Reflect;
+    const createSet = (iterable) => _Reflect$7.construct(_Set, iterable ? [iterable] : []);
+
     const _WeakMap = globalThis.WeakMap;
-    const _Reflect$5 = globalThis.Reflect;
-    /**
-     * (Safe copy) Creates a new WeakMap using the captured WeakMap constructor.
-     * Use this instead of `new WeakMap()`.
-     *
-     * @param iterable - Optional iterable of key-value pairs.
-     * @returns A new WeakMap instance.
-     */
-    const createWeakMap = (iterable) => _Reflect$5.construct(_WeakMap, iterable ? [iterable] : []);
-
-    /**
-     * Minimal channel structure required for registry operations.
-     * Extended with optional methods for use with full ChannelHandle objects.
-     */
-    /**
-     * Creates a new channel registry with isolated state.
-     * All lookup operations are O(1) using WeakMap/Map.
-     *
-     * @returns Registry functions for managing channels
-     *
-     * @example Creating and using a registry
-     * ```typescript
-     * const registry = createRegistry()
-     * registry.add({ id: 'ch-1', name: 'main', target: iframe.contentWindow })
-     * const channel = registry.getById('ch-1')
-     * ```
-     */
+    const _Reflect$6 = globalThis.Reflect;
+    const createWeakMap = (iterable) => _Reflect$6.construct(_WeakMap, iterable ? [iterable] : []);
+
     function createRegistry() {
         const windowMap = createWeakMap();
         const idMap = createMap();
@@ -667,31 +231,10 @@
         });
     }
 
-    /* eslint-disable workspace/lib-require-jsdoc-example */
-    /**
-     * Check if value is an object (not null, not array)
-     *
-     * @param value - The value to check
-     * @returns True if value is a plain object
-     */
     function isObject(value) {
         return value !== null && typeof value === 'object' && !isArray(value);
     }
 
-    /**
-     * Validates a channel contract structure.
-     *
-     * @param contract - The contract to validate
-     * @throws {Error} Error if contract is invalid
-     *
-     * @example Validating contract structure
-     * ```typescript
-     * validateContract({
-     *   emitted: [{ type: 'ping' }],
-     *   accepted: [{ type: 'pong' }]
-     * })
-     * ```
-     */
     function validateContract$1(contract) {
         if (!contract) {
             throw createError('Contract cannot be null or undefined');
@@ -725,27 +268,9 @@
         }
     }
 
-    /**
-     * Helper to check if a string is empty after trimming
-     *
-     * @param str - The string to check
-     * @returns True if string is empty after trimming
-     */
     function isEmpty(str) {
         return str.trim().length === 0;
     }
-    /**
-     * Validates a channel or broker name.
-     *
-     * @param name - The name to validate
-     * @throws {Error} Error if name is invalid
-     *
-     * @example Validating channel name
-     * ```typescript
-     * validateName('my-channel') // valid
-     * validateName('') // throws Error
-     * ```
-     */
     function validateName(name) {
         if (name === null || name === undefined) {
             throw createError('Name cannot be null or undefined');
@@ -758,98 +283,29 @@
         }
     }
 
-    /**
-     * Protocol registry factory.
-     *
-     * Creates a registry for managing protocol providers at the broker level.
-     *
-     * @module security/registry/factory
-     */
-    /**
-     * Creates a protocol registry for managing security protocol providers.
-     *
-     * The registry provides a centralized store for protocol providers,
-     * allowing channels to retrieve the appropriate provider based on
-     * the negotiated protocol version.
-     *
-     * The 'none' protocol is always considered supported (it requires
-     * no provider) and cannot be registered or unregistered.
-     *
-     * @returns A new protocol registry instance
-     *
-     * @example Managing protocol providers
-     * ```typescript
-     * const registry = createProtocolRegistry()
-     *
-     * // Register v1 protocol
-     * registry.register('v1', createProtocol(logger, 60))
-     *
-     * // Check availability
-     * registry.has('v1') // true
-     * registry.has('v2') // false
-     * registry.has('none') // always true
-     *
-     * // Get supported versions
-     * registry.getSupportedVersions() // ['v1', 'none']
-     * ```
-     */
     function createProtocolRegistry() {
         const providers = createMap();
-        /**
-         * Register a protocol provider.
-         *
-         * @param version - The protocol version ('v1' or 'v2')
-         * @param provider - The protocol provider instance
-         */
         const register = (version, provider) => {
             if (!provider) {
                 throw createError(`Cannot register null/undefined provider for ${version}`);
             }
             providers.set(version, provider);
         };
-        /**
-         * Unregister a protocol provider.
-         *
-         * @param version - The protocol version to unregister
-         */
         const unregister = (version) => {
             providers.delete(version);
         };
-        /**
-         * Get a registered protocol provider.
-         *
-         * Returns undefined for 'none' since it requires no provider.
-         *
-         * @param version - The protocol version to retrieve
-         * @returns The provider if registered, otherwise undefined
-         */
         const get = (version) => {
             if (version === 'none') {
                 return undefined;
             }
             return providers.get(version);
         };
-        /**
-         * Check if a protocol provider is registered.
-         *
-         * The 'none' protocol is always considered available.
-         *
-         * @param version - The protocol version to check
-         * @returns True if the provider is registered (or 'none')
-         */
         const has = (version) => {
             if (version === 'none') {
                 return true;
             }
             return providers.has(version);
         };
-        /**
-         * Get all supported protocol versions.
-         *
-         * Returns versions that have registered providers plus 'none'.
-         *
-         * @returns Array of supported protocol versions
-         */
         const getSupportedVersions = () => {
             const versions = ['none'];
             if (providers.has('v1')) {
@@ -869,20 +325,6 @@
         });
     }
 
-    /**
-     * Merges multiple channel contracts into a single contract
-     *
-     * @param contracts - The contracts to merge
-     * @returns A single merged contract containing all accepted and provided actions
-     *
-     * @example Merging channel contracts
-     * ```typescript
-     * const contract1 = { accepted: [{ type: 'a' }], provided: [{ type: 'b' }] }
-     * const contract2 = { accepted: [{ type: 'c' }], provided: [{ type: 'd' }] }
-     * const merged = mergeContracts(contract1, contract2)
-     * // merged = { accepted: [{ type: 'a' }, { type: 'c' }], emitted: [{ type: 'b' }, { type: 'd' }] }
-     * ```
-     */
     function mergeContracts(...contracts) {
         const mergedContract = {
             accepted: [],
@@ -919,38 +361,9 @@
         info: 1,
         debug: 0,
     };
-    /**
-     * Validates whether a given string is a valid log level.
-     *
-     * @param level - The log level to validate
-     * @returns True if the level is valid, false otherwise
-     *
-     * @example Validating log levels
-     * ```typescript
-     * isValidLogLevel('error') // => true
-     * isValidLogLevel('verbose') // => false
-     * ```
-     */
     function isValidLogLevel(level) {
         return logLevels.includes(level);
     }
-    /**
-     * Creates a log level configuration manager for controlling logging behavior.
-     * Provides methods to get, set, and evaluate log levels based on priority.
-     *
-     * @param level - The initial log level (defaults to 'error')
-     * @returns A configuration object with log level management methods
-     * @throws {Error} When the provided level is not a valid log level
-     *
-     * @example Managing log levels with priority checks
-     * ```typescript
-     * const config = createLogLevelConfig('warn')
-     * config.shouldLog('error') // => true (error >= warn)
-     * config.shouldLog('debug') // => false (debug < warn)
-     * config.setLogLevel('debug')
-     * config.shouldLog('debug') // => true
-     * ```
-     */
     function createLogLevelConfig(level = 'error') {
         if (!isValidLogLevel(level)) {
             throw createError('Cannot create log level configuration with a valid default log level');
@@ -1002,18 +415,6 @@
         },
     ];
 
-    /**
-     * Gets the keys from an iterable target based on its data type.
-     *
-     * @param target - The target to get the keys from.
-     * @param dataType - The data type of the target.
-     * @returns The keys from the iterable target.
-     *
-     * @example Extracting keys from object
-     * ```typescript
-     * getKeysFromIterable({ a: 1, b: 2 }, 'object') // ['a', 'b']
-     * ```
-     */
     const getKeysFromIterable = (target, dataType) => {
         if (dataType === 'array')
             dataType = Array.name;
@@ -1025,21 +426,6 @@
         return iterableClass.getKeys(target);
     };
 
-    /**
-     * Returns the data type of the target.
-     * Uses native `typeof` operator, however, makes distinction between `null`, `array`, and `object`.
-     * Also, when classes are registered via `registerClass`, it checks if objects are instance of any known registered class.
-     *
-     * @param target - The target to get the data type of.
-     * @returns The data type of the target.
-     *
-     * @example Determining data types
-     * ```typescript
-     * getType([1, 2]) // 'array'
-     * getType({ a: 1 }) // 'object'
-     * getType(null) // 'null'
-     * ```
-     */
     const getType = (target) => {
         if (target === null)
             return 'null';
@@ -1055,17 +441,6 @@
         return nativeDataType;
     };
 
-    /**
-     * Returns a list of iterable data types. By default 'array' and 'object' are included.,
-     * but can be extended by using `registerIterableClass`.
-     *
-     * @returns Array of iterable data types.
-     *
-     * @example Listing registered iterable types
-     * ```typescript
-     * getIterableTypes() // ['array', 'object', ...registered types]
-     * ```
-     */
     const getIterableTypes = () => registeredIterableClasses.map(({ classRef }) => {
         const name = classRef.name;
         if (name === Object.name)
@@ -1075,109 +450,19 @@
         return name;
     });
 
-    /**
-     * Checks if the provided data type is registered as an iterable type.
-     *
-     * @param dataType - The data type to check
-     * @returns `true` if the data type is iterable, otherwise `false`
-     *
-     * @example Checking iterable types
-     * ```typescript
-     * isIterableType('array') // true
-     * isIterableType('object') // true
-     * isIterableType('string') // false
-     * ```
-     */
     const isIterableType = (dataType) => getIterableTypes().includes(dataType);
 
-    /**
-     * Checks if the target is iterable.
-     *
-     * @param target - The target to check.
-     * @returns `true` if the target is iterable, `false` otherwise.
-     *
-     * @example Checking if value is iterable
-     * ```typescript
-     * isIterable([1, 2]) // true
-     * isIterable({ a: 1 }) // true
-     * isIterable('string') // false
-     * ```
-     */
     const isIterable = (target) => isIterableType(getType(target));
 
-    /**
-     * Safe copies of Date built-in via factory function and static methods.
-     *
-     * @module @hyperfrontend/immutable-api-utils/built-in-copy/date
-     */
-    /* eslint-disable jsdoc/require-param */
     const _Date = globalThis.Date;
-    const _Reflect$4 = globalThis.Reflect;
-    /**
-     * (Safe copy) Creates a new Date using the captured Date constructor.
-     * Use this instead of `new Date()`. Accepts all standard Date constructor signatures.
-     *
-     * @returns A new Date instance.
-     *
-     * @example Creating Date instances
-     * ```typescript
-     * const now = createDate()
-     * const fromTimestamp = createDate(1704067200000)
-     * const fromString = createDate('2024-01-01T00:00:00Z')
-     * const fromParts = createDate(2024, 0, 1, 12, 30, 0) // Jan 1, 2024 12:30:00
-     * ```
-     */
+    const _Reflect$5 = globalThis.Reflect;
     function createDate(...args) {
-        return _Reflect$4.construct(_Date, args);
-    }
-    /**
-     * (Safe copy) Returns the number of milliseconds elapsed since January 1, 1970 00:00:00 UTC.
-     *
-     * @example
-     * ```typescript
-     * const timestamp = dateNow()
-     * // => 1704067200000 (example timestamp)
-     * ```
-     */
+        return _Reflect$5.construct(_Date, args);
+    }
     const dateNow = _Date.now;
-    /**
-     * (Safe copy) Parses a string representation of a date.
-     *
-     * @example
-     * ```typescript
-     * const timestamp = dateParse('2024-01-01T00:00:00Z')
-     * // => 1704067200000
-     * ```
-     */
     const dateParse = _Date.parse;
-    /**
-     * (Safe copy) Returns the number of milliseconds in a Date object since January 1, 1970 UTC.
-     *
-     * @example
-     * ```typescript
-     * const timestamp = dateUTC(2024, 0, 1, 12, 0, 0)
-     * // => 1704110400000 (Jan 1, 2024 12:00:00 UTC)
-     * ```
-     */
     const dateUTC = _Date.UTC;
 
-    /* eslint-disable @typescript-eslint/no-explicit-any */
-    /**
-     * Creates a wrapper function that only executes the wrapped function if the condition function returns true.
-     *
-     * @param func - The function to be conditionally executed.
-     * @param conditionFunc - A function that returns a boolean, determining if `func` should be executed.
-     * @returns A wrapped version of `func` that executes conditionally.
-     *
-     * @example Conditional logging based on flag
-     * ```typescript
-     * let enabled = false
-     * const conditionalLog = createConditionalExecutionFunction(console.log, () => enabled)
-     * conditionalLog('test') // does nothing
-     * enabled = true
-     * conditionalLog('test') // logs 'test'
-     * ```
-     */
     function createConditionalExecutionFunction(func, conditionFunc) {
         return function (...args) {
             if (conditionFunc()) {
@@ -1186,77 +471,19 @@
         };
     }
 
-    /* eslint-disable @typescript-eslint/no-explicit-any */
-    /**
-     * Creates a wrapper function that silently ignores any errors thrown by the wrapped void function.
-     * This function is specifically for wrapping functions that do not return a value (void functions).
-     * Exceptions are swallowed without any logging or handling.
-     *
-     * @param func - The void function to be wrapped.
-     * @returns A wrapped version of the input function that ignores errors.
-     *
-     * @example Safely parsing invalid JSON
-     * ```typescript
-     * const safeParse = createErrorIgnoringFunction(() => JSON.parse('invalid'))
-     * safeParse() // silently fails without throwing
-     * ```
-     */
     function createErrorIgnoringFunction(func) {
         return function (...args) {
             try {
                 func(...args);
             }
             catch {
-                // Deliberately swallowing/ignoring the exception
             }
         };
     }
 
-    /* eslint-disable @typescript-eslint/no-unused-vars */
-    /**
-     * A no-operation function (noop) that does nothing regardless of the arguments passed.
-     * It is designed to be as permissive as possible in its typing without using the `Function` keyword.
-     *
-     * @param args - Any arguments passed to the function (ignored)
-     *
-     * @example Using noop as fallback callback
-     * ```typescript
-     * const callback = condition ? handleEvent : noop
-     * callback() // safely does nothing if condition is false
-     * ```
-     */
     const noop = (...args) => {
-        // Intentionally does nothing
     };
 
-    /**
-     * Creates a logger instance with configurable log level filtering.
-     * Each log function is wrapped to respect the current log level setting.
-     *
-     * @param error - Function to handle error-level logs (required)
-     * @param warn - Function to handle warning-level logs (optional, defaults to noop)
-     * @param log - Function to handle standard logs (optional, defaults to noop)
-     * @param info - Function to handle info-level logs (optional, defaults to noop)
-     * @param debug - Function to handle debug-level logs (optional, defaults to noop)
-     * @returns A frozen logger object with log methods, level control, channel, and timing helpers
-     * @throws {ErrorLevelFn} When any provided log function is invalid
-     *
-     * @example Creating a logger with log level filtering
-     * ```typescript
-     * const logger = createLogger(console.error, console.warn, console.log)
-     * logger.setLogLevel('warn')
-     * logger.warn('Connection timeout') // logs
-     * logger.info('Request complete')   // suppressed (below 'warn' level)
-     * ```
-     *
-     * @example Channeling and timing
-     * ```typescript
-     * const logger = createLogger(console.error, console.warn, console.log, console.info, console.debug)
-     * logger.setLogLevel('debug')
-     * const build = logger.channel('build')
-     * await build.timedAsync('bundle', async () => bundle())
-     * ```
-     */
     function createLogger$1(error, warn = noop, log = noop, info = noop, debug = noop) {
         if (notValidLogFn(error)) {
             throw createError(notFnMsg('error'));
@@ -1291,20 +518,11 @@
         };
         return createPrefixedLogger(core, '');
     }
-    /**
-     * Creates a Logger that prepends `[fullPrefix]` to every log call. When `fullPrefix`
-     * is empty, returns a Logger that delegates directly to the core functions.
-     *
-     * @param core - Shared level-aware log functions and level controls.
-     * @param fullPrefix - Channel chain joined with `:`, or `''` for the root logger.
-     * @returns A frozen Logger that emits with the resolved prefix.
-     */
     function createPrefixedLogger(core, fullPrefix) {
         const tag = fullPrefix ? `[${fullPrefix}]` : '';
         const prefixed = (fn) => {
             if (!tag)
                 return fn;
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
             return (...data) => fn(tag, ...data);
         };
         const instance = freeze({
@@ -1325,14 +543,6 @@
         });
         return instance;
     }
-    /**
-     * Times a sync call, logging completion at debug level or failure at error level.
-     *
-     * @param logger - The logger used to emit the timing message.
-     * @param label - Human-readable label for the timed operation.
-     * @param fn - The synchronous operation to invoke.
-     * @returns The value returned by `fn`.
-     */
     function runTimed(logger, label, fn) {
         const start = dateNow();
         try {
@@ -1347,15 +557,6 @@
             throw error;
         }
     }
-    /**
-     * Times an async call, logging completion at debug level or failure at error level.
-     * On rejection with an `Error` carrying a stack, the stack is also dumped at debug level.
-     *
-     * @param logger - The logger used to emit the timing message.
-     * @param label - Human-readable label for the timed operation.
-     * @param fn - The async operation to invoke.
-     * @returns The value resolved by `fn`'s promise.
-     */
     async function runTimedAsync(logger, label, fn) {
         const start = dateNow();
         try {
@@ -1373,144 +574,42 @@
             throw error;
         }
     }
-    /**
-     * Extracts a human-readable message from an unknown thrown value.
-     *
-     * @param error - The unknown value caught from a try/catch or rejected promise.
-     * @returns The error's `message` when it is an `Error`, otherwise its string coercion.
-     */
     function describeError(error) {
         return error instanceof Error ? error.message : String(error);
     }
-    /**
-     * Validates whether a given value is a valid log function.
-     *
-     * @param fn - The value to validate
-     * @returns True if the value is not a function (invalid), false if it is valid
-     */
     function notValidLogFn(fn) {
         return getType(fn) !== 'function' && fn !== noop;
     }
-    /**
-     * Generates an error message for invalid log function parameters.
-     *
-     * @param label - The name of the log function that failed validation
-     * @returns A formatted error message string
-     */
     function notFnMsg(label) {
         return `Cannot create a logger when ${label} is not a function`;
     }
 
-    /**
-     * Safe copies of Console built-in methods.
-     *
-     * These references are captured at module initialization time to protect against
-     * prototype pollution attacks. Import only what you need for tree-shaking.
-     *
-     * @module @hyperfrontend/immutable-api-utils/built-in-copy/console
-     */
     const _console = globalThis.console;
-    /**
-     * (Safe copy) Outputs a message to the console.
-     */
     const log = _console.log.bind(_console);
-    /**
-     * (Safe copy) Outputs a warning message to the console.
-     */
     const warn = _console.warn.bind(_console);
-    /**
-     * (Safe copy) Outputs an error message to the console.
-     */
     const error = _console.error.bind(_console);
-    /**
-     * (Safe copy) Outputs an informational message to the console.
-     */
     const info = _console.info.bind(_console);
-    /**
-     * (Safe copy) Outputs a debug message to the console.
-     */
     const debug = _console.debug.bind(_console);
-    /**
-     * (Safe copy) Outputs a stack trace to the console.
-     */
     _console.trace.bind(_console);
-    /**
-     * (Safe copy) Displays an interactive listing of the properties of a specified object.
-     */
     _console.dir.bind(_console);
-    /**
-     * (Safe copy) Displays tabular data as a table.
-     */
     _console.table.bind(_console);
-    /**
-     * (Safe copy) Writes an error message to the console if the assertion is false.
-     */
     _console.assert.bind(_console);
-    /**
-     * (Safe copy) Clears the console.
-     */
     _console.clear.bind(_console);
-    /**
-     * (Safe copy) Logs the number of times that this particular call to count() has been called.
-     */
     _console.count.bind(_console);
-    /**
-     * (Safe copy) Resets the counter used with console.count().
-     */
     _console.countReset.bind(_console);
-    /**
-     * (Safe copy) Creates a new inline group in the console.
-     */
     _console.group.bind(_console);
-    /**
-     * (Safe copy) Creates a new inline group in the console that is initially collapsed.
-     */
     _console.groupCollapsed.bind(_console);
-    /**
-     * (Safe copy) Exits the current inline group.
-     */
     _console.groupEnd.bind(_console);
-    /**
-     * (Safe copy) Starts a timer with a name specified as an input parameter.
-     */
     _console.time.bind(_console);
-    /**
-     * (Safe copy) Stops a timer that was previously started.
-     */
     _console.timeEnd.bind(_console);
-    /**
-     * (Safe copy) Logs the current value of a timer that was previously started.
-     */
     _console.timeLog.bind(_console);
 
     const logger = createLogger$1(error, warn, log, info, debug);
 
     const DEFAULT_PREFIX = '[nexus]';
-    /**
-     * Creates a logger instance configured for nexus.
-     *
-     * If a custom logger is provided, it will be used directly.
-     * Otherwise, a new logger will be created using the logging library.
-     *
-     * @param options - Logger configuration options
-     * @returns Logger instance
-     *
-     * @example Configuring logger options
-     * ```typescript
-     * const logger = createLogger({ level: 'debug', prefix: '[my-channel]' })
-     * logger.debug('Channel initialized')
-     * ```
-     */
     function createLogger(options = {}) {
         return createLoggerInternal(options);
     }
-    /**
-     * Internal helper to create a logger with given options.
-     *
-     * @param options - Logger configuration options
-     * @returns Configured logger instance
-     * @internal
-     */
     const createLoggerInternal = (options) => {
         const { level = 'error', prefix = DEFAULT_PREFIX, customLogger } = options;
         if (customLogger)
@@ -1521,31 +620,10 @@
         return nexusLogger;
     };
 
-    /**
-     * Safe WeakSet factory for protected weak set construction.
-     *
-     * @module @hyperfrontend/immutable-api-utils/built-in-copy/weak-set
-     */
-    /* eslint-disable workspace/lib-require-jsdoc-example */
     const _WeakSet = globalThis.WeakSet;
-    const _Reflect$3 = globalThis.Reflect;
-    /**
-     * (Safe copy) Creates a new WeakSet using the captured WeakSet constructor.
-     * Use this instead of `new WeakSet()`.
-     *
-     * @param iterable - Optional iterable of values.
-     * @returns A new WeakSet instance.
-     */
-    const createWeakSet = (iterable) => _Reflect$3.construct(_WeakSet, iterable ? [iterable] : []);
-
-    /**
-     * Checks whether an object has circular references using WeakSet.
-     * Safe for use with frozen objects since it only reads, never mutates.
-     *
-     * @param value - The value to check
-     * @param seen - WeakSet of already-seen references
-     * @returns True if circular reference detected
-     */
+    const _Reflect$4 = globalThis.Reflect;
+    const createWeakSet = (iterable) => _Reflect$4.construct(_WeakSet, iterable ? [iterable] : []);
+
     function hasCircular(value, seen) {
         if (!isIterable(value))
             return false;
@@ -1562,36 +640,12 @@
         }
         return false;
     }
-    /**
-     * Asserts that the given value does not contain circular references.
-     * Throws an Error if a circular reference is detected.
-     *
-     * Uses WeakSet-based cycle detection that works safely with frozen objects.
-     *
-     * @param value - The value to check for circular references
-     * @param paramName - Name of the parameter for error messaging
-     * @throws {Error} if circular reference is detected
-     *
-     * @example Checking for circular references
-     * ```typescript
-     * const config = { a: 1, b: 2 }
-     * assertNoCircularRef(config, 'config') // OK
-     *
-     * const circular: Record<string, unknown> = { a: 1 }
-     * circular.self = circular
-     * assertNoCircularRef(circular, 'config') // Throws Error
-     * ```
-     */
     function assertNoCircularRef(value, paramName) {
         if (hasCircular(value, createWeakSet())) {
             throw createError(`Circular reference detected in parameter "${paramName}"`);
         }
     }
 
-    /**
-     * Default channel settings.
-     * Accept any origin, queue messages, inherit contract from broker.
-     */
     const DEFAULT_CHANNEL_SETTINGS = freeze({
         origin: '*',
         queueMessages: true,
@@ -1599,23 +653,6 @@
         contract: undefined,
     });
 
-    /**
-     * Gracefully closes an active channel connection.
-     *
-     * - Only works if channel is currently active
-     * - Sets channel state to inactive
-     * - Optionally notifies the target window
-     * - Fires 'close' event to subscribers
-     *
-     * @param channel - Channel internals with state and dependencies
-     * @param notify - Whether to notify target window (default: true)
-     *
-     * @example Gracefully closing a connection
-     * ```typescript
-     * disconnect(channel, true) // Close and notify target
-     * disconnect(channel, false) // Close silently
-     * ```
-     */
     function disconnect(channel, notify = true) {
         const state = channel.getState();
         if (!state.active) {
@@ -1630,22 +667,6 @@
         channel.notifyEvent('close');
     }
 
-    /**
-     * Cancels a pending connection request.
-     *
-     * - If channel is closed, sends CANCEL_CONNECTION
-     * - If channel is already open, calls disconnect instead
-     * - Fires 'cancel' event to subscribers
-     *
-     * @param channel - Channel internals with state and dependencies
-     * @param notify - Whether to notify target window (default: true)
-     *
-     * @example Canceling a pending connection
-     * ```typescript
-     * cancel(channel, true) // Cancel and notify target
-     * cancel(channel, false) // Cancel silently
-     * ```
-     */
     function cancel(channel, notify = true) {
         const state = channel.getState();
         if (state.active) {
@@ -1660,19 +681,6 @@
         channel.notifyEvent('cancel');
     }
 
-    /**
-     * Clears all queued messages from the channel.
-     * Returns a new state object with empty queue (immutable update).
-     *
-     * @param state - Current channel state
-     * @returns New state with cleared message queue
-     *
-     * @example Clearing all queued messages
-     * ```typescript
-     * const clearedState = clearQueue(channelState)
-     * // => { ...channelState, queuedMessages: [] }
-     * ```
-     */
     function clearQueue(state) {
         return freeze({
             ...state,
@@ -1680,21 +688,6 @@
         });
     }
 
-    /**
-     * Adds a message to the channel's queue.
-     * Returns a new state object with the message appended (immutable update).
-     *
-     * @param state - Current channel state
-     * @param message - Message to queue
-     * @returns New state with message added to queue
-     *
-     * @example Adding a message to the queue
-     * ```typescript
-     * const message = { type: 'data', payload: { userId: 123 } }
-     * const updatedState = queueMessage(channelState, message)
-     * // => { ...channelState, queuedMessages: [...existingMessages, message] }
-     * ```
-     */
     function queueMessage(state, message) {
         return freeze({
             ...state,
@@ -1702,33 +695,12 @@
         });
     }
 
-    /**
-     * Queues a message for delivery when the channel opens.
-     *
-     * Messages are stored in the channel state and will be sent
-     * automatically when the channel becomes active via the flush operation.
-     *
-     * @param channel - Channel internals with state and dependencies
-     * @param message - Message to queue
-     *
-     * @example Queueing a message
-     * ```typescript
-     * queue(channel, { type: 'GREETING', data: 'Hello' })
-     * ```
-     */
     function queue(channel, message) {
         const state = channel.getState();
         const newState = queueMessage(state, message);
         channel.updateState(newState);
     }
 
-    /**
-     * Action types that should always be sent in plaintext.
-     *
-     * Handshake actions must remain unencrypted because:
-     * - Security negotiation happens during handshake
-     * - Both parties need to read handshake messages before security is established
-     */
     const PLAINTEXT_ACTION_TYPES = createSet([
         ACTION_TYPES.REQUEST_CONNECTION,
         ACTION_TYPES.ACCEPT_CONNECTION,
@@ -1737,26 +709,6 @@
         ACTION_TYPES.CANCEL_CONNECTION_ACKNOWLEDGED,
         ACTION_TYPES.OPEN_CONNECTION,
     ]);
-    /**
-     * Sends a raw action to the channel's target window.
-     *
-     * This function routes actions through the security transport when:
-     * - The channel has a security transport configured
-     * - The security transport is ready
-     * - The action type is not a handshake action (handshakes are always plaintext)
-     *
-     * For secure protocols (v1/v2), the action is encrypted and sent as Uint8Array.
-     * For 'none' protocol or handshake actions, the action is sent as plain object.
-     *
-     * @param channel - Channel internals with state and dependencies
-     * @param action - Action to send
-     *
-     * @example Sending an action to the target window
-     * ```typescript
-     * const action = channel.actions.requestConnection(processId)
-     * sendAction(channel, action)
-     * ```
-     */
     function sendAction(channel, action) {
         const state = channel.getState();
         if (!action || typeof action.type !== 'string') {
@@ -1771,29 +723,6 @@
         state.target.postMessage(action, '*');
     }
 
-    /**
-     * Sends a typed message through an active channel.
-     *
-     * Message routing behavior:
-     * - If channel is closed and queueMessages is enabled, queues the message
-     * - If channel is closed and queueMessages is disabled, throws error
-     * - If security transport exists but is not ready, queues the message
-     * - If channel is open and security is ready (or protocol is 'none'), sends message
-     *
-     * For secure protocols (v1/v2), the message is routed through the security
-     * transport which encrypts and sends as Uint8Array via postMessage.
-     *
-     * @param channel - Channel internals with state and dependencies
-     * @param message - Message to send with type and data
-     *
-     * @throws {Error} If channel is closed and queueing is disabled
-     * @throws {Error} If message type is not accepted in channel contract
-     *
-     * @example Sending a typed message
-     * ```typescript
-     * send(channel, { type: 'USER_ACTION', data: { userId: 123 } })
-     * ```
-     */
     function send(channel, message) {
         const state = channel.getState();
         if (!state.active) {
@@ -1816,24 +745,11 @@
         if (!emittedTypes.includes(message.type)) {
             throw createError(`Cannot send message to ${state.name} channel. Message type '${message.type}' is not in the emitted actions of channel contract.`);
         }
-        const action = channel.actions.newMessage(message.data);
+        const action = channel.actions.newMessage(message);
         sendAction(channel, action);
         channel.notifyMessage(message);
     }
 
-    /**
-     * Sends all queued messages and clears the queue.
-     *
-     * Called automatically when a channel opens if queueMessages is enabled.
-     * Messages are sent in FIFO order.
-     *
-     * @param channel - Channel internals with state and dependencies
-     *
-     * @example Flushing queued messages
-     * ```typescript
-     * flush(channel) // Sends all queued messages
-     * ```
-     */
     function flush(channel) {
         const state = channel.getState();
         for (const message of state.queuedMessages) {
@@ -1850,20 +766,6 @@
         channel.updateState(newState);
     }
 
-    /**
-     * Initiates the connection handshake for a channel.
-     *
-     * - If channel is already open, does nothing
-     * - If channel has a scheduled activation (pending connection), accepts it
-     * - Otherwise, sends REQUEST_CONNECTION to initiate handshake
-     *
-     * @param channel - Channel internals with state and dependencies
-     *
-     * @example Initiating a connection
-     * ```typescript
-     * connect(channel) // Sends REQUEST_CONNECTION or accepts pending
-     * ```
-     */
     function connect(channel) {
         const state = channel.getState();
         if (state.active) {
@@ -1905,24 +807,6 @@
         channel.sendAction(requestAction);
     }
 
-    /**
-     * Immediately destroys a channel and removes it from the broker.
-     *
-     * - Sets channel to inactive immediately
-     * - Optionally notifies the target window
-     * - Removes channel from all registries
-     * - Fires 'destroy' event to subscribers
-     * - This is irreversible - channel cannot be reconnected
-     *
-     * @param channel - Channel internals with state and dependencies
-     * @param notify - Whether to notify target window (default: true)
-     *
-     * @example Destroying a channel
-     * ```typescript
-     * destroy(channel, true) // Destroy and notify target
-     * destroy(channel, false) // Destroy silently
-     * ```
-     */
     function destroy(channel, notify = true) {
         channel.updateState({ active: false });
         if (notify) {
@@ -1934,22 +818,6 @@
         }
     }
 
-    /**
-     * Activates a channel by setting it as active and recording connection details.
-     * Returns a new state object (immutable update).
-     *
-     * @param state - Current channel state
-     * @param origin - Origin of the connected channel
-     * @param contract - Negotiated channel contract
-     * @returns New state with channel activated
-     *
-     * @example Activating a channel with contract
-     * ```typescript
-     * const contract = { accepted: [{ type: 'message' }] }
-     * const activeState = activate(channelState, 'https://example.com', contract)
-     * // => { ...channelState, active: true, origin: 'https://example.com', ... }
-     * ```
-     */
     function activate(state, origin, contract) {
         const acceptedActions = (contract.accepted || []).map((action) => action.type);
         return freeze({
@@ -1963,21 +831,6 @@
         });
     }
 
-    /**
-     * Creates the initial state for a new channel.
-     * All collections are empty, all optional fields are null.
-     *
-     * @param name - Channel name/identifier
-     * @param target - Target window for communication
-     * @param settings - Channel settings (queueMessages, debug, logger, etc.)
-     * @returns Fresh channel state object
-     *
-     * @example Creating initial channel state
-     * ```typescript
-     * const state = createInitialState('my-channel', targetWindow, { queueMessages: true })
-     * // => { id: '...', name: 'my-channel', active: false, queuedMessages: [], ... }
-     * ```
-     */
     function createInitialState(name, target, settings) {
         return freeze({
             id: uuidV4(),
@@ -2003,26 +856,6 @@
         });
     }
 
-    /**
-     * Implementation of subscribeToEvents that handles both overload signatures.
-     *
-     * @param channel - The channel internals object
-     * @param eventOrHandler - Either an event name or a handler function
-     * @param handler - Handler function when event name is provided
-     * @returns Unsubscribe function to remove the handler
-     *
-     * @example Subscribing to all events with cleanup
-     * ```typescript
-     * const unsubscribe = subscribeToEvents(channel, (event, data) => {
-     *   if (event === 'open') {
-     *     console.log('Channel opened:', data)
-     *   }
-     * })
-     *
-     * // Cleanup when no longer needed
-     * unsubscribe()
-     * ```
-     */
     function subscribeToEvents(channel, eventOrHandler, handler) {
         const isEventSpecific = typeof eventOrHandler === 'string' && typeof handler === 'function';
         let wrappedHandler;
@@ -2054,26 +887,6 @@
         };
     }
 
-    /**
-     * Subscribes to incoming messages on the channel.
-     *
-     * Handler will be called with each message received from the target window.
-     *
-     * @param channel - Channel internals with state and dependencies
-     * @param handler - Message handler function
-     * @returns Unsubscribe function to remove the handler
-     *
-     * @throws {Error} If handler is not a function
-     *
-     * @example Subscribing to channel messages
-     * ```typescript
-     * const unsubscribe = subscribeToMessages(channel, (message) => {
-     *   console.log('Message:', message.type, message.data)
-     * })
-     *
-     * // Later: unsubscribe()
-     * ```
-     */
     function subscribeToMessages(channel, handler) {
         if (typeof handler !== 'function') {
             throw createError('Expected callback function.');
@@ -2088,32 +901,10 @@
         };
     }
 
-    /**
-     * Logs a channel event in a structured format.
-     *
-     * @param logger - Logger instance to use
-     * @param event - Type of channel event that occurred
-     * @param data - Additional data associated with the event
-     */
     function logEvent(logger, event, data) {
         logger.debug(`Channel event:`, event, data);
     }
 
-    /**
-     * Notifies all event subscribers of a channel event.
-     *
-     * Calls each subscribed event handler with the event type, optional data, and channel JSON.
-     * Errors in handlers are caught and logged to prevent breaking other handlers.
-     *
-     * @param channel - Channel internals with state and dependencies
-     * @param event - Event type that occurred
-     * @param data - Optional event data
-     *
-     * @example Notifying subscribers of an event
-     * ```typescript
-     * notifyEvent(channel, 'open', { timestamp: Date.now() })
-     * ```
-     */
     function notifyEvent(channel, event, data) {
         const state = channel.getState();
         if (state.logger) {
@@ -2140,20 +931,6 @@
         }
     }
 
-    /**
-     * Notifies all message subscribers of an incoming message.
-     *
-     * Calls each subscribed message handler with the message data.
-     * Errors in handlers are caught and logged to prevent breaking other handlers.
-     *
-     * @param channel - Channel internals with state and dependencies
-     * @param message - Message that was received
-     *
-     * @example Notifying subscribers of a message
-     * ```typescript
-     * notifyMessage(channel, { type: 'USER_ACTION', data: { userId: 123 } })
-     * ```
-     */
     function notifyMessage(channel, message) {
         const state = channel.getState();
         for (const handler of state.messageSubscriptions) {
@@ -2168,26 +945,6 @@
         }
     }
 
-    /**
-     * Creates a new message channel.
-     *
-     * Uses functional programming with closures for encapsulation.
-     * Returns a public handle with methods while keeping state private.
-     *
-     * @param config - Channel configuration (name, target, settings)
-     * @param deps - Dependencies (action creators, process manager, cleanup)
-     * @returns Channel handle with public API
-     *
-     * @example Creating and using a channel
-     * ```typescript
-     * const channel = createChannel(
-     *   { name: 'my-channel', target: childWindow },
-     *   { actions, processManager, cleanup }
-     * )
-     * channel.connect()
-     * channel.send('greet', { message: 'Hello!' })
-     * ```
-     */
     function createChannel(config, deps) {
         assertNoCircularRef(config.settings, 'config.settings');
         const settings = { ...DEFAULT_CHANNEL_SETTINGS, ...config.settings };
@@ -2223,6 +980,7 @@
             getName: () => state.name,
             getTarget: () => state.target,
             isActive: () => state.active,
+            getAcceptedTypes: () => state.acceptedActions,
             toJSON: () => ({
                 id: state.id,
                 name: state.name,
@@ -2291,72 +1049,18 @@
         return freeze(handle);
     }
 
-    /**
-     * Adds a channel to the registry, making it available for lookup
-     * by window, ID, and name.
-     *
-     * @param registry - The channel registry instance
-     * @param channel - Channel to register (must have id, name, target)
-     * @throws {Error} Error if channel is invalid
-     *
-     * @example Registering a channel
-     * ```typescript
-     * const registry = createRegistry()
-     * add(registry, { id: 'ch-1', name: 'main', target: iframe.contentWindow })
-     * ```
-     */
     function add(registry, channel) {
         registry.add(channel);
     }
 
-    /**
-     * Finds a channel by its target window.
-     * Uses WeakMap for O(1) lookup that doesn't prevent garbage collection.
-     *
-     * @param registry - The channel registry instance
-     * @param target - The window to look up
-     * @returns Channel if found, undefined otherwise
-     */
     function getByWindow(registry, target) {
         return registry.getByWindow(target);
     }
 
-    /**
-     * Removes a channel from the registry, making it unavailable
-     * for all lookup methods.
-     *
-     * @param registry - The channel registry instance
-     * @param channel - Channel to unregister
-     */
     function remove(registry, channel) {
         registry.remove(channel);
     }
 
-    /**
-     * Adds a channel to the broker.
-     *
-     * @param state - Current broker state
-     * @param registry - Channel registry for storing and retrieving channels
-     * @param processManager - Process ID manager for tracking communication processes
-     * @param actions - Action creators from broker for managing channel lifecycle
-     * @param name - Unique identifier for the channel
-     * @param target - Target window to communicate with
-     * @param settings - Optional configuration settings for the channel
-     * @returns The created or existing channel
-     *
-     * @example Registering a channel with the broker
-     * ```typescript
-     * const channel = addChannel(
-     *   brokerState,
-     *   registry,
-     *   processManager,
-     *   actions,
-     *   'widget-channel',
-     *   iframe.contentWindow,
-     *   { timeout: 5000 }
-     * )
-     * ```
-     */
     function addChannel(state, registry, processManager, actions, name, target, settings = {}) {
         assertNoCircularRef(settings, 'settings');
         const existing = getByWindow(registry, target);
@@ -2383,43 +1087,14 @@
         return channel;
     }
 
-    /**
-     * Finds a channel by its unique ID.
-     * Uses Map for O(1) lookup.
-     *
-     * @param registry - The channel registry instance
-     * @param id - The channel ID (UUID) to look up
-     * @returns Channel if found, undefined otherwise
-     */
     function getById(registry, id) {
         return registry.getById(id);
     }
 
-    /**
-     * Finds a channel by its name.
-     * Uses Map for O(1) lookup.
-     *
-     * @param registry - The channel registry instance
-     * @param name - The channel name to look up
-     * @returns Channel if found, undefined otherwise
-     */
     function getByName(registry, name) {
         return registry.getByName(name);
     }
 
-    /**
-     * Gets a channel by reference (id, name, or window)
-     *
-     * @param registry - Channel registry containing all registered channels
-     * @param reference - Channel identifier (id, name, or window object)
-     * @returns The channel if found, null otherwise
-     *
-     * @example Retrieving channels by name or window
-     * ```typescript
-     * const channelByName = getChannel(registry, 'widget-channel')
-     * const channelByWindow = getChannel(registry, iframe.contentWindow)
-     * ```
-     */
     function getChannel(registry, reference) {
         if (typeof reference === 'object' && reference !== null) {
             const channel = getByWindow(registry, reference);
@@ -2432,64 +1107,20 @@
         return null;
     }
 
-    /**
-     * Returns all registered channels as an array.
-     * The order is not guaranteed.
-     *
-     * @param registry - The channel registry instance
-     * @returns Array of all registered channels
-     *
-     * @example Listing registered channels
-     * ```typescript
-     * const registry = createRegistry()
-     * const channels = getAll(registry)
-     * channels.forEach(ch => console.log(ch.name))
-     * ```
-     */
     function getAll(registry) {
         return registry.getAll();
     }
 
-    /**
-     * Lists all channels in JSON format
-     *
-     * @param registry - Channel registry containing all registered channels
-     * @returns Array of channel JSON representations
-     *
-     * @example Listing all channels as JSON
-     * ```typescript
-     * const channels = listChannels(registry)
-     * // => [{ id: 'abc-123', name: 'widget', state: 'connected' }, ...]
-     * ```
-     */
     function listChannels(registry) {
         const channels = getAll(registry);
         return channels.map((channel) => channel.toJSON());
     }
 
-    /**
-     * Removes a channel from the broker
-     *
-     * @param registry - Channel registry from which to remove the channel
-     * @param channel - The channel instance to cleanup and remove
-     *
-     * @example Removing a channel from the broker
-     * ```typescript
-     * const channel = getChannel(registry, 'widget-channel')
-     * if (channel) {
-     *   removeChannel(registry, channel)
-     * }
-     * ```
-     */
     function removeChannel(registry, channel) {
         channel.destroy(false);
         remove(registry, channel);
     }
 
-    /**
-     * Default broker settings
-     * Used when settings are partially provided
-     */
     const defaultBrokerSettings = freeze({
         whitelist: freeze([]),
         blacklist: freeze([]),
@@ -2497,21 +1128,6 @@
         logLevel: 'error',
     });
 
-    /**
-     * Creates a router map for action types to handlers.
-     *
-     * @param handlers - Map of action types to handler functions
-     * @returns Router map
-     *
-     * @example Creating a router for action handlers
-     * ```typescript
-     * const router = createRouter({
-     *   'OPEN': handleOpen,
-     *   'CLOSE': handleClose,
-     *   'MESSAGE': handleMessage,
-     * })
-     * ```
-     */
     function createRouter(handlers) {
         const router = createMap();
         entries(handlers).forEach(([type, handler]) => {
@@ -2520,21 +1136,6 @@
         return router;
     }
 
-    /**
-     * Applies a security policy to a connection request.
-     *
-     * @param policy - The security policy function
-     * @param event - The MessageEvent to validate
-     * @param logger - Logger instance for error reporting
-     * @returns true if policy allows connection, false otherwise
-     *
-     * @example Validating connection requests with security policy
-     * ```typescript
-     * const policy = (event) => event.origin === 'https://trusted.example.com'
-     * const allowed = applyPolicy(policy, messageEvent, logger)
-     * // => true or false
-     * ```
-     */
     function applyPolicy(policy, event, logger) {
         try {
             const result = policy(event);
@@ -2546,27 +1147,6 @@
         }
     }
 
-    /**
-     * Handles ACCEPT_CONNECTION action.
-     * Completes connection handshake from the initiator's side.
-     *
-     * @param context - Routing context with state, registry, actions, and logger
-     * @param message - Message event containing the ACCEPT_CONNECTION action
-     *
-     * @remarks
-     * Side Effects:
-     * - Activates the channel
-     * - Extracts negotiated security protocol (if present)
-     * - Stores negotiated protocol in channel state
-     * - Sends OPEN_CONNECTION to complete handshake (with security confirmation)
-     * - Terminates process after activation
-     * - Fires 'open' lifecycle event
-     *
-     * @example Three-way handshake acceptance
-     * Second step of three-way handshake:
-     * Initiator <- ACCEPT (this handler) <- Responder
-     * Initiator -> OPEN -> Responder
-     */
     function handleAccept(context, message) {
         const { state, processManager, logger } = context;
         const action = message.data;
@@ -2629,33 +1209,22 @@
         channel.notifyEvent('open', { origin: message.origin, contract });
     }
 
-    /**
-     * Handles CANCEL_CONNECTION action.
-     * Processes connection cancellation request.
-     *
-     * @param context - Routing context with state, registry, actions, and logger
-     * @param message - Message event containing the CANCEL_CONNECTION action
-     *
-     * @remarks
-     * Side Effects:
-     * - Cancels pending connection
-     * - Sends CANCEL_CONNECTION_ACKNOWLEDGED response
-     * - Terminates process
-     * - Fires 'cancel' lifecycle event
-     *
-     * @example Cancellation flow during connection
-     * Cancel flow (before connection completes):
-     * Side A -> CANCEL_CONNECTION
-     * Side B <- CANCEL (this handler)
-     * Side B -> CANCEL_ACKNOWLEDGED
-     * Both sides fire 'cancel' event
-     */
+    function resolveChannel(registry, message) {
+        const source = message.source;
+        if (source) {
+            const channel = registry.getByWindow(source);
+            if (channel) {
+                return channel;
+            }
+        }
+        return registry.getById(message.data.senderId);
+    }
+
     function handleCancel(context, message) {
         const { state, registry, processManager } = context;
         const action = message.data;
-        const senderId = action['senderId'];
         const processId = action['processId'];
-        const channel = (getById(registry, senderId) || processManager.get(processId));
+        const channel = (resolveChannel(registry, message) || processManager.get(processId));
         if (!channel) {
             return;
         }
@@ -2669,24 +1238,6 @@
         channel.notifyEvent('cancel', { notify: true });
     }
 
-    /**
-     * Handles CANCEL_CONNECTION_ACKNOWLEDGED action.
-     * Completes cancellation on initiator's side and notifies cancel event.
-     *
-     * @param context - Routing context with state, registry, actions, and logger
-     * @param message - Message event containing the CANCEL_CONNECTION_ACKNOWLEDGED action
-     *
-     * @remarks
-     * Side Effects:
-     * - Terminates the connection process
-     * - Fires 'cancel' lifecycle event on initiator's side
-     *
-     * @example Initiator-side cancellation acknowledgment
-     * Cancellation acknowledgment (initiator side):
-     * Initiator -> CANCEL_CONNECTION
-     * Initiator <- CANCEL_ACKNOWLEDGED (this handler)
-     * Initiator fires 'cancel' event
-     */
     function handleCancelAcknowledged(context, message) {
         const { processManager } = context;
         const action = message.data;
@@ -2699,36 +1250,14 @@
         channel.notifyEvent('cancel', { notify: false });
     }
 
-    /**
-     * Handles CLOSE_CONNECTION action.
-     * Gracefully closes an open connection.
-     *
-     * @param context - Routing context with state, registry, actions, and logger
-     * @param message - Message event containing the CLOSE_CONNECTION action
-     *
-     * @remarks
-     * Side Effects:
-     * - Deactivates the channel
-     * - Sends CLOSE_CONNECTION_ACKNOWLEDGED response
-     * - Terminates process
-     * - Fires 'close' lifecycle event
-     *
-     * @example Graceful disconnect flow
-     * Disconnect flow:
-     * Side A -> CLOSE_CONNECTION (initiates)
-     * Side B <- CLOSE_CONNECTION (this handler)
-     * Side B -> CLOSE_ACKNOWLEDGED
-     * Both sides fire 'close' event
-     */
     function handleClose(context, message) {
         const { state, registry, processManager } = context;
         const action = message.data;
-        const senderId = action.senderId;
         if (!('processId' in action)) {
             return;
         }
         const processId = action.processId;
-        const channel = getById(registry, senderId);
+        const channel = resolveChannel(registry, message);
         if (!channel || !channel.isActive()) {
             return;
         }
@@ -2742,18 +1271,6 @@
         channel.notifyEvent('close', { notify: true });
     }
 
-    /**
-     * Handles CLOSE_CONNECTION_ACKNOWLEDGED action.
-     * Completes close on initiator's side and notifies close event.
-     *
-     * @param context - Routing context with state, registry, actions, and logger
-     * @param message - Message event containing the CLOSE_CONNECTION_ACKNOWLEDGED action
-     *
-     * @example Handling close acknowledgment
-     * ```typescript
-     * handleCloseAcknowledged(routingContext, closeAcknowledgedEvent)
-     * ```
-     */
     function handleCloseAcknowledged(context, message) {
         const { processManager } = context;
         const action = message.data;
@@ -2766,25 +1283,6 @@
         channel.notifyEvent('close', { notify: false });
     }
 
-    /**
-     * Handles DENY_CONNECTION action.
-     * Processes connection denial from remote broker.
-     *
-     * @param context - Routing context with state, registry, actions, and logger
-     * @param message - Message event containing the DENY_CONNECTION action
-     *
-     * @remarks
-     * Side Effects:
-     * - Terminates the connection process
-     * - Fires 'deny' lifecycle event with error details
-     *
-     * @example Connection denial during handshake
-     * Denial flow (during handshake):
-     * Initiator -> REQUEST_CONNECTION
-     * Responder validates and rejects
-     * Initiator <- DENY_CONNECTION (this handler)
-     * Initiator fires 'deny' event
-     */
     function handleDeny(context, message) {
         const { processManager } = context;
         const action = message.data;
@@ -2798,55 +1296,15 @@
         channel.notifyEvent('deny', { error, origin: message.origin });
     }
 
-    /**
-     * Handles DESTROY_CONNECTION action.
-     * Immediately destroys a connection without handshake.
-     *
-     * @param context - Routing context with state, registry, actions, and logger
-     * @param message - Message event containing the DESTROY_CONNECTION action
-     *
-     * @remarks
-     * Side Effects:
-     * - Immediately destroys channel (no acknowledgment)
-     * - Removes channel from registry
-     * - No lifecycle event fired (forceful termination)
-     *
-     * @example Forceful connection termination
-     * Forceful termination (e.g., window unload):
-     * channel.destroy()
-     * -> DESTROY_CONNECTION sent
-     * -> Remote receives (this handler)
-     * -> Channel immediately removed
-     */
     function handleDestroy(context, message) {
         const { registry } = context;
-        const action = message.data;
-        const senderId = action.senderId;
-        const channel = getById(registry, senderId);
+        const channel = resolveChannel(registry, message);
         if (!channel) {
             return;
         }
         channel.destroy(false);
     }
 
-    /**
-     * Handles INVALID_REQUEST action.
-     * Processes error responses from remote broker.
-     *
-     * @param context - Routing context with state, registry, actions, and logger
-     * @param message - Message event containing the INVALID_REQUEST action
-     *
-     * @remarks
-     * Side Effects:
-     * - Fires 'invalid' lifecycle event with error details
-     *
-     * @example Handling protocol violations
-     * Protocol violation detected:
-     * Initiator sends malformed action
-     * Responder detects violation
-     * Initiator <- INVALID_REQUEST (this handler)
-     * Initiator fires 'invalid' event with reason
-     */
     function handleInvalid(context, message) {
         const { processManager } = context;
         const action = message.data;
@@ -2890,67 +1348,18 @@
     	additionalProperties: additionalProperties
     };
 
-    /**
-     * Safe copies of JSON built-in methods.
-     *
-     * These references are captured at module initialization time to protect against
-     * prototype pollution attacks. Import only what you need for tree-shaking.
-     *
-     * @module @hyperfrontend/immutable-api-utils/built-in-copy/json
-     */
     const _JSON = globalThis.JSON;
-    /**
-     * (Safe copy) Converts a JavaScript value to a JavaScript Object Notation (JSON) string.
-     */
     const stringify = _JSON.stringify;
 
-    /**
-     * Safe copies of Number built-in methods and constants.
-     *
-     * These references are captured at module initialization time to protect against
-     * prototype pollution attacks. Import only what you need for tree-shaking.
-     *
-     * @module @hyperfrontend/immutable-api-utils/built-in-copy/number
-     */
     const _Number = globalThis.Number;
     const _parseInt = globalThis.parseInt;
     const _isNaN = globalThis.isNaN;
     const _isFinite = globalThis.isFinite;
-    /**
-     * (Safe copy) Determines whether the passed value is an integer.
-     */
     const isInteger = _Number.isInteger;
-    /**
-     * (Safe copy) Parses a string and returns an integer.
-     */
     const parseInt = _parseInt;
-    /**
-     * (Safe copy) Global isNaN function (coerces to number first, less strict than Number.isNaN).
-     */
     const globalIsNaN = _isNaN;
-    /**
-     * (Safe copy) Global isFinite function (coerces to number first, less strict than Number.isFinite).
-     */
     const globalIsFinite = _isFinite;
 
-    /**
-     * Creates a new validation context.
-     *
-     * @param rootSchema - The root schema being validated against
-     * @param validator - The schema validator function
-     * @param collectAllErrors - Whether to collect all errors (default: true)
-     * @param strictPatterns - Whether to report errors for invalid regex patterns (default: false)
-     * @param patternSafetyChecker - Optional pattern safety checker for ReDoS detection
-     * @returns A new validation context
-     * @example Creating validation context
-     * ```typescript
-     * const schema = { type: 'string' }
-     * const ctx = createValidationContext(schema, validateSchema)
-     * // ctx.path === ''
-     * // ctx.errors === []
-     * // ctx.collectAllErrors === true
-     * ```
-     */
     function createValidationContext(rootSchema, validator, collectAllErrors = true, strictPatterns = false, patternSafetyChecker) {
         const definitions = createMap();
         if (rootSchema.definitions) {
@@ -2969,21 +1378,6 @@
             validate: validator,
         };
     }
-    /**
-     * Creates a child context with updated path.
-     *
-     * @param ctx - Parent context
-     * @param segment - Path segment to append
-     * @returns New context with updated path
-     * @example Creating child context with path
-     * ```typescript
-     * const ctx = createValidationContext(schema, validate)
-     * const childCtx = pushPath(ctx, 'items')
-     * // childCtx.path === '/items'
-     * const nestedCtx = pushPath(childCtx, 0)
-     * // nestedCtx.path === '/items/0'
-     * ```
-     */
     function pushPath(ctx, segment) {
         const escapedSegment = String(segment).replace(/~/g, '~0').replace(/\//g, '~1');
         return {
@@ -2991,22 +1385,6 @@
             path: `${ctx.path}/${escapedSegment}`,
         };
     }
-    /**
-     * Adds a validation error to the context.
-     *
-     * @param ctx - Validation context
-     * @param message - Human-readable error message
-     * @param instance - The failing value
-     * @param code - Optional error code for programmatic handling
-     * @param params - Optional additional parameters
-     * @example Adding validation error
-     * ```typescript
-     * const ctx = createValidationContext(schema, validate)
-     * addError(ctx, 'Value must be a string', 42, 'type', { expected: 'string' })
-     * // ctx.errors[0].message === 'Value must be a string'
-     * // ctx.errors[0].code === 'type'
-     * ```
-     */
     function addError(ctx, message, instance, code, params) {
         ctx.errors.push({
             message,
@@ -3016,42 +1394,10 @@
             params,
         });
     }
-    /**
-     * Checks if we should continue validation after an error.
-     *
-     * @param ctx - Validation context
-     * @returns true if we should continue, false if we should stop
-     * @example Checking error collection mode
-     * ```typescript
-     * const ctx = createValidationContext(schema, validate, true) // collectAllErrors: true
-     * addError(ctx, 'First error', 'value', 'error')
-     * shouldContinue(ctx) // => true (keep collecting errors)
-     *
-     * const ctx2 = createValidationContext(schema, validate, false) // collectAllErrors: false
-     * addError(ctx2, 'First error', 'value', 'error')
-     * shouldContinue(ctx2) // => false (stop at first error)
-     * ```
-     */
     function shouldContinue(ctx) {
         return ctx.collectAllErrors || ctx.errors.length === 0;
     }
 
-    /**
-     * Performs deep equality check for JSON values.
-     *
-     * Used for enum validation and uniqueItems validation.
-     *
-     * @param a - First value to compare
-     * @param b - Second value to compare
-     * @returns true if values are deeply equal, false otherwise
-     * @example Comparing values for equality
-     * ```typescript
-     * isEqual({ name: 'Alice' }, { name: 'Alice' }) // => true
-     * isEqual([1, 2, 3], [1, 2, 3])                 // => true
-     * isEqual({ a: 1 }, { a: 2 })                   // => false
-     * isEqual([1, 2], [2, 1])                       // => false (order matters)
-     * ```
-     */
     function isEqual(a, b) {
         if (a === b)
             return true;
@@ -3086,21 +1432,6 @@
         return false;
     }
 
-    /**
-     * Validates array length and uniqueItems constraints.
-     *
-     * @param instance - Array being validated
-     * @param schema - Schema containing array bounds
-     * @param ctx - Validation context
-     * @returns true if validation passes, false otherwise
-     * @example Validating array constraints
-     * ```typescript
-     * const schema = { minItems: 2, maxItems: 5, uniqueItems: true }
-     * validateArrayBounds([1, 2, 3], schema, ctx) // => true
-     * validateArrayBounds([1], schema, ctx)       // => false (too few items)
-     * validateArrayBounds([1, 1, 2], schema, ctx) // => false (duplicates)
-     * ```
-     */
     function validateArrayBounds(instance, schema, ctx) {
         let valid = true;
         if (schema.minItems !== undefined && instance.length < schema.minItems) {
@@ -3136,23 +1467,6 @@
         return valid;
     }
 
-    /**
-     * Validates 'allOf' keyword - all schemas must match.
-     *
-     * @param instance - Value being validated
-     * @param schema - Schema containing the allOf constraint
-     * @param ctx - Validation context
-     * @returns true if validation passes, false otherwise
-     * @example Validating allOf composition
-     * ```typescript
-     *     { type: 'object', required: ['name'] },
-     *     { type: 'object', required: ['email'] }
-     *   ]
-     * }
-     * validateAllOf({ name: 'Alice', email: 'alice@example.com' }, schema, ctx) // => true
-     * validateAllOf({ name: 'Alice' }, schema, ctx) // => false (missing email)
-     * ```
-     */
     function validateAllOf(instance, schema, ctx) {
         const allOf = schema.allOf;
         if (!allOf || allOf.length === 0) {
@@ -3161,7 +1475,6 @@
         let valid = true;
         for (let i = 0; i < allOf.length; i++) {
             const subSchema = allOf[i];
-            /* istanbul ignore if -- defensive null check for sparse arrays */
             if (!subSchema)
                 continue;
             if (!ctx.validate(instance, subSchema, ctx)) {
@@ -3172,26 +1485,6 @@
         }
         return valid;
     }
-    /**
-     * Validates 'anyOf' keyword - at least one schema must match.
-     *
-     * @param instance - Value being validated
-     * @param schema - Schema containing the anyOf constraint
-     * @param ctx - Validation context
-     * @returns true if validation passes, false otherwise
-     * @example Validating anyOf composition
-     * ```typescript
-     * const schema = {
-     *   anyOf: [
-     *     { type: 'string' },
-     *     { type: 'number' }
-     *   ]
-     * }
-     * validateAnyOf('hello', schema, ctx) // => true
-     * validateAnyOf(42, schema, ctx)      // => true
-     * validateAnyOf(true, schema, ctx)    // => false (neither string nor number)
-     * ```
-     */
     function validateAnyOf(instance, schema, ctx) {
         const anyOf = schema.anyOf;
         if (!anyOf || anyOf.length === 0) {
@@ -3207,26 +1500,6 @@
         addError(ctx, 'Value does not match any of the allowed schemas (anyOf)', instance, 'anyOf');
         return false;
     }
-    /**
-     * Validates 'oneOf' keyword - exactly one schema must match.
-     *
-     * @param instance - Value being validated
-     * @param schema - Schema containing the oneOf constraint
-     * @param ctx - Validation context
-     * @returns true if validation passes, false otherwise
-     * @example Validating oneOf composition
-     * ```typescript
-     * const schema = {
-     *   oneOf: [
-     *     { type: 'integer' },
-     *     { minimum: 5 }
-     *   ]
-     * }
-     * validateOneOf(3, schema, ctx)    // => true (matches first only)
-     * validateOneOf(10, schema, ctx)   // => false (matches both)
-     * validateOneOf('hi', schema, ctx) // => false (matches neither)
-     * ```
-     */
     function validateOneOf(instance, schema, ctx) {
         const oneOf = schema.oneOf;
         if (!oneOf || oneOf.length === 0) {
@@ -3255,20 +1528,6 @@
         }
         return false;
     }
-    /**
-     * Validates 'not' keyword - schema must NOT match.
-     *
-     * @param instance - Value being validated
-     * @param schema - Schema containing the not constraint
-     * @param ctx - Validation context
-     * @returns true if validation passes, false otherwise
-     * @example Validating not constraint
-     * ```typescript
-     * const schema = { not: { type: 'string' } }
-     * validateNot(42, schema, ctx)      // => true (not a string)
-     * validateNot('hello', schema, ctx) // => false (is a string)
-     * ```
-     */
     function validateNot(instance, schema, ctx) {
         const not = schema.not;
         if (!not) {
@@ -3283,58 +1542,31 @@
         return true;
     }
 
-    /**
-     * Validates object 'dependencies' keyword.
-     *
-     * @param instance - Object being validated
-     * @param schema - Schema containing the dependencies constraint
-     * @param ctx - Validation context
-     * @returns true if validation passes, false otherwise
-     * @example Validating dependent properties
-     * ```typescript
-     * const schema = {
-     *   dependencies: {
-     *     creditCard: ['billingAddress'],  // if creditCard present, billingAddress required
-     *     name: { required: ['email'] }    // if name present, email required via schema
-     *   }
-     * }
-     * validateDependencies({ creditCard: '1234', billingAddress: '123 Main St' }, schema, ctx) // => true
-     * validateDependencies({ creditCard: '1234' }, schema, ctx) // => false (missing billingAddress)
-     * ```
-     */
     function validateDependencies(instance, schema, ctx) {
         if (!schema.dependencies) {
             return true;
         }
         let valid = true;
         for (const [key, dependency] of entries(schema.dependencies)) {
-            /* istanbul ignore next -- key presence check */
             if (!hasOwn(instance, key)) {
                 continue;
             }
-            /* istanbul ignore next -- dependency type check */
             if (isArray(dependency)) {
                 for (const requiredKey of dependency) {
-                    /* istanbul ignore next -- required key check */
                     if (!hasOwn(instance, requiredKey)) {
                         addError(ctx, `Property '${key}' requires property '${requiredKey}' to also be present`, instance, 'dependencies', {
                             property: key,
-                            /* istanbul ignore next -- required key assignment */
                             required: requiredKey,
                         });
                         valid = false;
-                        /* istanbul ignore if -- early exit tested in validate.spec.ts */
                         if (!shouldContinue(ctx))
                             return false;
                     }
                 }
             }
             else {
-                /* istanbul ignore next -- schema dependency validation */
                 if (!ctx.validate(instance, dependency, ctx)) {
-                    /* istanbul ignore next -- failure path */
                     valid = false;
-                    /* istanbul ignore if -- early exit tested in validate.spec.ts */
                     if (!shouldContinue(ctx))
                         return false;
                 }
@@ -3343,20 +1575,6 @@
         return valid;
     }
 
-    /**
-     * Validates enum constraint.
-     *
-     * @param instance - Value being validated
-     * @param schema - Schema containing the enum constraint
-     * @param ctx - Validation context
-     * @returns true if validation passes, false otherwise
-     * @example Validating enum values
-     * ```typescript
-     * const schema = { enum: ['draft', 'published', 'archived'] }
-     * validateEnum('published', schema, ctx) // => true
-     * validateEnum('deleted', schema, ctx)   // => false (not in enum)
-     * ```
-     */
     function validateEnum(instance, schema, ctx) {
         if (!schema.enum) {
             return true;
@@ -3373,77 +1591,24 @@
         return false;
     }
 
-    /**
-     * Safe RegExp factory for protected regex construction.
-     *
-     * @module @hyperfrontend/immutable-api-utils/built-in-copy/regexp
-     */
-    /* eslint-disable workspace/lib-require-jsdoc-example */
     const _RegExp = globalThis.RegExp;
-    const _Reflect$2 = globalThis.Reflect;
-    /**
-     * (Safe copy) Creates a new RegExp using the captured RegExp constructor.
-     * Use this instead of `new RegExp()`.
-     *
-     * @param pattern - The pattern string or RegExp to copy.
-     * @param flags - Optional flags string.
-     * @returns A new RegExp instance.
-     */
-    const createRegExp = (pattern, flags) => _Reflect$2.construct(_RegExp, [pattern, flags]);
-
-    /**
-     * Safe copies of URL built-ins via factory functions.
-     *
-     * Provides safe references to URL and URLSearchParams.
-     * These references are captured at module initialization time to protect against
-     * prototype pollution attacks. Import only what you need for tree-shaking.
-     *
-     * @module @hyperfrontend/immutable-api-utils/built-in-copy/url
-     */
+    const _Reflect$3 = globalThis.Reflect;
+    const createRegExp = (pattern, flags) => _Reflect$3.construct(_RegExp, [pattern, flags]);
+
     const _URL = globalThis.URL;
-    const _Reflect$1 = globalThis.Reflect;
-    /**
-     * (Safe copy) Creates a new URL using the captured URL constructor.
-     * Use this instead of `new URL()`.
-     *
-     * @param url - The URL string to parse.
-     * @param base - Optional base URL for relative URLs.
-     * @returns A new URL instance.
-     *
-     * @example Creating URL instances
-     * ```typescript
-     * const absolute = createURL('https://example.com/path?query=1')
-     * const relative = createURL('/api/users', 'https://example.com')
-     * // => URL { href: 'https://example.com/api/users' }
-     * ```
-     */
-    const createURL = (url, base) => _Reflect$1.construct(_URL, [url, base]);
-    /**
-     * (Safe copy) Creates an object URL for the given object.
-     * Use this instead of `URL.createObjectURL()`.
-     *
-     * Note: This is a browser-only API. In Node.js environments, this will throw.
-     */
+    const _Reflect$2 = globalThis.Reflect;
+    const createURL = (url, base) => _Reflect$2.construct(_URL, [url, base]);
     typeof _URL.createObjectURL === 'function'
         ? _URL.createObjectURL.bind(_URL)
         : () => {
             throw new Error('URL.createObjectURL is not available in this environment');
         };
-    /**
-     * (Safe copy) Revokes an object URL previously created with createObjectURL.
-     * Use this instead of `URL.revokeObjectURL()`.
-     *
-     * Note: This is a browser-only API. In Node.js environments, this will throw.
-     */
     typeof _URL.revokeObjectURL === 'function'
         ? _URL.revokeObjectURL.bind(_URL)
         : () => {
             throw new Error('URL.revokeObjectURL is not available in this environment');
         };
 
-    /**
-     * Format validators for common string formats.
-     */
     const formatValidators = {
         'date-time': (v) => {
             if (!/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}/.test(v))
@@ -3533,7 +1698,6 @@
             try {
                 createURL(v);
                 return true;
-                /* istanbul ignore next -- URL constructor always throws for invalid URI */
             }
             catch {
                 return false;
@@ -3542,11 +1706,9 @@
         'uri-reference': (v) => {
             try {
                 createURL(v, 'http://example.com');
-                /* istanbul ignore next -- success path just returns true */
                 return true;
             }
             catch {
-                /* istanbul ignore next -- URL constructor is very permissive with base URL */
                 return false;
             }
         },
@@ -3555,7 +1717,6 @@
         },
         regex: (v) => {
             try {
-                // eslint-disable-next-line workspace/no-unsafe-regex -- intentionally validating user-provided regex patterns
                 createRegExp(v);
                 return true;
             }
@@ -3573,21 +1734,6 @@
             return segments.every((seg) => validSegment.test(seg));
         },
     };
-    /**
-     * Validates string format constraint.
-     *
-     * @param instance - String being validated
-     * @param schema - Schema containing the format constraint
-     * @param ctx - Validation context
-     * @returns true if validation passes, false otherwise
-     * @example Validating string formats
-     * ```typescript
-     * validateFormat('user@example.com', { format: 'email' }, ctx) // => true
-     * validateFormat('invalid-email', { format: 'email' }, ctx)    // => false
-     * validateFormat('2024-01-15', { format: 'date' }, ctx)        // => true
-     * validateFormat('192.168.1.1', { format: 'ipv4' }, ctx)       // => true
-     * ```
-     */
     function validateFormat(instance, schema, ctx) {
         if (!schema.format) {
             return true;
@@ -3605,27 +1751,6 @@
         return true;
     }
 
-    /**
-     * Validates array 'items' keyword.
-     *
-     * @param instance - Array being validated
-     * @param schema - Schema containing the items constraint
-     * @param ctx - Validation context
-     * @returns true if validation passes, false otherwise
-     * @example Single schema for all items
-     * ```typescript
-     * const schema = { items: { type: 'string' } }
-     * validateItems(['a', 'b', 'c'], schema, ctx) // => true
-     * validateItems(['a', 1, 'c'], schema, ctx)   // => false (1 is not a string)
-     * ```
-     *
-     * @example Tuple validation
-     * ```typescript
-     * const schema = { items: [{ type: 'string' }, { type: 'number' }] }
-     * validateItems(['name', 42], schema, ctx)  // => true
-     * validateItems([42, 'name'], schema, ctx)  // => false (wrong types)
-     * ```
-     */
     function validateItems(instance, schema, ctx) {
         const items = schema.items;
         if (items === undefined) {
@@ -3635,13 +1760,11 @@
         if (isArray(items)) {
             for (let i = 0; i < items.length && i < instance.length; i++) {
                 const itemSchema = items[i];
-                /* istanbul ignore if -- defensive null check for sparse arrays */
                 if (!itemSchema)
                     continue;
                 const itemCtx = pushPath(ctx, i);
                 if (!ctx.validate(instance[i], itemSchema, itemCtx)) {
                     valid = false;
-                    /* istanbul ignore if -- early exit already tested in validate.spec.ts */
                     if (!shouldContinue(ctx))
                         return false;
                 }
@@ -3664,24 +1787,12 @@
         }
         return valid;
     }
-    /**
-     * Validates 'additionalItems' keyword for tuple arrays.
-     *
-     * @param instance - Array being validated
-     * @param schema - Schema containing the additionalItems constraint
-     * @param ctx - Validation context
-     * @param startIndex - Index from which to start checking additional items
-     * @returns true if validation passes, false otherwise
-     */
     function validateAdditionalItems(instance, schema, ctx, startIndex) {
         const additionalItems = schema.additionalItems;
-        /* istanbul ignore if -- default case handled in items.spec.ts */
         if (additionalItems === undefined) {
             return true;
         }
-        /* istanbul ignore next -- additionalItems initialization and branching */
         let valid = true;
-        /* istanbul ignore next -- additionalItems branching */
         if (additionalItems === false) {
             if (instance.length > startIndex) {
                 addError(ctx, `Array has too many items. Expected at most ${startIndex}, got ${instance.length}`, instance, 'additionalItems', {
@@ -3694,10 +1805,8 @@
         else if (typeof additionalItems === 'object') {
             for (let i = startIndex; i < instance.length; i++) {
                 const itemCtx = pushPath(ctx, i);
-                /* istanbul ignore else -- validation failure tested in items.spec.ts */
                 if (!ctx.validate(instance[i], additionalItems, itemCtx)) {
                     valid = false;
-                    /* istanbul ignore if -- early exit tested in validate.spec.ts */
                     if (!shouldContinue(ctx))
                         return false;
                 }
@@ -3706,22 +1815,6 @@
         return valid;
     }
 
-    /**
-     * Validates number range and multipleOf constraints.
-     *
-     * @param instance - Number being validated
-     * @param schema - Schema containing number constraints
-     * @param ctx - Validation context
-     * @returns true if validation passes, false otherwise
-     * @example Validating number constraints
-     * ```typescript
-     * const schema = { minimum: 0, maximum: 100, multipleOf: 5 }
-     * validateNumberBounds(50, schema, ctx)  // => true
-     * validateNumberBounds(-1, schema, ctx)  // => false (below minimum)
-     * validateNumberBounds(101, schema, ctx) // => false (above maximum)
-     * validateNumberBounds(17, schema, ctx)  // => false (not multiple of 5)
-     * ```
-     */
     function validateNumberBounds(instance, schema, ctx) {
         let valid = true;
         if (schema.minimum !== undefined) {
@@ -3768,21 +1861,6 @@
         return valid;
     }
 
-    /**
-     * Validates object bounds constraints (minProperties, maxProperties).
-     *
-     * @param instance - Object being validated
-     * @param schema - Schema containing object bounds
-     * @param ctx - Validation context
-     * @returns true if validation passes, false otherwise
-     * @example Validating object property counts
-     * ```typescript
-     * const schema = { minProperties: 1, maxProperties: 3 }
-     * validateObjectBounds({ a: 1, b: 2 }, schema, ctx) // => true
-     * validateObjectBounds({}, schema, ctx)            // => false (no properties)
-     * validateObjectBounds({ a: 1, b: 2, c: 3, d: 4 }, schema, ctx) // => false (too many)
-     * ```
-     */
     function validateObjectBounds(instance, schema, ctx) {
         let valid = true;
         const propertyCount = keys(instance).length;
@@ -3807,25 +1885,6 @@
         return valid;
     }
 
-    /**
-     * Validates object 'patternProperties' keyword.
-     *
-     * @param instance - Object being validated
-     * @param schema - Schema containing the patternProperties constraint
-     * @param ctx - Validation context
-     * @returns true if validation passes, false otherwise
-     * @example Validating pattern properties
-     * ```typescript
-     * const schema = {
-     *   patternProperties: {
-     *     '^x-': { type: 'string' },  // extension properties must be strings
-     *     '^\\d+$': { type: 'number' } // numeric keys must have number values
-     *   }
-     * }
-     * validatePatternProperties({ 'x-custom': 'value', '42': 100 }, schema, ctx) // => true
-     * validatePatternProperties({ 'x-custom': 123 }, schema, ctx) // => false (should be string)
-     * ```
-     */
     function validatePatternProperties(instance, schema, ctx) {
         if (!schema.patternProperties) {
             return true;
@@ -3833,7 +1892,6 @@
         let valid = true;
         const patterns = [];
         for (const [pattern, patternSchema] of entries(schema.patternProperties)) {
-            /* istanbul ignore if -- patternSafetyChecker branch tested in validate.spec.ts */
             if (ctx.patternSafetyChecker) {
                 const safetyResult = ctx.patternSafetyChecker(pattern);
                 if (!safetyResult.safe) {
@@ -3848,21 +1906,15 @@
                 }
             }
             try {
-                // eslint-disable-next-line workspace/no-unsafe-regex -- Pattern safety validated above when safePatterns enabled
                 patterns.push({ regex: createRegExp(pattern), schema: patternSchema });
             }
             catch (e) {
-                /* istanbul ignore next -- strictPatterns mode verified in validate.spec.ts */
                 if (ctx.strictPatterns) {
-                    /* istanbul ignore next -- error reporting for invalid regex */
                     addError(ctx, `Invalid regex pattern in patternProperties: ${pattern}`, instance, 'patternProperties', {
-                        /* istanbul ignore next -- error message extraction */
                         pattern,
-                        /* istanbul ignore next -- ternary expression */
                         error: e instanceof Error ? e.message : 'Invalid regex',
                     });
                     valid = false;
-                    /* istanbul ignore if -- early exit tested in validate.spec.ts */
                     if (!shouldContinue(ctx))
                         return false;
                 }
@@ -3883,25 +1935,6 @@
         return valid;
     }
 
-    /**
-     * Validates object 'properties' keyword.
-     *
-     * @param instance - Object being validated
-     * @param schema - Schema containing the properties constraint
-     * @param ctx - Validation context
-     * @returns true if validation passes, false otherwise
-     * @example Validating object properties
-     * ```typescript
-     * const schema = {
-     *   properties: {
-     *     name: { type: 'string' },
-     *     age: { type: 'integer' }
-     *   }
-     * }
-     * validateProperties({ name: 'Alice', age: 30 }, schema, ctx) // => true
-     * validateProperties({ name: 123 }, schema, ctx) // => false (name should be string)
-     * ```
-     */
     function validateProperties(instance, schema, ctx) {
         if (!schema.properties) {
             return true;
@@ -3919,20 +1952,6 @@
         }
         return valid;
     }
-    /**
-     * Validates object 'required' keyword.
-     *
-     * @param instance - Object being validated
-     * @param schema - Schema containing the required constraint
-     * @param ctx - Validation context
-     * @returns true if validation passes, false otherwise
-     * @example Validating required properties
-     * ```typescript
-     * const schema = { required: ['name', 'email'] }
-     * validateRequired({ name: 'Alice', email: 'alice@example.com' }, schema, ctx) // => true
-     * validateRequired({ name: 'Alice' }, schema, ctx) // => false (missing email)
-     * ```
-     */
     function validateRequired(instance, schema, ctx) {
         if (!schema.required) {
             return true;
@@ -3948,38 +1967,18 @@
         }
         return valid;
     }
-    /**
-     * Validates object 'additionalProperties' keyword.
-     *
-     * @param instance - Object being validated
-     * @param schema - Schema containing the additionalProperties constraint
-     * @param ctx - Validation context
-     * @returns true if validation passes, false otherwise
-     * @example Validating additional properties
-     * ```typescript
-     * const schema = {
-     *   properties: { name: { type: 'string' } },
-     *   additionalProperties: false
-     * }
-     * validateAdditionalProperties({ name: 'Alice' }, schema, ctx) // => true
-     * validateAdditionalProperties({ name: 'Alice', extra: 1 }, schema, ctx) // => false
-     * ```
-     */
     function validateAdditionalProperties(instance, schema, ctx) {
         const additionalProperties = schema.additionalProperties;
         if (additionalProperties === undefined) {
             return true;
         }
-        /* istanbul ignore next -- definedKeys initialization */
         const definedKeys = createSet();
-        /* istanbul ignore next -- schema.properties may not exist */
         if (schema.properties) {
             for (const key of keys(schema.properties)) {
                 definedKeys.add(key);
             }
         }
         const patterns = [];
-        /* istanbul ignore next -- patternProperties may not always be present */
         if (schema.patternProperties) {
             for (const pattern of keys(schema.patternProperties)) {
                 if (ctx.patternSafetyChecker) {
@@ -3989,12 +1988,9 @@
                     }
                 }
                 try {
-                    // eslint-disable-next-line workspace/no-unsafe-regex -- Pattern safety validated above when safePatterns enabled
                     patterns.push(createRegExp(pattern));
-                    /* istanbul ignore next -- invalid regex patterns handled in patternProperties validator */
                 }
                 catch {
-                    // Invalid regex, skip
                 }
             }
         }
@@ -4011,7 +2007,6 @@
                     property: key,
                 });
                 valid = false;
-                /* istanbul ignore if -- early exit tested in validate.spec.ts */
                 if (!shouldContinue(ctx))
                     return false;
             }
@@ -4019,7 +2014,6 @@
                 const propCtx = pushPath(ctx, key);
                 if (!ctx.validate(instance[key], additionalProperties, propCtx)) {
                     valid = false;
-                    /* istanbul ignore if -- early exit tested in validate.spec.ts */
                     if (!shouldContinue(ctx))
                         return false;
                 }
@@ -4028,21 +2022,6 @@
         return valid;
     }
 
-    /**
-     * Validates string length and pattern constraints.
-     *
-     * @param instance - String being validated
-     * @param schema - Schema containing string constraints
-     * @param ctx - Validation context
-     * @returns true if validation passes, false otherwise
-     * @example Validating string constraints
-     * ```typescript
-     * const schema = { minLength: 3, maxLength: 10, pattern: '^[a-z]+$' }
-     * validateStringBounds('hello', schema, ctx) // => true
-     * validateStringBounds('hi', schema, ctx)    // => false (too short)
-     * validateStringBounds('Hello', schema, ctx) // => false (contains uppercase)
-     * ```
-     */
     function validateStringBounds(instance, schema, ctx) {
         let valid = true;
         if (schema.minLength !== undefined && instance.length < schema.minLength) {
@@ -4078,7 +2057,6 @@
                 }
             }
             try {
-                // eslint-disable-next-line workspace/no-unsafe-regex -- Pattern safety validated above when safePatterns enabled
                 const regex = createRegExp(schema.pattern);
                 if (!regex.test(instance)) {
                     addError(ctx, `String does not match pattern: ${schema.pattern}`, instance, 'pattern', {
@@ -4090,16 +2068,12 @@
                 }
             }
             catch (e) {
-                /* istanbul ignore next -- strictPatterns mode verified in validate.spec.ts */
                 if (ctx.strictPatterns) {
-                    /* istanbul ignore next -- error reporting for invalid regex */
                     addError(ctx, `Invalid regex pattern: ${schema.pattern}`, instance, 'pattern', {
                         pattern: schema.pattern,
-                        /* istanbul ignore next -- error message extraction ternary */
                         error: e instanceof Error ? e.message : 'Invalid regex',
                     });
                     valid = false;
-                    /* istanbul ignore if -- early exit tested in validate.spec.ts */
                     if (!shouldContinue(ctx))
                         return false;
                 }
@@ -4108,9 +2082,6 @@
         return valid;
     }
 
-    /**
-     * Type checking functions for JSON Schema types.
-     */
     const typeCheckers = {
         string: (v) => typeof v === 'string',
         number: (v) => typeof v === 'number' && globalIsFinite(v),
@@ -4120,12 +2091,6 @@
         object: (v) => v !== null && typeof v === 'object' && !isArray(v),
         null: (v) => v === null,
     };
-    /**
-     * Gets the actual JSON type of a value for error messages.
-     *
-     * @param value - The value to get the type of
-     * @returns The JSON type as a string
-     */
     function getActualType(value) {
         if (value === null)
             return 'null';
@@ -4134,28 +2099,12 @@
         const t = typeof value;
         if (t === 'number') {
             const num = value;
-            /* istanbul ignore next -- NaN/Infinity edge case */
             if (!globalIsFinite(num))
                 return 'number';
             return isInteger(num) ? 'integer' : 'number';
         }
         return t;
     }
-    /**
-     * Validates the 'type' keyword.
-     *
-     * @param instance - Value being validated
-     * @param schema - Schema containing the type constraint
-     * @param ctx - Validation context
-     * @returns true if validation passes, false otherwise
-     * @example Validating type constraints
-     * ```typescript
-     * validateType('hello', { type: 'string' }, ctx)     // => true
-     * validateType(42, { type: 'integer' }, ctx)         // => true
-     * validateType('42', { type: 'integer' }, ctx)       // => false
-     * validateType(null, { type: ['string', 'null'] }, ctx) // => true (union type)
-     * ```
-     */
     function validateType(instance, schema, ctx) {
         const schemaType = schema.type;
         if (schemaType === undefined) {
@@ -4164,11 +2113,9 @@
         const types = isArray(schemaType) ? schemaType : [schemaType];
         for (const type of types) {
             const checker = typeCheckers[type];
-            /* istanbul ignore if -- defensive check for unknown type */
             if (checker && checker(instance)) {
                 return true;
             }
-            /* istanbul ignore if -- defensive fallback for integer/number coercion */
             if (type === 'number' && typeCheckers['integer']?.(instance)) {
                 return true;
             }
@@ -4182,24 +2129,6 @@
         return false;
     }
 
-    /**
-     * Resolves a $ref JSON Pointer to its target schema.
-     *
-     * @param ref - The $ref string (e.g., '#/definitions/Address')
-     * @param ctx - Validation context containing root schema and definitions
-     * @returns The resolved schema, or undefined if not found
-     * @example Resolving schema references
-     * ```typescript
-     * const rootSchema = {
-     *   definitions: {
-     *     Address: { type: 'object', properties: { street: { type: 'string' } } }
-     *   }
-     * }
-     * const ctx = createValidationContext(rootSchema, validate)
-     * resolveRef('#/definitions/Address', ctx)
-     * // => { type: 'object', properties: { street: { type: 'string' } } }
-     * ```
-     */
     function resolveRef(ref, ctx) {
         const cached = ctx.definitions.get(ref);
         if (cached) {
@@ -4234,21 +2163,6 @@
         return undefined;
     }
 
-    /**
-     * Validates a value against a JSON Schema.
-     *
-     * @param instance - The value to validate
-     * @param schema - The JSON Schema to validate against
-     * @param options - Validation options
-     * @returns Validation result with valid flag and any errors
-     *
-     * @example Basic validation
-     * ```typescript
-     * const schema = { type: 'string', minLength: 1 }
-     * const result = validate('hello', schema)
-     * console.log(result.valid) // true
-     * ```
-     */
     function validate(instance, schema, options) {
         let patternSafetyChecker;
         const ctx = createValidationContext(schema, validateSchema, true, false, patternSafetyChecker);
@@ -4258,25 +2172,9 @@
             errors: ctx.errors,
         };
     }
-    /**
-     * Internal recursive validation function.
-     *
-     * @param instance - Value being validated
-     * @param schema - Schema to validate against
-     * @param ctx - Validation context
-     * @returns true if validation passes, false otherwise
-     * @example Internal recursive validation
-     * ```typescript
-     * const schema = { type: 'object', properties: { count: { type: 'integer' } } }
-     * const ctx = createValidationContext(schema, validateSchema)
-     * validateSchema({ count: 5 }, schema, ctx) // => true
-     * validateSchema({ count: 'five' }, schema, ctx) // => false
-     * ```
-     */
     function validateSchema(instance, schema, ctx) {
         if (schema.$ref) {
             const resolved = resolveRef(schema.$ref, ctx);
-            /* istanbul ignore if -- $ref resolution failures are tested in resolve-ref.spec.ts */
             if (!resolved) {
                 return true;
             }
@@ -4333,35 +2231,26 @@
             }
             if (!validateRequired(obj, schema, ctx)) {
                 valid = false;
-                /* istanbul ignore if -- early exit tested elsewhere */
                 if (!shouldContinue(ctx))
                     return false;
             }
-            /* istanbul ignore next -- patternProperties validation */
             if (!validatePatternProperties(obj, schema, ctx)) {
                 valid = false;
-                /* istanbul ignore next -- early exit tested elsewhere */
                 if (!shouldContinue(ctx))
                     return false;
             }
-            /* istanbul ignore next -- additionalProperties validation */
             if (!validateAdditionalProperties(obj, schema, ctx)) {
                 valid = false;
-                /* istanbul ignore next -- early exit tested elsewhere */
                 if (!shouldContinue(ctx))
                     return false;
             }
-            /* istanbul ignore next -- objectBounds validation */
             if (!validateObjectBounds(obj, schema, ctx)) {
                 valid = false;
-                /* istanbul ignore next -- early exit tested elsewhere */
                 if (!shouldContinue(ctx))
                     return false;
             }
-            /* istanbul ignore next -- dependencies validation */
             if (!validateDependencies(obj, schema, ctx)) {
                 valid = false;
-                /* istanbul ignore next -- early exit tested elsewhere */
                 if (!shouldContinue(ctx))
                     return false;
             }
@@ -4389,51 +2278,10 @@
         return valid;
     }
 
-    /**
-     * Creates a reusable validator function from a JSON Schema.
-     *
-     * @param schema - JSON Schema to validate against
-     * @param options - Validation options
-     * @returns A function that validates data against the schema
-     *
-     * @example Creating reusable validator
-     * ```typescript
-     * const schema = {
-     *   type: 'object',
-     *   properties: {
-     *     name: { type: 'string' },
-     *     age: { type: 'integer', minimum: 0 }
-     *   },
-     *   required: ['name']
-     * }
-     *
-     * const validateUser = createValidator(schema)
-     * const result = validateUser({ name: 'Alice', age: 30 })
-     * console.log(result.valid) // true
-     * ```
-     */
     function createValidator$1(schema, options) {
         return (data) => validate(data, schema);
     }
 
-    /**
-     * Creates a validator function from a JSON schema.
-     * Returns a function that validates data against the schema.
-     *
-     * @param schema - JSON Schema to validate against
-     * @returns Validator function that returns validation results
-     *
-     * @example Creating a schema validator
-     * ```typescript
-     * const validateUser = createValidator({
-     *   type: 'object',
-     *   properties: { name: { type: 'string' } },
-     *   required: ['name']
-     * })
-     * const result = validateUser({ name: 'Alice' })
-     * // => { valid: true, errors: [] }
-     * ```
-     */
     function createValidator(schema) {
         const validator = createValidator$1(schema);
         return (data) => {
@@ -4449,47 +2297,19 @@
         };
     }
 
-    /* istanbul ignore next -- validator initialization happens at module load */
     const validateMessageData = createValidator(messageSchema);
-    /**
-     * Validates a user message against the message schema.
-     *
-     * @param message - The message to validate
-     * @returns Validation result with any errors
-     */
     function validateMessage(message) {
         return validateMessageData(message);
     }
 
-    /**
-     * Handles NEW_MESSAGE action.
-     * Routes messages to appropriate channel.
-     *
-     * @param context - Routing context with state, registry, actions, and logger
-     * @param message - Message event containing the NEW_MESSAGE action
-     *
-     * @remarks
-     * Side Effects:
-     * - Validates message type against contract
-     * - Invokes channel message handlers if validation passes
-     * - Logs and ignores invalid messages
-     *
-     * @example Routing user messages
-     * User message flow:
-     * channel.send('USER_LOGIN', {userId: 123})
-     * -> NEW_MESSAGE action sent
-     * -> Received by remote broker (this handler)
-     * -> Routed to channel's onMessage handlers
-     */
     function handleMessage(context, message) {
         const { state, registry, logger } = context;
         const action = message.data;
-        const senderId = action.senderId;
         if (!isActionWithData(action)) {
             return;
         }
         const messageData = action.data;
-        const channel = getById(registry, senderId);
+        const channel = resolveChannel(registry, message);
         if (!channel || !channel.isActive()) {
             return;
         }
@@ -4498,29 +2318,13 @@
             logger.info(`${state.name} ignored message from ${channel.getName()}`);
             return;
         }
+        if (!channel.getAcceptedTypes().includes(messageData.type)) {
+            logger.info(`${state.name} dropped message type '${messageData.type}' not accepted by the ${channel.getName()} channel contract`);
+            return;
+        }
         channel.notifyMessage(messageData);
     }
 
-    /**
-     * Handles OPEN_CONNECTION action.
-     * Completes handshake on responder's side and notifies open event.
-     *
-     * @param context - Routing context with state, registry, actions, and logger
-     * @param message - Message event containing the OPEN_CONNECTION action
-     *
-     * @remarks
-     * Side Effects:
-     * - Terminates the connection process
-     * - Extracts security confirmation (if present)
-     * - Marks security as ready if security is active
-     * - Fires 'open' lifecycle event on responder's side
-     * - Fires 'security-ready' event if security transport is active
-     *
-     * @example Completing the three-way handshake
-     * Final step of three-way handshake:
-     * Responder receives OPEN (this handler) from Initiator
-     * Both sides now have active connection
-     */
     function handleOpen(context, message) {
         const { state, processManager, logger } = context;
         const action = message.data;
@@ -4548,33 +2352,6 @@
         channel.notifyEvent('open', { origin: message.origin });
     }
 
-    /**
-     * Protocol negotiation logic for security handshake.
-     *
-     * Implements the negotiation algorithm that determines the best
-     * security protocol to use between two communicating parties.
-     *
-     * @module security/negotiation/negotiate
-     */
-    /**
-     * Negotiates the best security protocol between initiator and responder.
-     *
-     * The algorithm iterates through the initiator's supported protocols
-     * (in preference order) and selects the first one that the responder
-     * also supports. If no overlap is found, falls back to 'none'.
-     *
-     * @param request - The initiator's security negotiation request
-     * @param responderSupported - Protocols supported by the responder
-     * @returns The negotiation result with the selected protocol
-     *
-     * @example Negotiating security protocol
-     * ```typescript
-     * const request = { supported: ['v2', 'v1', 'none'], preferred: 'v2' }
-     * const responderSupported = ['v1', 'none']
-     * const result = negotiateProtocol(request, responderSupported)
-     * // result.negotiated === 'v1' (first match from initiator's list)
-     * ```
-     */
     function negotiateProtocol(request, responderSupported) {
         for (const protocol of request.supported) {
             if (responderSupported.includes(protocol)) {
@@ -4589,55 +2366,12 @@
             isPreferred: request.preferred === 'none',
         };
     }
-    /**
-     * Creates a security negotiation response for the responder.
-     *
-     * Builds a response object containing the negotiated protocol
-     * and optional public parameters for protocol initialization.
-     *
-     * @param negotiated - The negotiated protocol version
-     * @param publicParams - Optional public parameters (e.g., key exchange hints)
-     * @returns A security negotiation response object
-     *
-     * @example Creating responder response
-     * ```typescript
-     * const response = createSecurityResponse('v2', { hint: 'value' })
-     * // { negotiated: 'v2', publicParams: { hint: 'value' } }
-     * ```
-     */
     function createSecurityResponse(negotiated, publicParams) {
         const response = { negotiated };
         return freeze(response);
     }
 
-    /**
-     * Default supported security protocols for the responder.
-     * Includes 'none' as fallback for backward compatibility.
-     */
     const DEFAULT_RESPONDER_SUPPORTED = ['none'];
-    /**
-     * Handles REQUEST_CONNECTION action.
-     * Creates or retrieves channel and initiates connection handshake.
-     *
-     * @param context - Routing context with state, registry, actions, and logger
-     * @param message - Message event containing the REQUEST_CONNECTION action
-     *
-     * @remarks
-     * Side Effects:
-     * - Creates new channel if not found in registry
-     * - Tracks process ID for handshake completion
-     * - Negotiates security protocol if security data present
-     * - Sends ACCEPT_CONNECTION if validation passes
-     * - Sends DENY_CONNECTION if contract or security policy fails
-     *
-     * @example Processing connection requests
-     * Incoming action triggers:
-     * 1. Channel lookup/creation
-     * 2. Contract validation
-     * 3. Security policy check
-     * 4. Security protocol negotiation (if applicable)
-     * 5. ACCEPT_CONNECTION response (or DENY if validation fails)
-     */
     function handleRequest(context, message) {
         const { state, registry, processManager, actions, logger } = context;
         const action = message.data;
@@ -4722,22 +2456,6 @@
         });
     }
 
-    /**
-     * Security error handling utilities.
-     *
-     * Provides functions for handling, categorizing, and emitting security-related
-     * errors during message encryption/decryption operations.
-     *
-     * @module security/errors
-     */
-    /**
-     * Security error class with additional metadata for programmatic handling.
-     *
-     * @example Creating security error
-     * ```typescript
-     * throw new SecurityError('Decryption failed', 'decryption_failed', originalError)
-     * ```
-     */
     class SecurityError extends Error {
         code;
         originalCause;
@@ -4749,25 +2467,6 @@
             setPrototypeOf(this, SecurityError.prototype);
         }
     }
-    /**
-     * Creates security error event data from an error.
-     *
-     * Converts various error types into a standardized SecurityErrorEventData
-     * structure for emitting via channel events.
-     *
-     * @param error - The error to convert
-     * @returns Standardized security error event data
-     *
-     * @example Converting errors to event data
-     * ```typescript
-     * try {
-     *   decrypt(payload)
-     * } catch (error) {
-     *   const eventData = createSecurityErrorEventData(error)
-     *   channel.notifyEvent('security-error', eventData)
-     * }
-     * ```
-     */
     function createSecurityErrorEventData(error) {
         if (error instanceof SecurityError) {
             return {
@@ -4789,17 +2488,6 @@
             code: 'unknown',
         };
     }
-    /**
-     * Categorizes an error into a security error code.
-     *
-     * Analyzes the error message to determine the appropriate category.
-     * This is used when errors from network-protocol are caught.
-     *
-     * @param error - The error to categorize
-     * @returns The appropriate security error code
-     *
-     * @internal
-     */
     function categorizeError(error) {
         const message = error.message.toLowerCase();
         if (message.includes('decrypt') || message.includes('invalid key') || message.includes('corrupted') || message.includes('cipher')) {
@@ -4816,21 +2504,6 @@
         }
         return 'unknown';
     }
-    /**
-     * Logs a security error with appropriate formatting.
-     *
-     * Uses logger.error for actual errors and logger.warn for
-     * retryable/expected failures.
-     *
-     * @param logger - Logger instance to use for output
-     * @param channelName - Name of the channel where error occurred
-     * @param error - The security error event data containing message, code, and optional cause
-     *
-     * @example Logging security errors
-     * ```typescript
-     * logSecurityError(logger, 'my-channel', errorData)
-     * ```
-     */
     function logSecurityError(logger, channelName, error) {
         const prefix = `${channelName} security error:`;
         if (error.code === 'unknown') {
@@ -4841,37 +2514,6 @@
         }
     }
 
-    /**
-     * Route encrypted messages through security transport.
-     *
-     * Handles Uint8Array payloads received via postMessage, routing them
-     * through the appropriate channel's security transport for decryption.
-     *
-     * @module broker/routing/route-encrypted-message
-     */
-    /**
-     * Routes an encrypted message to the appropriate channel for decryption.
-     *
-     * This function handles Uint8Array payloads received via postMessage:
-     * 1. Identifies the target channel based on message origin
-     * 2. Routes the encrypted payload through the channel's security transport
-     * 3. The security transport decrypts and invokes the registered receive handler
-     *
-     * If no matching channel is found or the channel has no security transport,
-     * the message is silently dropped (with optional debug logging).
-     *
-     * @param context - Routing context with state, registry, actions, and logger
-     * @param router - Message router for handling decrypted actions
-     * @param event - Message event containing the encrypted Uint8Array payload
-     *
-     * @example Routing encrypted payloads
-     * ```typescript
-     * // In broker's onMessage handler:
-     * if (event.data instanceof Uint8Array) {
-     *   routeEncryptedMessage(routingContext, router, event)
-     * }
-     * ```
-     */
     function routeEncryptedMessage(context, router, event) {
         const { state, registry, logger } = context;
         const origin = event?.origin;
@@ -4908,19 +2550,6 @@
             channel.notifyEvent('security-error', errorData);
         }
     }
-    /**
-     * Finds a channel by origin in the registry.
-     *
-     * Since encrypted messages don't contain senderId, we must match
-     * by origin. This works because each channel has a unique target window
-     * and thus a unique origin.
-     *
-     * @param registry - Channel registry to search
-     * @param origin - Origin of the message sender
-     * @returns The matching channel handle, or undefined if not found
-     *
-     * @internal
-     */
     function findChannelByOrigin(registry, origin) {
         const allChannels = getAll(registry);
         for (const channel of allChannels) {
@@ -4939,30 +2568,10 @@
         return undefined;
     }
 
-    /**
-     * Logs an action in a structured format.
-     *
-     * @param logger - Logger instance
-     * @param action - Action to log
-     * @param direction - Direction of action ('sent' or 'received')
-     */
     function logAction(logger, action, direction) {
         logger.debug(`Action ${direction}:`, action.type, action);
     }
 
-    /**
-     * Routes a message to the appropriate handler.
-     *
-     * @param router - Handler map containing action type to handler mappings
-     * @param context - Routing context with state, registry, actions, and logger
-     * @param message - Incoming message event containing the action to route
-     *
-     * @example Routing actions to handlers
-     * ```typescript
-     * const router = createRouter({ 'MESSAGE': handleMessage })
-     * routeMessage(router, routingContext, incomingEvent)
-     * ```
-     */
     function routeMessage(router, context, message) {
         const { logger } = context;
         try {
@@ -4985,26 +2594,6 @@
         }
     }
 
-    /**
-     * Filters message origin against whitelist/blacklist
-     *
-     * @param origin - The origin to check
-     * @param whitelist - List of allowed origins (takes precedence)
-     * @param blacklist - List of blocked origins
-     * @returns true if origin is allowed, false otherwise
-     *
-     * @example Filtering with a whitelist
-     * ```typescript
-     * filterOrigin('https://app.example.com', ['https://app.example.com'])
-     * // => true
-     * ```
-     *
-     * @example Filtering with a blacklist
-     * ```typescript
-     * filterOrigin('https://untrusted.com', [], ['https://untrusted.com'])
-     * // => false
-     * ```
-     */
     function filterOrigin(origin, whitelist = [], blacklist = []) {
         if (whitelist && whitelist.length > 0) {
             return whitelist.includes(origin);
@@ -5015,53 +2604,21 @@
         return true;
     }
 
-    /**
-     * Validates that a security policy is a function
-     *
-     * @param policy - The policy to validate
-     * @throws {Error} If policy is not a function
-     *
-     * @example Valid policy function
-     * ```typescript
-     * validatePolicy((event) => event.origin === 'https://trusted.com')
-     * // No error thrown
-     * ```
-     *
-     * @example Invalid policy throws
-     * ```typescript
-     * validatePolicy('not-a-function')
-     * // Throws: Security policy must be a function...
-     * ```
-     */
     function validatePolicy(policy) {
         if (typeof policy !== 'function') {
             throw createError('Security policy must be a function that returns true or false.');
         }
     }
 
-    /**
-     * Creates a message broker instance
-     *
-     * @param config - Broker configuration
-     * @param config.name - Unique name for the broker instance
-     * @param config.contract - Channel contract defining message protocols
-     * @param config.settings - Optional configuration overrides for broker behavior
-     * @returns Broker handle with public API
-     *
-     * @example Creating a message broker
-     * ```typescript
-     * const broker = createBroker({
-     *   name: 'app-broker',
-     *   contract: { messages: { ping: {}, pong: {} } },
-     *   settings: { logLevel: 'warn' },
-     * })
-     * ```
-     */
     function createBroker(config) {
         assertNoCircularRef(config.contract, 'config.contract');
         assertNoCircularRef(config.settings, 'config.settings');
         validateName(config.name);
         validateContract$1(config.contract);
+        const brokerWindow = config.window ?? (typeof window !== 'undefined' ? window : undefined);
+        if (!brokerWindow) {
+            throw createError('Cannot create broker: no window is available. Pass an explicit `window` in the broker config when running outside a browser environment.');
+        }
         const mergedSettings = {
             ...defaultBrokerSettings,
             ...config.settings,
@@ -5075,7 +2632,7 @@
         const state = {
             id: uuidV4(),
             name: config.name,
-            window: window,
+            window: brokerWindow,
             contract: config.contract,
             settings: mergedSettings,
             logger,
@@ -5128,10 +2685,7 @@
             }
             routeMessage(router, routingContext, event);
         };
-        /* istanbul ignore next -- environment detection for non-browser contexts */
-        if (typeof window !== 'undefined') {
-            window.addEventListener('message', onMessage);
-        }
+        brokerWindow.addEventListener('message', onMessage);
         const broker = {
             id: state.id,
             name: state.name,
@@ -5200,10 +2754,6 @@
         return freeze(broker);
     }
 
-    /**
-     * Default contract allowing any message type.
-     * Useful for development and prototyping.
-     */
     const DEFAULT_CONTRACT = freeze({
         emitted: freeze([
             { type: 'MESSAGE', description: 'Generic message' },
@@ -5217,49 +2767,36 @@
             { type: 'ACK', description: 'Acknowledgment' },
         ]),
     });
-    /**
-     * Singleton broker instance with sensible defaults.
-     *
-     * Features:
-     * - Generic contract accepting MESSAGE, DATA, EVENT action types
-     * - No security restrictions (whitelist/blacklist)
-     * - Debug mode off by default
-     *
-     * @example
-     * ```typescript
-     * import { broker } from '@hyperfrontend/nexus'
-     *
-     * // Create a channel
-     * const channel = broker.addChannel('my-channel', targetWindow)
-     * channel.connect()
-     * channel.send('MESSAGE', { hello: 'world' })
-     * ```
-     */
-    createBroker({
-        name: 'default-broker',
-        contract: DEFAULT_CONTRACT,
+
+    const _Reflect$1 = globalThis.Reflect;
+    const get = _Reflect$1.get;
+    const has = _Reflect$1.has;
+    const ownKeys = _Reflect$1.ownKeys;
+    const getOwnPropertyDescriptor = _Reflect$1.getOwnPropertyDescriptor;
+
+    let instance = null;
+    function resolveBroker() {
+        if (!instance) {
+            instance = createBroker({
+                name: 'default-broker',
+                contract: DEFAULT_CONTRACT,
+            });
+        }
+        return instance;
+    }
+    new Proxy({}, {
+        get: (_target, property) => get(resolveBroker(), property),
+        has: (_target, property) => has(resolveBroker(), property),
+        ownKeys: () => ownKeys(resolveBroker()),
+        getOwnPropertyDescriptor: (_target, property) => {
+            const descriptor = getOwnPropertyDescriptor(resolveBroker(), property);
+            return descriptor ? { ...descriptor, configurable: true } : undefined;
+        },
     });
 
-    // note: Runtime validation shared by the host/hostee factories and the config loader.
-    /**
-     * Narrows an unknown value to a non-null object.
-     *
-     * @param value - The value to test.
-     * @returns `true` when the value is a non-null, non-array object.
-     */
     function isRecord(value) {
         return typeof value === 'object' && value !== null && !isArray(value);
     }
-    /**
-     * Collects every problem with a single action list (`emitted` or `accepted`).
-     *
-     * Each malformed entry contributes its own message, distinguishing a non-object
-     * entry from one missing a usable `type`, so the caller can report them all at once.
-     *
-     * @param actions - The candidate action list.
-     * @param field - The field name, used to locate problems in messages.
-     * @param issues - The running list of human-readable problems, appended to in place.
-     */
     function collectActionListIssues(actions, field, issues) {
         if (!isArray(actions)) {
             issues.push(`"${field}" must be an array.`);
@@ -5273,14 +2810,21 @@
             if (typeof action['type'] !== 'string' || action['type'].length === 0) {
                 issues.push(`"${field}[${index}]" must have a non-empty string "type".`);
             }
+            if (action['respondsWith'] !== undefined && (typeof action['respondsWith'] !== 'string' || action['respondsWith'].length === 0)) {
+                issues.push(`"${field}[${index}]" has a "respondsWith" that must be a non-empty string.`);
+            }
+        });
+    }
+    function collectRespondsWithIssues(actions, field, other, otherField, issues) {
+        actions.forEach((action, index) => {
+            if (action.respondsWith === undefined) {
+                return;
+            }
+            if (!other.some((candidate) => candidate.type === action.respondsWith)) {
+                issues.push(`"${field}[${index}]" responds with "${action.respondsWith}", but "${otherField}" has no action of that type.`);
+            }
         });
     }
-    /**
-     * Names the kind of an unexpected value for an error message.
-     *
-     * @param value - The value to describe.
-     * @returns A short label such as `null`, `an array`, or `a number`.
-     */
     function describeType(value) {
         if (value === null) {
             return 'null';
@@ -5290,22 +2834,6 @@
         }
         return `a ${typeof value}`;
     }
-    /**
-     * Validates an unknown value as a {@link FeatureContract}.
-     *
-     * Reports every malformed action at once rather than stopping at the first, so a
-     * single error message lists all the problems to fix.
-     *
-     * @param contract - The candidate contract, typically parsed from disk.
-     * @returns The validated contract, typed.
-     * @throws {Error} When the value is not an object, or any action is malformed.
-     *
-     * @example Validating a parsed contract file
-     * ```typescript
-     * const contract = validateContract(parse(readFileSync('clock.contract.json', 'utf8')))
-     * contract.emitted.forEach((action) => console.log(action.type))
-     * ```
-     */
     function validateContract(contract) {
         if (!isRecord(contract)) {
             throw createError(`Invalid contract: expected an object with "emitted" and "accepted" arrays, but got ${describeType(contract)}.`);
@@ -5313,6 +2841,12 @@
         const issues = [];
         collectActionListIssues(contract['emitted'], 'emitted', issues);
         collectActionListIssues(contract['accepted'], 'accepted', issues);
+        if (issues.length === 0) {
+            const emitted = contract['emitted'];
+            const accepted = contract['accepted'];
+            collectRespondsWithIssues(emitted, 'emitted', accepted, 'accepted', issues);
+            collectRespondsWithIssues(accepted, 'accepted', emitted, 'emitted', issues);
+        }
         if (issues.length > 0) {
             throw createError(`Invalid contract:\n${issues.map((issue) => `  - ${issue}`).join('\n')}`);
         }
@@ -5322,47 +2856,29 @@
         };
     }
 
-    /**
-     * Internal control message types carried on the feature channel and hidden from consumers.
-     */
+    const CONTROL_PREFIX = '__hf:';
     const ControlType = freeze({
-        /** Hostee-to-host liveness beat. */
         Beat: '__hf:beat',
-        /** Hostee-to-host content-size announcement. */
         Size: '__hf:size',
+        Request: '__hf:request',
+        Response: '__hf:response',
     });
-    /**
-     * Extends a feature contract so the channel may also send and receive control traffic.
-     *
-     * @param contract - The consumer-facing feature contract.
-     * @returns A contract that additionally permits the reserved control types.
-     *
-     * @example Building a broker contract that carries the control plane
-     * ```typescript
-     * const broker = createBroker({ name, contract: withControlContract(contract) })
-     * ```
-     */
+    function isControlType(type) {
+        return type.startsWith(CONTROL_PREFIX);
+    }
     function withControlContract(contract) {
-        // note: Fresh action literals per direction — sharing references across emitted/accepted trips nexus's circular-reference guard, which flags any repeated object.
+        const controlActions = () => [
+            { type: ControlType.Beat },
+            { type: ControlType.Size },
+            { type: ControlType.Request },
+            { type: ControlType.Response },
+        ];
         return {
-            emitted: [...contract.emitted, { type: ControlType.Beat }, { type: ControlType.Size }],
-            accepted: [...contract.accepted, { type: ControlType.Beat }, { type: ControlType.Size }],
+            emitted: [...contract.emitted, ...controlActions()],
+            accepted: [...contract.accepted, ...controlActions()],
         };
     }
 
-    /**
-     * Creates an {@link EventEmitter} backed by a plain registry.
-     *
-     * @returns A frozen emitter instance.
-     *
-     * @example Subscribing and emitting
-     * ```typescript
-     * const emitter = createEventEmitter()
-     * const off = emitter.on('open', () => console.log('opened'))
-     * emitter.emit('open')
-     * off()
-     * ```
-     */
     function createEventEmitter() {
         const registry = {};
         const on = (event, handler) => {
@@ -5378,111 +2894,111 @@
         return freeze({ on, emit });
     }
 
-    /**
-     * Safe Promise factory and bound static methods.
-     *
-     * @module @hyperfrontend/immutable-api-utils/built-in-copy/promise
-     */
-    /* eslint-disable workspace/lib-require-jsdoc-example */
     const _Promise = globalThis.Promise;
     const _Reflect = globalThis.Reflect;
-    /**
-     * (Safe copy) Creates a new Promise using the captured Promise constructor.
-     * Use this instead of `new Promise()`.
-     *
-     * @param executor - The executor function.
-     * @returns A new Promise instance.
-     */
     const createPromise = (executor) => _Reflect.construct(_Promise, [executor]);
-    /**
-     * (Safe copy) Returns a Promise that resolves with the given value.
-     */
-    _Promise.resolve.bind(_Promise);
-    /**
-     * (Safe copy) Returns a Promise that rejects with the given reason.
-     */
-    _Promise.reject.bind(_Promise);
-    /**
-     * (Safe copy) Returns a Promise that resolves when all promises resolve.
-     */
+    const promiseResolve = _Promise.resolve.bind(_Promise);
+    const promiseReject = _Promise.reject.bind(_Promise);
     _Promise.all.bind(_Promise);
-    /**
-     * (Safe copy) Returns a Promise that resolves/rejects with the first settled promise.
-     */
     _Promise.race.bind(_Promise);
-    /**
-     * (Safe copy) Returns a Promise that resolves when all promises settle.
-     */
     _Promise.allSettled.bind(_Promise);
-    /**
-     * (Safe copy) Returns a Promise that resolves with the first fulfilled promise.
-     */
     _Promise.any.bind(_Promise);
-    /**
-     * (Safe copy) Creates a Promise along with its resolve and reject functions.
-     * Note: Available only in ES2024+ environments.
-     */
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     _Promise.withResolvers?.bind(_Promise);
 
-    /**
-     * Safe copies of Timer/Scheduling built-in functions.
-     *
-     * These references are captured at module initialization time to protect against
-     * prototype pollution attacks. Import only what you need for tree-shaking.
-     *
-     * @module @hyperfrontend/immutable-api-utils/built-in-copy/timers
-     */
+    const _setTimeout = globalThis.setTimeout;
     const _setInterval = globalThis.setInterval;
+    const _clearTimeout = globalThis.clearTimeout;
     const _clearInterval = globalThis.clearInterval;
-    /**
-     * (Safe copy) Repeatedly calls a function with a fixed time delay between each call.
-     *
-     * @param callback - Function to call at each interval.
-     * @param delay - Time in milliseconds between calls.
-     * @param args - Additional arguments to pass to the callback.
-     * @returns A numeric ID for the interval.
-     *
-     * @example Setting an interval
-     * ```typescript
-     * let count = 0
-     * const intervalId = setInterval(() => {
-     *   count++
-     *   if (count >= 5) clearInterval(intervalId)
-     * }, 1000)
-     * ```
-     */
+    const setTimeout = (callback, delay, ...args) => _setTimeout(callback, delay, ...args);
     const setInterval = (callback, delay, ...args) => _setInterval(callback, delay, ...args);
-    /**
-     * (Safe copy) Cancels a timed, repeating action previously established by setInterval.
-     *
-     * @param id - The identifier of the interval to cancel.
-     *
-     * @example Canceling an interval
-     * ```typescript
-     * const intervalId = setInterval(() => console.log('tick'), 1000)
-     * // Stop after some condition
-     * clearInterval(intervalId)
-     * ```
-     */
+    const clearTimeout = (id) => {
+        _clearTimeout(id);
+    };
     const clearInterval = (id) => {
         _clearInterval(id);
     };
 
-    // note: Baked-in liveness — the feature emits a beat on a fixed cadence with no consumer involvement, and the host monitors these to detect a hung or crashed feature.
+    const DEFAULT_TIMEOUT_MS = 30000;
+    function createRequestPeer(origin, send) {
+        let pending = {};
+        const handlers = {};
+        let nextCorrelation = 0;
+        const take = (correlationId) => {
+            const entry = pending[correlationId];
+            if (entry) {
+                clearTimeout(entry.timer);
+                delete pending[correlationId];
+            }
+            return entry;
+        };
+        const respond = (request, outcome) => send(ControlType.Response, { correlationId: request.correlationId, from: origin, innerType: request.innerType, ...outcome });
+        const answer = (request) => {
+            const handler = handlers[request.innerType];
+            if (!handler) {
+                respond(request, { ok: false, error: `No handler is registered for '${request.innerType}'.` });
+                return;
+            }
+            promiseResolve()
+                .then(() => handler(request.payload))
+                .then((payload) => respond(request, { ok: true, payload }), (error) => respond(request, { ok: false, error: error instanceof Error ? error.message : `${error}` }));
+        };
+        const settle = (response) => {
+            const entry = take(response.correlationId);
+            if (!entry) {
+                return;
+            }
+            if (response.ok) {
+                entry.resolve(response.payload);
+                return;
+            }
+            entry.reject(createError(response.error ?? `Request '${response.innerType}' failed.`));
+        };
+        const dispatch = (type, data) => {
+            const envelope = (typeof data === 'object' ? data : null);
+            if (!envelope || envelope.from === origin) {
+                return;
+            }
+            if (type === ControlType.Request) {
+                answer(envelope);
+                return;
+            }
+            if (type === ControlType.Response) {
+                settle(envelope);
+            }
+        };
+        const request = (type, data, options) => createPromise((resolve, reject) => {
+            const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+            const correlationId = `${origin}-${(nextCorrelation += 1)}`;
+            const timer = setTimeout(() => {
+                delete pending[correlationId];
+                reject(createError(`Request '${type}' timed out after ${timeoutMs}ms.`));
+            }, timeoutMs);
+            pending[correlationId] = { resolve, reject, timer };
+            send(ControlType.Request, { correlationId, from: origin, innerType: type, payload: data });
+        });
+        const handle = (type, handler) => {
+            if (handlers[type]) {
+                throw createError(`A handler for '${type}' is already registered.`);
+            }
+            handlers[type] = handler;
+            return () => {
+                if (handlers[type] === handler) {
+                    delete handlers[type];
+                }
+            };
+        };
+        const rejectAll = (reason) => {
+            const failed = values(pending);
+            pending = {};
+            for (const entry of failed) {
+                clearTimeout(entry.timer);
+                entry.reject(createError(reason));
+            }
+        };
+        return freeze({ request, handle, dispatch, rejectAll });
+    }
+
     const BEAT_INTERVAL_MS = 1000;
-    /**
-     * Creates the hostee-side heartbeat emitter.
-     *
-     * @param send - The control-channel send function (receives the reserved beat type).
-     * @returns A start/stop handle for the beat loop.
-     *
-     * @example Pulsing the host while connected
-     * ```typescript
-     * const heartbeat = createHeartbeatEmitter((type) => channel.send(type))
-     * heartbeat.start()
-     * ```
-     */
     function createHeartbeatEmitter(send) {
         let timer;
         return {
@@ -5499,24 +3015,6 @@
         };
     }
 
-    /**
-     * Observes an element for size changes and triggers a callback when resized.
-     *
-     * @param element - The element to observe for resize events
-     * @param callback - The function to call when the element is resized
-     * @returns A cleanup function to stop observing the element
-     *
-     * @example Observing element resize
-     * ```typescript
-     * const container = document.getElementById('resizable-panel')
-     * const stopObserving = onElementResize(container, (rect) => {
-     *   console.log(`New size: ${rect.width}x${rect.height}`)
-     * })
-     *
-     * // Stop observing when done
-     * stopObserving()
-     * ```
-     */
     function onElementResize(element, callback) {
         const resizeObserver = new ResizeObserver((entries) => {
             for (const entry of entries) {
@@ -5533,25 +3031,6 @@
         };
     }
 
-    /**
-     * Converts a CSS object into a CSS string suitable for inline styles or style sheets.
-     * Automatically converts camelCase properties to kebab-case.
-     *
-     * @param cssObj - The CSS object with property-value pairs
-     * @returns A CSS string representation
-     *
-     * @example Converting style object to CSS
-     * ```typescript
-     * const styles = {
-     *   backgroundColor: '#f0f0f0',
-     *   fontSize: '14px',
-     *   marginTop: '8px'
-     * }
-     *
-     * cssObjectToString(styles)
-     * // => 'background-color: #f0f0f0; font-size: 14px; margin-top: 8px; '
-     * ```
-     */
     function cssObjectToString(cssObj) {
         const errors = [];
         const cssString = entries(cssObj).reduce((prev, [property, value]) => {
@@ -5571,24 +3050,6 @@
         return cssString;
     }
 
-    /**
-     * Validates whether a string is a valid CSS selector by attempting to query with it.
-     *
-     * @param selector - The CSS selector string to validate
-     * @returns True if the selector is valid, false otherwise
-     *
-     * @example Validating CSS selectors
-     * ```typescript
-     * isValidCssSelector('.my-class')
-     * // => true
-     *
-     * isValidCssSelector('#header nav > ul')
-     * // => true
-     *
-     * isValidCssSelector('[invalid')
-     * // => false
-     * ```
-     */
     function isValidCssSelector(selector) {
         try {
             document.createDocumentFragment().querySelector(selector);
@@ -5599,31 +3060,6 @@
         }
     }
 
-    /**
-     * Generates a CSS rule string from a given selector and style declaration.
-     *
-     * This function takes a CSS selector and either a string or a CSSStyleDeclaration object
-     * representing the styles to be applied. It validates the selector and converts the CSS
-     * object to a string if needed. The function then constructs and returns a valid
-     * CSS rule as a string.
-     *
-     * @param selector - The CSS selector to which the styles will be applied
-     * @param css - The styles to apply, either as a string or CSSStyleDeclaration object
-     * @returns A string representing a complete CSS rule
-     * @throws {Error} When the selector is invalid or the css argument is not a valid string or object
-     *
-     * @example With style object
-     * ```typescript
-     * cssRule('.button', { padding: '8px 16px', borderRadius: '4px' })
-     * // => '.button{padding: 8px 16px; border-radius: 4px}'
-     * ```
-     *
-     * @example With CSS string
-     * ```typescript
-     * cssRule('.button:hover', 'background-color: #007bff; color: white')
-     * // => '.button:hover{background-color: #007bff; color: white}'
-     * ```
-     */
     function cssRule(selector, css) {
         if (!isValidCssSelector(selector)) {
             throw createError('A valid css select must be provided');
@@ -5637,23 +3073,6 @@
         return `${selector}{${css}}`;
     }
 
-    /**
-     * Creates CSS rules from a styles object, converting each selector-style pair into CSS rule strings.
-     *
-     * @param styles - An object mapping CSS selectors to style objects
-     * @returns A string containing all CSS rules separated by newlines
-     *
-     * @example Creating CSS rules from object
-     * ```typescript
-     * const styles = {
-     *   '.card': { padding: '16px', boxShadow: '0 2px 4px rgba(0,0,0,0.1)' },
-     *   '.card-title': { fontSize: '18px', fontWeight: 'bold' }
-     * }
-     *
-     * cssRules(styles)
-     * // => '.card{padding: 16px; box-shadow: 0 2px 4px rgba(0,0,0,0.1)}\n.card-title{font-size: 18px; font-weight: bold}'
-     * ```
-     */
     function cssRules(styles) {
         if (getType(styles) !== 'object')
             return '';
@@ -5666,33 +3085,6 @@
     const labels = createSet();
     const labeledStylesheets = createMap();
     const stylesheetLabels = createWeakMap();
-    /**
-     * Adds a new stylesheet to the document with optional label.
-     *
-     * @param css - The CSS rules to be added in the new stylesheet
-     * @param label - Optional label for the new stylesheet
-     * @returns A tuple where the first item is the created HTMLStyleElement, and the second item is a cleanup function
-     * @throws {Error} When css is not a string or StyleMap, is empty, or a stylesheet with the same label already exists
-     *
-     * @example CSS string
-     * ```typescript
-     * const [styleElement, removeStyles] = addStylesheet(`
-     *   .modal { display: flex; align-items: center; }
-     *   .modal-overlay { background: rgba(0, 0, 0, 0.5); }
-     * `, 'modal-styles')
-     *
-     * // Remove when done
-     * removeStyles()
-     * ```
-     *
-     * @example StyleMap object
-     * ```typescript
-     * const [styleElement, removeStyles] = addStylesheet({
-     *   '.button': { backgroundColor: '#3498db', padding: '10px 20px' },
-     *   '.button:hover': { backgroundColor: '#2980b9' },
-     * })
-     * ```
-     */
     function addStylesheet(css, label) {
         if (getType(css) === 'object') {
             css = cssRules(css);
@@ -5707,23 +3099,6 @@
         const removeCallback = () => removeStylesheet(style);
         return [style, removeCallback];
     }
-    /**
-     * Removes a stylesheet from the document.
-     *
-     * @param {string | HTMLStyleElement} ref - The label or the HTMLStyleElement of the stylesheet to be removed.
-     *
-     * @example By label
-     * ```typescript
-     * addStylesheet('.theme { color: red; }', 'theme-styles')
-     * removeStylesheet('theme-styles')
-     * ```
-     *
-     * @example By element reference
-     * ```typescript
-     * const [styleElement] = addStylesheet('.custom { margin: 0; }')
-     * removeStylesheet(styleElement)
-     * ```
-     */
     function removeStylesheet(ref) {
         const isLabel = getType(ref) === 'string';
         let style;
@@ -5741,7 +3116,6 @@
             stylesheets.delete(style);
         }
         catch {
-            /** Swallow any errors */
         }
         try {
             labels.delete(label);
@@ -5749,35 +3123,13 @@
             stylesheetLabels.delete(style);
         }
         catch {
-            /** Swallow any errors */
         }
     }
 
-    // note: The feature page resets its own body so the embedded UI fills the iframe edge-to-edge with a transparent backdrop; the host cannot touch the cross-origin body itself.
     const BODY_RESET_CSS = 'html,body{margin:0;padding:0;background:transparent}';
-    /**
-     * Neutralizes the feature page's body so the embedded UI is neither clipped nor padded.
-     *
-     * @example Resetting the body when a feature initializes
-     * ```typescript
-     * applyBodyReset()
-     * ```
-     */
     function applyBodyReset() {
         addStylesheet(BODY_RESET_CSS);
     }
-    /**
-     * Creates the hostee-side content-size announcer.
-     *
-     * @param send - The control-channel send function (receives the reserved size type).
-     * @returns A start/stop handle for the size-announcement loop.
-     *
-     * @example Announcing size to the host while connected
-     * ```typescript
-     * const announcer = createSizeAnnouncer((type, data) => channel.send(type, data))
-     * announcer.start()
-     * ```
-     */
     function createSizeAnnouncer(send) {
         let cleanup;
         const announce = () => send(ControlType.Size, { width: document.body.scrollWidth, height: document.body.scrollHeight });
@@ -5798,18 +3150,6 @@
         };
     }
 
-    // note: The host connects from a parent window (embedded iframe) or an opener window (popup/standalone); a top-level document has neither.
-    /**
-     * Resolves the window the host is expected to message the feature from.
-     *
-     * @param win - The feature's own window (`globalThis.window` in production).
-     * @returns The parent or opener window, or `null` when running top-level.
-     *
-     * @example Resolving the host window
-     * ```typescript
-     * const hostWindow = resolveHostWindow(window)
-     * ```
-     */
     function resolveHostWindow(win) {
         if (win.parent !== win) {
             return win.parent;
@@ -5819,23 +3159,10 @@
         }
         return null;
     }
-    /**
-     * Wires a hostee channel into the emitter and assembles the public handle.
-     *
-     * @param broker - The nexus broker for this feature.
-     * @param hostWindow - The resolved host window, or `null` when unembedded.
-     * @param emitter - The subscription registry backing `handle.on`.
-     * @returns The frozen {@link FeatureHandle}.
-     *
-     * @example Assembling a feature handle around a broker
-     * ```typescript
-     * const handle = createFeatureHandle(broker, resolveHostWindow(window), emitter)
-     * await handle.ready()
-     * ```
-     */
     function createFeatureHandle(broker, hostWindow, emitter) {
         let channel = null;
         let opened = false;
+        const requests = createRequestPeer('feature', (type, data) => channel?.send(type, data));
         if (hostWindow) {
             const activeChannel = broker.addChannel('host', hostWindow);
             channel = activeChannel;
@@ -5852,14 +3179,25 @@
                 emitter.emit('close');
                 heartbeat.stop();
                 announcer.stop();
+                requests.rejectAll('The host channel closed before the host responded.');
             });
             activeChannel.on('deny', (data) => emitter.emit('error', data));
             activeChannel.on('invalid', (data) => emitter.emit('error', data));
-            activeChannel.onMessage((message) => emitter.emit(message.type, message.data));
+            activeChannel.onMessage((message) => {
+                if (isControlType(message.type)) {
+                    requests.dispatch(message.type, message.data);
+                    return;
+                }
+                emitter.emit(message.type, message.data);
+            });
             activeChannel.connect();
         }
         return freeze({
             send: (type, data) => channel?.send(type, data),
+            request: (type, data, options) => channel
+                ? requests.request(type, data, options)
+                : promiseReject(createError(`Cannot send request '${type}': the feature is not connected to a host.`)),
+            handle: requests.handle,
             on: emitter.on,
             ready: () => createPromise((resolve) => {
                 if (opened) {
@@ -5872,22 +3210,6 @@
         });
     }
 
-    /**
-     * Initializes a feature app on the hostee side and waits for the host connection.
-     *
-     * Creates a nexus broker for the feature, resolves the host window, and returns
-     * a handle for messaging and lifecycle.
-     *
-     * @param options - Feature name and contract.
-     * @returns A handle exposing `send`, `on`, `ready`, and `close`.
-     *
-     * @example Initializing a clock feature
-     * ```typescript
-     * const feature = createFeature({ name: 'clock', contract })
-     * feature.ready().then(() => feature.send('timeUpdated', { time: Date.now() }))
-     * feature.on('setTimezone', (data) => console.log(data))
-     * ```
-     */
     function createFeature(options) {
         const contract = withControlContract(validateContract(options.contract));
         const emitter = createEventEmitter();