redweb 0.8.0 → 0.10.0

package/index.js

@@ -1,23 +1,55 @@
-const { BaseHttpServer, METHODS } = require('./src/http');
-const { ENCODINGS, HTTP_OPTIONS } = require('./src/http/BaseHttpServer');
+const { BaseHttpServer, METHODS } = require('./src/http');
+const { ENCODINGS, HTTP_OPTIONS } = require('./src/http/BaseHttpServer');
 const { sendJson } = require('./src/ws/util');
-const { SocketServer, SecureSocketServer, SOCKET_OPTIONS, SocketRoute, SocketService, SocketRegistry } = require('./src/ws');
+const {
+    SocketServer,
+    SecureSocketServer,
+    SOCKET_OPTIONS,
+    SocketRoute,
+    SocketService,
+    FixedStepService,
+    SocketRegistry,
+    RoomRegistry,
+    SessionRegistry,
+    ERROR_CODES,
+} = require('./src/ws');
 const { BaseHandler } = require('./src/ws/BaseHandler');
 const HttpServer = require('./src/http/HttpServer');
 const HttpsServer = require('./src/http/HttpsServer');
+const { action, attribute, codeBlock, component, defineSite, each, exportStatic, html, HtmlRenderer, LiveHtmlServer, LivePage, page, start, state, url, view } = require('./src/htmx');
 module.exports = {
-    HttpServer,
-    HttpsServer,
-    BaseHttpServer,
-    SocketServer,
+    HttpServer,
+    HttpsServer,
+    BaseHttpServer,
+    SocketServer,
     SecureSocketServer,
     BaseHandler,
     SocketRoute,
     SocketService,
+    FixedStepService,
     SocketRegistry,
+    RoomRegistry,
+    SessionRegistry,
+    ERROR_CODES,
     sendJson,
-    SOCKET_OPTIONS,
-    HTTP_OPTIONS,
-    ENCODINGS,
-    METHODS
-};
+    SOCKET_OPTIONS,
+    HTTP_OPTIONS,
+    ENCODINGS,
+    METHODS,
+    action,
+    attribute,
+    codeBlock,
+    component,
+    defineSite,
+    each,
+    exportStatic,
+    html,
+    HtmlRenderer,
+    LiveHtmlServer,
+    LivePage,
+    page,
+    start,
+    state,
+    url,
+    view
+};

package/package.json

@@ -1,31 +1,55 @@
 {
   "name": "redweb",
-  "version": "0.8.0",
+  "version": "0.10.0",
   "description": "A way to quickly set up an express server",
   "main": "index.js",
   "types": "index.d.ts",
-  "scripts": {
-    "pretest": "tsc -p tests/types/tsconfig.json",
-    "test": "npx jest"
+  "scripts": {
+    "pretest": "node scripts/build-live-html-examples.js --check && node scripts/generate-protocol-types.js --check && tsc -p tests/types/tsconfig.json && tsc -p tests/types/tsconfig.standard.json",
+    "prepack": "node scripts/build-live-html-examples.js --check",
+    "example:counter": "node examples/live-html/counter.js",
+    "example:chatroom": "node examples/live-html/chatroom.js",
+    "example:cards": "node examples/live-html/cards.js",
+    "example:components": "node examples/live-html/components.js",
+    "generate:protocol-types": "node scripts/generate-protocol-types.js",
+    "verify:overhead": "node scripts/verify-disabled-overhead.js",
+    "verify:soak": "node --expose-gc scripts/verify-soak.js",
+    "verify:memory": "node scripts/verify-memory-overhead.js",
+    "verify:load": "node scripts/verify-load.js",
+    "verify:recovery": "node --expose-gc scripts/verify-recovery.js",
+    "verify:live-html": "node scripts/build-live-html-examples.js --check && npx jest tests/integration/live-html.integration.test.js --runInBand --coverage=false",
+    "verify:live-html:browser": "node scripts/build-live-html-examples.js --check && node scripts/verify-live-html-browser.js",
+    "verify:live-html:load": "node scripts/build-live-html-examples.js --check && node --expose-gc scripts/verify-live-html-load.js",
+    "verify:live-html:package": "node scripts/verify-live-html-package.js",
+    "test": "npx jest"
   },
   "files": [
     "src/*",
-    "index.d.ts"
+    "client.js",
+    "client.d.ts",
+    "CHANGELOG.md",
+    "index.d.ts",
+    "docs",
+    "examples/live-html"
   ],
   "keywords": [],
   "author": "",
   "license": "ISC",
-  "dependencies": {
-    "@types/express": "^4.17.21",
-    "@types/cors": "2.8.19",
-    "@types/node": "20.19.24",
-    "@types/ws": "^8.18.1",
-    "cors": "^2.8.5",
-    "express": "^4.19.2",
-    "ws": "^8.17.0"
+  "engines": {
+    "node": ">=18"
   },
-  "devDependencies": {
-    "@types/jest": "^29.5.12",
+  "dependencies": {
+    "@types/cors": "2.8.19",
+    "@types/express": "^4.17.21",
+    "@types/node": "20.19.24",
+    "@types/ws": "^8.18.1",
+    "cors": "^2.8.5",
+    "express": "^4.22.2",
+    "redweb-client": "^0.1.0",
+    "ws": "^8.21.3"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.12",
     "jest": "^29.7.0",
     "supertest": "^7.0.0",
     "typescript": "^5.9.3"

package/src/htmx/Html.js

@@ -0,0 +1,133 @@
+const HTML_FRAGMENT = Symbol('redweb.htmlFragment');
+const HTML_ATTRIBUTE = Symbol('redweb.htmlAttribute');
+const HTML_URL = Symbol('redweb.htmlUrl');
+const HTML_RENDERERS = new WeakMap();
+const URL_ATTRIBUTES = new Set(['action', 'background', 'cite', 'data', 'formaction', 'href', 'manifest', 'ping', 'poster', 'src', 'xlink:href']);
+const FORBIDDEN_ATTRIBUTES = new Set(['srcdoc', 'srcset', 'style']);
+const { interpolationContext } = require('./HtmlSyntax');
+const synchronous = require('./synchronous');
+
+function escapeHtml(value) {
+    return String(value ?? '')
+        .replaceAll('&', '&')
+        .replaceAll('<', '&lt;')
+        .replaceAll('>', '&gt;')
+        .replaceAll('"', '&quot;')
+        .replaceAll("'", '&#39;');
+}
+
+function isHtml(value) {
+    if (Array.isArray(value)) return value.every(isHtml);
+    return Boolean(value?.[HTML_FRAGMENT]) || Boolean(value && typeof value === 'object' && HTML_RENDERERS.has(value));
+}
+
+function markHtml(value, toString) {
+    HTML_RENDERERS.set(value, toString);
+    return value;
+}
+
+function trustedHtml(value) {
+    const fragment = {};
+    markHtml(fragment, () => String(value));
+    return Object.freeze(fragment);
+}
+
+function trustedValue(brand, value) {
+    return Object.freeze({ [brand]: true, value: String(value) });
+}
+
+function attribute(value) {
+    if (!['string', 'number', 'bigint', 'boolean'].includes(typeof value)) {
+        throw new TypeError('attribute() requires a string, number, bigint, or boolean.');
+    }
+    return trustedValue(HTML_ATTRIBUTE, value);
+}
+
+function safeUrl(value) {
+    if (typeof value !== 'string' || !value || value !== value.trim() || /[\u0000-\u001f\u007f]/.test(value)) {
+        throw new TypeError('url() requires a non-empty URL without surrounding whitespace or control characters.');
+    }
+    if (value.startsWith('//') || value.includes('\\')) throw new TypeError('url() does not allow protocol-relative or backslash URLs.');
+    const protocol = /^[A-Za-z][A-Za-z0-9+.-]*:/.exec(value)?.[0].toLowerCase();
+    if (protocol && !['http:', 'https:', 'mailto:', 'tel:'].includes(protocol)) {
+        throw new TypeError(`url() does not allow the ${protocol} protocol.`);
+    }
+    return trustedValue(HTML_URL, value);
+}
+
+function renderValue(value) {
+    if (Array.isArray(value)) {
+        if (!isHtml(value)) throw new TypeError('Only arrays of HtmlFragment values can be rendered as HTML.');
+        return value.map(renderValue).join('');
+    }
+    if (HTML_RENDERERS.has(value)) return HTML_RENDERERS.get(value).call(value);
+    return isHtml(value) ? value.toString() : escapeHtml(value);
+}
+
+function renderInterpolation(source, value) {
+    const context = interpolationContext(source);
+    if (context.kind === 'attribute') {
+        const name = context.name;
+        if (name.startsWith('on') || FORBIDDEN_ATTRIBUTES.has(name)) {
+            throw new TypeError(`Dynamic ${name} attributes are not allowed.`);
+        }
+        if (URL_ATTRIBUTES.has(name)) {
+            if (!value?.[HTML_URL]) {
+                if (value?.[HTML_ATTRIBUTE]) throw new TypeError(`The ${name} attribute requires url().`);
+                value = safeUrl(value);
+            }
+        } else if (!value?.[HTML_ATTRIBUTE]) {
+            if (value?.[HTML_URL]) throw new TypeError(`The ${name} attribute requires attribute().`);
+            if (isHtml(value)) throw new TypeError(`The ${name} attribute requires a primitive value.`);
+            value = attribute(value);
+        }
+        return escapeHtml(value.value);
+    }
+    if (context.kind !== 'text') throw new TypeError('html interpolations are only allowed in element text.');
+    if (value?.[HTML_ATTRIBUTE] || value?.[HTML_URL]) {
+        throw new TypeError('attribute() and url() values may only be used in matching quoted attributes.');
+    }
+    return renderValue(value);
+}
+
+function html(strings, ...values) {
+    if (!Array.isArray(strings) || !Object.prototype.hasOwnProperty.call(strings, 'raw')) {
+        throw new TypeError('html must be used as a tagged template literal.');
+    }
+    const rendered = strings.reduce((result, part, index) => {
+        const next = result + part;
+        if (index >= values.length) return next;
+        return next + renderInterpolation(next, values[index]);
+    }, '');
+    return Object.freeze({ [HTML_FRAGMENT]: true, toString: () => rendered });
+}
+
+function each(items, render) {
+    if (!Array.isArray(items)) throw new TypeError('each() requires an array.');
+    if (typeof render !== 'function') throw new TypeError('each() requires a render function.');
+    const fragments = items.map((item, index) => render(item, index));
+    if (!fragments.every(isHtml)) throw new TypeError('each() render functions must return html fragments.');
+    return Object.freeze({ [HTML_FRAGMENT]: true, toString: () => fragments.map(renderValue).join('') });
+}
+
+function codeBlock(code, options = {}) {
+    if (!options || typeof options !== 'object' || Array.isArray(options)) {
+        throw new TypeError('codeBlock() options must be an object.');
+    }
+    const { language = 'text', label = language, highlight } = options;
+    if (typeof language !== 'string' || !/^[A-Za-z0-9_+-]{1,32}$/.test(language)) {
+        throw new TypeError('codeBlock() language must be a safe name of at most 32 characters.');
+    }
+    if (typeof label !== 'string') throw new TypeError('codeBlock() label must be a string.');
+    if (highlight !== undefined && typeof highlight !== 'function') throw new TypeError('codeBlock() highlight must be a function.');
+    const caption = label ? html`<figcaption>${label}</figcaption>` : html``;
+    let content = isHtml(code) ? code : String(code ?? '');
+    if (highlight) {
+        if (isHtml(code)) throw new TypeError('codeBlock() cannot highlight an HtmlFragment.');
+        content = synchronous(highlight(content, language), 'codeBlock() highlight must render synchronously.');
+        if (!isHtml(content)) throw new TypeError('codeBlock() highlight must return an HtmlFragment.');
+    }
+    return html`<figure class="redweb-code">${caption}<pre><code class="${attribute(`language-${language}`)}">${content}</code></pre></figure>`;
+}
+
+module.exports = { attribute, codeBlock, each, escapeHtml, html, isHtml, markHtml, renderValue, safeUrl, trustedHtml };

package/src/htmx/HtmlRenderer.js

@@ -0,0 +1,88 @@
+const { escapeHtml, isHtml, renderValue } = require('./Html');
+const PageAssetLoader = require('./PageAssetLoader');
+const TemplateRenderer = require('./TemplateRenderer');
+const { getStateConfig, getViewMetadata } = require('./metadata');
+
+function serializeJson(value) {
+    return JSON.stringify(value).replaceAll('<', '\\u003c');
+}
+
+function meta(attribute, name, content) {
+    return `<meta ${attribute}="${escapeHtml(name)}" content="${escapeHtml(content)}">`;
+}
+
+class HtmlRenderer {
+    static file(filePath, rootDir, kind) {
+        return new PageAssetLoader().load(filePath, rootDir, kind).content;
+    }
+
+    static template(filePath, rootDir) {
+        return HtmlRenderer.file(filePath, rootDir, 'template');
+    }
+
+    static stylesheet(filePath, rootDir) {
+        return HtmlRenderer.file(filePath, rootDir, 'stylesheet');
+    }
+
+    static render(source, page, options = {}) {
+        if (typeof source !== 'string') throw new TypeError('Page markup must be a string.');
+        if (!options || typeof options !== 'object' || Array.isArray(options)) throw new TypeError('Render options must be an object.');
+        const { live = true } = options;
+        if (typeof live !== 'boolean') throw new TypeError('Render live must be a boolean.');
+        return new TemplateRenderer(source, page, HtmlRenderer.collection, live).render();
+    }
+
+    static collection(page, name, value) {
+        if (!getStateConfig(page.constructor, name)) throw new Error(`Page collection "${name}" is missing @state metadata.`);
+        if (!Array.isArray(value)) throw new TypeError(`Page collection "${name}" must be an array.`);
+        const view = getViewMetadata(page.constructor, name);
+        if (!view) throw new Error(`Page collection "${name}" is missing @view metadata.`);
+        if (page[view.method] !== view.implementation) throw new Error(`View for page collection "${name}" was replaced.`);
+        return value.map((item, index) => {
+            const rendered = view.implementation.call(page, item, index);
+            if (!isHtml(rendered)) throw new TypeError(`View for page collection "${name}" must return html.`);
+            return renderValue(rendered);
+        }).join('');
+    }
+
+    static statePayload(name, value, page) {
+        if (page && getViewMetadata(page.constructor, name)) {
+            return { name, value: HtmlRenderer.collection(page, name, value), html: true };
+        }
+        return { name, value: isHtml(value) ? renderValue(value) : String(value ?? ''), html: isHtml(value) };
+    }
+
+    static head(metadata = {}) {
+        const tags = [];
+        if (metadata.title) tags.push(`<title>${escapeHtml(metadata.title)}</title>`, meta('property', 'og:title', metadata.title), meta('name', 'twitter:title', metadata.title));
+        if (metadata.description) tags.push(meta('name', 'description', metadata.description), meta('property', 'og:description', metadata.description), meta('name', 'twitter:description', metadata.description));
+        if (metadata.canonical) tags.push(`<link rel="canonical" href="${escapeHtml(metadata.canonical)}">`, meta('property', 'og:url', metadata.canonical));
+        if (metadata.image) tags.push(meta('property', 'og:image', metadata.image), meta('name', 'twitter:image', metadata.image));
+        if (metadata.robots) tags.push(meta('name', 'robots', metadata.robots));
+        if (metadata.title || metadata.description || metadata.image) tags.push(meta('name', 'twitter:card', metadata.image ? 'summary_large_image' : 'summary'));
+        return tags.join('');
+    }
+
+    static document(markup, config = null, stylesheets = [], metadata = {}) {
+        const bootstrap = config ? `<script type="application/json" id="__redweb_page">${serializeJson(config)}</script>` +
+            `<script type="module" src="${escapeHtml(config.runtimePath)}"></script>` : '';
+        const links = stylesheets.map(href => `<link rel="stylesheet" href="${escapeHtml(href)}">`).join('');
+        const headMarkup = HtmlRenderer.head(metadata) + links;
+        const body = TemplateRenderer.closingTag(markup, 'body');
+        if (body >= 0) {
+            const head = TemplateRenderer.closingTag(markup, 'head');
+            const insertions = [{ position: body, value: bootstrap }];
+            if (head >= 0) {
+                if (headMarkup) insertions.push({ position: head, value: headMarkup });
+            } else if (headMarkup) {
+                const bodyOpen = TemplateRenderer.openingTag(markup, 'body');
+                insertions.push({ position: Math.max(0, bodyOpen), value: `<head>${headMarkup}</head>` });
+            }
+            return insertions.sort((left, right) => right.position - left.position)
+                .reduce((result, insertion) => result.slice(0, insertion.position) + insertion.value + result.slice(insertion.position), markup);
+        }
+        return `<!doctype html><html><head>${headMarkup}</head><body><main data-rw-root>${markup}</main>${bootstrap}</body></html>`;
+    }
+}
+
+module.exports = HtmlRenderer;

package/src/htmx/HtmlSyntax.js

@@ -0,0 +1,168 @@
+const RAW_TEXT = new Set(['iframe', 'noembed', 'noframes', 'noscript', 'plaintext', 'script', 'style', 'textarea', 'title', 'xmp']);
+
+function isHtmlSpace(character) {
+    return character === ' ' || character === '\t' || character === '\n' || character === '\f' || character === '\r';
+}
+
+function isNonStartMarkup(source, start) {
+    const marker = source[start + 1];
+    if (marker === '!' || marker === '?') return true;
+    return marker === '/' && /[A-Za-z]/.test(source[start + 2]);
+}
+
+function equalsAsciiCaseInsensitive(value, expected) {
+    if (value.length !== expected.length) return false;
+    for (let index = 0; index < value.length; index += 1) {
+        const code = value.charCodeAt(index);
+        const folded = code >= 65 && code <= 90 ? code + 32 : code;
+        if (folded !== expected.charCodeAt(index)) return false;
+    }
+    return true;
+}
+
+function scanTag(source, position) {
+    let state = 'beforeAttribute';
+    let quote;
+    let attributeName = null;
+    let attributeStart = -1;
+    for (; position < source.length; position += 1) {
+        const character = source[position];
+        if (state === 'quotedValue') {
+            if (character === quote) state = 'beforeAttribute';
+            continue;
+        }
+        if (character === '>') return { end: position, state, attributeName };
+        if (state === 'beforeValue') {
+            if (isHtmlSpace(character)) continue;
+            if (character === '"' || character === "'") {
+                quote = character;
+                state = 'quotedValue';
+            } else state = 'unquotedValue';
+        } else if (state === 'beforeAttribute') {
+            if (!isHtmlSpace(character) && character !== '/') {
+                attributeStart = position;
+                state = 'attributeName';
+            }
+        } else if (state === 'attributeName') {
+            if (character === '=') {
+                attributeName = source.slice(attributeStart, position).toLowerCase();
+                state = 'beforeValue';
+            } else if (isHtmlSpace(character)) {
+                attributeName = source.slice(attributeStart, position).toLowerCase();
+                state = 'afterAttributeName';
+            }
+        } else if (state === 'afterAttributeName') {
+            if (character === '=') state = 'beforeValue';
+            else if (!isHtmlSpace(character) && character !== '/') {
+                attributeStart = position;
+                attributeName = null;
+                state = 'attributeName';
+            }
+        } else if (isHtmlSpace(character)) state = 'beforeAttribute';
+    }
+    return { end: -1, state, attributeName };
+}
+
+function tagEnd(source, position) {
+    return scanTag(source, position).end;
+}
+
+function rawClosingTag(source, name, position) {
+    while (true) {
+        const start = source.indexOf('</', position);
+        if (start < 0) return null;
+        const candidate = source.slice(start + 2, start + 2 + name.length);
+        const boundary = source[start + 2 + name.length];
+        if (equalsAsciiCaseInsensitive(candidate, name) && (boundary === '>' || boundary === '/' || isHtmlSpace(boundary))) {
+            const end = tagEnd(source, start + 2 + name.length);
+            if (end >= 0) return { start, end: end + 1 };
+        }
+        position = start + 2;
+    }
+}
+
+function tagLocation(source, target, kind) {
+    let position = 0;
+    while (position < source.length) {
+        const start = source.indexOf('<', position);
+        if (start < 0) return -1;
+        if (source.startsWith('<!--', start)) {
+            const commentEnd = source.indexOf('-->', start + 4);
+            position = commentEnd < 0 ? source.length : commentEnd + 3;
+            continue;
+        }
+        const recognizedMarkup = isNonStartMarkup(source, start);
+        if (!recognizedMarkup && !/[A-Za-z]/.test(source[start + 1])) {
+            position = start + 1;
+            continue;
+        }
+        const end = tagEnd(source, start + 1);
+        if (end < 0) return -1;
+        const tag = source.slice(start, end + 1);
+        const closing = /^<\/([A-Za-z][\w:-]*)/i.exec(tag)?.[1]?.toLowerCase();
+        if (kind === 'closing' && closing === target) return start;
+        const opening = /^<([A-Za-z][\w:-]*)/i.exec(tag)?.[1]?.toLowerCase();
+        if (kind === 'opening' && opening === target) return start;
+        if (opening && RAW_TEXT.has(opening)) {
+            if (opening === 'plaintext') return -1;
+            const close = rawClosingTag(source, opening, end + 1);
+            position = close ? close.end : source.length;
+        } else {
+            position = end + 1;
+        }
+    }
+    return -1;
+}
+
+function interpolationContext(source) {
+    let position = 0;
+    while (position < source.length) {
+        const start = source.indexOf('<', position);
+        if (start < 0) return { kind: 'text' };
+        if (source.startsWith('<!--', start)) {
+            const commentEnd = source.indexOf('-->', start + 4);
+            if (commentEnd < 0) return { kind: 'protected' };
+            position = commentEnd + 3;
+            continue;
+        }
+        const opening = /^<([A-Za-z][\w:-]*)/.exec(source.slice(start));
+        if (opening) {
+            const name = opening[1].toLowerCase();
+            const scanned = scanTag(source, start + opening[0].length);
+            if (scanned.end < 0) {
+                if (scanned.state === 'quotedValue' && scanned.attributeName) {
+                    return { kind: 'attribute', name: scanned.attributeName };
+                }
+                return { kind: 'protected' };
+            }
+            if (RAW_TEXT.has(name)) {
+                if (name === 'plaintext') return { kind: 'protected' };
+                const close = rawClosingTag(source, name, scanned.end + 1);
+                if (!close) return { kind: 'protected' };
+                position = close.end;
+            } else {
+                position = scanned.end + 1;
+            }
+            continue;
+        }
+        if (isNonStartMarkup(source, start)) {
+            const end = tagEnd(source, start + 1);
+            if (end < 0) return { kind: 'protected' };
+            position = end + 1;
+        } else {
+            position = start + 1;
+        }
+    }
+    return { kind: 'text' };
+}
+
+module.exports = {
+    RAW_TEXT,
+    closingTag: (source, target) => tagLocation(source, target, 'closing'),
+    interpolationContext,
+    isHtmlSpace,
+    isNonStartMarkup,
+    openingTag: (source, target) => tagLocation(source, target, 'opening'),
+    rawClosingTag,
+    tagEnd,
+};

package/src/htmx/LiveHtmlServer.js

@@ -0,0 +1,91 @@
+const express = require('express');
+const HttpServer = require('../http/HttpServer');
+const HttpsServer = require('../http/HttpsServer');
+const SocketServer = require('../ws/SocketServer');
+const { PageManager } = require('./PageManager');
+
+class LiveHtmlServer {
+    constructor(options = {}) {
+        if (!options || typeof options !== 'object' || Array.isArray(options)) {
+            throw new TypeError('Live HTML server options must be an object.');
+        }
+        const {
+            pages,
+            templateRoot,
+            livePaths,
+            sessionTtlMs,
+            maxSessions,
+            maxConcurrentRenders,
+            shutdownTimeoutMs = 1000,
+            heartbeat,
+            authenticate,
+            origins,
+            server: suppliedApp,
+            ...httpOptions
+        } = options;
+        const app = suppliedApp === undefined ? express() : suppliedApp;
+        if (!app || typeof app.get !== 'function' || typeof app.use !== 'function') {
+            throw new TypeError('`server` must be an Express-compatible application.');
+        }
+        this.manager = new PageManager({
+            pages,
+            templateRoot,
+            paths: livePaths,
+            sessionTtlMs,
+            maxSessions,
+            maxConcurrentRenders,
+            shutdownTimeoutMs,
+            heartbeat,
+            authenticate,
+            origins,
+            logger: httpOptions.logger,
+        });
+        this.manager.mount(app);
+        const listen = httpOptions.listen ?? true;
+        const ServerClass = httpOptions.ssl ? HttpsServer : HttpServer;
+        this.http = new ServerClass({ ...httpOptions, server: app, listen: this.manager.hasLivePages ? false : listen });
+        if (this.manager.hasLivePages) {
+            const Route = this.manager.route();
+            this.sockets = new SocketServer({
+                server: this.http.server,
+                routes: [Route],
+                listen,
+                port: this.http.port,
+                bind: this.http.bind,
+                listenCallback: this.http.listenCallback,
+                logger: this.http.logger,
+                closeServerOnShutdown: false,
+            });
+        } else {
+            this.sockets = null;
+        }
+        this.app = this.http.app;
+        this.server = this.http.server;
+        this._shutdownPromise = null;
+    }
+
+    shutdown() {
+        if (!this._shutdownPromise) {
+            this._shutdownPromise = this.performShutdown();
+        }
+        return this._shutdownPromise;
+    }
+
+    async performShutdown() {
+        const errors = [];
+        if (this.sockets) {
+            try { await this.sockets.shutdown(); }
+            catch (error) { errors.push(error); }
+        }
+        try { await this.manager.shutdown(); }
+        catch (error) {
+            errors.push(error);
+            if (error?.code === 'LIVE_HTML_SHUTDOWN_TIMEOUT') this.server.closeAllConnections?.();
+        }
+        try { await this.http.shutdown(); }
+        catch (error) { errors.push(error); }
+        if (errors.length) throw new AggregateError(errors, 'Live HTML shutdown failed.');
+    }
+}
+
+module.exports = LiveHtmlServer;