@phreshos/client 0.1.37 → 0.1.39

package/README.md

@@ -49,10 +49,16 @@ bun run verify
 `verify` checks the types and completions, builds the package, and validates its
 published shape.
 
+`check` performs static checks, `build` creates distributable output, and `test`
+runs Vitest assertions from `tests/`. Run `build` before testing built artifacts.
+`verify` runs `check`, `build`, and `test` in order. Operational tooling belongs
+in `scripts/`; tests and their fixtures belong in `tests/`. Verification uses
+the committed dependency graph without local package substitutions.
+
 ## Related repositories
 
-- [`@phreshos/core`](https://github.com/PhreshOS/core) owns every shared
-  contract and domain class exposed here.
+- [`@phreshos/core`](https://github.com/PhreshOS/core) is the one public import
+  path for every shared contract and domain class implemented by these handles.
 - [`@phreshos/server`](https://github.com/PhreshOS/server) adapts the paired
   Server Endpoint boundary.
 - [`@phreshos/react`](https://github.com/PhreshOS/react) adapts the Client

package/dist/appearance.d.ts

@@ -4,19 +4,14 @@ import Events from "./events.js";
 export default class ClientAppearance extends Events<AppearanceEvents, never> implements WritableAppearance {
     constructor();
     snapshot(): Promise<Readonly<{
-        background: import("@phreshos/core").ThemedValue<string, string>;
-        foreground: import("@phreshos/core").ThemedValue<string, string>;
-        primary: import("@phreshos/core").ThemedValue<string, string>;
-        secondary: import("@phreshos/core").ThemedValue<string, string>;
-        success: import("@phreshos/core").ThemedValue<string, string>;
-        warning: import("@phreshos/core").ThemedValue<string, string>;
-        danger: import("@phreshos/core").ThemedValue<string, string>;
-        info: import("@phreshos/core").ThemedValue<string, string>;
-        spacing: import("@phreshos/core").ThemedValue<number>;
-        radius: import("@phreshos/core").ThemedValue<number>;
-        surface: import("@phreshos/core").ThemedValue<import("@phreshos/core").AppearanceSurface, import("@phreshos/core").AppearanceSurface>;
-        signInWallpaper: import("@phreshos/core").ThemedValue<string | null, string | null>;
-        desktopWallpaper: import("@phreshos/core").ThemedValue<string | null, string | null>;
+        colors: import("@phreshos/core").ThemedValue<import("@phreshos/core").AppearanceColors>;
+        spacing: number;
+        radius: number;
+        shadow: import("@phreshos/core").ThemedValue<import("@phreshos/core").AppearanceShadow>;
+        material: import("@phreshos/core").ThemedValue<import("@phreshos/core").AppearanceMaterial>;
+        transaction: import("@phreshos/core").AppearanceTransaction;
+        signInWallpaper: import("@phreshos/core").ThemedValue<string | null>;
+        desktopWallpaper: import("@phreshos/core").ThemedValue<string | null>;
     }>>;
     update(appearance: Appearance): Promise<void>;
 }

package/dist/appearance.js

@@ -1,19 +1,19 @@
-import { createAppearanceSnapshot } from "@phreshos/core";
+import { parseAppearance } from "@phreshos/core";
 import Events from "./events.js";
 import wire from "./wire.js";
 /** Read-only System Appearance reached through the Desktop boundary. */
 export default class ClientAppearance extends Events {
     constructor() {
         super((event, listener, impossible) => wire.on("host-appearance", event, value => {
-            listener(createAppearanceSnapshot(value));
+            listener(parseAppearance(value));
         }, null, impossible), observer => wire.onAll("host-appearance", (event, value) => {
             if (typeof event === "string")
-                observer(event, createAppearanceSnapshot(value));
+                observer(event, parseAppearance(value));
         }));
     }
     async snapshot() {
         const [appearance] = await wire.request(["appearance"]);
-        return createAppearanceSnapshot(appearance);
+        return parseAppearance(appearance);
     }
     async update(appearance) {
         await wire.request(["updateAppearance", appearance]);

package/dist/content.d.ts

@@ -1,6 +1,7 @@
+import type { WritableContent } from "@phreshos/core";
 export type ContentBody = Blob | ReadableStream<Uint8Array>;
 /** Converts one authored value into the browser body and metadata used by storage and serving. */
-export declare function content(value: unknown): {
+export declare function content(value: WritableContent): {
     body: ContentBody;
     extension: string;
     type: string;

package/dist/context.d.ts

@@ -1,13 +1,3 @@
-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 Endpoint Context. */
-export type ContextCapture<Events extends object = {}> = CoreContextCapture<Events, Endpoint | null>;
-export type Context<Events extends object = {}> = CoreClientContext<Events>;
+import type { ClientContext as CoreClientContext } from "@phreshos/core";
 /** Inbound events, owner hierarchy, and paired Server Endpoint for this Client runtime. */
-export declare const context: Context;
+export declare const context: CoreClientContext;

package/dist/context.js

@@ -1,21 +1,27 @@
 import Deadline from "./deadline.js";
-import { ClientEndpoint, ServerEndpoint, ServerTrafficHandle, TrafficHandle, bindEvents, endpointLifecycle, endpointEvents, process, program, visibleEndpoint, localWindow, window as windowHandle, } from "./domain.js";
+import { ClientEndpoint, ServerEndpoint, ServerTrafficHandle, TrafficHandle, endpointLifecycle, endpointEvents, process, program, visibleEndpoint, localWindow, window as windowHandle, } from "./domain.js";
 import Events from "./events.js";
 import wire from "./wire.js";
 import { contextPermissions } from "./permissions.js";
-const ServerEndpointBase = ServerEndpoint;
-const ClientEndpointBase = ClientEndpoint;
-class ContextServerHandle extends ServerEndpointBase {
+class ContextServerHandle extends ServerEndpoint {
     owner;
+    subscribe;
+    wait;
+    events;
     traffic = new ServerTrafficHandle(null, "server");
     lifecycle = endpointLifecycle(currentAddress, "server");
     constructor(owner) {
         super();
         this.owner = owner;
-        bindEvents(this, endpointEvents(null, "server"));
+        const events = endpointEvents(null, "server");
+        this.subscribe = events.subscribe;
+        this.wait = events.wait;
+        this.events = events.events;
     }
     process() { return this.owner(); }
-    publish(event, payload = undefined) { wire.send("end-end", event, payload); }
+    publish = (event, payload = undefined) => {
+        wire.send("end-end", event, payload);
+    };
     async exists() {
         const answer = await wire.request(["exists", "server"]);
         return answer[0];
@@ -54,22 +60,28 @@ function owner() {
     return ownerPromise;
 }
 contextServer = new ContextServerHandle(owner);
-class ContextClientHandle extends ClientEndpointBase {
+class ContextClientHandle extends ClientEndpoint {
     owner;
+    subscribe;
+    wait;
+    events;
     traffic = new TrafficHandle(null, "client");
     lifecycle = endpointLifecycle(currentAddress, "client");
     window = windowHandle(currentAddress);
     constructor(owner) {
         super();
         this.owner = owner;
-        bindEvents(this, endpointEvents(null, "client"));
+        const events = endpointEvents(null, "client");
+        this.subscribe = events.subscribe;
+        this.wait = events.wait;
+        this.events = events.events;
     }
     process() { return this.owner(); }
-    publish(event, payload = undefined) {
+    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];
@@ -101,9 +113,9 @@ class ClientContext extends Events {
         const answer = await wire.request(["current-program"]);
         return program(answer[0]);
     }
-    async option(name) {
-        const answer = await wire.request(["option", undefined, name]);
-        return answer[0];
+    async options(name) {
+        const process = await owner();
+        return name === undefined ? process.options() : process.options(name);
     }
     async stop() { await wire.request(["stop-current"]); }
     async isService() { return contextClient.isService(); }

package/dist/desktop/desktop.js

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

package/dist/desktop/viewport.d.ts

@@ -0,0 +1,9 @@
+import type { DesktopViewportEvents, DesktopViewportSource } from "@phreshos/core";
+import Events from "../events.js";
+/** Read-only access to the Desktop viewport containing this Client Endpoint. */
+export default class ClientViewport extends Events<DesktopViewportEvents, never> implements DesktopViewportSource {
+    constructor();
+    snapshot(): Promise<Readonly<{
+        size: import("@phreshos/core").DesktopSize;
+    }>>;
+}

package/dist/desktop/{surface.js → viewport.js}

@@ -1,23 +1,23 @@
 import Events from "../events.js";
 import wire from "../wire.js";
-/** Read-only access to the Desktop surface containing this Client Endpoint. */
-export default class ClientSurface extends Events {
+/** Read-only access to the Desktop viewport containing this Client Endpoint. */
+export default class ClientViewport extends Events {
     constructor() {
-        super((event, listener, impossible) => wire.on("host-desktop-surface", event, value => {
+        super((event, listener, impossible) => wire.on("host-desktop-viewport", event, value => {
             const snapshot = createSnapshot(value);
             if (snapshot)
                 listener(snapshot);
-        }, null, impossible), observer => wire.onAll("host-desktop-surface", (event, value) => {
+        }, null, impossible), observer => wire.onAll("host-desktop-viewport", (event, value) => {
             const snapshot = createSnapshot(value);
             if (typeof event === "string" && snapshot)
                 observer(event, snapshot);
         }));
     }
     async snapshot() {
-        const answer = await wire.request(["desktopSurface"]);
+        const answer = await wire.request(["desktopViewport"]);
         const snapshot = createSnapshot(answer[0]);
         if (!snapshot)
-            throw new Error("The System returned an invalid Desktop surface");
+            throw new Error("The System returned an invalid Desktop viewport");
         return snapshot;
     }
 }

package/dist/domain.d.ts

@@ -1,50 +1,12 @@
-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 AnswerOutcome, 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 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 { ClientEndpoint as CoreClientEndpoint, Endpoint as CoreEndpoint, Process as CoreProcess, Program as CoreProgram, ServerEndpoint as CoreServerEndpoint, type AnswerCapture as CoreAnswerCapture, type AnswerMessage as CoreAnswerMessage, type AnswerOutcome, 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 EndpointReference as CoreEndpointReference, type EndpointSnapshot, type HandleAddress, type ProcessSnapshot, type ProgramSnapshot, type EndpointTraffic as CoreEndpointTraffic, type EndpointLifecycleEvents, type EndpointDeclaration, type Exit, type EventOptions, type LocalWindow, type ProgramProcess as CoreProgramProcess, type ProgramProcessRunEvent as CoreProgramProcessRunEvent, type ProgramProcessRunOptions as CoreProgramProcessRunOptions, type ServerTraffic as CoreServerTraffic, 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 EndpointDeclarationRecord {
-    start: boolean;
-    service: boolean;
-}
-export interface ClientDeclarationRecord extends EndpointDeclarationRecord {
-    title: string | null;
-    size: Size | null;
-    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;
-    description: string | null;
-    hasAgent: boolean;
-    server: EndpointDeclarationRecord | null;
-    client: ClientDeclarationRecord | null;
-}
-export interface ProcessRecord {
-    reference: string;
-    identity: string;
-    name: string | null;
-    program: ProgramRecord;
-    options: Record<string, string>;
-    startedAt: string | Date;
-    server: EndpointRecord | null;
-    client: EndpointRecord | null;
-}
-export interface EndpointRecord {
-    service: boolean;
-}
-export interface EndpointReference {
-    kind: "server" | "client";
-    process: ProcessRecord;
-}
+export type { HandleAddress };
+export type EndpointDeclarationRecord = EndpointDeclaration;
+export type ClientDeclarationRecord = ClientDeclaration;
+export type ProgramRecord = ProgramSnapshot;
+export type ProcessRecord = ProcessSnapshot;
+export type EndpointRecord = EndpointSnapshot;
+export type EndpointReference = CoreEndpointReference;
 export type WindowRecord = WindowState;
 export type Program = CoreProgram;
 export type ProgramProcess = CoreProgramProcess;
@@ -79,48 +41,47 @@ export type Endpoint<Events extends object = {}, Fallback = unknown> = CoreEndpo
 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 {
+export declare class TrafficHandle<EventsMap extends object = {}, Fallback = unknown> extends Events<TrafficEvents<EventsMap>, TrafficMessage<Fallback>> {
     protected readonly target: HandleAddress | null;
     protected readonly kind: "server" | "client";
     constructor(target: HandleAddress | null, kind: "server" | "client");
-    subscribeAsks(subscriber: (capture: AskCapture) => unknown): Cleanup;
-    asks(options?: EventOptions): AsyncIterableIterator<Readonly<{
+    subscribeAsks<Payload = unknown>(subscriber: (capture: AskCapture<Payload>) => unknown): Cleanup;
+    asks<Payload = unknown>(options?: EventOptions): AsyncIterableIterator<Readonly<{
         event: string;
         questionId: string;
         message: Readonly<{
             to: ServerEndpoint<{}, unknown> | null;
-            payload: unknown;
+            payload: Payload;
         }>;
     }>>;
     private followAsks;
 }
-export declare class ServerTrafficHandle extends TrafficHandle {
-    subscribeAnswers(subscriber: (capture: AnswerCapture) => unknown): Cleanup;
-    answers(options?: EventOptions): AsyncIterableIterator<Readonly<{
+export declare class ServerTrafficHandle<EventsMap extends object = {}, Fallback = unknown> extends TrafficHandle<EventsMap, Fallback> {
+    subscribeAnswers<Result = unknown>(subscriber: (capture: AnswerCapture<Result>) => unknown): Cleanup;
+    answers<Result = unknown>(options?: EventOptions): AsyncIterableIterator<Readonly<{
         event: string;
         questionId: string;
         message: Readonly<{
             to: Endpoint<{}, unknown> | null;
-            outcome: AnswerOutcome<unknown>;
+            outcome: AnswerOutcome<Result>;
         }>;
     }>>;
     private followAnswers;
 }
 type WindowTarget = () => Promise<HandleAddress>;
-export declare function scoped(route: string, subject: string | null, convert: (event: string, values: unknown[]) => unknown): Events<{}, unknown>;
+export declare function scoped<Definitions extends object = {}, Fallback = unknown>(route: string, subject: string | null, convert: (event: string, values: unknown[]) => unknown): Events<Definitions, Fallback>;
 /** Destinationless events originating from one Endpoint handle. */
 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<{}, unknown>;
+export declare function endpointLifecycle(target: WindowTarget, half: "server" | "client"): Events<EndpointLifecycleEvents, never>;
 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?: {
+export declare function program(value: unknown): Program;
+export declare function process(value: unknown, endpoints?: {
     server?: ServerEndpoint;
     client?: ClientEndpoint;
 }): Process;
-export declare function endpoint(reference: EndpointReference | undefined): Endpoint;
+export declare function endpoint(value: unknown): Endpoint;
 export declare function claimEndpoint(reference: string, kind: "server" | "client", endpoint: Endpoint): Endpoint<{}, unknown>;
 export declare function window(target: WindowTarget): Window;
 export declare function localWindow(target: WindowTarget): LocalWindow;
@@ -136,4 +97,3 @@ export declare const Endpoint: typeof CoreEndpoint;
 export declare const ServerEndpoint: typeof CoreServerEndpoint;
 /** Runtime constructor shared by all client-visible Client Endpoint handles. */
 export declare const ClientEndpoint: typeof CoreClientEndpoint;
-export {};

package/dist/domain.js

@@ -1,4 +1,4 @@
-import { ClientEndpoint as CoreClientEndpoint, Endpoint as CoreEndpoint, Process as CoreProcess, Program as CoreProgram, ServerEndpoint as CoreServerEndpoint, parseClientPermissions } from "@phreshos/core";
+import { ClientEndpoint as CoreClientEndpoint, Endpoint as CoreEndpoint, Process as CoreProcess, Program as CoreProgram, ServerEndpoint as CoreServerEndpoint, parseEndpointReference, parseProcessSnapshot, parseProgramSnapshot } from "@phreshos/core";
 import Events, { stream } from "./events.js";
 import Deadline from "./deadline.js";
 import HandleRegistry from "./handle-registry.js";
@@ -7,11 +7,10 @@ import startup from "./startup.js";
 import { programPermissions } from "./permissions.js";
 import wire from "./wire.js";
 const handles = new HandleRegistry();
-const ProgramBase = CoreProgram;
-const ProcessBase = CoreProcess;
-const ServerEndpointBase = CoreServerEndpoint;
-const ClientEndpointBase = CoreClientEndpoint;
-class ProgramHandle extends ProgramBase {
+class ProgramHandle extends CoreProgram {
+    subscribe;
+    wait;
+    events;
     identity;
     reference;
     data;
@@ -36,19 +35,18 @@ class ProgramHandle extends ProgramBase {
         this.startup = startup(this.address);
         this.permissions = programPermissions(this.address);
         this.process = new ProgramProcessHandle(this.address, record.reference);
-        bindEvents(this, scoped("program-host", record.reference, programEvent));
+        const events = scoped("program-host", record.reference, programEvent);
+        this.subscribe = events.subscribe;
+        this.wait = events.wait;
+        this.events = events.events;
     }
     get name() { return this.record.name; }
     get assetId() { return this.record.assetId; }
     get version() { return this.record.version; }
     get description() { return this.record.description; }
     get hasAgent() { return this.record.hasAgent; }
-    get server() {
-        return this.record.server ? declaration(this.record.server) : null;
-    }
-    get client() {
-        return this.record.client ? clientDeclaration(this.record.client) : null;
-    }
+    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)
@@ -92,28 +90,17 @@ function programCommandChunk(value) {
     }
     return Object.freeze({ stream: chunk.stream, text: chunk.text });
 }
-function declaration(record) {
-    return Object.freeze({
-        start: record.start,
-        service: record.service
-    });
-}
-function clientDeclaration(record) {
-    return Object.freeze({
-        ...declaration(record),
-        title: record.title,
-        size: record.size,
-        position: record.position,
-        layer: record.layer,
-        minimize: record.minimize,
-        permissions: parseClientPermissions(record.permissions)
-    });
-}
 class ProgramProcessHandle {
     address;
+    subscribe;
+    wait;
+    events;
     constructor(address, reference) {
         this.address = address;
-        bindEvents(this, scoped("program-process", reference, programProcessEvent));
+        const events = scoped("program-process", reference, programProcessEvent);
+        this.subscribe = events.subscribe;
+        this.wait = events.wait;
+        this.events = events.events;
     }
     async list() {
         const answer = await wire.request(["program-process-list", this.address]);
@@ -165,7 +152,10 @@ function processRunEvent(value) {
 function chronological(processes) {
     return processes.sort((left, right) => left.startedAt.getTime() - right.startedAt.getTime());
 }
-class ProcessHandle extends ProcessBase {
+class ProcessHandle extends CoreProcess {
+    subscribe;
+    wait;
+    events;
     identity;
     reference;
     name;
@@ -173,7 +163,7 @@ class ProcessHandle extends ProcessBase {
     server;
     client;
     ownerProgram;
-    options;
+    launchOptions;
     constructor(record, endpoints = {}) {
         super();
         this.identity = record.identity;
@@ -181,10 +171,13 @@ class ProcessHandle extends ProcessBase {
         this.name = record.name;
         this.startedAt = new Date(record.startedAt);
         this.ownerProgram = program(record.program);
-        this.options = record.options;
+        this.launchOptions = Object.freeze({ ...record.options });
         this.server = endpointHandle(this, "server", endpoints.server);
         this.client = endpointHandle(this, "client", endpoints.client);
-        bindEvents(this, scoped("process-host", record.reference, processEvent));
+        const events = scoped("process-host", record.reference, processEvent);
+        this.subscribe = events.subscribe;
+        this.wait = events.wait;
+        this.events = events.events;
     }
     program() { return this.ownerProgram; }
     get address() { return { identity: this.identity, reference: this.reference }; }
@@ -192,11 +185,8 @@ class ProcessHandle extends ProcessBase {
         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.address, name]);
-        return answer[0];
+    async options(name) {
+        return name === undefined ? this.launchOptions : this.launchOptions[name];
     }
     async exit() { await wire.request(["exit", this.address]); }
     async exited() {
@@ -245,8 +235,11 @@ export class ServerTrafficHandle extends TrafficHandle {
         }, impossible);
     }
 }
-class ServerEndpointHandle extends ServerEndpointBase {
+class ServerEndpointHandle extends CoreServerEndpoint {
     owner;
+    subscribe;
+    wait;
+    events;
     traffic;
     lifecycle;
     constructor(owner) {
@@ -254,10 +247,15 @@ class ServerEndpointHandle extends ServerEndpointBase {
         this.owner = owner;
         this.traffic = new ServerTrafficHandle(owner.address, "server");
         this.lifecycle = endpointLifecycle(() => Promise.resolve(owner.address), "server");
-        bindEvents(this, endpointEvents(owner.address, "server"));
+        const events = endpointEvents(owner.address, "server");
+        this.subscribe = events.subscribe;
+        this.wait = events.wait;
+        this.events = events.events;
     }
     async process() { return this.owner; }
-    publish(event, payload = undefined) { wire.send("end-host", "send", this.owner.address, "server", event, payload); }
+    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.address]);
         return answer[0];
@@ -288,8 +286,11 @@ class ServerEndpointHandle extends ServerEndpointBase {
         }
     }
 }
-class ClientEndpointHandle extends ClientEndpointBase {
+class ClientEndpointHandle extends CoreClientEndpoint {
     owner;
+    subscribe;
+    wait;
+    events;
     traffic;
     lifecycle;
     window;
@@ -299,10 +300,15 @@ class ClientEndpointHandle extends ClientEndpointBase {
         this.traffic = new TrafficHandle(owner.address, "client");
         this.lifecycle = endpointLifecycle(() => Promise.resolve(owner.address), "client");
         this.window = window(async () => owner.address);
-        bindEvents(this, endpointEvents(owner.address, "client"));
+        const events = endpointEvents(owner.address, "client");
+        this.subscribe = events.subscribe;
+        this.wait = events.wait;
+        this.events = events.events;
     }
     async process() { return this.owner; }
-    publish(event, payload = undefined) { wire.send("end-host", "send", this.owner.address, "client", event, payload); }
+    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.address]);
         return answer[0];
@@ -326,16 +332,18 @@ class WindowHandle extends Events {
     async position() { return (await this.state()).position; }
     async size() { return (await this.state()).size; }
     async minimized() { return (await this.state()).minimized; }
+    async maximized() { return (await this.state()).maximized; }
     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", await this.target(), position]); }
     async resize(size) { await wire.request(["resize", await this.target(), size]); }
     async setGeometry(geometry) { await wire.request(["setGeometry", await this.target(), geometry]); }
     async minimize(minimized = true) { await wire.request(["minimize", await this.target(), minimized]); }
+    async maximize(maximized = true) { await wire.request(["maximize", await this.target(), maximized]); }
     async changeTitle(title) { await wire.request(["changeTitle", await this.target(), title]); }
     async raise() { await wire.request(["raise", await this.target()]); }
 }
+const windowTargets = new WeakMap();
 class LocalWindowHandle {
     target;
     selected;
@@ -351,6 +359,17 @@ class LocalWindowHandle {
     async move(position) { await this.change("windowLocalMove", position); }
     async resize(size) { await this.change("windowLocalResize", size); }
     async setGeometry(geometry) { await this.change("windowLocalGeometry", geometry); }
+    async minimize(minimized = true) { await this.change("windowLocalMinimize", minimized); }
+    async maximize(maximized = true) { await this.change("windowLocalMaximize", maximized); }
+    async changeTitle(title) { await wire.request(["windowLocalTitle", await this.target(), title]); }
+    async follow(window) {
+        const target = windowTargets.get(window);
+        if (!target)
+            throw new Error("Local Window follow requires a Window from this Client SDK");
+        await wire.request(["windowLocalFollow", await this.target(), await target(), this.selected]);
+    }
+    async unfollow() { await wire.request(["windowLocalUnfollow", await this.target(), this.selected]); }
+    async raise() { await wire.request(["windowLocalRaise", await this.target()]); }
     async change(operation, value) {
         await wire.request([operation, await this.target(), value, this.selected]);
     }
@@ -378,7 +397,7 @@ function deferredScoped(route, target, convert) {
     ];
 }
 function windowEvent(event) {
-    return event === "move" || event === "resize" || event === "geometry" || event === "minimize" || event === "changeTitle" || event === "front";
+    return event === "move" || event === "resize" || event === "geometry" || event === "minimize" || event === "maximize" || event === "changeTitle" || event === "front";
 }
 function deferred(target, register, impossible) {
     let active = true;
@@ -471,24 +490,18 @@ export function trafficMessage(value) {
     const raw = value;
     return { to: visibleEndpoint(raw.to), payload: raw.payload };
 }
-export function bindEvents(target, events) {
-    Object.assign(target, {
-        subscribe: events.subscribe.bind(events),
-        waitFor: events.waitFor.bind(events),
-        events: events.events.bind(events)
-    });
-}
-export function program(record) {
+export function program(value) {
+    const record = parseProgramSnapshot(value);
     const handle = handles.obtain(`program:${record.reference}`, () => new ProgramHandle(record));
     handle.update(record);
     return handle;
 }
-export function process(record, endpoints = {}) {
+export function process(value, endpoints = {}) {
+    const record = parseProcessSnapshot(value);
     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");
+export function endpoint(value) {
+    const reference = parseEndpointReference(value);
     const owner = process(reference.process);
     return reference.kind === "server" ? owner.server : owner.client;
 }
@@ -499,7 +512,9 @@ function endpointHandle(owner, kind, preferred) {
     return handles.obtain(`endpoint:${owner.reference}:${kind}`, () => preferred ?? (kind === "server" ? new ServerEndpointHandle(owner) : new ClientEndpointHandle(owner)));
 }
 export function window(target) {
-    return new WindowHandle(target);
+    const handle = new WindowHandle(target);
+    windowTargets.set(handle, target);
+    return handle;
 }
 export function localWindow(target) {
     return new LocalWindowHandle(target);