@phreshos/client 0.1.0 → 0.1.1

package/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2026 Zohayr SLILEH
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -17,9 +17,31 @@ It uses the domain objects and shared contracts from `@phreshos/core` through
 a peer dependency. It does not redefine those objects, own server-side
 capabilities, or contain host and transport implementations.
 
-Its `Host` contract exposes only desktop-session capabilities: surface and
-pointer state, publicly served values, and unrestricted server-side Fetch. It
-does not expose system-wide Program or Process discovery.
+Its `Host` contract exposes only desktop-session capabilities: the public
+system Theme, surface and pointer state, publicly served values, and
+unrestricted server-side Fetch. `host.theme.snapshot()` explicitly and
+asynchronously reads the current snapshot retained by the desktop host.
+`host.theme.subscribe("change", listener)` is an ordinary live subscription:
+it receives only complete replacements published after registration, with no
+initial value or replay. The Client cannot write the authoritative value. The
+Host does not expose system-wide Program or Process discovery.
+
+Surface and pointer access are independent objects rather than events merged
+into Host:
+
+```ts
+const surface = await host.surface.size()
+const stopSurface = host.surface.subscribe("resize", next => undefined)
+
+const position = await host.pointer.position()
+const stopPointer = host.pointer.subscribe("move", next => undefined)
+```
+
+A Surface contains only the width and height of the current Client Window's
+own layer. Client code cannot select another layer, and the desktop's gutter
+never enters an endpoint. Pointer position and movement both require the
+`pointer` permission. Reads are asynchronous requests; subscriptions receive
+only future publications and never replay a retained value.
 
 A Client may traverse `Process.parent()` through any number of ancestors in
 its own Program. The first parent outside that Program is structurally hidden
@@ -31,28 +53,53 @@ Its JavaScript entry point adapts the iframe boundary to these contracts. The
 SDK owns callbacks, waits, queues, and their cleanup; the boundary owns only
 the forwarding registrations requested by the SDK.
 
+Importing the SDK and establishing the iframe's host lease inject no message
+into the endpoint. Identity, Theme, Process, Window, readiness, lifecycle, and
+application values enter only in response to an explicit request or a live
+registration made by Program code.
+
 `Current` combines navigation into the executing Client's Process with its
-inbound subscription Channel. The paired Server is explicitly named as
+Channel. The paired Server is explicitly named as
 `current.server`; its publishing, asking, existence, readiness, start, and stop
 operations never masquerade as properties of `current`. `current.stop()` stops
 the executing Client, while complete Process exit remains available only
-through `current.process()`.
+through `current.process()`. It is the canonical Process-owned handle, so
+`current.server === (await current.process()).server`.
+Endpoint `process()` navigation is asynchronous; contextual ownership is
+requested only when navigation needs it and then retained by the SDK.
+
+All domain handles are canonical within this iframe's JavaScript realm. Lookup,
+navigation, event payloads, and message metadata reuse the same weakly retained
+handle. A Client and its synchronous `window` capability remain stable for the
+Process lifetime; Window operations always address that Client's current live
+presentation state.
 
 `server.ask()` does not route a question before the current Server incarnation
 is ready. The Client SDK owns one deadline across readiness and the answer;
 absence or incarnation loss rejects without turning the boundary into a waiter.
 
-The package provides two contextual values rather than constructors:
+The package provides two contextual runtime entry points:
 
 ```ts
 import { host, current } from "@phreshos/client"
 ```
 
-The current Client's inbound Channel is composed directly into `current`. It
-exposes `subscribe()`, `waitFor()`, `events()`, and `observe()` for events
-addressed to this Client. It has no outbound, existence, readiness, or
-lifecycle operations; those belong to `current.server`, `current.stop()`, or an
-explicit Endpoint handle.
+It also re-exports the shared Core runtime classes—`Program`, `Process`,
+`Endpoint`, `Server`, and `Client`—and refines the handles returned through
+them. These are the same domain classes used by the Server SDK, so
+`instanceof Server` and `instanceof Client` retain one meaning. `Window`, like
+`ClientTraffic`, is a type-only capability owned by Client and has no
+independent `instanceof` identity.
+
+The current Client's Channel is composed directly into `current`. Its
+subscription tools receive events addressed to this Client, while `publish()`
+emits outward from this Client without choosing a destination. Existence,
+readiness, and lifecycle operations belong to `current.server`,
+`current.stop()`, or an explicit Endpoint handle.
+
+An Endpoint handle is also a selective source: `endpoint.subscribe()` follows
+destinationless events emitted by that Endpoint. Its `traffic` property remains
+reserved for directed publications, questions, and answers.
 
 Messages sent by an Endpoint in the same Program contain that real Endpoint in
 `from`. If the sender belongs to another Program, `from` is `null`; the foreign
@@ -61,5 +108,46 @@ The same rule applies to Client-visible traffic destinations.
 
 Client-visible Program handles can operate only within their own Program.
 They deliberately omit `install()` and `fork()`, and their storage areas never
-expose host filesystem paths. Client Window handles add synchronous
-`localMove()` and `localResize()` for representation-local gestures.
+expose host filesystem paths. Client Window capabilities add awaitable
+`localMove()` and `localResize()` for representation-local gestures. Their
+Promises confirm that the current Client host accepted and applied the local
+draft; they do not enter server authority or emit Window events.
+
+An `under` or `over` Client may own one authoritative host-rendered Surface.
+The capability remains silent until Program code explicitly reads, changes, or
+subscribes to it:
+
+```ts
+const initial = await window.surface.snapshot()
+
+const stop = window.surface.subscribe("change", surface => {
+  // Future replacements only; subscriptions do not replay `initial`.
+})
+
+await window.surface.set({
+  opacity: 0.65,
+  radius: "large",
+  transaction: { duration: 240, easing: "ease-out" }
+})
+
+await window.surface.remove()
+```
+
+The server stores the target beside its Window and broadcasts complete future
+replacements. `set()` with no settings creates a sharp, fully opaque Surface.
+Opacity is a finite number from `0` through `1`; zero retains the Surface node.
+Radius accepts a nonnegative pixel number, a Theme-derived `ScaleLevel`, or
+`"full"`. Only `remove()` restores exact `null` and immediately removes the
+node. The optional transaction uses milliseconds and a stable named or cubic
+Bézier easing; the desktop performs the motion, honors reduced motion, and does
+not replay a stored transaction when restoring an initial snapshot. The sharp
+container follows the iframe geometry while the independently rounded Surface
+neither clips nor masks Client content. `window` and `wallpaper` layers reject
+the capability.
+
+`program.icon()` requests the current Program's guaranteed PNG `Blob` on
+demand. The desktop derives the Program from the calling frame; no identity,
+private asset address, or filesystem path crosses from Client code.
+
+Persistent startup is deliberately absent. Only a Server endpoint may change
+whether an installed Program creates a Process when the system starts.

package/dist/channel.d.ts

@@ -1,8 +1,12 @@
 import type { Channel as CoreChannel, ChannelCapture as CoreChannelCapture, ChannelEvents as CoreChannelEvents, ChannelMessage as CoreChannelMessage } from "@phreshos/core";
 import { type Endpoint } from "./domain.js";
+/** One value addressed to the current Client, with a client-visible sender. */
 export type ChannelMessage<Payload = unknown> = CoreChannelMessage<Payload, Endpoint | null>;
+/** Applies the client-visible sender envelope to known Channel events. */
 export type ChannelEvents<Events extends object> = CoreChannelEvents<Events, Endpoint | null>;
+/** Every event observable through the current Client's Channel. */
 export type ChannelCapture<Events extends object = {}> = CoreChannelCapture<Events, Endpoint | null>;
+/** Events explicitly accepted by the current Client. */
 export interface Channel<Events extends object = {}> extends CoreChannel<Events, Endpoint | null> {
 }
 export declare const channel: Channel;

package/dist/channel.js

@@ -8,6 +8,9 @@ class ClientChannel extends Events {
                 observer(event, message(value));
         }));
     }
+    publish(event, payload = undefined) {
+        wire.send("end-host", "emit", event, payload);
+    }
 }
 function message(value) {
     const raw = value;

package/dist/current.d.ts

@@ -1,20 +1,23 @@
-import type { Askable, Channel as CoreChannel, Publishable } from "@phreshos/core";
-import { type Process, type Program, type Endpoint, type Window } from "./domain.js";
-/** The paired Server as addressed from the currently executing Client. */
-export interface CurrentServer extends Publishable, Askable {
-    exists(): Promise<boolean>;
-    start(): Promise<void>;
-    stop(): Promise<void>;
-    waitReady(timeout?: number): Promise<void>;
-}
+import type { Channel as CoreChannel } from "@phreshos/core";
+import { Server, type Endpoint, type Process, type Program, type Window } from "./domain.js";
+/** The current Process's canonical Server handle. */
+export type CurrentServer<Events extends object = {}> = Server<Events>;
 /** Current Client context: its inbound Channel, owner hierarchy, and paired Server. */
 export interface Current<Events extends object = {}> extends CoreChannel<Events, Endpoint | null> {
+    /** The same Server handle exposed by the current Process. */
     readonly server: CurrentServer;
+    /** Presentation capability of this current Client. */
+    readonly window: Window;
+    /** Returns the Process represented by this Client. */
     process(): Promise<Process>;
+    /** Returns the accessible parent Process, or `null` when none exists. */
     parent(): Promise<Process | null>;
+    /** Returns the Program that owns this Client. */
     program(): Promise<Program>;
-    window(): Promise<Window>;
+    /** Returns one immutable option supplied when this Process was created. */
     option(name: string): Promise<string | undefined>;
+    /** Stops the current Client; rejects when it is the final live Endpoint. */
     stop(): Promise<void>;
 }
+/** Inbound events, owner hierarchy, and paired Server for the current Client. */
 export declare const current: Current;

package/dist/current.js

@@ -1,15 +1,19 @@
 import { channel } from "./channel.js";
 import Deadline from "./deadline.js";
-import { process, program } from "./domain.js";
+import { Client, Server, ServerTrafficHandle, TrafficHandle, bindEvents, endpointEvents, process, program, window as windowHandle } from "./domain.js";
 import wire from "./wire.js";
-class PairedServer {
-    publish(event, payload) { wire.send("end-end", event, payload); }
-    async ask(event, payload) {
-        return this.askWithin(undefined, event, payload);
-    }
-    timeout(milliseconds) {
-        return { ask: (event, payload) => this.askWithin(milliseconds, event, payload) };
+const ServerBase = Server;
+const ClientBase = Client;
+class CurrentServerHandle extends ServerBase {
+    owner;
+    traffic = new ServerTrafficHandle(null, "server");
+    constructor(owner) {
+        super();
+        this.owner = owner;
+        bindEvents(this, endpointEvents(null, "server"));
     }
+    process() { return this.owner(); }
+    publish(event, payload = undefined) { wire.send("end-end", event, payload); }
     async exists() {
         const answer = await wire.request(["exists", "server"]);
         return answer[0];
@@ -17,21 +21,69 @@ class PairedServer {
     async start() { await wire.request(["start-endpoint", undefined, "server"]); }
     async stop() { await wire.request(["stop-endpoint", undefined, "server"]); }
     async waitReady(timeout) { await wire.request(["wait-ready"], timeout); }
+    async ask(event, payload = undefined) {
+        return this.askWithin(undefined, event, payload);
+    }
+    timeout(milliseconds) {
+        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", null, true], deadline);
         return await wire.askServerWithin(event, payload, deadline);
     }
 }
+let ownerPromise = null;
+let currentServer;
+let currentClient;
+function owner() {
+    if (!ownerPromise) {
+        const resolving = wire.request(["process"]).then(answer => {
+            return process(answer[0], { server: currentServer, client: currentClient });
+        });
+        const retained = resolving.catch(error => {
+            if (ownerPromise === retained)
+                ownerPromise = null;
+            throw error;
+        });
+        ownerPromise = retained;
+    }
+    return ownerPromise;
+}
+currentServer = new CurrentServerHandle(owner);
+class CurrentClientHandle extends ClientBase {
+    owner;
+    traffic = new TrafficHandle(null, "client");
+    window = windowHandle(async () => {
+        const identity = await wire.identity();
+        return { identity: identity.process, reference: identity.reference };
+    });
+    constructor(owner) {
+        super();
+        this.owner = owner;
+        bindEvents(this, endpointEvents(null, "client"));
+    }
+    process() { return this.owner(); }
+    publish(event, payload = undefined) {
+        void wire.identity().then(identity => {
+            wire.send("end-host", "send", { identity: identity.process, reference: identity.reference }, "client", event, payload);
+        });
+    }
+    async exists() {
+        const answer = await wire.request(["exists", "client"]);
+        return answer[0];
+    }
+    async start(overrides = {}) { await wire.request(["start-endpoint", undefined, "client", overrides]); }
+    async stop() { await wire.request(["stop-endpoint", undefined, "client"]); }
+}
+currentClient = new CurrentClientHandle(owner);
 class ClientCurrent {
-    server = new PairedServer();
+    server = currentServer;
+    window = currentClient.window;
     constructor() {
         bindChannel(this, channel);
     }
-    async process() {
-        const answer = await wire.request(["process"]);
-        return process(answer[0]);
-    }
+    process() { return owner(); }
     async parent() {
         const answer = await wire.request(["parent"]);
         return answer[0] ? process(answer[0]) : null;
@@ -40,7 +92,6 @@ class ClientCurrent {
         const answer = await wire.request(["program"]);
         return program(answer[0]);
     }
-    async window() { return (await this.process()).client.window(); }
     async option(name) {
         const answer = await wire.request(["option", undefined, name]);
         return answer[0];
@@ -49,10 +100,12 @@ class ClientCurrent {
 }
 function bindChannel(target, source) {
     Object.assign(target, {
+        publish: source.publish.bind(source),
         subscribe: source.subscribe.bind(source),
         waitFor: source.waitFor.bind(source),
         events: source.events.bind(source),
         observe: source.observe.bind(source)
     });
 }
+/** Inbound events, owner hierarchy, and paired Server for the current Client. */
 export const current = new ClientCurrent();

package/dist/domain.d.ts

@@ -1,16 +1,21 @@
-import { Client as CoreClient, Endpoint as CoreEndpoint, Process as CoreProcess, Program as CoreProgram, Server as CoreServer, Window as CoreWindow, type AnswerCapture as CoreAnswerCapture, type AnswerMessage as CoreAnswerMessage, type AnswerObserver as CoreAnswerObserver, type AskCapture as CoreAskCapture, type AskMessage as CoreAskMessage, type AskObserver as CoreAskObserver, type ClientTraffic as CoreClientTraffic, type ClientDeclaration, type EndpointTraffic as CoreEndpointTraffic, type EndpointDeclaration, type Exit, type Launch, type Position, type ServerTraffic as CoreServerTraffic, type Size, type TrafficMessage as CoreTrafficMessage, type TrafficCapture as CoreTrafficCapture, type TrafficEvents as CoreTrafficEvents } from "@phreshos/core";
+import { Client as CoreClient, Endpoint as CoreEndpoint, Process as CoreProcess, Program as CoreProgram, Server as CoreServer, type AnswerCapture as CoreAnswerCapture, type AnswerMessage as CoreAnswerMessage, type AnswerObserver as CoreAnswerObserver, type AskCapture as CoreAskCapture, type AskMessage as CoreAskMessage, type AskObserver as CoreAskObserver, type Cleanup, type ClientTraffic as CoreClientTraffic, type ClientDeclaration, type EndpointTraffic as CoreEndpointTraffic, type EndpointDeclaration, type Exit, type Launch, type Position, type ServerTraffic as CoreServerTraffic, type Size, type TrafficMessage as CoreTrafficMessage, type TrafficCapture as CoreTrafficCapture, type TrafficEvents as CoreTrafficEvents, type Window as CoreWindow, type WindowState } from "@phreshos/core";
 import Events from "./events.js";
+export interface HandleAddress {
+    identity: string;
+    reference: string;
+}
 export interface ProgramRecord {
+    reference: string;
     identity: string;
     installed?: boolean;
     name: string;
     version: string | null;
     description: string | null;
-    icons?: boolean;
     server: EndpointDeclaration | null;
     client: ClientDeclaration | null;
 }
 export interface ProcessRecord {
+    reference: string;
     identity: string;
     name: string | null;
     program: ProgramRecord;
@@ -23,71 +28,119 @@ export interface EndpointReference {
     kind: "server" | "client";
     process: ProcessRecord;
 }
-export type Program<Events extends object = {}> = Omit<CoreProgram<Events>, "processes" | "getProcess" | "createProcess"> & {
+export type WindowRecord = WindowState;
+/** Program handle visible inside a structurally isolated Client. */
+export type Program<Events extends object = {}> = Omit<CoreProgram<Events>, "processes" | "firstProcess" | "lastProcess" | "getProcess" | "createProcess"> & {
+    /** Returns every live Process of this Program visible to the current Client. */
     processes(): Promise<Process[]>;
+    /** Returns the earliest-started visible live Process, or `null` when none exist. */
+    firstProcess(): Promise<Process | null>;
+    /** Returns the latest-started visible live Process, or `null` when none exist. */
+    lastProcess(): Promise<Process | null>;
+    /** Finds a visible live Process by runtime identity or Program-local name. */
     getProcess(identityOrName: string): Promise<Process | null>;
+    /** Creates one Process of this same Program. */
     createProcess(launch?: Launch): Promise<Process>;
 };
+/** Process handle visible inside a structurally isolated Client. */
 export type Process<Events extends object = {}> = Omit<CoreProcess<Events>, "server" | "client" | "program" | "parent"> & {
+    /** Permanent handle to this Process's Server. */
     readonly server: Server;
+    /** Permanent handle to this Process's Client. */
     readonly client: Client;
+    /** Returns the Program that owns this Process. */
     program(): Program;
+    /** Returns the visible parent Process, or `null` when no parent is accessible. */
     parent(): Promise<Process | null>;
 };
+/** Traffic value with identities hidden when they cross the Client boundary. */
 export type TrafficMessage<Payload = unknown> = CoreTrafficMessage<Payload, Endpoint | null>;
+/** Applies client-visible destination metadata to known traffic events. */
 export type TrafficEvents<Events extends object> = CoreTrafficEvents<Events, Endpoint | null>;
+/** Every ordinary event observable in client-visible Endpoint traffic. */
 export type TrafficCapture<Events extends object = {}> = CoreTrafficCapture<Events, Endpoint | null>;
+/** Question with a Server destination hidden when it crosses the Client boundary. */
 export type AskMessage<Payload = unknown> = CoreAskMessage<Payload, Server | null>;
+/** One question observable in client-visible Endpoint traffic. */
 export type AskCapture<Payload = unknown> = CoreAskCapture<Payload, Server | null>;
+/** Callback that observes questions sent by a client-visible Endpoint. */
 export type AskObserver<Payload = unknown> = CoreAskObserver<Payload, Server | null>;
+/** Answer with an Endpoint destination hidden when it crosses the Client boundary. */
 export type AnswerMessage<Result = unknown> = CoreAnswerMessage<Result, Endpoint | null>;
+/** One answer observable in client-visible Server traffic. */
 export type AnswerCapture<Result = unknown> = CoreAnswerCapture<Result, Endpoint | null>;
+/** Callback that observes answers sent by a client-visible Server. */
 export type AnswerObserver<Result = unknown> = CoreAnswerObserver<Result, Endpoint | null>;
+/** Directed communication originating from one client-visible Endpoint. */
 export type EndpointTraffic<Events extends object = {}> = CoreEndpointTraffic<Events, Endpoint | null, Server | null>;
+/** Directed communication originating from one client-visible Server. */
 export type ServerTraffic<Events extends object = {}> = CoreServerTraffic<Events, Endpoint | null, Server | null>;
+/** Directed communication originating from one client-visible Client. */
 export type ClientTraffic<Events extends object = {}> = CoreClientTraffic<Events, Endpoint | null, Server | null>;
+/** Common Endpoint handle visible inside a structurally isolated Client. */
 export type Endpoint<Events extends object = {}> = Omit<CoreEndpoint<Events>, "process" | "traffic"> & {
+    /** Directed communication originating from this Endpoint. */
     readonly traffic: EndpointTraffic<Events>;
-    process(): Process;
+    /** Returns the Process that owns this Endpoint. */
+    process(): Promise<Process>;
 };
+/** Server handle visible inside a structurally isolated Client. */
 export type Server<Events extends object = {}> = Omit<CoreServer<Events>, "process" | "traffic"> & Endpoint<Events> & {
+    /** Directed communication originating from this Server. */
     readonly traffic: ServerTraffic<Events>;
-    process(): Process;
+    /** Returns the Process that owns this Server. */
+    process(): Promise<Process>;
 };
+/** Client handle visible inside a structurally isolated Client. */
 export type Client<Events extends object = {}> = Omit<CoreClient<Events>, "process" | "traffic" | "window"> & Endpoint<Events> & {
+    /** Directed communication originating from this Client. */
     readonly traffic: ClientTraffic<Events>;
-    process(): Process;
-    window(): Promise<Window>;
+    /** Presentation capability permanently owned by this Client handle. */
+    readonly window: Window;
+    /** Returns the Process that owns this Client. */
+    process(): Promise<Process>;
 };
-export type Window<Events extends object = {}> = Omit<CoreWindow<Events>, "client"> & {
-    client(): Client;
-    localMove(position: Position): void;
-    localResize(size: Size): void;
+/** Client-owned Window capability visible inside a Client boundary. */
+export type Window = CoreWindow & {
+    /** Moves this Window representation without changing authoritative state. */
+    localMove(position: Position): Promise<void>;
+    /** Resizes this Window representation without changing authoritative state. */
+    localResize(size: Size): Promise<void>;
 };
+export declare class TrafficHandle extends Events {
+    protected readonly target: HandleAddress | null;
+    protected readonly kind: "server" | "client";
+    constructor(target: HandleAddress | null, kind: "server" | "client");
+    observeAsks(observer: (capture: AskCapture) => unknown): Cleanup;
+}
+export declare class ServerTrafficHandle extends TrafficHandle {
+    observeAnswers(observer: (capture: AnswerCapture) => unknown): Cleanup;
+}
+type WindowTarget = () => Promise<HandleAddress>;
 export declare function scoped(route: string, subject: string | null, convert: (event: string, values: unknown[]) => unknown): Events;
+/** Destinationless events originating from one Endpoint handle. */
+export declare function endpointEvents(target: HandleAddress | null, half: "server" | "client"): Events;
 export declare function exit(code: unknown, signal: unknown): Exit;
 export declare function trafficMessage(value: unknown): TrafficMessage;
 export declare function bindEvents(target: object, events: Events): void;
 export declare function program(record: ProgramRecord): Program;
-export declare function process(record: ProcessRecord): Process;
+export declare function process(record: ProcessRecord, endpoints?: {
+    server?: Server;
+    client?: Client;
+}): Process;
 export declare function endpoint(reference: EndpointReference | undefined): Endpoint;
+export declare function claimEndpoint(reference: string, kind: "server" | "client", endpoint: Endpoint): Endpoint<{}>;
+export declare function window(target: WindowTarget): Window;
 /** Resolves only endpoint identities intentionally visible to this Client. */
 export declare function visibleEndpoint(reference: EndpointReference | null | undefined): Endpoint | null;
-export declare const Program: {
-    new <Events extends object = {}>(): Program<Events>;
-};
-export declare const Process: {
-    new <Events extends object = {}>(): Process<Events>;
-};
-export declare const Endpoint: {
-    new <Events extends object = {}>(): Endpoint<Events>;
-};
-export declare const Server: {
-    new <Events extends object = {}>(): Server<Events>;
-};
-export declare const Client: {
-    new <Events extends object = {}>(): Client<Events>;
-};
-export declare const Window: {
-    new <Events extends object = {}>(): Window<Events>;
-};
+/** Runtime constructor shared by all client-visible Program handles. */
+export declare const Program: typeof CoreProgram;
+/** Runtime constructor shared by all client-visible Process handles. */
+export declare const Process: typeof CoreProcess;
+/** Runtime constructor shared by all client-visible Endpoint handles. */
+export declare const Endpoint: typeof CoreEndpoint;
+/** Runtime constructor shared by all client-visible Server handles. */
+export declare const Server: typeof CoreServer;
+/** Runtime constructor shared by all client-visible Client handles. */
+export declare const Client: typeof CoreClient;
+export {};