@phreshos/client 0.1.12 → 0.1.14

package/README.md

@@ -51,11 +51,11 @@ same canonical capability:
 ```ts
 const program = await current.program()
 
-await program.permissions.granted("pointer")
-await current.permissions.request("pointer")
-await current.permissions.timeout(5_000).request("pointer")
+await program.permission.granted("pointer")
+await current.permission.request("pointer")
+await current.permission.timeout(5_000).request("pointer")
 
-current.permissions === program.permissions
+current.permission === program.permission
 ```
 
 `granted()` reads the effective decision without prompting. `request()` asks
@@ -63,6 +63,20 @@ only when no known decision can answer immediately and returns `null` if its
 deadline expires. The desktop remains the internal enforcement boundary, but
 permission ownership does not alter the public shape of `host`.
 
+The Client Host exposes only direct, exact Service handles. Creating a handle
+does not read or start the Service and exposes no Service registry:
+
+```ts
+const service = host.service({
+  program: "counter",
+  endpoint: "server",
+  name: "state"
+})
+
+await service.waitReady()
+if (await service.enabled()) await service.channel.ask("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
 and returned as `null`; no cross-Program Process handle enters the client. If
@@ -133,6 +147,21 @@ authoritative, subscribable Window capability and its `window.local` physical
 representation on this desktop. Local reads and updates have no events and do
 not change Server state. `current.window` is only convenient access to the
 executing Client's canonical Window; it has no additional authority.
+
+A Program may converge its Clients on one named Process without a manual
+`find()`/`create()` race:
+
+```ts
+const shared = await program.process.findOrCreate({
+  name: "shared-server",
+  server: true,
+  client: false
+})
+```
+
+The authoritative Core returns the existing Process only when its normalized
+launch is equivalent; a conflicting launch rejects without changing it.
+
 When both dimensions must change, `setGeometry({ position, size })` commits
 them through one authoritative request and produces one `geometry` event.
 Calling `move()` and `resize()` sequentially or through `Promise.all()` remains

package/dist/channel.d.ts

@@ -1,4 +1,4 @@
-import type { Channel as CoreChannel, ChannelCapture as CoreChannelCapture, ChannelEvents as CoreChannelEvents, ChannelMessage as CoreChannelMessage, ServiceDefinition } from "@phreshos/core";
+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>;
@@ -7,6 +7,6 @@ export type ChannelEvents<Events extends object> = CoreChannelEvents<Events, End
 /** 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, ServiceDefinition> {
+export interface Channel<Events extends object = {}> extends CoreChannel<Events, Endpoint | null> {
 }
 export declare const channel: Channel;

package/dist/channel.js

@@ -12,7 +12,7 @@ class ClientChannel extends Events {
     publish(event, payload = undefined) {
         wire.send("end-host", "emit", event, payload);
     }
-    async enableService(definition) { await enableCurrentService(definition); }
+    async enableService(name) { await enableCurrentService(name); }
     async disableService() { await disableCurrentService(); }
 }
 function message(value) {

package/dist/current.d.ts

@@ -9,7 +9,7 @@ export interface Current<Events extends object = {}> extends Channel<Events>, Pi
     /** Presentation capability of this current Client. */
     readonly window: Window;
     /** The same permission capability exposed by the current Program. */
-    readonly permissions: Program["permissions"];
+    readonly permission: Program["permission"];
     /** Returns the Process represented by this Client. */
     process(): Promise<Process>;
     /** Returns the accessible parent Process, or `null` when none exists. */

package/dist/current.js

@@ -3,7 +3,7 @@ import Deadline from "./deadline.js";
 import { Client, Server, ServerTrafficHandle, TrafficHandle, bindEvents, endpointEvents, process, program, window as windowHandle } from "./domain.js";
 import wire from "./wire.js";
 import { endpointService } from "./service.js";
-import { currentProgramPermissions } from "./permissions.js";
+import { currentProgramPermission } from "./permissions.js";
 const ServerBase = Server;
 const ClientBase = Client;
 class CurrentServerHandle extends ServerBase {
@@ -41,7 +41,7 @@ let currentServer;
 let currentClient;
 function owner() {
     if (!ownerPromise) {
-        const resolving = wire.request(["process"]).then(answer => {
+        const resolving = wire.request(["current-process"]).then(answer => {
             return process(answer[0], { server: currentServer, client: currentClient });
         });
         const retained = resolving.catch(error => {
@@ -84,7 +84,7 @@ currentClient = new CurrentClientHandle(owner);
 class ClientCurrent {
     server = currentServer;
     window = currentClient.window;
-    permissions = currentProgramPermissions;
+    permission = currentProgramPermission;
     constructor() {
         bindChannel(this, channel);
     }
@@ -94,7 +94,7 @@ class ClientCurrent {
         return answer[0] ? process(answer[0]) : null;
     }
     async program() {
-        const answer = await wire.request(["program"]);
+        const answer = await wire.request(["current-program"]);
         return program(answer[0]);
     }
     async option(name) {

package/dist/domain.d.ts

@@ -1,9 +1,20 @@
-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 LocalWindow, type Permissions, 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 { 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 Exit, type Launch, type LocalWindow, 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 Events from "./events.js";
 export interface HandleAddress {
     identity: string;
     reference: string;
 }
+export interface EndpointDeclarationRecord {
+    start: boolean;
+    hasService: boolean;
+}
+export interface ClientDeclarationRecord extends EndpointDeclarationRecord {
+    title: string | null;
+    size: Size | null;
+    position: Position | null;
+    layer: ClientDeclaration["layer"];
+    minimize: boolean | null;
+}
 export interface ProgramRecord {
     reference: string;
     identity: string;
@@ -11,8 +22,8 @@ export interface ProgramRecord {
     name: string;
     version: string | null;
     description: string | null;
-    server: EndpointDeclaration | null;
-    client: ClientDeclaration | null;
+    server: EndpointDeclarationRecord | null;
+    client: ClientDeclarationRecord | null;
 }
 export interface ProcessRecord {
     reference: string;
@@ -30,19 +41,28 @@ export interface EndpointReference {
 }
 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"> & {
+export type Program<Events extends object = {}> = Omit<CoreProgram<Events>, "process"> & {
     /** Effective permission decisions owned by this Program. */
-    readonly permissions: Permissions;
+    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. */
-    processes(): Promise<Process[]>;
+    list(): Promise<Process[]>;
     /** Returns the earliest-started visible live Process, or `null` when none exist. */
-    firstProcess(): Promise<Process | null>;
+    first(): Promise<Process | null>;
     /** Returns the latest-started visible live Process, or `null` when none exist. */
-    lastProcess(): Promise<Process | null>;
+    last(): Promise<Process | null>;
     /** Finds a visible live Process by runtime identity or Program-local name. */
-    getProcess(identityOrName: string): Promise<Process | null>;
+    find(identityOrName: string): Promise<Process | null>;
     /** Creates one Process of this same Program. */
-    createProcess(launch?: Launch): Promise<Process>;
+    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<Events extends object = {}> = Omit<CoreProcess<Events>, "server" | "client" | "program" | "parent"> & {

package/dist/domain.js

@@ -5,7 +5,7 @@ import HandleRegistry from "./handle-registry.js";
 import { area, sql, store } from "./storage.js";
 import wire from "./wire.js";
 import { endpointService } from "./service.js";
-import { currentProgramPermissions } from "./permissions.js";
+import { currentProgramPermission } from "./permissions.js";
 const handles = new HandleRegistry();
 const ProgramBase = CoreProgram;
 const ProcessBase = CoreProcess;
@@ -19,43 +19,31 @@ class ProgramHandle extends ProgramBase {
     store = store();
     logs = sql("logs");
     database = sql("database");
-    permissions = currentProgramPermissions;
+    permission = currentProgramPermission;
+    process;
     record;
     constructor(record) {
         super();
         this.identity = record.identity;
         this.reference = record.reference;
         this.record = record;
-        bindEvents(this, scoped("host-end", record.reference, programEvent));
+        this.process = new ProgramProcessHandle(record.reference);
+        bindEvents(this, scoped("program-host", 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 server() {
+        return this.record.server ? declaration("server", this.record.server) : null;
+    }
+    get client() {
+        return this.record.client ? clientDeclaration(this.record.client) : null;
+    }
     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"]);
-        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", undefined, identityOrName]);
-        return answer[0] ? process(answer[0]) : null;
-    }
-    async createProcess(launch = {}) {
-        const answer = await wire.request(["create-process", undefined, launch]);
-        return process(answer[0]);
-    }
     async icon(size = "medium") {
         const answer = await wire.request(["icon", size]);
         return new Blob([Uint8Array.from(answer[0])], { type: "image/png" });
@@ -66,8 +54,58 @@ class ProgramHandle extends ProgramBase {
     }
     async uninstall(everything = false) { await wire.request(["uninstall", undefined, everything]); }
     async forget() { await wire.request(["forget"]); }
+}
+function declaration(endpoint, record) {
+    return Object.freeze({
+        start: record.start,
+        hasService: () => record.hasService,
+        docs: () => endpointDocs(endpoint, record.hasService)
+    });
+}
+function clientDeclaration(record) {
+    return Object.freeze({
+        ...declaration("client", record),
+        title: record.title,
+        size: record.size,
+        position: record.position,
+        layer: record.layer,
+        minimize: record.minimize
+    });
+}
+async function endpointDocs(endpoint, declared) {
+    if (!declared)
+        return null;
+    const answer = await wire.request(["endpoint-docs", endpoint]);
+    return answer[0];
+}
+class ProgramProcessHandle {
+    constructor(program) {
+        bindEvents(this, scoped("program-process", program, programProcessEvent));
+    }
+    async list() {
+        const answer = await wire.request(["program-process-list"]);
+        return answer[0].map(record => process(record));
+    }
+    async first() {
+        return chronological(await this.list())[0] ?? null;
+    }
+    async last() {
+        return chronological(await this.list()).at(-1) ?? null;
+    }
+    async find(identityOrName) {
+        const answer = await wire.request(["program-process-find", identityOrName]);
+        return answer[0] ? process(answer[0]) : null;
+    }
+    async create(launch = {}) {
+        const answer = await wire.request(["program-process-create", launch]);
+        return process(answer[0]);
+    }
+    async findOrCreate(launch) {
+        const answer = await wire.request(["program-process-find-or-create", launch]);
+        return process(answer[0]);
+    }
     async exitAll() {
-        const answer = await wire.request(["exit-all"]);
+        const answer = await wire.request(["program-process-exit-all"]);
         return answer[0];
     }
 }
@@ -333,13 +371,16 @@ function unscoped(subject, values) {
         return values;
     return values[0] === subject ? values.slice(1) : null;
 }
-function programEvent(event, values) {
+function programProcessEvent(event, values) {
     if (event === "endpointStart" || event === "endpointStop")
         return lifecycleEndpoint(values[0], values[1]);
-    if (event === "processCreate")
+    if (event === "create")
         return process(values[0]);
-    if (event === "processExit")
+    if (event === "exit")
         return { process: process(values[0]), ...exit(values[1], values[2]) };
+    return undefined;
+}
+function programEvent(event, values) {
     if (event === "uninstall")
         return { everythingRemoved: values[0] === true };
     return undefined;

package/dist/host.d.ts

@@ -1,6 +1,11 @@
-import type { ClientServiceHandler, ServedFile, ServerServiceHandler, Theme, ThemeProperties } from "@phreshos/core";
+import type { ClientServiceHandler, ServedFile, ServerServiceHandler, ServiceKey, Theme, ThemeProperties } from "@phreshos/core";
 import { type HostPointer } from "./pointer.js";
 import { type HostDesktop } from "./desktop.js";
+type ServiceEndpoint = ServiceKey["endpoint"];
+type ServiceAddress<Endpoint extends ServiceEndpoint> = Omit<ServiceKey, "endpoint"> & Readonly<{
+    endpoint: Endpoint;
+}>;
+type ServiceHandle<Endpoint extends ServiceEndpoint, Events extends object> = Endpoint extends "server" ? ServerServiceHandler<Events> : ClientServiceHandler<Events>;
 /** Desktop capabilities structurally available to a Client endpoint. */
 export interface Host {
     /** Read-only system Theme explicitly read from and observed through the desktop host. */
@@ -13,18 +18,13 @@ export interface Host {
     serve(value: unknown): Promise<ServedFile>;
     /** Performs an unrestricted server-side fetch on behalf of this Client. */
     fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
-    /** Returns a stable handle for one exact Server service identity. */
-    service<ServiceEvents extends object = {}>(key: {
-        program: string;
-        endpoint: "server";
-        name: string;
-    }): ServerServiceHandler<ServiceEvents>;
-    /** Returns a stable handle for one exact Client service identity. */
-    service<ServiceEvents extends object = {}>(key: {
-        program: string;
-        endpoint: "client";
-        name: string;
-    }): ClientServiceHandler<ServiceEvents>;
+    /** Returns a precisely typed stable handle for either service endpoint. */
+    service<Endpoint extends ServiceEndpoint>(key: ServiceAddress<Endpoint>): ServiceHandle<Endpoint, {}>;
+    /** Returns a typed stable handle for one exact Server service identity. */
+    service<ServiceEvents extends object>(key: ServiceAddress<"server">): ServerServiceHandler<ServiceEvents>;
+    /** Returns a typed stable handle for one exact Client service identity. */
+    service<ServiceEvents extends object>(key: ServiceAddress<"client">): ClientServiceHandler<ServiceEvents>;
 }
 /** Desktop capabilities available to this Client. */
 export declare const host: Host;
+export {};

package/dist/host.js

@@ -3,11 +3,12 @@ import ClientTheme from "./theme.js";
 import wire from "./wire.js";
 import ClientPointer, {} from "./pointer.js";
 import ClientDesktop, {} from "./desktop.js";
-import { service as serviceHandle } from "./service.js";
+import { prepareService } from "./service.js";
 class ClientHost {
     theme = new ClientTheme();
     desktop = new ClientDesktop();
     pointer = new ClientPointer();
+    service(key) { return prepareService(key); }
     async serve(value) {
         const source = content(value);
         const channel = new MessageChannel();
@@ -78,9 +79,6 @@ class ClientHost {
         });
         return response;
     }
-    service(key) {
-        return serviceHandle(key);
-    }
 }
 function requestHeaders(normalized, supplied) {
     if (!supplied)

package/dist/main.d.ts

@@ -4,5 +4,5 @@ export { type DesktopEvents, type DesktopSize, type HostDesktop } from "./deskto
 export { current, type Current, type CurrentServer } from "./current.js";
 export { type Channel, type ChannelCapture, type ChannelEvents, type ChannelMessage } from "./channel.js";
 export { ClientServiceHandler, ServerServiceHandler, ServiceHandler, type ClientServiceChannel, type ServerServiceChannel, type ServiceChannel, type ServiceKey, type ServiceLifecycleEvents } from "@phreshos/core";
-export { Client, Endpoint, Process, Program, Server, type Window, type AnswerCapture, type AnswerMessage, type AnswerObserver, type AskCapture, type AskMessage, type AskObserver, type ClientTraffic, type EndpointTraffic, type ServerTraffic, type TrafficCapture, type TrafficEvents, type TrafficMessage } from "./domain.js";
-export type { Askable, Capture, Captures, ClientDeclaration, Cleanup, DirectoryStat, EndpointDeclaration, EntryStat, EventMessage, EventName, EventObserver, EventOptions, EventSubscriber, Exit, FileStat, Launch, LaunchClient, Layer, LogKind, LogRecord, LogSource, Message, OtherStat, Outcome, PermissionDecision, Permissions, Position, ProgramArea, ProgramEvents, ProgramProcessExit, ProgramSql, ProgramStore, ProcessEvents, Publishable, ServedFile, Size, Subscribable, SubscribableEvents, SubscribableFallback, TimedAskable, TimedPermissions, Timeoutable, Theme, ThemeEvents, ThemeProperties, Value, WritableTheme, WindowEvents, WindowGeometry, WindowLayer, WindowState, Easing, LocalWindow, LocalWindowSurface, SurfaceSettings, Transaction } from "@phreshos/core";
+export { Client, Endpoint, Process, Program, Server, type Window, type ProgramProcess, type AnswerCapture, type AnswerMessage, type AnswerObserver, type AskCapture, type AskMessage, type AskObserver, type ClientTraffic, type EndpointTraffic, type ServerTraffic, type TrafficCapture, type TrafficEvents, type TrafficMessage } from "./domain.js";
+export type { Askable, Capture, Captures, ClientDeclaration, Cleanup, DirectoryStat, EndpointDeclaration, EntryStat, EventMessage, EventName, EventObserver, EventOptions, EventSubscriber, Exit, FileStat, Launch, LaunchClient, Layer, LogKind, LogRecord, LogSource, Message, OtherStat, Outcome, PermissionDecision, Permission, Position, ProgramArea, ProgramEvents, ProgramProcessEvents, ProgramProcessExit, ProgramSql, ProgramStore, ProcessEvents, Publishable, ServedFile, Size, Subscribable, SubscribableEvents, SubscribableFallback, TimedAskable, TimedPermission, Timeoutable, Theme, ThemeEvents, ThemeProperties, Value, WritableTheme, WindowEvents, WindowGeometry, WindowLayer, WindowState, Easing, LocalWindow, LocalWindowSurface, SurfaceSettings, Transaction } from "@phreshos/core";

package/dist/permissions.d.ts

@@ -1,10 +1,10 @@
-import type { PermissionDecision, PermissionName, Permissions, TimedPermissions } from "@phreshos/core";
+import type { Permission, PermissionDecision, PermissionName, TimedPermission } from "@phreshos/core";
 /** Client access to the current Program's effective permission decisions. */
-export default class ClientPermissions implements Permissions {
+export default class ClientPermission implements Permission {
     granted(name: PermissionName): Promise<PermissionDecision>;
     request(name: PermissionName): Promise<PermissionDecision>;
-    timeout(milliseconds: number): TimedPermissions;
+    timeout(milliseconds: number): TimedPermission;
     private requestWithin;
 }
 /** The one Program-owned permission capability visible in this isolated Client. */
-export declare const currentProgramPermissions: ClientPermissions;
+export declare const currentProgramPermission: ClientPermission;

package/dist/permissions.js

@@ -1,7 +1,7 @@
 import wire from "./wire.js";
 const defaultPermissionTimeout = 30_000;
 /** Client access to the current Program's effective permission decisions. */
-export default class ClientPermissions {
+export default class ClientPermission {
     async granted(name) {
         const answer = await wire.request(["permission-granted", name]);
         return answer[0];
@@ -20,4 +20,4 @@ export default class ClientPermissions {
     }
 }
 /** The one Program-owned permission capability visible in this isolated Client. */
-export const currentProgramPermissions = new ClientPermissions();
+export const currentProgramPermission = new ClientPermission();

package/dist/service.d.ts

@@ -1,13 +1,13 @@
-import { type ClientServiceHandler, type ServerServiceHandler, type ServiceDefinition, type ServiceHandler, type ServiceKey } from "@phreshos/core";
+import { type ClientServiceHandler, type ServerServiceHandler, type ServiceHandler, type ServiceKey } from "@phreshos/core";
 import type { HandleAddress } from "./domain.js";
-export declare function service<EventsMap extends object = {}>(key: ServiceKey & {
+export declare function prepareService<EventsMap extends object = {}>(key: ServiceKey & {
     endpoint: "server";
 }): ServerServiceHandler<EventsMap>;
-export declare function service<EventsMap extends object = {}>(key: ServiceKey & {
+export declare function prepareService<EventsMap extends object = {}>(key: ServiceKey & {
     endpoint: "client";
 }): ClientServiceHandler<EventsMap>;
-export declare function service(key: ServiceKey): ServiceHandler;
-export declare function enableCurrentService(definition: ServiceDefinition): Promise<void>;
+export declare function prepareService(key: ServiceKey): ServiceHandler;
+export declare function enableCurrentService(name: string): Promise<void>;
 export declare function disableCurrentService(): Promise<void>;
 export declare function endpointService<EventsMap extends object = {}>(target: HandleAddress | null, endpoint: "server"): Promise<ServerServiceHandler<EventsMap> | null>;
 export declare function endpointService<EventsMap extends object = {}>(target: HandleAddress | null, endpoint: "client"): Promise<ClientServiceHandler<EventsMap> | null>;

package/dist/service.js

@@ -46,47 +46,43 @@ class ClientChannelHandle extends Events {
 }
 class ServerHandler extends ServerServiceBase {
     key;
-    program;
-    endpoint = "server";
     name;
     channel;
     constructor(key) {
         super();
         this.key = key;
-        this.program = key.program;
         this.name = key.name;
         this.channel = new ServerChannelHandle(key);
         bindEvents(this, new Events(...serviceEvents(key, "lifecycle")));
     }
-    async disabled() {
-        const answer = await wire.request(["service-disabled", this.key]);
+    async enabled() {
+        const answer = await wire.request(["service-enabled", this.key]);
         return answer[0];
     }
-    async docs() {
-        const answer = await wire.request(["service-docs", this.key]);
-        return answer[0];
+    async waitReady(timeout) {
+        await wire.request(["service-wait-ready", this.key, timeout], timeout);
     }
 }
 class ClientHandler extends ClientServiceBase {
     key;
-    program;
-    endpoint = "client";
     name;
     channel;
     constructor(key) {
         super();
         this.key = key;
-        this.program = key.program;
         this.name = key.name;
         this.channel = new ClientChannelHandle(key);
         bindEvents(this, new Events(...serviceEvents(key, "lifecycle")));
     }
-    async disabled() {
-        const answer = await wire.request(["service-disabled", this.key]);
+    async enabled() {
+        const answer = await wire.request(["service-enabled", this.key]);
         return answer[0];
     }
+    async waitReady(timeout) {
+        await wire.request(["service-wait-ready", this.key, timeout], timeout);
+    }
 }
-export function service(key) {
+export function prepareService(key) {
     if (!isServiceKey(key))
         throw new Error("A complete service key is required");
     const normalized = Object.freeze({ program: key.program, endpoint: key.endpoint, name: key.name });
@@ -97,15 +93,15 @@ export function service(key) {
             : new ClientHandler(normalized);
     });
 }
-export async function enableCurrentService(definition) {
-    await wire.request(["enable-service", definition]);
+export async function enableCurrentService(name) {
+    await wire.request(["enable-service", name]);
 }
 export async function disableCurrentService() {
     await wire.request(["disable-service"]);
 }
 export async function endpointService(target, endpoint) {
     const answer = await wire.request(["endpoint-service", target, endpoint]);
-    return answer[0] ? service(answer[0]) : null;
+    return answer[0] ? prepareService(answer[0]) : null;
 }
 function serviceEvents(key, scope) {
     return [

package/dist/theme.js

@@ -5,28 +5,14 @@ import wire from "./wire.js";
 export default class ClientTheme extends Events {
     constructor() {
         super((event, listener, impossible) => wire.on("host-theme", event, value => {
-            if (isObject(value))
-                listener(createThemeSnapshot(value));
+            listener(createThemeSnapshot(value));
         }, null, impossible), observer => wire.onAll("host-theme", (event, value) => {
-            if (typeof event === "string" && isObject(value))
+            if (typeof event === "string")
                 observer(event, createThemeSnapshot(value));
         }));
     }
     async snapshot() {
-        const answer = await wire.request(["theme"]);
-        if (!isObject(answer[0]))
-            throw new Error("The desktop returned an invalid Theme snapshot");
-        return createThemeSnapshot(answer[0]);
+        const [theme] = await wire.request(["theme"]);
+        return createThemeSnapshot(theme);
     }
 }
-function isObject(value) {
-    if (typeof value !== "object" || value === null || Array.isArray(value))
-        return false;
-    const theme = value;
-    const surface = theme.surface;
-    return typeof theme.background === "string" && typeof theme.foreground === "string" && typeof theme.accent === "string"
-        && typeof theme.spacing === "number" && typeof theme.radius === "number"
-        && typeof surface === "object" && surface !== null
-        && typeof surface.grain === "number" && typeof surface.animation === "number"
-        && typeof surface.backdrop === "number" && typeof surface.opacity === "number";
-}

package/dist/wire.js

@@ -62,7 +62,7 @@ class Wire {
     /** Resolves this endpoint's Process address only for operations that need it. */
     identity() {
         if (!this.identityPromise) {
-            const resolving = this.request(["process"]).then(value => {
+            const resolving = this.request(["current-process"]).then(value => {
                 const [record] = value;
                 if (typeof record?.identity !== "string" || typeof record.reference !== "string") {
                     throw new Error("The desktop returned an invalid Process identity");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phreshos/client",
-  "version": "0.1.12",
+  "version": "0.1.14",
   "description": "The SDK used by a Program's client endpoint.",
   "type": "module",
   "main": "dist/main.js",
@@ -41,18 +41,19 @@
     "clean": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\"",
     "check": "tsc --noEmit",
     "build": "node --run clean && tsc --noEmit false --outDir dist --rootDir source",
+    "verify:completions": "node scripts/verify-completions.mjs",
     "verify:package": "node scripts/verify-package.mjs",
-    "verify": "node --run check && node --run build && node --run verify:package",
+    "verify": "node --run check && node --run verify:completions && node --run build && node --run verify:package",
     "prepack": "node --run build"
   },
   "peerDependencies": {
-    "@phreshos/core": "^0.1.8"
+    "@phreshos/core": "^0.1.11"
   },
   "dependencies": {
     "@msgpack/msgpack": "^3.1.3"
   },
   "devDependencies": {
-    "@phreshos/core": "^0.1.8",
+    "@phreshos/core": "^0.1.11",
     "typescript": "^6.0.3"
   }
 }