@astrale-os/shell-react 0.2.9 → 0.2.10-beta.2

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

@@ -0,0 +1,205 @@
+import { bindQueries } from '@astrale-os/sdk/query';
+import { useCallback, useEffect, useMemo, useRef, useSyncExternalStore } from 'react';
+import { useDynamicDomain } from '../schema/domain.hook.js';
+import { retainRefreshScheduler } from './resource.js';
+import { useGraphStore } from './store.js';
+class DefinitionObserver {
+    store;
+    binding;
+    definition;
+    input;
+    listeners = new Set();
+    subscriptions = Object.freeze([]);
+    touched = Object.freeze([]);
+    current = Object.freeze({ state: 'loading' });
+    generation = 0;
+    pending = null;
+    started = false;
+    rerunQueued = false;
+    constructor(store, binding, definition, input) {
+        this.store = store;
+        this.binding = binding;
+        this.definition = definition;
+        this.input = input;
+    }
+    subscribe = (listener) => {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    };
+    getSnapshot = () => this.current;
+    start() {
+        this.started = true;
+        void this.run('cached');
+        return () => {
+            this.started = false;
+            this.generation += 1;
+            this.subscriptions.forEach((unsubscribe) => unsubscribe());
+            this.subscriptions = Object.freeze([]);
+        };
+    }
+    refresh = async () => {
+        await this.run('refresh');
+    };
+    run(freshness) {
+        if (this.pending !== null && freshness === 'cached')
+            return this.pending;
+        const generation = ++this.generation;
+        const touched = [];
+        this.update({
+            state: this.current.data === undefined ? 'loading' : 'refreshing',
+            ...(this.current.data === undefined ? {} : { data: this.current.data }),
+        });
+        const execute = async (ast, options) => {
+            touched.push(Object.freeze({ ast, options }));
+            return this.store.read(ast, { ...options, freshness });
+        };
+        const bind = this.binding.$.bind;
+        const query = bindQueries(execute, { bind });
+        const running = query(this.definition, this.input)
+            .then((data) => {
+            if (!this.started || generation !== this.generation)
+                return;
+            this.touched = dedupeShapes(touched);
+            this.bindShapes();
+            this.update({ state: this.storeState(), data });
+        })
+            .catch((error) => {
+            if (!this.started || generation !== this.generation)
+                return;
+            this.touched = dedupeShapes(touched);
+            this.bindShapes();
+            this.update({
+                state: 'failed',
+                ...(this.current.data === undefined ? {} : { data: this.current.data }),
+                error,
+            });
+        })
+            .finally(() => {
+            if (this.pending === running)
+                this.pending = null;
+        });
+        this.pending = running;
+        return running;
+    }
+    bindShapes() {
+        this.subscriptions.forEach((unsubscribe) => unsubscribe());
+        this.subscriptions = Object.freeze(this.touched.map(({ ast, options }) => this.store.subscribe(ast, this.onStoreChange, options)));
+    }
+    onStoreChange = () => {
+        const state = this.storeState();
+        this.update({
+            state,
+            ...(this.current.data === undefined ? {} : { data: this.current.data }),
+            ...(this.current.error === undefined ? {} : { error: this.current.error }),
+        });
+        if ((state === 'ready' || state === 'optimistic') && !this.rerunQueued) {
+            this.rerunQueued = true;
+            queueMicrotask(() => {
+                this.rerunQueued = false;
+                if (this.started)
+                    void this.run('cached');
+            });
+        }
+    };
+    storeState() {
+        const snapshots = this.touched.map(({ ast, options }) => this.store.getSnapshot(ast, options));
+        if (snapshots.length === 0)
+            return this.current.state;
+        return combine(snapshots);
+    }
+    update(next) {
+        if (next.state === this.current.state &&
+            next.data === this.current.data &&
+            next.error === this.current.error)
+            return;
+        this.current = Object.freeze(next);
+        this.listeners.forEach((listener) => listener());
+    }
+}
+/** Execute one named SDK Query definition exclusively through the current GraphStore. */
+export function useQuery(definition, input, options = {}) {
+    const store = useGraphStore();
+    const binding = useDynamicDomain();
+    const inputIdentity = stableIdentity(input);
+    const observer = useMemo(() => (definition === null ? null : new DefinitionObserver(store, binding, definition, input)), [store, binding, definition, inputIdentity]);
+    const idle = useMemo(() => Object.freeze({ state: 'idle' }), []);
+    const subscribe = useCallback((listener) => observer?.subscribe(listener) ?? (() => { }), [observer]);
+    const snapshot = useCallback(() => observer?.getSnapshot() ?? idle, [observer, idle]);
+    const current = useSyncExternalStore(subscribe, snapshot, snapshot);
+    useEffect(() => observer?.start(), [observer]);
+    const identity = definition === null ? 'idle' : `${definition.id}\u0000${inputIdentity}`;
+    useEffect(() => {
+        if (observer === null || options.refreshInterval === undefined)
+            return;
+        return retainRefreshScheduler(store, identity, observer.refresh, options.refreshInterval, options.refreshWhen ?? 'visible');
+    }, [store, observer, identity, options.refreshInterval, options.refreshWhen]);
+    const previousRef = useRef(undefined);
+    const previous = options.keepPrevious && previousRef.current?.identity !== identity
+        ? previousRef.current
+        : undefined;
+    useEffect(() => {
+        if (current.data !== undefined) {
+            previousRef.current = Object.freeze({ identity, data: current.data });
+        }
+    }, [identity, current.data]);
+    return useMemo(() => Object.freeze({
+        state: current.state,
+        data: current.data,
+        error: current.error,
+        ...(previous === undefined ? {} : { previous }),
+        transitioning: current.state === 'loading' || current.state === 'refreshing',
+        live: false,
+        sequence: 0,
+        refresh: observer?.refresh ?? (() => Promise.resolve()),
+        more: Object.freeze({ has: false, pending: false, load: () => Promise.resolve() }),
+    }), [current, previous, observer]);
+}
+function dedupeShapes(input) {
+    const seen = new Set();
+    return Object.freeze(input.filter(({ ast, options }) => {
+        const key = `${JSON.stringify(ast)}\u0000${JSON.stringify(options.page)}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    }));
+}
+function combine(snapshots) {
+    if (snapshots.some((snapshot) => snapshot.state === 'cold'))
+        return 'loading';
+    for (const state of ['failed', 'loading', 'refreshing', 'optimistic', 'stale']) {
+        if (snapshots.some((snapshot) => snapshot.state === state))
+            return state;
+    }
+    return 'ready';
+}
+function stableIdentity(value) {
+    const seen = new WeakSet();
+    const encode = (input) => {
+        if (input === null)
+            return ['null'];
+        if (typeof input !== 'object') {
+            if (typeof input === 'function' || typeof input === 'symbol' || typeof input === 'bigint') {
+                throw new TypeError('Query input must be portable and serializable.');
+            }
+            if (input === undefined)
+                return ['undefined'];
+            if (typeof input === 'number' && !Number.isFinite(input)) {
+                throw new TypeError('Query input numbers must be finite.');
+            }
+            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)
+                .sort()
+                .map((key) => [key, encode(input[key])])),
+        ];
+    };
+    return JSON.stringify(encode(value));
+}

package/dist/graph/resource.d.ts

@@ -0,0 +1,34 @@
+import type { GraphStore, StoreQueryResponse } from '@astrale-os/kernel-client/store';
+import type { QueryAST } from '@astrale-os/sdk/query';
+export type GraphResourceState = 'idle' | 'loading' | 'ready' | 'stale' | 'refreshing' | 'optimistic' | 'failed';
+export interface GraphResource<T> {
+    readonly state: GraphResourceState;
+    /** Current-scope data only. Previous-scope data is never substituted here. */
+    readonly data: T | undefined;
+    readonly error: unknown;
+    readonly previous?: {
+        readonly identity: string;
+        readonly data: T;
+    };
+    readonly transitioning: boolean;
+    readonly live: false;
+    readonly sequence: 0;
+    refresh(): Promise<void>;
+    readonly more: {
+        readonly has: boolean;
+        readonly pending: boolean;
+        load(): Promise<void>;
+    };
+}
+export interface StoreResourceOptions<Output> {
+    readonly identity?: string;
+    readonly keepPrevious?: boolean;
+    readonly window?: 'page' | 'append';
+    readonly merge?: (pages: readonly Output[]) => Output;
+    readonly refreshInterval?: number;
+    readonly refreshWhen?: 'always' | 'visible';
+}
+/** Adapt exact Store pages into a tear-free React resource without a parallel entity cache. */
+export declare function useStoreResource<Query extends QueryAST, Output>(query: Query | null, pageSize: number, project: (response: StoreQueryResponse<Query>) => Output, options?: StoreResourceOptions<Output>): GraphResource<Output>;
+export declare function retainRefreshScheduler(store: GraphStore, identity: string, refresh: () => Promise<void>, interval: number, when: 'always' | 'visible'): () => void;
+//# sourceMappingURL=resource.d.ts.map

package/dist/graph/resource.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resource.d.ts","sourceRoot":"","sources":["../../src/graph/resource.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,kBAAkB,EAAiB,MAAM,iCAAiC,CAAA;AACpG,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAA;AAMrD,MAAM,MAAM,kBAAkB,GAC1B,MAAM,GACN,SAAS,GACT,OAAO,GACP,OAAO,GACP,YAAY,GACZ,YAAY,GACZ,QAAQ,CAAA;AAEZ,MAAM,WAAW,aAAa,CAAC,CAAC;IAC9B,QAAQ,CAAC,KAAK,EAAE,kBAAkB,CAAA;IAClC,8EAA8E;IAC9E,QAAQ,CAAC,IAAI,EAAE,CAAC,GAAG,SAAS,CAAA;IAC5B,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAA;IACvB,QAAQ,CAAC,QAAQ,CAAC,EAAE;QAAE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAA;KAAE,CAAA;IACnE,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAA;IAC/B,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAA;IACpB,QAAQ,CAAC,QAAQ,EAAE,CAAC,CAAA;IACpB,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;IACxB,QAAQ,CAAC,IAAI,EAAE;QACb,QAAQ,CAAC,GAAG,EAAE,OAAO,CAAA;QACrB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;QACzB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;KACtB,CAAA;CACF;AAED,MAAM,WAAW,oBAAoB,CAAC,MAAM;IAC1C,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,YAAY,CAAC,EAAE,OAAO,CAAA;IAC/B,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,QAAQ,CAAA;IACnC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,KAAK,MAAM,CAAA;IACrD,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAA;IACjC,QAAQ,CAAC,WAAW,CAAC,EAAE,QAAQ,GAAG,SAAS,CAAA;CAC5C;AAsID,+FAA+F;AAC/F,wBAAgB,gBAAgB,CAAC,KAAK,SAAS,QAAQ,EAAE,MAAM,EAC7D,KAAK,EAAE,KAAK,GAAG,IAAI,EACnB,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,CAAC,QAAQ,EAAE,kBAAkB,CAAC,KAAK,CAAC,KAAK,MAAM,EACxD,OAAO,GAAE,oBAAoB,CAAC,MAAM,CAAM,GACzC,aAAa,CAAC,MAAM,CAAC,CA2EvB;AAoCD,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,UAAU,EACjB,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,EAC5B,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,QAAQ,GAAG,SAAS,GACzB,MAAM,IAAI,CAkCZ"}

package/dist/graph/resource.js

@@ -0,0 +1,244 @@
+import { useCallback, useEffect, useMemo, useRef, useSyncExternalStore } from 'react';
+import { useGraphStore } from './store.js';
+class StoreObserver {
+    store;
+    query;
+    size;
+    listeners = new Set();
+    pages = Object.freeze([Object.freeze({})]);
+    unsubs = Object.freeze([]);
+    current;
+    morePromise = null;
+    started = false;
+    constructor(store, query, size) {
+        this.store = store;
+        this.query = query;
+        this.size = size;
+    }
+    subscribe = (listener) => {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    };
+    getSnapshot = () => {
+        if (this.current !== undefined)
+            return this.current;
+        this.current = Object.freeze({
+            snapshots: Object.freeze(this.pages.map((page) => this.store.getSnapshot(this.query, this.pageOptions(page)))),
+            pendingMore: this.morePromise !== null,
+        });
+        return this.current;
+    };
+    start() {
+        if (!this.started) {
+            this.started = true;
+            this.bindPages();
+            void this.store
+                .read(this.query, {
+                ...this.pageOptions(this.pages[0]),
+                freshness: 'cached',
+            })
+                .catch(() => { });
+        }
+        return () => {
+            this.started = false;
+            this.unsubs.forEach((unsubscribe) => unsubscribe());
+            this.unsubs = Object.freeze([]);
+        };
+    }
+    async refresh() {
+        await Promise.all(this.pages.map((page) => this.store.read(this.query, { ...this.pageOptions(page), freshness: 'refresh' })));
+    }
+    hasMore() {
+        const snapshots = this.getSnapshot().snapshots;
+        const last = snapshots[snapshots.length - 1];
+        const response = last === undefined ? undefined : responseOf(last);
+        return response?.page.next !== undefined;
+    }
+    loadMore() {
+        if (this.morePromise !== null)
+            return this.morePromise;
+        const snapshots = this.getSnapshot().snapshots;
+        const last = snapshots[snapshots.length - 1];
+        const after = last === undefined ? undefined : responseOf(last)?.page.next;
+        if (after === undefined)
+            return Promise.resolve();
+        if (this.pages.some((page) => page.after === after))
+            return Promise.resolve();
+        this.pages = Object.freeze([...this.pages, Object.freeze({ after })]);
+        this.bindPages();
+        this.morePromise = this.store
+            .read(this.query, { ...this.pageOptions({ after }), freshness: 'cached' })
+            .then(() => { })
+            .finally(() => {
+            this.morePromise = null;
+            this.publish();
+        });
+        this.publish();
+        return this.morePromise;
+    }
+    pageOptions(page) {
+        return Object.freeze({
+            page: Object.freeze({
+                size: this.size,
+                ...(page.after === undefined ? {} : { after: page.after }),
+            }),
+        });
+    }
+    bindPages() {
+        this.unsubs.forEach((unsubscribe) => unsubscribe());
+        this.unsubs = Object.freeze(this.pages.map((page) => this.store.subscribe(this.query, this.publish, this.pageOptions(page))));
+        this.publish();
+    }
+    publish = () => {
+        this.current = undefined;
+        this.listeners.forEach((listener) => listener());
+    };
+}
+const pollers = new WeakMap();
+/** Adapt exact Store pages into a tear-free React resource without a parallel entity cache. */
+export function useStoreResource(query, pageSize, project, options = {}) {
+    const store = useGraphStore();
+    const observer = useMemo(() => (query === null ? null : new StoreObserver(store, query, positivePage(pageSize))), [store, query, pageSize]);
+    const subscribe = useCallback((listener) => (observer === null ? () => { } : observer.subscribe(listener)), [observer]);
+    const idle = useMemo(() => Object.freeze({ snapshots: Object.freeze([]), pendingMore: false }), []);
+    const getSnapshot = useCallback(() => observer?.getSnapshot() ?? idle, [observer, idle]);
+    const current = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+    useEffect(() => observer?.start(), [observer]);
+    const pollIdentity = query === null ? null : `${options.identity ?? JSON.stringify(query)}\u0000${pageSize}`;
+    useEffect(() => {
+        if (query === null || observer === null || options.refreshInterval === undefined)
+            return;
+        return retainRefreshScheduler(store, pollIdentity, () => observer.refresh(), options.refreshInterval, options.refreshWhen ?? 'visible');
+    }, [store, query, observer, pollIdentity, options.refreshInterval, options.refreshWhen]);
+    const refresh = useCallback(async () => observer?.refresh(), [observer]);
+    const loadMore = useCallback(async () => observer?.loadMore(), [observer]);
+    const identity = options.identity ?? pollIdentity ?? 'idle';
+    const projected = useMemo(() => {
+        const responses = current.snapshots.flatMap((snapshot) => {
+            const response = responseOf(snapshot);
+            return response === undefined ? [] : [response];
+        });
+        if (responses.length === 0)
+            return undefined;
+        const pages = responses.map(project);
+        if ((options.window ?? 'page') === 'page')
+            return pages[0];
+        return options.merge?.(pages) ?? mergeAppendPages(pages);
+    }, [current, project, options.window, options.merge]);
+    const previousRef = useRef(undefined);
+    const prior = previousRef.current;
+    const previous = options.keepPrevious && prior !== undefined && prior.identity !== identity ? prior : undefined;
+    useEffect(() => {
+        if (projected !== undefined)
+            previousRef.current = Object.freeze({ identity, data: projected });
+    }, [identity, projected]);
+    return useMemo(() => {
+        const snapshots = current.snapshots;
+        const state = query === null ? 'idle' : combinedState(snapshots);
+        const failed = snapshots.find((snapshot) => snapshot.state === 'failed');
+        return Object.freeze({
+            state,
+            data: projected,
+            ...(failed?.state === 'failed' ? { error: failed.error } : { error: undefined }),
+            ...(previous === undefined ? {} : { previous }),
+            transitioning: state === 'loading' || state === 'refreshing',
+            live: false,
+            sequence: 0,
+            refresh,
+            more: Object.freeze({
+                has: observer?.hasMore() ?? false,
+                pending: current.pendingMore,
+                load: loadMore,
+            }),
+        });
+    }, [current, query, projected, previous, refresh, observer, loadMore]);
+}
+function combinedState(snapshots) {
+    if (snapshots.length === 0 || snapshots.some((snapshot) => snapshot.state === 'cold'))
+        return 'loading';
+    for (const state of ['failed', 'loading', 'refreshing', 'optimistic', 'stale']) {
+        if (snapshots.some((snapshot) => snapshot.state === state))
+            return state;
+    }
+    return 'ready';
+}
+function responseOf(snapshot) {
+    return 'response' in snapshot ? snapshot.response : undefined;
+}
+function mergeAppendPages(pages) {
+    const first = pages[0];
+    if (!Array.isArray(first))
+        return pages[pages.length - 1];
+    const seen = new Set();
+    const merged = [];
+    for (const page of pages) {
+        for (const value of page) {
+            const identity = value !== null && typeof value === 'object' && 'id' in value
+                ? value.id
+                : value;
+            if (seen.has(identity))
+                continue;
+            seen.add(identity);
+            merged.push(value);
+        }
+    }
+    return Object.freeze(merged);
+}
+export function retainRefreshScheduler(store, identity, refresh, interval, when) {
+    if (!Number.isSafeInteger(interval) || interval < 250) {
+        throw new TypeError('refreshInterval must be an integer of at least 250ms.');
+    }
+    let byIdentity = pollers.get(store);
+    if (byIdentity === undefined) {
+        byIdentity = new Map();
+        pollers.set(store, byIdentity);
+    }
+    let scheduler = byIdentity.get(identity);
+    if (scheduler === undefined) {
+        scheduler = { subscribers: new Map(), timer: undefined };
+        byIdentity.set(identity, scheduler);
+    }
+    const token = Symbol(identity);
+    scheduler.subscribers.set(token, { interval, when, refresh });
+    schedulePoll(scheduler);
+    if (typeof document !== 'undefined' && scheduler.onVisibility === undefined) {
+        scheduler.onVisibility = () => schedulePoll(scheduler, true);
+        document.addEventListener('visibilitychange', scheduler.onVisibility);
+    }
+    return () => {
+        scheduler.subscribers.delete(token);
+        if (scheduler.subscribers.size !== 0) {
+            schedulePoll(scheduler);
+            return;
+        }
+        if (scheduler.timer !== undefined)
+            clearTimeout(scheduler.timer);
+        if (typeof document !== 'undefined' && scheduler.onVisibility !== undefined) {
+            document.removeEventListener('visibilitychange', scheduler.onVisibility);
+        }
+        byIdentity.delete(identity);
+        if (byIdentity.size === 0)
+            pollers.delete(store);
+    };
+}
+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));
+    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);
+}
+function positivePage(input) {
+    if (!Number.isSafeInteger(input) || input < 1) {
+        throw new TypeError('Graph resource page size must be a positive safe integer.');
+    }
+    return input;
+}

package/dist/graph/store.d.ts

@@ -0,0 +1,25 @@
+import type { GraphApi } from '@astrale-os/kernel-client/graph';
+import type { GraphStore as GraphStoreValue } from '@astrale-os/kernel-client/store';
+import type { Shell } from '@astrale-os/shell';
+interface StoreEntry {
+    readonly shell: Shell;
+    readonly graph: GraphApi;
+    readonly scope: string;
+    readonly store: GraphStoreValue;
+    readonly owned: boolean;
+    retained: number;
+    generation: number;
+}
+/** Authority/schema identity. Session ids and Publication ETags are deliberately absent. */
+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;
+export declare function retainStore(entry: StoreEntry): () => void;
+/** The exact caller/schema-scoped GraphStore for the current View subtree. */
+export declare function useGraphStore(): GraphStoreValue;
+export {};
+//# sourceMappingURL=store.d.ts.map

package/dist/graph/store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../src/graph/store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iCAAiC,CAAA;AAC/D,OAAO,KAAK,EAAE,UAAU,IAAI,eAAe,EAAE,MAAM,iCAAiC,CAAA;AACpF,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAA;AAO9C,UAAU,UAAU;IAClB,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAA;IACrB,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAA;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,KAAK,EAAE,eAAe,CAAA;IAC/B,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAA;IACvB,QAAQ,EAAE,MAAM,CAAA;IAChB,UAAU,EAAE,MAAM,CAAA;CACnB;AAID,4FAA4F;AAC5F,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAA;CAChC;AAED,KAAK,aAAa,GAAG,OAAO,CAAC,UAAU,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAA;AAE3E,wBAAsB,sBAAsB,CAC1C,KAAK,EAAE,KAAK,EACZ,aAAa,CAAC,EAAE,aAAa,GAAG,IAAI,GACnC,OAAO,CAAC,eAAe,CAAC,CAc1B;AAED,wBAAgB,QAAQ,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,eAAe,GAAG,UAAU,CAwBzE;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,IAAI,CAezD;AAED,8EAA8E;AAC9E,wBAAgB,aAAa,IAAI,eAAe,CAI/C"}

package/dist/graph/store.js

@@ -0,0 +1,69 @@
+import { GraphStore } from '@astrale-os/kernel-client/store';
+import { useContext } from 'react';
+import { GraphContext } from './graph.context.js';
+const entries = new WeakMap();
+export async function resolveGraphStoreScope(shell, knownIdentity) {
+    const [identity, snapshot] = await Promise.all([
+        knownIdentity === undefined
+            ? shell.kernel.auth.whoami().catch(() => null)
+            : Promise.resolve(knownIdentity),
+        shell.kernel.snapshot(),
+    ]);
+    return Object.freeze({
+        authority: identity === null
+            ? 'anonymous'
+            : `${identity.issuer}\u0000${identity.subject}\u0000${identity.id}`,
+        schemaRevision: snapshot.publication.schema.revision,
+    });
+}
+export function storeFor(shell, scope) {
+    const current = entries.get(shell);
+    const scopeKey = `${scope.authority}\u0000${scope.schemaRevision}`;
+    if (current !== undefined && current.graph === shell.kernel.graph && current.scope === scopeKey) {
+        return current;
+    }
+    const supplied = shell.kernel.store;
+    const created = {
+        shell,
+        graph: shell.kernel.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 }),
+        owned: current !== undefined || supplied === undefined,
+        retained: 0,
+        generation: 0,
+    };
+    entries.set(shell, created);
+    if (current !== undefined && current.retained === 0 && current.owned)
+        current.store.close();
+    return created;
+}
+export function retainStore(entry) {
+    entry.generation += 1;
+    entry.retained += 1;
+    let released = false;
+    return () => {
+        if (released)
+            return;
+        released = true;
+        entry.retained -= 1;
+        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);
+            entry.store.close();
+        });
+    };
+}
+/** The exact caller/schema-scoped GraphStore for the current View subtree. */
+export function useGraphStore() {
+    const store = useContext(GraphContext);
+    if (store === null)
+        throw new Error('useGraphStore must be used within a <ShellProvider>');
+    return store;
+}

package/dist/host/actions.hook.d.ts

@@ -0,0 +1,34 @@
+import type { AccessRequest, AccessResult, ExternalOpenRequest, ExternalOpenResult, HostCapabilities, ModalRequest, ModalResult, NotificationRequest, NotificationResult, OpenViewRequest, OpenViewResult } from '@astrale-os/shell';
+export declare function useHostCapabilities(): HostCapabilities;
+export declare class HostCapabilityUnavailableError extends Error {
+    readonly capability: string;
+    readonly code: 'SHELL_REACT_HOST_CAPABILITY_UNAVAILABLE';
+    constructor(capability: string);
+}
+export interface HostDialogApi {
+    readonly supported: boolean;
+    open(request: ModalRequest): Promise<ModalResult>;
+    confirm(request: Omit<ModalRequest, 'nested'>): Promise<boolean>;
+}
+export declare function useHostDialog(): HostDialogApi;
+export interface NotifyApi {
+    (request: NotificationRequest): Promise<NotificationResult>;
+    readonly supported: boolean;
+}
+export declare function useNotify(): NotifyApi;
+export interface OpenViewApi {
+    (request: OpenViewRequest): Promise<OpenViewResult>;
+    readonly supported: boolean;
+}
+export declare function useOpenView(): OpenViewApi;
+export interface ExternalOpenApi {
+    (request: ExternalOpenRequest): Promise<ExternalOpenResult>;
+    readonly supported: boolean;
+}
+export declare function useExternalOpen(): ExternalOpenApi;
+export interface RequestAccessApi {
+    (request: AccessRequest): Promise<AccessResult>;
+    readonly supported: boolean;
+}
+export declare function useRequestAccess(): RequestAccessApi;
+//# sourceMappingURL=actions.hook.d.ts.map

package/dist/host/actions.hook.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"actions.hook.d.ts","sourceRoot":"","sources":["../../src/host/actions.hook.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EACb,YAAY,EACZ,mBAAmB,EACnB,kBAAkB,EAClB,gBAAgB,EAChB,YAAY,EACZ,WAAW,EACX,mBAAmB,EACnB,kBAAkB,EAClB,eAAe,EACf,cAAc,EACf,MAAM,mBAAmB,CAAA;AAO1B,wBAAgB,mBAAmB,IAAI,gBAAgB,CAEtD;AAED,qBAAa,8BAA+B,SAAQ,KAAK;IAE3C,QAAQ,CAAC,UAAU,EAAE,MAAM;IADvC,QAAQ,CAAC,IAAI,EAAG,yCAAyC,CAAS;IAClE,YAAqB,UAAU,EAAE,MAAM,EAGtC;CACF;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAA;IAC3B,IAAI,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,WAAW,CAAC,CAAA;IACjD,OAAO,CAAC,OAAO,EAAE,IAAI,CAAC,YAAY,EAAE,QAAQ,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;CACjE;AAED,wBAAgB,aAAa,IAAI,aAAa,CAmB7C;AAED,MAAM,WAAW,SAAS;IACxB,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAAA;IAC3D,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAA;CAC5B;AAED,wBAAgB,SAAS,IAAI,SAAS,CAerC;AAED,MAAM,WAAW,WAAW;IAC1B,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,cAAc,CAAC,CAAA;IACnD,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAA;CAC5B;AAED,wBAAgB,WAAW,IAAI,WAAW,CAezC;AAED,MAAM,WAAW,eAAe;IAC9B,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAAA;IAC3D,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAA;CAC5B;AAED,wBAAgB,eAAe,IAAI,eAAe,CAejD;AAED,MAAM,WAAW,gBAAgB;IAC/B,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC,CAAA;IAC/C,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAA;CAC5B;AAED,wBAAgB,gBAAgB,IAAI,gBAAgB,CAenD"}