@xingular/harness 1.0.0 → 1.2.0

package/dist/sdk/agents/profiles.d.ts

@@ -0,0 +1,81 @@
+import { type Effort } from "../core/effort.js";
+export declare const PROFILE_NAME: RegExp;
+export declare const PROFILE_COLORS: readonly ["blue", "green", "yellow", "red", "magenta", "cyan", "orange", "purple"];
+export type ProfileColor = (typeof PROFILE_COLORS)[number];
+export type ProfileSource = 'builtin' | 'global' | 'project' | 'variant';
+/** Where a person's own profile file lives. */
+export type ProfileScope = 'global' | 'project';
+/** Which variant a profile's subagent runs: a scope's head or version, none, or the parent's (null). */
+export type ProfileVariant = {
+    scope: string;
+    version: string | null;
+} | 'none' | null;
+export interface AgentProfile {
+    name: string;
+    description: string;
+    color: ProfileColor;
+    /** The role instructions: the file's body. */
+    instructions: string;
+    /** Tool allowlist; null keeps every tool the parent has. */
+    tools: string[] | null;
+    /** Plugin ids whose contributions the subagent keeps; null keeps all. Required plugins always stay. */
+    plugins: string[] | null;
+    variant: ProfileVariant;
+    model: string | null;
+    effort: Effort | null;
+    source: ProfileSource;
+    /** The file it was read from; null for built-ins. */
+    path: string | null;
+}
+export interface ProfileProblem {
+    name: string;
+    source: ProfileSource;
+    path: string;
+    error: string;
+}
+export interface ProfileListing {
+    profiles: AgentProfile[];
+    problems: ProfileProblem[];
+}
+/** The built-in profile definitions, before a source is attached. */
+export type ProfileDefinition = Omit<AgentProfile, 'source' | 'path'>;
+/** Nearest folder above `cwd` that holds `.git`, or `cwd` itself. */
+export declare function projectRoot(cwd: string): string;
+export declare function profileDirs(root: string, cwd?: string | null): {
+    global: string;
+    project: string | null;
+};
+export declare function parseVariant(value: unknown): ProfileVariant;
+export declare function formatVariant(variant: ProfileVariant): string | null;
+/** Reads one profile file. Throws an `invalid_request` error that names what is wrong. */
+export declare function parseProfile(text: string, name: string, source: ProfileSource, path: string | null): AgentProfile;
+/** The file text for a profile, as `createProfile` writes it. */
+export declare function profileText(profile: ProfileDefinition): string;
+/**
+ * Every profile a session in `cwd` can use. An unreadable file is reported in `problems`; it hides
+ * nothing, so a broken project file leaves the global or built-in profile of that name in force.
+ */
+export declare function listProfiles(root: string, cwd?: string | null, variantDir?: string | null): ProfileListing;
+export declare function resolveProfile(root: string, cwd: string | null | undefined, name: string, variantDir?: string | null): AgentProfile | null;
+/** Writes a new profile file from the template, or a copy of `from`. Refuses to overwrite one. */
+export declare function createProfile(root: string, cwd: string | null | undefined, input: {
+    name: string;
+    scope: ProfileScope;
+    from?: string | null;
+}): AgentProfile;
+/** Deletes a person's own profile file. Built-ins and variant subagents cannot be removed here. */
+export declare function removeProfile(root: string, cwd: string | null | undefined, input: {
+    name: string;
+    scope: ProfileScope;
+}): void;
+/** Where the profile list sits among the prompt sections: the slot a variant's subagents used. */
+export declare const PROFILE_SECTION_ORDER = 64;
+/** The prompt section that lists the profiles a run can start subagents from. */
+export declare function profileSection(root: string, cwd: string | null | undefined, variantDir?: string | null, planResearchOnly?: boolean): {
+    id: string;
+    title: string;
+    body: string;
+    budget: number;
+    order: number;
+    dynamic: true;
+};

package/dist/sdk/agents/profiles.js

@@ -0,0 +1,226 @@
+// Agent profiles (PROP-0029): named bundles a subagent starts from, with its instructions, colour,
+// tools, plugins, variant, model and effort. They come from four places, later ones winning:
+// built-ins in code, `<data root>/agents/*.md`, `<project>/.xingular/agents/*.md`; a variant's own
+// c5 subagents fill in names nobody else took. Profiles only narrow what the parent has.
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { EFFORTS } from "../core/effort.js";
+import { invalid, notFound } from "../core/errors.js";
+import { parse, serialize } from "../core/frontmatter.js";
+import { atomicWrite } from "../core/fs.js";
+import { subagentOf } from "../variant/materialise.js";
+import { BUILTIN_PROFILES } from "./builtin.js";
+import { planResearchProfile } from "./planResearch.js";
+export const PROFILE_NAME = /^[a-z0-9][a-z0-9_-]*$/;
+export const PROFILE_COLORS = ['blue', 'green', 'yellow', 'red', 'magenta', 'cyan', 'orange', 'purple'];
+/** Nearest folder above `cwd` that holds `.git`, or `cwd` itself. */
+export function projectRoot(cwd) {
+    let dir = cwd;
+    for (;;) {
+        if (existsSync(join(dir, '.git')))
+            return dir;
+        const parent = dirname(dir);
+        if (parent === dir)
+            return cwd;
+        dir = parent;
+    }
+}
+export function profileDirs(root, cwd) {
+    return { global: join(root, 'agents'), project: cwd ? join(projectRoot(cwd), '.xingular', 'agents') : null };
+}
+function stringList(value, field) {
+    if (value === undefined || value === null)
+        return null;
+    const list = typeof value === 'string' ? value.split(/[\s,]+/u) : value;
+    if (!Array.isArray(list) || list.some(item => typeof item !== 'string'))
+        throw invalid(`${field} must be a list of names.`);
+    return [...new Set(list.map(item => item.trim()).filter(Boolean))];
+}
+function optionalText(value, field) {
+    if (value === undefined || value === null || value === '')
+        return null;
+    if (typeof value !== 'string')
+        throw invalid(`${field} must be text.`);
+    return value.trim() || null;
+}
+export function parseVariant(value) {
+    const text = optionalText(value, 'variant');
+    if (!text)
+        return null;
+    if (text === 'none')
+        return 'none';
+    const [scope, version, ...rest] = text.split('@');
+    if (!scope || rest.length || (version !== undefined && !version))
+        throw invalid('variant must be <scope>, <scope>@<version> or none.');
+    return { scope, version: version ?? null };
+}
+export function formatVariant(variant) {
+    if (!variant)
+        return null;
+    if (variant === 'none')
+        return 'none';
+    return variant.version ? `${variant.scope}@${variant.version}` : variant.scope;
+}
+/** Reads one profile file. Throws an `invalid_request` error that names what is wrong. */
+export function parseProfile(text, name, source, path) {
+    if (!PROFILE_NAME.test(name))
+        throw invalid('A profile name uses lowercase letters, digits, - and _, and starts with a letter or digit.');
+    const parsed = parse(text);
+    if (!parsed)
+        throw invalid('The profile needs a frontmatter block between --- lines.');
+    const front = parsed.front;
+    if (front.name !== undefined && front.name !== name)
+        throw invalid(`The file is named ${name} but its frontmatter says ${String(front.name)}.`);
+    const description = optionalText(front.description, 'description');
+    if (!description)
+        throw invalid('The profile needs a description.');
+    const color = optionalText(front.color, 'color') ?? 'blue';
+    if (!PROFILE_COLORS.includes(color))
+        throw invalid(`color must be one of ${PROFILE_COLORS.join(', ')}.`);
+    const effort = optionalText(front.effort, 'effort');
+    if (effort && !EFFORTS.includes(effort))
+        throw invalid(`effort must be one of ${EFFORTS.join(', ')}.`);
+    return {
+        name, description, color: color, instructions: parsed.body.trim(),
+        tools: stringList(front.tools, 'tools'), plugins: stringList(front.plugins, 'plugins'),
+        variant: parseVariant(front.variant), model: optionalText(front.model, 'model'), effort: effort,
+        source, path
+    };
+}
+/** The file text for a profile, as `createProfile` writes it. */
+export function profileText(profile) {
+    const front = { name: profile.name, description: profile.description, color: profile.color };
+    if (profile.tools)
+        front.tools = profile.tools;
+    if (profile.plugins)
+        front.plugins = profile.plugins;
+    const variant = formatVariant(profile.variant);
+    if (variant)
+        front.variant = variant;
+    if (profile.model)
+        front.model = profile.model;
+    if (profile.effort)
+        front.effort = profile.effort;
+    return serialize(front, profile.instructions);
+}
+function readFolder(dir, source, into, problems) {
+    if (!dir || !existsSync(dir))
+        return;
+    for (const file of readdirSync(dir).filter(entry => entry.endsWith('.md')).sort()) {
+        const path = join(dir, file);
+        const name = file.slice(0, -3);
+        try {
+            if (!statSync(path).isFile())
+                continue;
+            into.set(name, parseProfile(readFileSync(path, 'utf8'), name, source, path));
+        }
+        catch (error) {
+            problems.push({ name, source, path, error: error instanceof Error ? error.message : String(error) });
+        }
+    }
+}
+function variantDefinitions(variantDir) {
+    const folder = variantDir ? join(variantDir, 'sub_agents') : null;
+    if (!folder || !existsSync(folder))
+        return [];
+    return readdirSync(folder).sort().flatMap(name => {
+        const definition = subagentOf(variantDir, name);
+        if (!definition)
+            return [];
+        return [{
+                name, description: definition.description || name, color: 'blue', instructions: definition.instructions || definition.description,
+                tools: null, plugins: null, variant: null, model: null, effort: null,
+                source: 'variant', path: join(folder, name, 'AGENT.md')
+            }];
+    });
+}
+/**
+ * Every profile a session in `cwd` can use. An unreadable file is reported in `problems`; it hides
+ * nothing, so a broken project file leaves the global or built-in profile of that name in force.
+ */
+export function listProfiles(root, cwd, variantDir) {
+    const profiles = new Map();
+    const problems = [];
+    for (const definition of BUILTIN_PROFILES)
+        profiles.set(definition.name, { ...definition, source: 'builtin', path: null });
+    const dirs = profileDirs(root, cwd);
+    readFolder(dirs.global, 'global', profiles, problems);
+    readFolder(dirs.project, 'project', profiles, problems);
+    for (const definition of variantDefinitions(variantDir))
+        if (!profiles.has(definition.name))
+            profiles.set(definition.name, definition);
+    return { profiles: [...profiles.values()].sort((left, right) => left.name.localeCompare(right.name)), problems };
+}
+export function resolveProfile(root, cwd, name, variantDir) {
+    if (!PROFILE_NAME.test(name))
+        return null;
+    return listProfiles(root, cwd, variantDir).profiles.find(profile => profile.name === name) ?? null;
+}
+function scopeDir(root, cwd, scope) {
+    const dirs = profileDirs(root, cwd);
+    if (scope === 'global')
+        return dirs.global;
+    if (!dirs.project)
+        throw invalid('A project profile needs a working folder.');
+    return dirs.project;
+}
+const TEMPLATE = {
+    description: 'What this agent is for, in one line.',
+    color: 'blue',
+    instructions: 'Describe how this agent should work: what to do with a brief, what to avoid, and what to report back.',
+    tools: null, plugins: null, variant: null, model: null, effort: null
+};
+/** Writes a new profile file from the template, or a copy of `from`. Refuses to overwrite one. */
+export function createProfile(root, cwd, input) {
+    const name = typeof input.name === 'string' ? input.name.trim() : '';
+    if (!PROFILE_NAME.test(name))
+        throw invalid('A profile name uses lowercase letters, digits, - and _, and starts with a letter or digit.');
+    if (input.scope !== 'global' && input.scope !== 'project')
+        throw invalid('scope must be global or project.');
+    const dir = scopeDir(root, cwd, input.scope);
+    const path = join(dir, `${name}.md`);
+    if (existsSync(path))
+        throw invalid(`There is already a ${input.scope} profile named ${name}.`);
+    let source = { ...TEMPLATE, name };
+    if (input.from) {
+        const original = resolveProfile(root, cwd, input.from);
+        if (!original)
+            throw notFound(`The profile ${input.from}`);
+        source = { ...original, name };
+    }
+    mkdirSync(dir, { recursive: true });
+    const text = profileText(source);
+    atomicWrite(path, text);
+    return parseProfile(text, name, input.scope, path);
+}
+/** Deletes a person's own profile file. Built-ins and variant subagents cannot be removed here. */
+export function removeProfile(root, cwd, input) {
+    if (!PROFILE_NAME.test(input.name))
+        throw invalid('That is not a profile name.');
+    if (input.scope !== 'global' && input.scope !== 'project')
+        throw invalid('scope must be global or project.');
+    const path = join(scopeDir(root, cwd, input.scope), `${input.name}.md`);
+    if (!existsSync(path))
+        throw notFound(`The ${input.scope} profile ${input.name}`);
+    rmSync(path);
+}
+/** Where the profile list sits among the prompt sections: the slot a variant's subagents used. */
+export const PROFILE_SECTION_ORDER = 64;
+/** The prompt section that lists the profiles a run can start subagents from. */
+export function profileSection(root, cwd, variantDir, planResearchOnly = false) {
+    const { profiles } = listProfiles(root, cwd, variantDir);
+    const listed = planResearchOnly ? profiles.filter(planResearchProfile) : profiles;
+    return {
+        id: 'subagents',
+        title: 'Subagents',
+        body: [
+            planResearchOnly
+                ? 'Plan mode may start only a named profile listed here, for read-only research. Do not omit agent or use a profile not listed.'
+                : 'Delegate when it meaningfully reduces work: choose a substantial, bounded task that can proceed independently, such as unfamiliar cross-file research likely to take several searches or a self-contained implementation. Do a known-file lookup, one or two simple tool calls, a tiny edit or tightly coupled work yourself. Prefer a named profile: explorer for repository research, researcher for public-source research, and worker for a defined change it can own end to end; omit agent only when no profile fits. Each child starts without this conversation, so give it the goal, relevant context or paths, non-goals, expected result and acceptance or verification; use its own checklist for multi-step work. Prefer context-heavy research with concise evidence-backed findings. Parallelize only independent tasks and never assign overlapping edits. Return without waiting only when useful independent work remains; otherwise wait. You own integration, verification and the user-facing report. A profile can only narrow your tools.',
+            ...(listed.length ? listed.map((profile) => `- ${profile.name} — ${profile.description}`) : ['- No eligible read-only research profiles are configured.'])
+        ].join('\n'),
+        budget: 6_000,
+        order: PROFILE_SECTION_ORDER,
+        dynamic: true
+    };
+}

package/dist/sdk/annotations/bridge.d.ts

@@ -0,0 +1,42 @@
+import { type PageOperation } from "./pageScript.js";
+export interface BridgeWindow {
+    id: string;
+    url: string;
+    title: string;
+    lastSeen: number;
+}
+export interface BridgeInfo {
+    port: number;
+    token: string;
+    scriptUrl: string;
+    /** What to put in the app while developing it. */
+    snippet: string;
+}
+/** The script a window loads: the page helper plus a loop that pulls operations from the bridge. */
+export declare function bridgeScript(base: string, token: string): string;
+export declare class NotesBridge {
+    private readonly options;
+    private server;
+    private starting;
+    private info;
+    private readonly windows;
+    private nextWindow;
+    private nextCall;
+    constructor(options: {
+        stateDir: string;
+        port?: number;
+    });
+    private settingsFile;
+    /** Starts the bridge (once) on the port and token kept from last time, so the app's snippet stays valid. */
+    start(): Promise<BridgeInfo>;
+    private listen;
+    list(): BridgeWindow[];
+    /** Sends one helper operation to a window and waits for its JSON reply. */
+    call(windowId: string, operation: PageOperation): Promise<unknown>;
+    private flush;
+    private sweep;
+    private json;
+    private body;
+    private handle;
+    close(): Promise<void>;
+}

package/dist/sdk/annotations/bridge.js

@@ -0,0 +1,264 @@
+// The page bridge (PROP-0018): page notes in a web view that has no DevTools port, such as a Tauri
+// window on macOS. The developer loads one script into their app while developing it; the script
+// carries the page helper and pulls operations from this loopback server, answering each with the
+// helper's JSON. Only 127.0.0.1 listens, every request carries the bridge token, and everything a
+// window answers is untrusted page data.
+import { randomBytes } from 'node:crypto';
+import { chmodSync, existsSync } from 'node:fs';
+import { createServer } from 'node:http';
+import { join } from 'node:path';
+import { readJson, writeJson } from "../core/fs.js";
+import { PAGE_SCRIPT } from "./pageScript.js";
+const POLL_MS = 20_000;
+const GONE_MS = 45_000;
+const CALL_MS = 10_000;
+const MAX_BODY = 1_000_000;
+const MAX_WINDOWS = 32;
+const bounded = (value, size) => (typeof value === 'string' ? Array.from(value).slice(0, size).join('') : '');
+/** The script a window loads: the page helper plus a loop that pulls operations from the bridge. */
+export function bridgeScript(base, token) {
+    const helper = PAGE_SCRIPT.replace('__ARGS__', () => '__op');
+    return `(() => {
+  if (window.__harnessPageNotesBridge) return
+  window.__harnessPageNotesBridge = true
+  const base = ${JSON.stringify(base)}
+  const token = ${JSON.stringify(token)}
+  const call = (__op) => ${helper}
+  let windowId = null
+  const post = (path, body) => fetch(base + path, { method: 'POST', headers: { 'content-type': 'text/plain' }, body: JSON.stringify({ token, ...body }) })
+    .then(response => response.ok ? response.json() : Promise.reject(new Error(String(response.status))))
+  const pause = ms => new Promise(resolve => setTimeout(resolve, ms))
+  const loop = async () => {
+    for (;;) {
+      try {
+        if (!windowId) windowId = (await post('/register', { url: location.href, title: document.title })).windowId
+        const query = '?token=' + encodeURIComponent(token) + '&window=' + encodeURIComponent(windowId) + '&url=' + encodeURIComponent(location.href.slice(0, 2000)) + '&title=' + encodeURIComponent(document.title.slice(0, 200))
+        const response = await fetch(base + '/poll' + query)
+        if (response.status === 410) { windowId = null; continue }
+        if (response.status !== 200) { if (response.status !== 204) await pause(2000); continue }
+        const { id, operation } = await response.json()
+        let reply
+        try { reply = call(operation) } catch (error) { reply = JSON.stringify({ ok: false, error: String(error && error.message || error) }) }
+        await post('/reply', { window: windowId, id, reply })
+      } catch {
+        await pause(2000)
+      }
+    }
+  }
+  if (document.readyState === 'loading') document.addEventListener('DOMContentLoaded', loop, { once: true })
+  else loop()
+})()
+`;
+}
+export class NotesBridge {
+    options;
+    server = null;
+    starting = null;
+    info = null;
+    windows = new Map();
+    nextWindow = 1;
+    nextCall = 1;
+    constructor(options) {
+        this.options = options;
+    }
+    settingsFile() {
+        return join(this.options.stateDir, 'notes-bridge.json');
+    }
+    /** Starts the bridge (once) on the port and token kept from last time, so the app's snippet stays valid. */
+    start() {
+        if (this.info)
+            return Promise.resolve(this.info);
+        this.starting ??= this.listen().finally(() => { this.starting = null; });
+        return this.starting;
+    }
+    async listen() {
+        const settingsFile = this.settingsFile();
+        if (existsSync(settingsFile))
+            chmodSync(settingsFile, 0o600);
+        const saved = existsSync(settingsFile) ? readJson(settingsFile) : null;
+        const token = typeof saved?.token === 'string' && /^[a-f0-9]{48}$/.test(saved.token) ? saved.token : randomBytes(24).toString('hex');
+        const wanted = this.options.port ?? (Number.isSafeInteger(saved?.port) ? saved.port : 0);
+        const server = createServer((request, response) => void this.handle(request, response, token));
+        const port = await new Promise((resolve, reject) => {
+            const attempt = (port, retry) => {
+                server.once('error', (error) => {
+                    if (retry && error.code === 'EADDRINUSE')
+                        attempt(0, false);
+                    else
+                        reject(error);
+                });
+                server.listen(port, '127.0.0.1', () => resolve(server.address().port));
+            };
+            attempt(wanted, wanted !== 0);
+        });
+        this.server = server;
+        writeJson(settingsFile, { port, token });
+        chmodSync(settingsFile, 0o600);
+        const base = `http://127.0.0.1:${port}`;
+        const scriptUrl = `${base}/page-notes.js?token=${token}`;
+        this.info = {
+            port,
+            token,
+            scriptUrl,
+            snippet: `<script src="${scriptUrl}"></script>`
+        };
+        return this.info;
+    }
+    list() {
+        this.sweep();
+        return [...this.windows.values()].map(({ id, url, title, lastSeen }) => ({ id, url, title, lastSeen }));
+    }
+    /** Sends one helper operation to a window and waits for its JSON reply. */
+    call(windowId, operation) {
+        this.sweep();
+        const live = this.windows.get(windowId);
+        if (!live)
+            return Promise.reject(new Error('That app window is no longer connected.'));
+        return new Promise((resolve, reject) => {
+            const id = String(this.nextCall++);
+            const pending = {
+                id, operation, resolve, reject,
+                timer: setTimeout(() => {
+                    live.sent.delete(id);
+                    live.queue = live.queue.filter((entry) => entry !== pending);
+                    reject(new Error('The app window did not answer.'));
+                }, CALL_MS)
+            };
+            live.queue.push(pending);
+            this.flush(live);
+        });
+    }
+    flush(live) {
+        if (!live.waiter || !live.queue.length)
+            return;
+        const pending = live.queue.shift();
+        live.sent.set(pending.id, pending);
+        const waiter = live.waiter;
+        live.waiter = null;
+        if (live.waiterTimer)
+            clearTimeout(live.waiterTimer);
+        live.waiterTimer = null;
+        this.json(waiter, 200, { id: pending.id, operation: pending.operation });
+    }
+    sweep() {
+        const now = Date.now();
+        for (const live of this.windows.values()) {
+            if (now - live.lastSeen <= GONE_MS || live.waiter)
+                continue;
+            this.windows.delete(live.id);
+            for (const pending of [...live.queue, ...live.sent.values()]) {
+                clearTimeout(pending.timer);
+                pending.reject(new Error('That app window is no longer connected.'));
+            }
+        }
+    }
+    json(response, status, body) {
+        response.writeHead(status, { 'content-type': 'application/json', 'access-control-allow-origin': '*', 'cache-control': 'no-store' });
+        response.end(body === undefined ? undefined : JSON.stringify(body));
+    }
+    async body(request) {
+        let size = 0;
+        const chunks = [];
+        for await (const chunk of request) {
+            size += chunk.length;
+            if (size > MAX_BODY)
+                return null;
+            chunks.push(chunk);
+        }
+        try {
+            const value = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+            return value && typeof value === 'object' ? value : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    async handle(request, response, token) {
+        try {
+            const port = this.server?.address()?.port;
+            // Refuse other host names, so a web page cannot reach the bridge by DNS rebinding.
+            if (request.headers.host !== `127.0.0.1:${port}` && request.headers.host !== `localhost:${port}`)
+                return this.json(response, 421);
+            const url = new URL(request.url ?? '/', `http://127.0.0.1:${port}`);
+            if (request.method === 'OPTIONS')
+                return this.json(response, 204);
+            if (request.method === 'GET' && url.pathname === '/page-notes.js') {
+                if (url.searchParams.get('token') !== token)
+                    return this.json(response, 403);
+                response.writeHead(200, { 'content-type': 'application/javascript; charset=utf-8', 'access-control-allow-origin': '*', 'cache-control': 'no-store' });
+                response.end(bridgeScript(`http://127.0.0.1:${port}`, token));
+                return;
+            }
+            if (request.method === 'GET' && url.pathname === '/poll') {
+                if (url.searchParams.get('token') !== token)
+                    return this.json(response, 403);
+                const live = this.windows.get(url.searchParams.get('window') ?? '');
+                if (!live)
+                    return this.json(response, 410);
+                live.lastSeen = Date.now();
+                live.url = bounded(url.searchParams.get('url'), 2000) || live.url;
+                live.title = bounded(url.searchParams.get('title'), 200);
+                if (live.waiter)
+                    this.json(live.waiter, 204);
+                live.waiter = response;
+                live.waiterTimer = setTimeout(() => {
+                    if (live.waiter !== response)
+                        return;
+                    live.waiter = null;
+                    this.json(response, 204);
+                }, POLL_MS);
+                response.on('close', () => { if (live.waiter === response)
+                    live.waiter = null; });
+                this.flush(live);
+                return;
+            }
+            if (request.method === 'POST' && (url.pathname === '/register' || url.pathname === '/reply')) {
+                const body = await this.body(request);
+                if (!body || body.token !== token)
+                    return this.json(response, 403);
+                if (url.pathname === '/register') {
+                    this.sweep();
+                    if (this.windows.size >= MAX_WINDOWS)
+                        return this.json(response, 429);
+                    const id = `a${this.nextWindow++}`;
+                    this.windows.set(id, { id, url: bounded(body.url, 2000), title: bounded(body.title, 200), lastSeen: Date.now(), queue: [], sent: new Map(), waiter: null, waiterTimer: null });
+                    return this.json(response, 200, { windowId: id });
+                }
+                const live = this.windows.get(typeof body.window === 'string' ? body.window : '');
+                const pending = live?.sent.get(typeof body.id === 'string' ? body.id : '');
+                if (!live || !pending)
+                    return this.json(response, 410);
+                live.sent.delete(pending.id);
+                clearTimeout(pending.timer);
+                pending.resolve(body.reply);
+                return this.json(response, 200, {});
+            }
+            this.json(response, 404);
+        }
+        catch {
+            if (!response.headersSent)
+                this.json(response, 500);
+        }
+    }
+    async close() {
+        for (const live of this.windows.values()) {
+            if (live.waiter)
+                this.json(live.waiter, 204);
+            if (live.waiterTimer)
+                clearTimeout(live.waiterTimer);
+            for (const pending of [...live.queue, ...live.sent.values()]) {
+                clearTimeout(pending.timer);
+                pending.reject(new Error('The page bridge closed.'));
+            }
+        }
+        this.windows.clear();
+        const server = this.server;
+        this.server = null;
+        this.info = null;
+        if (server) {
+            const closed = new Promise((resolve) => server.close(() => resolve()));
+            server.closeAllConnections();
+            await closed;
+        }
+    }
+}