@phreshos/server 0.1.0 → 0.1.2

package/dist/domain.js

@@ -1,142 +1,176 @@
-import { Client as CoreClient, Endpoint as CoreEndpoint, Process as CoreProcess, Program as CoreProgram, Server as CoreServer, Window as CoreWindow } from "@phreshos/core";
+import { Client as CoreClient, Endpoint as CoreEndpoint, Process as CoreProcess, Program as CoreProgram, Server as CoreServer } from "@phreshos/core";
 import { randomUUID } from "node:crypto";
 import Events from "./events.js";
 import Deadline from "./deadline.js";
+import HandleRegistry from "./handle-registry.js";
 import { area, sql, store } from "./storage.js";
+import startup, {} from "./startup.js";
+import permissions from "./permissions.js";
 import wire from "./wire.js";
+const handles = new HandleRegistry();
 const ProgramBase = CoreProgram;
 const ProcessBase = CoreProcess;
 const ServerBase = CoreServer;
 const ClientBase = CoreClient;
-const WindowBase = CoreWindow;
 class ProgramHandle extends ProgramBase {
     identity;
-    name;
-    version;
-    description;
-    server;
-    client;
+    reference;
     data;
     cache;
     store;
     logs;
     database;
+    startup;
+    permissions;
+    record;
     constructor(record) {
         super();
         this.identity = record.identity;
-        this.name = record.name;
-        this.version = record.version;
-        this.description = record.description;
-        this.server = record.server;
-        this.client = record.client;
-        this.data = area(record.identity, "data");
-        this.cache = area(record.identity, "cache");
-        this.store = store(record.identity);
-        this.logs = sql("logs", record.identity);
-        this.database = sql("database", record.identity);
-        bindEvents(this, scoped("host-end", record.identity, programEvent));
+        this.reference = record.reference;
+        this.record = record;
+        this.data = area(this.address, "data");
+        this.cache = area(this.address, "cache");
+        this.store = store(this.address);
+        this.logs = sql("logs", this.address);
+        this.database = sql("database", this.address);
+        this.startup = startup(this.address);
+        this.permissions = permissions(this.address);
+        bindEvents(this, scoped("host-end", record.reference, programEvent));
+    }
+    get name() { return this.record.name; }
+    get version() { return this.record.version; }
+    get description() { return this.record.description; }
+    get server() { return this.record.server; }
+    get client() { return this.record.client; }
+    get address() { return { identity: this.identity, reference: this.reference }; }
+    update(record) {
+        if (record.reference !== this.reference)
+            throw new Error("A Program handle cannot become another Program");
+        this.record = record;
     }
     async processes() {
-        const answer = await wire.request(["processes", this.identity]);
-        return answer[0].map(process);
+        const answer = await wire.request(["processes", this.address]);
+        return answer[0].map(record => process(record));
+    }
+    async firstProcess() {
+        return chronological(await this.processes())[0] ?? null;
+    }
+    async lastProcess() {
+        return chronological(await this.processes()).at(-1) ?? null;
     }
     async getProcess(identityOrName) {
-        const answer = await wire.request(["program-process", this.identity, identityOrName]);
+        const answer = await wire.request(["program-process", this.address, identityOrName]);
         return answer[0] ? process(answer[0]) : null;
     }
     async createProcess(launch = {}) {
-        const answer = await wire.request(["create-process", this.identity, launch]);
+        const answer = await wire.request(["create-process", this.address, launch]);
         return process(answer[0]);
     }
     async apiDocs() {
-        const answer = await wire.request(["api-docs", this.identity]);
+        const answer = await wire.request(["api-docs", this.address]);
         return answer[0];
     }
+    async icon(size = "medium") {
+        const answer = await wire.request(["icon", this.address, size]);
+        return new Blob([Uint8Array.from(answer[0])], { type: "image/png" });
+    }
     async installed() {
-        const answer = await wire.request(["installed", this.identity]);
+        const answer = await wire.request(["installed", this.address]);
         return answer[0];
     }
     async install() {
-        await wire.request(["install", this.identity]);
+        await wire.request(["install", this.address]);
         return this;
     }
     async fork(identity) {
-        const answer = await wire.request(["fork", this.identity, identity]);
+        const answer = await wire.request(["fork", this.address, identity]);
         return program(answer[0]);
     }
     async uninstall(everything = false) {
-        await wire.request(["uninstall", this.identity, everything]);
+        await wire.request(["uninstall", this.address, everything]);
     }
     async forget() {
-        await wire.request(["forget", this.identity]);
+        await wire.request(["forget", this.address]);
     }
     async exitAll() {
-        const answer = await wire.request(["exit-all", this.identity]);
+        const answer = await wire.request(["exit-all", this.address]);
         return answer[0];
     }
 }
+/** Internal transport address for a Program handle created by this SDK. */
+export function programAddress(value) {
+    if (!(value instanceof ProgramHandle))
+        throw new Error("A Program handle is required");
+    return value.address;
+}
+function chronological(processes) {
+    return processes.sort((left, right) => left.startedAt.getTime() - right.startedAt.getTime());
+}
 class ProcessHandle extends ProcessBase {
     identity;
+    reference;
     name;
     startedAt;
     server;
     client;
     ownerProgram;
     options;
-    constructor(record) {
+    constructor(record, endpoints = {}) {
         super();
         this.identity = record.identity;
+        this.reference = record.reference;
         this.name = record.name;
         this.startedAt = new Date(record.startedAt);
         this.ownerProgram = program(record.program);
         this.options = record.options;
-        this.server = new ServerHandle(this);
-        this.client = new ClientHandle(this);
-        bindEvents(this, scoped("process-host", record.identity, processEvent));
+        this.server = endpointHandle(this, "server", endpoints.server);
+        this.client = endpointHandle(this, "client", endpoints.client);
+        bindEvents(this, scoped("process-host", record.reference, processEvent));
     }
     program() { return this.ownerProgram; }
+    get address() { return { identity: this.identity, reference: this.reference }; }
     async parent() {
-        const answer = await wire.request(["parent", this.identity]);
+        const answer = await wire.request(["parent", this.address]);
         return answer[0] ? process(answer[0]) : null;
     }
     async option(name) {
         if (name in this.options)
             return this.options[name];
-        const answer = await wire.request(["option", this.identity, name]);
+        const answer = await wire.request(["option", this.address, name]);
         return answer[0];
     }
     async exit() {
-        await wire.request(["exit", this.identity]);
+        await wire.request(["exit", this.address]);
     }
     async exited() {
-        const answer = await wire.request(["exited", this.identity]);
+        const answer = await wire.request(["exited", this.address]);
         return answer[0];
     }
 }
-class TrafficHandle extends Events {
-    owner;
+export class TrafficHandle extends Events {
+    target;
     kind;
-    constructor(owner, kind) {
-        super((event, listener, impossible) => wire.observe(owner.identity, kind, "publish", event, value => {
+    constructor(target, kind) {
+        super((event, listener, impossible) => wire.observe(target, kind, "publish", event, value => {
             listener(trafficMessage(value));
-        }, impossible), observer => wire.observe(owner.identity, kind, "publish", null, (event, value) => {
+        }, impossible), observer => wire.observe(target, kind, "publish", null, (event, value) => {
             if (typeof event === "string")
                 observer(event, trafficMessage(value));
         }));
-        this.owner = owner;
+        this.target = target;
         this.kind = kind;
     }
     observeAsks(observer) {
-        return wire.observe(this.owner.identity, this.kind, "ask", null, (event, questionId, message) => {
+        return wire.observe(this.target, this.kind, "ask", null, (event, questionId, message) => {
             if (typeof event !== "string" || typeof questionId !== "string")
                 return;
             observer({ event, questionId, message: trafficMessage(message) });
         });
     }
 }
-class ServerTrafficHandle extends TrafficHandle {
+export class ServerTrafficHandle extends TrafficHandle {
     observeAnswers(observer) {
-        return wire.observe(this.owner.identity, "server", "answer", null, (event, questionId, message) => {
+        return wire.observe(this.target, "server", "answer", null, (event, questionId, message) => {
             if (typeof event !== "string" || typeof questionId !== "string")
                 return;
             const raw = message;
@@ -154,35 +188,36 @@ class ServerHandle extends ServerBase {
     constructor(owner) {
         super();
         this.owner = owner;
-        this.traffic = new ServerTrafficHandle(owner, "server");
+        this.traffic = new ServerTrafficHandle(owner.address, "server");
+        bindEvents(this, endpointEvents(owner.address, "server"));
     }
-    process() { return this.owner; }
-    publish(event, payload) {
-        wire.send("end-host", "send", this.owner.identity, "server", event, payload);
+    async process() { return this.owner; }
+    publish(event, payload = undefined) {
+        wire.send("end-host", "send", this.owner.address, "server", event, payload);
     }
     async exists() {
-        const answer = await wire.request(["exists", "server", this.owner.identity]);
+        const answer = await wire.request(["exists", "server", this.owner.address]);
         return answer[0];
     }
-    async start() { await wire.request(["start-endpoint", this.owner.identity, "server"]); }
-    async stop() { await wire.request(["stop-endpoint", this.owner.identity, "server"]); }
+    async start() { await wire.request(["start-endpoint", this.owner.address, "server"]); }
+    async stop() { await wire.request(["stop-endpoint", this.owner.address, "server"]); }
     async waitReady(timeout) {
-        await wire.request(["wait-ready", this.owner.identity], timeout);
+        await wire.request(["wait-ready", this.owner.address], timeout);
     }
-    async ask(event, payload) {
+    async ask(event, payload = undefined) {
         return this.askWithin(undefined, event, payload);
     }
     timeout(milliseconds) {
-        return { ask: (event, payload) => this.askWithin(milliseconds, event, payload) };
+        return { ask: (event, payload = undefined) => this.askWithin(milliseconds, event, payload) };
     }
     async askWithin(timeout, event, payload) {
         const deadline = new Deadline(timeout);
-        await wire.requestWithin(["wait-ready", this.owner.identity, true], deadline);
-        const identity = await wire.identity;
+        await wire.requestWithin(["wait-ready", this.owner.address, true], deadline);
+        const identity = await wire.identity();
         const address = `server:${identity.process}:${randomUUID()}`;
         const questionId = randomUUID();
         const waiting = wire.expectWithin(address, deadline);
-        wire.send("end-host", "ask", this.owner.identity, "server", address, questionId, event, payload);
+        wire.send("end-host", "ask", this.owner.address, "server", address, questionId, event, payload);
         try {
             return await waiting;
         }
@@ -194,36 +229,35 @@ class ServerHandle extends ServerBase {
 class ClientHandle extends ClientBase {
     owner;
     traffic;
+    window;
     constructor(owner) {
         super();
         this.owner = owner;
-        this.traffic = new TrafficHandle(owner, "client");
+        this.traffic = new TrafficHandle(owner.address, "client");
+        this.window = window(async () => owner.address);
+        bindEvents(this, endpointEvents(owner.address, "client"));
     }
-    process() { return this.owner; }
-    publish(event, payload) { wire.send("end-host", "send", this.owner.identity, "client", event, payload); }
+    async process() { return this.owner; }
+    publish(event, payload = undefined) { wire.send("end-host", "send", this.owner.address, "client", event, payload); }
     async exists() {
-        const answer = await wire.request(["exists", "client", this.owner.identity]);
+        const answer = await wire.request(["exists", "client", this.owner.address]);
         return answer[0];
     }
     async start(overrides = {}) {
-        await wire.request(["start-endpoint", this.owner.identity, "client", overrides]);
-    }
-    async stop() { await wire.request(["stop-endpoint", this.owner.identity, "client"]); }
-    async window() {
-        await wire.request(["window", this.owner.identity]);
-        return new WindowHandle(this);
+        await wire.request(["start-endpoint", this.owner.address, "client", overrides]);
     }
+    async stop() { await wire.request(["stop-endpoint", this.owner.address, "client"]); }
 }
-class WindowHandle extends WindowBase {
-    owner;
-    constructor(owner) {
-        super();
-        this.owner = owner;
-        bindEvents(this, scoped("host-end", owner.process().identity, (_event, values) => values[0]));
+class WindowHandle extends Events {
+    target;
+    surface;
+    constructor(target) {
+        super(...deferredScoped("host-end", target, (_event, values) => values[0]));
+        this.target = target;
+        this.surface = new WindowSurfaceHandle(target);
     }
-    client() { return this.owner; }
     async state() {
-        const answer = await wire.request(["window", this.owner.process().identity]);
+        const answer = await wire.request(["window", await this.target()]);
         return answer[0];
     }
     async title() { return (await this.state()).title; }
@@ -233,11 +267,62 @@ class WindowHandle extends WindowBase {
     async front() { return (await this.state()).front; }
     async layer() { return (await this.state()).layer; }
     async location() { return (await this.state()).location; }
-    async move(position) { await wire.request(["move", this.owner.process().identity, position]); }
-    async resize(size) { await wire.request(["resize", this.owner.process().identity, size]); }
-    async minimize(minimized = true) { await wire.request(["minimize", this.owner.process().identity, minimized]); }
-    async changeTitle(title) { await wire.request(["changeTitle", this.owner.process().identity, title]); }
-    async raise() { await wire.request(["raise", this.owner.process().identity]); }
+    async move(position) { await wire.request(["move", await this.target(), position]); }
+    async resize(size) { await wire.request(["resize", await this.target(), size]); }
+    async minimize(minimized = true) { await wire.request(["minimize", await this.target(), minimized]); }
+    async changeTitle(title) { await wire.request(["changeTitle", await this.target(), title]); }
+    async raise() { await wire.request(["raise", await this.target()]); }
+}
+class WindowSurfaceHandle {
+    target;
+    constructor(target) {
+        this.target = target;
+    }
+    async set(settings = {}) { await wire.request(["surfaceSet", await this.target(), settings]); }
+    async remove() { await wire.request(["surfaceRemove", await this.target()]); }
+}
+function deferredScoped(route, target, convert) {
+    return [
+        (event, listener, impossible) => {
+            if (!windowEvent(event)) {
+                impossible?.(new Error(`A Window has no "${event}" event`));
+                return () => undefined;
+            }
+            return deferred(target, subject => wire.on(route, event, (...values) => {
+                const message = unscoped(subject, values);
+                if (message)
+                    listener(convert(event, message));
+            }, subject, impossible), impossible);
+        },
+        observer => deferred(target, subject => wire.onAll(route, (event, ...values) => {
+            if (typeof event !== "string" || !windowEvent(event))
+                return;
+            const message = unscoped(subject, values);
+            if (message)
+                observer(event, convert(event, message));
+        }, subject))
+    ];
+}
+function windowEvent(event) {
+    return event === "move" || event === "resize" || event === "minimize" || event === "changeTitle" || event === "front";
+}
+function deferred(target, register, impossible) {
+    let active = true;
+    let stop = () => undefined;
+    void target().then(address => {
+        if (active)
+            stop = register(address.reference);
+    }, error => {
+        const failure = error instanceof Error ? error : new Error(String(error));
+        if (active && impossible)
+            impossible(failure);
+        else if (active)
+            queueMicrotask(() => { throw failure; });
+    });
+    return () => {
+        active = false;
+        stop();
+    };
 }
 export function scoped(route, subject, convert) {
     return new Events((event, listener, impossible) => wire.on(route, event, (...values) => {
@@ -252,16 +337,23 @@ export function scoped(route, subject, convert) {
             observer(event, convert(event, message));
     }, subject));
 }
+/** Destinationless events originating from one Endpoint handle. */
+export function endpointEvents(target, half) {
+    return new Events((event, listener, impossible) => wire.follow(target, half, event, listener, impossible), observer => wire.follow(target, half, null, (event, payload) => {
+        if (typeof event === "string")
+            observer(event, payload);
+    }));
+}
 function unscoped(subject, values) {
     if (subject === null)
         return values;
     return values[0] === subject ? values.slice(1) : null;
 }
 function programEvent(event, values) {
-    if (event === "serverStart" || event === "clientStart" || event === "clientStop" || event === "processCreate")
+    if (event === "endpointStart" || event === "endpointStop")
+        return lifecycleEndpoint(values[0], values[1]);
+    if (event === "processCreate")
         return process(values[0]);
-    if (event === "serverStop")
-        return { process: process(values[0]), code: numberOrNull(values[1]), signal: stringOrNull(values[2]) };
     if (event === "processExit")
         return { process: process(values[0]), ...exit(values[1], values[2]) };
     if (event === "uninstall")
@@ -269,12 +361,20 @@ function programEvent(event, values) {
     return undefined;
 }
 function processEvent(event, values) {
-    if (event === "serverStop")
-        return { code: numberOrNull(values[0]), signal: stringOrNull(values[1]) };
+    if (event === "endpointStart" || event === "endpointStop")
+        return lifecycleEndpoint(values[0], values[1]);
     if (event === "exit")
         return exit(values[0], values[1]);
     return undefined;
 }
+export function lifecycleEndpoint(record, kind) {
+    const owner = process(record);
+    if (kind === "server")
+        return owner.server;
+    if (kind === "client")
+        return owner.client;
+    throw new Error("The host returned an invalid Endpoint lifecycle event");
+}
 export function exit(code, signal) {
     const namedSignal = stringOrNull(signal);
     return { status: namedSignal === null ? "exited" : "signaled", code: numberOrNull(code), signal: namedSignal };
@@ -294,20 +394,35 @@ export function bindEvents(target, events) {
     });
 }
 export function program(record) {
-    return new ProgramHandle(record);
+    const handle = handles.obtain(`program:${record.reference}`, () => new ProgramHandle(record));
+    handle.update(record);
+    return handle;
 }
-export function process(record) {
-    return new ProcessHandle(record);
+export function process(record, endpoints = {}) {
+    return handles.obtain(`process:${record.reference}`, () => new ProcessHandle(record, endpoints));
 }
 export function endpoint(reference) {
     if (!reference)
         throw new Error("The boundary returned an invalid Endpoint reference");
-    const owner = new ProcessHandle(reference.process);
+    const owner = process(reference.process);
     return reference.kind === "server" ? owner.server : owner.client;
 }
+export function claimEndpoint(reference, kind, endpoint) {
+    return handles.adopt(`endpoint:${reference}:${kind}`, endpoint);
+}
+function endpointHandle(owner, kind, preferred) {
+    return handles.obtain(`endpoint:${owner.reference}:${kind}`, () => preferred ?? (kind === "server" ? new ServerHandle(owner) : new ClientHandle(owner)));
+}
+export function window(target) {
+    return new WindowHandle(target);
+}
+/** Runtime constructor used to identify and type Server-visible Program handles. */
 export const Program = CoreProgram;
+/** Runtime constructor used to identify and type Server-visible Process handles. */
 export const Process = CoreProcess;
+/** Runtime constructor used to identify and type Server-visible Endpoint handles. */
 export const Endpoint = CoreEndpoint;
+/** Runtime constructor used to identify and type Server-visible Server handles. */
 export const Server = CoreServer;
+/** Runtime constructor used to identify and type Server-visible Client handles. */
 export const Client = CoreClient;
-export const Window = CoreWindow;

package/dist/handle-registry.d.ts

@@ -0,0 +1,7 @@
+/** Weak canonical references for system-backed domain handles in this SDK realm. */
+export default class HandleRegistry {
+    private readonly handles;
+    private readonly released;
+    obtain<Value extends object>(key: string, create: () => Value): Value;
+    adopt<Value extends object>(key: string, value: Value): Value;
+}

package/dist/handle-registry.js

@@ -0,0 +1,24 @@
+/** Weak canonical references for system-backed domain handles in this SDK realm. */
+export default class HandleRegistry {
+    handles = new Map();
+    released = new FinalizationRegistry(({ key, reference }) => {
+        if (this.handles.get(key) === reference)
+            this.handles.delete(key);
+    });
+    obtain(key, create) {
+        const existing = this.handles.get(key)?.deref();
+        if (existing)
+            return existing;
+        const value = create();
+        const reference = new WeakRef(value);
+        this.handles.set(key, reference);
+        this.released.register(value, { key, reference });
+        return value;
+    }
+    adopt(key, value) {
+        const existing = this.handles.get(key)?.deref();
+        if (existing && existing !== value)
+            throw new Error(`The canonical handle for "${key}" already exists`);
+        return existing ?? this.obtain(key, () => value);
+    }
+}

package/dist/host.d.ts

@@ -1,65 +1,113 @@
-import type { Exit, Layer, Position, ServedFile, Size, Subscribable } from "@phreshos/core";
-import { type Process, type Program } from "./domain.js";
+import type { DesktopWallpaper, Exit, FileWallpaper, Layer, Position, ServedFile, Size, Subscribable, ThemeProperties, WritableTheme } from "@phreshos/core";
+import { type Client, type Process, type Program, type Server } from "./domain.js";
+/** Resolved production description for a Program's Server. */
 export type ServerDescription = Readonly<{
+    /** Absolute directory containing the production Server files. */
     location: string;
+    /** Whether newly created Processes start this Server by default. */
     start?: boolean;
+    /** Command used to install the Server's production dependencies. */
     installCommand?: string;
+    /** Command used to start the Server from its production directory. */
     startCommand: string;
 }>;
+/** Resolved production description for a Program's Client and initial Window. */
 export type ClientDescription = Readonly<{
+    /** Absolute directory containing the production Client files. */
     location: string;
+    /** Whether newly created Processes start this Client by default. */
     start?: boolean;
+    /** Default Window title. */
     title?: string;
+    /** Default Window size. */
     size?: Size;
+    /** Default Window position. */
     position?: Position;
+    /** Default Window layer. */
     layer?: Layer;
+    /** Whether the Window starts minimized. */
     minimize?: boolean;
 }>;
 type Description = Readonly<{
+    /** Stable identity assigned to the Program. */
     identity: string;
+    /** Human-readable Program name. */
     name?: string;
+    /** Declared Program version. */
     version?: string;
+    /** Short human-readable Program description. */
     description?: string;
+    /** Path to the Program-authored API entry document. */
     apiDocs?: string;
-    icons?: string;
+    /** Absolute validated PNG source used to derive the Program's hosted icon sizes. */
+    icon?: string;
+    /** Absolute directory used for the Program's persistent storage. */
     storage: string;
 }>;
+/** Complete runtime description used to create a Program. */
 export type ProgramDescription = Description & (Readonly<{
+    /** Required Server description when no Client is described. */
     server: ServerDescription;
+    /** Optional Client description. */
     client?: ClientDescription;
 }> | Readonly<{
+    /** Optional Server description. */
     server?: ServerDescription;
+    /** Required Client description when no Server is described. */
     client: ClientDescription;
 }>);
-export type HostServerStop = Omit<Exit, "status"> & Readonly<{
-    process: Process;
-}>;
+/** An uninstall reported with the affected Program and removal scope. */
 export type HostProgramUninstall = Readonly<{
+    /** Program that left the installed state. */
     program: Program;
+    /** Whether all installed resources, including storage, were removed. */
     everythingRemoved: boolean;
 }>;
+/** A Process exit reported with the Process that ended. */
 export type HostProcessExit = Exit & Readonly<{
+    /** Process that ended. */
     process: Process;
 }>;
+/** Authoritative lifecycle events visible to the Server host. */
 export type HostEvents = {
-    serverStart: Process;
-    serverStop: HostServerStop;
-    clientStart: Process;
-    clientStop: Process;
+    /** One Process Endpoint entered a new live incarnation. */
+    endpointStart: Server | Client;
+    /** One Process Endpoint incarnation ended. */
+    endpointStop: Server | Client;
+    /** A Program entered the runtime registry. */
     programCreate: Program;
+    /** A Program left the runtime registry. */
     programForget: Program;
+    /** A Program entered the installed state. */
     programInstall: Program;
+    /** A Program left the installed state. */
     programUninstall: HostProgramUninstall;
+    /** A Process entered the runtime set. */
     processCreate: Process;
+    /** A Process left the runtime set. */
     processExit: HostProcessExit;
 };
+/** Authoritative system capabilities available to a Server endpoint. */
 export interface Host<Events extends object = {}> extends Subscribable<HostEvents & Events, never> {
+    /** Observable system Theme authority. */
+    readonly theme: WritableTheme<ThemeProperties>;
+    /** Authoritative wallpaper visible before authentication. */
+    readonly signInWallpaper: FileWallpaper;
+    /** Authoritative wallpaper visible within authenticated desktops. */
+    readonly desktopWallpaper: DesktopWallpaper;
+    /** Publishes a value through the host and returns its public file metadata. */
     serve(value: unknown): Promise<ServedFile>;
+    /** Returns all known Programs, optionally restricted to installed Programs. */
     programs(onlyInstalled?: boolean): Promise<Program[]>;
+    /** Returns the Program with the given stable identity. */
     getProgram(identity: string): Promise<Program>;
+    /** Creates a runtime Program from a description or description file path. */
     createProgram(source: ProgramDescription | string): Promise<Program>;
+    /** Returns every live Process known to the authoritative host. */
     processes(): Promise<Process[]>;
+    /** Returns the live Process with the given runtime identity. */
     getProcess(identity: string): Promise<Process>;
 }
+/** Authoritative system capabilities for the currently executing Server. */
 export declare const host: Host;
 export {};