@phreshos/react 0.1.17 → 0.1.19

package/README.md

@@ -20,47 +20,45 @@ domain state.
 ## Providers
 
 ```tsx
-import { ContextProvider, SystemProvider } from "@phreshos/react"
-
-<SystemProvider
-  appearance={system.appearance}
-  desktopSurface={system.desktop.surface}
-  desktopPointer={system.desktop.pointer}
-  desktopPreferences={system.desktop.preferences}
->
-  <ContextProvider
-    program={() => context.program()}
-    process={() => context.process()}
-    parent={() => context.process().then(process => process.parent())}
-  >
-    {children}
-  </ContextProvider>
+import { ContextProvider, DesktopProvider, SystemProvider } from "@phreshos/react"
+
+<SystemProvider system={system}>
+  <DesktopProvider desktop={desktop}>
+    <ContextProvider context={context}>
+      {children}
+    </ContextProvider>
+  </DesktopProvider>
 </SystemProvider>
 ```
 
-Each provider accepts explicitly selected sources and resolves only those
-values. A provider requires at least one source; mounting it does not fetch an
-entire runtime implicitly.
+Each provider receives one complete Core contract. The three roots remain
+separate: global System, current Client Context, and Client Desktop.
 
 ## Hooks
 
 Context hooks expose the supplied handles:
 
+- `useContext()`
 - `useProgram()`
 - `useProcess()`
 - `useParent()`
 
-System hooks expose the supplied live snapshots:
+System hooks expose the System and its live Appearance:
 
+- `useSystem()`
 - `useSystemAppearance()`
+
+Desktop hooks expose the Desktop and its live state:
+
+- `useDesktop()`
 - `useDesktopSurface()`
-- `useDesktopPointer()`
 - `useDesktopPreferences()`
 
 State hooks compose one explicit read with future events:
 
 - `useProgramState()`
 - `useProcessState()`
+- `useEndpointState()`
 - `useServiceState()`
 - `useWindowState()`
 

package/dist/context-provider.d.ts

@@ -1,30 +1,23 @@
 import { type ReactNode } from "react";
-import type { Process, Program } from "@phreshos/core";
-/** Resolves only the runtime handles supplied by the surrounding runtime. */
-export default function ContextProvider({ children, fallback, parent, process, program }: ContextProviderProperties): string | number | bigint | boolean | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<ReactNode> | Promise<string | number | bigint | boolean | import("react").ReactPortal | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | import("react").FunctionComponentElement<import("react").ProviderProps<Partial<Readonly<{
-    program: Program;
-    process: Process;
-    parent: Process | null;
-}>> | null>> | null;
-/** Returns the current Program supplied by the nearest provider. */
+import type { ClientContext, Process, Program } from "@phreshos/core";
+import LiveSnapshot from "./live-snapshot.js";
+/** Provides one complete Client execution Context to a React tree. */
+export default function ContextProvider({ children, context, fallback }: ContextProviderProperties): string | number | bigint | boolean | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<ReactNode> | Promise<string | number | bigint | boolean | import("react").ReactPortal | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | import("react").FunctionComponentElement<import("react").ProviderProps<Readonly<{
+    context: ClientContext;
+    process: LiveSnapshot<Process>;
+    program: LiveSnapshot<Program>;
+    parent: LiveSnapshot<Process | null>;
+}> | null>> | null;
+/** Returns the complete Client Context supplied by the nearest provider. */
+export declare function useContext(): ClientContext;
+/** Returns the current Program once it resolves. */
 export declare function useProgram<Handle extends Program = Program>(): Handle;
-/** Returns the current Process supplied by the nearest provider. */
+/** Returns the current Process once it resolves. */
 export declare function useProcess<Handle extends Process = Process>(): Handle;
-/** Returns the current Process's supplied visible parent. */
+/** Returns the current Process parent once it resolves. */
 export declare function useParent<Handle extends Process = Process>(): Handle | null;
-/** A stable handle or resolver supplied by one runtime integration. */
-export type ContextSource<Value> = Value | (() => Value | PromiseLike<Value>);
-/** Properties accepted by ContextProvider. */
 export type ContextProviderProperties = Readonly<{
-    readonly children: ReactNode;
-    readonly fallback?: ReactNode;
-}> & AtLeastOne<ContextSources>;
-type ContextSources = Readonly<{
-    readonly parent?: ContextSource<Process | null>;
-    readonly process?: ContextSource<Process>;
-    readonly program?: ContextSource<Program>;
+    children: ReactNode;
+    context: ClientContext;
+    fallback?: ReactNode;
 }>;
-type AtLeastOne<Values> = {
-    [Name in keyof Values]-?: Required<Pick<Values, Name>> & Partial<Omit<Values, Name>>;
-}[keyof Values];
-export {};

package/dist/context-provider.js

@@ -1,63 +1,44 @@
-import { createContext, createElement, useContext, useEffect, useMemo, useState } from "react";
-const RuntimeContext = createContext(null);
-/** Resolves only the runtime handles supplied by the surrounding runtime. */
-export default function ContextProvider({ children, fallback = null, parent, process, program }) {
-    const sources = useMemo(() => ({ parent, process, program }), [parent, process, program]);
-    const [resolution, setResolution] = useState({ status: "pending", sources });
-    if (parent === undefined && process === undefined && program === undefined) {
-        throw new Error("ContextProvider requires at least one runtime handle");
-    }
-    useEffect(() => {
-        let active = true;
-        void resolveSources(sources).then(value => {
-            if (active)
-                setResolution({ status: "ready", sources, value });
-        }, error => {
-            if (active)
-                setResolution({ status: "error", sources, error });
-        });
-        return () => { active = false; };
-    }, [sources]);
-    if (resolution.sources !== sources || resolution.status === "pending")
-        return fallback;
-    if (resolution.status === "error")
-        throw resolution.error;
-    return createElement(RuntimeContext.Provider, { value: resolution.value }, children);
-}
-async function resolveSources(sources) {
-    const entries = await Promise.all(contextNames.flatMap(name => {
-        const source = sources[name];
-        return source === undefined ? [] : [resolveSource(name, source)];
-    }));
-    return Object.fromEntries(entries);
-}
-async function resolveSource(name, source) {
-    const value = typeof source === "function" ? source() : source;
-    return [name, await value];
-}
-/** Returns the current Program supplied by the nearest provider. */
+import { createContext, createElement, useContext as useReactContext, useMemo, useSyncExternalStore } from "react";
+import LiveSnapshot from "./live-snapshot.js";
+import useProviderResolution from "./provider-resolution.js";
+const CurrentContext = createContext(null);
+/** Provides one complete Client execution Context to a React tree. */
+export default function ContextProvider({ children, context, fallback = null }) {
+    const value = useMemo(() => ({
+        context,
+        process: fixed(() => context.process()),
+        program: fixed(() => context.program()),
+        parent: fixed(() => context.parent())
+    }), [context]);
+    const stores = useMemo(() => [value.process, value.program, value.parent], [value]);
+    const ready = useProviderResolution(stores);
+    return ready ? createElement(CurrentContext.Provider, { value }, children) : fallback;
+}
+/** Returns the complete Client Context supplied by the nearest provider. */
+export function useContext() {
+    return useValue().context;
+}
+/** Returns the current Program once it resolves. */
 export function useProgram() {
-    return useProvided("program");
+    return useResolved(useValue().program);
 }
-/** Returns the current Process supplied by the nearest provider. */
+/** Returns the current Process once it resolves. */
 export function useProcess() {
-    return useProvided("process");
+    return useResolved(useValue().process);
 }
-/** Returns the current Process's supplied visible parent. */
+/** Returns the current Process parent once it resolves. */
 export function useParent() {
-    return useProvided("parent");
-}
-function useProvided(name) {
-    const context = useContext(RuntimeContext);
-    if (!context)
-        throw new Error(`${hookNames[name]} must be used inside ContextProvider`);
-    if (!(name in context))
-        throw new Error(`${hookNames[name]} requires ContextProvider's ${name} prop`);
-    return context[name];
-}
-const contextNames = ["program", "process", "parent"];
-const hookNames = {
-    parent: "useParent",
-    process: "useProcess",
-    program: "useProgram"
-};
+    return useResolved(useValue().parent);
+}
+function useResolved(store) {
+    return useSyncExternalStore(store.subscribe, store.snapshot, store.snapshot);
+}
+function useValue() {
+    const value = useReactContext(CurrentContext);
+    if (!value)
+        throw new Error("useContext must be used inside ContextProvider");
+    return value;
+}
+function fixed(read) {
+    return new LiveSnapshot(read, () => () => undefined);
+}

package/dist/desktop-provider.d.ts

@@ -0,0 +1,20 @@
+import { type ReactNode } from "react";
+import type { Desktop, DesktopPreferences, DesktopSurfaceSnapshot } from "@phreshos/core";
+import LiveSnapshot from "./live-snapshot.js";
+/** Provides one complete Client Desktop environment to a React tree. */
+export default function DesktopProvider({ children, desktop, fallback }: DesktopProviderProperties): string | number | bigint | boolean | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<ReactNode> | Promise<string | number | bigint | boolean | import("react").ReactPortal | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | import("react").FunctionComponentElement<import("react").ProviderProps<Readonly<{
+    desktop: Desktop;
+    surface: LiveSnapshot<DesktopSurfaceSnapshot>;
+    preferences: LiveSnapshot<DesktopPreferences>;
+}> | null>> | null;
+/** Returns the complete Desktop supplied by the nearest provider. */
+export declare function useDesktop(): Desktop;
+/** Resolves and follows the current Desktop surface. */
+export declare function useDesktopSurface(): DesktopSurfaceSnapshot;
+/** Resolves and follows the effective Desktop preferences. */
+export declare function useDesktopPreferences(): DesktopPreferences;
+export type DesktopProviderProperties = Readonly<{
+    children: ReactNode;
+    desktop: Desktop;
+    fallback?: ReactNode;
+}>;

package/dist/desktop-provider.js

@@ -0,0 +1,35 @@
+import { createContext, createElement, useContext as useReactContext, useMemo, useSyncExternalStore } from "react";
+import LiveSnapshot from "./live-snapshot.js";
+import useProviderResolution from "./provider-resolution.js";
+const DesktopContext = createContext(null);
+/** Provides one complete Client Desktop environment to a React tree. */
+export default function DesktopProvider({ children, desktop, fallback = null }) {
+    const value = useMemo(() => ({
+        desktop,
+        surface: new LiveSnapshot(() => desktop.surface.snapshot(), subscriber => desktop.surface.subscribe("resize", subscriber)),
+        preferences: new LiveSnapshot(() => desktop.preferences.snapshot(), subscriber => desktop.preferences.subscribe("change", subscriber))
+    }), [desktop]);
+    const stores = useMemo(() => [value.surface, value.preferences], [value]);
+    const ready = useProviderResolution(stores);
+    return ready ? createElement(DesktopContext.Provider, { value }, children) : fallback;
+}
+/** Returns the complete Desktop supplied by the nearest provider. */
+export function useDesktop() {
+    return useValue().desktop;
+}
+/** Resolves and follows the current Desktop surface. */
+export function useDesktopSurface() {
+    const store = useValue().surface;
+    return useSyncExternalStore(store.subscribe, store.snapshot, store.snapshot);
+}
+/** Resolves and follows the effective Desktop preferences. */
+export function useDesktopPreferences() {
+    const store = useValue().preferences;
+    return useSyncExternalStore(store.subscribe, store.snapshot, store.snapshot);
+}
+function useValue() {
+    const value = useReactContext(DesktopContext);
+    if (!value)
+        throw new Error("useDesktop must be used inside DesktopProvider");
+    return value;
+}

package/dist/main.d.ts

@@ -1,8 +1,10 @@
-export { default as ContextProvider, useParent, useProcess, useProgram, type ContextSource, type ContextProviderProperties } from "./context-provider.js";
-export { default as SystemProvider, useDesktopPointer, useDesktopSurface, useDesktopPreferences, useSystemAppearance, type SystemProviderProperties } from "./system-provider.js";
+export { default as ContextProvider, useContext, useParent, useProcess, useProgram, type ContextProviderProperties } from "./context-provider.js";
+export { default as SystemProvider, useSystem, useSystemAppearance, type SystemProviderProperties } from "./system-provider.js";
+export { default as DesktopProvider, useDesktop, useDesktopSurface, useDesktopPreferences, type DesktopProviderProperties } from "./desktop-provider.js";
 export { default as useSubscribe } from "./use-subscribe.js";
 export { default as useProgramState, type ProgramState } from "./use-program-state.js";
 export { default as useProcessState, type ProcessState } from "./use-process-state.js";
+export { default as useEndpointState, type EndpointState } from "./use-endpoint-state.js";
 export { default as useServiceState, type ServiceState } from "./use-service-state.js";
 export { default as useWindowState } from "./use-window-state.js";
 export { default as useSubscribeAsks, type AskSubscribable } from "./use-subscribe-asks.js";

package/dist/main.js

@@ -1,8 +1,10 @@
-export { default as ContextProvider, useParent, useProcess, useProgram } from "./context-provider.js";
-export { default as SystemProvider, useDesktopPointer, useDesktopSurface, useDesktopPreferences, useSystemAppearance } from "./system-provider.js";
+export { default as ContextProvider, useContext, useParent, useProcess, useProgram } from "./context-provider.js";
+export { default as SystemProvider, useSystem, useSystemAppearance } from "./system-provider.js";
+export { default as DesktopProvider, useDesktop, useDesktopSurface, useDesktopPreferences } from "./desktop-provider.js";
 export { default as useSubscribe } from "./use-subscribe.js";
 export { default as useProgramState } from "./use-program-state.js";
 export { default as useProcessState } from "./use-process-state.js";
+export { default as useEndpointState } from "./use-endpoint-state.js";
 export { default as useServiceState } from "./use-service-state.js";
 export { default as useWindowState } from "./use-window-state.js";
 export { default as useSubscribeAsks } from "./use-subscribe-asks.js";

package/dist/provider-resolution.d.ts

@@ -0,0 +1,5 @@
+import LiveSnapshot from "./live-snapshot.js";
+type Stores = readonly LiveSnapshot<unknown>[];
+/** Starts a provider's stores as one lifecycle and reports when all are ready. */
+export default function useProviderResolution(stores: Stores): boolean;
+export {};

package/dist/provider-resolution.js

@@ -0,0 +1,28 @@
+import { useEffect, useState } from "react";
+import LiveSnapshot from "./live-snapshot.js";
+/** Starts a provider's stores as one lifecycle and reports when all are ready. */
+export default function useProviderResolution(stores) {
+    const [resolution, setResolution] = useState({ stores, status: "pending" });
+    useEffect(() => {
+        let active = true;
+        void Promise.all(stores.map(store => store.start())).then(() => {
+            if (active)
+                setResolution({ stores, status: "ready" });
+        }, error => {
+            for (const store of stores)
+                store.stop();
+            if (active)
+                setResolution({ stores, status: "error", error });
+        });
+        return () => {
+            active = false;
+            for (const store of stores)
+                store.stop();
+        };
+    }, [stores]);
+    if (resolution.stores !== stores)
+        return false;
+    if (resolution.status === "error")
+        throw resolution.error;
+    return resolution.status === "ready";
+}

package/dist/system-provider.d.ts

@@ -1,38 +1,17 @@
 import { type ReactNode } from "react";
-import type { Appearance, AppearanceSource, DesktopPointerSnapshot, DesktopPointerSource, DesktopPreferences, DesktopPreferencesSource, DesktopSurfaceSnapshot, DesktopSurfaceSource } from "@phreshos/core";
+import type { Appearance, System } from "@phreshos/core";
 import LiveSnapshot from "./live-snapshot.js";
-/** Resolves and follows only the System capabilities supplied by the runtime. */
-export default function SystemProvider({ appearance, children, desktopPointer, desktopPreferences, desktopSurface, fallback }: SystemProviderProperties): string | number | bigint | boolean | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<ReactNode> | Promise<string | number | bigint | boolean | import("react").ReactPortal | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | import("react").FunctionComponentElement<import("react").ProviderProps<SystemStores | null>> | null;
-/** Returns the complete unresolved Appearance and follows authoritative updates. */
+/** Provides one complete global System contract to a React tree. */
+export default function SystemProvider({ children, fallback, system }: SystemProviderProperties): string | number | bigint | boolean | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<ReactNode> | Promise<string | number | bigint | boolean | import("react").ReactPortal | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | import("react").FunctionComponentElement<import("react").ProviderProps<Readonly<{
+    system: System;
+    appearance: LiveSnapshot<Appearance>;
+}> | null>> | null;
+/** Returns the complete global System supplied by the nearest provider. */
+export declare function useSystem(): System;
+/** Resolves and follows the global System Appearance. */
 export declare function useSystemAppearance(): Appearance;
-/** Returns the Desktop surface snapshot and follows future resizes. */
-export declare function useDesktopSurface(): DesktopSurfaceSnapshot;
-/** Returns the Desktop pointer snapshot and follows future movement. */
-export declare function useDesktopPointer(): DesktopPointerSnapshot;
-/** Returns all effective Desktop preferences and follows authoritative updates. */
-export declare function useDesktopPreferences(): DesktopPreferences;
-/** Properties accepted by SystemProvider. */
 export type SystemProviderProperties = Readonly<{
-    readonly children: ReactNode;
-    readonly fallback?: ReactNode;
-}> & AtLeastOne<SystemSources>;
-type SystemSources = Readonly<{
-    readonly appearance?: AppearanceSource;
-    readonly desktopPointer?: DesktopPointerSource;
-    readonly desktopPreferences?: DesktopPreferencesSource;
-    readonly desktopSurface?: DesktopSurfaceSource;
+    children: ReactNode;
+    fallback?: ReactNode;
+    system: System;
 }>;
-type SystemValues = Readonly<{
-    appearance: Appearance;
-    desktopPointer: DesktopPointerSnapshot;
-    desktopPreferences: DesktopPreferences;
-    desktopSurface: DesktopSurfaceSnapshot;
-}>;
-type SystemName = keyof SystemValues;
-type SystemStores = {
-    [Name in SystemName]?: LiveSnapshot<SystemValues[Name]>;
-};
-type AtLeastOne<Values> = {
-    [Name in keyof Values]-?: Required<Pick<Values, Name>> & Partial<Omit<Values, Name>>;
-}[keyof Values];
-export {};

package/dist/system-provider.js

@@ -1,85 +1,29 @@
-import { createContext, createElement, useContext, useEffect, useMemo, useState, useSyncExternalStore } from "react";
+import { createContext, createElement, useContext as useReactContext, useMemo, useSyncExternalStore } from "react";
 import LiveSnapshot from "./live-snapshot.js";
+import useProviderResolution from "./provider-resolution.js";
 const SystemContext = createContext(null);
-/** Resolves and follows only the System capabilities supplied by the runtime. */
-export default function SystemProvider({ appearance, children, desktopPointer, desktopPreferences, desktopSurface, fallback = null }) {
-    const stores = useMemo(() => createStores({
-        appearance,
-        desktopPointer,
-        desktopPreferences,
-        desktopSurface
-    }), [appearance, desktopPointer, desktopPreferences, desktopSurface]);
-    const [resolution, setResolution] = useState({ status: "pending", stores });
-    if (Object.keys(stores).length === 0)
-        throw new Error("SystemProvider requires at least one System capability");
-    useEffect(() => {
-        let active = true;
-        const selected = Object.values(stores);
-        void Promise.all(selected.map(store => store.start())).then(() => {
-            if (active)
-                setResolution({ status: "ready", stores });
-        }, error => {
-            for (const store of selected)
-                store.stop();
-            if (active)
-                setResolution({ status: "error", stores, error });
-        });
-        return () => {
-            active = false;
-            for (const store of selected)
-                store.stop();
-        };
-    }, [stores]);
-    if (resolution.stores !== stores || resolution.status === "pending")
-        return fallback;
-    if (resolution.status === "error")
-        throw resolution.error;
-    return createElement(SystemContext.Provider, { value: stores }, children);
+/** Provides one complete global System contract to a React tree. */
+export default function SystemProvider({ children, fallback = null, system }) {
+    const value = useMemo(() => ({
+        system,
+        appearance: new LiveSnapshot(() => system.appearance.snapshot(), subscriber => system.appearance.subscribe("change", subscriber))
+    }), [system]);
+    const stores = useMemo(() => [value.appearance], [value]);
+    const ready = useProviderResolution(stores);
+    return ready ? createElement(SystemContext.Provider, { value }, children) : fallback;
 }
-/** Returns the complete unresolved Appearance and follows authoritative updates. */
-export function useSystemAppearance() {
-    return useProvided("appearance");
-}
-/** Returns the Desktop surface snapshot and follows future resizes. */
-export function useDesktopSurface() {
-    return useProvided("desktopSurface");
-}
-/** Returns the Desktop pointer snapshot and follows future movement. */
-export function useDesktopPointer() {
-    return useProvided("desktopPointer");
+/** Returns the complete global System supplied by the nearest provider. */
+export function useSystem() {
+    return useValue().system;
 }
-/** Returns all effective Desktop preferences and follows authoritative updates. */
-export function useDesktopPreferences() {
-    return useProvided("desktopPreferences");
-}
-function useProvided(name) {
-    const context = useContext(SystemContext);
-    if (!context)
-        throw new Error(`${hookNames[name]} must be used inside SystemProvider`);
-    const store = context[name];
-    if (!store)
-        throw new Error(`${hookNames[name]} requires SystemProvider's ${name} prop`);
+/** Resolves and follows the global System Appearance. */
+export function useSystemAppearance() {
+    const store = useValue().appearance;
     return useSyncExternalStore(store.subscribe, store.snapshot, store.snapshot);
 }
-function createStores(sources) {
-    const stores = {};
-    const appearance = sources.appearance;
-    const surface = sources.desktopSurface;
-    const pointer = sources.desktopPointer;
-    const preferences = sources.desktopPreferences;
-    if (appearance)
-        stores.appearance = new LiveSnapshot(() => appearance.snapshot(), subscriber => appearance.subscribe("change", subscriber));
-    if (surface)
-        stores.desktopSurface = new LiveSnapshot(() => surface.snapshot(), subscriber => surface.subscribe("resize", subscriber));
-    if (pointer)
-        stores.desktopPointer = new LiveSnapshot(() => pointer.snapshot(), subscriber => pointer.subscribe("move", subscriber));
-    if (preferences)
-        stores.desktopPreferences = new LiveSnapshot(() => preferences.snapshot(), subscriber => preferences.subscribe("change", subscriber));
-    return stores;
+function useValue() {
+    const value = useReactContext(SystemContext);
+    if (!value)
+        throw new Error("useSystem must be used inside SystemProvider");
+    return value;
 }
-const hookNames = {
-    appearance: "useSystemAppearance",
-    desktopPointer: "useDesktopPointer",
-    desktopPreferences: "useDesktopPreferences",
-    desktopSurface: "useDesktopSurface"
-};

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

@@ -0,0 +1,6 @@
+import type { Endpoint } from "@phreshos/core";
+export type EndpointState = Readonly<{
+    exists: boolean;
+}>;
+/** Explicitly reads and follows one Endpoint address while mounted. */
+export default function useEndpointState(endpoint: Endpoint): EndpointState | undefined;

package/dist/use-endpoint-state.js

@@ -0,0 +1,10 @@
+import { useMemo, useSyncExternalStore } from "react";
+import LiveState, { combineCleanups } from "./live-state.js";
+/** Explicitly reads and follows one Endpoint address while mounted. */
+export default function useEndpointState(endpoint) {
+    const state = useMemo(() => new LiveState(async () => ({ exists: await endpoint.exists() }), reduce => combineCleanups(endpoint.lifecycle.subscribe("start", () => reduce(current => setExists(current, true))), endpoint.lifecycle.subscribe("stop", () => reduce(current => setExists(current, false))))), [endpoint]);
+    return useSyncExternalStore(state.subscribe, state.snapshot, state.snapshot);
+}
+function setExists(state, exists) {
+    return state.exists === exists ? state : { exists };
+}

package/dist/use-subscribe.d.ts

@@ -1,4 +1,4 @@
-import type { Captures, Context, ContextMessage, Endpoint, EventMessage, EventName, Subscribable, SubscribableEvents, SubscribableFallback } from "@phreshos/core";
+import type { Captures, EventMessage, EventName, Subscribable, SubscribableEvents, SubscribableFallback } from "@phreshos/core";
 type OpenEvent = string & {};
 type AvailableEvent<Events extends object, Fallback> = EventName<Events> | ([Fallback] extends [never] ? never : OpenEvent);
 type CompatibleEvent<Events extends object, Fallback, Narrowed> = {
@@ -14,12 +14,8 @@ type TargetMessage<Target, Event extends string> = EventMessage<SubscribableEven
 type TargetCapture<Target> = Captures<SubscribableEvents<Target>, SubscribableFallback<Target>>;
 /** Subscribes while mounted and retains the latest named message. */
 export default function useSubscribe<Target extends SubscribableTarget, Event extends TargetEvent<Target>>(target: Target, event: Event): TargetMessage<Target, Event> | undefined;
-export default function useSubscribe<Narrowed = unknown>(target: Endpoint, event: string): Narrowed | undefined;
-export default function useSubscribe<Narrowed extends ContextMessage<unknown> = ContextMessage<unknown>>(target: Context, event: string): Narrowed | undefined;
 /** Subscribes while mounted and retains the latest projected named message. */
 export default function useSubscribe<Target extends SubscribableTarget, Event extends TargetEvent<Target>, Result>(target: Target, event: Event, project: (message: TargetMessage<Target, Event>) => Result): Awaited<Result> | undefined;
-export default function useSubscribe<Narrowed, Result = unknown>(target: Endpoint, event: string, project: (message: Narrowed) => Result): Awaited<Result> | undefined;
-export default function useSubscribe<Narrowed extends ContextMessage<unknown>, Result = unknown>(target: Context, event: string, project: (message: Narrowed) => Result): Awaited<Result> | undefined;
 export default function useSubscribe<Narrowed, Events extends object, Fallback, Result>(target: Subscribable<Events, Fallback>, event: CompatibleEvent<Events, Fallback, Narrowed>, project: (message: Narrowed) => Result): Awaited<Result> | undefined;
 /** Subscribes across every event and retains the latest projected capture. */
 export default function useSubscribe<Target extends SubscribableTarget, Result>(target: Target, project: (capture: TargetCapture<Target>) => Result): Awaited<Result> | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phreshos/react",
-  "version": "0.1.17",
+  "version": "0.1.19",
   "description": "Runtime-neutral React adapters for PhreshOS contracts.",
   "type": "module",
   "main": "dist/main.js",
@@ -47,11 +47,11 @@
     "prepack": "node --run test && node --run build"
   },
   "peerDependencies": {
-    "@phreshos/core": "^0.1.31",
+    "@phreshos/core": "^0.1.37",
     "react": "^19.2.0"
   },
   "devDependencies": {
-    "@phreshos/core": "^0.1.31",
+    "@phreshos/core": "^0.1.37",
     "@testing-library/react": "^16.3.0",
     "@types/react": "^19.2.18",
     "@types/react-dom": "^19.2.4",