@parity/product-lab 0.0.1-placeholder → 0.1.0

package/adapters/host/dotli/src/dotli-build.js

@@ -0,0 +1,169 @@
+// Copyright 2026 Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+import { createHash } from "node:crypto";
+import { cpSync, existsSync, mkdirSync, readdirSync, readFileSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { isAbsolute, join, relative } from "node:path";
+import { fileURLToPath } from "node:url";
+import { z } from "zod";
+export const DOTLI_LOCK_FILE = fileURLToPath(new URL("../dotli.lock.json", import.meta.url));
+export const DOTLI_BUILDS = ["apps/host/dist", "apps/sandbox/dist", "apps/protocol/dist"];
+const lockSchema = z
+    .strictObject({
+    schemaVersion: z.literal(1),
+    repository: z.url(),
+    commit: z.string().regex(/^[a-f0-9]{40}$/),
+    network: z.string().regex(/^[a-z0-9-]+$/),
+    debug: z.literal(true),
+    truapi: z.strictObject({ client: z.string().regex(/^\d+\.\d+\.\d+$/), host: z.string().regex(/^\d+\.\d+\.\d+$/) }),
+});
+export function readDotliLock(file = DOTLI_LOCK_FILE) {
+    return lockSchema.parse(JSON.parse(readFileSync(file, "utf8")));
+}
+export function dotliCacheRoot(env = process.env) {
+    if (env.PRODUCT_LAB_CACHE_DIR) {
+        if (!isAbsolute(env.PRODUCT_LAB_CACHE_DIR))
+            throw new Error("PRODUCT_LAB_CACHE_DIR must be absolute");
+        return env.PRODUCT_LAB_CACHE_DIR;
+    }
+    return join(env.XDG_CACHE_HOME && isAbsolute(env.XDG_CACHE_HOME) ? env.XDG_CACHE_HOME : join(homedir(), ".cache"), "product-lab");
+}
+export const dotliBuildName = (lock) => `${lock.commit.slice(0, 12)}-${lock.network}-debug`;
+export const dotliBuildDir = (cacheDir, lock) => join(cacheDir, "hosts", "dotli", dotliBuildName(lock));
+export function treeDigest(root, parts = DOTLI_BUILDS) {
+    const entries = [];
+    let bytes = 0;
+    const walk = (dir) => {
+        for (const name of readdirSync(dir).sort()) {
+            const path = join(dir, name);
+            const stat = statSync(path);
+            if (stat.isDirectory())
+                walk(path);
+            else {
+                const data = readFileSync(path);
+                bytes += data.length;
+                entries.push(`${relative(root, path)}\0${createHash("sha256").update(data).digest("hex")}`);
+            }
+        }
+    };
+    for (const part of parts) {
+        const dir = join(root, part);
+        if (!existsSync(dir))
+            throw new Error(`dot.li build part ${part} is missing under ${root}`);
+        walk(dir);
+    }
+    return { sha256: createHash("sha256").update(entries.join("\n")).digest("hex"), files: entries.length, bytes };
+}
+export class MissingDotliBuildError extends Error {
+    command = "product-lab host build --host dotli";
+    constructor(message) {
+        super(`${message}\nFix: run \`bun run product-lab host build --host dotli\` in the product-lab checkout (clones the locked dot.li commit, builds it in debug mode for the locked network and caches it; needs git and the package manager its lockfile names, npm or Bun).`);
+        this.name = "MissingDotliBuildError";
+    }
+}
+export function findDotliBuild(options = {}) {
+    const lock = options.lock ?? readDotliLock();
+    const dir = dotliBuildDir(options.cacheDir ?? dotliCacheRoot(), lock);
+    const file = join(dir, "acquired.json");
+    if (!existsSync(file))
+        throw new MissingDotliBuildError(`No dot.li build of ${lock.commit.slice(0, 12)} for ${lock.network} is cached at ${dir}.`);
+    const record = JSON.parse(readFileSync(file, "utf8"));
+    if (record.commit !== lock.commit || record.network !== lock.network)
+        throw new MissingDotliBuildError(`The cached dot.li build at ${dir} is ${record.commit.slice(0, 12)} for ${record.network}; the lock asks for ${lock.commit.slice(0, 12)} for ${lock.network}.`);
+    const digest = treeDigest(dir);
+    if (digest.sha256 !== record.treeSha256)
+        throw new MissingDotliBuildError(`The cached dot.li build at ${dir} was modified: its files digest to ${digest.sha256}, recorded ${record.treeSha256}. Delete it and build again.`);
+    return { dir, record };
+}
+export async function buildDotli(options) {
+    const log = options.log ?? (() => { });
+    const lock = options.lock ?? readDotliLock();
+    const cacheDir = options.cacheDir ?? dotliCacheRoot();
+    const workdir = options.workdir ?? join(realpathSync(tmpdir()), `product-lab-dotli-build-${Date.now().toString(36)}`);
+    if (!isAbsolute(workdir))
+        throw new Error("--workdir must be an absolute path");
+    if (existsSync(workdir))
+        throw new Error(`${workdir} already exists; the dot.li build creates its own checkout`);
+    const tool = async (command, args) => {
+        try {
+            const result = await options.commands.run({ command, args, timeoutMs: 30_000, signal: options.signal });
+            if (result.code !== 0)
+                throw new Error(result.stderr || `exit ${result.code}`);
+            return result.stdout.trim().split("\n")[0];
+        }
+        catch (error) {
+            throw new Error(`The dot.li build needs ${command} (${command} ${args.join(" ")} failed)`, { cause: error });
+        }
+    };
+    const tools = { git: await tool("git", ["--version"]) };
+    const steps = [];
+    const run = async (name, command, args, cwd, env = {}) => {
+        const started = performance.now();
+        log(`${name}: $ ${command} ${args.join(" ")}`);
+        const result = await options.commands.run({ command, args, cwd, env, timeoutMs: name === "fetch" ? 600_000 : 900_000, maxOutputBytes: 64 * 1024 * 1024, signal: options.signal });
+        if (result.code !== 0)
+            throw new Error(`dot.li ${name} failed (${command} ${args.join(" ")}, exit ${result.code}):\n${(result.stderr || result.stdout || "").slice(-4000)}`);
+        const ms = Math.round(performance.now() - started);
+        steps.push({ name, ms });
+        log(`${name}: done in ${(ms / 1000).toFixed(1)} s`);
+    };
+    try {
+        mkdirSync(workdir, { recursive: true });
+        await run("init", "git", ["init", "--quiet"], workdir);
+        await run("fetch", "git", ["fetch", "--quiet", "--depth", "1", options.repo ?? lock.repository, lock.commit], workdir);
+        await run("checkout", "git", ["-c", "advice.detachedHead=false", "checkout", "--quiet", "FETCH_HEAD"], workdir);
+        const headResult = await options.commands.run({ command: "git", args: ["rev-parse", "HEAD"], cwd: workdir, timeoutMs: 10_000, signal: options.signal });
+        if (headResult.code !== 0)
+            throw new Error(`dot.li checkout verification failed (exit ${headResult.code}): ${headResult.stderr.trim()}`);
+        const head = headResult.stdout.trim();
+        if (head !== lock.commit)
+            throw new Error(`The checkout is at ${head}, not the locked ${lock.commit}`);
+        const manager = existsSync(join(workdir, "package-lock.json")) ? "npm" : "bun";
+        tools[manager] = await tool(manager, ["--version"]);
+        if (manager === "npm")
+            await run("install", "npm", ["ci"], workdir);
+        else
+            await run("install", "bun", ["install", "--frozen-lockfile"], workdir);
+        const clearVite = Object.fromEntries(Object.keys(process.env).filter((key) => key.startsWith("VITE_")).map((key) => [key, undefined]));
+        await run("build", manager, ["run", "build"], workdir, { ...clearVite, VITE_NETWORKS: lock.network, VITE_APP_DEBUG: "true" });
+        const installed = (name) => {
+            const file = join(workdir, "node_modules", "@parity", name, "package.json");
+            return existsSync(file) ? JSON.parse(readFileSync(file, "utf8")).version : undefined;
+        };
+        const truapi = Object.fromEntries([["client", "truapi"], ["host", "truapi-host"], ["provider", "truapi-provider"]].flatMap(([key, name]) => {
+            const version = installed(name);
+            return version ? [[key, version]] : [];
+        }));
+        const target = dotliBuildDir(cacheDir, lock);
+        const staging = `${target}.staging-${process.pid}`;
+        rmSync(staging, { recursive: true, force: true });
+        for (const part of DOTLI_BUILDS)
+            cpSync(join(workdir, part), join(staging, part), { recursive: true });
+        const digest = treeDigest(staging);
+        const record = {
+            schemaVersion: 1,
+            label: `dotli-${lock.commit.slice(0, 12)}-${lock.network}-debug`,
+            repository: lock.repository,
+            commit: lock.commit,
+            network: lock.network,
+            debug: true,
+            treeSha256: digest.sha256,
+            files: digest.files,
+            bytes: digest.bytes,
+            builtAt: new Date().toISOString(),
+            tools,
+            steps,
+            ...(Object.keys(truapi).length ? { truapi } : {}),
+        };
+        writeFileSync(join(staging, "acquired.json"), JSON.stringify(record, null, 2) + "\n");
+        mkdirSync(join(cacheDir, "hosts", "dotli"), { recursive: true });
+        rmSync(target, { recursive: true, force: true });
+        renameSync(staging, target);
+        log(`cached ${record.label} at ${target} (${digest.files} files, ${digest.bytes} bytes, tree ${digest.sha256.slice(0, 12)}…)`);
+        return { dir: target, record };
+    }
+    finally {
+        if (!options.keepWorkdir)
+            rmSync(workdir, { recursive: true, force: true });
+    }
+}

package/adapters/host/dotli/src/dotli-host-factory.d.ts

@@ -0,0 +1,66 @@
+import type { Browser } from "@parity/product-lab/ports/browser";
+import type { ChainGateSource, PortAllocator, SystemPorts } from "@parity/product-lab/ports/system";
+import type { AdapterFlag, AdapterFlagValues } from "@parity/product-lab/ports/factory";
+import type { HostAdapterFactory, HostAvailability, HostToolContext } from "@parity/product-lab/ports/host";
+import { z } from "zod";
+import type { HostNetworkRoutes } from "@parity/product-lab/domain";
+import { DotliHost } from "./dotli-host.js";
+/** Flags of `product-lab host fetch|build --host dotli`. */
+export declare const DOTLI_FLAGS: readonly AdapterFlag[];
+/** The adapter kind (`HostAdapterFactory.kind`). */
+export declare const DOTLI_KIND = "dotli";
+/** The data options of a dot.li host (what a lab can declare). */
+export declare const dotliHostOptionsSchema: z.ZodObject<{
+    hostPort: z.ZodOptional<z.ZodNumber>;
+    hostnameSuffix: z.ZodOptional<z.ZodString>;
+    allowOrigins: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    build: z.ZodOptional<z.ZodString>;
+    denyByDefault: z.ZodOptional<z.ZodBoolean>;
+    networkExceptions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        origin: z.ZodString;
+        reason: z.ZodString;
+    }, z.core.$strict>>>;
+    readyTimeoutMs: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type DotliHostConfig = z.input<typeof dotliHostOptionsSchema>;
+/** What a dot.li host runs with besides its options. */
+export interface DotliHostDeps {
+    /** How the host reaches the local network (for example `RunningEnvironment.routes`). */
+    routes: HostNetworkRoutes;
+    /** The browser sessions open in; without it the host runs no sessions (interception table only). */
+    browser?: Browser;
+    system?: Partial<Pick<SystemPorts, "inspectAppFraming">> & {
+        /** The lab's port allocator: `next` reserves the host's port when no `hostPort` is given. */
+        readonly ports?: Pick<PortAllocator, "next">;
+    };
+    /** Backlog 92's origin gates (the composition root's): a deny-by-default host routes itself through them. */
+    chainGates?: ChainGateSource;
+}
+export declare class DotliHostFactory implements HostAdapterFactory<DotliHostConfig, DotliHost, DotliHostDeps> {
+    readonly kind = "dotli";
+    readonly label = "dot.li browser host (locked debug build; unsigned sessions with deny-by-default interception)";
+    readonly color = "#0e7490";
+    readonly options: z.ZodObject<{
+        hostPort: z.ZodOptional<z.ZodNumber>;
+        hostnameSuffix: z.ZodOptional<z.ZodString>;
+        allowOrigins: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        build: z.ZodOptional<z.ZodString>;
+        denyByDefault: z.ZodOptional<z.ZodBoolean>;
+        networkExceptions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            origin: z.ZodString;
+            reason: z.ZodString;
+        }, z.core.$strict>>>;
+        readyTimeoutMs: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>;
+    readonly flags: readonly AdapterFlag[];
+    /** A host for options its schema accepted (the registry validates them first) and the environment's routes. */
+    create(options: DotliHostConfig, deps: DotliHostDeps): DotliHost;
+    /** Backlog 28: the interception table needs People, Asset Hub and Bulletin routed. */
+    routingProblem(_options: DotliHostConfig, routes: HostNetworkRoutes): string | undefined;
+    /** Whether the locked dot.li build is cached (no build, no start). */
+    availability(options: DotliHostConfig): HostAvailability;
+    /** `product-lab host fetch --host dotli`: the cached build, or what is missing (nothing is downloaded). */
+    fetch(values: AdapterFlagValues): Promise<import("./dotli-build.js").DotliBuild>;
+    /** `product-lab host build --host dotli`: clone the locked commit, build it (debug, locked network) and cache it. */
+    build(values: AdapterFlagValues, { log, signal, commands }: HostToolContext): Promise<import("./dotli-build.js").DotliBuild>;
+}

package/adapters/host/dotli/src/dotli-host-factory.js

@@ -0,0 +1,82 @@
+// Copyright 2026 Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+import { isAbsolute } from "node:path";
+import { buildDotli, dotliCacheRoot, findDotliBuild } from "./dotli-build.js";
+import { z } from "zod";
+import { DOTLI_HOST_COLOR, DotliHost } from "./dotli-host.js";
+import { isLoopback, localEndpoints } from "./routing.js";
+export const DOTLI_FLAGS = [
+    { name: "cache", type: "string", value: "<dir>", description: "host cache (default $PRODUCT_LAB_CACHE_DIR or ~/.cache/product-lab)", commands: ["fetch", "build"] },
+    { name: "repo", type: "string", value: "<clone>", description: "local dot.li clone to clone from (default: the locked GitHub repository)", commands: ["build"] },
+    { name: "workdir", type: "string", value: "<dir>", description: "absolute path for the new checkout (must not exist; default: a new temporary directory, removed afterwards)", commands: ["build"] },
+    { name: "keep-workdir", type: "boolean", description: "keep the checkout", commands: ["build"] },
+];
+export const DOTLI_KIND = "dotli";
+const loopback = z.string().refine(isLoopback, { message: "must be a loopback endpoint" });
+export const dotliHostOptionsSchema = z
+    .strictObject({
+    hostPort: z.number().int().min(1024).max(65535).optional(),
+    hostnameSuffix: z.string().regex(/^[a-z0-9.-]+$/).optional(),
+    allowOrigins: z.array(loopback).optional(),
+    build: z.string().refine((path) => isAbsolute(path), "build must be an absolute path").optional(),
+    denyByDefault: z.boolean().optional(),
+    networkExceptions: z.array(z.strictObject({ origin: z.string(), reason: z.string().trim().min(1) })).optional(),
+    readyTimeoutMs: z.number().int().positive().optional(),
+});
+export class DotliHostFactory {
+    kind = DOTLI_KIND;
+    label = "dot.li browser host (locked debug build; unsigned sessions with deny-by-default interception)";
+    color = DOTLI_HOST_COLOR;
+    options = dotliHostOptionsSchema;
+    flags = DOTLI_FLAGS;
+    create(options, deps) {
+        const ports = deps.system?.ports;
+        return new DotliHost({
+            ...options, routes: deps.routes,
+            ...(deps.browser ? { browser: deps.browser } : {}),
+            ...(deps.system?.inspectAppFraming ? { inspectAppFraming: deps.system.inspectAppFraming } : {}),
+            ...(deps.chainGates ? { chainGates: deps.chainGates } : {}),
+            ...(options.hostPort === undefined && ports?.next ? { nextPort: ports.next.bind(ports) } : {}),
+        });
+    }
+    routingProblem(_options, routes) {
+        try {
+            localEndpoints(routes);
+            return undefined;
+        }
+        catch (error) {
+            return error instanceof Error ? error.message : String(error);
+        }
+    }
+    availability(options) {
+        try {
+            if (options.build)
+                return { available: true, detail: `${options.build} (unpinned build)` };
+            const build = findDotliBuild();
+            return { available: true, detail: `${build.record.label} at ${build.dir}` };
+        }
+        catch (error) {
+            return { available: false, detail: error.message, fix: "bun run product-lab host build --host dotli" };
+        }
+    }
+    async fetch(values) {
+        const cacheDir = typeof values.cache === "string" ? values.cache : dotliCacheRoot();
+        return findDotliBuild({ cacheDir });
+    }
+    async build(values, { log, signal, commands }) {
+        if (!commands)
+            throw new Error("dot.li build needs the runtime's bounded command runner");
+        const text = (name) => (typeof values[name] === "string" ? values[name] : undefined);
+        const workdir = text("workdir");
+        const repo = text("repo");
+        return buildDotli({
+            commands,
+            signal,
+            cacheDir: text("cache") ?? dotliCacheRoot(),
+            ...(repo ? { repo } : {}),
+            ...(workdir ? { workdir } : {}),
+            keepWorkdir: values["keep-workdir"] === true,
+            log,
+        });
+    }
+}

package/adapters/host/dotli/src/dotli-host.d.ts

@@ -0,0 +1,182 @@
+/**
+ * dot.li as a `HostProvider`, declared honestly.
+ *
+ * What the 2026-09-24 browser spike proved is the interception table (bridged
+ * chain RPC, local content, deny-by-default), which this host builds from its
+ * options and exposes as `table`. Given a browser (`DotliHostDeps.browser`),
+ * the host also runs sessions (Phase 3 close-out, 25 September 2026): it
+ * serves a locked dot.li debug build (`dotli-build.ts`, `dotli-server.ts`) and
+ * opens the app in dot.li's own product frame through its `/localhost:<port>`
+ * path, in a browser context of its own whose every request goes through the
+ * interception table: public chain endpoints are bridged to the local routes,
+ * and everything else is decided by the domain's `NetworkPolicy` and, when
+ * denied, recorded (`session.network.blocked()`).
+ *
+ * Sessions are not signed in: dot.li signs through a paired Polkadot App or
+ * signing host, and pairing against a local network is unproven. So they
+ * declare `productAccounts: false` and no approval policy; `importIdentity`
+ * throws `UnsupportedHostOperation`. `denyByDefaultNetwork` is declared only
+ * with `denyByDefault`, and `prepare()` then refuses a browser launched
+ * without the policy's resolver backstop (dot.li runs its core in a
+ * SharedWorker, whose traffic page routing cannot see). Given `chainGates`
+ * as well (backlog 92's origin gates), the host routes itself through them
+ * and admits only dot.li's own page and protocol frame: routing cannot tell
+ * which frame opens a local node, so a product frame that opens one is
+ * refused at the gate and reported in `session.network.blocked()`.
+ */
+import { type HostCapabilities } from "@parity/product-lab/domain";
+import type { HostProvider, HostSession, HostSessionEvidence, HostSessionRequest, ResolvedHost } from "@parity/product-lab/ports/host";
+import { NetworkPolicy, type HostNetworkRoutes, type NetworkException } from "@parity/product-lab/domain";
+import type { Browser, BrowserTab } from "@parity/product-lab/ports/browser";
+import { type InterceptionRecord } from "./interception.js";
+import { type DocumentHeaders } from "./framing.js";
+import { type DotliConsoleRecord } from "./page-console.js";
+import type { AppFramingInspection } from "@parity/product-lab/domain";
+import type { AppFramingInspector, ChainGateSource } from "@parity/product-lab/ports/system";
+import { type DotliNetworkEndpoints, type InterceptionTable } from "./routing.js";
+export declare const DOTLI_HOST_ID = "dotli";
+/** The hue views mark a dot.li host with (`HostAdapterFactory.color`). */
+export declare const DOTLI_HOST_COLOR = "#0e7490";
+/** The dot.li networks whose public endpoints the interception table knows. */
+export declare const DOTLI_NETWORKS: Readonly<Record<string, DotliNetworkEndpoints>>;
+/** dot.li's product-id override on the `/localhost:<port>` path (`DOTLI_PRODUCT_ID_PARAM`, apps/host/src/main.ts). */
+export declare const DOTLI_PRODUCT_ID_PARAM = "dotliProductId";
+/** The product frame dot.li's bridge creates in its `#app` container (packages/ui/src/bridge.ts `renderIframe`). */
+export declare const DOTLI_PRODUCT_FRAME = "#app iframe";
+export interface DotliHostOptions {
+    /**
+     * How the host reaches the local network (the domain's routing, for example
+     * `RunningEnvironment.routes`): its network names the dot.li network whose
+     * compiled-in public endpoints are bridged (`paseo-next-v2`), and its People,
+     * Asset Hub, Bulletin and (optional) relay routes are where they bridge to.
+     */
+    routes: HostNetworkRoutes;
+    /** Port the local dot.li build is served on (`http://*.localhost:<port>`); absent: `nextPort` reserves one in `prepare()`. */
+    hostPort?: number;
+    /** A free port of the lab's (its port allocator's `next`), for a host given no `hostPort`. */
+    nextPort?: () => Promise<number>;
+    /** Hostname suffix of the dot.li build's origins (default `localhost`). */
+    hostnameSuffix?: string;
+    /** Extra local origins the page may contact directly (for example a local gateway). */
+    allowOrigins?: readonly string[];
+    /** The browser sessions open in (the Browser port; the caller launches it). Without it the host runs no sessions. */
+    browser?: Browser;
+    /** A dot.li build to serve: a directory holding `apps/{host,sandbox,protocol}/dist` (debug build). Default: the locked build from the cache. */
+    build?: string;
+    /** Declare `denyByDefaultNetwork`: `prepare()` then requires the browser's resolver backstop. */
+    denyByDefault?: boolean;
+    /** Origins off the routes the sessions may reach, each with its recorded reason (a leaky control uses one). */
+    networkExceptions?: readonly NetworkException[];
+    readyTimeoutMs?: number;
+    /** Reads the app document's headers for the framing check (framing.ts); tests pass their own. */
+    documentHeaders?: DocumentHeaders;
+    /** The shared application inspection, supplied by the factory's system ports. */
+    inspectAppFraming?: AppFramingInspector;
+    /** Redacts each dot.li console message before a session keeps it (after the adapter's own `scrubConsoleText`). */
+    redactConsole?: (text: string) => string;
+    /**
+     * Backlog 92's origin gates in front of the local nodes. With `denyByDefault`, `prepare()` routes the host through
+     * them and admits only dot.li's own origins (`dotliOrigins`); without `denyByDefault` they are not opened.
+     */
+    chainGates?: ChainGateSource;
+}
+/** No session capability: nothing a session contract could exercise is proven. */
+export declare const DOTLI_HOST_CAPABILITIES: HostCapabilities;
+export interface DotliSessionEvidence extends HostSessionEvidence {
+    host: "dotli";
+    /** The dot.li page the session opened (`/localhost:<port>` path of the debug build). */
+    dotliUrl: string;
+    productUrl: string;
+    signedIn: false;
+    framing: AppFramingInspection;
+    network: {
+        policy: ReturnType<NetworkPolicy["toJSON"]>;
+        backstop: "verified" | "not required";
+        /** The origins the chain gates admit, or "not gated" (no `chainGates`, or not deny-by-default). */
+        gates: readonly string[] | "not gated";
+    };
+}
+export interface DotliHostSession extends HostSession {
+    readonly evidence: DotliSessionEvidence;
+    /** The dot.li page (topbar, product frame); `page()` is the product frame. */
+    hostPage(): BrowserTab;
+    /** Every request the session's interception decided. */
+    interception(): InterceptionRecord;
+    /** The dot.li page's console (the page and its frames), redacted, from before its first navigation. */
+    console(): DotliConsoleRecord;
+}
+/**
+ * The origins of dot.li's own page (its landing origin, `localhost`, which serves the session) and its protocol frame
+ * (`host.<suffix>`) on `hostPort`: the only ones its chain gates admit. A product's sandbox (`*.app.<suffix>`) and a
+ * local product (`/localhost:<port>`, its own origin) are not dot.li's.
+ */
+export declare function dotliOrigins(hostPort: number, hostnameSuffix?: string): string[];
+/** The app's address as dot.li's `/localhost:<port>` path needs it (`localhost`, not `127.0.0.1`). */
+export declare function productUrlFor(url: string): URL;
+/** The dot.li page that shows `productUrl` in its product frame, as `productId`. */
+export declare function dotliSessionUrl(hostPort: number, productUrl: URL, productId: string): string;
+export declare class DotliHost implements HostProvider<DotliHostSession> {
+    private readonly options;
+    readonly id = "dotli";
+    readonly color = "#0e7490";
+    readonly capabilities: HostCapabilities;
+    /** The interception table a browser context is given (`installDotliInterception`); every local endpoint is loopback,
+     * and what it does not translate is decided by the domain's `NetworkPolicy` (`table.policy`). Built when the port is
+     * known: at once for a given `hostPort`, else in `prepare()`, which reserves it. */
+    get table(): InterceptionTable;
+    private built;
+    /** The port dot.li is served on: the given `hostPort`, else the one `prepare()` reserved. */
+    private port;
+    private readonly network;
+    /** The routes the host reaches: the options', or the gates' once `prepare()` opened them. */
+    private routes;
+    private gated;
+    private readonly sessions;
+    private server;
+    private build;
+    private backstop;
+    private readonly records;
+    constructor(options: DotliHostOptions);
+    private tableFor;
+    private readBuild;
+    resolve(): Promise<ResolvedHost>;
+    /** The port dot.li is served on; known from `prepare()` on (or at once when given). */
+    private get hostPort();
+    prepare(): Promise<void>;
+    createSession({ actor, app, approvals, path }: HostSessionRequest): Promise<DotliHostSession>;
+    /** Every session's interception decisions (kept after the session stops), for evidence. */
+    interceptionLog(): {
+        actor: string;
+        app: string;
+        counts: {
+            allowed: number;
+            bridged: number;
+            served: number;
+            denied: number;
+        };
+        frames: Record<string, {
+            toLocal: number;
+            toPage: number;
+        }>;
+        events: import("./interception.js").InterceptionEvent[];
+    }[];
+    /** Every session's dot.li console (kept after the session stops, and for a session that failed to start), redacted. */
+    consoleLog(): {
+        actor: string;
+        app: string;
+        watched: boolean;
+        gaps: readonly string[];
+        dropped: number;
+        diagnostics: import("./page-console.js").DotliConsoleEntry[];
+        messages: readonly import("./page-console.js").DotliConsoleEntry[];
+    }[];
+    importIdentity(): Promise<void>;
+    dispose(): Promise<void>;
+}
+/**
+ * Refuse a browser launched without the policy's resolver backstop (the check
+ * the WASM and CLI hosts make; written here, since one adapter never imports
+ * another): under it the canary name resolves to 127.0.0.1 and this
+ * function's own server answers; without it `.invalid` never resolves.
+ */
+export declare function verifyResolverBackstop(browser: Browser): Promise<void>;