humanish 0.106.1 → 0.108.0

package/dist/deprecated.js

@@ -1,106 +0,0 @@
-// The exports this minor deprecates and the next minor removes (docs/contracts/schemas.md,
-// "Library options"). Each function warns once per process and then runs unchanged. Each type is
-// an alias of the type it always was, and each constant has the value it always had. Internal code
-// calls the original functions, so only a package caller sees a warning.
-import { runCuaActorSession as cuaActorSession, } from "./actors/computer-use/actor.js";
-import { resolveLabDryRun as labDryRun } from "./lab/plan.js";
-import { actorResolvesToTerminal as resolvesToTerminal, cuaLaneCount as laneCount, MAX_CUA_LANES as laneCap, resolveSeatUrl as seatUrl, } from "./lab/routing.js";
-import { concurrentSharedWorldValidationReason as concurrentSharedWorldReason, cuaLaneValidationReason as laneRosterReason, externalPublicSharedWorldValidationReason as externalPublicSharedWorldReason, sharedWorldValidationReason as sharedWorldReason, } from "./lab/validation.js";
-import { runCuaActorLab as cuaActorLab } from "./routes/computer-use/route.js";
-import { runScriptedBrowserLab as scriptedBrowserLab } from "./routes/scripted/route.js";
-import { runConcurrentSharedWorld as concurrentSharedWorld } from "./routes/shared-world/route.js";
-import { runTerminalProductLab as terminalProductLab } from "./routes/terminal/route.js";
-import { runDryRun as dryRun } from "./run/dry-run.js";
-const warned = new Set();
-function deprecated(name, replacement) {
-    if (warned.has(name))
-        return;
-    warned.add(name);
-    process.emitWarning(`${name} is deprecated and is removed in the next minor. Use ${replacement}.`, { type: "DeprecationWarning", code: "HUMANISH_DEPRECATED_EXPORT" });
-}
-const RUN_LAB = "runLab(config, options); its result is LabResult<route>";
-/**
- * @deprecated Use `runComputerUseLoop` with `createOpenAiResponsesProvider({ singleDispatch: true })`,
- * the strict-spend composition in docs/contracts/schemas.md.
- */
-export function runCuaActorSession(options) {
-    deprecated("runCuaActorSession", "runComputerUseLoop with createOpenAiResponsesProvider({ singleDispatch: true }) (the strict-spend composition in docs/contracts/schemas.md)");
-    return cuaActorSession(options);
-}
-/** @deprecated Use `runLab(config, options)`; its result is `LabResult<"computer-use">`. */
-export function runCuaActorLab(options) {
-    deprecated("runCuaActorLab", RUN_LAB);
-    return cuaActorLab(options);
-}
-/** @deprecated Use `runLab(config, options)`; its result is `LabResult<"scripted">`. */
-export function runScriptedBrowserLab(options) {
-    deprecated("runScriptedBrowserLab", RUN_LAB);
-    return scriptedBrowserLab(options);
-}
-/** @deprecated Use `runLab(config, options)`; its result is `LabResult<"terminal">`. */
-export function runTerminalProductLab(options) {
-    deprecated("runTerminalProductLab", RUN_LAB);
-    return terminalProductLab(options);
-}
-/** @deprecated Use `runLab(config, options)`; its result is `LabResult<"shared-world">`. */
-export function runConcurrentSharedWorld(options) {
-    deprecated("runConcurrentSharedWorld", RUN_LAB);
-    return concurrentSharedWorld(options);
-}
-/** @deprecated Use `runLab(config, options)` on a `this-repo` lab; its result is `LabResult<"preview">`. */
-export function runDryRun(options) {
-    deprecated("runDryRun", RUN_LAB);
-    return dryRun(options);
-}
-const PARSE_REASON = "parseLabConfig, which returns the same reason";
-/** @deprecated Use `routeOf(config)` on the lab. This goes in the next minor. */
-export function actorResolvesToTerminal(type) {
-    deprecated("actorResolvesToTerminal", "routeOf(config) on the lab");
-    return resolvesToTerminal(type);
-}
-/**
- * @deprecated Use the `plan` `LabEvent` from `RunLabOptions.onEvent`, which lists every
- * participant. This goes in the next minor.
- */
-export function cuaLaneCount(config) {
-    deprecated("cuaLaneCount", "the plan LabEvent from RunLabOptions.onEvent, which lists every participant");
-    return laneCount(config);
-}
-/**
- * @deprecated Use `parseLabConfig`, which refuses a seat entry that is not same-origin loopback.
- * This goes in the next minor.
- */
-export function resolveSeatUrl(serveUrl, entry) {
-    deprecated("resolveSeatUrl", "parseLabConfig, which refuses a participant entry that is not same-origin loopback");
-    return seatUrl(serveUrl, entry);
-}
-/** @deprecated Use `parseLabConfig`, which returns the same reason. This goes in the next minor. */
-export function cuaLaneValidationReason(config) {
-    deprecated("cuaLaneValidationReason", PARSE_REASON);
-    return laneRosterReason(config);
-}
-/** @deprecated Use `parseLabConfig`, which returns the same reason. This goes in the next minor. */
-export function sharedWorldValidationReason(config) {
-    deprecated("sharedWorldValidationReason", PARSE_REASON);
-    return sharedWorldReason(config);
-}
-/** @deprecated Use `parseLabConfig`, which returns the same reason. This goes in the next minor. */
-export function concurrentSharedWorldValidationReason(config) {
-    deprecated("concurrentSharedWorldValidationReason", PARSE_REASON);
-    return concurrentSharedWorldReason(config);
-}
-/** @deprecated Use `parseLabConfig`, which returns the same reason. This goes in the next minor. */
-export function externalPublicSharedWorldValidationReason(config) {
-    deprecated("externalPublicSharedWorldValidationReason", PARSE_REASON);
-    return externalPublicSharedWorldReason(config);
-}
-/**
- * @deprecated Use `RunLabOptions.dryRun`; without it, `scenario.mode` decides. This goes in the
- * next minor.
- */
-export function resolveLabDryRun(config, override, fallback) {
-    deprecated("resolveLabDryRun", "RunLabOptions.dryRun; without it, scenario.mode decides");
-    return labDryRun(config, override, fallback);
-}
-/** @deprecated `parseLabConfig` refuses a roster larger than this. This goes in the next minor. */
-export const MAX_CUA_LANES = laneCap;

package/dist/lab/bag-overrides.d.ts

@@ -1,18 +0,0 @@
-/** The members each bag type declares, forwarded even when the bag does not enumerate them. */
-export declare const HOOK_MEMBERS: {
-    readonly cua: string[];
-    readonly sharedWorld: string[];
-    readonly terminal: string[];
-    readonly scripted: string[];
-    readonly analysis: string[];
-};
-/**
- * The bag with `overrides` in place of its own members. Every other member becomes an enumerable
- * accessor that reads the bag when it is read, so a getter runs only then and a spread of the
- * result keeps every member. The members are the bag's own and inherited keys (string or symbol)
- * plus `declared`, the members its type declares, which a proxy-backed bag may answer without
- * listing. A function is bound to the bag, so its private fields still work. The overrides are
- * ordinary data properties. Declared members always appear as own properties (undefined when
- * unset), so code reading a wrapped bag tests the value, never `in`.
- */
-export declare function withHookOverrides<T extends object>(bag: T | undefined, declared: readonly string[], overrides: Partial<T>): T;

package/dist/lab/bag-overrides.js

@@ -1,121 +0,0 @@
-// A caller's hook bag with some members replaced, without copying the bag's values. Spreading a
-// class instance keeps only its own properties, so a route that spreads a caller's bag loses the
-// class's methods; this builds a plain object that keeps them.
-// Every member each bag type declares. The record type makes the compiler reject a missing or
-// unknown name, so a member added to a bag type must be added here too.
-const cuaMembers = {
-    prepareDesktop: true,
-    onPreflight: true,
-    onPhase: true,
-    onRuntimeStreamReady: true,
-    onRuntimeStreamEnded: true,
-    loadDesktopModule: true,
-    runSession: true,
-    buildExecutor: true,
-    buildProvider: true,
-    createDesktopLane: true,
-    env: true,
-    renderObserverFn: true,
-    now: true,
-    detachedTimers: true,
-    packLocalTree: true,
-    score: true,
-    deriveFeedback: true,
-    deriveArtifacts: true,
-};
-const sharedWorldMembers = {
-    loadDesktopModule: true,
-    prepareDesktop: true,
-    onRuntimeStreamReady: true,
-    onRuntimeStreamEnded: true,
-    runSession: true,
-    env: true,
-    renderObserverFn: true,
-    detachedTimers: true,
-    onPhase: true,
-    now: true,
-    proberCadenceMs: true,
-    handoffDeadlineMs: true,
-    readLobbyCodeFromFrame: true,
-    packLocalTree: true,
-    score: true,
-    deriveFeedback: true,
-    deriveArtifacts: true,
-};
-const terminalMembers = {
-    loadModule: true,
-    env: true,
-    renderObserverFn: true,
-    now: true,
-    costProbe: true,
-    score: true,
-    deriveFeedback: true,
-};
-const scriptedMembers = {
-    runSession: true,
-    launchBrowser: true,
-    env: true,
-    loadDesktopModule: true,
-    prepareDesktop: true,
-    detachedTimers: true,
-    browserCommand: true,
-    renderObserverFn: true,
-    now: true,
-};
-const analysisMembers = {
-    deps: true,
-    onStart: true,
-    run: true,
-};
-/** The members each bag type declares, forwarded even when the bag does not enumerate them. */
-export const HOOK_MEMBERS = {
-    cua: Object.keys(cuaMembers),
-    sharedWorld: Object.keys(sharedWorldMembers),
-    terminal: Object.keys(terminalMembers),
-    scripted: Object.keys(scriptedMembers),
-    analysis: Object.keys(analysisMembers),
-};
-/**
- * The bag with `overrides` in place of its own members. Every other member becomes an enumerable
- * accessor that reads the bag when it is read, so a getter runs only then and a spread of the
- * result keeps every member. The members are the bag's own and inherited keys (string or symbol)
- * plus `declared`, the members its type declares, which a proxy-backed bag may answer without
- * listing. A function is bound to the bag, so its private fields still work. The overrides are
- * ordinary data properties. Declared members always appear as own properties (undefined when
- * unset), so code reading a wrapped bag tests the value, never `in`.
- */
-export function withHookOverrides(bag, declared, overrides) {
-    const forward = {};
-    const replaced = new Set(Reflect.ownKeys(overrides));
-    const forwardMember = (key) => {
-        if (key === "constructor" || replaced.has(key) || Object.hasOwn(forward, key))
-            return;
-        Object.defineProperty(forward, key, {
-            enumerable: true,
-            configurable: true,
-            get() {
-                const value = Reflect.get(bag, key, bag);
-                return typeof value === "function" ? value.bind(bag) : value;
-            },
-            set(value) {
-                Reflect.set(bag, key, value, bag);
-            },
-        });
-    };
-    if (bag !== undefined) {
-        for (let source = bag; source !== null && source !== Object.prototype; source = Object.getPrototypeOf(source))
-            for (const key of Reflect.ownKeys(source))
-                forwardMember(key);
-        for (const key of declared)
-            forwardMember(key);
-    }
-    for (const key of replaced) {
-        Object.defineProperty(forward, key, {
-            value: overrides[key],
-            enumerable: true,
-            configurable: true,
-            writable: true,
-        });
-    }
-    return forward;
-}

package/dist/observer/static.d.ts

@@ -1,39 +0,0 @@
-import type { IncomingMessage, ServerResponse } from "node:http";
-export declare const OBSERVER_STATIC_HOST = "127.0.0.1";
-export interface ObserverStaticHandlerOptions {
-    /** Directory served as the loopback root. Requests can never escape it. */
-    root: string;
-    /** File served for directory requests. Defaults to `index.html`. */
-    indexPath?: string;
-    /**
-     * When set, an exact `/` request returns a 302 to `/<redirectRootTo>` instead
-     * of serving a file. Used to land visitors on `observer/index.html` so the
-     * Observer's relative artifact links (`../run.json`, ...) resolve.
-     */
-    redirectRootTo?: string;
-}
-export interface ObserverStaticServeOptions extends ObserverStaticHandlerOptions {
-    /** TCP port to bind on 127.0.0.1. Defaults to an ephemeral port (0). */
-    port?: number;
-    /**
-     * Relative entry page (e.g. `observer/index.html`). Drives the returned
-     * `url` and the `/` -> entry redirect so callers open the page directly.
-     */
-    entryPath?: string;
-}
-export interface ObserverStaticServer {
-    url: string;
-    port: number;
-    host: string;
-    close(): Promise<void>;
-}
-export declare function observerStaticContentType(filePath: string): string;
-/**
- * Resolve, guard, and serve a single static request from `root`. Never throws:
- * any unexpected failure is reported as a 500 so the connection always closes.
- * Exported directly so the security guards can be unit-tested without binding a
- * socket.
- */
-export declare function respondToObserverStaticRequest(options: ObserverStaticHandlerOptions, request: Pick<IncomingMessage, "method" | "url">, response: ServerResponse): Promise<void>;
-export declare function createObserverStaticHandler(options: ObserverStaticHandlerOptions): (request: IncomingMessage, response: ServerResponse) => void;
-export declare function serveObserverStatic(options: ObserverStaticServeOptions): Promise<ObserverStaticServer>;

package/dist/observer/static.js

@@ -1,369 +0,0 @@
-import { constants as fsConstants } from "node:fs";
-import { createServer } from "node:http";
-import { lstat, open, realpath } from "node:fs/promises";
-import path from "node:path";
-import { buildArtifactSecurityHeaders } from "./http.js";
-// Loopback-only host for the Observer static server. We never bind 0.0.0.0:
-// the Observer surfaces local run evidence and must stay reachable only from
-// the machine that owns the run bundle.
-export const OBSERVER_STATIC_HOST = "127.0.0.1";
-// Minimal extension -> content-type map. Kept dependency-free (no `mime`
-// package) because the Observer ships a small, known set of asset kinds.
-const CONTENT_TYPES = {
-    ".html": "text/html; charset=utf-8",
-    ".htm": "text/html; charset=utf-8",
-    ".js": "text/javascript; charset=utf-8",
-    ".mjs": "text/javascript; charset=utf-8",
-    ".css": "text/css; charset=utf-8",
-    ".json": "application/json; charset=utf-8",
-    ".map": "application/json; charset=utf-8",
-    ".svg": "image/svg+xml",
-    ".png": "image/png",
-    ".jpg": "image/jpeg",
-    ".jpeg": "image/jpeg",
-    ".webp": "image/webp",
-    ".gif": "image/gif",
-    ".ico": "image/x-icon",
-    ".md": "text/markdown; charset=utf-8",
-    ".ndjson": "application/x-ndjson; charset=utf-8",
-    ".txt": "text/plain; charset=utf-8",
-    ".woff": "font/woff",
-    ".woff2": "font/woff2",
-};
-export function observerStaticContentType(filePath) {
-    return CONTENT_TYPES[path.extname(filePath).toLowerCase()] ?? "application/octet-stream";
-}
-/**
- * Resolve, guard, and serve a single static request from `root`. Never throws:
- * any unexpected failure is reported as a 500 so the connection always closes.
- * Exported directly so the security guards can be unit-tested without binding a
- * socket.
- */
-export async function respondToObserverStaticRequest(options, request, response) {
-    applySecurityHeaders(response);
-    try {
-        const root = await pinStaticRoot(options.root);
-        await respondToPinnedObserverStaticRequest(root, options, request, response);
-    }
-    catch {
-        if (response.headersSent) {
-            response.end();
-            return;
-        }
-        writeText(response, 500, "Observer request failed");
-    }
-}
-async function respondToPinnedObserverStaticRequest(root, options, request, response) {
-    applySecurityHeaders(response);
-    const indexRelative = options.indexPath ?? "index.html";
-    try {
-        await assertPinnedStaticRoot(root);
-        const method = request.method ?? "GET";
-        if (method !== "GET" && method !== "HEAD") {
-            writeText(response, 405, "Method Not Allowed");
-            return;
-        }
-        let pathname;
-        try {
-            pathname = new URL(request.url ?? "/", `http://${OBSERVER_STATIC_HOST}`).pathname;
-        }
-        catch {
-            writeText(response, 400, "Bad Request");
-            return;
-        }
-        if (pathname === "/" && options.redirectRootTo) {
-            const location = `/${options.redirectRootTo.replace(/^\/+/, "")}`;
-            response.writeHead(302, {
-                location,
-                "cache-control": "no-store",
-                "content-length": "0",
-            });
-            response.end();
-            return;
-        }
-        let decoded;
-        try {
-            decoded = decodeURIComponent(pathname);
-        }
-        catch {
-            writeText(response, 400, "Bad Request");
-            return;
-        }
-        // Reject embedded NUL bytes outright rather than letting them reach the fs.
-        if (decoded.includes("\0")) {
-            writeText(response, 400, "Bad Request");
-            return;
-        }
-        let relative = decoded.replace(/^\/+/, "");
-        if (relative === "" || relative.endsWith("/")) {
-            relative = `${relative}${indexRelative}`;
-        }
-        const target = path.resolve(root.physicalPath, relative);
-        if (!isPathInside(root.physicalPath, target)) {
-            writeText(response, 403, "Forbidden");
-            return;
-        }
-        let info;
-        try {
-            info = await lstat(target);
-        }
-        catch {
-            writeText(response, 404, "Not Found");
-            return;
-        }
-        if (info.isSymbolicLink()) {
-            writeText(response, 403, "Forbidden");
-            return;
-        }
-        let filePath = target;
-        if (info.isDirectory()) {
-            filePath = path.resolve(target, indexRelative);
-            if (!isPathInside(root.physicalPath, filePath)) {
-                writeText(response, 403, "Forbidden");
-                return;
-            }
-        }
-        const rawBody = await readContainedRegularFile(root, filePath);
-        const body = rawBody ? recordedObserverStaticBody(filePath, rawBody) : null;
-        if (!body) {
-            writeText(response, 404, "Not Found");
-            return;
-        }
-        response.writeHead(200, {
-            "cache-control": "no-store",
-            "content-type": observerStaticContentType(filePath),
-            "content-length": String(body.byteLength),
-        });
-        if (method === "HEAD") {
-            response.end();
-            return;
-        }
-        response.end(body);
-    }
-    catch {
-        if (response.headersSent) {
-            response.end();
-            return;
-        }
-        writeText(response, 500, "Observer request failed");
-    }
-}
-function applySecurityHeaders(response) {
-    for (const [name, value] of Object.entries(buildArtifactSecurityHeaders()))
-        response.setHeader(name, value);
-}
-/** Static serving is recorded evidence. Neither JSON files nor inline HTML snapshots
- * can carry a live process observation or grant provider-origin access. */
-function recordedObserverStaticBody(filePath, body) {
-    const strip = (text) => {
-        try {
-            const data = JSON.parse(text);
-            if (!data ||
-                typeof data !== "object" ||
-                Array.isArray(data) ||
-                data.schema !== "humanish.observer-data.v1")
-                return null;
-            const projection = data;
-            delete projection.runtime;
-            if (Array.isArray(projection.streams)) {
-                for (const stream of projection.streams) {
-                    if (!stream || typeof stream !== "object" || Array.isArray(stream))
-                        continue;
-                    const embed = stream.embed;
-                    if (embed && typeof embed === "object" && !Array.isArray(embed))
-                        delete embed.runtimeDesktop;
-                }
-            }
-            return JSON.stringify(projection)
-                .replace(/</g, "\\u003c")
-                .replace(/>/g, "\\u003e")
-                .replace(/&/g, "\\u0026");
-        }
-        catch {
-            return null;
-        }
-    };
-    if (path.basename(filePath) === "observer-data.json") {
-        const stripped = strip(body.toString("utf8"));
-        return stripped === null ? body : Buffer.from(stripped);
-    }
-    if (/\.html?$/i.test(filePath)) {
-        const html = body.toString("utf8");
-        // Identify Observer JSON by its schema, not an attribute spelling: HTML permits
-        // encoded ids and '>' inside quoted attributes. Other scripts remain byte-identical.
-        const sanitized = html.replace(/(<script\b(?:[^>"']|"[^"]*"|'[^']*')*>)([\s\S]*?)(<\/script\s*>)/gi, (match, start, json, end) => {
-            const stripped = strip(json);
-            return stripped === null ? match : `${start}${stripped}${end}`;
-        });
-        return sanitized === html ? body : Buffer.from(sanitized);
-    }
-    return body;
-}
-async function readContainedRegularFile(root, filePathInput) {
-    const filePath = path.resolve(filePathInput);
-    if (!isPathInside(root.physicalPath, filePath))
-        return null;
-    try {
-        await assertPinnedStaticRoot(root);
-        const expectedStats = await inspectContainedStaticFile(root, filePath);
-        if (!expectedStats) {
-            return null;
-        }
-        const handle = await open(filePath, fsConstants.O_RDONLY | fsConstants.O_NOFOLLOW);
-        try {
-            const openedStats = await handle.stat({ bigint: true });
-            if (!openedStats.isFile() ||
-                openedStats.nlink !== 1n ||
-                openedStats.dev !== expectedStats.dev ||
-                openedStats.ino !== expectedStats.ino) {
-                return null;
-            }
-            const recheckedStats = await inspectContainedStaticFile(root, filePath);
-            if (!recheckedStats ||
-                recheckedStats.dev !== expectedStats.dev ||
-                recheckedStats.ino !== expectedStats.ino) {
-                return null;
-            }
-            await assertPinnedStaticRoot(root);
-            const body = await handle.readFile();
-            await assertPinnedStaticRoot(root);
-            return body;
-        }
-        finally {
-            await handle.close();
-        }
-    }
-    catch {
-        return null;
-    }
-}
-export function createObserverStaticHandler(options) {
-    let rootPromise;
-    return (request, response) => {
-        applySecurityHeaders(response);
-        rootPromise ??= pinStaticRoot(options.root);
-        void rootPromise
-            .then((root) => respondToPinnedObserverStaticRequest(root, options, request, response))
-            .catch(() => {
-            if (response.headersSent) {
-                response.end();
-                return;
-            }
-            writeText(response, 500, "Observer request failed");
-        });
-    };
-}
-export async function serveObserverStatic(options) {
-    const entryPath = options.entryPath?.replace(/^\/+/, "") ?? "";
-    const handlerOptions = {
-        root: options.root,
-        ...(options.indexPath === undefined ? {} : { indexPath: options.indexPath }),
-        ...(entryPath ? { redirectRootTo: entryPath } : {}),
-    };
-    const root = await pinStaticRoot(options.root);
-    const handler = (request, response) => {
-        void respondToPinnedObserverStaticRequest(root, handlerOptions, request, response);
-    };
-    const server = createServer(handler);
-    const port = await listen(server, options.port ?? 0);
-    return {
-        url: `http://${OBSERVER_STATIC_HOST}:${port}/${entryPath}`,
-        port,
-        host: OBSERVER_STATIC_HOST,
-        close: () => closeServer(server),
-    };
-}
-function writeText(response, status, message) {
-    const body = `${message}\n`;
-    response.writeHead(status, {
-        "cache-control": "no-store",
-        "content-type": "text/plain; charset=utf-8",
-        "content-length": String(Buffer.byteLength(body)),
-    });
-    response.end(body);
-}
-function isPathInside(root, candidate) {
-    const relative = path.relative(root, candidate);
-    return (relative === "" ||
-        (relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative)));
-}
-async function inspectContainedStaticFile(root, filePath) {
-    const relative = path.relative(root.physicalPath, filePath);
-    if (!relative ||
-        relative === ".." ||
-        relative.startsWith(`..${path.sep}`) ||
-        path.isAbsolute(relative)) {
-        return null;
-    }
-    const segments = relative.split(path.sep).filter(Boolean);
-    let current = root.physicalPath;
-    let fileIdentity = null;
-    for (const [index, segment] of segments.entries()) {
-        current = path.join(current, segment);
-        const stats = await lstat(current, { bigint: true });
-        if (stats.isSymbolicLink())
-            return null;
-        if (index < segments.length - 1) {
-            if (!stats.isDirectory())
-                return null;
-        }
-        else {
-            if (!stats.isFile() || stats.nlink !== 1n)
-                return null;
-            fileIdentity = { dev: stats.dev, ino: stats.ino };
-        }
-    }
-    if ((await realpath(filePath)) !== filePath)
-        return null;
-    return fileIdentity;
-}
-async function pinStaticRoot(rootInput) {
-    const physicalPath = await realpath(path.resolve(rootInput));
-    const stats = await lstat(physicalPath, { bigint: true });
-    if (stats.isSymbolicLink() || !stats.isDirectory()) {
-        throw new Error("Observer static roots must be physical directories.");
-    }
-    return Object.freeze({
-        birthtimeNs: stats.birthtimeNs,
-        dev: stats.dev,
-        ino: stats.ino,
-        physicalPath,
-    });
-}
-async function assertPinnedStaticRoot(root) {
-    const stats = await lstat(root.physicalPath, { bigint: true });
-    if (stats.isSymbolicLink() ||
-        !stats.isDirectory() ||
-        stats.birthtimeNs !== root.birthtimeNs ||
-        stats.dev !== root.dev ||
-        stats.ino !== root.ino ||
-        (await realpath(root.physicalPath)) !== root.physicalPath) {
-        throw new Error("Observer static root identity changed.");
-    }
-}
-function listen(server, port) {
-    return new Promise((resolve, reject) => {
-        server.once("error", reject);
-        server.listen(port, OBSERVER_STATIC_HOST, () => {
-            server.off("error", reject);
-            const address = server.address();
-            if (!address || typeof address === "string") {
-                reject(new Error("Observer static server did not bind to a TCP port."));
-                return;
-            }
-            resolve(address.port);
-        });
-    });
-}
-function closeServer(server) {
-    return new Promise((resolve, reject) => {
-        server.close((error) => {
-            if (error) {
-                reject(error);
-            }
-            else {
-                resolve();
-            }
-        });
-    });
-}