@phreshos/node 0.1.3 → 0.1.5

package/dist/events.d.ts

@@ -1,6 +1,6 @@
 import type { Subscribable } from "@phreshos/core";
 type Wait = (event: string | null, signal: AbortSignal, timeout?: number) => Promise<unknown>;
-/** Adapt authoritative one-event waits into the shared Subscribable contract. */
+/** Adapts authoritative one-event waits into the shared Subscribable contract. */
 export default class Events<Definitions extends object, Fallback = never> {
     private readonly names;
     private readonly wait;
@@ -8,6 +8,6 @@ export default class Events<Definitions extends object, Fallback = never> {
     readonly subscribe: Subscribable<Definitions, Fallback>["subscribe"];
     readonly waitFor: Subscribable<Definitions, Fallback>["waitFor"];
     readonly events: Subscribable<Definitions, Fallback>["events"];
-    readonly observe: Subscribable<Definitions, Fallback>["observe"];
+    private listen;
 }
 export {};

package/dist/events.js

@@ -1,4 +1,4 @@
-/** Adapt authoritative one-event waits into the shared Subscribable contract. */
+/** Adapts authoritative one-event waits into the shared Subscribable contract. */
 export default class Events {
     names;
     wait;
@@ -6,73 +6,112 @@ export default class Events {
         this.names = names;
         this.wait = wait;
     }
-    subscribe = ((event, subscriber) => {
-        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)
-                        controller.abort();
-                }
-            }
-        })();
-        return () => controller.abort();
+    subscribe = ((eventOrSubscriber, subscriber) => {
+        if (typeof eventOrSubscriber === "string")
+            return this.listen(eventOrSubscriber, subscriber);
+        if (this.names.length) {
+            const stops = this.names.map(event => this.listen(event, message => eventOrSubscriber({ event, message })));
+            return () => stops.forEach(stop => stop());
+        }
+        return this.listen(null, value => {
+            const capture = value;
+            if (typeof capture.event === "string")
+                eventOrSubscriber({ event: capture.event, message: capture.payload });
+        });
     });
     waitFor = ((event, timeout) => {
         return this.wait(event, new AbortController().signal, timeout);
     });
-    events = ((event, options = {}) => {
-        const wait = this.wait;
-        return (async function* () {
-            const controller = new AbortController();
-            const abort = () => controller.abort(options.signal?.reason);
-            options.signal?.addEventListener("abort", abort, { once: true });
-            try {
-                while (!controller.signal.aborted) {
-                    try {
-                        yield await wait(event, controller.signal, 86_400_000);
-                    }
-                    catch (error) {
-                        if (!controller.signal.aborted && timeout(error))
-                            continue;
-                        throw error;
-                    }
-                }
-            }
-            finally {
-                options.signal?.removeEventListener("abort", abort);
-                controller.abort();
+    events = ((eventOrOptions = {}, namedOptions = {}) => {
+        if (typeof eventOrOptions === "string") {
+            return stream((subscriber, impossible) => this.listen(eventOrOptions, subscriber, impossible), namedOptions);
+        }
+        return stream((subscriber, impossible) => {
+            if (this.names.length) {
+                const stops = this.names.map(event => this.listen(event, message => subscriber({ event, message }), impossible));
+                return () => stops.forEach(stop => stop());
             }
-        })();
+            return this.listen(null, value => {
+                const capture = value;
+                if (typeof capture.event === "string")
+                    subscriber({ event: capture.event, message: capture.payload });
+            }, impossible);
+        }, eventOrOptions);
     });
-    observe = ((observer) => {
-        if (this.names.length) {
-            const stops = this.names.map(event => this.subscribe(event, message => observer({ event, message })));
-            return () => stops.forEach(stop => stop());
-        }
+    listen(event, subscriber, impossible) {
         const controller = new AbortController();
         void (async () => {
             while (!controller.signal.aborted) {
                 try {
-                    const capture = await this.wait(null, controller.signal, 86_400_000);
-                    observer({ event: capture.event, message: capture.payload });
+                    subscriber(await this.wait(event, controller.signal, 86_400_000));
                 }
                 catch (error) {
                     if (!controller.signal.aborted && timeout(error))
                         continue;
                     if (!controller.signal.aborted)
-                        controller.abort();
+                        impossible?.(failure(error));
+                    controller.abort();
                 }
             }
         })();
         return () => controller.abort();
-    });
+    }
+}
+function stream(register, options = {}) {
+    const capacity = options.capacity ?? 64;
+    if (capacity !== Infinity && (!Number.isInteger(capacity) || capacity < 0)) {
+        throw new Error("An event queue capacity must be a non-negative integer or Infinity");
+    }
+    return (async function* () {
+        const queue = [];
+        let ended = false;
+        let failure = null;
+        let wake = null;
+        const stop = register(message => {
+            if (ended || failure)
+                return;
+            if (queue.length >= capacity)
+                failure = new Error(`Event queue exceeded its capacity of ${capacity}`);
+            else
+                queue.push(message);
+            wake?.();
+            wake = null;
+        }, error => {
+            if (ended || failure)
+                return;
+            failure = error;
+            wake?.();
+            wake = null;
+        });
+        const abort = () => {
+            ended = true;
+            wake?.();
+            wake = null;
+        };
+        options.signal?.addEventListener("abort", abort, { once: true });
+        if (options.signal?.aborted)
+            abort();
+        try {
+            while (!ended) {
+                if (queue.length) {
+                    yield queue.shift();
+                    continue;
+                }
+                if (failure)
+                    throw failure;
+                await new Promise(resolve => { wake = resolve; });
+            }
+        }
+        finally {
+            ended = true;
+            stop();
+            options.signal?.removeEventListener("abort", abort);
+        }
+    })();
 }
 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 ClientServiceChannel, type ServerServiceChannel, type ServiceChannel, type ServiceKey, type ServiceLifecycleEvents } from "@phreshos/core";
+export { Service, type ServiceKey, type ServiceLifecycle, type ServiceLifecycleEvents } 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/system.d.ts

@@ -1,6 +1,4 @@
-import { Client as CoreClient, ClientService as CoreClientService, Endpoint as CoreEndpoint, Process as CoreProcess, Program as CoreProgram, Server as CoreServer, ServerService as CoreServerService, type ClientDeclaration, type EndpointDeclaration, type Launch, type LaunchClient, type Position, type ProgramDefinition, type ProgramCommandChunk, type ServiceKey, type Size, type System as CoreSystem, type SystemClientEntity, type SystemEndpointEntity, type SystemProcessEntity, type SystemProcess, type SystemProgram, type SystemProgramEntity, type SystemProgramProcessEvents, type SystemServerEntity, type SystemUploads, type WritableAppearance, type Window, type WindowEvents, type WindowGeometry } from "@phreshos/core";
-import Events from "./events.js";
-import { type TransportEvent } from "./transport.js";
+import { Client as CoreClient, ClientService as CoreClientService, Endpoint as CoreEndpoint, Process as CoreProcess, Program as CoreProgram, Server as CoreServer, ServerService as CoreServerService, type ProgramDefinition, type ProgramCommandChunk, type ServiceKey, type System as CoreSystem, type SystemClientEntity, type SystemEndpointEntity, type SystemProcessEntity, type SystemProcess, type SystemProgram, type SystemProgramEntity, type SystemServerEntity, type SystemUploads, type WritableAppearance } from "@phreshos/core";
 export type ProgramProcessRunOptions = Readonly<{
     signal?: AbortSignal;
 }>;
@@ -14,29 +12,13 @@ export type ProgramProcessRunEvent = Readonly<{
     process: SystemProcessEntity;
     exit: import("@phreshos/core").Exit;
 }>;
-interface SystemTransport {
-    control(request: object, signal?: AbortSignal): Promise<unknown>;
-    api(request: object, signal?: AbortSignal): Promise<unknown>;
-    lifecycle(request: object, signal?: AbortSignal): AsyncGenerator<TransportEvent, void, void>;
-}
-declare const ProgramBase: new () => object;
-declare const ProcessBase: new () => object;
-declare const ServerBase: new () => object;
-declare const ClientBase: new () => object;
 /** One connected owner-local implementation of the shared System contract. */
 export declare class System implements CoreSystem {
-    private readonly connection;
-    readonly home: string;
-    readonly address: string;
     readonly storage: import("@phreshos/core").Storage;
     readonly appearance: WritableAppearance;
     readonly program: SystemProgram;
     readonly process: SystemProcess;
     readonly uploads: SystemUploads;
-    readonly transport: SystemTransport;
-    private closed;
-    private readonly lifetime;
-    private readonly handles;
     private constructor();
     /** Connect to the System selected by argument, environment, or owner default. */
     static connect(home?: string): Promise<System>;
@@ -50,148 +32,6 @@ export declare class System implements CoreSystem {
     service<EventsMap extends object = {}>(key: ServiceKey & {
         endpoint: "client";
     }): ClientService<EventsMap>;
-    programHandle(snapshot: ProgramSnapshot): ProgramHandle;
-    processHandle(snapshot: ProcessSnapshot): ProcessHandle;
-    private signal;
-    private requireConnected;
-}
-interface ProgramHandle extends SystemProgramEntity {
-}
-declare class ProgramHandle extends ProgramBase {
-    private readonly system;
-    private readonly reference;
-    readonly identity: string;
-    readonly process: ProgramProcesses;
-    readonly startup: ProgramStartup;
-    private snapshot;
-    constructor(system: System, snapshot: ProgramSnapshot);
-    get name(): string;
-    get version(): string | null;
-    get description(): string | null;
-    get hasAgent(): boolean;
-    get server(): EndpointDeclaration | null;
-    get client(): ClientDeclaration | null;
-    update(snapshot: ProgramSnapshot): void;
-    agent(): Promise<string | null>;
-    installed(): Promise<boolean>;
-    install(): AsyncGenerator<Readonly<{
-        stream: "stdout" | "stderr";
-        text: string;
-    }>, void, void>;
-    uninstall(everything?: boolean): AsyncGenerator<Readonly<{
-        stream: "stdout" | "stderr";
-        text: string;
-    }>, void, void>;
-    forget(): Promise<void>;
-    address(): Readonly<{
-        identity: string;
-        reference: string;
-    }>;
-}
-declare class ProgramStartup {
-    private readonly system;
-    private readonly program;
-    constructor(system: System, program: ProgramHandle);
-    get(): Promise<Readonly<{
-        name?: string;
-        server?: boolean;
-        client?: boolean | LaunchClient;
-        options?: Readonly<Record<string, string>>;
-    }> | null>;
-    enable(launch?: Launch): Promise<void>;
-    disable(): Promise<void>;
-    private change;
-}
-declare class ProgramProcesses extends Events<SystemProgramProcessEvents> {
-    private readonly system;
-    private readonly program;
-    constructor(system: System, program: ProgramHandle);
-    list(): Promise<ProcessHandle[]>;
-    first(): Promise<ProcessHandle | null>;
-    last(): Promise<ProcessHandle | null>;
-    find(identityOrName: string): Promise<ProcessHandle | null>;
-    create(launch?: Launch): Promise<ProcessHandle>;
-    run(launch?: Launch, options?: ProgramProcessRunOptions): AsyncGenerator<ProgramProcessRunEvent, void, void>;
-    findOrCreate(launch: Launch & {
-        name: string;
-    }): Promise<ProcessHandle>;
-    exitAll(): Promise<string[]>;
-    private createExact;
-}
-interface ProcessHandle extends SystemProcessEntity {
-}
-declare class ProcessHandle extends ProcessBase {
-    private readonly system;
-    private readonly snapshot;
-    readonly identity: string;
-    readonly name: string | null;
-    readonly startedAt: Date;
-    readonly server: ServerEndpoint;
-    readonly client: ClientEndpoint;
-    constructor(system: System, snapshot: ProcessSnapshot);
-    program(): ProgramHandle;
-    exit(): Promise<void>;
-    exited(): Promise<boolean>;
-}
-interface ServerEndpoint extends SystemServerEntity {
-}
-declare class ServerEndpoint extends ServerBase {
-    private readonly system;
-    private readonly owner;
-    readonly endpoint: "server";
-    private readonly base;
-    constructor(system: System, owner: ProcessHandle);
-    process(): Promise<ProcessHandle>;
-    exists(): Promise<boolean>;
-    start(): Promise<void>;
-    stop(): Promise<void>;
-    publish(event: string, payload?: unknown): void;
-    ask<Answer = unknown>(event: string, payload?: unknown): Promise<Answer>;
-    timeout(milliseconds: number): {
-        ask: <Answer = unknown>(event: string, payload?: unknown) => Promise<Answer>;
-    };
-    waitReady(timeout?: number): Promise<void>;
-    service<EventsMap extends object = {}>(): Promise<ServerService<EventsMap> | null>;
-}
-interface ClientEndpoint extends SystemClientEntity {
-}
-declare class ClientEndpoint extends ClientBase {
-    readonly endpoint: "client";
-    readonly window: SystemWindow;
-    private readonly base;
-    constructor(system: System, owner: ProcessHandle);
-    process(): Promise<ProcessHandle>;
-    exists(): Promise<boolean>;
-    start(overrides?: LaunchClient): Promise<void>;
-    stop(): Promise<void>;
-    publish(event: string, payload?: unknown): void;
-    service<EventsMap extends object = {}>(): Promise<ClientService<EventsMap> | null>;
-}
-declare class SystemWindow extends Events<WindowEvents> implements Window {
-    private readonly system;
-    private readonly process;
-    constructor(system: System, process: ProcessHandle);
-    title(): Promise<string>;
-    position(): Promise<Readonly<{
-        x: import("@phreshos/core").Value;
-        y: import("@phreshos/core").Value;
-    }>>;
-    size(): Promise<Readonly<{
-        width: import("@phreshos/core").Value;
-        height: import("@phreshos/core").Value;
-    }>>;
-    minimized(): Promise<boolean>;
-    front(): Promise<boolean>;
-    layer(): Promise<import("@phreshos/core").Layer>;
-    location(): Promise<string>;
-    move(position: Position): Promise<void>;
-    resize(size: Size): Promise<void>;
-    setGeometry(geometry: WindowGeometry): Promise<void>;
-    minimize(minimized?: boolean): Promise<void>;
-    changeTitle(title: string): Promise<void>;
-    raise(): Promise<void>;
-    private snapshot;
-    private change;
 }
 /** Node-SDK handle for a Service provided by a Server Endpoint. */
 export declare class ServerService<EventsMap extends object = {}> extends CoreServerService<EventsMap> {
@@ -201,35 +41,6 @@ export declare class ServerService<EventsMap extends object = {}> extends CoreSe
 export declare class ClientService<EventsMap extends object = {}> extends CoreClientService<EventsMap> {
     protected constructor();
 }
-interface ProgramSnapshot {
-    reference: string;
-    identity: string;
-    name: string;
-    version: string | null;
-    description: string | null;
-    installed?: boolean;
-    hasAgent: boolean;
-    server: {
-        start: boolean;
-    } | null;
-    client: ClientDeclaration | null;
-}
-interface ProcessSnapshot {
-    reference: string;
-    identity: string;
-    name: string | null;
-    program: string;
-    programSnapshot?: ProgramSnapshot;
-    startedAt: string;
-    server: {
-        declared: boolean;
-        running: boolean;
-    };
-    client: {
-        declared: boolean;
-        running: boolean;
-    };
-}
 export type Program = SystemProgramEntity;
 export declare const Program: typeof CoreProgram;
 export type Process = SystemProcessEntity;
@@ -240,4 +51,3 @@ export type Server<EventsMap extends object = {}> = SystemServerEntity<EventsMap
 export declare const Server: typeof CoreServer;
 export type Client<EventsMap extends object = {}> = SystemClientEntity<EventsMap>;
 export declare const Client: typeof CoreClient;
-export {};

package/dist/system.js

@@ -7,88 +7,94 @@ import { resolveHome } from "./home.js";
 import { filesystemStorage } from "./storage.js";
 import { openConnection, request, streamProgram } from "./transport.js";
 import Uploads from "./uploads.js";
+const systems = new WeakMap();
 const ProgramBase = CoreProgram;
 const ProcessBase = CoreProcess;
 const ServerBase = CoreServer;
 const ClientBase = CoreClient;
 /** One connected owner-local implementation of the shared System contract. */
 export class System {
-    connection;
-    home;
-    address;
     storage = filesystemStorage(homedir(), "the native home directory");
     appearance;
     program;
     process;
     uploads;
-    transport;
-    closed = false;
-    lifetime = new AbortController();
-    handles = new HandleRegistry();
-    constructor(home, address, connection) {
-        this.connection = connection;
-        this.home = home;
-        this.address = address;
-        this.transport = {
-            control: (value, signal) => request(address, "system", value, this.signal(signal)),
-            api: (value, signal) => request(address, "api", value, this.signal(signal)),
-            lifecycle: (value, signal) => streamProgram(address, value, this.signal(signal))
+    constructor(address, connection) {
+        const lifetime = new AbortController();
+        const handles = new HandleRegistry();
+        const transport = {
+            control: (value, signal) => request(address, "system", value, connectedSignal(this, signal)),
+            api: (value, signal) => request(address, "api", value, connectedSignal(this, signal)),
+            lifecycle: (value, signal) => streamProgram(address, value, connectedSignal(this, signal))
         };
-        this.appearance = new SystemAppearance(this.transport);
+        systems.set(this, { address, connection, handles, lifetime, transport, closed: false });
+        this.appearance = new SystemAppearance(transport);
         this.program = new ProgramRegistry(this);
         this.process = new ProcessRegistry(this);
-        this.uploads = new Uploads(value => this.transport.api(value));
+        this.uploads = new Uploads(value => transport.api(value));
     }
     /** Connect to the System selected by argument, environment, or owner default. */
     static async connect(home) {
         const resolved = resolveHome(home);
         const address = gatewayAddress(resolved);
-        return new System(resolved, address, await openConnection(address));
+        return new System(address, await openConnection(address));
     }
     /** Atomically replace one runtime Program without touching its installed form. */
     async forceCreateProgram(source) {
-        this.requireConnected();
-        for await (const event of this.transport.lifecycle({ word: "force-create", program: source })) {
+        requireConnected(this);
+        for await (const event of transport(this).lifecycle({ word: "force-create", program: source })) {
             if (event.event === "created")
-                return this.programHandle(required(event.program));
+                return programHandle(this, required(event.program));
         }
         throw new Error("The System did not confirm the created Program");
     }
     /** Close this owner connection and abort every attached operation it owns. */
     async disconnect() {
-        if (this.closed)
+        const state = systemState(this);
+        if (state.closed)
             return;
-        this.closed = true;
-        this.lifetime.abort(new Error("This System connection is closed"));
-        this.connection.destroy();
-        this.handles.clear();
+        state.closed = true;
+        state.lifetime.abort(new Error("This System connection is closed"));
+        state.connection.destroy();
+        state.handles.clear();
     }
     service(key) {
-        this.requireConnected();
+        requireConnected(this);
         if (!isServiceKey(key))
             throw new Error("A complete service key is required");
         const normalized = Object.freeze({ program: key.program, endpoint: key.endpoint, name: key.name });
         const identity = JSON.stringify([normalized.program, normalized.endpoint, normalized.name]);
-        return this.handles.obtain(`service:${identity}`, () => normalized.endpoint === "server"
+        return systemState(this).handles.obtain(`service:${identity}`, () => normalized.endpoint === "server"
             ? new ServerServiceHandle(this, normalized)
             : new ClientServiceHandle(this, normalized));
     }
-    programHandle(snapshot) {
-        const handle = this.handles.obtain(`program:${snapshot.reference}`, () => new ProgramHandle(this, snapshot));
-        handle.update(snapshot);
-        return handle;
-    }
-    processHandle(snapshot) {
-        return this.handles.obtain(`process:${snapshot.reference}`, () => new ProcessHandle(this, snapshot));
-    }
-    signal(signal) {
-        this.requireConnected();
-        return signal ? AbortSignal.any([signal, this.lifetime.signal]) : this.lifetime.signal;
-    }
-    requireConnected() {
-        if (this.closed)
-            throw new Error("This System connection is closed");
-    }
+}
+function systemState(system) {
+    const state = systems.get(system);
+    if (!state)
+        throw new Error("Unknown System connection");
+    return state;
+}
+function requireConnected(system) {
+    if (systemState(system).closed)
+        throw new Error("This System connection is closed");
+}
+function connectedSignal(system, signal) {
+    const lifetime = systemState(system).lifetime.signal;
+    requireConnected(system);
+    return signal ? AbortSignal.any([signal, lifetime]) : lifetime;
+}
+function transport(system) {
+    requireConnected(system);
+    return systemState(system).transport;
+}
+function programHandle(system, snapshot) {
+    const handle = systemState(system).handles.obtain(`program:${snapshot.reference}`, () => new ProgramHandle(system, snapshot));
+    handle.update(snapshot);
+    return handle;
+}
+function processHandle(system, snapshot) {
+    return systemState(system).handles.obtain(`process:${snapshot.reference}`, () => new ProcessHandle(system, snapshot));
 }
 class SystemAppearance extends Events {
     transport;
@@ -106,7 +112,7 @@ class SystemAppearance extends Events {
 class ProgramRegistry extends Events {
     system;
     constructor(system) {
-        super(["create", "forget", "install", "uninstall"], (event, signal, timeout) => (system.transport.control({ capability: "program", operation: "wait", input: { event, timeout } }, signal)
+        super(["create", "forget", "install", "uninstall"], (event, signal, timeout) => (transport(system).control({ capability: "program", operation: "wait", input: { event, timeout } }, signal)
             .then(value => this.event(value))));
         this.system = system;
     }
@@ -114,12 +120,12 @@ class ProgramRegistry extends Events {
         const programs = [];
         let offset = 0;
         while (true) {
-            const page = await this.system.transport.control({
+            const page = await transport(this.system).control({
                 capability: "program",
                 operation: "list",
                 input: { installedOnly: onlyInstalled, limit: 100, offset }
             });
-            programs.push(...page.data.map(snapshot => this.system.programHandle(snapshot)));
+            programs.push(...page.data.map(snapshot => programHandle(this.system, snapshot)));
             offset += page.data.length;
             if (!page.truncated || !page.data.length)
                 return programs;
@@ -127,8 +133,8 @@ class ProgramRegistry extends Events {
     }
     async find(identity) {
         try {
-            const snapshot = await this.system.transport.control({ capability: "program", operation: "inspect", input: { program: identity } });
-            return this.system.programHandle(snapshot);
+            const snapshot = await transport(this.system).control({ capability: "program", operation: "inspect", input: { program: identity } });
+            return programHandle(this.system, snapshot);
         }
         catch (error) {
             if (unknown(error, "Program"))
@@ -137,9 +143,9 @@ class ProgramRegistry extends Events {
         }
     }
     async create(source) {
-        for await (const event of this.system.transport.lifecycle({ word: "create", program: source })) {
+        for await (const event of transport(this.system).lifecycle({ word: "create", program: source })) {
             if (event.event === "created")
-                return this.system.programHandle(required(event.program));
+                return programHandle(this.system, required(event.program));
         }
         throw new Error("The System did not confirm the created Program");
     }
@@ -147,9 +153,9 @@ class ProgramRegistry extends Events {
         const waited = value;
         if (waited.event === "uninstall") {
             const payload = waited.payload;
-            return { program: this.system.programHandle(required(payload.program)), everythingRemoved: payload.everythingRemoved === true };
+            return { program: programHandle(this.system, required(payload.program)), everythingRemoved: payload.everythingRemoved === true };
         }
-        return this.system.programHandle(required(waited.payload));
+        return programHandle(this.system, required(waited.payload));
     }
 }
 class ProgramHandle extends ProgramBase {
@@ -163,7 +169,7 @@ class ProgramHandle extends ProgramBase {
         super();
         this.system = system;
         this.snapshot = snapshot;
-        bindEvents(this, new Events(["forget", "uninstall"], (event, signal, timeout) => system.transport.control({
+        bindEvents(this, new Events(["forget", "uninstall"], (event, signal, timeout) => transport(system).control({
             capability: "program", operation: "wait", input: { program: snapshot.identity, event, timeout }
         }, signal).then(value => value.payload)));
         this.reference = snapshot.reference;
@@ -196,11 +202,11 @@ class ProgramHandle extends ProgramBase {
     async agent() {
         if (!this.hasAgent)
             return null;
-        const value = await this.system.transport.control({ capability: "program", operation: "agent", input: { program: this.identity } });
+        const value = await transport(this.system).control({ capability: "program", operation: "agent", input: { program: this.identity } });
         return typeof value.content === "string" ? value.content : null;
     }
     async installed() {
-        for await (const event of this.system.transport.lifecycle({ word: "installed", handle: this.address() })) {
+        for await (const event of transport(this.system).lifecycle({ word: "installed", handle: this.address() })) {
             if (event.event === "installedState")
                 return event.installed === true;
         }
@@ -209,7 +215,7 @@ class ProgramHandle extends ProgramBase {
     install() { return command(this.system, { word: "install-existing", handle: this.address() }); }
     uninstall(everything = false) { return command(this.system, { word: "uninstall-existing", handle: this.address(), everything }); }
     async forget() {
-        for await (const _event of this.system.transport.lifecycle({ word: "forget", handle: this.address() })) { /* consume completion */ }
+        for await (const _event of transport(this.system).lifecycle({ word: "forget", handle: this.address() })) { /* consume completion */ }
     }
     address() { return Object.freeze({ identity: this.identity, reference: this.reference }); }
 }
@@ -221,7 +227,7 @@ class ProgramStartup {
         this.program = program;
     }
     async get() {
-        for await (const event of this.system.transport.lifecycle({
+        for await (const event of transport(this.system).lifecycle({
             word: "startup", handle: this.program.address(), operation: "get"
         })) {
             if (event.event === "startup")
@@ -236,7 +242,7 @@ class ProgramStartup {
         await this.change("disable");
     }
     async change(operation, launch) {
-        for await (const event of this.system.transport.lifecycle({
+        for await (const event of transport(this.system).lifecycle({
             word: "startup", handle: this.program.address(), operation, launch
         })) {
             if (event.event === "startup")
@@ -249,7 +255,7 @@ class ProgramProcesses extends Events {
     system;
     program;
     constructor(system, program) {
-        super(["endpointStart", "endpointStop", "create", "exit"], (event, signal, timeout) => system.transport.control({
+        super(["endpointStart", "endpointStop", "create", "exit"], (event, signal, timeout) => transport(system).control({
             capability: "process", operation: "wait", input: { program: program.identity, event, timeout }
         }, signal).then(value => processEvent(system, value)));
         this.system = system;
@@ -265,13 +271,13 @@ class ProgramProcesses extends Events {
     create(launch = {}) { return this.createExact("create-process", launch); }
     async *run(launch = {}, options = {}) {
         let process = null;
-        for await (const event of this.system.transport.lifecycle({
+        for await (const event of transport(this.system).lifecycle({
             word: "run-process",
             handle: this.program.address(),
             launch
         }, options.signal)) {
             if (event.event === "started") {
-                process = this.system.processHandle(required(event.process));
+                process = processHandle(this.system, required(event.process));
                 yield Object.freeze({ event: "started", process });
             }
             else if (event.event === "output") {
@@ -312,9 +318,9 @@ class ProgramProcesses extends Events {
         return processes.map(process => process.identity);
     }
     async createExact(word, launch) {
-        for await (const event of this.system.transport.lifecycle({ word, handle: this.program.address(), launch })) {
+        for await (const event of transport(this.system).lifecycle({ word, handle: this.program.address(), launch })) {
             if (event.event === "createdProcess")
-                return this.system.processHandle(required(event.process));
+                return processHandle(this.system, required(event.process));
         }
         throw new Error("The System did not confirm the created Process");
     }
@@ -322,7 +328,7 @@ class ProgramProcesses extends Events {
 class ProcessRegistry extends Events {
     system;
     constructor(system) {
-        super(["endpointStart", "endpointStop", "create", "exit"], (event, signal, timeout) => system.transport.control({
+        super(["endpointStart", "endpointStop", "create", "exit"], (event, signal, timeout) => transport(system).control({
             capability: "process", operation: "wait", input: { event, timeout }
         }, signal).then(value => processEvent(system, value)));
         this.system = system;
@@ -330,8 +336,8 @@ class ProcessRegistry extends Events {
     list() { return listProcesses(this.system); }
     async find(identity) {
         try {
-            const snapshot = await this.system.transport.control({ capability: "process", operation: "inspect", input: { process: identity } });
-            return this.system.processHandle(snapshot);
+            const snapshot = await transport(this.system).control({ capability: "process", operation: "inspect", input: { process: identity } });
+            return processHandle(this.system, snapshot);
         }
         catch (error) {
             if (unknown(error, "Process"))
@@ -352,7 +358,7 @@ class ProcessHandle extends ProcessBase {
         super();
         this.system = system;
         this.snapshot = snapshot;
-        bindEvents(this, new Events(["endpointStart", "endpointStop", "exit"], (event, signal, timeout) => system.transport.control({
+        bindEvents(this, new Events(["endpointStart", "endpointStop", "exit"], (event, signal, timeout) => transport(system).control({
             capability: "process", operation: "wait", input: { process: snapshot.identity, event, timeout }
         }, signal).then(value => processEvent(system, value))));
         this.identity = snapshot.identity;
@@ -361,9 +367,9 @@ class ProcessHandle extends ProcessBase {
         this.server = new ServerEndpoint(system, this);
         this.client = new ClientEndpoint(system, this);
     }
-    program() { return this.system.programHandle(required(this.snapshot.programSnapshot, this.snapshot.program)); }
+    program() { return programHandle(this.system, required(this.snapshot.programSnapshot, this.snapshot.program)); }
     async exit() {
-        await this.system.transport.control({ capability: "process", operation: "exit", input: { process: this.identity } });
+        await transport(this.system).control({ capability: "process", operation: "exit", input: { process: this.identity } });
     }
     async exited() { return await this.system.process.find(this.identity) === null; }
 }
@@ -371,15 +377,19 @@ class EndpointOperations extends Events {
     system;
     owner;
     endpoint;
+    lifecycle;
     constructor(system, owner, endpoint) {
         super([], (event, signal, timeout) => event === null
-            ? system.transport.api({ capability: "endpoint", operation: "wait", process: owner.identity, endpoint, event, timeout }, signal)
-            : system.transport.control({
+            ? transport(system).api({ capability: "endpoint", operation: "wait", process: owner.identity, endpoint, event, timeout }, signal)
+            : transport(system).control({
                 capability: "endpoint", operation: "wait", input: { process: owner.identity, endpoint, event, timeout }
             }, signal).then(value => value.payload));
         this.system = system;
         this.owner = owner;
         this.endpoint = endpoint;
+        this.lifecycle = new Events(["start", "stop"], (event, signal, timeout) => {
+            return waitEndpointLifecycle(system, owner, endpoint, event, signal, timeout);
+        });
     }
     process() { return Promise.resolve(this.owner); }
     async exists() {
@@ -389,21 +399,21 @@ class EndpointOperations extends Events {
     async start(client) { await this.operation("start", client); }
     async stop() { await this.operation("stop"); }
     async service() {
-        const key = await this.system.transport.api({ capability: "endpoint", operation: "service", process: this.owner.identity, endpoint: this.endpoint });
+        const key = await transport(this.system).api({ capability: "endpoint", operation: "service", process: this.owner.identity, endpoint: this.endpoint });
         return key ? this.system.service(key) : null;
     }
     publish(event, payload) {
-        void this.system.transport.control({ capability: "endpoint", operation: "publish", input: {
+        void transport(this.system).control({ capability: "endpoint", operation: "publish", input: {
                 process: this.owner.identity, endpoint: this.endpoint, event, payload
             } });
     }
     inspect() {
-        return this.system.transport.control({ capability: "endpoint", operation: "inspect", input: {
+        return transport(this.system).control({ capability: "endpoint", operation: "inspect", input: {
                 process: this.owner.identity, endpoint: this.endpoint
             } });
     }
     async operation(operation, client) {
-        await this.system.transport.control({ capability: "endpoint", operation, input: {
+        await transport(this.system).control({ capability: "endpoint", operation, input: {
                 process: this.owner.identity, endpoint: this.endpoint, ...(client ? { client } : {})
             } });
     }
@@ -412,12 +422,14 @@ class ServerEndpoint extends ServerBase {
     system;
     owner;
     endpoint = "server";
+    lifecycle;
     base;
     constructor(system, owner) {
         super();
         this.system = system;
         this.owner = owner;
         this.base = new EndpointOperations(system, owner, "server");
+        this.lifecycle = this.base.lifecycle;
         bindEvents(this, this.base);
     }
     process() { return this.base.process(); }
@@ -426,17 +438,17 @@ class ServerEndpoint extends ServerBase {
     stop() { return this.base.stop(); }
     publish(event, payload) { return this.base.publish(event, payload); }
     async ask(event, payload) {
-        return await this.system.transport.control({ capability: "endpoint", operation: "ask", input: {
+        return await transport(this.system).control({ capability: "endpoint", operation: "ask", input: {
                 process: this.owner.identity, endpoint: "server", event, payload
             } });
     }
     timeout(milliseconds) {
-        return { ask: (event, payload) => this.system.transport.control({
+        return { ask: (event, payload) => transport(this.system).control({
                 capability: "endpoint", operation: "ask", input: { process: this.owner.identity, endpoint: "server", event, payload, timeout: milliseconds }
             }) };
     }
     async waitReady(timeout) {
-        await this.system.transport.control({ capability: "endpoint", operation: "waitReady", input: { process: this.owner.identity, endpoint: "server", timeout } });
+        await transport(this.system).control({ capability: "endpoint", operation: "waitReady", input: { process: this.owner.identity, endpoint: "server", timeout } });
     }
     async service() {
         return await this.base.service();
@@ -444,11 +456,13 @@ class ServerEndpoint extends ServerBase {
 }
 class ClientEndpoint extends ClientBase {
     endpoint = "client";
+    lifecycle;
     window;
     base;
     constructor(system, owner) {
         super();
         this.base = new EndpointOperations(system, owner, "client");
+        this.lifecycle = this.base.lifecycle;
         bindEvents(this, this.base);
         this.window = new SystemWindow(system, owner);
     }
@@ -465,7 +479,7 @@ class SystemWindow extends Events {
     system;
     process;
     constructor(system, process) {
-        super(["move", "resize", "geometry", "minimize", "changeTitle", "front"], (event, signal, timeout) => system.transport.control({
+        super(["move", "resize", "geometry", "minimize", "changeTitle", "front"], (event, signal, timeout) => transport(system).control({
             capability: "window", operation: "wait", input: { process: process.identity, event, timeout }
         }, signal).then(value => value.payload));
         this.system = system;
@@ -485,44 +499,62 @@ class SystemWindow extends Events {
     async changeTitle(title) { await this.change("changeTitle", { title }); }
     async raise() { await this.change("raise", {}); }
     snapshot() {
-        return this.system.transport.control({ capability: "window", operation: "inspect", input: { process: this.process.identity } });
+        return transport(this.system).control({ capability: "window", operation: "inspect", input: { process: this.process.identity } });
     }
     async change(operation, input) {
-        await this.system.transport.control({ capability: "window", operation, input: { process: this.process.identity, ...input } });
+        await transport(this.system).control({ capability: "window", operation, input: { process: this.process.identity, ...input } });
     }
 }
-class ServiceBase extends Events {
+class ServiceBase {
     system;
     key;
     name;
+    lifecycle;
     constructor(system, key) {
-        super(["enable", "disable"], (event, signal, timeout) => system.transport.api({
-            capability: "service", operation: "wait", scope: "lifecycle", key, event, timeout
-        }, signal));
         this.system = system;
         this.key = key;
+        this.lifecycle = new Events(["enable", "disable"], (event, signal, timeout) => transport(system).api({
+            capability: "service", operation: "wait", scope: "lifecycle", key, event, timeout
+        }, signal));
         this.name = key.name;
     }
-    async enabled() { return await this.system.transport.api({ capability: "service", operation: "enabled", key: this.key }); }
-    async waitReady(timeout) { await this.system.transport.api({ capability: "service", operation: "waitReady", key: this.key, timeout }); }
+    async enabled() { return await transport(this.system).api({ capability: "service", operation: "enabled", key: this.key }); }
+    async waitReady(timeout) { await transport(this.system).api({ capability: "service", operation: "waitReady", key: this.key, timeout }); }
 }
 /** Node-SDK handle for a Service provided by a Server Endpoint. */
 export class ServerService extends CoreServerService {
     constructor() { super(); }
 }
 class ServerServiceHandle extends ServerService {
+    system;
+    key;
     name;
-    channel;
+    lifecycle;
     base;
     constructor(system, key) {
         super();
+        this.system = system;
+        this.key = key;
         this.base = new ServiceBase(system, key);
         this.name = key.name;
-        this.channel = new ServerServiceChannelHandle(system, key);
-        Object.assign(this, eventsOf(this.base));
+        this.lifecycle = this.base.lifecycle;
+        bindEvents(this, new Events([], (event, signal, timeout) => transport(system).api({
+            capability: "service", operation: "wait", scope: "events", key, event, timeout
+        }, signal)));
     }
     enabled() { return this.base.enabled(); }
     waitReady(timeout) { return this.base.waitReady(timeout); }
+    publish = (event, payload) => {
+        void transport(this.system).api({ capability: "service", operation: "publish", key: this.key, event, payload });
+    };
+    async ask(event, payload) {
+        return await transport(this.system).api({ capability: "service", operation: "ask", key: this.key, event, payload });
+    }
+    timeout(milliseconds) {
+        return { ask: (event, payload) => transport(this.system).api({
+                capability: "service", operation: "ask", key: this.key, event, payload, timeout: milliseconds
+            }) };
+    }
 }
 /** Node-SDK handle for a Service provided by a Client Endpoint. */
 export class ClientService extends CoreClientService {
@@ -530,53 +562,33 @@ export class ClientService extends CoreClientService {
 }
 class ClientServiceHandle extends ClientService {
     name;
-    channel;
+    lifecycle;
     base;
     constructor(system, key) {
         super();
         this.base = new ServiceBase(system, key);
         this.name = key.name;
-        this.channel = new ClientServiceChannelHandle(system, key);
-        Object.assign(this, eventsOf(this.base));
+        this.lifecycle = this.base.lifecycle;
+        bindEvents(this, new Events([], (event, signal, timeout) => transport(system).api({
+            capability: "service", operation: "wait", scope: "events", key, event, timeout
+        }, signal)));
     }
     enabled() { return this.base.enabled(); }
     waitReady(timeout) { return this.base.waitReady(timeout); }
 }
-class ClientServiceChannelHandle extends Events {
-    system;
-    key;
-    constructor(system, key) {
-        super([], (event, signal, timeout) => system.transport.api({ capability: "service", operation: "wait", scope: "channel", key, event, timeout }, signal));
-        this.system = system;
-        this.key = key;
-    }
-}
-class ServerServiceChannelHandle extends ClientServiceChannelHandle {
-    async ask(event, payload) {
-        return await this.system.transport.api({ capability: "service", operation: "ask", key: this.key, event, payload });
-    }
-    timeout(milliseconds) {
-        return { ask: (event, payload) => this.system.transport.api({
-                capability: "service", operation: "ask", key: this.key, event, payload, timeout: milliseconds
-            }) };
-    }
-    publish(event, payload) {
-        void this.system.transport.api({ capability: "service", operation: "publish", key: this.key, event, payload });
-    }
-}
 async function listProcesses(system, program) {
     const processes = [];
     let offset = 0;
     while (true) {
-        const page = await system.transport.control({ capability: "process", operation: "list", input: { program, limit: 100, offset } });
-        processes.push(...page.data.map(snapshot => system.processHandle(snapshot)));
+        const page = await transport(system).control({ capability: "process", operation: "list", input: { program, limit: 100, offset } });
+        processes.push(...page.data.map(snapshot => processHandle(system, snapshot)));
         offset += page.data.length;
         if (!page.truncated || !page.data.length)
             return processes;
     }
 }
 async function* command(system, request) {
-    for await (const event of system.transport.lifecycle(request)) {
+    for await (const event of transport(system).lifecycle(request)) {
         if (event.event === "output")
             yield {
                 stream: event.stream === "stderr" ? "stderr" : "stdout",
@@ -584,22 +596,38 @@ async function* command(system, request) {
             };
     }
 }
+async function waitEndpointLifecycle(system, owner, endpoint, event, signal, timeout = 10_000) {
+    if (event !== "start" && event !== "stop")
+        throw new Error(`An Endpoint lifecycle has no "${event}" event`);
+    const processEventName = event === "start" ? "endpointStart" : "endpointStop";
+    const deadline = Date.now() + timeout;
+    while (true) {
+        const value = await transport(system).control({
+            capability: "process",
+            operation: "wait",
+            input: { process: owner.identity, event: processEventName, timeout: Math.max(0, deadline - Date.now()) }
+        }, signal);
+        const changed = processEvent(system, value);
+        if (changed === owner[endpoint])
+            return undefined;
+    }
+}
 function processEvent(system, value) {
     const waited = value;
     const payload = waited.payload;
     if (waited.event === "exit" && payload)
         return {
-            process: system.processHandle(required(payload.processSnapshot, String(payload.process ?? ""))),
+            process: processHandle(system, required(payload.processSnapshot, String(payload.process ?? ""))),
             status: payload.status,
             code: payload.code,
             signal: payload.signal
         };
     if ((waited.event === "endpointStart" || waited.event === "endpointStop") && payload?.processSnapshot) {
-        const process = system.processHandle(payload.processSnapshot);
+        const process = processHandle(system, payload.processSnapshot);
         return payload.endpoint === "client" ? process.client : process.server;
     }
     if (payload && typeof payload.identity === "string")
-        return system.processHandle(payload);
+        return processHandle(system, payload);
     return payload;
 }
 function bindEvents(target, events) {
@@ -609,8 +637,7 @@ function eventsOf(events) {
     return {
         subscribe: events.subscribe,
         waitFor: events.waitFor,
-        events: events.events,
-        observe: events.observe
+        events: events.events
     };
 }
 function chronological(left, right) { return left.startedAt.getTime() - right.startedAt.getTime(); }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phreshos/node",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Node.js access to PhreshOS and Program projects.",
   "type": "module",
   "main": "dist/main.js",
@@ -32,7 +32,7 @@
     "prepack": "node --run build"
   },
   "dependencies": {
-    "@phreshos/core": "^0.1.24",
+    "@phreshos/core": "^0.1.26",
     "adm-zip": "^0.6.0",
     "jiti": "^2.7.0"
   },