@astrale-os/shell-react 0.4.0-beta.17 → 0.4.0-beta.18

package/dist/auth/act-as.context.js

@@ -1,5 +1,7 @@
 import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
-import { createContext, useContext, useEffect, useMemo, useState } from 'react';
+import { createContext, useContext, useEffect, useState } from 'react';
+import { GraphContext } from '../graph/graph.context.js';
+import { resolveGraphStoreScope, retainStore, storeFor } from '../graph/store.js';
 import { ShellContext } from '../session/session.context.js';
 export const IdentityContext = createContext(null);
 IdentityContext.displayName = 'AstraleIdentityContext';
@@ -19,22 +21,34 @@ export function ActAs({ client, fallback, children }) {
     const [state, setState] = useState({ status: 'pending' });
     useEffect(() => {
         let active = true;
+        let release;
         setState({ status: 'pending' });
-        void client.auth.whoami().then((self) => {
-            if (active)
-                setState({ status: 'ready', self });
-        }, (error) => {
-            if (active)
-                setState({ status: 'failed', error });
-        });
+        void (async () => {
+            try {
+                const self = await client.auth.whoami();
+                if (!active)
+                    return;
+                const scope = await resolveGraphStoreScope(client, self);
+                if (!active)
+                    return;
+                const entry = storeFor(client, scope);
+                release = retainStore(entry);
+                setState({ status: 'ready', binding: { kernel: client, self }, store: entry.store });
+            }
+            catch (error) {
+                if (active)
+                    setState({ status: 'failed', client, error });
+            }
+        })();
         return () => {
             active = false;
+            release?.();
         };
     }, [client]);
-    const value = useMemo(() => (state.status === 'ready' ? { kernel: client, self: state.self } : null), [client, state]);
-    if (state.status === 'failed')
+    if (state.status === 'failed' && state.client === client)
         throw state.error;
-    if (value === null)
+    if (state.status !== 'ready' || state.binding.kernel !== client) {
         return fallback === undefined ? null : _jsx(_Fragment, { children: fallback });
-    return _jsx(IdentityContext.Provider, { value: value, children: children });
+    }
+    return (_jsx(IdentityContext.Provider, { value: state.binding, children: _jsx(GraphContext.Provider, { value: state.store, children: children }) }));
 }

package/dist/graph/query-definition.hook.js

@@ -183,7 +183,7 @@ function combine(snapshots) {
     return 'ready';
 }
 function stableIdentity(value) {
-    const seen = new WeakSet();
+    const ancestors = new WeakSet();
     const encode = (input) => {
         if (input === null)
             return ['null'];
@@ -198,17 +198,22 @@ function stableIdentity(value) {
             }
             return [typeof input, input];
         }
-        if (seen.has(input))
+        if (ancestors.has(input))
             throw new TypeError('Query input cannot contain cycles.');
-        seen.add(input);
-        if (Array.isArray(input))
-            return ['array', input.map(encode)];
-        return [
-            'object',
-            Object.fromEntries(Object.keys(input)
-                .sort()
-                .map((key) => [key, encode(input[key])])),
-        ];
+        ancestors.add(input);
+        try {
+            if (Array.isArray(input))
+                return ['array', input.map(encode)];
+            return [
+                'object',
+                Object.fromEntries(Object.keys(input)
+                    .sort()
+                    .map((key) => [key, encode(input[key])])),
+            ];
+        }
+        finally {
+            ancestors.delete(input);
+        }
     };
     return JSON.stringify(encode(value));
 }

package/dist/graph/resource.js

@@ -227,19 +227,27 @@ export function retainRefreshScheduler(store, identity, refresh, interval, when)
     };
 }
 function schedulePoll(scheduler, immediate = false) {
-    if (scheduler.timer !== undefined)
-        clearTimeout(scheduler.timer);
     const subscribers = [...scheduler.subscribers.values()];
     if (subscribers.length === 0)
         return;
     const interval = Math.min(...subscribers.map((subscriber) => subscriber.interval));
+    const delay = immediate ? 0 : interval;
+    const dueAt = Date.now() + delay;
+    // Observer changes may advance a refresh, but must not postpone pending work.
+    if (scheduler.timer !== undefined) {
+        if (scheduler.dueAt !== undefined && scheduler.dueAt <= dueAt)
+            return;
+        clearTimeout(scheduler.timer);
+    }
+    scheduler.dueAt = dueAt;
     scheduler.timer = setTimeout(() => {
         scheduler.timer = undefined;
+        scheduler.dueAt = undefined;
         const visible = typeof document === 'undefined' || document.visibilityState !== 'hidden';
         const eligible = [...scheduler.subscribers.values()].filter((subscriber) => subscriber.when === 'always' || visible);
         eligible.forEach((subscriber) => void subscriber.refresh().catch(() => { }));
         schedulePoll(scheduler);
-    }, immediate ? 0 : interval);
+    }, delay);
 }
 function positivePage(input) {
     if (!Number.isSafeInteger(input) || input < 1) {

package/dist/graph/store.d.ts

@@ -1,8 +1,8 @@
 import type { GraphApi } from '@astrale-os/sdk/client';
 import type { GraphStore as GraphStoreValue } from '@astrale-os/sdk/client/store';
-import type { Shell } from '@astrale-os/shell';
+import type { KernelClient } from '@astrale-os/shell';
 interface StoreEntry {
-    readonly shell: Shell;
+    readonly client: KernelClient;
     readonly graph: GraphApi;
     readonly scope: string;
     readonly store: GraphStoreValue;
@@ -15,9 +15,9 @@ export interface GraphStoreScope {
     readonly authority: string;
     readonly schemaRevision: string;
 }
-type StoreIdentity = Awaited<ReturnType<Shell['kernel']['auth']['whoami']>>;
-export declare function resolveGraphStoreScope(shell: Shell, knownIdentity?: StoreIdentity | null): Promise<GraphStoreScope>;
-export declare function storeFor(shell: Shell, scope: GraphStoreScope): StoreEntry;
+type StoreIdentity = Awaited<ReturnType<KernelClient['auth']['whoami']>>;
+export declare function resolveGraphStoreScope(client: KernelClient, knownIdentity?: StoreIdentity | null): Promise<GraphStoreScope>;
+export declare function storeFor(client: KernelClient, scope: GraphStoreScope): StoreEntry;
 export declare function retainStore(entry: StoreEntry): () => void;
 /** The exact caller/schema-scoped GraphStore for the current View subtree. */
 export declare function useGraphStore(): GraphStoreValue;

package/dist/graph/store.js

@@ -2,39 +2,39 @@ import { GraphStore } from '@astrale-os/sdk/client/store';
 import { useContext } from 'react';
 import { GraphContext } from './graph.context.js';
 const entries = new WeakMap();
-export async function resolveGraphStoreScope(shell, knownIdentity) {
+export async function resolveGraphStoreScope(client, knownIdentity) {
     const [identity, snapshot] = await Promise.all([
         knownIdentity === undefined
-            ? shell.kernel.auth.whoami().catch(() => null)
+            ? client.auth.whoami().catch(() => null)
             : Promise.resolve(knownIdentity),
-        shell.kernel.snapshot(),
+        client.snapshot(),
     ]);
     return Object.freeze({
         authority: identity === null ? 'anonymous' : `${identity.iss}\u0000${identity.sub}\u0000${identity.id}`,
         schemaRevision: snapshot.publication.schema.revision,
     });
 }
-export function storeFor(shell, scope) {
-    const current = entries.get(shell);
+export function storeFor(client, scope) {
+    const current = entries.get(client);
     const scopeKey = `${scope.authority}\u0000${scope.schemaRevision}`;
-    if (current !== undefined && current.graph === shell.kernel.graph && current.scope === scopeKey) {
+    if (current !== undefined && current.graph === client.graph && current.scope === scopeKey) {
         return current;
     }
-    const supplied = shell.kernel.store;
+    const supplied = client.store;
     const created = {
-        shell,
-        graph: shell.kernel.graph,
+        client,
+        graph: client.graph,
         scope: scopeKey,
         // A supplied Store is trusted only for the KernelClient's first declared scope. A later
         // authority/revision/GraphApi replacement gets a new Store and cannot inherit old memory.
         store: current === undefined && supplied !== undefined
             ? supplied
-            : new GraphStore({ graph: shell.kernel.graph }),
+            : new GraphStore({ graph: client.graph }),
         owned: current !== undefined || supplied === undefined,
         retained: 0,
         generation: 0,
     };
-    entries.set(shell, created);
+    entries.set(client, created);
     if (current !== undefined && current.retained === 0 && current.owned)
         current.store.close();
     return created;
@@ -52,8 +52,8 @@ export function retainStore(entry) {
         queueMicrotask(() => {
             if (entry.retained !== 0 || entry.generation !== generation || !entry.owned)
                 return;
-            if (entries.get(entry.shell) === entry)
-                entries.delete(entry.shell);
+            if (entries.get(entry.client) === entry)
+                entries.delete(entry.client);
             entry.store.close();
         });
     };

package/dist/session/provider.js

@@ -45,10 +45,10 @@ export function ShellProvider(props) {
                 await primeUser(shell);
                 if (generation !== ref.generation)
                     return;
-                const storeScope = await resolveGraphStoreScope(shell, self);
+                const storeScope = await resolveGraphStoreScope(shell.kernel, self);
                 if (generation !== ref.generation)
                     return;
-                const graph = storeFor(shell, storeScope);
+                const graph = storeFor(shell.kernel, storeScope);
                 dispatch({
                     type: 'ready',
                     runtime: { shell, self, storeScope, store: graph.store, ownsStore: graph.owned },
@@ -105,7 +105,7 @@ export function ShellProvider(props) {
     useEffect(() => {
         if (shell === null || store === null || storeScope === null)
             return;
-        return retainStore(storeFor(shell, storeScope));
+        return retainStore(storeFor(shell.kernel, storeScope));
     }, [shell, store, storeScope]);
     if (state.status === 'error') {
         if (errorFallback !== undefined)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrale-os/shell-react",
-  "version": "0.4.0-beta.17",
+  "version": "0.4.0-beta.18",
   "description": "Astrale shell-react — the React face of the shell (provider, hooks, view components)",
   "license": "Apache-2.0",
   "repository": {
@@ -31,7 +31,7 @@
     "zod": "4.4.3"
   },
   "devDependencies": {
-    "@astrale-os/sdk": "0.5.0-beta.131",
+    "@astrale-os/sdk": "0.5.0-beta.136",
     "@testing-library/dom": "^10.4.0",
     "@testing-library/react": "^16.3.0",
     "@types/node": "^26.2.0",
@@ -46,7 +46,7 @@
     "vitest": "4.1.10"
   },
   "peerDependencies": {
-    "@astrale-os/sdk": ">=0.5.0-beta.131 <1.0.0",
+    "@astrale-os/sdk": ">=0.5.0-beta.136 <1.0.0",
     "react": ">=18",
     "react-dom": ">=18"
   },

package/src/auth/act-as.context.tsx

@@ -2,8 +2,10 @@ import type { Identity } from '@astrale-os/sdk/auth'
 import type { KernelClient } from '@astrale-os/shell'
 import type { ReactElement, ReactNode } from 'react'
 
-import { createContext, useContext, useEffect, useMemo, useState } from 'react'
+import { createContext, useContext, useEffect, useState } from 'react'
 
+import { GraphContext } from '../graph/graph.context.js'
+import { resolveGraphStoreScope, retainStore, storeFor } from '../graph/store.js'
 import { ShellContext } from '../session/session.context.js'
 
 export type NodeValue = Identity
@@ -40,31 +42,44 @@ export interface ActAsProps {
 export function ActAs({ client, fallback, children }: ActAsProps): ReactElement | null {
   const [state, setState] = useState<
     | { readonly status: 'pending' }
-    | { readonly status: 'ready'; readonly self: Identity }
-    | { readonly status: 'failed'; readonly error: unknown }
+    | {
+        readonly status: 'ready'
+        readonly binding: IdentityBinding
+        readonly store: ReturnType<typeof storeFor>['store']
+      }
+    | { readonly status: 'failed'; readonly client: KernelClient; readonly error: unknown }
   >({ status: 'pending' })
 
   useEffect(() => {
     let active = true
+    let release: (() => void) | undefined
     setState({ status: 'pending' })
-    void client.auth.whoami().then(
-      (self) => {
-        if (active) setState({ status: 'ready', self })
-      },
-      (error: unknown) => {
-        if (active) setState({ status: 'failed', error })
-      },
-    )
+    void (async () => {
+      try {
+        const self = await client.auth.whoami()
+        if (!active) return
+        const scope = await resolveGraphStoreScope(client, self)
+        if (!active) return
+        const entry = storeFor(client, scope)
+        release = retainStore(entry)
+        setState({ status: 'ready', binding: { kernel: client, self }, store: entry.store })
+      } catch (error) {
+        if (active) setState({ status: 'failed', client, error })
+      }
+    })()
     return () => {
       active = false
+      release?.()
     }
   }, [client])
 
-  const value = useMemo<IdentityBinding | null>(
-    () => (state.status === 'ready' ? { kernel: client, self: state.self } : null),
-    [client, state],
+  if (state.status === 'failed' && state.client === client) throw state.error
+  if (state.status !== 'ready' || state.binding.kernel !== client) {
+    return fallback === undefined ? null : <>{fallback}</>
+  }
+  return (
+    <IdentityContext.Provider value={state.binding}>
+      <GraphContext.Provider value={state.store}>{children}</GraphContext.Provider>
+    </IdentityContext.Provider>
   )
-  if (state.status === 'failed') throw state.error
-  if (value === null) return fallback === undefined ? null : <>{fallback}</>
-  return <IdentityContext.Provider value={value}>{children}</IdentityContext.Provider>
 }

package/src/graph/query-definition.hook.ts

@@ -251,7 +251,7 @@ function combine(snapshots: readonly StoreSnapshot[]): GraphResourceState {
 }
 
 function stableIdentity(value: unknown): string {
-  const seen = new WeakSet<object>()
+  const ancestors = new WeakSet<object>()
   const encode = (input: unknown): unknown => {
     if (input === null) return ['null']
     if (typeof input !== 'object') {
@@ -264,17 +264,21 @@ function stableIdentity(value: unknown): string {
       }
       return [typeof input, input]
     }
-    if (seen.has(input)) throw new TypeError('Query input cannot contain cycles.')
-    seen.add(input)
-    if (Array.isArray(input)) return ['array', input.map(encode)]
-    return [
-      'object',
-      Object.fromEntries(
-        Object.keys(input as Record<string, unknown>)
-          .sort()
-          .map((key) => [key, encode((input as Record<string, unknown>)[key])]),
-      ),
-    ]
+    if (ancestors.has(input)) throw new TypeError('Query input cannot contain cycles.')
+    ancestors.add(input)
+    try {
+      if (Array.isArray(input)) return ['array', input.map(encode)]
+      return [
+        'object',
+        Object.fromEntries(
+          Object.keys(input as Record<string, unknown>)
+            .sort()
+            .map((key) => [key, encode((input as Record<string, unknown>)[key])]),
+        ),
+      ]
+    } finally {
+      ancestors.delete(input)
+    }
   }
   return JSON.stringify(encode(value))
 }

package/src/graph/resource.ts

@@ -176,6 +176,7 @@ interface PollSubscriber {
 interface PollScheduler {
   readonly subscribers: Map<symbol, PollSubscriber>
   timer: ReturnType<typeof setTimeout> | undefined
+  dueAt?: number
   onVisibility?: () => void
 }
 
@@ -344,22 +345,27 @@ export function retainRefreshScheduler(
 }
 
 function schedulePoll(scheduler: PollScheduler, immediate = false): void {
-  if (scheduler.timer !== undefined) clearTimeout(scheduler.timer)
   const subscribers = [...scheduler.subscribers.values()]
   if (subscribers.length === 0) return
   const interval = Math.min(...subscribers.map((subscriber) => subscriber.interval))
-  scheduler.timer = setTimeout(
-    () => {
-      scheduler.timer = undefined
-      const visible = typeof document === 'undefined' || document.visibilityState !== 'hidden'
-      const eligible = [...scheduler.subscribers.values()].filter(
-        (subscriber) => subscriber.when === 'always' || visible,
-      )
-      eligible.forEach((subscriber) => void subscriber.refresh().catch(() => {}))
-      schedulePoll(scheduler)
-    },
-    immediate ? 0 : interval,
-  )
+  const delay = immediate ? 0 : interval
+  const dueAt = Date.now() + delay
+  // Observer changes may advance a refresh, but must not postpone pending work.
+  if (scheduler.timer !== undefined) {
+    if (scheduler.dueAt !== undefined && scheduler.dueAt <= dueAt) return
+    clearTimeout(scheduler.timer)
+  }
+  scheduler.dueAt = dueAt
+  scheduler.timer = setTimeout(() => {
+    scheduler.timer = undefined
+    scheduler.dueAt = undefined
+    const visible = typeof document === 'undefined' || document.visibilityState !== 'hidden'
+    const eligible = [...scheduler.subscribers.values()].filter(
+      (subscriber) => subscriber.when === 'always' || visible,
+    )
+    eligible.forEach((subscriber) => void subscriber.refresh().catch(() => {}))
+    schedulePoll(scheduler)
+  }, delay)
 }
 
 function positivePage(input: number): number {

package/src/graph/store.ts

@@ -1,6 +1,6 @@
 import type { GraphApi } from '@astrale-os/sdk/client'
 import type { GraphStore as GraphStoreValue } from '@astrale-os/sdk/client/store'
-import type { Shell } from '@astrale-os/shell'
+import type { KernelClient } from '@astrale-os/shell'
 
 import { GraphStore } from '@astrale-os/sdk/client/store'
 import { useContext } from 'react'
@@ -8,7 +8,7 @@ import { useContext } from 'react'
 import { GraphContext } from './graph.context.js'
 
 interface StoreEntry {
-  readonly shell: Shell
+  readonly client: KernelClient
   readonly graph: GraphApi
   readonly scope: string
   readonly store: GraphStoreValue
@@ -17,7 +17,7 @@ interface StoreEntry {
   generation: number
 }
 
-const entries = new WeakMap<Shell, StoreEntry>()
+const entries = new WeakMap<KernelClient, StoreEntry>()
 
 /** Authority/schema identity. Session ids and Publication ETags are deliberately absent. */
 export interface GraphStoreScope {
@@ -25,17 +25,17 @@ export interface GraphStoreScope {
   readonly schemaRevision: string
 }
 
-type StoreIdentity = Awaited<ReturnType<Shell['kernel']['auth']['whoami']>>
+type StoreIdentity = Awaited<ReturnType<KernelClient['auth']['whoami']>>
 
 export async function resolveGraphStoreScope(
-  shell: Shell,
+  client: KernelClient,
   knownIdentity?: StoreIdentity | null,
 ): Promise<GraphStoreScope> {
   const [identity, snapshot] = await Promise.all([
     knownIdentity === undefined
-      ? shell.kernel.auth.whoami().catch(() => null)
+      ? client.auth.whoami().catch(() => null)
       : Promise.resolve(knownIdentity),
-    shell.kernel.snapshot(),
+    client.snapshot(),
   ])
   return Object.freeze({
     authority:
@@ -44,28 +44,28 @@ export async function resolveGraphStoreScope(
   })
 }
 
-export function storeFor(shell: Shell, scope: GraphStoreScope): StoreEntry {
-  const current = entries.get(shell)
+export function storeFor(client: KernelClient, scope: GraphStoreScope): StoreEntry {
+  const current = entries.get(client)
   const scopeKey = `${scope.authority}\u0000${scope.schemaRevision}`
-  if (current !== undefined && current.graph === shell.kernel.graph && current.scope === scopeKey) {
+  if (current !== undefined && current.graph === client.graph && current.scope === scopeKey) {
     return current
   }
-  const supplied = shell.kernel.store
+  const supplied = client.store
   const created: StoreEntry = {
-    shell,
-    graph: shell.kernel.graph,
+    client,
+    graph: client.graph,
     scope: scopeKey,
     // A supplied Store is trusted only for the KernelClient's first declared scope. A later
     // authority/revision/GraphApi replacement gets a new Store and cannot inherit old memory.
     store:
       current === undefined && supplied !== undefined
         ? supplied
-        : new GraphStore({ graph: shell.kernel.graph }),
+        : new GraphStore({ graph: client.graph }),
     owned: current !== undefined || supplied === undefined,
     retained: 0,
     generation: 0,
   }
-  entries.set(shell, created)
+  entries.set(client, created)
   if (current !== undefined && current.retained === 0 && current.owned) current.store.close()
   return created
 }
@@ -81,7 +81,7 @@ export function retainStore(entry: StoreEntry): () => void {
     const generation = ++entry.generation
     queueMicrotask(() => {
       if (entry.retained !== 0 || entry.generation !== generation || !entry.owned) return
-      if (entries.get(entry.shell) === entry) entries.delete(entry.shell)
+      if (entries.get(entry.client) === entry) entries.delete(entry.client)
       entry.store.close()
     })
   }

package/src/session/provider.tsx

@@ -61,9 +61,9 @@ export function ShellProvider(props: ShellProviderProps): ReactElement | null {
         if (generation !== ref.generation) return
         await primeUser(shell)
         if (generation !== ref.generation) return
-        const storeScope = await resolveGraphStoreScope(shell, self)
+        const storeScope = await resolveGraphStoreScope(shell.kernel, self)
         if (generation !== ref.generation) return
-        const graph = storeFor(shell, storeScope)
+        const graph = storeFor(shell.kernel, storeScope)
         dispatch({
           type: 'ready',
           runtime: { shell, self, storeScope, store: graph.store, ownsStore: graph.owned },
@@ -117,7 +117,7 @@ export function ShellProvider(props: ShellProviderProps): ReactElement | null {
   const storeScope = state.runtime?.storeScope ?? null
   useEffect(() => {
     if (shell === null || store === null || storeScope === null) return
-    return retainStore(storeFor(shell, storeScope))
+    return retainStore(storeFor(shell.kernel, storeScope))
   }, [shell, store, storeScope])
 
   if (state.status === 'error') {