@phreshos/client 0.1.31 → 0.1.33

package/README.md

@@ -2,9 +2,9 @@
 
 The SDK for a PhreshOS Program's Client Endpoint.
 
-The Client SDK adapts the sandboxed desktop boundary to the shared Core domain
-model. It exposes the restricted `system` and `context` available inside a
-Client without redefining Program, Process, Endpoint, Server, or Client.
+The Client SDK adapts the Desktop boundary to the shared Core domain model. It
+exposes the same complete `system` contract as the Server and Node SDKs, the
+current Client `context`, and the Client's `desktop` environment.
 
 ## Installation
 
@@ -31,12 +31,14 @@ context.publish("changed", { value: 1 })
 const program = await context.program()
 const process = await context.process()
 const server = context.server
-const window = context.window
+const position = await context.window.position()
+await context.localWindow.move({ x: 20, y: 20 })
 ```
 
 `context` belongs to the executing Client. It provides communication,
-navigation to its Program and Process, its paired Server, its Window, and
-Client-owned capabilities.
+navigation to its Program and Process, its paired Server, the authoritative
+current Window through `window`, and command-only control of the current
+Desktop representation through `localWindow`.
 
 ## System
 
@@ -44,15 +46,23 @@ Client-owned capabilities.
 import { system } from "@phreshos/client"
 
 const appearance = await system.appearance.snapshot()
-const surface = await system.desktop.surface.snapshot()
-const pointer = await system.desktop.pointer.snapshot()
-const preferences = await system.desktop.preferences.snapshot()
+const programs = await system.program.list()
+const processes = await system.process.list()
 ```
 
-The Client System exposes only capabilities allowed by the desktop boundary:
-read-only Appearance, desktop surface and pointer state, writable desktop
-preferences, uploads, Fetch, and exact Service handles. It does not expose
-system-wide Program or Process registries.
+`system` is the complete global System contract sourced from Core.
+
+## Desktop
+
+```ts
+import { desktop } from "@phreshos/client"
+
+const surface = await desktop.surface.snapshot()
+const preferences = await desktop.preferences.snapshot()
+```
+
+Desktop capabilities remain separate from the global System and the current
+execution Context.
 
 Requests read current state. Subscriptions observe future publications and do
 not replay an initial value. Importing the SDK performs neither operation.

package/dist/appearance.d.ts

@@ -1,6 +1,7 @@
+import { type Appearance, type AppearanceEvents, type WritableAppearance } from "@phreshos/core";
 import Events from "./events.js";
 /** Read-only System Appearance reached through the Desktop boundary. */
-export default class ClientAppearance extends Events {
+export default class ClientAppearance extends Events<AppearanceEvents, never> implements WritableAppearance {
     constructor();
     snapshot(): Promise<Readonly<{
         background: import("@phreshos/core").ThemedValue<string, string>;
@@ -12,4 +13,5 @@ export default class ClientAppearance extends Events {
         signInWallpaper: import("@phreshos/core").ThemedValue<string | null, string | null>;
         desktopWallpaper: import("@phreshos/core").ThemedValue<string | null, string | null>;
     }>>;
+    update(appearance: Appearance): Promise<void>;
 }

package/dist/appearance.js

@@ -15,4 +15,7 @@ export default class ClientAppearance extends Events {
         const [appearance] = await wire.request(["appearance"]);
         return createAppearanceSnapshot(appearance);
     }
+    async update(appearance) {
+        await wire.request(["updateAppearance", appearance]);
+    }
 }

package/dist/context.d.ts

@@ -1,33 +1,13 @@
-import type { Context as CoreContext, ContextCapture as CoreContextCapture, ContextEvents as CoreContextEvents, ContextMessage as CoreContextMessage } from "@phreshos/core";
-import { Server, type Endpoint, type Process, type Program, type Window } from "./domain.js";
-/** The executing Process's canonical Server handle. */
-export type ContextServer<Events extends object = {}, Fallback = never> = Server<Events, Fallback>;
-/** One value addressed to the current Client, with a client-visible sender. */
+import type { ClientContext as CoreClientContext, ContextCapture as CoreContextCapture, ContextEvents as CoreContextEvents, ContextMessage as CoreContextMessage } from "@phreshos/core";
+import { ServerEndpoint, type Endpoint } from "./domain.js";
+/** The executing Process's canonical Server Endpoint handle. */
+export type ContextServer<Events extends object = {}, Fallback = unknown> = ServerEndpoint<Events, Fallback>;
+/** One value addressed to the current Client Endpoint, with a client-visible sender. */
 export type ContextMessage<Payload = unknown> = CoreContextMessage<Payload, Endpoint | null>;
 /** Applies the client-visible sender envelope to known Context events. */
 export type ContextEvents<Events extends object> = CoreContextEvents<Events, Endpoint | null>;
-/** Every event observable through the current Client Context. */
+/** Every event observable through the current Client Endpoint Context. */
 export type ContextCapture<Events extends object = {}> = CoreContextCapture<Events, Endpoint | null>;
-/** Client runtime context: inbound communication, owner hierarchy, and paired Server. */
-export interface Context<Events extends object = {}> extends CoreContext<Events, Endpoint | null> {
-    /** The same Server handle exposed by the executing Process. */
-    readonly server: ContextServer;
-    /** Presentation capability of the executing Client. */
-    readonly window: Window;
-    /** The same permission capability exposed by the executing Program. */
-    readonly permission: Program["permission"];
-    /** Returns the Process represented by this Client. */
-    process(): Promise<Process>;
-    /** Returns the executing Process's Program-local name, or `null` when unnamed. */
-    name(): Promise<string | null>;
-    /** Returns the accessible parent Process, or `null` when none exists. */
-    parent(): Promise<Process | null>;
-    /** Returns the Program that owns this Client. */
-    program(): Promise<Program>;
-    /** Returns one immutable option supplied when this Process was created. */
-    option(name: string): Promise<string | undefined>;
-    /** Stops the executing Client; rejects when it is the final live Endpoint. */
-    stop(): Promise<void>;
-}
-/** Inbound events, owner hierarchy, and paired Server for this Client runtime. */
+export type Context<Events extends object = {}> = CoreClientContext<Events>;
+/** Inbound events, owner hierarchy, and paired Server Endpoint for this Client runtime. */
 export declare const context: Context;

package/dist/context.js

@@ -1,11 +1,11 @@
 import Deadline from "./deadline.js";
-import { Client, Server, ServerTrafficHandle, TrafficHandle, bindEvents, endpointLifecycle, endpointEvents, process, program, visibleEndpoint, window as windowHandle } from "./domain.js";
+import { ClientEndpoint, ServerEndpoint, ServerTrafficHandle, TrafficHandle, bindEvents, endpointLifecycle, endpointEvents, process, program, visibleEndpoint, localWindow, window as windowHandle, } from "./domain.js";
 import Events from "./events.js";
 import wire from "./wire.js";
-import { currentProgramPermission } from "./permissions.js";
-const ServerBase = Server;
-const ClientBase = Client;
-class ContextServerHandle extends ServerBase {
+import { contextPermissions } from "./permissions.js";
+const ServerEndpointBase = ServerEndpoint;
+const ClientEndpointBase = ClientEndpoint;
+class ContextServerHandle extends ServerEndpointBase {
     owner;
     traffic = new ServerTrafficHandle(null, "server");
     lifecycle = endpointLifecycle(currentAddress, "server");
@@ -23,7 +23,7 @@ class ContextServerHandle extends ServerBase {
     async start(launch = {}) { await wire.request(["start-endpoint", undefined, "server", launch]); }
     async stop() { await wire.request(["stop-endpoint", undefined, "server"]); }
     async isService() { return (await wire.request(["is-service", "server"]))[0]; }
-    async waitReady(timeout) { await wire.request(["wait-ready"], timeout); }
+    async waitReady(timeout) { await wire.request(["wait-ready", undefined, "server"], timeout); }
     async ask(event, payload = undefined) {
         return this.askWithin(undefined, event, payload);
     }
@@ -32,7 +32,7 @@ class ContextServerHandle extends ServerBase {
     }
     async askWithin(timeout, event, payload) {
         const deadline = new Deadline(timeout);
-        await wire.requestWithin(["wait-ready", null, true], deadline);
+        await wire.requestWithin(["wait-ready", undefined, "server", true], deadline);
         return await wire.askServerWithin(event, payload, deadline);
     }
 }
@@ -54,7 +54,7 @@ function owner() {
     return ownerPromise;
 }
 contextServer = new ContextServerHandle(owner);
-class ContextClientHandle extends ClientBase {
+class ContextClientHandle extends ClientEndpointBase {
     owner;
     traffic = new TrafficHandle(null, "client");
     lifecycle = endpointLifecycle(currentAddress, "client");
@@ -77,12 +77,14 @@ class ContextClientHandle extends ClientBase {
     async start(launch = {}) { await wire.request(["start-endpoint", undefined, "client", launch]); }
     async stop() { await wire.request(["stop-endpoint", undefined, "client"]); }
     async isService() { return (await wire.request(["is-service", "client"]))[0]; }
+    async waitReady(timeout) { await wire.request(["wait-ready", undefined, "client"], timeout); }
 }
 contextClient = new ContextClientHandle(owner);
 class ClientContext extends Events {
     server = contextServer;
     window = contextClient.window;
-    permission = currentProgramPermission;
+    localWindow = localWindow(currentAddress);
+    permissions = contextPermissions();
     constructor() {
         super((event, listener, impossible) => wire.on("end-end", event, value => listener(contextMessage(value)), null, impossible), (listener, impossible) => wire.onAll("end-end", (event, value) => {
             if (typeof event === "string")
@@ -115,5 +117,5 @@ function contextMessage(value) {
     const raw = value;
     return { from: visibleEndpoint(raw.from), payload: raw.payload };
 }
-/** Inbound events, owner hierarchy, and paired Server for this Client runtime. */
+/** Inbound events, owner hierarchy, and paired Server Endpoint for this Client runtime. */
 export const context = new ClientContext();

package/dist/desktop/desktop.d.ts

@@ -1,13 +1,3 @@
-import type { DesktopPointerSource, DesktopSurfaceSource, WritableDesktopPreferencesSource } from "@phreshos/core";
-/** Every capability owned by the Desktop containing this Client. */
-export interface SystemDesktop {
-    readonly surface: DesktopSurfaceSource;
-    readonly pointer: DesktopPointerSource;
-    readonly preferences: WritableDesktopPreferencesSource;
-}
-/** Desktop access bound to the current Client Process boundary. */
-export default class ClientDesktop implements SystemDesktop {
-    readonly surface: DesktopSurfaceSource;
-    readonly pointer: DesktopPointerSource;
-    readonly preferences: WritableDesktopPreferencesSource;
-}
+import type { Desktop } from "@phreshos/core";
+/** The Desktop environment containing this Client Endpoint. */
+export declare const desktop: Desktop;

package/dist/desktop/desktop.js

@@ -1,9 +1,9 @@
-import ClientPointer from "./pointer.js";
 import ClientPreferences from "./preferences.js";
 import ClientSurface from "./surface.js";
-/** Desktop access bound to the current Client Process boundary. */
-export default class ClientDesktop {
+/** Desktop access bound to the current Client Endpoint's Process boundary. */
+class ClientDesktop {
     surface = new ClientSurface();
-    pointer = new ClientPointer();
     preferences = new ClientPreferences();
 }
+/** The Desktop environment containing this Client Endpoint. */
+export const desktop = new ClientDesktop();

package/dist/desktop/preferences.d.ts

@@ -1,7 +1,7 @@
-import type { DesktopPreferencesUpdate } from "@phreshos/core";
+import type { DesktopPreferencesEvents, DesktopPreferencesUpdate, WritableDesktopPreferencesSource } from "@phreshos/core";
 import Events from "../events.js";
-/** Effective preferences owned by the Desktop containing this Client. */
-export default class ClientPreferences extends Events {
+/** Effective preferences owned by the Desktop containing this Client Endpoint. */
+export default class ClientPreferences extends Events<DesktopPreferencesEvents, never> implements WritableDesktopPreferencesSource {
     constructor();
     snapshot(): Promise<Readonly<{
         theme: import("@phreshos/core").Theme;

package/dist/desktop/preferences.js

@@ -1,6 +1,6 @@
 import Events from "../events.js";
 import wire from "../wire.js";
-/** Effective preferences owned by the Desktop containing this Client. */
+/** Effective preferences owned by the Desktop containing this Client Endpoint. */
 export default class ClientPreferences extends Events {
     constructor() {
         super((event, listener, impossible) => wire.on("host-desktop-preferences", event, value => {

package/dist/desktop/surface.d.ts

@@ -1,6 +1,7 @@
+import type { DesktopSurfaceEvents, DesktopSurfaceSource } from "@phreshos/core";
 import Events from "../events.js";
-/** Read-only access to the Desktop surface containing this Client. */
-export default class ClientSurface extends Events {
+/** Read-only access to the Desktop surface containing this Client Endpoint. */
+export default class ClientSurface extends Events<DesktopSurfaceEvents, never> implements DesktopSurfaceSource {
     constructor();
     snapshot(): Promise<Readonly<{
         size: import("@phreshos/core").DesktopSize;

package/dist/desktop/surface.js

@@ -1,6 +1,6 @@
 import Events from "../events.js";
 import wire from "../wire.js";
-/** Read-only access to the Desktop surface containing this Client. */
+/** Read-only access to the Desktop surface containing this Client Endpoint. */
 export default class ClientSurface extends Events {
     constructor() {
         super((event, listener, impossible) => wire.on("host-desktop-surface", event, value => {

package/dist/domain.d.ts

@@ -1,4 +1,4 @@
-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 AnswerSubscriber as CoreAnswerSubscriber, type AskCapture as CoreAskCapture, type AskMessage as CoreAskMessage, type AskSubscriber as CoreAskSubscriber, type Cleanup, type ClientTraffic as CoreClientTraffic, type ClientDeclaration, type EndpointTraffic as CoreEndpointTraffic, type Exit, type EventOptions, type Launch, type LocalWindow, type Outcome, type Permission, type Position, type ProgramProcess as CoreProgramProcess, 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 { ClientEndpoint as CoreClientEndpoint, Endpoint as CoreEndpoint, Process as CoreProcess, Program as CoreProgram, ServerEndpoint as CoreServerEndpoint, type AnswerCapture as CoreAnswerCapture, type AnswerMessage as CoreAnswerMessage, type AnswerSubscriber as CoreAnswerSubscriber, type AskCapture as CoreAskCapture, type AskMessage as CoreAskMessage, type AskSubscriber as CoreAskSubscriber, type Cleanup, type ClientTraffic as CoreClientTraffic, type ClientDeclaration, type EndpointTraffic as CoreEndpointTraffic, type Exit, type EventOptions, type LocalWindow, type Outcome, type Position, type ProgramProcess as CoreProgramProcess, type ProgramProcessRunEvent as CoreProgramProcessRunEvent, type ProgramProcessRunOptions as CoreProgramProcessRunOptions, 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;
@@ -14,10 +14,12 @@ export interface ClientDeclarationRecord extends EndpointDeclarationRecord {
     position: Position | null;
     layer: ClientDeclaration["layer"];
     minimize: boolean | null;
+    permissions: ClientDeclaration["permissions"];
 }
 export interface ProgramRecord {
     reference: string;
     identity: string;
+    assetId: string;
     installed?: boolean;
     name: string;
     version: string | null;
@@ -44,93 +46,39 @@ export interface EndpointReference {
     process: ProcessRecord;
 }
 export type WindowRecord = WindowState;
-/** Program handle visible inside a structurally isolated Client. */
-export type Program = Omit<CoreProgram, "process"> & {
-    /** Effective permission decisions owned by this Program. */
-    readonly permission: Permission;
-    /** Operations and lifecycle observation for this Program's Processes. */
-    readonly process: ProgramProcess;
-};
-/** Client-visible Process operations scoped to one Program. */
-export type ProgramProcess = Omit<CoreProgramProcess, "list" | "first" | "last" | "find" | "create" | "findOrCreate"> & {
-    /** Returns every live Process of this Program visible to the current Client. */
-    list(): Promise<Process[]>;
-    /** Returns the earliest-started visible live Process, or `null` when none exist. */
-    first(): Promise<Process | null>;
-    /** Returns the latest-started visible live Process, or `null` when none exist. */
-    last(): Promise<Process | null>;
-    /** Finds a visible live Process by runtime identity or Program-local name. */
-    find(identityOrName: string): Promise<Process | null>;
-    /** Creates one Process of this same Program. */
-    create(launch?: Launch): Promise<Process>;
-    /** Finds the named Process or atomically creates it with the same resolved launch. */
-    findOrCreate(launch: Launch & Readonly<{
-        name: string;
-    }>): Promise<Process>;
-};
-/** Process handle visible inside a structurally isolated Client. */
-export type Process = Omit<CoreProcess, "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 Program = CoreProgram;
+export type ProgramProcess = CoreProgramProcess;
+export type ProgramProcessRunEvent = CoreProgramProcessRunEvent;
+export type ProgramProcessRunOptions = CoreProgramProcessRunOptions;
+export type Process = CoreProcess;
+/** Traffic value resolved to the same global Endpoint handles as the System. */
 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 = {}, Fallback = never> = CoreTrafficCapture<Events, Endpoint | null, Fallback>;
-/** Question with a Server destination hidden when it crosses the Client boundary. */
-export type AskMessage<Payload = unknown> = CoreAskMessage<Payload, Server | null>;
+export type TrafficCapture<Events extends object = {}, Fallback = unknown> = CoreTrafficCapture<Events, Endpoint | null, Fallback>;
+/** Question carrying its globally resolved Server Endpoint destination. */
+export type AskMessage<Payload = unknown> = CoreAskMessage<Payload, ServerEndpoint | null>;
 /** One question observable in client-visible Endpoint traffic. */
-export type AskCapture<Payload = unknown> = CoreAskCapture<Payload, Server | null>;
+export type AskCapture<Payload = unknown> = CoreAskCapture<Payload, ServerEndpoint | null>;
 /** Callback that observes questions sent by a client-visible Endpoint. */
-export type AskSubscriber<Payload = unknown> = CoreAskSubscriber<Payload, Server | null>;
-/** Answer with an Endpoint destination hidden when it crosses the Client boundary. */
+export type AskSubscriber<Payload = unknown> = CoreAskSubscriber<Payload, ServerEndpoint | null>;
+/** Answer carrying its globally resolved Endpoint destination. */
 export type AnswerMessage<Result = unknown> = CoreAnswerMessage<Result, Endpoint | null>;
-/** One answer observable in client-visible Server traffic. */
+/** One answer observable in client-visible Server Endpoint traffic. */
 export type AnswerCapture<Result = unknown> = CoreAnswerCapture<Result, Endpoint | null>;
-/** Callback that observes answers sent by a client-visible Server. */
+/** Callback that observes answers sent by a client-visible Server Endpoint. */
 export type AnswerSubscriber<Result = unknown> = CoreAnswerSubscriber<Result, Endpoint | null>;
 /** Directed communication originating from one client-visible Endpoint. */
-export type EndpointTraffic<Events extends object = {}, Fallback = never> = CoreEndpointTraffic<Events, Endpoint | null, Server | null, Fallback>;
-/** Directed communication originating from one client-visible Server. */
-export type ServerTraffic<Events extends object = {}, Fallback = never> = CoreServerTraffic<Events, Endpoint | null, Server | null, Fallback>;
-/** Directed communication originating from one client-visible Client. */
-export type ClientTraffic<Events extends object = {}, Fallback = never> = CoreClientTraffic<Events, Endpoint | null, Server | null, Fallback>;
-/** Common Endpoint handle visible inside a structurally isolated Client. */
-export type Endpoint<Events extends object = {}, Fallback = never> = Omit<CoreEndpoint<Events, Fallback>, "process" | "traffic"> & {
-    /** Directed communication originating from this Endpoint. */
-    readonly traffic: EndpointTraffic<Events, Fallback>;
-    /** Returns the Process that owns this Endpoint. */
-    process(): Promise<Process>;
-};
-/** Server handle visible inside a structurally isolated Client. */
-export type Server<Events extends object = {}, Fallback = never> = Omit<CoreServer<Events, Fallback>, "process" | "traffic"> & Endpoint<Events, Fallback> & {
-    /** Directed communication originating from this Server. */
-    readonly traffic: ServerTraffic<Events, Fallback>;
-    /** Returns the Process that owns this Server. */
-    process(): Promise<Process>;
-};
-/** Client handle visible inside a structurally isolated Client. */
-export type Client<Events extends object = {}, Fallback = never> = Omit<CoreClient<Events, Fallback>, "process" | "traffic" | "window"> & Endpoint<Events, Fallback> & {
-    /** Directed communication originating from this Client. */
-    readonly traffic: ClientTraffic<Events, Fallback>;
-    /** Presentation capability permanently owned by this Client handle. */
-    readonly window: Window;
-    /** Returns the Process that owns this Client. */
-    process(): Promise<Process>;
-};
-/** Authoritative Window state plus its representation on this desktop. */
-export type Window = CoreWindow & {
-    /** Physical representation of this Window on the current desktop. */
-    readonly local: LocalWindow;
-};
+export type EndpointTraffic<Events extends object = {}, Fallback = unknown> = CoreEndpointTraffic<Events, Endpoint | null, ServerEndpoint | null, Fallback>;
+/** Directed communication originating from one client-visible Server Endpoint. */
+export type ServerTraffic<Events extends object = {}, Fallback = unknown> = CoreServerTraffic<Events, Endpoint | null, ServerEndpoint | null, Fallback>;
+/** Directed communication originating from one client-visible Client Endpoint. */
+export type ClientTraffic<Events extends object = {}, Fallback = unknown> = CoreClientTraffic<Events, Endpoint | null, ServerEndpoint | null, Fallback>;
+export type Endpoint<Events extends object = {}, Fallback = unknown> = CoreEndpoint<Events, Fallback>;
+export type ServerEndpoint<Events extends object = {}, Fallback = unknown> = CoreServerEndpoint<Events, Fallback>;
+export type ClientEndpoint<Events extends object = {}, Fallback = unknown> = CoreClientEndpoint<Events, Fallback>;
+export type Window = CoreWindow;
 export declare class TrafficHandle extends Events {
     protected readonly target: HandleAddress | null;
     protected readonly kind: "server" | "client";
@@ -140,7 +88,7 @@ export declare class TrafficHandle extends Events {
         event: string;
         questionId: string;
         message: Readonly<{
-            to: Server<{}, never> | null;
+            to: ServerEndpoint<{}, unknown> | null;
             payload: unknown;
         }>;
     }>>;
@@ -152,30 +100,31 @@ export declare class ServerTrafficHandle extends TrafficHandle {
         event: string;
         questionId: string;
         message: Readonly<{
-            to: Endpoint<{}, never> | null;
+            to: Endpoint<{}, unknown> | null;
             outcome: Outcome<unknown>;
         }>;
     }>>;
     private followAnswers;
 }
 type WindowTarget = () => Promise<HandleAddress>;
-export declare function scoped(route: string, subject: string | null, convert: (event: string, values: unknown[]) => unknown): Events;
+export declare function scoped(route: string, subject: string | null, convert: (event: string, values: unknown[]) => unknown): Events<{}, unknown>;
 /** Destinationless events originating from one Endpoint handle. */
-export declare function endpointEvents(target: HandleAddress | null, half: "server" | "client"): Events;
+export declare function endpointEvents(target: HandleAddress | null, half: "server" | "client"): Events<{}, unknown>;
 /** Start and stop transitions belonging directly to one permanent Endpoint. */
-export declare function endpointLifecycle(target: WindowTarget, half: "server" | "client"): Events;
+export declare function endpointLifecycle(target: WindowTarget, half: "server" | "client"): Events<{}, unknown>;
 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, endpoints?: {
-    server?: Server;
-    client?: Client;
+    server?: ServerEndpoint;
+    client?: ClientEndpoint;
 }): Process;
 export declare function endpoint(reference: EndpointReference | undefined): Endpoint;
-export declare function claimEndpoint(reference: string, kind: "server" | "client", endpoint: Endpoint): Endpoint<{}, never>;
+export declare function claimEndpoint(reference: string, kind: "server" | "client", endpoint: Endpoint): Endpoint<{}, unknown>;
 export declare function window(target: WindowTarget): Window;
-/** Resolves only endpoint identities intentionally visible to this Client. */
+export declare function localWindow(target: WindowTarget): LocalWindow;
+/** Resolves an Endpoint reference through the Client Endpoint's global handle registry. */
 export declare function visibleEndpoint(reference: EndpointReference | null | undefined): Endpoint | null;
 /** Runtime constructor shared by all client-visible Program handles. */
 export declare const Program: typeof CoreProgram;
@@ -183,8 +132,8 @@ export declare const Program: typeof CoreProgram;
 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;
+/** Runtime constructor shared by all client-visible Server Endpoint handles. */
+export declare const ServerEndpoint: typeof CoreServerEndpoint;
+/** Runtime constructor shared by all client-visible Client Endpoint handles. */
+export declare const ClientEndpoint: typeof CoreClientEndpoint;
 export {};