@phreshos/react 0.1.11 → 0.1.13

package/README.md

@@ -16,7 +16,7 @@ dependencies.
 
 It provides two kinds of adapter:
 
-- `CurrentProvider` resolves exactly the current values named by its required
+- `ContextProvider` resolves exactly the runtime values named by its required
   `provide` prop, then exposes them synchronously through `useProgram()`,
   `useProcess()`, and `useParent()`.
 - `SystemProvider` subscribes before reading exactly the system values named by its
@@ -33,8 +33,8 @@ It provides two kinds of adapter:
   while `useObserveAnswers()` adapts a Server traffic surface's answer
   observation.
 
-Window needs no React resolution: `current.window` is already a synchronous,
-silent capability object. `CurrentProvider` therefore has no `window` selection
+Window needs no React resolution: `context.window` is already a synchronous,
+silent capability object. `ContextProvider` therefore has no `window` selection
 and the React SDK exposes no pass-through `useWindow()` hook.
 
 The domain state hooks return only mutable state; identity and immutable
@@ -111,13 +111,14 @@ because either SDK was imported, and an unselected system value never enters the
 Client. `pointerPosition` is permission-guarded: selecting it does not request
 permission, and resolution fails unless the Program already holds `pointer`.
 The provider renders its optional fallback, or `null`, until every selected
-value resolves. `useDesktopPreferences()` is a pure state adapter; document
-presentation remains an explicit concern of the consuming interface.
+value resolves. `useDesktopPreferences()` is a pure state adapter. The System
+communicates its effective scheme through the Client iframe, while each Client
+HTML document declares which schemes it supports.
 
 ```tsx
-import { current } from "@phreshos/client"
+import { context } from "@phreshos/client"
 import {
-  CurrentProvider,
+  ContextProvider,
   useProgram,
   useSubscribe
 } from "@phreshos/react"
@@ -125,7 +126,7 @@ import {
 function Counter() {
   const program = useProgram()
 
-  const count = useSubscribe(current, "count", message => {
+  const count = useSubscribe(context, "count", message => {
     return Number(message.payload)
   })
 
@@ -134,14 +135,14 @@ function Counter() {
 
 export default function App() {
   return (
-    <CurrentProvider provide={["program"]} fallback={<p>Loading…</p>} waitServer>
+    <ContextProvider provide={["program"]} fallback={<p>Loading…</p>} waitServer>
       <Counter />
-    </CurrentProvider>
+    </ContextProvider>
   )
 }
 ```
 
-Using a current or system hook outside its provider, or without selecting its
+Using a context or system hook outside its provider, or without selecting its
 value, throws a configuration error. Neither provider supplies an implicit
 "everything" selection, so adding a future capability cannot make it enter an
 existing application.

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

@@ -1,34 +1,34 @@
 import { type ReactNode } from "react";
 import { type Process, type Program } from "@phreshos/client";
 declare const provisionNames: readonly ["program", "process", "parent"];
-/** Resolves only the current handles explicitly selected by the program. */
-export default function CurrentProvider({ children, fallback, provide, waitServer }: CurrentProviderProperties): import("react").FunctionComponentElement<SelectedCurrentProviderProperties>;
+/** Resolves only the runtime handles explicitly selected by the program. */
+export default function ContextProvider({ children, fallback, provide, waitServer }: ContextProviderProperties): import("react").FunctionComponentElement<SelectedContextProviderProperties>;
 /** Returns the current Program selected by the nearest provider. */
 export declare function useProgram(): Program;
 /** Returns the current Process selected by the nearest provider. */
 export declare function useProcess(): Process;
 /** Returns the current Process's selected visible parent. */
 export declare function useParent(): Process | null;
-/** Values that CurrentProvider can resolve. */
-export type CurrentProvisionName = typeof provisionNames[number];
-/** Required non-empty selection of current values. */
-export type CurrentProvision = readonly [CurrentProvisionName, ...CurrentProvisionName[]];
-/** Properties accepted by CurrentProvider. */
-export interface CurrentProviderProperties {
-    /** Content rendered after every selected current handle has resolved. */
+/** Values that ContextProvider can resolve. */
+export type ContextProvisionName = typeof provisionNames[number];
+/** Required non-empty selection of runtime values. */
+export type ContextProvision = readonly [ContextProvisionName, ...ContextProvisionName[]];
+/** Properties accepted by ContextProvider. */
+export interface ContextProviderProperties {
+    /** Content rendered after every selected runtime handle has resolved. */
     readonly children: ReactNode;
     /** Content rendered while selected handles or optional Server readiness resolve. */
     readonly fallback?: ReactNode;
-    /** Exact current values made available to descendant hooks. */
-    readonly provide: CurrentProvision;
+    /** Exact runtime values made available to descendant hooks. */
+    readonly provide: ContextProvision;
     /**
      * Waits for the Process's Server before rendering children.
      * `true` uses the default ten-second deadline; a number sets milliseconds.
      */
     readonly waitServer?: boolean | number;
 }
-type SelectedCurrentProviderProperties = Omit<CurrentProviderProperties, "provide" | "waitServer"> & Readonly<{
-    selection: readonly CurrentProvisionName[];
+type SelectedContextProviderProperties = Omit<ContextProviderProperties, "provide" | "waitServer"> & Readonly<{
+    selection: readonly ContextProvisionName[];
     waitServer: boolean | number;
 }>;
 export {};

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

@@ -1,13 +1,13 @@
 import { createContext, createElement, useContext, useEffect, useMemo, useState } from "react";
-import { current } from "@phreshos/client";
+import { context } from "@phreshos/client";
 const provisionNames = ["program", "process", "parent"];
-const CurrentContext = createContext(null);
-/** Resolves only the current handles explicitly selected by the program. */
-export default function CurrentProvider({ children, fallback = null, provide, waitServer = false }) {
+const RuntimeContext = createContext(null);
+/** Resolves only the runtime handles explicitly selected by the program. */
+export default function ContextProvider({ children, fallback = null, provide, waitServer = false }) {
     const normalized = normalizeProvision(provide);
     const selectionKey = normalized.join("\0");
     const selection = useMemo(() => normalized, [selectionKey]);
-    return createElement(SelectedCurrentProvider, {
+    return createElement(SelectedContextProvider, {
         children,
         fallback,
         key: `${selectionKey}\0${String(waitServer)}`,
@@ -15,12 +15,12 @@ export default function CurrentProvider({ children, fallback = null, provide, wa
         waitServer
     });
 }
-function SelectedCurrentProvider({ children, fallback, selection, waitServer }) {
+function SelectedContextProvider({ children, fallback, selection, waitServer }) {
     const [resolution, setResolution] = useState({ status: "pending" });
     useEffect(() => {
         let active = true;
         setResolution({ status: "pending" });
-        void resolveCurrent(selection, waitServer).then(value => {
+        void resolveContext(selection, waitServer).then(value => {
             if (active)
                 setResolution({ status: "ready", value });
         }, error => {
@@ -33,12 +33,12 @@ function SelectedCurrentProvider({ children, fallback, selection, waitServer })
         return fallback;
     if (resolution.status === "error")
         throw resolution.error;
-    return createElement(CurrentContext.Provider, { value: resolution.value }, children);
+    return createElement(RuntimeContext.Provider, { value: resolution.value }, children);
 }
-async function resolveCurrent(selection, waitServer) {
+async function resolveContext(selection, waitServer) {
     const serverReady = typeof waitServer === "number"
-        ? current.server.waitReady(waitServer)
-        : waitServer ? current.server.waitReady() : undefined;
+        ? context.server.waitReady(waitServer)
+        : waitServer ? context.server.waitReady() : undefined;
     const [entries] = await Promise.all([
         Promise.all(selection.map(resolveProvision)),
         serverReady
@@ -50,9 +50,9 @@ async function resolveCurrent(selection, waitServer) {
 }
 async function resolveProvision(name) {
     switch (name) {
-        case "program": return [name, await current.program()];
-        case "process": return [name, await current.process()];
-        case "parent": return [name, await current.parent()];
+        case "program": return [name, await context.program()];
+        case "process": return [name, await context.process()];
+        case "parent": return [name, await context.parent()];
     }
 }
 /** Returns the current Program selected by the nearest provider. */
@@ -68,22 +68,22 @@ export function useParent() {
     return useProvided("parent");
 }
 function useProvided(name) {
-    const context = useContext(CurrentContext);
-    if (!context)
-        throw new Error(`use${hookName(name)} must be used inside CurrentProvider`);
-    if (!context.provided.has(name))
-        throw new Error(`use${hookName(name)} requires "${name}" in CurrentProvider's provide prop`);
-    return context.values[name];
+    const providedContext = useContext(RuntimeContext);
+    if (!providedContext)
+        throw new Error(`use${hookName(name)} must be used inside ContextProvider`);
+    if (!providedContext.provided.has(name))
+        throw new Error(`use${hookName(name)} requires "${name}" in ContextProvider's provide prop`);
+    return providedContext.values[name];
 }
 function normalizeProvision(provide) {
     if (!Array.isArray(provide) || provide.length === 0)
-        throw new Error("CurrentProvider's provide prop must select at least one current value");
+        throw new Error("ContextProvider's provide prop must select at least one runtime value");
     const selected = new Set();
     for (const name of provide) {
         if (!provisionNames.includes(name))
-            throw new Error(`CurrentProvider cannot provide "${String(name)}"`);
+            throw new Error(`ContextProvider cannot provide "${String(name)}"`);
         if (selected.has(name))
-            throw new Error(`CurrentProvider's provide prop selects "${name}" more than once`);
+            throw new Error(`ContextProvider's provide prop selects "${name}" more than once`);
         selected.add(name);
     }
     return [...selected];

package/dist/main.d.ts

@@ -1,4 +1,4 @@
-export { default as CurrentProvider, useParent, useProcess, useProgram, type CurrentProvision, type CurrentProvisionName, type CurrentProviderProperties } from "./current-provider.js";
+export { default as ContextProvider, useParent, useProcess, useProgram, type ContextProvision, type ContextProvisionName, type ContextProviderProperties } from "./context-provider.js";
 export { default as SystemProvider, usePointerPosition, useDesktopSize, useDesktopPreferences, useSystemAppearance, type SystemProvision, type SystemProvisionName, type SystemProviderProperties } from "./system-provider.js";
 export { default as useSubscribe } from "./use-subscribe.js";
 export { default as useObserve } from "./use-observe.js";

package/dist/main.js

@@ -1,4 +1,4 @@
-export { default as CurrentProvider, useParent, useProcess, useProgram } from "./current-provider.js";
+export { default as ContextProvider, useParent, useProcess, useProgram } from "./context-provider.js";
 export { default as SystemProvider, usePointerPosition, useDesktopSize, useDesktopPreferences, useSystemAppearance } from "./system-provider.js";
 export { default as useSubscribe } from "./use-subscribe.js";
 export { default as useObserve } from "./use-observe.js";

package/dist/use-service-state.d.ts

@@ -1,7 +1,7 @@
-import type { ServiceHandler } from "@phreshos/client";
+import type { Service } from "@phreshos/client";
 /** Live availability of one exact service identity. */
 export type ServiceState = Readonly<{
     enabled: boolean;
 }>;
 /** Explicitly reads and follows one service while this hook is mounted. */
-export default function useServiceState(service: ServiceHandler): ServiceState | undefined;
+export default function useServiceState(service: Service): ServiceState | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phreshos/react",
-  "version": "0.1.11",
+  "version": "0.1.13",
   "description": "React adapters for the Client SDK.",
   "type": "module",
   "main": "dist/main.js",
@@ -47,13 +47,13 @@
     "prepack": "node --run test && node --run build"
   },
   "peerDependencies": {
-    "@phreshos/client": "^0.1.23",
-    "@phreshos/core": "^0.1.22",
+    "@phreshos/client": "^0.1.25",
+    "@phreshos/core": "^0.1.24",
     "react": "^19.2.0"
   },
   "devDependencies": {
-    "@phreshos/client": "^0.1.23",
-    "@phreshos/core": "^0.1.22",
+    "@phreshos/client": "^0.1.25",
+    "@phreshos/core": "^0.1.24",
     "@testing-library/react": "^16.3.0",
     "@types/react": "^19.2.18",
     "@types/react-dom": "^19.2.4",