@phreshos/node 0.1.2 → 0.1.4

package/dist/main.d.ts

@@ -1,4 +1,5 @@
 export { gatewayAddress } from "./address.js";
-export { Client, Endpoint, Process, Program, Server, System, type ProgramProcessRunEvent, type ProgramProcessRunOptions } from "./system.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 { resolveHome } from "./home.js";
 export { Project, type Manifest, type PackedProject, type ProjectMode, type ProjectOptions, type ProjectRunOptions } from "./project.js";

package/dist/main.js

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

package/dist/system.d.ts

@@ -1,6 +1,4 @@
-import { Client as CoreClient, ClientServiceHandler as CoreClientServiceHandler, Endpoint as CoreEndpoint, Process as CoreProcess, Program as CoreProgram, Server as CoreServer, ServerServiceHandler as CoreServerServiceHandler, type ClientDeclaration, type ClientServiceChannel, type EndpointDeclaration, type Launch, type LaunchClient, type Position, type ProgramDefinition, type ProgramCommandChunk, type ServerServiceChannel, 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,197 +32,14 @@ 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;
-}
-declare class ServerService<EventsMap extends object = {}> extends CoreServerServiceHandler<EventsMap> {
-    readonly name: string;
-    readonly channel: ServerServiceChannel<EventsMap>;
-    private readonly base;
-    constructor(system: System, key: ServiceKey & {
-        endpoint: "server";
-    });
-    enabled(): Promise<boolean>;
-    waitReady(timeout?: number): Promise<void>;
-}
-declare class ClientService<EventsMap extends object = {}> extends CoreClientServiceHandler<EventsMap> {
-    readonly name: string;
-    readonly channel: ClientServiceChannel<EventsMap>;
-    private readonly base;
-    constructor(system: System, key: ServiceKey & {
-        endpoint: "client";
-    });
-    enabled(): Promise<boolean>;
-    waitReady(timeout?: number): Promise<void>;
 }
-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;
+/** Node-SDK handle for a Service provided by a Server Endpoint. */
+export declare class ServerService<EventsMap extends object = {}> extends CoreServerService<EventsMap> {
+    protected constructor();
 }
-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;
-    };
+/** Node-SDK handle for a Service provided by a Client Endpoint. */
+export declare class ClientService<EventsMap extends object = {}> extends CoreClientService<EventsMap> {
+    protected constructor();
 }
 export type Program = SystemProgramEntity;
 export declare const Program: typeof CoreProgram;
@@ -252,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

@@ -1,4 +1,4 @@
-import { Client as CoreClient, ClientServiceHandler as CoreClientServiceHandler, Endpoint as CoreEndpoint, Process as CoreProcess, Program as CoreProgram, Server as CoreServer, ServerServiceHandler as CoreServerServiceHandler } from "@phreshos/core";
+import { Client as CoreClient, ClientService as CoreClientService, Endpoint as CoreEndpoint, Process as CoreProcess, Program as CoreProgram, Server as CoreServer, ServerService as CoreServerService, isServiceKey } from "@phreshos/core";
 import { homedir } from "node:os";
 import { gatewayAddress } from "./address.js";
 import Events from "./events.js";
@@ -7,85 +7,95 @@ 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();
-        return key.endpoint === "server"
-            ? new ServerService(this, key)
-            : new ClientService(this, key);
-    }
-    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");
+        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 systemState(this).handles.obtain(`service:${identity}`, () => normalized.endpoint === "server"
+            ? new ServerServiceHandle(this, normalized)
+            : new ClientServiceHandle(this, normalized));
     }
 }
+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;
     constructor(transport) {
@@ -102,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;
     }
@@ -110,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;
@@ -123,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"))
@@ -133,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");
     }
@@ -143,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 {
@@ -159,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;
@@ -192,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;
         }
@@ -205,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 }); }
 }
@@ -217,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")
@@ -232,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")
@@ -245,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;
@@ -261,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") {
@@ -308,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");
     }
@@ -318,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;
@@ -326,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"))
@@ -348,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;
@@ -357,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; }
 }
@@ -369,8 +379,8 @@ class EndpointOperations extends Events {
     endpoint;
     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;
@@ -385,21 +395,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 } : {})
             } });
     }
@@ -422,17 +432,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();
@@ -461,7 +471,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;
@@ -481,10 +491,10 @@ 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 {
@@ -492,17 +502,21 @@ class ServiceBase extends Events {
     key;
     name;
     constructor(system, key) {
-        super(["enable", "disable"], (event, signal, timeout) => system.transport.api({
+        super(["enable", "disable"], (event, signal, timeout) => transport(system).api({
             capability: "service", operation: "wait", scope: "lifecycle", key, event, timeout
         }, signal));
         this.system = system;
         this.key = key;
         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 ServerService extends CoreServerServiceHandler {
+class ServerServiceHandle extends ServerService {
     name;
     channel;
     base;
@@ -516,7 +530,11 @@ class ServerService extends CoreServerServiceHandler {
     enabled() { return this.base.enabled(); }
     waitReady(timeout) { return this.base.waitReady(timeout); }
 }
-class ClientService extends CoreClientServiceHandler {
+/** Node-SDK handle for a Service provided by a Client Endpoint. */
+export class ClientService extends CoreClientService {
+    constructor() { super(); }
+}
+class ClientServiceHandle extends ClientService {
     name;
     channel;
     base;
@@ -534,37 +552,37 @@ 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));
+        super([], (event, signal, timeout) => transport(system).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 });
+        return await transport(this.system).api({ capability: "service", operation: "ask", key: this.key, event, payload });
     }
     timeout(milliseconds) {
-        return { ask: (event, payload) => this.system.transport.api({
+        return { ask: (event, payload) => transport(this.system).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 });
+        void transport(this.system).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",
@@ -577,17 +595,17 @@ function processEvent(system, 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) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phreshos/node",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "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.23",
+    "@phreshos/core": "^0.1.25",
     "adm-zip": "^0.6.0",
     "jiti": "^2.7.0"
   },