@nylorun/runtime 0.9.0-beta → 0.10.0-beta

package/dist/host/create-host.js

@@ -0,0 +1,396 @@
+import { createServer, } from "node:http";
+import { createHash, timingSafeEqual } from "node:crypto";
+import { unlinkSync, existsSync } from "node:fs";
+import { checkCompatibility, HOST_PROTOCOL, isTenantId, PROTOCOL_HEADER, TENANT_HEADER, } from "@nylorun/core/compatibility";
+import { AdminStatusSchema, CreateTenantRequestSchema, } from "@nylorun/core/contracts";
+import { hostPaths } from "../tenant/paths.js";
+import { TenantBusyError, TenantConflictError, } from "../tenant/quarantine.js";
+import { EXIT_NON_LOOPBACK, EXIT_PORT_IN_USE, HostListenError, isAllowedRequestHost, isJsonContentType, isLoopbackHost, readBearer, readJsonBody, redactRoutePath, requestHasBody, sendJson, sendOpaqueNotFound, sendProtocolRejected, sendRejected, } from "./http.js";
+import { RUNTIME_VERSION } from "../version.js";
+function hashUtf8(value) {
+    return createHash("sha256").update(value, "utf8").digest();
+}
+/** Constant-time comparison of SHA-256 digests of the presented and stored admin keys. */
+export function adminKeyMatches(presented, adminKey) {
+    if (presented === undefined)
+        return false;
+    const a = hashUtf8(presented);
+    const b = hashUtf8(adminKey);
+    return a.length === b.length && timingSafeEqual(a, b);
+}
+function headerValue(headers, name) {
+    const raw = headers[name.toLowerCase()];
+    if (Array.isArray(raw))
+        return raw[0];
+    return raw;
+}
+function parseProtocolVersion(raw) {
+    if (raw === undefined)
+        return undefined;
+    const trimmed = raw.trim();
+    if (!/^\d+$/.test(trimmed))
+        return undefined;
+    return Number(trimmed);
+}
+function protocolAccepted(raw) {
+    const version = parseProtocolVersion(raw);
+    if (version === undefined)
+        return false;
+    return checkCompatibility({ version, required: [] }, HOST_PROTOCOL).ok;
+}
+export function createHost(options) {
+    const { hostRoot, module, config, credentials, logger, coreVersion, } = options;
+    const pid = options.pid ?? process.pid;
+    const paths = hostPaths(hostRoot);
+    let server;
+    let url = "";
+    let listenPort = config.port;
+    let closing = false;
+    let closePromise;
+    const adminStatusBody = async () => {
+        const tenants = await module.list();
+        const aggregate = module.summarize();
+        return AdminStatusSchema.parse({
+            service: "nylorun-runtime",
+            version: RUNTIME_VERSION,
+            protocol: {
+                min: HOST_PROTOCOL.min,
+                max: HOST_PROTOCOL.max,
+                features: [...HOST_PROTOCOL.features],
+            },
+            tenants,
+            aggregate,
+            host: {
+                hostId: config.hostId,
+                url,
+                pid,
+            },
+        });
+    };
+    const requireAdmin = (request, response) => {
+        const token = readBearer(headerValue(request.headers, "authorization"));
+        if (!adminKeyMatches(token, credentials.adminKey)) {
+            sendOpaqueNotFound(response);
+            return false;
+        }
+        return true;
+    };
+    const handleAdmin = async (request, response, urlObj, segments) => {
+        const method = request.method ?? "GET";
+        // /v1/admin/...
+        if (segments[2] === "tenants") {
+            if (segments.length === 3 && method === "GET") {
+                const tenants = await module.list();
+                return sendJson(response, 200, tenants);
+            }
+            if (segments.length === 3 && method === "POST") {
+                const body = CreateTenantRequestSchema.parse(await readJsonBody(request));
+                try {
+                    const result = await module.create({
+                        tenantId: body.tenantId,
+                        name: body.name,
+                        principalId: body.principalId,
+                        credentialHash: body.credentialHash,
+                        idempotencyKey: body.idempotencyKey,
+                    });
+                    return sendJson(response, result.created ? 201 : 200, result.envelope);
+                }
+                catch (error) {
+                    const code = error.code;
+                    if (error instanceof TenantConflictError ||
+                        error.name === "TenantConflictError" ||
+                        code === "conflict" ||
+                        code === "tenant_conflict") {
+                        return sendRejected(response, 409, "tenant_conflict", error instanceof Error ? error.message : "Tenant conflict");
+                    }
+                    throw error;
+                }
+            }
+            if (segments.length === 4 && segments[3]) {
+                const id = segments[3];
+                if (method === "GET") {
+                    const status = await module.status(id);
+                    if (!status)
+                        return sendOpaqueNotFound(response);
+                    return sendJson(response, 200, status);
+                }
+                if (method === "DELETE") {
+                    const activeWork = urlObj.searchParams.get("activeWork") ?? "refuse";
+                    if (activeWork !== "refuse" &&
+                        activeWork !== "drain" &&
+                        activeWork !== "cancel") {
+                        return sendJson(response, 400, {
+                            status: "rejected",
+                            code: "invalid_request",
+                            message: "activeWork must be refuse, drain, or cancel",
+                        });
+                    }
+                    try {
+                        await module.delete(id, activeWork);
+                        response.writeHead(204);
+                        response.end();
+                        return;
+                    }
+                    catch (error) {
+                        const code = error.code;
+                        if (error instanceof TenantBusyError ||
+                            error.name === "TenantBusyError" ||
+                            code === "active_work" ||
+                            code === "conflict") {
+                            return sendRejected(response, 409, "active_work", error instanceof Error ? error.message : "Active work");
+                        }
+                        throw error;
+                    }
+                }
+            }
+        }
+        // D12: /v1/admin/status and /v1/admin/host share one handler.
+        if ((segments[2] === "host" || segments[2] === "status") &&
+            segments.length === 3 &&
+            method === "GET") {
+            return sendJson(response, 200, await adminStatusBody());
+        }
+        if (segments[2] === "host" &&
+            segments.length === 4 &&
+            segments[3] === "shutdown" &&
+            method === "POST") {
+            sendJson(response, 200, { status: "shutting_down" });
+            void close();
+            return;
+        }
+        return sendRejected(response, 404, "not_found", "Route not found");
+    };
+    const handle = async (request, response) => {
+        const started = Date.now();
+        let tenantId;
+        let statusCode = 500;
+        try {
+            const urlObj = new URL(request.url ?? "/", "http://runtime.local");
+            const pathname = urlObj.pathname;
+            // D§11: Host, Origin, then Content-Type — before any other processing.
+            const hostHeader = headerValue(request.headers, "host");
+            if (!isAllowedRequestHost(hostHeader, {
+                port: listenPort,
+                host: config.host,
+                allowNonLoopback: config.allowNonLoopback,
+            })) {
+                sendRejected(response, 421, "host_rejected", "Host header is not an allowed loopback or configured address");
+                statusCode = 421;
+                return;
+            }
+            if (headerValue(request.headers, "origin") !== undefined) {
+                sendRejected(response, 403, "origin_rejected", "Browser Origin headers are not accepted");
+                statusCode = 403;
+                return;
+            }
+            if (requestHasBody(request) &&
+                !isJsonContentType(headerValue(request.headers, "content-type"))) {
+                sendRejected(response, 415, "unsupported_media_type", "Request bodies must use application/json");
+                statusCode = 415;
+                return;
+            }
+            if (pathname === "/health") {
+                sendJson(response, 200, {
+                    status: "ok",
+                    service: "nylorun-runtime",
+                    version: RUNTIME_VERSION,
+                    protocol: {
+                        min: HOST_PROTOCOL.min,
+                        max: HOST_PROTOCOL.max,
+                        features: [...HOST_PROTOCOL.features],
+                    },
+                    coreVersion,
+                    hostId: config.hostId,
+                    pid,
+                });
+                statusCode = 200;
+                return;
+            }
+            if (pathname === "/ready") {
+                const listener = Boolean(server?.listening);
+                const discovery = module.started;
+                const ready = listener && discovery && !closing;
+                sendJson(response, ready ? 200 : 503, {
+                    status: ready ? "ready" : "not_ready",
+                    service: "nylorun-runtime",
+                    checks: { listener, discovery },
+                });
+                statusCode = ready ? 200 : 503;
+                return;
+            }
+            const segments = pathname.split("/").filter(Boolean);
+            const isAdmin = segments[0] === "v1" && segments[1] === "admin";
+            if (isAdmin) {
+                const protocolHeader = headerValue(request.headers, PROTOCOL_HEADER);
+                if (!protocolAccepted(protocolHeader)) {
+                    sendProtocolRejected(response);
+                    statusCode = 426;
+                    return;
+                }
+                if (!requireAdmin(request, response)) {
+                    statusCode = 404;
+                    return;
+                }
+                await handleAdmin(request, response, urlObj, segments);
+                statusCode = response.statusCode || 200;
+                return;
+            }
+            // Tenant-scoped routes: header pattern → protocol → resolve → Tenant handle.
+            const tenantHeader = headerValue(request.headers, TENANT_HEADER);
+            if (tenantHeader === undefined || tenantHeader.trim() === "") {
+                sendJson(response, 400, {
+                    status: "rejected",
+                    code: "invalid_request",
+                    message: `${TENANT_HEADER} header is required`,
+                });
+                statusCode = 400;
+                return;
+            }
+            if (!isTenantId(tenantHeader)) {
+                sendJson(response, 400, {
+                    status: "rejected",
+                    code: "invalid_request",
+                    message: `${TENANT_HEADER} header is malformed`,
+                });
+                statusCode = 400;
+                return;
+            }
+            tenantId = tenantHeader;
+            const protocolHeader = headerValue(request.headers, PROTOCOL_HEADER);
+            if (!protocolAccepted(protocolHeader)) {
+                sendProtocolRejected(response);
+                statusCode = 426;
+                return;
+            }
+            const resolution = module.resolve(tenantId);
+            if (resolution.kind !== "open") {
+                if (resolution.kind === "quarantined") {
+                    logger.warn("tenant_quarantined", {
+                        tenantId,
+                        code: resolution.quarantine.code,
+                        repair: resolution.quarantine.repair,
+                    });
+                }
+                sendOpaqueNotFound(response);
+                statusCode = 404;
+                return;
+            }
+            await resolution.handle.handle(request, response, urlObj);
+            statusCode = response.statusCode || 200;
+        }
+        catch (error) {
+            const status = error.status;
+            if (typeof status === "number" && status >= 400 && status < 600) {
+                sendJson(response, status, {
+                    status: "rejected",
+                    code: status === 400 ? "invalid_request" : "request_rejected",
+                    message: error instanceof Error ? error.message : "Request rejected",
+                });
+                statusCode = status;
+            }
+            else if (error &&
+                typeof error === "object" &&
+                "name" in error &&
+                error.name === "ZodError") {
+                sendJson(response, 400, {
+                    status: "rejected",
+                    code: "invalid_request",
+                    message: "Invalid request body",
+                });
+                statusCode = 400;
+            }
+            else {
+                logger.error("request_failed", {
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                if (!response.headersSent) {
+                    sendJson(response, 500, {
+                        status: "rejected",
+                        code: "internal_error",
+                        message: "Internal error",
+                    });
+                }
+                statusCode = 500;
+            }
+        }
+        finally {
+            if (pathnameIsLogged(request.url)) {
+                logger.info("request", {
+                    status: statusCode,
+                    tenantId,
+                    durationMs: Date.now() - started,
+                    path: redactRoutePath(new URL(request.url ?? "/", "http://runtime.local").pathname),
+                    method: request.method,
+                });
+            }
+        }
+    };
+    async function listen() {
+        if (server)
+            throw new Error("Already listening");
+        if (!config.allowNonLoopback && !isLoopbackHost(config.host)) {
+            throw new HostListenError(`Refusing to bind non-loopback host ${config.host} without allowNonLoopback`, EXIT_NON_LOOPBACK);
+        }
+        server = createServer((req, res) => {
+            void handle(req, res);
+        });
+        await new Promise((resolve, reject) => {
+            server.once("error", (error) => {
+                if (error.code === "EADDRINUSE") {
+                    reject(new HostListenError(`Port ${config.port} on ${config.host} is already in use`, EXIT_PORT_IN_USE, error));
+                    return;
+                }
+                reject(error);
+            });
+            server.listen(config.port, config.host, resolve);
+        });
+        const address = server.address();
+        listenPort =
+            typeof address === "object" && address ? address.port : config.port;
+        url = `http://${config.host}:${listenPort}`;
+        await module.start();
+        logger.info("host_listening", {
+            hostId: config.hostId,
+            url,
+            pid,
+        });
+    }
+    async function close() {
+        if (closePromise)
+            return closePromise;
+        closePromise = (async () => {
+            closing = true;
+            logger.info("host_shutdown", { hostId: config.hostId });
+            if (server) {
+                await new Promise((resolve) => {
+                    server.close(() => resolve());
+                    server.closeIdleConnections?.();
+                });
+                server = undefined;
+            }
+            await module.close();
+            if (existsSync(paths.state)) {
+                try {
+                    unlinkSync(paths.state);
+                }
+                catch {
+                    /* best-effort */
+                }
+            }
+        })();
+        return closePromise;
+    }
+    return {
+        listen,
+        close,
+        get url() {
+            return url;
+        },
+    };
+}
+function pathnameIsLogged(rawUrl) {
+    if (!rawUrl)
+        return true;
+    const pathname = new URL(rawUrl, "http://runtime.local").pathname;
+    return pathname !== "/health" && pathname !== "/ready";
+}

package/dist/host/environment.d.ts

@@ -0,0 +1,13 @@
+import type { HostConfigFile } from "./config.js";
+import type { HostPaths } from "../tenant/paths.js";
+import type { TenantPaths } from "../tenant/types.js";
+/**
+ * Allowlisted ambient keys for Host and Tenant child processes.
+ * `NODE_OPTIONS` is never copied.
+ */
+export declare function baselineEnvironment(env: NodeJS.ProcessEnv | Readonly<Record<string, string | undefined>>): Record<string, string>;
+export type HostProcessPathInputs = Pick<HostPaths, "root" | "home" | "tmp">;
+/** Environment for the Runtime Host process itself (CLI spawn / `runtime run`). */
+export declare function hostProcessEnvironment(baseline: Readonly<Record<string, string>>, hostConfig: HostConfigFile, paths: HostProcessPathInputs): Record<string, string>;
+/** Environment for Tenant-owned children (MCP stdio, sandboxes). */
+export declare function tenantChildEnvironment(baseline: Readonly<Record<string, string>>, hostConfig: HostConfigFile, tenantPaths: TenantPaths): Record<string, string>;

package/dist/host/environment.js

@@ -0,0 +1,53 @@
+const BASELINE_KEYS = new Set(["PATH", "LANG", "TZ"]);
+function isBaselineKey(key) {
+    return BASELINE_KEYS.has(key) || key.startsWith("LC_");
+}
+/**
+ * Allowlisted ambient keys for Host and Tenant child processes.
+ * `NODE_OPTIONS` is never copied.
+ */
+export function baselineEnvironment(env) {
+    const out = {};
+    for (const [key, value] of Object.entries(env)) {
+        if (value === undefined)
+            continue;
+        if (key === "NODE_OPTIONS")
+            continue;
+        if (!isBaselineKey(key))
+            continue;
+        out[key] = value;
+    }
+    return out;
+}
+function proxyEnv(hostConfig) {
+    const out = {};
+    const proxy = hostConfig.proxy;
+    if (!proxy)
+        return out;
+    if (proxy.httpsProxy)
+        out.HTTPS_PROXY = proxy.httpsProxy;
+    if (proxy.noProxy)
+        out.NO_PROXY = proxy.noProxy;
+    if (proxy.nodeExtraCaCerts)
+        out.NODE_EXTRA_CA_CERTS = proxy.nodeExtraCaCerts;
+    return out;
+}
+/** Environment for the Runtime Host process itself (CLI spawn / `runtime run`). */
+export function hostProcessEnvironment(baseline, hostConfig, paths) {
+    return {
+        ...baseline,
+        ...proxyEnv(hostConfig),
+        HOME: paths.home,
+        TMPDIR: paths.tmp,
+        NYLORUN_HOME: paths.root,
+    };
+}
+/** Environment for Tenant-owned children (MCP stdio, sandboxes). */
+export function tenantChildEnvironment(baseline, hostConfig, tenantPaths) {
+    return {
+        ...baseline,
+        ...proxyEnv(hostConfig),
+        HOME: tenantPaths.home,
+        TMPDIR: tenantPaths.tmp,
+    };
+}

package/dist/host/http.d.ts

@@ -0,0 +1,35 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import { type ErrorCode, type ProtocolRange } from "@nylorun/core/compatibility";
+export declare const OPAQUE_NOT_FOUND: {
+    status: "rejected";
+    code: "not_found";
+    message: string;
+};
+export declare const EXIT_PORT_IN_USE = 98;
+export declare const EXIT_NON_LOOPBACK = 99;
+export declare class HostListenError extends Error {
+    readonly exitCode: number;
+    readonly cause?: unknown;
+    constructor(message: string, exitCode: number, cause?: unknown);
+}
+export declare function sendJson(response: ServerResponse, status: number, body: unknown): void;
+export declare function sendRejected(response: ServerResponse, status: number, code: ErrorCode, message: string, details?: unknown): void;
+export declare function sendOpaqueNotFound(response: ServerResponse): void;
+export declare function sendProtocolRejected(response: ServerResponse, protocol?: ProtocolRange): void;
+/**
+ * D§11 Host allowlist: loopback forms with the listening port, plus the
+ * configured host when `allowNonLoopback` is set.
+ */
+export declare function isAllowedRequestHost(hostHeader: string | undefined, options: {
+    port: number;
+    host: string;
+    allowNonLoopback?: boolean;
+}): boolean;
+export declare function isJsonContentType(value: string | undefined): boolean;
+/** True when the request carries a body (Content-Length > 0 or chunked). */
+export declare function requestHasBody(request: IncomingMessage): boolean;
+/** Redact path parameters after `/v1/sessions/` for Host logs. */
+export declare function redactRoutePath(pathname: string): string;
+export declare function readBearer(authorization: string | undefined): string | undefined;
+export declare function readJsonBody(request: import("node:http").IncomingMessage, limit?: number): Promise<unknown>;
+export declare function isLoopbackHost(host: string): boolean;

package/dist/host/http.js

@@ -0,0 +1,136 @@
+import { HOST_PROTOCOL, } from "@nylorun/core/compatibility";
+export const OPAQUE_NOT_FOUND = {
+    status: "rejected",
+    code: "not_found",
+    message: "Not found",
+};
+export const EXIT_PORT_IN_USE = 98;
+export const EXIT_NON_LOOPBACK = 99;
+export class HostListenError extends Error {
+    exitCode;
+    cause;
+    constructor(message, exitCode, cause) {
+        super(message);
+        this.exitCode = exitCode;
+        this.cause = cause;
+        this.name = "HostListenError";
+    }
+}
+export function sendJson(response, status, body) {
+    const payload = JSON.stringify(body);
+    // No Access-Control-* headers (D§11).
+    response.writeHead(status, {
+        "content-type": "application/json",
+        "content-length": Buffer.byteLength(payload),
+    });
+    response.end(payload);
+}
+export function sendRejected(response, status, code, message, details) {
+    const body = { status: "rejected", code, message };
+    if (details !== undefined)
+        body.details = details;
+    sendJson(response, status, body);
+}
+export function sendOpaqueNotFound(response) {
+    sendJson(response, 404, OPAQUE_NOT_FOUND);
+}
+export function sendProtocolRejected(response, protocol = HOST_PROTOCOL) {
+    sendJson(response, 426, {
+        status: "rejected",
+        code: "protocol_unsupported",
+        protocol: {
+            min: protocol.min,
+            max: protocol.max,
+            features: [...protocol.features],
+        },
+    });
+}
+/**
+ * D§11 Host allowlist: loopback forms with the listening port, plus the
+ * configured host when `allowNonLoopback` is set.
+ */
+export function isAllowedRequestHost(hostHeader, options) {
+    if (hostHeader === undefined)
+        return false;
+    const normalized = hostHeader.trim().toLowerCase();
+    const port = String(options.port);
+    const allowed = new Set([
+        `127.0.0.1:${port}`,
+        `localhost:${port}`,
+        `[::1]:${port}`,
+    ]);
+    if (options.allowNonLoopback) {
+        const configured = options.host.trim().toLowerCase();
+        if (configured.includes(":") && !configured.startsWith("[")) {
+            allowed.add(`[${configured}]:${port}`);
+        }
+        else {
+            allowed.add(`${configured}:${port}`);
+        }
+    }
+    return allowed.has(normalized);
+}
+export function isJsonContentType(value) {
+    if (value === undefined)
+        return false;
+    const media = value.split(";")[0].trim().toLowerCase();
+    return media === "application/json";
+}
+/** True when the request carries a body (Content-Length > 0 or chunked). */
+export function requestHasBody(request) {
+    const te = request.headers["transfer-encoding"];
+    const transfer = Array.isArray(te) ? te.join(",") : te;
+    if (transfer && transfer.toLowerCase() !== "identity")
+        return true;
+    const cl = request.headers["content-length"];
+    const raw = Array.isArray(cl) ? cl[0] : cl;
+    if (raw === undefined)
+        return false;
+    const n = Number(raw);
+    return Number.isFinite(n) && n > 0;
+}
+/** Redact path parameters after `/v1/sessions/` for Host logs. */
+export function redactRoutePath(pathname) {
+    const parts = pathname.split("/");
+    // ["", "v1", "sessions", "<id>", ...]
+    if (parts[1] === "v1" && parts[2] === "sessions" && parts.length > 3) {
+        return `/v1/sessions/:id${parts.length > 4 ? "/…" : ""}`;
+    }
+    return pathname;
+}
+export function readBearer(authorization) {
+    if (!authorization)
+        return undefined;
+    const match = /^Bearer\s+(\S+)/i.exec(authorization.trim());
+    return match?.[1];
+}
+export async function readJsonBody(request, limit = 1024 * 1024) {
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of request) {
+        const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        size += buf.length;
+        if (size > limit) {
+            const error = new Error("Request too large");
+            error.status = 413;
+            throw error;
+        }
+        chunks.push(buf);
+    }
+    if (chunks.length === 0)
+        return undefined;
+    try {
+        return JSON.parse(Buffer.concat(chunks).toString("utf8"));
+    }
+    catch {
+        const error = new Error("Invalid JSON");
+        error.status = 400;
+        throw error;
+    }
+}
+export function isLoopbackHost(host) {
+    const normalized = host.trim().toLowerCase();
+    return (normalized === "127.0.0.1" ||
+        normalized === "::1" ||
+        normalized === "localhost");
+}

package/dist/host/index.d.ts

@@ -0,0 +1,6 @@
+export type { HostConfigFile, HostCredentialsFile, HostStateFile, } from "./config.js";
+export { baselineEnvironment, hostProcessEnvironment, tenantChildEnvironment, } from "./environment.js";
+export { createHost, adminKeyMatches, type CreateHostOptions, type HostServer } from "./create-host.js";
+export { createHostLogger } from "./logger.js";
+export { configForFactory } from "./config-for.js";
+export { EXIT_PORT_IN_USE, EXIT_NON_LOOPBACK, HostListenError, OPAQUE_NOT_FOUND, } from "./http.js";

package/dist/host/index.js

@@ -0,0 +1,5 @@
+export { baselineEnvironment, hostProcessEnvironment, tenantChildEnvironment, } from "./environment.js";
+export { createHost, adminKeyMatches } from "./create-host.js";
+export { createHostLogger } from "./logger.js";
+export { configForFactory } from "./config-for.js";
+export { EXIT_PORT_IN_USE, EXIT_NON_LOOPBACK, HostListenError, OPAQUE_NOT_FOUND, } from "./http.js";

package/dist/host/logger.d.ts

@@ -0,0 +1,3 @@
+import type { Logger } from "../tenant/types.js";
+/** Host logger: JSON lines to stdout (CLI redirects to `runtime.log`). */
+export declare function createHostLogger(write?: (line: string) => void): Logger;

package/dist/host/logger.js

@@ -0,0 +1,18 @@
+/** Host logger: JSON lines to stdout (CLI redirects to `runtime.log`). */
+export function createHostLogger(write = (line) => {
+    process.stdout.write(`${line}\n`);
+}) {
+    const emit = (level, message, fields) => {
+        write(JSON.stringify({
+            level,
+            message,
+            time: new Date().toISOString(),
+            ...fields,
+        }));
+    };
+    return {
+        info: (message, fields) => emit("info", message, fields),
+        warn: (message, fields) => emit("warn", message, fields),
+        error: (message, fields) => emit("error", message, fields),
+    };
+}

package/dist/host/main.d.ts

@@ -0,0 +1,3 @@
+import { EXIT_PORT_IN_USE, EXIT_NON_LOOPBACK } from "./http.js";
+export declare function main(): Promise<void>;
+export { EXIT_PORT_IN_USE, EXIT_NON_LOOPBACK };