@fungi.computer/computer 0.0.0-stage → 0.1.0

package/dist/light-shell.d.ts

@@ -0,0 +1,44 @@
+export type ShellRoute = Readonly<{
+    where: "light";
+}> | Readonly<{
+    where: "full";
+    reason: string;
+}> | Readonly<{
+    where: "invalid";
+    message: string;
+}>;
+export declare const lightShellCommands: readonly string[];
+/** Route the maintained parser's AST before either backend executes anything. */
+export declare function routeShellCommand(source: string): ShellRoute;
+export type CommandCompletion = Readonly<{
+    name: string;
+    where: "light" | "full";
+}>;
+/** First-word completion reads the maintained AST; quoted/path completion is deferred. */
+export declare function completeShellCommand(source: string): readonly CommandCompletion[] | null | Readonly<{
+    kind: "invalid";
+    message: string;
+}>;
+/**
+ * `cd`/`export` route light (they need no external program), but the exec
+ * primitive behind a light command has no state event yet: each run is its
+ * own process, so a bare `cd`/`export` would report success and change
+ * nothing the next command sees. True only for a line that is exactly one
+ * such invocation, so the caller can refuse it honestly instead of faking a
+ * result; a `cd`/`export` combined with other work is not detected here and
+ * still runs, silently without the navigation/export effect, as today.
+ */
+export declare function bareNavigationCommand(source: string): Readonly<{
+    name: "cd" | "export";
+}> | null;
+/** Prompt controls never become a backend command or change model shell grammar. */
+export declare function prepareShellPrompt(source: string): Readonly<{
+    kind: "command";
+    command: string;
+    route: ShellRoute;
+}> | Readonly<{
+    kind: "light" | "exit";
+}> | Readonly<{
+    kind: "invalid";
+    message: string;
+}>;

package/dist/light-shell.js

@@ -0,0 +1,376 @@
+import * as z from "zod";
+import { Bash, getCommandNames } from "just-bash/browser";
+// These optional groups are intentionally absent from the Worker shell.
+const deferredGroups = new Set(["sqlite3", "html-to-markdown"]);
+export const lightShellCommands = [
+    ...getCommandNames().filter((name) => !deferredGroups.has(name)),
+    "cd",
+    "export",
+];
+const lightCommands = new Set(lightShellCommands);
+// Constructed lazily: a module that only needs the command set or types
+// (for example, a mounting React tree before any command is typed) should
+// never pay for a real just-bash parser instance.
+let parser;
+function shellParser() {
+    parser ??= new Bash({ commands: [] });
+    return parser;
+}
+function literalWord(parts) {
+    let value = "";
+    for (const part of parts) {
+        if (part.type === "DoubleQuoted") {
+            const quoted = literalWord(part.parts);
+            if (quoted === null)
+                return null;
+            value += quoted;
+        }
+        else if (part.type === "Literal" ||
+            part.type === "SingleQuoted" ||
+            part.type === "Escaped") {
+            value += part.value;
+        }
+        else
+            return null;
+    }
+    return value;
+}
+function routeStatements(statements) {
+    for (const statement of statements) {
+        if (statement.background)
+            return { where: "full", reason: "background job" };
+        if (statement.deferredError)
+            return { where: "invalid", message: statement.deferredError.message };
+        for (const pipeline of statement.pipelines) {
+            for (const command of pipeline.commands) {
+                const route = routeCommand(command);
+                if (route.where !== "light")
+                    return route;
+            }
+        }
+    }
+    return { where: "light" };
+}
+function routeCommand(command) {
+    for (const redirection of command.redirections) {
+        if (redirection.target.type === "HereDoc" && redirection.target.quoted)
+            continue;
+        const word = redirection.target.type === "HereDoc"
+            ? redirection.target.content
+            : redirection.target;
+        const route = routeWord(word.parts);
+        if (route.where !== "light")
+            return route;
+    }
+    if (command.type === "SimpleCommand") {
+        const name = command.name === null ? null : literalWord(command.name.parts);
+        if (name !== null && !lightCommands.has(name))
+            return { where: "full", reason: name };
+        const words = [
+            ...(command.name === null ? [] : [command.name]),
+            ...command.args,
+            ...command.assignments.flatMap((assignment) => [
+                ...(assignment.value === null ? [] : [assignment.value]),
+                ...(assignment.array ?? []),
+            ]),
+        ];
+        for (const word of words) {
+            const route = routeWord(word.parts);
+            if (route.where !== "light")
+                return route;
+        }
+        return { where: "light" };
+    }
+    if (command.type === "If") {
+        for (const clause of command.clauses) {
+            const route = routeStatements([...clause.condition, ...clause.body]);
+            if (route.where !== "light")
+                return route;
+        }
+        return routeStatements(command.elseBody ?? []);
+    }
+    if (command.type === "While" || command.type === "Until")
+        return routeStatements([...command.condition, ...command.body]);
+    if (command.type === "Subshell" || command.type === "Group")
+        return routeStatements(command.body);
+    if (command.type === "FunctionDef")
+        return routeCommand(command.body);
+    if (command.type === "For") {
+        for (const word of command.words ?? []) {
+            const route = routeWord(word.parts);
+            if (route.where !== "light")
+                return route;
+        }
+        return routeStatements(command.body);
+    }
+    if (command.type === "Case") {
+        const route = routeWord(command.word.parts);
+        if (route.where !== "light")
+            return route;
+        for (const item of command.items) {
+            for (const pattern of item.patterns) {
+                const route = routeWord(pattern.parts);
+                if (route.where !== "light")
+                    return route;
+            }
+            const route = routeStatements(item.body);
+            if (route.where !== "light")
+                return route;
+        }
+        return { where: "light" };
+    }
+    return { where: "full", reason: "shell expression" };
+}
+function routeWord(parts) {
+    for (const part of parts) {
+        if (part.type === "CommandSubstitution" ||
+            part.type === "ProcessSubstitution") {
+            const nested = routeStatements(part.body.statements);
+            if (nested.where !== "light")
+                return nested;
+        }
+        else if (part.type === "DoubleQuoted") {
+            const nested = routeWord(part.parts);
+            if (nested.where !== "light")
+                return nested;
+        }
+        else if (part.type === "ArithmeticExpansion") {
+            const nested = routeArithmetic(part.expression.expression);
+            if (nested.where !== "light")
+                return nested;
+        }
+        else if (part.type === "ParameterExpansion") {
+            const nested = routeParameter(part.operation);
+            if (nested.where !== "light")
+                return nested;
+        }
+    }
+    return { where: "light" };
+}
+function routeArithmetic(expression) {
+    if (expression.type === "ArithCommandSubst")
+        return routeShellCommand(expression.command);
+    // These forms expand and reparse text at execution time. Never replay them.
+    if (expression.type === "ArithBracedExpansion" ||
+        expression.type === "ArithDynamicBase" ||
+        expression.type === "ArithDynamicNumber")
+        return { where: "full", reason: "dynamic arithmetic" };
+    const children = [
+        ...("left" in expression ? [expression.left] : []),
+        ...("right" in expression ? [expression.right] : []),
+        ...("operand" in expression ? [expression.operand] : []),
+        ...("condition" in expression ? [expression.condition] : []),
+        ...("consequent" in expression ? [expression.consequent] : []),
+        ...("alternate" in expression ? [expression.alternate] : []),
+        ...(expression.type === "ArithAssignment" ||
+            expression.type === "ArithDynamicAssignment"
+            ? [expression.value]
+            : []),
+        ...("subscript" in expression ? [expression.subscript] : []),
+        ...("target" in expression ? [expression.target] : []),
+        ...("nameExpr" in expression ? [expression.nameExpr] : []),
+        ...("index" in expression ? [expression.index] : []),
+        ...("expression" in expression ? [expression.expression] : []),
+        ...("parts" in expression ? expression.parts : []),
+    ];
+    for (const child of children) {
+        const route = routeArithmetic(child);
+        if (route.where !== "light")
+            return route;
+    }
+    return { where: "light" };
+}
+function routeParameter(operation) {
+    if (!operation)
+        return { where: "light" };
+    const words = [
+        ...("word" in operation && operation.word ? [operation.word] : []),
+        ...("pattern" in operation && operation.pattern ? [operation.pattern] : []),
+        ...("replacement" in operation && operation.replacement
+            ? [operation.replacement]
+            : []),
+    ];
+    for (const word of words) {
+        const route = routeWord(word.parts);
+        if (route.where !== "light")
+            return route;
+    }
+    return "innerOp" in operation
+        ? routeParameter(operation.innerOp)
+        : { where: "light" };
+}
+function parseShell(source) {
+    try {
+        return { kind: "parsed", ast: shellParser().transform(source).ast };
+    }
+    catch (cause) {
+        return {
+            kind: "invalid",
+            message: cause instanceof Error ? cause.message : "Invalid shell syntax",
+        };
+    }
+}
+/** Route the maintained parser's AST before either backend executes anything. */
+export function routeShellCommand(source) {
+    const parsed = parseShell(source);
+    return parsed.kind === "invalid"
+        ? { where: "invalid", message: parsed.message }
+        : routeStatements(parsed.ast.statements);
+}
+const fullCompletionCommands = [
+    "bun",
+    "cargo",
+    "curl",
+    "docker",
+    "git",
+    "go",
+    "make",
+    "nano",
+    "node",
+    "npm",
+    "npx",
+    "pnpm",
+    "python3",
+    "ssh",
+    "vim",
+    "wget",
+];
+const completionCommands = [
+    ...new Set([...lightShellCommands, ...fullCompletionCommands]),
+].sort();
+/** First-word completion reads the maintained AST; quoted/path completion is deferred. */
+export function completeShellCommand(source) {
+    const parsed = parseShell(source);
+    if (parsed.kind === "invalid")
+        return parsed;
+    const statement = parsed.ast.statements[0];
+    if (statement === undefined ||
+        parsed.ast.statements.length !== 1 ||
+        statement.background ||
+        statement.deferredError ||
+        statement.pipelines.length !== 1)
+        return null;
+    const pipeline = statement.pipelines[0];
+    if (pipeline === undefined)
+        return null;
+    const command = pipeline.commands[0];
+    if (command === undefined ||
+        pipeline.commands.length !== 1 ||
+        pipeline.negated ||
+        pipeline.timed ||
+        command.type !== "SimpleCommand" ||
+        command.assignments.length !== 0 ||
+        command.redirections.length !== 0 ||
+        command.args.length !== 0 ||
+        command.name === null)
+        return null;
+    const parts = command.name.parts;
+    const part = parts[0];
+    if (parts.length !== 1 || part?.type !== "Literal" || part.value !== source)
+        return null;
+    return completionCommands
+        .filter((name) => name.startsWith(source))
+        .map((name) => ({
+        name,
+        where: lightCommands.has(name) ? "light" : "full",
+    }));
+}
+/**
+ * `cd`/`export` route light (they need no external program), but the exec
+ * primitive behind a light command has no state event yet: each run is its
+ * own process, so a bare `cd`/`export` would report success and change
+ * nothing the next command sees. True only for a line that is exactly one
+ * such invocation, so the caller can refuse it honestly instead of faking a
+ * result; a `cd`/`export` combined with other work is not detected here and
+ * still runs, silently without the navigation/export effect, as today.
+ */
+export function bareNavigationCommand(source) {
+    const parsed = parseShell(source);
+    if (parsed.kind === "invalid")
+        return null;
+    const statement = parsed.ast.statements[0];
+    if (statement === undefined ||
+        parsed.ast.statements.length !== 1 ||
+        statement.background ||
+        statement.deferredError ||
+        statement.pipelines.length !== 1)
+        return null;
+    const pipeline = statement.pipelines[0];
+    if (pipeline === undefined)
+        return null;
+    const command = pipeline.commands[0];
+    if (command === undefined ||
+        pipeline.commands.length !== 1 ||
+        pipeline.negated ||
+        pipeline.timed ||
+        command.type !== "SimpleCommand" ||
+        command.redirections.length !== 0)
+        return null;
+    const name = command.name === null ? null : literalWord(command.name.parts);
+    return name === "cd" || name === "export" ? { name } : null;
+}
+const promptControlSchema = z.enum(["ordinary", "full", "light", "exit"]);
+let promptParser;
+function shellPromptParser() {
+    if (promptParser !== undefined)
+        return promptParser;
+    const configured = new Bash({ commands: [] });
+    configured.registerTransformPlugin({
+        name: "fungi-shell-prompt",
+        transform: ({ ast }) => {
+            const statement = ast.statements[0];
+            const pipeline = statement?.pipelines[0];
+            const command = pipeline?.commands[0];
+            if (command?.type !== "SimpleCommand" || command.assignments.length !== 0)
+                return { ast, metadata: { control: "ordinary" } };
+            const name = command.name === null ? null : literalWord(command.name.parts);
+            const standalone = ast.statements.length === 1 &&
+                statement?.pipelines.length === 1 &&
+                pipeline?.commands.length === 1 &&
+                !statement.background &&
+                command.redirections.length === 0;
+            if ((name === "light" || name === "exit") &&
+                standalone &&
+                command.args.length === 0)
+                return { ast, metadata: { control: name } };
+            if (name !== "full")
+                return { ast, metadata: { control: "ordinary" } };
+            const next = command.args.shift();
+            if (next !== undefined) {
+                command.name = next;
+                return { ast, metadata: { control: "full" } };
+            }
+            return standalone
+                ? { ast: { ...ast, statements: [] }, metadata: { control: "full" } }
+                : { ast, metadata: { control: "ordinary" } };
+        },
+    });
+    promptParser = configured;
+    return configured;
+}
+/** Prompt controls never become a backend command or change model shell grammar. */
+export function prepareShellPrompt(source) {
+    try {
+        const transformed = shellPromptParser().transform(source);
+        const control = promptControlSchema.parse(transformed.metadata.control);
+        if (control === "light" || control === "exit")
+            return { kind: control };
+        const command = control === "full" ? transformed.script : source;
+        const route = routeStatements(transformed.ast.statements);
+        return {
+            kind: "command",
+            command,
+            route: route.where === "invalid"
+                ? route
+                : control === "full"
+                    ? { where: "full", reason: "explicit full" }
+                    : route,
+        };
+    }
+    catch (cause) {
+        return {
+            kind: "invalid",
+            message: cause instanceof Error ? cause.message : "Invalid shell syntax",
+        };
+    }
+}

package/dist/local-backend.d.ts

@@ -0,0 +1,52 @@
+import type { BackendHandle, WorkspaceBackend } from "@fungi.computer/cloudflare-computer";
+import { type LocalBackend } from "./computer-backends.js";
+/**
+ * A member's machine as a Workspace backend.
+ *
+ * The machine runs the same `computerd` as the container image and dials out
+ * to its Computer; there is no listener to reach. The Hub hands the accepted
+ * WebSocket to this Computer, which parks it here. `connect()` opens a capnweb
+ * session over the parked socket and returns the machine's `WorkspaceRPC` as a
+ * `sync: "remote"` handle, exactly as the container backend returns its
+ * `computerd`. With nothing parked the machine is offline and `connect()`
+ * fails at once, so routing can move on.
+ */
+export declare class LocalBackendOfflineError extends Error {
+    readonly backendId: string;
+    constructor(backendId: string);
+}
+/**
+ * The live dial-ins of one Computer, keyed by backend id. It outlives each
+ * Workspace generation so a rebuild does not forget a connected machine.
+ */
+export declare class LocalBackendConnections {
+    #private;
+    constructor(connected?: (id: string) => void);
+    online(id: string): boolean;
+    socket(id: string): WebSocket | undefined;
+    /** Park a verified dial-in; a newer dial from the same device replaces it. */
+    park(id: string, socket: WebSocket): void;
+    close(id: string, reason: string): void;
+    /** Close every dial-in whose backend is no longer attached. */
+    retain(attached: ReadonlySet<string>): void;
+}
+export declare class LocalWorkspaceBackend implements WorkspaceBackend {
+    #private;
+    readonly type = "fungi-local";
+    readonly id: string;
+    constructor(backend: LocalBackend, connections: LocalBackendConnections);
+    connect(): Promise<BackendHandle>;
+}
+/** The audience one attached local backend's dial-in is signed for. */
+export declare function localBackendAudience(computerName: string, backendId: string): string;
+/**
+ * Verify a machine's signed dial-in against the public key its attachment
+ * pinned. The WebSocket upgrade carries no body, so it signs an unsigned
+ * payload over the exact path.
+ */
+export declare function verifyLocalBackendDial(request: Request, computerName: string, backend: LocalBackend): Promise<boolean>;
+/**
+ * The public dial path: `/api/teams/:team/computers/:computer/backends/:id/connect`.
+ * The Hub forwards it unchanged so the signature covers what the machine sent.
+ */
+export declare const localBackendDialPath: RegExp;

package/dist/local-backend.js

@@ -0,0 +1,143 @@
+import { workspaceStream } from "./workspace-stream.js";
+import { newWebSocketRpcSession } from "@fungi.computer/capnweb";
+import { SeamReplayGuard, importSeamVerifiers, seamHeader, verifySeamRequest, } from "@fungi.computer/seam";
+import { attachedBackendId } from "./computer-backends.js";
+/**
+ * A member's machine as a Workspace backend.
+ *
+ * The machine runs the same `computerd` as the container image and dials out
+ * to its Computer; there is no listener to reach. The Hub hands the accepted
+ * WebSocket to this Computer, which parks it here. `connect()` opens a capnweb
+ * session over the parked socket and returns the machine's `WorkspaceRPC` as a
+ * `sync: "remote"` handle, exactly as the container backend returns its
+ * `computerd`. With nothing parked the machine is offline and `connect()`
+ * fails at once, so routing can move on.
+ */
+export class LocalBackendOfflineError extends Error {
+    backendId;
+    constructor(backendId) {
+        super(`Local Computer backend ${backendId} is offline`);
+        this.backendId = backendId;
+        this.name = "LocalBackendOfflineError";
+    }
+}
+/**
+ * The live dial-ins of one Computer, keyed by backend id. It outlives each
+ * Workspace generation so a rebuild does not forget a connected machine.
+ */
+export class LocalBackendConnections {
+    #sockets = new Map();
+    #connected;
+    constructor(connected = () => undefined) {
+        this.#connected = connected;
+    }
+    online(id) {
+        return this.#sockets.has(id);
+    }
+    socket(id) {
+        return this.#sockets.get(id);
+    }
+    /** Park a verified dial-in; a newer dial from the same device replaces it. */
+    park(id, socket) {
+        this.close(id, "replaced by a newer connection");
+        this.#sockets.set(id, socket);
+        const forget = () => {
+            if (this.#sockets.get(id) === socket)
+                this.#sockets.delete(id);
+        };
+        socket.addEventListener("close", forget);
+        socket.addEventListener("error", forget);
+        this.#connected(id);
+    }
+    close(id, reason) {
+        const socket = this.#sockets.get(id);
+        if (socket === undefined)
+            return;
+        this.#sockets.delete(id);
+        socket.close(1000, reason);
+    }
+    /** Close every dial-in whose backend is no longer attached. */
+    retain(attached) {
+        for (const id of this.#sockets.keys())
+            if (!attached.has(id))
+                this.close(id, "backend detached");
+    }
+}
+export class LocalWorkspaceBackend {
+    type = "fungi-local";
+    id;
+    #connections;
+    constructor(backend, connections) {
+        this.id = attachedBackendId(backend);
+        this.#connections = connections;
+    }
+    connect() {
+        const socket = this.#connections.socket(this.id);
+        if (socket === undefined)
+            return Promise.reject(new LocalBackendOfflineError(this.id));
+        const session = newWebSocketRpcSession(socket);
+        const closed = new Promise((resolve) => {
+            const settle = () => {
+                resolve();
+            };
+            socket.addEventListener("close", settle, { once: true });
+            socket.addEventListener("error", settle, { once: true });
+            session.onRpcBroken(settle);
+        });
+        const rpc = {
+            shell: session.shell,
+            sync: {
+                push: (input) => session.sync.push(input),
+                fetchChanges: (input) => session.sync.fetchChanges(input),
+                watermarks: () => session.sync.watermarks(),
+                readEntry: (path) => session.sync.readEntry(path),
+                hasObjects: (hashes) => session.sync.hasObjects(hashes),
+                pushObjects: (objects) => session.sync.pushObjects(objects),
+                // capnweb resolves a streamed RPC result asynchronously. Workspace
+                // consumes a synchronous stream handle, so bridge one chunk per pull.
+                fetchObjects: (hashes) => workspaceStream(session.sync.fetchObjects(hashes)),
+            },
+        };
+        return Promise.resolve({
+            rpc,
+            sync: "remote",
+            closed,
+            close: () => {
+                try {
+                    session[Symbol.dispose]();
+                }
+                catch (cause) {
+                    console.error("Local Computer backend operation failed", cause);
+                    // The session already ended.
+                }
+                this.#connections.close(this.id, "Workspace closed");
+                return Promise.resolve();
+            },
+        });
+    }
+}
+/** The audience one attached local backend's dial-in is signed for. */
+export function localBackendAudience(computerName, backendId) {
+    return `fungi-local-backend:${computerName}:${backendId}`;
+}
+const dialReplay = new SeamReplayGuard();
+/**
+ * Verify a machine's signed dial-in against the public key its attachment
+ * pinned. The WebSocket upgrade carries no body, so it signs an unsigned
+ * payload over the exact path.
+ */
+export async function verifyLocalBackendDial(request, computerName, backend) {
+    try {
+        await verifySeamRequest(await importSeamVerifiers({ [backend.deviceId]: backend.publicKey }), localBackendAudience(computerName, attachedBackendId(backend)), request.method, request.url, request.headers.get(seamHeader), null, dialReplay);
+        return true;
+    }
+    catch (cause) {
+        console.error("Local Computer backend operation failed", cause);
+        return false;
+    }
+}
+/**
+ * The public dial path: `/api/teams/:team/computers/:computer/backends/:id/connect`.
+ * The Hub forwards it unchanged so the signature covers what the machine sent.
+ */
+export const localBackendDialPath = /^\/api\/teams\/([^/]+)\/computers\/([^/]+)\/backends\/(local-[a-z2-7]{16})\/connect$/;

package/dist/metered-container-host.d.ts

@@ -0,0 +1,26 @@
+import type { IWorkspaceContainerAPI, WorkspaceRef } from "@fungi.computer/cloudflare-computer/backends/container";
+import type { ContainerRuntimeStart, HostedBacking } from "./computer-backends.js";
+/**
+ * A container host that reports each runtime it starts. Every other call
+ * passes through unchanged, so the container backend cannot tell it apart
+ * from the host it wraps.
+ */
+export declare class MeteredContainerHost implements IWorkspaceContainerAPI {
+    #private;
+    constructor(host: IWorkspaceContainerAPI, backing: HostedBacking, started: (start: ContainerRuntimeStart) => void);
+    start(env: Record<string, string>, enableInternet: boolean): Promise<{
+        runtimeId: string;
+    }>;
+    restart(env: Record<string, string>, enableInternet: boolean): Promise<{
+        runtimeId: string;
+    }>;
+    status(): ReturnType<IWorkspaceContainerAPI["status"]>;
+    exitInfo(): ReturnType<IWorkspaceContainerAPI["exitInfo"]>;
+    interceptOutboundHttp(host: string, workspace: WorkspaceRef): Promise<void>;
+    interceptAllOutboundHttp(workspace: WorkspaceRef, token: string): Promise<void>;
+    fetchPort(port: number, input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
+    port(port: number): {
+        fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
+        connect(address: SocketAddress | string, options?: SocketOptions): Socket;
+    };
+}

package/dist/metered-container-host.js

@@ -0,0 +1,48 @@
+/**
+ * A container host that reports each runtime it starts. Every other call
+ * passes through unchanged, so the container backend cannot tell it apart
+ * from the host it wraps.
+ */
+export class MeteredContainerHost {
+    #host;
+    #backing;
+    #started;
+    constructor(host, backing, started) {
+        this.#host = host;
+        this.#backing = backing;
+        this.#started = started;
+    }
+    async #report(boot) {
+        const runtime = await boot;
+        this.#started({
+            runtimeId: runtime.runtimeId,
+            backing: this.#backing,
+            startedAt: Date.now(),
+        });
+        return runtime;
+    }
+    start(env, enableInternet) {
+        return this.#report(this.#host.start(env, enableInternet));
+    }
+    restart(env, enableInternet) {
+        return this.#report(this.#host.restart(env, enableInternet));
+    }
+    status() {
+        return this.#host.status();
+    }
+    exitInfo() {
+        return this.#host.exitInfo();
+    }
+    interceptOutboundHttp(host, workspace) {
+        return this.#host.interceptOutboundHttp(host, workspace);
+    }
+    interceptAllOutboundHttp(workspace, token) {
+        return this.#host.interceptAllOutboundHttp(workspace, token);
+    }
+    fetchPort(port, input, init) {
+        return this.#host.fetchPort(port, input, init);
+    }
+    port(port) {
+        return this.#host.port(port);
+    }
+}