redweb 0.16.1 → 0.16.3

package/src/htmx/index.js

@@ -2,9 +2,10 @@ const HtmlRenderer = require('./HtmlRenderer');
 const LiveHtmlServer = require('./LiveHtmlServer');
 const LivePage = require('./LivePage');
 const { attribute, codeBlock, each, html, safeUrl: url } = require('./Html');
-const { action, component, page, state, view } = require('./metadata');
+const { action, component, inject, page, resource, state, upload, view } = require('./metadata');
+const { LiveResource, liveResource } = require('./LiveResource');
 const { start } = require('./start');
 const { exportStatic } = require('./StaticExporter');
 const { defineSite } = require('./StaticSite');
 
-module.exports = { action, attribute, codeBlock, component, defineSite, each, exportStatic, html, HtmlRenderer, LiveHtmlServer, LivePage, page, start, state, url, view };
+module.exports = { action, attribute, codeBlock, component, defineSite, each, exportStatic, html, HtmlRenderer, inject, LiveHtmlServer, LivePage, LiveResource, liveResource, page, resource, start, state, upload, url, view };

package/src/htmx/metadata.js

@@ -7,6 +7,12 @@ const STANDARD_ACTIONS = new WeakMap();
 const VIEW_METADATA = new WeakMap();
 const RESOLVED_VIEW = new WeakMap();
 const STANDARD_VIEWS = new WeakMap();
+const RESOURCE_METADATA = new WeakMap();
+const RESOLVED_RESOURCE = new WeakMap();
+const INJECT_METADATA = new WeakMap();
+const RESOLVED_INJECT = new WeakMap();
+const UPLOAD_METADATA = new WeakMap();
+const RESOLVED_UPLOAD = new WeakMap();
 const PAGE_ROOTS = new WeakMap();
 const PAGE_STYLESHEET_ROOTS = new WeakMap();
 const COMPONENT_CLASSES = new WeakSet();
@@ -65,6 +71,27 @@ function registerView(store, PageClass, stateName, method, implementation) {
     metadataVersion += 1;
 }
 
+function registerResource(PageClass, property, config) {
+    const properties = new Map(RESOURCE_METADATA.get(PageClass) || []);
+    properties.set(property, config);
+    RESOURCE_METADATA.set(PageClass, properties);
+    metadataVersion += 1;
+}
+
+function registerInject(PageClass, property, provider) {
+    const properties = new Map(INJECT_METADATA.get(PageClass) || []);
+    properties.set(property, provider);
+    INJECT_METADATA.set(PageClass, properties);
+    metadataVersion += 1;
+}
+
+function registerUpload(PageClass, method, config) {
+    const methods = new Map(UPLOAD_METADATA.get(PageClass) || []);
+    methods.set(method, config);
+    UPLOAD_METADATA.set(PageClass, methods);
+    metadataVersion += 1;
+}
+
 function resolvedState(PageClass) {
     const cached = RESOLVED_STATE.get(PageClass);
     if (cached?.version === metadataVersion) return cached.value;
@@ -112,6 +139,15 @@ function resolvedView(PageClass) {
     return value;
 }
 
+function resolved(store, cache, PageClass) {
+    const cached = cache.get(PageClass);
+    if (cached?.version === metadataVersion) return cached.value;
+    const value = new Map();
+    hierarchy(PageClass).forEach(CurrentClass => store.get(CurrentClass)?.forEach((config, property) => value.set(property, config)));
+    cache.set(PageClass, { version: metadataVersion, value });
+    return value;
+}
+
 function pageHead(value) {
     if (value === undefined) return undefined;
     if (!value || typeof value !== 'object' || Array.isArray(value)) throw new TypeError('Page head must be an object.');
@@ -178,10 +214,10 @@ function page(routePath, options = {}) {
     if (!['connection', 'shared'].includes(scope)) {
         throw new TypeError('Page scope must be "connection" or "shared".');
     }
-    if (typeof live !== 'boolean') throw new TypeError('Page live must be a boolean.');
-    if (options.socket !== undefined && (typeof options.socket !== 'function' || !live || scope !== 'connection')) {
-        throw new TypeError('Page socket requires a route class and a live connection-scoped page.');
-    }
+    if (typeof live !== 'boolean') throw new TypeError('Page live must be a boolean.');
+    if (options.socket !== undefined && (typeof options.socket !== 'function' || !live || scope !== 'connection')) {
+        throw new TypeError('Page socket requires a route class and a live connection-scoped page.');
+    }
     if (layout !== undefined && typeof layout !== 'function') throw new TypeError('Page layout must be a function.');
     const head = pageHead(options.head);
     const cache = pageCache(options.cache, live);
@@ -192,8 +228,8 @@ function page(routePath, options = {}) {
         PAGE_METADATA.set(PageClass, Object.freeze({
             path: routePath,
             template,
-            scope,
-            ...(options.socket && { socket: options.socket }),
+            scope,
+            ...(options.socket && { socket: options.socket }),
             ...(live === false && { live: false }),
             ...(head && { head }),
             ...(cache && { cache }),
@@ -250,6 +286,71 @@ function state(options = {}) {
     };
 }
 
+function resource(liveResource, select) {
+    const { LiveResource } = require('./LiveResource');
+    if (!(liveResource instanceof LiveResource)) throw new TypeError('resource() requires a value created by liveResource().');
+    if (typeof select !== 'function') throw new TypeError('resource() requires a key selector.');
+    const config = Object.freeze({ resource: liveResource, select });
+    return (target, property) => {
+        if (property?.kind === 'field') {
+            if (property.static || property.private || typeof property.name !== 'string' || !property.name) {
+                throw new TypeError('resource() requires a public instance field with a string name.');
+            }
+            property.addInitializer(function registerStandardResource() {
+                registerState(this.constructor, property.name, Object.freeze({ writable: false }));
+                registerResource(this.constructor, property.name, config);
+            });
+            return initialValue => initialValue;
+        }
+        const PageClass = assertDecoratorTarget(target, 'resource()');
+        if (typeof property !== 'string' || !property) throw new TypeError('Resource property must be a non-empty string.');
+        registerState(PageClass, property, Object.freeze({ writable: false }));
+        registerResource(PageClass, property, config);
+    };
+}
+
+function inject(provider) {
+    if (typeof provider !== 'string' || !provider || provider.length > 128 || ['__proto__', 'prototype', 'constructor'].includes(provider)) {
+        throw new TypeError('inject() requires a safe non-empty provider name of at most 128 characters.');
+    }
+    return (target, property) => {
+        if (property?.kind === 'field') {
+            if (property.static || property.private || typeof property.name !== 'string' || !property.name) {
+                throw new TypeError('inject() requires a public instance field with a string name.');
+            }
+            property.addInitializer(function registerStandardInject() { registerInject(this.constructor, property.name, provider); });
+            return initialValue => initialValue;
+        }
+        const PageClass = assertDecoratorTarget(target, 'inject()');
+        if (typeof property !== 'string' || !property) throw new TypeError('Injected property must be a non-empty string.');
+        registerInject(PageClass, property, provider);
+    };
+}
+
+function upload(options = {}) {
+    if (!options || typeof options !== 'object' || Array.isArray(options)) throw new TypeError('upload() options must be an object.');
+    const { maxBytes = 10 * 1024 * 1024, accept = [] } = options;
+    if (!Number.isInteger(maxBytes) || maxBytes < 1 || maxBytes > 1024 * 1024 * 1024) throw new RangeError('upload() maxBytes must be an integer between 1 and 1 GiB.');
+    const types = Array.isArray(accept) ? accept : [accept];
+    if (types.some(type => typeof type !== 'string' || !/^[a-z]+\/(?:[a-z0-9.+-]+|\*)$/.test(type))) throw new TypeError('upload() accept must contain MIME types or type wildcards.');
+    const config = Object.freeze({ maxBytes, accept: Object.freeze([...new Set(types)]) });
+    return (target, method, descriptor) => {
+        if (method?.kind === 'method') {
+            if (method.static || method.private || typeof method.name !== 'string' || !method.name || typeof target !== 'function') throw new TypeError('upload() requires a public instance method with a string name.');
+            const entry = Object.freeze({ implementation: target, definition: new ActionDefinition() });
+            method.addInitializer(function registerStandardUpload() {
+                if (this[method.name] === target) { registerStandardAction(this.constructor, method.name, entry); registerUpload(this.constructor, method.name, config); }
+            });
+            return target;
+        }
+        const PageClass = assertDecoratorTarget(target, 'upload()');
+        if (typeof method !== 'string' || !method || typeof descriptor?.value !== 'function') throw new TypeError('upload() must decorate a method.');
+        registerAction(PageClass, method, Object.freeze({ implementation: descriptor.value, definition: new ActionDefinition() }));
+        registerUpload(PageClass, method, config);
+        return descriptor;
+    };
+}
+
 function action(options) {
     const definition = new ActionDefinition(options);
     return (target, method, descriptor) => {
@@ -321,6 +422,10 @@ function getStateConfig(PageClass, property) {
     return resolvedState(PageClass).get(property);
 }
 
+function getResourceMetadata(PageClass) { return new Map(resolved(RESOURCE_METADATA, RESOLVED_RESOURCE, PageClass)); }
+function getInjectMetadata(PageClass) { return new Map(resolved(INJECT_METADATA, RESOLVED_INJECT, PageClass)); }
+function getUploadMetadata(PageClass) { return new Map(resolved(UPLOAD_METADATA, RESOLVED_UPLOAD, PageClass)); }
+
 function forEachState(PageClass, callback) {
     resolvedState(PageClass).forEach(callback);
 }
@@ -349,6 +454,9 @@ module.exports = {
     getActionDefinition,
     getActionMetadata,
     getPageMetadata,
+    getInjectMetadata,
+    getUploadMetadata,
+    getResourceMetadata,
     getPageStylesheetRoots,
     getPageTemplateRoot,
     getStateConfig,
@@ -356,10 +464,13 @@ module.exports = {
     getViewImplementation,
     getViewMetadata,
     isComponentClass,
+    inject,
     page,
     pageCache,
     pageHead,
     setPageStylesheetRoots,
     state,
+    resource,
+    upload,
     view,
 };

package/src/ws/BaseHandler.js

@@ -20,12 +20,12 @@ class BaseHandler {
      */
     async handleMessage(socket, message) {
         const validationResult = await this.validateMessage(message, socket);
-        if (validationResult === false) {
-            throw new Error('Invalid message');
-        }
-        const guard = require('./HandlerGuard').guards.get(socket);
-        if (guard) await guard();
-        return this.onMessage(socket, message);
+        if (validationResult === false) {
+            throw new Error('Invalid message');
+        }
+        const guard = require('./HandlerGuard').guards.get(socket);
+        if (guard) await guard();
+        return this.onMessage(socket, message);
     }
 
     validateMessage() {

package/src/ws/ConnectedClients.js

@@ -1,207 +1,207 @@
-'use strict';
-
-const { AccessPolicy, AccessDenied } = require('../access/AccessPolicy');
-const { guards } = require('./HandlerGuard');
-const { BoundedOperation } = require('../async/BoundedOperation');
-
-/** Deliberately public rejection text; unexpected exceptions remain private. */
-class ClientError extends Error {
-    constructor(message) {
-        if (typeof message !== 'string' || !message || message.length > 512) throw new TypeError('Client error text must contain 1–512 characters.');
-        super(message);
-    }
-}
-
-class ConnectedClient {
-    #owner;
-    constructor(owner, socket) {
-        this.#owner = owner;
-        Object.defineProperty(this, 'socket', { value: socket });
-        Object.freeze(this);
-    }
-    get identity() { this.#owner.assertActive(this.socket); return this.socket.context.principal; }
-    get rooms() { return this.#owner.rooms.roomsFor(this.socket); }
-    get room() {
-        const rooms = this.rooms;
-        if (rooms.length !== 1) throw new ClientError('Join a room first.');
-        return rooms[0];
-    }
-    get page() { this.#owner.assertActive(this.socket); return this.socket.page(this.#owner.options.page()); }
-    join(room, commit) { return this.#owner.join(this, room, commit); }
-    leave(room) { this.#owner.assertActive(this.socket); return this.#owner.rooms.leave(room, this.socket); }
-}
-
-/** One route-owned projection layer; RoomRegistry alone owns membership. */
-class ConnectedClients {
-    #route;
-    #clients = new WeakMap();
-    #joining = new WeakSet();
-    #queued = new Set();
-    #generations = new Map();
-
-    constructor(options) {
-        if (!options || typeof options !== 'object') throw new TypeError('Connected clients require options.');
-        for (const name of ['identity', 'page', 'project']) {
-            if (typeof options[name] !== 'function') throw new TypeError(`Connected clients require ${name}.`);
-        }
-        for (const name of ['reject', 'errorState']) {
-            if (options[name] !== undefined && typeof options[name] !== 'function') throw new TypeError(`${name} must be a function.`);
-        }
-        if (options.raw !== undefined && (!options.raw || typeof options.raw.update !== 'function' ||
-            (options.raw.reject !== undefined && typeof options.raw.reject !== 'function'))) {
-            throw new TypeError('A raw adapter requires update and an optional reject callback.');
-        }
-        this.options = Object.freeze({ ...options, raw: options.raw && Object.freeze({ ...options.raw }) });
-        this.policy = new AccessPolicy(async context => {
-            const identity = await this.options.identity(context);
-            return identity !== undefined && identity !== null && identity !== false && Object.is(identity, context.principal);
-        }, options.authorizationTimeoutMs);
-        this.projection = new BoundedOperation(options.projectionTimeoutMs);
-    }
-
-    attach(route, rooms) {
-        if (this.#route) throw new TypeError('Connected clients belong to one route instance. Create them inside your application factory.');
-        if (!rooms || !route.protocolPolicy) throw new TypeError('Connected clients require rooms and a socket protocol.');
-        this.#route = route;
-        this.rooms = rooms;
-    }
-
-    assertActive(socket) {
-        if (!this.#route || this.#route.draining || this.#route.clients.get(socket.clientKey) !== socket ||
-            socket.readyState !== 1 || socket.context.signal.aborted) throw new AccessDenied('ACCESS_CANCELLED');
-    }
-
-    get(socket) {
-        this.assertActive(socket);
-        let client = this.#clients.get(socket);
-        if (!client) { client = new ConnectedClient(this, socket); this.#clients.set(socket, client); }
-        return client;
-    }
-
-    async check(socket) {
-        this.assertActive(socket);
-        await this.policy.check(socket.context);
-        const guard = guards.get(socket);
-        if (guard) await guard();
-        this.assertActive(socket);
-        if (!socket.page && !this.options.raw) throw new AccessDenied();
-    }
-
-    async join(client, room, commit = () => {}) {
-        const socket = client.socket;
-        if (typeof commit !== 'function') throw new TypeError('Room commit must be synchronous.');
-        if (this.#joining.has(socket)) throw new ClientError('A room join is already pending.');
-        const existing = this.rooms.has(room, socket);
-        this.#joining.add(socket);
-        try {
-            await this.check(socket);
-            if (!await this.rooms.enter(room, socket)) throw new ClientError('Room capacity or access denied.');
-            await this.check(socket);
-            if (!this.rooms.has(room, socket)) throw new AccessDenied('ACCESS_CANCELLED');
-            const result = commit();
-            if (result && typeof result.then === 'function') {
-                Promise.resolve(result).catch(() => {});
-                throw new TypeError('Room commit must be synchronous.');
-            }
-        } catch (error) {
-            if (!existing) this.rooms.leave(room, socket);
-            throw error;
-        } finally { this.#joining.delete(socket); this.changed(room); }
-    }
-
-    changed(room) {
-        if (this.#route.draining) return;
-        this.#generations.set(room, Symbol());
-        if (this.#queued.has(room)) return;
-        this.#queued.add(room);
-        queueMicrotask(() => {
-            if (!this.#queued.delete(room)) return;
-            void this.refresh(room).catch(error => this.#route.logger.error('Connected client refresh failed:', error));
-        });
-    }
-
-    refresh(room) {
-        this.rooms.validateRoomId(room);
-        this.#queued.delete(room);
-        return this.#route.runtime.run(() => this.project(room));
-    }
-
-    async project(room) {
-        const generation = Symbol();
-        this.#generations.set(room, generation);
-        const current = socket => this.#generations.get(room) === generation && this.rooms.has(room, socket) && !this.#joining.has(socket);
-        const eligible = [];
-        try {
-            await Promise.all(this.rooms.members(room).map(async socket => {
-                if (!current(socket)) return;
-                try {
-                    await this.check(socket);
-                    if (current(socket)) { const client = this.get(socket); eligible.push({ client, identity: client.identity }); }
-                }
-                catch (error) { if (current(socket)) this.exclude(socket, error); }
-            }));
-            const online = Object.freeze([...new Set(eligible.map(entry => entry.identity))]);
-            await Promise.all(eligible.map(async ({ client }) => {
-                const socket = client.socket;
-                try {
-                    if (!current(socket)) return;
-                    const { state, frame } = await this.projection.run(async () => {
-                        const state = await this.options.project(client, room, online);
-                        const frame = socket.page ? null : await this.options.raw.update(state);
-                        return { state, frame };
-                    }, socket.context.signal);
-                    await this.check(socket);
-                    if (!current(socket)) return;
-                    if (socket.page) Object.assign(client.page, state);
-                    else socket.sendEvent(frame.type, frame.payload);
-                } catch (error) { if (current(socket)) this.exclude(socket, error); }
-            }));
-        } finally {
-            if (this.#generations.get(room) === generation) this.#generations.delete(room);
-        }
-    }
-
-    exclude(socket, error) {
-        this.rooms.leaveAll(socket);
-        if (!(error instanceof AccessDenied)) this.#route.handleError(socket, error);
-        socket.close(error instanceof AccessDenied ? 1008 : 1011, 'Connection unavailable.');
-    }
-
-    bind(contract) {
-        return Object.freeze({
-            protocol: contract.protocol,
-            handler: (type, callback) => {
-                if (typeof callback !== 'function') throw new TypeError('A client handler requires a callback.');
-                return contract.handler(type, async (socket, payload, message) => {
-                    const client = this.get(socket);
-                    await this.check(socket);
-                    try {
-                        const result = await callback(client, payload);
-                        if (result === false) return false;
-                        await Promise.all(client.rooms.map(room => this.refresh(room)));
-                        if (!socket.page && message.requestId !== undefined) {
-                            await this.check(socket);
-                            socket.sendEvent('redweb:result', null, { requestId: message.requestId });
-                        }
-                        return result;
-                    } catch (error) {
-                        const text = error instanceof ClientError ? error.message : this.options.reject?.(error);
-                        if (typeof text !== 'string' || !text || text.length > 512) throw error;
-                        const metadata = { requestId: message.requestId };
-                        const frame = socket.page || !this.options.raw.reject ? null :
-                            await this.projection.run(() => this.options.raw.reject(text), socket.context.signal);
-                        await this.check(socket);
-                        if (socket.page) {
-                            if (this.options.errorState) Object.assign(client.page, this.options.errorState(text));
-                        } else if (frame) socket.sendEvent(frame.type, frame.payload);
-                        socket.sendProtocolError('COMMAND_REJECTED', text, metadata);
-                        return false;
-                    }
-                });
-            },
-        });
-    }
-}
-
-const connectedClients = options => new ConnectedClients(options);
-module.exports = { connectedClients, ConnectedClients, ConnectedClient, ClientError };
+'use strict';
+
+const { AccessPolicy, AccessDenied } = require('../access/AccessPolicy');
+const { guards } = require('./HandlerGuard');
+const { BoundedOperation } = require('../async/BoundedOperation');
+
+/** Deliberately public rejection text; unexpected exceptions remain private. */
+class ClientError extends Error {
+    constructor(message) {
+        if (typeof message !== 'string' || !message || message.length > 512) throw new TypeError('Client error text must contain 1–512 characters.');
+        super(message);
+    }
+}
+
+class ConnectedClient {
+    #owner;
+    constructor(owner, socket) {
+        this.#owner = owner;
+        Object.defineProperty(this, 'socket', { value: socket });
+        Object.freeze(this);
+    }
+    get identity() { this.#owner.assertActive(this.socket); return this.socket.context.principal; }
+    get rooms() { return this.#owner.rooms.roomsFor(this.socket); }
+    get room() {
+        const rooms = this.rooms;
+        if (rooms.length !== 1) throw new ClientError('Join a room first.');
+        return rooms[0];
+    }
+    get page() { this.#owner.assertActive(this.socket); return this.socket.page(this.#owner.options.page()); }
+    join(room, commit) { return this.#owner.join(this, room, commit); }
+    leave(room) { this.#owner.assertActive(this.socket); return this.#owner.rooms.leave(room, this.socket); }
+}
+
+/** One route-owned projection layer; RoomRegistry alone owns membership. */
+class ConnectedClients {
+    #route;
+    #clients = new WeakMap();
+    #joining = new WeakSet();
+    #queued = new Set();
+    #generations = new Map();
+
+    constructor(options) {
+        if (!options || typeof options !== 'object') throw new TypeError('Connected clients require options.');
+        for (const name of ['identity', 'page', 'project']) {
+            if (typeof options[name] !== 'function') throw new TypeError(`Connected clients require ${name}.`);
+        }
+        for (const name of ['reject', 'errorState']) {
+            if (options[name] !== undefined && typeof options[name] !== 'function') throw new TypeError(`${name} must be a function.`);
+        }
+        if (options.raw !== undefined && (!options.raw || typeof options.raw.update !== 'function' ||
+            (options.raw.reject !== undefined && typeof options.raw.reject !== 'function'))) {
+            throw new TypeError('A raw adapter requires update and an optional reject callback.');
+        }
+        this.options = Object.freeze({ ...options, raw: options.raw && Object.freeze({ ...options.raw }) });
+        this.policy = new AccessPolicy(async context => {
+            const identity = await this.options.identity(context);
+            return identity !== undefined && identity !== null && identity !== false && Object.is(identity, context.principal);
+        }, options.authorizationTimeoutMs);
+        this.projection = new BoundedOperation(options.projectionTimeoutMs);
+    }
+
+    attach(route, rooms) {
+        if (this.#route) throw new TypeError('Connected clients belong to one route instance. Create them inside your application factory.');
+        if (!rooms || !route.protocolPolicy) throw new TypeError('Connected clients require rooms and a socket protocol.');
+        this.#route = route;
+        this.rooms = rooms;
+    }
+
+    assertActive(socket) {
+        if (!this.#route || this.#route.draining || this.#route.clients.get(socket.clientKey) !== socket ||
+            socket.readyState !== 1 || socket.context.signal.aborted) throw new AccessDenied('ACCESS_CANCELLED');
+    }
+
+    get(socket) {
+        this.assertActive(socket);
+        let client = this.#clients.get(socket);
+        if (!client) { client = new ConnectedClient(this, socket); this.#clients.set(socket, client); }
+        return client;
+    }
+
+    async check(socket) {
+        this.assertActive(socket);
+        await this.policy.check(socket.context);
+        const guard = guards.get(socket);
+        if (guard) await guard();
+        this.assertActive(socket);
+        if (!socket.page && !this.options.raw) throw new AccessDenied();
+    }
+
+    async join(client, room, commit = () => {}) {
+        const socket = client.socket;
+        if (typeof commit !== 'function') throw new TypeError('Room commit must be synchronous.');
+        if (this.#joining.has(socket)) throw new ClientError('A room join is already pending.');
+        const existing = this.rooms.has(room, socket);
+        this.#joining.add(socket);
+        try {
+            await this.check(socket);
+            if (!await this.rooms.enter(room, socket)) throw new ClientError('Room capacity or access denied.');
+            await this.check(socket);
+            if (!this.rooms.has(room, socket)) throw new AccessDenied('ACCESS_CANCELLED');
+            const result = commit();
+            if (result && typeof result.then === 'function') {
+                Promise.resolve(result).catch(() => {});
+                throw new TypeError('Room commit must be synchronous.');
+            }
+        } catch (error) {
+            if (!existing) this.rooms.leave(room, socket);
+            throw error;
+        } finally { this.#joining.delete(socket); this.changed(room); }
+    }
+
+    changed(room) {
+        if (this.#route.draining) return;
+        this.#generations.set(room, Symbol());
+        if (this.#queued.has(room)) return;
+        this.#queued.add(room);
+        queueMicrotask(() => {
+            if (!this.#queued.delete(room)) return;
+            void this.refresh(room).catch(error => this.#route.logger.error('Connected client refresh failed:', error));
+        });
+    }
+
+    refresh(room) {
+        this.rooms.validateRoomId(room);
+        this.#queued.delete(room);
+        return this.#route.runtime.run(() => this.project(room));
+    }
+
+    async project(room) {
+        const generation = Symbol();
+        this.#generations.set(room, generation);
+        const current = socket => this.#generations.get(room) === generation && this.rooms.has(room, socket) && !this.#joining.has(socket);
+        const eligible = [];
+        try {
+            await Promise.all(this.rooms.members(room).map(async socket => {
+                if (!current(socket)) return;
+                try {
+                    await this.check(socket);
+                    if (current(socket)) { const client = this.get(socket); eligible.push({ client, identity: client.identity }); }
+                }
+                catch (error) { if (current(socket)) this.exclude(socket, error); }
+            }));
+            const online = Object.freeze([...new Set(eligible.map(entry => entry.identity))]);
+            await Promise.all(eligible.map(async ({ client }) => {
+                const socket = client.socket;
+                try {
+                    if (!current(socket)) return;
+                    const { state, frame } = await this.projection.run(async () => {
+                        const state = await this.options.project(client, room, online);
+                        const frame = socket.page ? null : await this.options.raw.update(state);
+                        return { state, frame };
+                    }, socket.context.signal);
+                    await this.check(socket);
+                    if (!current(socket)) return;
+                    if (socket.page) Object.assign(client.page, state);
+                    else socket.sendEvent(frame.type, frame.payload);
+                } catch (error) { if (current(socket)) this.exclude(socket, error); }
+            }));
+        } finally {
+            if (this.#generations.get(room) === generation) this.#generations.delete(room);
+        }
+    }
+
+    exclude(socket, error) {
+        this.rooms.leaveAll(socket);
+        if (!(error instanceof AccessDenied)) this.#route.handleError(socket, error);
+        socket.close(error instanceof AccessDenied ? 1008 : 1011, 'Connection unavailable.');
+    }
+
+    bind(contract) {
+        return Object.freeze({
+            protocol: contract.protocol,
+            handler: (type, callback) => {
+                if (typeof callback !== 'function') throw new TypeError('A client handler requires a callback.');
+                return contract.handler(type, async (socket, payload, message) => {
+                    const client = this.get(socket);
+                    await this.check(socket);
+                    try {
+                        const result = await callback(client, payload);
+                        if (result === false) return false;
+                        await Promise.all(client.rooms.map(room => this.refresh(room)));
+                        if (!socket.page && message.requestId !== undefined) {
+                            await this.check(socket);
+                            socket.sendEvent('redweb:result', null, { requestId: message.requestId });
+                        }
+                        return result;
+                    } catch (error) {
+                        const text = error instanceof ClientError ? error.message : this.options.reject?.(error);
+                        if (typeof text !== 'string' || !text || text.length > 512) throw error;
+                        const metadata = { requestId: message.requestId };
+                        const frame = socket.page || !this.options.raw.reject ? null :
+                            await this.projection.run(() => this.options.raw.reject(text), socket.context.signal);
+                        await this.check(socket);
+                        if (socket.page) {
+                            if (this.options.errorState) Object.assign(client.page, this.options.errorState(text));
+                        } else if (frame) socket.sendEvent(frame.type, frame.payload);
+                        socket.sendProtocolError('COMMAND_REJECTED', text, metadata);
+                        return false;
+                    }
+                });
+            },
+        });
+    }
+}
+
+const connectedClients = options => new ConnectedClients(options);
+module.exports = { connectedClients, ConnectedClients, ConnectedClient, ClientError };

package/src/ws/HandlerGuard.js

@@ -1,4 +1,4 @@
-'use strict';
-// A private hook, never a field supplied by an incoming message.
-const guards = new WeakMap();
-module.exports = { guards };
+'use strict';
+// A private hook, never a field supplied by an incoming message.
+const guards = new WeakMap();
+module.exports = { guards };