@phreshos/node 0.1.12 → 0.1.14

package/README.md

@@ -1,9 +1,22 @@
 # `@phreshos/node`
 
-Node.js access to a running PhreshOS System and local Program projects.
+Node.js access to a PhreshOS System and local Program projects.
 
-The Node SDK exposes the same System model used inside Server Endpoints and adds
-only connection lifecycle and project tooling.
+[Documentation](https://docs.phreshos.com/sdks/node) ·
+[System](https://docs.phreshos.com/system) ·
+[First Program](https://docs.phreshos.com/first-program) ·
+[Source](https://github.com/PhreshOS/node)
+
+## Role
+
+The Node SDK exposes the same complete System contract available inside Server
+Endpoints. It adds only the lifecycle of an externally owned connection and the
+`Project` authoring API for building, running, installing, and packaging local
+Program projects.
+
+The connection transport is not public API. Core owns the domain model, and the
+System remains authoritative whether an operation can execute locally or must
+cross the connection boundary.
 
 ## Installation
 
@@ -14,44 +27,21 @@ only connection lifecycle and project tooling.
 | Bun | `bun add @phreshos/node` |
 | Yarn | `yarn add @phreshos/node` |
 
-## System
-
-```ts
-import { System } from "@phreshos/node"
-
-const system = await System.connect()
-const programs = await system.program.list()
-
-await system.disconnect()
-```
-
-The transport is not public API. Code receives the same System, Program,
-Process, Endpoint, Service, Window, storage, and upload handles used by the
-Server SDK. `disconnect()` exists because external Node code owns the
-connection.
-
-## Project
-
 ```ts
 import { Project, System } from "@phreshos/node"
 
-const project = await Project.open()
 const system = await System.connect()
+const project = await Project.open()
 
-for await (const event of await project.start(system, { signal })) {
+for await (const event of await project.start(system)) {
   console.log(event)
 }
 
 await system.disconnect()
 ```
 
-`Project` owns authoring concerns: builds, development and production
-definitions, installation, execution shortcuts, and packaging. The System
-receives only the resulting Program definition.
-
-`Project.open()` starts from the current working directory by default.
-`System.connect()` resolves an explicit System home, then `PHRESHOS_HOME`,
-then the current owner's default System home.
+See [Node SDK](https://docs.phreshos.com/sdks/node) for System connection and
+Project lifecycle details.
 
 ## Development
 
@@ -60,14 +50,19 @@ bun install --frozen-lockfile
 bun run verify
 ```
 
-See the [Node SDK documentation](https://github.com/PhreshOS/docs/blob/main/content/docs/sdks/node.mdx)
-for the public model.
+`verify` checks the types, builds the package, and runs the connection and
+Project tests.
 
-## Repository boundary
+## Related repositories
 
-This repository owns the external Node connection and local-project API. Core
-owns the domain model, Server owns the Endpoint runtime adapter, and CLI owns
-terminal presentation and native service management.
+- [`@phreshos/core`](https://github.com/PhreshOS/core) owns the shared System
+  and runtime contracts.
+- [`@phreshos/server`](https://github.com/PhreshOS/server) exposes the same
+  System contract inside Server Endpoints.
+- [`@phreshos/cli`](https://github.com/PhreshOS/cli) presents Project and System
+  operations as terminal commands.
+- [PhreshOS System](https://github.com/PhreshOS/system) owns the connected
+  runtime.
 
 ## License
 

package/dist/development-client.d.ts

@@ -0,0 +1,20 @@
+import type { ClientDevelopment, ProgramProcessRunEvent } from "@phreshos/core";
+/** One prepared Client development source owned by a Project development run. */
+export default class DevelopmentClient {
+    readonly url: string;
+    private readonly startCommand;
+    private readonly directory;
+    private command;
+    private controller;
+    private releaseSignal;
+    private constructor();
+    /** Select the development address without starting the authored command. */
+    static prepare(development: ClientDevelopment, directory: string): Promise<DevelopmentClient>;
+    /** Start and verify the Client beneath its System-created asset address. */
+    start(assetId: string, signal?: AbortSignal): Promise<void>;
+    processSignal(fallback?: AbortSignal): AbortSignal | undefined;
+    supervise(lifecycle: AsyncGenerator<ProgramProcessRunEvent, void, void>): AsyncGenerator<ProgramProcessRunEvent, void, void>;
+    dispose(reason: unknown): Promise<void>;
+    private waitUntilReady;
+    private supervisedLifecycle;
+}

package/dist/development-client.js

@@ -0,0 +1,259 @@
+import { spawn } from "node:child_process";
+import { connect, createServer } from "node:net";
+import { delimiter, join } from "node:path";
+const readinessTimeout = 15_000;
+const pollingInterval = 200;
+/** One prepared Client development source owned by a Project development run. */
+export default class DevelopmentClient {
+    url;
+    startCommand;
+    directory;
+    command = null;
+    controller = null;
+    releaseSignal = () => undefined;
+    constructor(url, startCommand, directory) {
+        this.url = url;
+        this.startCommand = startCommand;
+        this.directory = directory;
+    }
+    /** Select the development address without starting the authored command. */
+    static async prepare(development, directory) {
+        const url = development.url ?? `http://localhost:${await availablePort()}/`;
+        if (development.startCommand)
+            await assertAvailable(url);
+        return new DevelopmentClient(url, development.startCommand ?? null, directory);
+    }
+    /** Start and verify the Client beneath its System-created asset address. */
+    async start(assetId, signal) {
+        if (this.controller)
+            throw new Error("The Client development source has already started");
+        const base = `/program/${assetId}/assets/`;
+        const controller = new AbortController();
+        this.controller = controller;
+        this.releaseSignal = forwardAbort(signal, controller);
+        try {
+            if (this.startCommand) {
+                this.command = new OwnedCommand(this.startCommand, this.directory, {
+                    PHRESHOS_CLIENT_BASE: base,
+                    PHRESHOS_CLIENT_PORT: String(portOf(this.url))
+                });
+            }
+            await this.waitUntilReady(new URL(base, this.url).href);
+        }
+        catch (error) {
+            await this.dispose(error);
+            throw error;
+        }
+    }
+    processSignal(fallback) {
+        return this.command ? this.controller?.signal : fallback;
+    }
+    supervise(lifecycle) {
+        if (!this.command) {
+            this.releaseSignal();
+            return lifecycle;
+        }
+        return this.supervisedLifecycle(lifecycle);
+    }
+    async dispose(reason) {
+        this.releaseSignal();
+        this.controller?.abort(reason);
+        await this.command?.stop();
+    }
+    async waitUntilReady(url) {
+        const deadline = Date.now() + readinessTimeout;
+        while (Date.now() < deadline) {
+            this.controller.signal.throwIfAborted();
+            const exit = this.command?.exitResult();
+            if (exit)
+                throw commandFailure(exit);
+            try {
+                const response = await fetch(url, {
+                    signal: AbortSignal.timeout(Math.max(1, Math.min(500, deadline - Date.now())))
+                });
+                await response.body?.cancel();
+                if (response.ok)
+                    return;
+            }
+            catch { /* The development server is still starting. */ }
+            await pause(Math.min(pollingInterval, Math.max(0, deadline - Date.now())), this.controller.signal);
+        }
+        throw new Error(`Client development URL did not respond within 15 seconds: ${url}`);
+    }
+    async *supervisedLifecycle(lifecycle) {
+        const iterator = lifecycle[Symbol.asyncIterator]();
+        const command = this.command;
+        try {
+            while (true) {
+                const next = iterator.next();
+                const outcome = await Promise.race([
+                    next.then(result => ({ source: "system", result }), error => ({ source: "system-error", error })),
+                    command.exited().then(result => ({ source: "client", result }))
+                ]);
+                if (outcome.source === "client") {
+                    const error = commandFailure(outcome.result);
+                    this.controller?.abort(error);
+                    await next.catch(() => undefined);
+                    throw error;
+                }
+                if (outcome.source === "system-error")
+                    throw outcome.error;
+                if (outcome.result.done)
+                    return;
+                yield outcome.result.value;
+            }
+        }
+        finally {
+            await this.dispose(new Error("The development lifecycle ended"));
+            await iterator.return?.();
+        }
+    }
+}
+/** One operating-system command supervised as a complete process tree. */
+class OwnedCommand {
+    child;
+    completion;
+    result = null;
+    stopped = false;
+    constructor(command, directory, environment) {
+        this.child = spawn(command, {
+            cwd: directory,
+            env: commandEnvironment(directory, environment),
+            shell: true,
+            stdio: ["ignore", "pipe", "pipe"],
+            detached: true
+        });
+        this.child.stdout?.pipe(process.stdout, { end: false });
+        this.child.stderr?.pipe(process.stderr, { end: false });
+        this.completion = new Promise(resolve => {
+            const finish = (exit) => {
+                if (this.result)
+                    return;
+                this.result = exit;
+                resolve(exit);
+            };
+            this.child.once("error", error => finish({ code: null, signal: null, error }));
+            this.child.once("exit", (code, signal) => finish({ code, signal, error: null }));
+        });
+    }
+    exited() { return this.completion; }
+    exitResult() { return this.result; }
+    async stop() {
+        if (this.stopped)
+            return;
+        this.stopped = true;
+        if (!running(this.child))
+            return;
+        terminate(this.child, "SIGTERM");
+        await waitUntilStopped(this.child, 1_000);
+        if (running(this.child))
+            terminate(this.child, "SIGKILL");
+        await waitUntilStopped(this.child, 1_000);
+    }
+}
+async function availablePort() {
+    const server = createServer();
+    return await new Promise((done, fail) => {
+        server.once("error", fail);
+        server.listen(0, "localhost", () => {
+            const address = server.address();
+            if (!address || typeof address === "string") {
+                server.close();
+                fail(new Error("An available Client development port could not be selected"));
+                return;
+            }
+            server.close(error => error ? fail(error) : done(address.port));
+        });
+    });
+}
+async function assertAvailable(url) {
+    const location = new URL(url);
+    const occupied = await new Promise(done => {
+        const socket = connect({ host: location.hostname, port: portOf(url) });
+        let finished = false;
+        const finish = (value) => {
+            if (finished)
+                return;
+            finished = true;
+            socket.destroy();
+            done(value);
+        };
+        socket.setTimeout(500);
+        socket.once("connect", () => finish(true));
+        socket.once("error", () => finish(false));
+        socket.once("timeout", () => finish(false));
+    });
+    if (occupied)
+        throw new Error(`Client development URL is already in use: ${url}`);
+}
+function portOf(url) {
+    const location = new URL(url);
+    return Number(location.port || (location.protocol === "https:" ? 443 : 80));
+}
+function commandEnvironment(directory, additions) {
+    const key = Object.keys(process.env).find(name => name.toLowerCase() === "path") ?? "PATH";
+    const inherited = process.env[key];
+    return { ...process.env, ...additions, [key]: [join(directory, "node_modules", ".bin"), inherited].filter(Boolean).join(delimiter) };
+}
+function forwardAbort(source, target) {
+    if (!source)
+        return () => undefined;
+    const abort = () => target.abort(source.reason);
+    if (source.aborted)
+        abort();
+    else
+        source.addEventListener("abort", abort, { once: true });
+    return () => source.removeEventListener("abort", abort);
+}
+function commandFailure(exit) {
+    if (exit.error)
+        return new Error(`Client development command failed: ${exit.error.message}`);
+    if (exit.signal)
+        return new Error(`Client development command ended on ${exit.signal}`);
+    return new Error(`Client development command exited with ${exit.code ?? 0}`);
+}
+function terminate(child, signal) {
+    if (!child.pid)
+        return;
+    try {
+        process.kill(-child.pid, signal);
+    }
+    catch {
+        child.kill(signal);
+    }
+}
+function running(child) {
+    if (!child.pid)
+        return false;
+    try {
+        process.kill(-child.pid, 0);
+        return true;
+    }
+    catch {
+        return child.exitCode === null && child.signalCode === null;
+    }
+}
+async function waitUntilStopped(child, milliseconds) {
+    const deadline = Date.now() + milliseconds;
+    while (running(child) && Date.now() < deadline)
+        await new Promise(resolve => setTimeout(resolve, 20));
+}
+function pause(milliseconds, signal) {
+    return new Promise((done, fail) => {
+        if (signal.aborted) {
+            fail(signal.reason);
+            return;
+        }
+        const timeout = setTimeout(finish, milliseconds);
+        const abort = () => finish(signal.reason);
+        signal.addEventListener("abort", abort, { once: true });
+        function finish(error) {
+            clearTimeout(timeout);
+            signal.removeEventListener("abort", abort);
+            if (error !== undefined)
+                fail(error);
+            else
+                done();
+        }
+    });
+}

package/dist/events.d.ts

@@ -1,12 +1,12 @@
 import type { Cleanup, EventOptions, Subscribable } from "@phreshos/core";
-type Wait = (event: string | null, signal: AbortSignal, timeout?: number) => Promise<unknown>;
 type Failure = (error: Error) => void;
 type Register<Message> = (subscriber: (message: Message) => unknown, impossible?: Failure) => Cleanup;
-/** Adapts authoritative one-event waits into the shared Subscribable contract. */
+type Subscribe = (event: string | null, subscriber: (message: unknown) => unknown, impossible?: Failure) => Cleanup;
+/** Adapts one live representation source into the shared Subscribable contract. */
 export default class Events<Definitions extends object, Fallback = never> {
     private readonly names;
-    private readonly wait;
-    constructor(names: readonly string[], wait: Wait);
+    private readonly register;
+    constructor(names: readonly string[], register: Subscribe);
     readonly subscribe: Subscribable<Definitions, Fallback>["subscribe"];
     readonly waitFor: Subscribable<Definitions, Fallback>["waitFor"];
     readonly events: Subscribable<Definitions, Fallback>["events"];

package/dist/events.js

@@ -1,10 +1,10 @@
-/** Adapts authoritative one-event waits into the shared Subscribable contract. */
+/** Adapts one live representation source into the shared Subscribable contract. */
 export default class Events {
     names;
-    wait;
-    constructor(names, wait) {
+    register;
+    constructor(names, register) {
         this.names = names;
-        this.wait = wait;
+        this.register = register;
     }
     subscribe = ((eventOrSubscriber, subscriber) => {
         if (typeof eventOrSubscriber === "string")
@@ -19,9 +19,19 @@ export default class Events {
                 eventOrSubscriber({ event: capture.event, message: capture.payload });
         });
     });
-    waitFor = ((event, timeout) => {
-        return this.wait(event, new AbortController().signal, timeout);
-    });
+    waitFor = ((event, timeout = 10_000) => new Promise((resolve, reject) => {
+        let stop = () => undefined;
+        const timer = setTimeout(() => {
+            stop();
+            reject(new Error(`The "${event}" event did not occur before the timeout`));
+        }, timeout);
+        const finish = (work) => {
+            clearTimeout(timer);
+            stop();
+            work();
+        };
+        stop = this.listen(event, message => finish(() => resolve(message)), error => finish(() => reject(error)));
+    }));
     events = ((eventOrOptions = {}, namedOptions = {}) => {
         if (typeof eventOrOptions === "string") {
             return stream((subscriber, impossible) => this.listen(eventOrOptions, subscriber, impossible), namedOptions);
@@ -39,22 +49,7 @@ export default class Events {
         }, eventOrOptions);
     });
     listen(event, subscriber, impossible) {
-        const controller = new AbortController();
-        void (async () => {
-            while (!controller.signal.aborted) {
-                try {
-                    subscriber(await this.wait(event, controller.signal, 86_400_000));
-                }
-                catch (error) {
-                    if (!controller.signal.aborted && timeout(error))
-                        continue;
-                    if (!controller.signal.aborted)
-                        impossible?.(failure(error));
-                    controller.abort();
-                }
-            }
-        })();
-        return () => controller.abort();
+        return this.register(event, subscriber, impossible);
     }
 }
 export function stream(register, options = {}) {
@@ -109,9 +104,3 @@ export function stream(register, options = {}) {
         }
     })();
 }
-function timeout(error) {
-    return error instanceof Error && /timeout|timed out/i.test(error.message);
-}
-function failure(error) {
-    return error instanceof Error ? error : new Error(String(error));
-}

package/dist/main.d.ts

@@ -1,5 +1,5 @@
 export { gatewayAddress } from "./address.js";
-export { Client, ClientService, Endpoint, Process, Program, Server, ServerService, System, type ProgramProcessRunEvent, type ProgramProcessRunOptions } from "./system.js";
-export { Service, type ClientLaunch, type Launch, type ProgramPermission, type ProgramDefinition, type ServerLaunch, type ServiceKey, type SystemProgramStartup, type SystemStorage, } from "@phreshos/core";
+export { ClientEndpoint, ClientService, Endpoint, Process, Program, ServerEndpoint, ServerService, System, type ProgramProcessRunEvent, type ProgramProcessRunOptions } from "./system.js";
+export { Service, clientPermissionCatalog, isPermissionName, type ClientLaunch, type Launch, type Permission, type PermissionChange, type PermissionDefinition, type PermissionDefinitions, type PermissionInput, type PermissionName, type PermissionValue, type PermissionValueDomain, type Permissions, type ProgramPermissions, type ProgramDefinition, type ServerLaunch, type ServiceKey, type ShellEvent, type ShellOptions, type ProgramStartup, type Storage, } from "@phreshos/core";
 export { resolveHome } from "./home.js";
 export { Project, type Manifest, type PackedProject, type ProjectMode, type ProjectOptions, type ProjectRunOptions } from "./project.js";

package/dist/main.js

@@ -1,5 +1,5 @@
 export { gatewayAddress } from "./address.js";
-export { Client, ClientService, Endpoint, Process, Program, Server, ServerService, System } from "./system.js";
-export { Service, } from "@phreshos/core";
+export { ClientEndpoint, ClientService, Endpoint, Process, Program, ServerEndpoint, ServerService, System } from "./system.js";
+export { Service, clientPermissionCatalog, isPermissionName, } from "@phreshos/core";
 export { resolveHome } from "./home.js";
 export { Project } from "./project.js";

package/dist/process-tree.d.ts

@@ -0,0 +1,10 @@
+import type { ChildProcess } from "node:child_process";
+/** The complete operating-system process tree beneath one shell command. */
+export default class ProcessTree {
+    private readonly child;
+    private readonly ended;
+    private forcing;
+    constructor(child: ChildProcess, ended: (code: number | null, signal: NodeJS.Signals | null) => void | Promise<void>);
+    stop(): void;
+    private finish;
+}

package/dist/process-tree.js

@@ -0,0 +1,67 @@
+const terminationGrace = 1_000;
+/** The complete operating-system process tree beneath one shell command. */
+export default class ProcessTree {
+    child;
+    ended;
+    forcing = null;
+    constructor(child, ended) {
+        this.child = child;
+        this.ended = ended;
+        child.on("exit", (code, signal) => { this.finish(code, signal).catch(() => undefined); });
+    }
+    stop() {
+        signalTree(this.child, "SIGTERM");
+        if (this.forcing)
+            return;
+        this.forcing = setTimeout(() => signalTree(this.child, "SIGKILL"), terminationGrace);
+        this.forcing.unref();
+    }
+    async finish(code, signal) {
+        if (this.forcing)
+            clearTimeout(this.forcing);
+        this.forcing = null;
+        await finishTree(this.child);
+        await this.ended(code, signal);
+    }
+}
+function signalTree(child, signal) {
+    if (!child.pid)
+        return;
+    try {
+        process.kill(-child.pid, signal);
+    }
+    catch (error) {
+        if (error.code === "ESRCH")
+            return;
+        if (child.exitCode === null && child.signalCode === null)
+            child.kill(signal);
+    }
+}
+async function finishTree(child) {
+    const pid = child.pid;
+    if (!pid || !treeExists(pid))
+        return;
+    signalTree(child, "SIGTERM");
+    if (await waitForTree(pid))
+        return;
+    signalTree(child, "SIGKILL");
+    await waitForTree(pid);
+}
+async function waitForTree(pid) {
+    const began = Date.now();
+    while (treeExists(pid)) {
+        if (Date.now() - began >= terminationGrace)
+            return false;
+        await new Promise(resolve => setTimeout(resolve, 20));
+    }
+    return true;
+}
+function treeExists(pid) {
+    try {
+        process.kill(-pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code !== "ESRCH";
+    }
+}

package/dist/program-resources.d.ts

@@ -1,13 +1,13 @@
-import type { ProgramPermission, ProgramSql, ProgramStore } from "@phreshos/core";
-type Request = (value: object) => Promise<unknown>;
+import { type ProgramPermissions, type ProgramSql, type ProgramStore } from "@phreshos/core";
+type Call = <Result = unknown>(event: string, ...values: unknown[]) => Promise<Result>;
 type ProgramAddress = Readonly<{
     identity: string;
     reference: string;
 }>;
 /** Program-owned key-value storage carried through the owner-local Gateway. */
-export declare function programStore(request: Request, handle: ProgramAddress): ProgramStore;
+export declare function programStore(call: Call, handle: ProgramAddress): ProgramStore;
 /** Program-owned SQL capability carried through the owner-local Gateway. */
-export declare function programSql(request: Request, handle: ProgramAddress, database: "database" | "logs"): ProgramSql;
-/** Persistent Program permission decisions carried through the owner-local Gateway. */
-export declare function programPermission(request: Request, handle: ProgramAddress): ProgramPermission;
+export declare function programSql(call: Call, handle: ProgramAddress, database: "database" | "logs"): ProgramSql;
+/** Program permission management carried through the owner-local Gateway. */
+export declare function programPermissions(call: Call, handle: ProgramAddress): ProgramPermissions;
 export {};

package/dist/program-resources.js

@@ -1,14 +1,7 @@
+import { parsePermission, parsePermissionChange, parsePermissions } from "@phreshos/core";
 /** Program-owned key-value storage carried through the owner-local Gateway. */
-export function programStore(request, handle) {
-    const operate = (storeOperation, key, value, ttl) => request({
-        capability: "program",
-        operation: "store",
-        handle,
-        storeOperation,
-        key,
-        value,
-        ttl
-    });
+export function programStore(call, handle) {
+    const operate = (storeOperation, key, value, ttl) => (call("/program/store", handle, storeOperation, key, value, ttl));
     return {
         get: (key) => operate("get", key),
         set: (key, value, ttl) => operate("set", key, value, ttl),
@@ -18,29 +11,22 @@ export function programStore(request, handle) {
     };
 }
 /** Program-owned SQL capability carried through the owner-local Gateway. */
-export function programSql(request, handle, database) {
+export function programSql(call, handle, database) {
     return {
         query(statement, ...rest) {
             const [text, values] = written(statement, rest);
-            return request({ capability: "program", operation: "query", handle, database, statement: text, values });
+            return call(`/program/${database}`, handle, text, values);
         }
     };
 }
-/** Persistent Program permission decisions carried through the owner-local Gateway. */
-export function programPermission(request, handle) {
-    const operate = (permissionOperation, name, value) => request({
-        capability: "program",
-        operation: "permission",
-        handle,
-        permissionOperation,
-        name,
-        value
-    });
+/** Program permission management carried through the owner-local Gateway. */
+export function programPermissions(call, handle) {
+    const operate = (permissionOperation, name, permission) => (call("/program/permissions", handle, permissionOperation, name, permission));
     return {
-        get: name => operate("get", name),
-        getAll: () => operate("getAll"),
-        set: (name, value) => operate("set", name, value),
-        delete: name => operate("delete", name)
+        async get(name) { return parsePermission(name, await operate("get", name)); },
+        async all() { return parsePermissions(await operate("all")); },
+        async set(name, permission) { return parsePermissionChange(name, await operate("set", name, permission)); },
+        async delete(name) { return parsePermissionChange(name, await operate("delete", name)); }
     };
 }
 function written(statement, rest) {

package/dist/project.d.ts

@@ -18,9 +18,11 @@ export declare class Project {
     /** Run the optional author-owned production build command. */
     build(): Promise<void>;
     /** Build this Project and return its production Process lifecycle generator. */
-    start(system: SystemContract, options?: ProjectRunOptions): Promise<AsyncGenerator<import("@phreshos/core").SystemProcessRunEvent, void, void>>;
-    /** Return this Project's development Process lifecycle generator. */
-    dev(system: SystemContract, options?: ProjectRunOptions): Promise<AsyncGenerator<import("@phreshos/core").SystemProcessRunEvent, void, void>>;
+    start(system: SystemContract, options?: ProjectRunOptions): Promise<AsyncGenerator<import("@phreshos/core").ProgramProcessRunEvent, void, void>>;
+    /** Prepare this Project's Client development source and return its Process lifecycle. */
+    dev(system: SystemContract, options?: ProjectRunOptions): Promise<AsyncGenerator<import("@phreshos/core").ProgramProcessRunEvent, void, void>>;
+    private developmentRun;
+    private prepareDevelopment;
     /** Build this Project and return its Program installation generator. */
     install(system: SystemContract): Promise<AsyncGenerator<Readonly<{
         stream: "stdout" | "stderr";