@design.estate/wcctools 6.1.0 → 7.0.0

package/dist_ts/classes.bundlestatus.js

@@ -0,0 +1,110 @@
+import * as plugins from './plugins.js';
+/** The longest time a status request waits for a change before it answers the unchanged status. */
+export const bundleStatusWaitLimitMs = 25_000;
+/** What a status request answers while the board is closed: the server is not serving. */
+export const bundleStatusClosedMessage = 'wcctools: the dev server is not serving the bundle status.';
+/**
+ * The status of the catalog bundles, as tswatch's bundle events report it, for the shell's
+ * `getBundleStatus` requests. Every event raises the revision and answers the requests waiting for
+ * a change. While closed (the server is not serving), requests are refused with a typed error, so
+ * a client backs off as it does for any failed request.
+ */
+export class WccBundleStatusBoard {
+    bundles = new Map();
+    revision = 0;
+    isOpen = false;
+    /** Settles one waiting request: answers the current snapshot, or refuses; each removes itself. */
+    waiters = new Set();
+    /** Starts a run of the server: the bundles of an earlier run are forgotten. */
+    open() {
+        this.bundles.clear();
+        this.isOpen = true;
+        this.changed();
+    }
+    /** Ends the run: every waiting request is refused now, later ones at once. */
+    close() {
+        this.isOpen = false;
+        const refusal = this.createClosedError();
+        for (const settle of [...this.waiters]) {
+            settle(refusal);
+        }
+    }
+    /** The number of requests waiting for a change. */
+    getWaiterCount() {
+        return this.waiters.size;
+    }
+    record(eventArg) {
+        const previous = this.bundles.get(eventArg.name);
+        const status = { name: eventArg.name, state: eventArg.type };
+        switch (eventArg.type) {
+            case 'started':
+                // The latest completed run stays reported while the next one runs
+                if (previous?.durationMs !== undefined) {
+                    status.durationMs = previous.durationMs;
+                }
+                if (previous?.errorMessage !== undefined) {
+                    status.errorMessage = previous.errorMessage;
+                }
+                break;
+            case 'finished':
+                status.durationMs = eventArg.durationMs;
+                break;
+            case 'failed':
+                status.durationMs = eventArg.durationMs;
+                status.errorMessage = eventArg.errorMessage;
+                break;
+        }
+        this.bundles.set(eventArg.name, status);
+        this.changed();
+    }
+    getSnapshot() {
+        return {
+            revision: this.revision,
+            bundles: [...this.bundles.values()].map((statusArg) => ({ ...statusArg })),
+        };
+    }
+    /**
+     * The snapshot once it differs from `afterRevisionArg`, or after the wait limit; at once without
+     * a revision or for a revision that is no longer current. Refused while closed. When
+     * `abortSignalArg` aborts (the client went away), the wait ends at once and releases its timer;
+     * it answers the current snapshot, which the transport drops.
+     */
+    waitForChange(afterRevisionArg, abortSignalArg) {
+        if (!this.isOpen) {
+            return Promise.reject(this.createClosedError());
+        }
+        if (afterRevisionArg === undefined || afterRevisionArg !== this.revision || abortSignalArg?.aborted) {
+            return Promise.resolve(this.getSnapshot());
+        }
+        return new Promise((resolve, reject) => {
+            const settle = (refusalArg) => {
+                clearTimeout(waitLimit);
+                abortSignalArg?.removeEventListener('abort', onAbort);
+                this.waiters.delete(settle);
+                if (refusalArg) {
+                    reject(refusalArg);
+                }
+                else {
+                    resolve(this.getSnapshot());
+                }
+            };
+            const onAbort = () => settle();
+            const waitLimit = setTimeout(() => settle(), bundleStatusWaitLimitMs);
+            abortSignalArg?.addEventListener('abort', onAbort, { once: true });
+            this.waiters.add(settle);
+        });
+    }
+    changed() {
+        this.revision++;
+        this.answerWaiters();
+    }
+    answerWaiters() {
+        for (const settle of [...this.waiters]) {
+            settle();
+        }
+    }
+    createClosedError() {
+        return new plugins.typedrequest.TypedResponseError(bundleStatusClosedMessage);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/classes.devapi.d.ts

@@ -1,10 +1,13 @@
 import * as plugins from './plugins.js';
+import { WccBundleStatusBoard } from './classes.bundlestatus.js';
 /**
  * The typed API the shell reaches on `/wcctools/typedrequest`. Later features register their
  * handlers on `typedrouter`.
  */
 export declare class WccDevApi {
     readonly typedrouter: plugins.typedrequest.TypedRouter<import("@api.global/typedrequest-interfaces").ITypedRequest>;
+    /** The catalog bundles' status, fed with tswatch's bundle events while the server runs. */
+    readonly bundleStatus: WccBundleStatusBoard;
     private serverInfo;
     constructor();
     setServerInfo(infoArg: plugins.interfaces.IWccDevServerInfo): void;

package/dist_ts/classes.devapi.js

@@ -1,10 +1,13 @@
 import * as plugins from './plugins.js';
+import { WccBundleStatusBoard } from './classes.bundlestatus.js';
 /**
  * The typed API the shell reaches on `/wcctools/typedrequest`. Later features register their
  * handlers on `typedrouter`.
  */
 export class WccDevApi {
     typedrouter = new plugins.typedrequest.TypedRouter();
+    /** The catalog bundles' status, fed with tswatch's bundle events while the server runs. */
+    bundleStatus = new WccBundleStatusBoard();
     serverInfo = null;
     constructor() {
         this.typedrouter.addTypedHandler(new plugins.typedrequest.TypedHandler('getDevServerInfo', async () => {
@@ -13,9 +16,13 @@ export class WccDevApi {
             }
             return { ...this.serverInfo };
         }));
+        this.typedrouter.addTypedHandler(new plugins.typedrequest.TypedHandler('getBundleStatus', async (requestArg, typedToolsArg) => {
+            // A client that goes away ends its wait, so no waiter or timer outlives the request
+            return this.bundleStatus.waitForChange(requestArg.afterRevision, typedToolsArg?.abortSignal);
+        }));
     }
     setServerInfo(infoArg) {
         this.serverInfo = { ...infoArg };
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xhc3Nlcy5kZXZhcGkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9jbGFzc2VzLmRldmFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssT0FBTyxNQUFNLGNBQWMsQ0FBQztBQUV4Qzs7O0dBR0c7QUFDSCxNQUFNLE9BQU8sU0FBUztJQUNKLFdBQVcsR0FBRyxJQUFJLE9BQU8sQ0FBQyxZQUFZLENBQUMsV0FBVyxFQUFFLENBQUM7SUFDN0QsVUFBVSxHQUFnRCxJQUFJLENBQUM7SUFFdkU7UUFDRSxJQUFJLENBQUMsV0FBVyxDQUFDLGVBQWUsQ0FDOUIsSUFBSSxPQUFPLENBQUMsWUFBWSxDQUFDLFlBQVksQ0FBMkMsa0JBQWtCLEVBQUUsS0FBSyxJQUFJLEVBQUU7WUFDN0csSUFBSSxDQUFDLElBQUksQ0FBQyxVQUFVLEVBQUUsQ0FBQztnQkFDckIsTUFBTSxJQUFJLEtBQUssQ0FBQyxpQ0FBaUMsQ0FBQyxDQUFDO1lBQ3JELENBQUM7WUFDRCxPQUFPLEVBQUUsR0FBRyxJQUFJLENBQUMsVUFBVSxFQUFFLENBQUM7UUFDaEMsQ0FBQyxDQUFDLENBQ0gsQ0FBQztJQUNKLENBQUM7SUFFTSxhQUFhLENBQUMsT0FBNkM7UUFDaEUsSUFBSSxDQUFDLFVBQVUsR0FBRyxFQUFFLEdBQUcsT0FBTyxFQUFFLENBQUM7SUFDbkMsQ0FBQztDQUNGIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xhc3Nlcy5kZXZhcGkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9jbGFzc2VzLmRldmFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssT0FBTyxNQUFNLGNBQWMsQ0FBQztBQUN4QyxPQUFPLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQztBQUVqRTs7O0dBR0c7QUFDSCxNQUFNLE9BQU8sU0FBUztJQUNKLFdBQVcsR0FBRyxJQUFJLE9BQU8sQ0FBQyxZQUFZLENBQUMsV0FBVyxFQUFFLENBQUM7SUFDckUsMkZBQTJGO0lBQzNFLFlBQVksR0FBRyxJQUFJLG9CQUFvQixFQUFFLENBQUM7SUFDbEQsVUFBVSxHQUFnRCxJQUFJLENBQUM7SUFFdkU7UUFDRSxJQUFJLENBQUMsV0FBVyxDQUFDLGVBQWUsQ0FDOUIsSUFBSSxPQUFPLENBQUMsWUFBWSxDQUFDLFlBQVksQ0FBMkMsa0JBQWtCLEVBQUUsS0FBSyxJQUFJLEVBQUU7WUFDN0csSUFBSSxDQUFDLElBQUksQ0FBQyxVQUFVLEVBQUUsQ0FBQztnQkFDckIsTUFBTSxJQUFJLEtBQUssQ0FBQyxpQ0FBaUMsQ0FBQyxDQUFDO1lBQ3JELENBQUM7WUFDRCxPQUFPLEVBQUUsR0FBRyxJQUFJLENBQUMsVUFBVSxFQUFFLENBQUM7UUFDaEMsQ0FBQyxDQUFDLENBQ0gsQ0FBQztRQUNGLElBQUksQ0FBQyxXQUFXLENBQUMsZUFBZSxDQUM5QixJQUFJLE9BQU8sQ0FBQyxZQUFZLENBQUMsWUFBWSxDQUEwQyxpQkFBaUIsRUFBRSxLQUFLLEVBQUUsVUFBVSxFQUFFLGFBQWEsRUFBRSxFQUFFO1lBQ3BJLG9GQUFvRjtZQUNwRixPQUFPLElBQUksQ0FBQyxZQUFZLENBQUMsYUFBYSxDQUFDLFVBQVUsQ0FBQyxhQUFhLEVBQUUsYUFBYSxFQUFFLFdBQVcsQ0FBQyxDQUFDO1FBQy9GLENBQUMsQ0FBQyxDQUNILENBQUM7SUFDSixDQUFDO0lBRU0sYUFBYSxDQUFDLE9BQTZDO1FBQ2hFLElBQUksQ0FBQyxVQUFVLEdBQUcsRUFBRSxHQUFHLE9BQU8sRUFBRSxDQUFDO0lBQ25DLENBQUM7Q0FDRiJ9

package/dist_ts/classes.devserver.d.ts

@@ -1,42 +1,93 @@
 import { WccDevApi } from './classes.devapi.js';
+import { WccHostPolicy } from './classes.hostpolicy.js';
+import { WccCaptureService } from './capture/index.js';
 export interface IWccDevServerOptions {
     /** Port to listen on; overrides the tswatch configuration. 0 picks a free port. */
     port?: number;
+    /**
+     * The project directory: its tswatch configuration, package.json and catalog are served, and
+     * tswatch bundles and watches in it (default: `process.cwd()` when the server is constructed).
+     */
+    cwd?: string;
+    /**
+     * The interface address to listen on (default `127.0.0.1`, this machine only). `0.0.0.0` or
+     * `::` listen on every interface; the machine's interface addresses are then allowed hosts.
+     */
+    host?: string;
+    /** Further hostnames or addresses the server answers, besides localhost and the listen address. */
+    allowedHosts?: readonly string[];
 }
 export interface IWccDevServerAddress {
     port: number;
     /** The shell's address. */
     url: string;
+    /** The interface address the server listens on. */
+    host: string;
+    /** The hostnames the server answers; requests for any other Host are refused. */
+    allowedHosts: string[];
 }
 /**
- * `wcctools dev`: bundles the catalog of the current project with tswatch, as its
- * `@git.zone/tswatch` configuration (or the `element` preset) describes, and serves on one port:
+ * `wcctools dev`: bundles the catalog of a project with tswatch, as its `@git.zone/tswatch`
+ * configuration (or the `element` preset) describes, and serves on one port:
  *
  * - the shell on `/wcctools/` (`/` redirects there) and its routes `/wcctools-route/...`,
- * - the typed API on `/wcctools/typedrequest`,
+ * - the typed API on `/wcctools/typedrequest`, including the bundles' status,
  * - the catalog's preview document and bundle from the tswatch serve directory on every other
- *   path, with live reload that reloads only the preview document.
+ *   path, with live reload that reloads only the preview document,
+ * - captures of single demos in a headless browser (`capture`, also on the typed API).
+ *
+ * It listens on loopback unless told otherwise and admits requests as its `WccHostPolicy`
+ * describes: only the hosts it serves, and state-changing requests and WebSockets only from its
+ * own origin.
  *
- * tswatch resolves its paths against the process's working directory, so the server serves the
- * project the process runs in.
+ * The server owns no process lifecycle: while it runs, a process shutdown through smartexit's
+ * `ProcessLifecycle` stops it. The entry point installs that lifecycle with
+ * `getShutdownTimeoutMs()`.
  */
 export declare class WccDevServer {
     private readonly options;
     /** The typed API on `/wcctools/typedrequest`; register further handlers before `start()`. */
     readonly api: WccDevApi;
-    private tsWatch;
+    /** Screenshots and interaction captures of the served catalog; available while the server runs. */
+    readonly capture: WccCaptureService;
+    /** Who may talk to the server: the hosts it answers and the origin of its requests. */
+    readonly hostPolicy: WccHostPolicy;
+    /** The project directory everything resolves against. */
+    readonly cwd: string;
+    /** The project's tswatch configuration, or the `element` preset; read once, on construction. */
+    private readonly config;
+    /** Bundling and watching stay tswatch's; its own server stays off. */
+    private readonly tsWatch;
     private typedServer;
-    private readonly smartExit;
+    /** Stops the server on a process shutdown; registered by start(), released by stop(). */
+    private smartExit;
+    private unsubscribeBundleEvents;
+    private running;
+    private starting;
+    private stopping;
     constructor(options?: IWccDevServerOptions);
+    /**
+     * The shutdown deadline the server needs, tswatch's: the entry point installs smartexit's
+     * `ProcessLifecycle` with it, so every watcher command keeps its full grace period.
+     */
+    getShutdownTimeoutMs(): number;
+    /**
+     * Bundles the catalog, starts the watchers and serves. Refused while the server runs or stops;
+     * the server starts again after stop().
+     */
     start(): Promise<IWccDevServerAddress>;
-    /** Stops the server, then tswatch's bundling and watching. */
+    /**
+     * Stops the server and tswatch's bundling and watching, and releases everything start()
+     * registered. A stop during start() waits for the start to settle first; concurrent and
+     * repeated calls share one stop.
+     */
     stop(): Promise<void>;
+    private release;
+    private startServing;
+    private getElementPreset;
     /**
-     * The shell: the prebuilt shell bundle and the typed API.
-     *
-     * Seam for side-effecting APIs (assistant, capture, standards fixes): before any handler with
-     * side effects is registered here, add a `websocketAdmission`/`requestAdmission` that accepts
-     * only the shell's own origin, and keep surface mode's strict authority validation.
+     * The shell: the prebuilt shell bundle and the typed API, whose requests (captures among them)
+     * are admitted only from the server's own origin.
      */
     private createShellSurface;
     /**

package/dist_ts/classes.devserver.js

@@ -2,6 +2,8 @@ import * as plugins from './plugins.js';
 import * as paths from './paths.js';
 import { commitinfo } from './00_commitinfo_data.js';
 import { WccDevApi } from './classes.devapi.js';
+import { WccHostPolicy, defaultListenHost, formatUrlHost } from './classes.hostpolicy.js';
+import { WccCaptureService } from './capture/index.js';
 import { loadShellContent, shellPathPrefix } from './shellcontent.js';
 /** tswatch's default port and serve directory, used when the configuration names none. */
 const defaultPort = 3002;
@@ -11,83 +13,182 @@ const securityHeaders = {
     crossOriginOpenerPolicy: 'same-origin',
     crossOriginEmbedderPolicy: 'require-corp',
 };
+/** Every surface takes every hostname: the server-wide Host admission refuses the ones it does not serve. */
 const acceptAnyHostname = () => true;
 /**
- * `wcctools dev`: bundles the catalog of the current project with tswatch, as its
- * `@git.zone/tswatch` configuration (or the `element` preset) describes, and serves on one port:
+ * `wcctools dev`: bundles the catalog of a project with tswatch, as its `@git.zone/tswatch`
+ * configuration (or the `element` preset) describes, and serves on one port:
  *
  * - the shell on `/wcctools/` (`/` redirects there) and its routes `/wcctools-route/...`,
- * - the typed API on `/wcctools/typedrequest`,
+ * - the typed API on `/wcctools/typedrequest`, including the bundles' status,
  * - the catalog's preview document and bundle from the tswatch serve directory on every other
- *   path, with live reload that reloads only the preview document.
+ *   path, with live reload that reloads only the preview document,
+ * - captures of single demos in a headless browser (`capture`, also on the typed API).
  *
- * tswatch resolves its paths against the process's working directory, so the server serves the
- * project the process runs in.
+ * It listens on loopback unless told otherwise and admits requests as its `WccHostPolicy`
+ * describes: only the hosts it serves, and state-changing requests and WebSockets only from its
+ * own origin.
+ *
+ * The server owns no process lifecycle: while it runs, a process shutdown through smartexit's
+ * `ProcessLifecycle` stops it. The entry point installs that lifecycle with
+ * `getShutdownTimeoutMs()`.
  */
 export class WccDevServer {
     options;
     /** The typed API on `/wcctools/typedrequest`; register further handlers before `start()`. */
     api = new WccDevApi();
-    tsWatch = null;
+    /** Screenshots and interaction captures of the served catalog; available while the server runs. */
+    capture;
+    /** Who may talk to the server: the hosts it answers and the origin of its requests. */
+    hostPolicy;
+    /** The project directory everything resolves against. */
+    cwd;
+    /** The project's tswatch configuration, or the `element` preset; read once, on construction. */
+    config;
+    /** Bundling and watching stay tswatch's; its own server stays off. */
+    tsWatch;
     typedServer = null;
-    smartExit = new plugins.smartexit.SmartExit({ silent: true });
+    /** Stops the server on a process shutdown; registered by start(), released by stop(). */
+    smartExit = null;
+    unsubscribeBundleEvents = null;
+    running = false;
+    starting = null;
+    stopping = null;
     constructor(options = {}) {
         this.options = options;
-        this.smartExit.addCleanupFunction(() => this.stop());
+        this.cwd = plugins.path.resolve(options.cwd ?? process.cwd());
+        const configHandler = new plugins.tswatch.ConfigHandler(this.cwd);
+        this.config = configHandler.loadConfig() ?? this.getElementPreset(configHandler);
+        this.tsWatch = new plugins.tswatch.TsWatch({ ...this.config, server: { enabled: false } }, { cwd: this.cwd });
+        this.hostPolicy = new WccHostPolicy({ listenHost: options.host ?? defaultListenHost, allowedHosts: options.allowedHosts });
+        this.capture = new WccCaptureService(this.api.bundleStatus);
+        this.capture.addTypedHandlers(this.api.typedrouter);
     }
+    /**
+     * The shutdown deadline the server needs, tswatch's: the entry point installs smartexit's
+     * `ProcessLifecycle` with it, so every watcher command keeps its full grace period.
+     */
+    getShutdownTimeoutMs() {
+        return this.tsWatch.getShutdownTimeoutMs();
+    }
+    /**
+     * Bundles the catalog, starts the watchers and serves. Refused while the server runs or stops;
+     * the server starts again after stop().
+     */
     async start() {
-        if (this.typedServer) {
-            throw new Error('wcctools: the dev server is already started.');
+        if (this.running || this.stopping) {
+            throw new Error('wcctools: the dev server is already started or still stopping.');
+        }
+        this.running = true;
+        // A process shutdown stops the server from here on, also while it is still starting
+        const smartExit = new plugins.smartexit.SmartExit({ silent: true });
+        smartExit.addCleanupFunction(() => this.stop());
+        this.smartExit = smartExit;
+        const starting = this.startServing();
+        this.starting = starting;
+        try {
+            const address = await starting;
+            if (this.stopping) {
+                throw new Error('wcctools: the dev server was stopped while starting.');
+            }
+            return address;
+        }
+        catch (error) {
+            // A start that failed halfway releases what it opened
+            await this.stop();
+            throw error;
+        }
+        finally {
+            if (this.starting === starting) {
+                this.starting = null;
+            }
+        }
+    }
+    /**
+     * Stops the server and tswatch's bundling and watching, and releases everything start()
+     * registered. A stop during start() waits for the start to settle first; concurrent and
+     * repeated calls share one stop.
+     */
+    stop() {
+        this.stopping ??= this.release().finally(() => {
+            this.stopping = null;
+        });
+        return this.stopping;
+    }
+    async release() {
+        await this.starting?.catch(() => undefined);
+        const smartExit = this.smartExit;
+        const typedServer = this.typedServer;
+        const unsubscribeBundleEvents = this.unsubscribeBundleEvents;
+        this.smartExit = null;
+        this.typedServer = null;
+        this.unsubscribeBundleEvents = null;
+        smartExit?.deregister();
+        // Status requests waiting for a change are refused now, so none holds the server's stop, and
+        // requests until the server stops listening are refused too: the shell backs off
+        this.api.bundleStatus.close();
+        try {
+            // Captures end and the capture browser closes before the server stops answering its pages
+            await this.capture.close();
+            await typedServer?.stop();
+        }
+        finally {
+            this.hostPolicy.setPort(null);
+            try {
+                await this.tsWatch.stop();
+            }
+            finally {
+                unsubscribeBundleEvents?.();
+                this.running = false;
+            }
         }
-        const cwd = process.cwd();
-        const configHandler = new plugins.tswatch.ConfigHandler(cwd);
-        const config = configHandler.loadConfig() ?? configHandler.getPreset('element');
-        const serveDir = plugins.path.resolve(cwd, config.server?.serveDir ?? defaultServeDir);
-        const port = this.options.port ?? config.server?.port ?? defaultPort;
+    }
+    async startServing() {
+        const serveDir = plugins.path.resolve(this.cwd, this.config.server?.serveDir ?? defaultServeDir);
+        const port = this.options.port ?? this.config.server?.port ?? defaultPort;
         // The preview surface watches the serve directory, which must exist before the first bundle
         await plugins.fs.mkdir(serveDir, { recursive: true });
         this.api.setServerInfo({
             wcctoolsVersion: commitinfo.version,
-            projectName: await this.readProjectName(cwd),
+            projectName: await this.readProjectName(),
         });
+        const surfaces = [await this.createShellSurface(), this.createPreviewSurface(serveDir)];
         const typedServer = new plugins.typedserver.TypedServer({
             cors: false,
             port,
-            surfaces: [
-                await this.createShellSurface(),
-                this.createPreviewSurface(serveDir),
-            ],
+            listenHostname: this.hostPolicy.listenHost,
+            // Requests and WebSocket upgrades for a Host the server does not serve are refused
+            requestAdmission: this.hostPolicy.admitHost,
+            websocketAdmission: this.hostPolicy.admitHost,
+            surfaces,
         });
         this.typedServer = typedServer;
-        // Bundling and watching stay tswatch's; its own server stays off
-        this.tsWatch = new plugins.tswatch.TsWatch({ ...config, server: { enabled: false } });
-        try {
-            await this.tsWatch.start();
-            await typedServer.start();
-        }
-        catch (error) {
-            await this.stop();
-            throw error;
-        }
+        this.api.bundleStatus.open();
+        const bundleStatus = this.api.bundleStatus;
+        this.unsubscribeBundleEvents = this.tsWatch.onBundleEvent((eventArg) => bundleStatus.record(eventArg));
+        // The initial bundles run here; a failed one is reported in the bundle status
+        await this.tsWatch.start();
+        await typedServer.start();
         const boundPort = typedServer.listeningPort ?? port;
-        return { port: boundPort, url: `http://localhost:${boundPort}${shellPathPrefix}/` };
+        this.hostPolicy.setPort(boundPort);
+        this.capture.open(`http://${formatUrlHost(this.hostPolicy.getLocalHost())}:${boundPort}`);
+        return {
+            port: boundPort,
+            url: `http://${formatUrlHost(this.hostPolicy.getDisplayHost())}:${boundPort}${shellPathPrefix}/`,
+            host: this.hostPolicy.listenHost,
+            allowedHosts: [...this.hostPolicy.allowedHostnames],
+        };
     }
-    /** Stops the server, then tswatch's bundling and watching. */
-    async stop() {
-        const typedServer = this.typedServer;
-        const tsWatch = this.tsWatch;
-        this.typedServer = null;
-        this.tsWatch = null;
-        this.smartExit.deregister();
-        await typedServer?.stop();
-        await tsWatch?.stop();
+    getElementPreset(configHandlerArg) {
+        const preset = configHandlerArg.getPreset('element');
+        if (!preset) {
+            throw new Error('wcctools: tswatch provides no `element` preset.');
+        }
+        return preset;
     }
     /**
-     * The shell: the prebuilt shell bundle and the typed API.
-     *
-     * Seam for side-effecting APIs (assistant, capture, standards fixes): before any handler with
-     * side effects is registered here, add a `websocketAdmission`/`requestAdmission` that accepts
-     * only the shell's own origin, and keep surface mode's strict authority validation.
+     * The shell: the prebuilt shell bundle and the typed API, whose requests (captures among them)
+     * are admitted only from the server's own origin.
      */
     async createShellSurface() {
         return {
@@ -100,6 +201,8 @@ export class WccDevServer {
             spaFallback: true,
             httpTypedRouter: this.api.typedrouter,
             typedRequestPath: `${shellPathPrefix}/typedrequest`,
+            requestAdmission: this.hostPolicy.admitRequestOrigin,
+            websocketAdmission: this.hostPolicy.admitWebsocketOrigin,
             noCache: true,
             securityHeaders,
         };
@@ -122,8 +225,10 @@ export class WccDevServer {
             watch: true,
             // Lets the reload client get pushed changes instead of polling
             websocketTypedRouter: new plugins.typedrequest.TypedRouter(),
-            // As tswatch serves catalogs
-            cors: true,
+            requestAdmission: this.hostPolicy.admitRequestOrigin,
+            websocketAdmission: this.hostPolicy.admitWebsocketOrigin,
+            // Shell and preview share one origin, so no other origin may read the catalog
+            cors: false,
             httpHandler: async (contextArg) => {
                 if (contextArg.path === '/' && (contextArg.method === 'GET' || contextArg.method === 'HEAD')) {
                     return new Response(null, { status: 302, headers: { Location: `${shellPathPrefix}/` } });
@@ -134,9 +239,9 @@ export class WccDevServer {
             securityHeaders,
         };
     }
-    async readProjectName(cwdArg) {
-        const packageJson = JSON.parse(await plugins.fs.readFile(plugins.path.join(cwdArg, 'package.json'), 'utf8'));
-        return packageJson.name ?? plugins.path.basename(cwdArg);
+    async readProjectName() {
+        const packageJson = JSON.parse(await plugins.fs.readFile(plugins.path.join(this.cwd, 'package.json'), 'utf8'));
+        return packageJson.name ?? plugins.path.basename(this.cwd);
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.devserver.js","sourceRoot":"","sources":["../../ts/classes.devserver.ts"],"names":[],"mappings":"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"}

package/dist_ts/classes.hostpolicy.d.ts

@@ -0,0 +1,63 @@
+import * as plugins from './plugins.js';
+type TRequestContext = plugins.typedserver.IRequestContext;
+type TAdmissionResult = plugins.typedserver.TRequestAdmissionResult;
+/** The interface address `wcctools dev` listens on unless told otherwise. */
+export declare const defaultListenHost = "127.0.0.1";
+/** Canonical form of a hostname: lower case, IPv6 without brackets, no trailing dot. */
+export declare const normalizeHostname: (hostnameArg: string) => string;
+/** Whether the address is the wildcard address of all interfaces. */
+export declare const isWildcardHost: (hostArg: string) => boolean;
+/** Whether a peer address is a loopback address (IPv4, IPv6 or IPv4-mapped IPv6). */
+export declare const isLoopbackAddress: (addressArg: string) => boolean;
+/** A hostname as it appears in a URL: IPv6 addresses in brackets. */
+export declare const formatUrlHost: (hostnameArg: string) => string;
+/** An invalid `--host` or `--allowed-host` value. */
+export declare class WccHostPolicyError extends Error {
+    constructor(messageArg: string);
+}
+export interface IWccHostPolicyOptions {
+    /** The interface address the server listens on. */
+    listenHost: string;
+    /** Further hostnames or addresses the server answers (`--allowed-host`). */
+    allowedHosts?: readonly string[];
+}
+/**
+ * Who may talk to a `wcctools dev` server. The server listens on loopback unless told otherwise
+ * and answers only the hostnames it serves: the loopback names, the address it listens on, the
+ * machine's interface addresses when it listens on all of them, and the hosts allowed explicitly.
+ * Every other Host is refused, which defeats DNS rebinding. Requests that can change state
+ * (any method but GET, HEAD and OPTIONS) and WebSocket connections are further admitted only from
+ * the server's own origin, so other web pages cannot drive the API; a request without an Origin
+ * is admitted only from a loopback peer (local tools, such as the CLI and tests).
+ */
+export declare class WccHostPolicy {
+    /** The canonical hostnames the server answers. */
+    readonly allowedHostnames: ReadonlySet<string>;
+    readonly listenHost: string;
+    private port;
+    constructor(optionsArg: IWccHostPolicyOptions);
+    /** A hostname or address, as a URL would carry it; anything else is refused. */
+    private static parseHost;
+    /** Every address of the machine's network interfaces. */
+    private static getInterfaceAddresses;
+    /** The port the server listens on, once it does: origins are compared against it. */
+    setPort(portArg: number | null): void;
+    /**
+     * The host the server's own tools reach it on: the loopback address when it listens on all
+     * interfaces or on loopback, otherwise the address it listens on.
+     */
+    getLocalHost(): string;
+    /** The host shown to the user: `localhost` for a loopback or all-interface server. */
+    getDisplayHost(): string;
+    /** Server-wide HTTP and WebSocket admission: the Host must be one the server answers. */
+    readonly admitHost: (contextArg: TRequestContext) => TAdmissionResult;
+    /** Surface HTTP admission: a request that can change state must come from the server's origin. */
+    readonly admitRequestOrigin: (contextArg: TRequestContext) => TAdmissionResult;
+    /** Surface WebSocket admission: a connection must come from the server's origin. */
+    readonly admitWebsocketOrigin: (contextArg: TRequestContext) => TAdmissionResult;
+    /** Whether an Origin header names this server: http, an allowed host and the server's port. */
+    isOwnOrigin(originArg: string): boolean;
+    private admitOrigin;
+    private refuse;
+}
+export {};