@phreshos/client 0.1.24 → 0.1.25

package/README.md

@@ -51,17 +51,17 @@ requests; subscriptions receive only future publications and never replay a
 retained value.
 
 Permission decisions belong to the current Program, not to the desktop System.
-They are available from a Program handle and flattened through `current` as the
+They are available from a Program handle and flattened through `context` as the
 same canonical capability:
 
 ```ts
-const program = await current.program()
+const program = await context.program()
 
 await program.permission.granted("pointer")
-await current.permission.request("pointer")
-await current.permission.timeout(5_000).request("pointer")
+await context.permission.request("pointer")
+await context.permission.timeout(5_000).request("pointer")
 
-current.permission === program.permission
+context.permission === program.permission
 ```
 
 `granted()` reads the effective decision without prompting. `request()` asks
@@ -98,13 +98,13 @@ into the endpoint. Identity, Theme, Process, Window, readiness, lifecycle, and
 application values enter only in response to an explicit request or a live
 registration made by Program code.
 
-`Current` combines navigation into the executing Client's Process with its
+`Context` combines navigation into the executing Client's Process with its
 Channel. The paired Server is explicitly named as
-`current.server`; its publishing, asking, existence, readiness, start, and stop
-operations never masquerade as properties of `current`. `current.stop()` stops
+`context.server`; its publishing, asking, existence, readiness, start, and stop
+operations never masquerade as properties of `context`. `context.stop()` stops
 the executing Client, while complete Process exit remains available only
-through `current.process()`. It is the canonical Process-owned handle, so
-`current.server === (await current.process()).server`.
+through `context.process()`. It is the canonical Process-owned handle, so
+`context.server === (await context.process()).server`.
 Endpoint `process()` navigation is asynchronous; contextual ownership is
 requested only when navigation needs it and then retained by the SDK.
 
@@ -121,7 +121,7 @@ absence or incarnation loss rejects without turning the boundary into a waiter.
 The package provides two contextual runtime entry points:
 
 ```ts
-import { system, current } from "@phreshos/client"
+import { system, context } from "@phreshos/client"
 ```
 
 It also re-exports the shared Core runtime classes—`Program`, `Process`,
@@ -131,11 +131,11 @@ them. These are the same domain classes used by the Server SDK, so
 `ClientTraffic`, is a type-only capability owned by Client and has no
 independent `instanceof` identity.
 
-The current Client's Channel is composed directly into `current`. Its
+The executing Client's Channel is composed directly into `context`. Its
 subscription tools receive events addressed to this Client, while `publish()`
 emits outward from this Client without choosing a destination. Existence,
-readiness, and lifecycle operations belong to `current.server`,
-`current.stop()`, or an explicit Endpoint handle.
+readiness, and lifecycle operations belong to `context.server`,
+`context.stop()`, or an explicit Endpoint handle.
 
 An Endpoint handle is also a selective source: `endpoint.subscribe()` follows
 destinationless events emitted by that Endpoint. Its `traffic` property remains
@@ -151,7 +151,7 @@ They deliberately omit `install()` and `fork()`, and their `Storage` values neve
 expose native filesystem paths. Every Client-side Window handle exposes the same
 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
+not change Server state. `context.window` is only convenient access to the
 executing Client's canonical Window; it has no additional authority.
 
 A Client may uninstall only its own Program. The operation is an async
@@ -186,9 +186,9 @@ two independent operations and can expose an intermediate state remotely.
 An `under` or `over` representation may request one local system-rendered Surface:
 
 ```ts
-await current.window.local.surface.set({ duration: 240, easing: "ease-out", wait: true })
+await context.window.local.surface.set({ duration: 240, easing: "ease-out", wait: true })
 
-await current.window.local.surface.remove({ duration: 180, easing: "ease-in" })
+await context.window.local.surface.remove({ duration: 180, easing: "ease-in" })
 ```
 
 The desktop holds local state only for the lifetime of that iframe

package/dist/{current.d.ts → context.d.ts}

@@ -1,14 +1,14 @@
 import { type Channel } from "./channel.js";
 import { Client, Server, type Process, type Program, type Window } from "./domain.js";
-/** The current Process's canonical Server handle. */
-export type CurrentServer<Events extends object = {}> = Server<Events>;
-/** Current Client context: its inbound Channel, owner hierarchy, and paired Server. */
-export interface Current<Events extends object = {}> extends Channel<Events>, Pick<Client, "service"> {
-    /** The same Server handle exposed by the current Process. */
-    readonly server: CurrentServer;
-    /** Presentation capability of this current Client. */
+/** The executing Process's canonical Server handle. */
+export type ContextServer<Events extends object = {}> = Server<Events>;
+/** Client runtime context: its inbound Channel, owner hierarchy, and paired Server. */
+export interface Context<Events extends object = {}> extends Channel<Events>, Pick<Client, "service"> {
+    /** 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 current Program. */
+    /** The same permission capability exposed by the executing Program. */
     readonly permission: Program["permission"];
     /** Returns the Process represented by this Client. */
     process(): Promise<Process>;
@@ -18,8 +18,8 @@ export interface Current<Events extends object = {}> extends Channel<Events>, Pi
     program(): Promise<Program>;
     /** Returns one immutable option supplied when this Process was created. */
     option(name: string): Promise<string | undefined>;
-    /** Stops the current Client; rejects when it is the final live Endpoint. */
+    /** Stops the executing Client; rejects when it is the final live Endpoint. */
     stop(): Promise<void>;
 }
-/** Inbound events, owner hierarchy, and paired Server for the current Client. */
-export declare const current: Current;
+/** Inbound events, owner hierarchy, and paired Server for this Client runtime. */
+export declare const context: Context;

package/dist/{current.js → context.js}

@@ -6,7 +6,7 @@ import { endpointService } from "./service.js";
 import { currentProgramPermission } from "./permissions.js";
 const ServerBase = Server;
 const ClientBase = Client;
-class CurrentServerHandle extends ServerBase {
+class ContextServerHandle extends ServerBase {
     owner;
     traffic = new ServerTrafficHandle(null, "server");
     constructor(owner) {
@@ -37,12 +37,12 @@ class CurrentServerHandle extends ServerBase {
     }
 }
 let ownerPromise = null;
-let currentServer;
-let currentClient;
+let contextServer;
+let contextClient;
 function owner() {
     if (!ownerPromise) {
         const resolving = wire.request(["current-process"]).then(answer => {
-            return process(answer[0], { server: currentServer, client: currentClient });
+            return process(answer[0], { server: contextServer, client: contextClient });
         });
         const retained = resolving.catch(error => {
             if (ownerPromise === retained)
@@ -53,8 +53,8 @@ function owner() {
     }
     return ownerPromise;
 }
-currentServer = new CurrentServerHandle(owner);
-class CurrentClientHandle extends ClientBase {
+contextServer = new ContextServerHandle(owner);
+class ContextClientHandle extends ClientBase {
     owner;
     traffic = new TrafficHandle(null, "client");
     window = windowHandle(async () => {
@@ -80,10 +80,10 @@ class CurrentClientHandle extends ClientBase {
     async stop() { await wire.request(["stop-endpoint", undefined, "client"]); }
     service() { return endpointService(null, "client"); }
 }
-currentClient = new CurrentClientHandle(owner);
-class ClientCurrent {
-    server = currentServer;
-    window = currentClient.window;
+contextClient = new ContextClientHandle(owner);
+class ClientContext {
+    server = contextServer;
+    window = contextClient.window;
     permission = currentProgramPermission;
     constructor() {
         bindChannel(this, channel);
@@ -115,5 +115,5 @@ function bindChannel(target, source) {
         disableService: source.disableService.bind(source)
     });
 }
-/** Inbound events, owner hierarchy, and paired Server for the current Client. */
-export const current = new ClientCurrent();
+/** Inbound events, owner hierarchy, and paired Server for this Client runtime. */
+export const context = new ClientContext();

package/dist/main.d.ts

@@ -1,7 +1,7 @@
 export { system, type System } from "./system.js";
 export { type SystemPointer, type PointerEvents, type PointerPosition } from "./pointer.js";
 export { type DesktopEvents, type DesktopSize, type SystemDesktop } from "./desktop.js";
-export { current, type Current, type CurrentServer } from "./current.js";
+export { context, type Context, type ContextServer } from "./context.js";
 export { type Channel, type ChannelCapture, type ChannelEvents, type ChannelMessage } from "./channel.js";
 export { ClientService, ServerService, Service, type ClientServiceChannel, type ServerServiceChannel, type ServiceChannel, type ServiceKey, type ServiceLifecycleEvents } 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";

package/dist/main.js

@@ -1,7 +1,7 @@
 export { system } from "./system.js";
 export {} from "./pointer.js";
 export {} from "./desktop.js";
-export { current } from "./current.js";
+export { context } from "./context.js";
 export {} from "./channel.js";
 export { ClientService, ServerService, Service } from "@phreshos/core";
 export { Client, Endpoint, Process, Program, Server } from "./domain.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phreshos/client",
-  "version": "0.1.24",
+  "version": "0.1.25",
   "description": "The SDK used by a Program's client endpoint.",
   "type": "module",
   "main": "dist/main.js",