@phreshos/node 0.1.12 → 0.1.14

package/dist/system.js

@@ -1,64 +1,68 @@
-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 { ClientEndpoint as CoreClientEndpoint, ClientService as CoreClientService, Endpoint as CoreEndpoint, Process as CoreProcess, Program as CoreProgram, ServerEndpoint as CoreServerEndpoint, ServerService as CoreServerService, isServiceKey, parseClientPermissions } from "@phreshos/core";
 import { homedir } from "node:os";
 import { gatewayAddress } from "./address.js";
 import Events from "./events.js";
 import HandleRegistry from "./handle-registry.js";
 import { resolveHome } from "./home.js";
-import { filesystemStorage } from "./storage.js";
-import { programPermission, programSql, programStore } from "./program-resources.js";
+import { filesystemStorage, nativeStorage } from "./storage.js";
+import { programPermissions, programSql, programStore } from "./program-resources.js";
 import { EndpointTrafficHandle, ServerTrafficHandle } from "./traffic.js";
-import { openConnection, request, streamProgram } from "./transport.js";
+import SystemRepresentation, {} from "./representation.js";
+import { GatewayConnection, openConnection } from "./transport.js";
 import Uploads from "./uploads.js";
+import shell from "./shell.js";
+import websocket from "./websocket.js";
 const systems = new WeakMap();
+const processSnapshots = new WeakMap();
 const ProgramBase = CoreProgram;
 const ProcessBase = CoreProcess;
-const ServerBase = CoreServer;
-const ClientBase = CoreClient;
+const ServerEndpointBase = CoreServerEndpoint;
+const ClientEndpointBase = CoreClientEndpoint;
 /** One connected owner-local implementation of the shared System contract. */
 export class System {
-    storage = filesystemStorage(homedir(), "the native home directory");
+    storage;
     appearance;
     program;
     process;
     uploads;
-    constructor(address, connection) {
+    async fetch(input, init) {
+        const request = new Request(input, init);
+        return await fetch(request, { signal: connectedSignal(this, request.signal) });
+    }
+    websocket(url, protocols) {
+        return websocket(url, protocols, connectedSignal(this));
+    }
+    async *shell(command, options = {}) {
+        yield* shell(command, { ...options, signal: connectedSignal(this, options.signal) });
+    }
+    constructor(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))
-        };
-        systems.set(this, { address, connection, handles, lifetime, transport, closed: false });
-        this.appearance = new SystemAppearance(transport);
+        const representation = new SystemRepresentation(connection);
+        systems.set(this, { connection, handles, lifetime, representation, closed: false });
+        connection.onDisconnect(() => void closeSystem(this, new Error("This System connection is closed")));
+        this.storage = nativeStorage(homedir(), "the native filesystem", () => connectedSignal(this));
+        this.appearance = new SystemAppearance(this);
         this.program = new ProgramRegistry(this);
         this.process = new ProcessRegistry(this);
-        this.uploads = new Uploads(value => transport.api(value));
+        this.uploads = new Uploads(value => uploadRequest(this, value), () => connectedSignal(this));
+        representation.activate();
     }
     /** 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(address, await openConnection(address));
+        return new System(await openConnection(address));
     }
     /** Atomically replace one runtime Program without touching its installed form. */
     async forceCreateProgram(source) {
         requireConnected(this);
-        for await (const event of transport(this).lifecycle({ word: "force-create", program: source })) {
-            if (event.event === "created")
-                return programHandle(this, required(event.program));
-        }
-        throw new Error("The System did not confirm the created Program");
+        const identity = await representation(this).call("/program/force-create-program", source, "");
+        return programHandle(this, required(representation(this).programs.get(identity), identity));
     }
     /** Close this owner connection and abort every attached operation it owns. */
     async disconnect() {
-        const state = systemState(this);
-        if (state.closed)
-            return;
-        state.closed = true;
-        state.lifetime.abort(new Error("This System connection is closed"));
-        state.connection.destroy();
-        state.handles.clear();
+        await closeSystem(this, new Error("This System connection is closed"));
     }
     service(key) {
         requireConnected(this);
@@ -81,6 +85,16 @@ function systemState(system) {
         throw new Error("Unknown System connection");
     return state;
 }
+function closeSystem(system, reason) {
+    const state = systemState(system);
+    if (state.closed)
+        return Promise.resolve();
+    state.closed = true;
+    state.lifetime.abort(reason);
+    state.representation.close();
+    state.handles.clear();
+    return state.connection.disconnect();
+}
 function requireConnected(system) {
     if (systemState(system).closed)
         throw new Error("This System connection is closed");
@@ -90,9 +104,9 @@ function connectedSignal(system, signal) {
     requireConnected(system);
     return signal ? AbortSignal.any([signal, lifetime]) : lifetime;
 }
-function transport(system) {
+function representation(system) {
     requireConnected(system);
-    return systemState(system).transport;
+    return systemState(system).representation;
 }
 function programHandle(system, snapshot) {
     const handle = systemState(system).handles.obtain(`program:${snapshot.reference}`, () => new ProgramHandle(system, snapshot));
@@ -103,65 +117,45 @@ function processHandle(system, snapshot) {
     return systemState(system).handles.obtain(`process:${snapshot.reference}`, () => new ProcessHandle(system, snapshot));
 }
 class SystemAppearance extends Events {
-    transport;
-    constructor(transport) {
-        super(["change"], (_event, signal) => transport.api({ capability: "appearance", operation: "wait" }, signal));
-        this.transport = transport;
+    system;
+    constructor(system) {
+        super(["change"], (_event, subscriber) => representation(system).on("appearance", subscriber));
+        this.system = system;
     }
     async snapshot() {
-        return await this.transport.api({ capability: "appearance", operation: "snapshot" });
+        return representation(this.system).appearance;
     }
     async update(appearance) {
-        await this.transport.api({ capability: "appearance", operation: "update", value: appearance });
+        await representation(this.system).call("/appearance/update", appearance);
     }
 }
 class ProgramRegistry extends Events {
     system;
     constructor(system) {
-        super(["create", "forget", "install", "uninstall"], (event, signal, timeout) => (transport(system).control({ capability: "program", operation: "wait", input: { event, timeout } }, signal)
-            .then(value => this.event(value))));
+        super(["create", "forget", "install", "uninstall"], (event, subscriber) => {
+            if (event === null)
+                throw new Error("System Program events are named");
+            return representation(system).on(`program:${event}`, (...values) => subscriber(this.event(event, values)));
+        });
         this.system = system;
     }
     async list(onlyInstalled = false) {
-        const programs = [];
-        let offset = 0;
-        while (true) {
-            const page = await transport(this.system).control({
-                capability: "program",
-                operation: "list",
-                input: { installedOnly: onlyInstalled, limit: 100, offset }
-            });
-            programs.push(...page.data.map(snapshot => programHandle(this.system, snapshot)));
-            offset += page.data.length;
-            if (!page.truncated || !page.data.length)
-                return programs;
-        }
+        return [...representation(this.system).programs.values()]
+            .filter(program => !onlyInstalled || program.installed)
+            .sort((left, right) => left.identity.localeCompare(right.identity))
+            .map(program => programHandle(this.system, program));
     }
     async find(identity) {
-        try {
-            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"))
-                return null;
-            throw error;
-        }
+        const program = representation(this.system).programs.get(identity);
+        return program ? programHandle(this.system, program) : null;
     }
     async create(source) {
-        for await (const event of transport(this.system).lifecycle({ word: "create", program: source })) {
-            if (event.event === "created")
-                return programHandle(this.system, required(event.program));
-        }
-        throw new Error("The System did not confirm the created Program");
+        const identity = await representation(this.system).call("/program/create-program", source);
+        return programHandle(this.system, required(representation(this.system).programs.get(identity), identity));
     }
-    async event(value) {
-        const waited = value;
-        if (waited.event === "uninstall") {
-            const payload = waited.payload;
-            return { program: programHandle(this.system, required(payload.program)), everything: payload.everything === true };
-        }
-        return programHandle(this.system, required(waited.payload));
+    event(event, values) {
+        const program = programHandle(this.system, required(values[0]));
+        return event === "uninstall" ? { program, everything: values[1] === true } : program;
     }
 }
 class ProgramHandle extends ProgramBase {
@@ -173,9 +167,9 @@ class ProgramHandle extends ProgramBase {
     store;
     logs;
     database;
-    permission;
     process;
     startup;
+    permissions;
     snapshot;
     constructor(system, snapshot) {
         super();
@@ -184,20 +178,24 @@ class ProgramHandle extends ProgramBase {
         this.reference = snapshot.reference;
         this.identity = snapshot.identity;
         const address = this.address();
-        bindEvents(this, new Events(["forget", "uninstall"], (event, signal, timeout) => transport(system).api({
-            capability: "program", operation: "wait", handle: address, event, timeout
-        }, signal)));
-        const request = (value) => transport(system).api(value);
-        this.data = filesystemStorage(() => programStoragePath(system, address, "data"), `Program "${this.identity}" data`);
-        this.cache = filesystemStorage(() => programStoragePath(system, address, "cache"), `Program "${this.identity}" cache`);
-        this.store = programStore(request, address);
-        this.logs = programSql(request, address, "logs");
-        this.database = programSql(request, address, "database");
-        this.permission = programPermission(request, address);
+        bindEvents(this, new Events(["forget", "uninstall"], (event, subscriber) => {
+            if (event === null)
+                throw new Error("Program events are named");
+            return representation(system).on(`program:${this.reference}:${event}`, (...values) => subscriber(values[0]));
+        }));
+        representation(system).on(`program:${this.reference}:change`, value => this.update(value));
+        const call = (event, ...values) => representation(system).call(event, ...values);
+        this.data = filesystemStorage(() => programStoragePath(system, address, "data"), `Program "${this.identity}" data`, () => connectedSignal(system));
+        this.cache = filesystemStorage(() => programStoragePath(system, address, "cache"), `Program "${this.identity}" cache`, () => connectedSignal(system));
+        this.store = programStore(call, address);
+        this.logs = programSql(call, address, "logs");
+        this.database = programSql(call, address, "database");
         this.process = new ProgramProcesses(system, this);
         this.startup = new ProgramStartup(system, this);
+        this.permissions = programPermissions(call, address);
     }
     get name() { return this.snapshot.name; }
+    get assetId() { return this.snapshot.assetId; }
     get version() { return this.snapshot.version; }
     get description() { return this.snapshot.description; }
     get hasAgent() { return this.snapshot.hasAgent; }
@@ -215,7 +213,8 @@ class ProgramHandle extends ProgramBase {
             size: this.snapshot.client.size,
             position: this.snapshot.client.position,
             layer: this.snapshot.client.layer,
-            minimize: this.snapshot.client.minimize
+            minimize: this.snapshot.client.minimize,
+            permissions: parseClientPermissions(this.snapshot.client.permissions)
         }) : null;
     }
     update(snapshot) {
@@ -224,7 +223,7 @@ class ProgramHandle extends ProgramBase {
         this.snapshot = snapshot;
     }
     async icon(size = "medium") {
-        const value = await transport(this.system).api({ capability: "program", operation: "icon", handle: this.address(), size });
+        const value = await representation(this.system).call("/program/icon", this.address(), size);
         if (!Array.isArray(value) || value.some(byte => typeof byte !== "number"))
             throw new Error("The System returned an invalid Program icon");
         return new Blob([Uint8Array.from(value)], { type: "image/png" });
@@ -232,27 +231,20 @@ class ProgramHandle extends ProgramBase {
     async agent() {
         if (!this.hasAgent)
             return null;
-        const value = await transport(this.system).api({ capability: "program", operation: "agent", handle: this.address() });
+        const value = await representation(this.system).call("/program/agent", this.address());
         return typeof value === "string" ? value : null;
     }
     async installed() {
-        for await (const event of transport(this.system).lifecycle({ word: "installed", handle: this.address() })) {
-            if (event.event === "installedState")
-                return event.installed === true;
-        }
-        throw new Error("The System returned no Program installation state");
+        return this.snapshot.installed;
     }
-    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 }); }
+    install() { return command(this.system, "install", this.address()); }
+    uninstall(everything = false) { return command(this.system, "uninstall", this.address(), everything); }
     async fork(identity) {
-        for await (const event of transport(this.system).lifecycle({ word: "fork", handle: this.address(), identity })) {
-            if (event.event === "created")
-                return programHandle(this.system, required(event.program));
-        }
-        throw new Error("The System did not confirm the forked Program");
+        const created = await representation(this.system).call("/program/fork-program", this.address(), identity);
+        return programHandle(this.system, required(representation(this.system).programs.get(created), created));
     }
     async forget() {
-        for await (const _event of transport(this.system).lifecycle({ word: "forget", handle: this.address() })) { /* consume completion */ }
+        await representation(this.system).call("/program/forget-program", this.address(), "");
     }
     address() { return Object.freeze({ identity: this.identity, reference: this.reference }); }
 }
@@ -264,13 +256,7 @@ class ProgramStartup {
         this.program = program;
     }
     async get() {
-        for await (const event of transport(this.system).lifecycle({
-            word: "startup", handle: this.program.address(), operation: "get"
-        })) {
-            if (event.event === "startup")
-                return event.launch;
-        }
-        throw new Error("The System returned no Program startup state");
+        return await representation(this.system).call("/program/startup", this.program.address(), "get");
     }
     async enable(launch = {}) {
         await this.change("enable", launch);
@@ -279,30 +265,25 @@ class ProgramStartup {
         await this.change("disable");
     }
     async change(operation, launch) {
-        for await (const event of transport(this.system).lifecycle({
-            word: "startup", handle: this.program.address(), operation, launch
-        })) {
-            if (event.event === "startup")
-                return;
-        }
-        throw new Error("The System did not confirm the Program startup change");
+        await representation(this.system).call("/program/startup", this.program.address(), operation, launch);
     }
 }
 class ProgramProcesses extends Events {
     system;
     program;
     constructor(system, program) {
-        super(["create", "exit"], (event, signal, timeout) => transport(system).api({
-            capability: "programProcess", operation: "wait", handle: program.address(), event, timeout
-        }, signal).then(value => programProcessEvent(system, event, value)));
+        super(["create", "exit"], (event, subscriber) => {
+            if (event === null)
+                throw new Error("Program Process events are named");
+            return representation(system).on(`program:${program.identity}:process:${event}`, (...values) => (subscriber(programProcessEvent(system, event, values))));
+        });
         this.system = system;
         this.program = program;
     }
     async list() {
-        const value = await transport(this.system).api({ capability: "programProcess", operation: "list", handle: this.program.address() });
-        if (!Array.isArray(value))
-            throw new Error("The System returned an invalid Program Process list");
-        return value.map(snapshot => processHandle(this.system, snapshot));
+        return [...representation(this.system).processes.values()]
+            .filter(process => process.program === this.program.identity)
+            .map(process => processHandle(this.system, process));
     }
     async first() { return (await this.list()).sort(chronological)[0] ?? null; }
     async last() { return (await this.list()).sort(chronological).at(-1) ?? null; }
@@ -313,13 +294,12 @@ class ProgramProcesses extends Events {
     create(launch = {}) { return this.createExact("create-process", launch); }
     async *run(launch = {}, options = {}) {
         let process = null;
-        for await (const event of transport(this.system).lifecycle({
-            word: "run-process",
-            handle: this.program.address(),
-            launch
-        }, options.signal)) {
+        for await (const event of representation(this.system).command("run", this.program.address(), launch, options.signal)) {
             if (event.event === "started") {
-                process = processHandle(this.system, required(event.process));
+                const identity = event.process?.identity;
+                if (typeof identity !== "string")
+                    throw new Error("The System returned an invalid started Process");
+                process = processHandle(this.system, required(representation(this.system).processes.get(identity), identity));
                 yield Object.freeze({ event: "started", process });
             }
             else if (event.event === "output") {
@@ -355,42 +335,32 @@ class ProgramProcesses extends Events {
     }
     findOrCreate(launch) { return this.createExact("find-or-create-process", launch); }
     async exitAll() {
-        const processes = await this.list();
-        await Promise.all(processes.map(process => process.exit()));
-        return processes.map(process => process.identity);
+        return await representation(this.system).call("/process/exit-all", this.program.identity, "");
     }
     async createExact(word, launch) {
-        for await (const event of transport(this.system).lifecycle({ word, handle: this.program.address(), launch })) {
-            if (event.event === "createdProcess")
-                return processHandle(this.system, required(event.process));
-        }
-        throw new Error("The System did not confirm the created Process");
+        const route = word === "create-process" ? "/program/create-process" : "/program/find-or-create-process";
+        const identity = await representation(this.system).call(route, this.program.address(), launch, null);
+        return processHandle(this.system, required(representation(this.system).processes.get(identity), identity));
     }
 }
 class ProcessRegistry extends Events {
     system;
     constructor(system) {
-        super(["create", "exit"], (event, signal, timeout) => transport(system).control({
-            capability: "process", operation: "wait", input: { event, timeout }
-        }, signal).then(value => processEvent(system, value)));
+        super(["create", "exit"], (event, subscriber) => {
+            if (event === null)
+                throw new Error("System Process events are named");
+            return representation(system).on(`process:${event}`, (...values) => subscriber(processEvent(system, event, values)));
+        });
         this.system = system;
     }
     list() { return listProcesses(this.system); }
     async find(identity) {
-        try {
-            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"))
-                return null;
-            throw error;
-        }
+        const process = representation(this.system).processes.get(identity);
+        return process ? processHandle(this.system, process) : null;
     }
 }
 class ProcessHandle extends ProcessBase {
     system;
-    snapshot;
     identity;
     name;
     startedAt;
@@ -399,30 +369,32 @@ class ProcessHandle extends ProcessBase {
     constructor(system, snapshot) {
         super();
         this.system = system;
-        this.snapshot = snapshot;
-        bindEvents(this, new Events(["exit"], (event, signal, timeout) => transport(system).control({
-            capability: "process", operation: "wait", input: { process: snapshot.identity, event, timeout }
-        }, signal).then(exactProcessEvent)));
+        processSnapshots.set(this, snapshot);
+        bindEvents(this, new Events(["exit"], (_event, subscriber) => (representation(system).on(`process:${snapshot.reference}:exit`, value => subscriber(value)))));
         this.identity = snapshot.identity;
         this.name = snapshot.name;
         this.startedAt = new Date(snapshot.startedAt);
-        this.server = new ServerEndpoint(system, this);
-        this.client = new ClientEndpoint(system, this);
+        this.server = new ServerEndpointHandle(system, this);
+        this.client = new ClientEndpointHandle(system, this);
+    }
+    program() {
+        const snapshot = processState(this.system, this);
+        return programHandle(this.system, required(representation(this.system).programs.get(snapshot.program), snapshot.program));
     }
-    program() { return programHandle(this.system, required(this.snapshot.programSnapshot, this.snapshot.program)); }
     async parent() {
         if (!await this.exists())
             throw new Error(`Process "${this.identity}" no longer exists`);
-        if (this.snapshot.parent === null)
+        const snapshot = processState(this.system, this);
+        if (snapshot.parent === null)
             return null;
-        const parent = await this.system.process.find(this.snapshot.parent);
+        const parent = await this.system.process.find(snapshot.parent.identity);
         if (!parent)
             throw new Error("The parent Process no longer exists");
         return parent;
     }
-    async option(name) { return this.snapshot.options[name]; }
+    async option(name) { return processState(this.system, this).options[name]; }
     async exit() {
-        await transport(this.system).control({ capability: "process", operation: "exit", input: { process: this.identity } });
+        await representation(this.system).call("/process/exit", this.identity);
     }
     async exited() { return await this.system.process.find(this.identity) === null; }
     async exists() { return !await this.exited(); }
@@ -433,52 +405,37 @@ class EndpointOperations extends Events {
     endpoint;
     lifecycle;
     constructor(system, owner, endpoint) {
-        super([], (event, signal, timeout) => event === null
-            ? 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));
+        super([], (event, subscriber, impossible) => representation(system).follow({
+            scope: "endpoint",
+            process: owner.identity,
+            endpoint,
+            event
+        }, (_received, payload) => subscriber(payload), impossible));
         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);
-        });
+        this.lifecycle = new Events(["start", "stop"], (event, subscriber, impossible) => (endpointLifecycle(system, owner, endpoint, event, subscriber, impossible)));
     }
     process() { return Promise.resolve(this.owner); }
     async exists() {
-        const value = await this.inspect();
-        return value.running;
+        return endpointState(this.system, this.owner, this.endpoint) !== null;
     }
     async start(launch = {}) { await this.operation("start", launch); }
     async stop() { await this.operation("stop"); }
     async waitReady(timeout) {
-        await transport(this.system).control({ capability: "endpoint", operation: "waitReady", input: {
-                process: this.owner.identity, endpoint: this.endpoint, timeout
-            } });
+        await waitEndpointReady(this.system, this.owner, this.endpoint, timeout);
     }
     async isService() {
-        return await transport(this.system).api({
-            capability: "endpoint", operation: "isService", process: this.owner.identity, endpoint: this.endpoint
-        });
+        return endpointState(this.system, this.owner, this.endpoint)?.service === true;
     }
     publish(event, payload) {
-        void transport(this.system).control({ capability: "endpoint", operation: "publish", input: {
-                process: this.owner.identity, endpoint: this.endpoint, event, payload
-            } });
-    }
-    inspect() {
-        return transport(this.system).control({ capability: "endpoint", operation: "inspect", input: {
-                process: this.owner.identity, endpoint: this.endpoint
-            } });
+        void representation(this.system).call("/process/endpoint/publish", this.owner.identity, this.endpoint, event, payload);
     }
     async operation(operation, launch) {
-        await transport(this.system).control({ capability: "endpoint", operation, input: {
-                process: this.owner.identity, endpoint: this.endpoint, ...(launch ? { launch } : {})
-            } });
+        await representation(this.system).call(`/process/endpoint/${operation}`, this.owner.identity, this.endpoint, launch);
     }
 }
-class ServerEndpoint extends ServerBase {
+class ServerEndpointHandle extends ServerEndpointBase {
     system;
     owner;
     endpoint = "server";
@@ -490,7 +447,7 @@ class ServerEndpoint extends ServerBase {
         this.system = system;
         this.owner = owner;
         this.base = new EndpointOperations(system, owner, "server");
-        this.traffic = new ServerTrafficHandle((value, signal) => transport(system).api(value, signal), owner.identity, "server", value => endpointFromReference(system, value));
+        this.traffic = new ServerTrafficHandle(representation(system), owner.identity, "server", value => endpointFromReference(system, value));
         this.lifecycle = this.base.lifecycle;
         bindEvents(this, this.base);
     }
@@ -502,17 +459,16 @@ class ServerEndpoint extends ServerBase {
     stop() { return this.base.stop(); }
     publish(event, payload) { return this.base.publish(event, payload); }
     async ask(event, payload) {
-        return await transport(this.system).control({ capability: "endpoint", operation: "ask", input: {
-                process: this.owner.identity, endpoint: "server", event, payload
-            } });
+        return await this.askWithin(event, payload, 10_000);
     }
     timeout(milliseconds) {
-        return { ask: (event, payload) => transport(this.system).control({
-                capability: "endpoint", operation: "ask", input: { process: this.owner.identity, endpoint: "server", event, payload, timeout: milliseconds }
-            }) };
+        return { ask: (event, payload) => this.askWithin(event, payload, milliseconds) };
+    }
+    askWithin(event, payload, timeout) {
+        return representation(this.system).call("/process/endpoint/ask", this.owner.identity, event, payload, timeout);
     }
 }
-class ClientEndpoint extends ClientBase {
+class ClientEndpointHandle extends ClientEndpointBase {
     endpoint = "client";
     traffic;
     lifecycle;
@@ -521,7 +477,7 @@ class ClientEndpoint extends ClientBase {
     constructor(system, owner) {
         super();
         this.base = new EndpointOperations(system, owner, "client");
-        this.traffic = new EndpointTrafficHandle((value, signal) => transport(system).api(value, signal), owner.identity, "client", value => endpointFromReference(system, value));
+        this.traffic = new EndpointTrafficHandle(representation(system), owner.identity, "client", value => endpointFromReference(system, value));
         this.lifecycle = this.base.lifecycle;
         bindEvents(this, this.base);
         this.window = new SystemWindow(system, owner);
@@ -538,9 +494,11 @@ class SystemWindow extends Events {
     system;
     process;
     constructor(system, process) {
-        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));
+        super(["move", "resize", "geometry", "minimize", "changeTitle", "front"], (event, subscriber) => {
+            if (event === null)
+                throw new Error("Window events are named");
+            return representation(system).on(`window:${process.identity}:${event}`, subscriber);
+        });
         this.system = system;
         this.process = process;
     }
@@ -548,20 +506,23 @@ class SystemWindow extends Events {
     async position() { return (await this.snapshot()).position; }
     async size() { return (await this.snapshot()).size; }
     async minimized() { return (await this.snapshot()).minimized; }
-    async front() { return (await this.snapshot()).front; }
+    async front() { return frontWindow(this.system, this.process); }
     async layer() { return (await this.snapshot()).layer; }
     async location() { return (await this.snapshot()).location; }
-    async move(position) { await this.change("move", { position }); }
-    async resize(size) { await this.change("resize", { size }); }
-    async setGeometry(geometry) { await this.change("setGeometry", geometry); }
-    async minimize(minimized = true) { await this.change("minimize", { minimized }); }
-    async changeTitle(title) { await this.change("changeTitle", { title }); }
-    async raise() { await this.change("raise", {}); }
+    async move(position) { await this.change("move", position); }
+    async resize(size) { await this.change("resize", size); }
+    async setGeometry(geometry) { await this.change("geometry", geometry); }
+    async minimize(minimized = true) { await this.change("minimize", minimized); }
+    async changeTitle(title) { await this.change("change-title", title); }
+    async raise() { await this.change("raise"); }
     snapshot() {
-        return transport(this.system).control({ capability: "window", operation: "inspect", input: { process: this.process.identity } });
+        const window = processState(this.system, this.process).client?.window;
+        if (!window)
+            throw new Error(`Process "${this.process.identity}" has no live Client Endpoint`);
+        return Promise.resolve(window);
     }
     async change(operation, input) {
-        await transport(this.system).control({ capability: "window", operation, input: { process: this.process.identity, ...input } });
+        await representation(this.system).call(`/process/${operation}`, this.process.identity, input);
     }
 }
 class ServiceBase {
@@ -571,19 +532,19 @@ class ServiceBase {
     constructor(system, key) {
         this.system = system;
         this.key = key;
-        this.lifecycle = new Events(["start", "stop"], (event, signal, timeout) => transport(system).api({
-            capability: "service", operation: "wait", scope: "lifecycle", key, event, timeout
-        }, signal));
+        this.lifecycle = new Events(["start", "stop"], (event, subscriber, impossible) => representation(system).follow({
+            scope: "service", key, kind: "lifecycle", event
+        }, (_received, payload) => subscriber(payload), impossible));
     }
-    async exists() { return await transport(this.system).api({ capability: "service", operation: "exists", key: this.key }); }
+    async exists() { return serviceState(this.system, this.key) !== null; }
     async waitReady(timeout) {
-        await transport(this.system).api({ capability: "service", operation: "waitReady", key: this.key, timeout });
+        await representation(this.system).call("/process/service/wait-ready", this.key, timeout);
     }
     publish(event, payload) {
-        void transport(this.system).api({ capability: "service", operation: "publish", key: this.key, event, payload });
+        void representation(this.system).call("/process/service/publish", this.key, event, payload);
     }
 }
-/** Node-SDK handle for a Service provided by a Server Endpoint. */
+/** Node SDK handle for a Service provided by a Server Endpoint. */
 export class ServerService extends CoreServerService {
     constructor() { super(); }
 }
@@ -598,23 +559,21 @@ class ServerServiceHandle extends ServerService {
         this.key = key;
         this.base = new ServiceBase(system, key);
         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)));
+        bindEvents(this, new Events([], (event, subscriber, impossible) => representation(system).follow({
+            scope: "service", key, kind: "events", event
+        }, (_received, payload) => subscriber(payload), impossible)));
     }
     exists() { return this.base.exists(); }
     waitReady(timeout) { return this.base.waitReady(timeout); }
     publish = (event, payload) => this.base.publish(event, payload);
     async ask(event, payload) {
-        return await transport(this.system).api({ capability: "service", operation: "ask", key: this.key, event, payload });
+        return await representation(this.system).call("/process/service/ask", this.key, event, payload, 10_000);
     }
     timeout(milliseconds) {
-        return { ask: (event, payload) => transport(this.system).api({
-                capability: "service", operation: "ask", key: this.key, event, payload, timeout: milliseconds
-            }) };
+        return { ask: (event, payload) => representation(this.system).call("/process/service/ask", this.key, event, payload, milliseconds) };
     }
 }
-/** Node-SDK handle for a Service provided by a Client Endpoint. */
+/** Node SDK handle for a Service provided by a Client Endpoint. */
 export class ClientService extends CoreClientService {
     constructor() { super(); }
 }
@@ -625,27 +584,21 @@ class ClientServiceHandle extends ClientService {
         super();
         this.base = new ServiceBase(system, key);
         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)));
+        bindEvents(this, new Events([], (event, subscriber, impossible) => representation(system).follow({
+            scope: "service", key, kind: "events", event
+        }, (_received, payload) => subscriber(payload), impossible)));
     }
     exists() { return this.base.exists(); }
     waitReady(timeout) { return this.base.waitReady(timeout); }
     publish = (event, payload) => this.base.publish(event, payload);
 }
 async function listProcesses(system) {
-    const processes = [];
-    let offset = 0;
-    while (true) {
-        const page = await transport(system).control({ capability: "process", operation: "list", input: { 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 transport(system).lifecycle(request)) {
+    return [...representation(system).processes.values()]
+        .sort((left, right) => right.startedAt.getTime() - left.startedAt.getTime())
+        .map(process => processHandle(system, process));
+}
+async function* command(system, operation, subject, value) {
+    for await (const event of representation(system).command(operation, subject, value)) {
         if (event.event === "output")
             yield {
                 stream: event.stream === "stderr" ? "stderr" : "stdout",
@@ -653,49 +606,21 @@ async function* command(system, request) {
             };
     }
 }
-async function waitEndpointLifecycle(system, owner, endpoint, event, signal, timeout = 10_000) {
+function endpointLifecycle(system, owner, endpoint, event, subscriber, impossible) {
     if (event !== "start" && event !== "stop")
         throw new Error(`An Endpoint lifecycle has no "${event}" event`);
-    await transport(system).control({
-        capability: "endpoint",
-        operation: "waitLifecycle",
-        input: { process: owner.identity, endpoint, event, timeout }
-    }, signal);
-}
-function processEvent(system, value) {
-    const waited = value;
-    const payload = waited.payload;
-    if (waited.event === "exit" && payload)
-        return {
-            process: processHandle(system, required(payload.processSnapshot, String(payload.process ?? ""))),
-            status: payload.status,
-            code: payload.code,
-            signal: payload.signal
-        };
-    if (payload && typeof payload.identity === "string")
-        return processHandle(system, payload);
-    return payload;
-}
-function programProcessEvent(system, event, value) {
-    if (event === "create")
-        return processHandle(system, value);
-    const exit = value;
-    return {
-        process: processHandle(system, required(exit.process)),
-        status: exit.status,
-        code: exit.code,
-        signal: exit.signal
-    };
+    const model = representation(system);
+    const stopEvent = model.on(`endpoint:${processReference(owner)}:${endpoint}:${event}`, () => subscriber(undefined));
+    const stopExit = model.on(`process:${processReference(owner)}:exit`, () => impossible?.(new Error(`Process "${owner.identity}" exited`)));
+    return () => { stopEvent(); stopExit(); };
 }
-function exactProcessEvent(value) {
-    const payload = value.payload;
-    if (!payload)
-        return payload;
-    return {
-        status: payload.status,
-        code: payload.code,
-        signal: payload.signal
-    };
+function processEvent(system, event, values) {
+    const process = processHandle(system, required(values[0]));
+    return event === "exit" ? { process, ...values[1] } : process;
+}
+function programProcessEvent(system, event, values) {
+    const process = processHandle(system, required(values[0]));
+    return event === "exit" ? { process, ...values[1] } : process;
 }
 function bindEvents(target, events) {
     Object.assign(target, eventsOf(events));
@@ -709,36 +634,84 @@ function eventsOf(events) {
 }
 function chronological(left, right) { return left.startedAt.getTime() - right.startedAt.getTime(); }
 async function programStoragePath(system, handle, area) {
-    const value = await transport(system).api({ capability: "program", operation: "storagePath", handle, area });
+    const value = await representation(system).call("/program/area", handle, area, "path", []);
     if (typeof value !== "string")
         throw new Error("The System returned an invalid Program storage path");
     return value;
 }
 function endpointFromReference(system, value) {
     const reference = value;
-    if (!reference || (reference.kind !== "server" && reference.kind !== "client"))
+    if (!reference || (reference.kind !== "server" && reference.kind !== "client") || typeof reference.process?.identity !== "string") {
         throw new Error("The System returned an invalid Endpoint reference");
-    const owner = processHandle(system, snapshotFromReference(reference.process));
+    }
+    const owner = processHandle(system, required(representation(system).processes.get(reference.process.identity), reference.process.identity));
     return reference.kind === "server" ? owner.server : owner.client;
 }
-function snapshotFromReference(reference) {
-    const owner = reference.program;
-    if (!owner || typeof owner.reference !== "string" || typeof owner.identity !== "string")
-        throw new Error("The System returned an invalid Process reference");
-    return {
-        reference: reference.reference,
-        identity: reference.identity,
-        name: reference.name,
-        program: owner.identity,
-        programSnapshot: owner,
-        parent: null,
-        options: reference.options,
-        startedAt: reference.startedAt,
-        server: { declared: owner.server !== null, running: reference.server !== null, service: reference.server?.service === true },
-        client: { declared: owner.client !== null, running: reference.client !== null, service: reference.client?.service === true }
-    };
+function processState(system, process) {
+    const original = required(processSnapshots.get(process));
+    const current = representation(system).processes.get(process.identity);
+    if (!current || current.reference !== original.reference)
+        throw new Error(`Process "${process.identity}" no longer exists`);
+    return current;
+}
+function processReference(process) { return required(processSnapshots.get(process)).reference; }
+function endpointState(system, process, endpoint) {
+    const current = representation(system).processes.get(process.identity);
+    const original = required(processSnapshots.get(process));
+    return current?.reference === original.reference ? current[endpoint] : null;
+}
+function waitEndpointReady(system, process, endpoint, timeout = 10_000) {
+    if (endpointReady(endpointState(system, process, endpoint), endpoint))
+        return Promise.resolve();
+    return new Promise((resolve, reject) => {
+        const model = representation(system);
+        const reference = processReference(process);
+        const finish = (work) => {
+            clearTimeout(timer);
+            stopStart();
+            stopReady();
+            stopExit();
+            work();
+        };
+        const inspect = () => {
+            if (endpointReady(endpointState(system, process, endpoint), endpoint))
+                finish(resolve);
+        };
+        const stopStart = model.on(`endpoint:${reference}:${endpoint}:start`, inspect);
+        const stopReady = model.on(`endpoint:${reference}:${endpoint}:ready`, inspect);
+        const stopExit = model.on(`process:${reference}:exit`, () => finish(() => reject(new Error(`Process "${process.identity}" exited`))));
+        const timer = setTimeout(() => finish(() => reject(new Error("The Endpoint did not become ready before the timeout"))), timeout);
+        inspect();
+    });
+}
+function endpointReady(state, endpoint) {
+    return state !== null && (endpoint === "client" || "ready" in state && state.ready);
+}
+function serviceState(system, key) {
+    const model = representation(system);
+    const process = key.program === undefined
+        ? model.processes.get(key.process)
+        : [...model.processes.values()].find(candidate => candidate.program === key.program && (candidate.identity === key.process || candidate.name === key.process));
+    const endpoint = process?.[key.endpoint];
+    return endpoint?.service === true ? endpoint : null;
+}
+function frontWindow(system, process) {
+    const window = processState(system, process).client?.window;
+    if (!window || window.minimized)
+        return false;
+    return ![...representation(system).processes.values()].some(candidate => {
+        const other = candidate.client?.window;
+        return other && !other.minimized && other.layer === window.layer && other.depth > window.depth;
+    });
+}
+async function uploadRequest(system, value) {
+    const request = value;
+    if (request.operation === "access")
+        return representation(system).call("/uploads/access");
+    if (request.operation === "stat")
+        return representation(system).call("/uploads/stat", request.file);
+    throw new Error(`The Uploads API does not know "${String(request.operation)}"`);
 }
-function unknown(error, entity) { return error instanceof Error && error.message.startsWith(`Unknown ${entity}`); }
 function required(value, identity = "") {
     if (value !== undefined)
         return value;
@@ -747,5 +720,5 @@ function required(value, identity = "") {
 export const Program = CoreProgram;
 export const Process = CoreProcess;
 export const Endpoint = CoreEndpoint;
-export const Server = CoreServer;
-export const Client = CoreClient;
+export const ServerEndpoint = CoreServerEndpoint;
+export const ClientEndpoint = CoreClientEndpoint;