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

package/dist/graph/memory/read/read.js

@@ -1,87 +0,0 @@
-import { canonicalizeAST, shapeInputToAST, stableStringify } from '@astrale-os/kernel-client/store';
-/**
- * The shared read substrate (API §1, §5). One `useSyncExternalStore` binding over
- * a memory shape — the substrate every graph read hook narrows. Handles the four
- * cross-cutting concerns once: idle inputs (§1.3), suspense-first on a cold shape
- * (§1.4), stale-while-revalidate + `keepPrevious` (§1.5), and referential
- * stability (§1.7 — an unchanged shape returns the store's own stable snapshot).
- */
-import { useCallback, useRef, useSyncExternalStore } from 'react';
-import { useMemory } from '../scope.js';
-import { EMPTY_PENDING, IDLE_READ, withPending } from './envelope.js';
-import { isIdleInput } from './idle.js';
-const NOOP_UNSUB = () => { };
-const IDLE_TOKEN = ' idle';
-/** Project shell-react read options onto the store's — `with`/`window`/`live` key the shape. */
-function storeReadOptions(opts) {
-    if (opts === undefined)
-        return undefined;
-    const out = {};
-    if (opts.live !== undefined)
-        out.live = opts.live;
-    if (opts.window !== undefined)
-        out.window = opts.window;
-    // `with` is a PermName at the store/kernel (READ lit-up today); the public
-    // `PermMask` typing reconciles with the grant epoch (API §14 G7).
-    if (opts.with !== undefined)
-        out.with = opts.with;
-    return out;
-}
-/**
- * A stable per-render key for a shape input + its keying options, so the
- * subscription/snapshot closures only re-bind when the LOGICAL read changes
- * (not when an inline builder closure is re-created each render).
- */
-function shapeToken(shape, opts) {
-    const canon = stableStringify(canonicalizeAST(shapeInputToAST(shape)));
-    return `${canon}#w=${String(opts?.with ?? '')}#win=${opts?.window ?? ''}#live=${opts?.live === false ? '0' : '1'}`;
-}
-/**
- * Subscribe to a memory shape and project it. `null`/`undefined` shape → idle.
- * Cold + `suspend` (default) throws the cold-shape promise; `suspend:false`
- * returns empty-pending; `keepPrevious` returns the last data while confirming.
- */
-export function useRead(shape, opts) {
-    const memory = useMemory();
-    const idle = isIdleInput(shape);
-    const shapeRef = useRef(shape);
-    shapeRef.current = shape;
-    const optsRef = useRef(opts);
-    optsRef.current = opts;
-    const token = idle ? IDLE_TOKEN : shapeToken(shape, opts);
-    const subscribe = useCallback((onStoreChange) => {
-        const s = shapeRef.current;
-        if (token === IDLE_TOKEN || s === null || s === undefined)
-            return NOOP_UNSUB;
-        return memory.subscribe(s, onStoreChange, storeReadOptions(optsRef.current));
-    }, [memory, token]);
-    const getSnapshot = useCallback(() => {
-        const s = shapeRef.current;
-        if (token === IDLE_TOKEN || s === null || s === undefined)
-            return null;
-        return memory.getSnapshot(s, storeReadOptions(optsRef.current));
-    }, [memory, token]);
-    const snap = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
-    const prevRef = useRef(null);
-    if (idle)
-        return IDLE_READ;
-    const warm = memory.peek(shape, storeReadOptions(opts)) !== null;
-    if (warm && snap !== null) {
-        prevRef.current = snap;
-        return snap;
-    }
-    if (opts?.keepPrevious === true && prevRef.current !== null) {
-        return withPending(prevRef.current);
-    }
-    if (opts?.suspend !== false) {
-        // Cold FAILURE (§1.4): the shape fetched and rejected with no data to show —
-        // throw the error to the nearest boundary. Re-throwing the promise here would
-        // re-arm a fresh fetch every retry (the entry's inflight was cleared on
-        // failure), looping render→fetch→reject forever. This breaks that loop.
-        if (snap !== null && snap.error !== undefined)
-            throw snap.error;
-        // Cold shape: suspend on the first-confirmed-data promise (§1.4).
-        throw memory.promise(shape, storeReadOptions(opts));
-    }
-    return EMPTY_PENDING;
-}

package/dist/graph/memory/scope.d.ts

@@ -1,7 +0,0 @@
-import type { GraphMemory } from '@astrale-os/kernel-client/store';
-/**
- * The memory for this subtree. Throws outside a `<ShellProvider>`. Above any
- * `<ActAs>` it is the base memory; inside one it is scoped by the binding.
- */
-export declare function useMemory(): GraphMemory;
-//# sourceMappingURL=scope.d.ts.map

package/dist/graph/memory/scope.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"scope.d.ts","sourceRoot":"","sources":["../../../src/graph/memory/scope.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAA;AAclE;;;GAGG;AACH,wBAAgB,SAAS,IAAI,WAAW,CASvC"}

package/dist/graph/memory/scope.js

@@ -1,25 +0,0 @@
-/**
- * Memory scope resolution (API §5.4). `useMemory` returns the memory for this
- * subtree: the base memory derived from the provider's Shell, re-scoped (and
- * re-api'd) to the `<ActAs>` principal via `forScope` when an identity binding is
- * present — so a principal never shares cached results with another.
- */
-import { useContext, useMemo } from 'react';
-import { IdentityContext } from '../../auth/act-as.context.js';
-import { ShellContext } from '../../session/session.context.js';
-import { baseMemoryFor } from './base.js';
-/**
- * The memory for this subtree. Throws outside a `<ShellProvider>`. Above any
- * `<ActAs>` it is the base memory; inside one it is scoped by the binding.
- */
-export function useMemory() {
-    const runtime = useContext(ShellContext);
-    const binding = useContext(IdentityContext);
-    const shell = runtime?.shell ?? null;
-    return useMemo(() => {
-        if (shell === null)
-            throw new Error('graph hooks must be used within a <ShellProvider>');
-        const base = baseMemoryFor(shell);
-        return binding === null ? base : base.forScope(binding.scope, binding.kernel);
-    }, [shell, binding]);
-}

package/dist/graph/mutate/move.hook.d.ts

@@ -1,7 +0,0 @@
-import type { NodeRefInput } from '@astrale-os/kernel-client';
-import type { PathLike } from '@astrale-os/kernel-client/graph';
-import type { Action } from '../action.js';
-import type { Node } from '../memory/read/envelope.js';
-export type MoveAction = Action<[node: Node | NodeRefInput, to: PathLike], void>;
-export declare function useMove(): MoveAction;
-//# sourceMappingURL=move.hook.d.ts.map

package/dist/graph/mutate/move.hook.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"move.hook.d.ts","sourceRoot":"","sources":["../../../src/graph/mutate/move.hook.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAA;AAC7D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iCAAiC,CAAA;AAY/D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAA;AAC1C,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,4BAA4B,CAAA;AAMtD,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,CAAC,IAAI,EAAE,IAAI,GAAG,YAAY,EAAE,EAAE,EAAE,QAAQ,CAAC,EAAE,IAAI,CAAC,CAAA;AAEhF,wBAAgB,OAAO,IAAI,UAAU,CAYpC"}

package/dist/graph/mutate/move.hook.js

@@ -1,49 +0,0 @@
-import { rawOf } from '@astrale-os/kernel-client/graph';
-/**
- * useMove (API §5, the G1 seam) — dispatch the sealed `node::move` method (the one
- * tree op no patch arm can express). PESSIMISTIC today (honest `pending`); affected
- * container shapes revalidate on settlement. Turns optimistic when the `nodes.move`
- * patch arm lands, with zero consumer change.
- */
-import { useCallback } from 'react';
-import { useSessionKernel } from '../../auth/session-kernel.js';
-import { useAction } from '../action.js';
-import { useMemory } from '../memory/scope.js';
-export function useMove() {
-    const kernel = useSessionKernel();
-    const memory = useMemory();
-    const run = useCallback(async (node, to) => {
-        const method = isNode(node) ? `@${node.id}::move` : `${rawOf(node)}::move`;
-        await kernel.call(method, { to: rawOf(to) });
-        await reconcileMove(memory, node, to);
-    }, [kernel, memory]);
-    return useAction(run);
-}
-function isNode(x) {
-    return typeof x === 'object' && x !== null && 'id' in x && 'class' in x && 'path' in x;
-}
-/** Root-first parent of a raw absolute path, or `null` at the root. */
-function parentPathOf(raw) {
-    const trimmed = raw.replace(/\/+$/, '');
-    const i = trimmed.lastIndexOf('/');
-    if (i < 0)
-        return null;
-    return i === 0 ? '/' : trimmed.slice(0, i);
-}
-/**
- * Best-effort settlement reconciliation (Tier 0): refetch the source and
- * destination container's default `children` shapes when they are observed. A
- * custom-ordered/filtered children shape is keyed distinctly and is not reached
- * here — consumers get honest `pending` and reconcile on G1.
- */
-async function reconcileMove(memory, node, to) {
-    const path = isNode(node) ? rawOf(node.path) : rawOf(node);
-    const containers = new Set([rawOf(to)]);
-    const old = parentPathOf(path);
-    if (old !== null)
-        containers.add(old);
-    await Promise.allSettled([...containers].map((c) => {
-        const snap = memory.peek((q) => q.from(c).children());
-        return snap !== null ? snap.refetch() : Promise.resolve();
-    }));
-}

package/dist/graph/mutate/mutate.hook.d.ts

@@ -1,17 +0,0 @@
-import type { PatchBuilder } from '@astrale-os/kernel-client/graph';
-import type { GraphMemory } from '@astrale-os/kernel-client/store';
-import type { Action } from '../action.js';
-export interface UseMutateOptions<A extends unknown[], R> {
-    /**
-     * `'auto'` (default) / `false`: the write's own overlay governs optimism - the
-     * callback's graph writes apply the authored patch. A function opens a
-     * MANUAL overlay decoupled from what the callback dispatches.
-     */
-    optimistic?: 'auto' | false | ((overlay: PatchBuilder, ...args: A) => void);
-    /** default 'auto'. false = keep the manual overlay on failure (caller reconciles). */
-    rollback?: 'auto' | false;
-    onCommit?: (result: R) => void;
-    onError?: (error: unknown) => void;
-}
-export declare function useMutate<A extends unknown[], R>(fn: (graph: GraphMemory, ...args: A) => Promise<R>, opts?: UseMutateOptions<A, R>): Action<A, R>;
-//# sourceMappingURL=mutate.hook.d.ts.map

package/dist/graph/mutate/mutate.hook.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"mutate.hook.d.ts","sourceRoot":"","sources":["../../../src/graph/mutate/mutate.hook.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAA;AACnE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAA;AAUlE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAA;AAK1C,MAAM,WAAW,gBAAgB,CAAC,CAAC,SAAS,OAAO,EAAE,EAAE,CAAC;IACtD;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,GAAG,KAAK,GAAG,CAAC,CAAC,OAAO,EAAE,YAAY,EAAE,GAAG,IAAI,EAAE,CAAC,KAAK,IAAI,CAAC,CAAA;IAC3E,sFAAsF;IACtF,QAAQ,CAAC,EAAE,MAAM,GAAG,KAAK,CAAA;IACzB,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,CAAC,KAAK,IAAI,CAAA;IAC9B,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAA;CACnC;AAED,wBAAgB,SAAS,CAAC,CAAC,SAAS,OAAO,EAAE,EAAE,CAAC,EAC9C,EAAE,EAAE,CAAC,KAAK,EAAE,WAAW,EAAE,GAAG,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,EAClD,IAAI,CAAC,EAAE,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,GAC5B,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAoCd"}

package/dist/graph/mutate/mutate.hook.js

@@ -1,45 +0,0 @@
-/**
- * useMutate (API 5/1.6) - build a graph-scoped Action. The callback receives
- * this subtree's GraphMemory, so callers do not need a separate useGraph() just
- * to author the mutation. Patch-shaped writes are optimistic via their own
- * overlay; pass a function `optimistic` to preview an opaque dispatch effect.
- */
-import { useCallback, useRef } from 'react';
-import { useAction } from '../action.js';
-import { useMemory } from '../memory/scope.js';
-export function useMutate(fn, opts) {
-    const memory = useMemory();
-    const fnRef = useRef(fn);
-    fnRef.current = fn;
-    const optsRef = useRef(opts);
-    optsRef.current = opts;
-    const run = useCallback(async (...args) => {
-        const o = optsRef.current;
-        const optimistic = o?.optimistic;
-        if (typeof optimistic === 'function') {
-            const overlay = memory.overlay((m) => optimistic(m, ...args));
-            try {
-                const result = await fnRef.current(memory, ...args);
-                overlay.commit();
-                o?.onCommit?.(result);
-                return result;
-            }
-            catch (error) {
-                if (o?.rollback !== false)
-                    overlay.rollback();
-                o?.onError?.(error);
-                throw error;
-            }
-        }
-        try {
-            const result = await fnRef.current(memory, ...args);
-            o?.onCommit?.(result);
-            return result;
-        }
-        catch (error) {
-            o?.onError?.(error);
-            throw error;
-        }
-    }, [memory]);
-    return useAction(run);
-}

package/dist/graph/query/children.hook.d.ts

@@ -1,29 +0,0 @@
-import type { AnyBoundNode, TypeNames } from '@astrale-os/kernel-client';
-import type { OrderInput, PathLike } from '@astrale-os/kernel-client/graph';
-import type { Schema } from '@astrale-os/kernel-dsl';
-import type { TypedChildrenResult } from '../../schema/types.js';
-import type { ReadState, Node, ReadOptions, Windowed } from '../memory/read/envelope.js';
-export interface ChildrenOptions extends ReadOptions {
-    /** Restrict to these classes (dual-path descent filter). */
-    classes?: PathLike[];
-    /** Server-ordered by a node prop / `id`. */
-    order?: OrderInput;
-    /** Page size; `more.load()` extends. */
-    limit?: number;
-    /** `append` (default, infinite) vs `paged` (replace). */
-    window?: 'append' | 'paged';
-}
-export interface ChildrenResult extends ReadState, Windowed {
-    /** Ordered, all loaded pages, parent excluded. */
-    readonly children: readonly Node[];
-}
-/** Typed: a bound node's children of `opts.type`. */
-export declare function useChildren<S extends Schema, T extends TypeNames<S>>(parent: AnyBoundNode<S> | null | undefined, opts: ReadOptions & {
-    type: T;
-    order?: OrderInput;
-    limit?: number;
-    window?: 'append' | 'paged';
-}): TypedChildrenResult<S, T>;
-/** Untyped: a node's direct children — windowed, live; `null` parent is idle (§1.3). */
-export declare function useChildren(parent: Node | PathLike | null | undefined, opts?: ChildrenOptions): ChildrenResult;
-//# sourceMappingURL=children.hook.d.ts.map

package/dist/graph/query/children.hook.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"children.hook.d.ts","sourceRoot":"","sources":["../../../src/graph/query/children.hook.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAA;AACxE,OAAO,KAAK,EAEV,UAAU,EACV,QAAQ,EAGT,MAAM,iCAAiC,CAAA;AACxC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAA;AAWpD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAA;AAChE,OAAO,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,4BAA4B,CAAA;AAKxF,MAAM,WAAW,eAAgB,SAAQ,WAAW;IAClD,4DAA4D;IAC5D,OAAO,CAAC,EAAE,QAAQ,EAAE,CAAA;IACpB,4CAA4C;IAC5C,KAAK,CAAC,EAAE,UAAU,CAAA;IAClB,wCAAwC;IACxC,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,yDAAyD;IACzD,MAAM,CAAC,EAAE,QAAQ,GAAG,OAAO,CAAA;CAC5B;AAED,MAAM,WAAW,cAAe,SAAQ,SAAS,EAAE,QAAQ;IACzD,kDAAkD;IAClD,QAAQ,CAAC,QAAQ,EAAE,SAAS,IAAI,EAAE,CAAA;CACnC;AAuBD,qDAAqD;AACrD,wBAAgB,WAAW,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,SAAS,CAAC,CAAC,CAAC,EAClE,MAAM,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,IAAI,GAAG,SAAS,EAC1C,IAAI,EAAE,WAAW,GAAG;IAClB,IAAI,EAAE,CAAC,CAAA;IACP,KAAK,CAAC,EAAE,UAAU,CAAA;IAClB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,MAAM,CAAC,EAAE,QAAQ,GAAG,OAAO,CAAA;CAC5B,GACA,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAA;AAC5B,wFAAwF;AACxF,wBAAgB,WAAW,CACzB,MAAM,EAAE,IAAI,GAAG,QAAQ,GAAG,IAAI,GAAG,SAAS,EAC1C,IAAI,CAAC,EAAE,eAAe,GACrB,cAAc,CAAA"}

package/dist/graph/query/children.hook.js

@@ -1,64 +0,0 @@
-import { rawOf } from '@astrale-os/kernel-client/graph';
-/**
- * useChildren (API §5 + §6) — ONE public symbol, overloaded: pass `opts.type`
- * (over a `BoundNode` parent) for the typed children, or a bare parent for the
- * untyped children. Both ride the SAME windowed memory shape. The untyped floor
- * is a windowed, live read of a node's direct children; the typed twin binds them.
- */
-import { useMemo } from 'react';
-import { useChildren as useChildrenTyped } from '../../schema/bind-read.js';
-import { useRead } from '../memory/read/read.js';
-/** A node's direct children — windowed, live; `null` parent is idle (§1.3). */
-function useChildrenUntyped(parent, opts) {
-    const shape = isIdle(parent) ? null : childrenShape(parent, opts);
-    const r = useRead(shape, opts);
-    return useMemo(() => ({
-        pending: r.pending,
-        error: r.error,
-        live: r.live,
-        seq: r.seq,
-        refetch: r.refetch,
-        children: r.children,
-        more: r.more,
-    }), [r]);
-}
-export function useChildren(parent, opts) {
-    if (hasType(opts)) {
-        return useChildrenTyped(parent, opts);
-    }
-    return useChildrenUntyped(parent, opts);
-}
-function hasType(opts) {
-    return (typeof opts === 'object' &&
-        opts !== null &&
-        'type' in opts &&
-        opts.type !== undefined);
-}
-// ── internals ────────────────────────────────────────────────────────────────
-function isIdle(x) {
-    return x === null || x === undefined;
-}
-function isNode(x) {
-    return typeof x === 'object' && x !== null && 'id' in x && 'class' in x && 'path' in x;
-}
-/** A parent ref anchored on the node id (stable across rename) or the raw path. */
-function refOf(parent) {
-    return isNode(parent) ? `@${parent.id}` : parent;
-}
-function walkOptsOf(opts) {
-    if (opts === undefined)
-        return undefined;
-    const { classes, order, limit } = opts;
-    if (classes === undefined && order === undefined && limit === undefined)
-        return undefined;
-    return {
-        ...(classes !== undefined ? { classes: classes.map((c) => rawOf(c)) } : {}),
-        ...(order !== undefined ? { order } : {}),
-        ...(limit !== undefined ? { limit } : {}),
-    };
-}
-function childrenShape(parent, opts) {
-    const ref = refOf(parent);
-    const walk = walkOptsOf(opts);
-    return (q) => q.from(ref).children(walk);
-}

package/dist/graph/query/graph.hook.d.ts

@@ -1,9 +0,0 @@
-/**
- * useGraph (API §5) — the memory handle for this subtree (the raw floor plus the
- * memory's optimistic-auto write shorthands). The same scoped memory every
- * graph/schema/nav hook reads.
- */
-import type { GraphMemory } from '@astrale-os/kernel-client/store';
-/** The memory for this subtree — the raw floor plus optimistic-auto shorthands (§5). */
-export declare function useGraph(): GraphMemory;
-//# sourceMappingURL=graph.hook.d.ts.map

package/dist/graph/query/graph.hook.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"graph.hook.d.ts","sourceRoot":"","sources":["../../../src/graph/query/graph.hook.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAA;AAIlE,wFAAwF;AACxF,wBAAgB,QAAQ,IAAI,WAAW,CAEtC"}

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

@@ -1,5 +0,0 @@
-import { useMemory } from '../memory/scope.js';
-/** The memory for this subtree — the raw floor plus optimistic-auto shorthands (§5). */
-export function useGraph() {
-    return useMemory();
-}

package/dist/graph/query/neighbors.hook.d.ts

@@ -1,7 +0,0 @@
-import type { AnyBoundNode, EdgeNames } from '@astrale-os/kernel-client';
-import type { Schema } from '@astrale-os/kernel-dsl';
-import type { EndpointResult } from '../../schema/types.js';
-import type { ReadOptions } from '../memory/read/envelope.js';
-export declare function useOut<S extends Schema, E extends EdgeNames<S>>(node: AnyBoundNode<S> | null | undefined, edge: E, opts?: ReadOptions): EndpointResult<S, E, 'to'>;
-export declare function useIn<S extends Schema, E extends EdgeNames<S>>(node: AnyBoundNode<S> | null | undefined, edge: E, opts?: ReadOptions): EndpointResult<S, E, 'from'>;
-//# sourceMappingURL=neighbors.hook.d.ts.map

package/dist/graph/query/neighbors.hook.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"neighbors.hook.d.ts","sourceRoot":"","sources":["../../../src/graph/query/neighbors.hook.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAA;AACxE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAA;AASpD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAA;AAC3D,OAAO,KAAK,EAAa,WAAW,EAAE,MAAM,4BAA4B,CAAA;AAKxE,wBAAgB,MAAM,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,SAAS,CAAC,CAAC,CAAC,EAC7D,IAAI,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,IAAI,GAAG,SAAS,EACxC,IAAI,EAAE,CAAC,EACP,IAAI,CAAC,EAAE,WAAW,GACjB,cAAc,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,CAAC,CAE5B;AAED,wBAAgB,KAAK,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,SAAS,CAAC,CAAC,CAAC,EAC5D,IAAI,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,IAAI,GAAG,SAAS,EACxC,IAAI,EAAE,CAAC,EACP,IAAI,CAAC,EAAE,WAAW,GACjB,cAAc,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC,CAE9B"}

package/dist/graph/query/neighbors.hook.js

@@ -1,104 +0,0 @@
-/**
- * useOut / useIn (API §6) — the public typed traversal read hooks. Resolve
- * endpoints one-shot through `BoundNode.links.out/in` (`live: false`); become live with
- * no surface change once edge-endpoint ids land. Deviations tracked in API §6/G6.
- */
-import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
-import { schemaOf, tagSchema } from '../../schema/tag.js';
-import { isIdleInput } from '../memory/read/idle.js';
-export function useOut(node, edge, opts) {
-    return useEndpoint(node, edge, 'out', opts);
-}
-export function useIn(node, edge, opts) {
-    return useEndpoint(node, edge, 'in', opts);
-}
-function useEndpoint(node, edge, side, opts) {
-    const schema = isIdleInput(node) ? undefined : schemaOf(node);
-    const single = schema !== undefined && isSingleEndpoint(schema, edge, side);
-    const key = `${node?.id ?? ''}\u0000${edge}\u0000${side}`;
-    const run = useCallback(async () => {
-        if (isIdleInput(node))
-            return null;
-        const result = await (side === 'out' ? node.links.out(edge) : node.links.in(edge));
-        if (schema !== undefined)
-            tagEndpoints(result, schema);
-        return result;
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [node?.id, edge, side]);
-    const { data, pending, error, refetch } = useAsyncRead(isIdleInput(node) ? null : run, key, opts?.keepPrevious === true);
-    return useMemo(() => {
-        const live = { pending, error, live: false, seq: 0, refetch };
-        if (isIdleInput(node))
-            return { ...live, node: null, nodes: EMPTY };
-        if (single) {
-            const value = Array.isArray(data) ? data[0] : data;
-            return { ...live, node: (value ?? null) };
-        }
-        const values = Array.isArray(data) ? data : data === null || data === undefined ? EMPTY : [data];
-        return { ...live, nodes: values };
-    }, [node, data, pending, error, refetch, single]);
-}
-// ── helpers ──────────────────────────────────────────────────────────────────
-const EMPTY = Object.freeze([]);
-function isSingleEndpoint(schema, edge, side) {
-    const definition = schema.classes[edge];
-    const cardinality = (side === 'out' ? definition?.to : definition?.from)?.cardinality;
-    return cardinality === '1' || cardinality === '0..1';
-}
-function tagEndpoints(result, schema) {
-    if (Array.isArray(result))
-        for (const r of result)
-            tagSchema(r, schema);
-    else if (result !== null && result !== undefined)
-        tagSchema(result, schema);
-}
-/** One-shot async read with pending/error/refetch and stale-response guarding. */
-function useAsyncRead(run, key, keepPrevious) {
-    const [state, setState] = useState({
-        pending: run !== null,
-        error: undefined,
-        key: run === null ? null : key,
-    });
-    const runRef = useRef(run);
-    runRef.current = run;
-    const keyRef = useRef(key);
-    keyRef.current = key;
-    const keepPreviousRef = useRef(keepPrevious);
-    keepPreviousRef.current = keepPrevious;
-    const seq = useRef(0);
-    const refetch = useCallback(() => {
-        const current = runRef.current;
-        const currentKey = keyRef.current;
-        if (current === null) {
-            setState({ pending: false, error: undefined, data: undefined, key: null });
-            return Promise.resolve();
-        }
-        const my = ++seq.current;
-        setState((s) => ({
-            data: s.key === currentKey || keepPreviousRef.current === true ? s.data : undefined,
-            pending: true,
-            error: undefined,
-            key: currentKey,
-        }));
-        return current().then((data) => {
-            if (my === seq.current) {
-                setState({ data, pending: false, error: undefined, key: currentKey });
-            }
-        }, (error) => {
-            if (my === seq.current) {
-                setState((s) => ({ data: s.data, pending: false, error, key: currentKey }));
-            }
-        });
-    }, []);
-    useEffect(() => {
-        void refetch();
-    }, [key, refetch]);
-    const current = state.key === key;
-    return {
-        data: current || keepPrevious ? state.data : undefined,
-        pending: run !== null && (!current || state.pending),
-        error: current ? state.error : undefined,
-        key: current ? state.key : null,
-        refetch,
-    };
-}

package/dist/graph/query/node.hook.d.ts

@@ -1,14 +0,0 @@
-import type { NodeRefInput, TypeNames } from '@astrale-os/kernel-client';
-import type { PathLike } from '@astrale-os/kernel-client/graph';
-import type { Schema } from '@astrale-os/kernel-dsl';
-import type { TypedNodeResult } from '../../schema/types.js';
-import type { ReadState, Node, ReadOptions } from '../memory/read/envelope.js';
-export interface NodeResult extends ReadState {
-    /** The node, or `null` when missing ≡ masked (never throws NOT_FOUND). */
-    readonly node: Node | null;
-}
-/** Typed: one node bound under `schema` as `type`. */
-export declare function useNode<S extends Schema, T extends TypeNames<S>>(schema: S, type: T, ref: NodeRefInput | null | undefined, opts?: ReadOptions): TypedNodeResult<S, T>;
-/** Untyped: one node by ref — `null` ref is idle (§1.3). */
-export declare function useNode(ref: PathLike | null | undefined, opts?: ReadOptions): NodeResult;
-//# sourceMappingURL=node.hook.d.ts.map

package/dist/graph/query/node.hook.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"node.hook.d.ts","sourceRoot":"","sources":["../../../src/graph/query/node.hook.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAA;AACxE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iCAAiC,CAAA;AAC/D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAA;AAWpD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAA;AAC5D,OAAO,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAA;AAK9E,MAAM,WAAW,UAAW,SAAQ,SAAS;IAC3C,0EAA0E;IAC1E,QAAQ,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,CAAA;CAC3B;AAiCD,sDAAsD;AACtD,wBAAgB,OAAO,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,SAAS,CAAC,CAAC,CAAC,EAC9D,MAAM,EAAE,CAAC,EACT,IAAI,EAAE,CAAC,EACP,GAAG,EAAE,YAAY,GAAG,IAAI,GAAG,SAAS,EACpC,IAAI,CAAC,EAAE,WAAW,GACjB,eAAe,CAAC,CAAC,EAAE,CAAC,CAAC,CAAA;AACxB,4DAA4D;AAC5D,wBAAgB,OAAO,CAAC,GAAG,EAAE,QAAQ,GAAG,IAAI,GAAG,SAAS,EAAE,IAAI,CAAC,EAAE,WAAW,GAAG,UAAU,CAAA"}

package/dist/graph/query/node.hook.js

@@ -1,43 +0,0 @@
-/**
- * useNode (API §5 + §6) — ONE public symbol, overloaded: pass a `Schema` (+ type)
- * for the typed `BoundNode` result, or a bare ref for the untyped `Node` result.
- * Both forms ride the SAME memory shape — a typed read and its untyped twin are
- * one cache entry, one liveness, one overlay. The runtime dispatches on the first
- * argument; a given call site is always one form, so hook order is stable.
- */
-import { useMemo } from 'react';
-import { useNode as useNodeTyped } from '../../schema/bind-read.js';
-import { useRead } from '../memory/read/read.js';
-/**
- * A `Schema` (from `defineSchema`) — its shape (`domain`/`classes`/`interfaces`)
- * is disjoint from a `PathLike` (`string | Path`), so this cleanly routes the
- * typed vs untyped overload at runtime.
- */
-function isSchema(value) {
-    return (typeof value === 'object' &&
-        value !== null &&
-        'domain' in value &&
-        'classes' in value &&
-        'interfaces' in value);
-}
-/** One node by path — live, suspense-first; `null` ref is idle (§1.3). */
-function useNodeUntyped(ref, opts) {
-    const r = useRead(ref, opts);
-    return useMemo(() => ({
-        pending: r.pending,
-        error: r.error,
-        live: r.live,
-        seq: r.seq,
-        refetch: r.refetch,
-        node: r.first,
-    }), [r]);
-}
-// The implementation signature returns an erased supertype of both result
-// shapes — every overload above is assignable to it regardless of `BoundNode`
-// variance; callers only ever see the precise overload return types.
-export function useNode(a, b, c, d) {
-    if (isSchema(a)) {
-        return useNodeTyped(a, b, c, d);
-    }
-    return useNodeUntyped(a, b);
-}

package/dist/graph/query/query.hook.d.ts

@@ -1,14 +0,0 @@
-import type { GatherBuilder, QueryASTInput, QuerySource } from '@astrale-os/kernel-client/graph';
-import type { ReadState, Node, ReadOptions, Windowed } from '../memory/read/envelope.js';
-export interface QueryResult extends ReadState, Windowed {
-    readonly nodes: readonly Node[];
-    readonly roots: readonly Node[];
-    readonly first: Node | null;
-    gathered(alias: string): {
-        readonly nodes: readonly Node[];
-        readonly first: Node | null;
-    };
-}
-/** A structured read — builder callback or AST value; `null` is idle (§1.3). */
-export declare function useQuery(build: ((q: QuerySource) => GatherBuilder) | QueryASTInput | null | undefined, opts?: ReadOptions): QueryResult;
-//# sourceMappingURL=query.hook.d.ts.map

package/dist/graph/query/query.hook.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"query.hook.d.ts","sourceRoot":"","sources":["../../../src/graph/query/query.hook.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAA;AAShG,OAAO,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,4BAA4B,CAAA;AAIxF,MAAM,WAAW,WAAY,SAAQ,SAAS,EAAE,QAAQ;IACtD,QAAQ,CAAC,KAAK,EAAE,SAAS,IAAI,EAAE,CAAA;IAC/B,QAAQ,CAAC,KAAK,EAAE,SAAS,IAAI,EAAE,CAAA;IAC/B,QAAQ,CAAC,KAAK,EAAE,IAAI,GAAG,IAAI,CAAA;IAC3B,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG;QAAE,QAAQ,CAAC,KAAK,EAAE,SAAS,IAAI,EAAE,CAAC;QAAC,QAAQ,CAAC,KAAK,EAAE,IAAI,GAAG,IAAI,CAAA;KAAE,CAAA;CAC1F;AAED,gFAAgF;AAChF,wBAAgB,QAAQ,CACtB,KAAK,EAAE,CAAC,CAAC,CAAC,EAAE,WAAW,KAAK,aAAa,CAAC,GAAG,aAAa,GAAG,IAAI,GAAG,SAAS,EAC7E,IAAI,CAAC,EAAE,WAAW,GACjB,WAAW,CAiBb"}

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

@@ -1,23 +0,0 @@
-/**
- * useQuery (API §5) — a structured read: a builder callback or an AST value;
- * `null` is idle (§1.3). Rides the §1 envelope over the shared memory, projecting
- * roots/first/nodes and the gathered-alias arms.
- */
-import { useMemo } from 'react';
-import { useRead } from '../memory/read/read.js';
-/** A structured read — builder callback or AST value; `null` is idle (§1.3). */
-export function useQuery(build, opts) {
-    const r = useRead(build ?? null, opts);
-    return useMemo(() => ({
-        pending: r.pending,
-        error: r.error,
-        live: r.live,
-        seq: r.seq,
-        refetch: r.refetch,
-        nodes: r.nodes,
-        roots: r.roots,
-        first: r.first,
-        gathered: r.gathered,
-        more: r.more,
-    }), [r]);
-}

package/dist/schema/bind-read.d.ts

@@ -1,37 +0,0 @@
-import type { OrderInput } from '@astrale-os/kernel-client/graph';
-import type { LiveResult, ShapeInput } from '@astrale-os/kernel-client/store';
-import type { Node } from '@astrale-os/kernel-core';
-import type { Schema } from '@astrale-os/kernel-dsl';
-import { type AnyBoundNode, type BoundNode, type DefOf, type NodeRefInput, type SchemaBoundView, type TypeNames } from '@astrale-os/kernel-client';
-import type { ReadOptions } from '../graph/memory/read/envelope.js';
-import type { TypedChildrenResult, TypedNodeResult } from './types.js';
-/** Bind one wire node as `type`; stable while the wire node, binding, and type hold. */
-export declare function useBoundNode<S extends Schema, T extends TypeNames<S>>(binding: SchemaBoundView<S>, type: T, wire: Node | null | undefined): BoundNode<DefOf<S, T>, S> | null;
-/**
- * Bind many wire nodes as `type`; per-node identity + a stable array on no
- * change. `skipMismatch` drops nodes whose class is not `type` (a mixed-class
- * child set) instead of throwing.
- */
-export declare function useBoundNodes<S extends Schema, T extends TypeNames<S>>(binding: SchemaBoundView<S>, type: T, wires: readonly Node[], skipMismatch?: boolean): readonly BoundNode<DefOf<S, T>, S>[];
-/** Bind many wire nodes classlessly (traversal endpoints); per-node + stable array. */
-export declare function useBoundEndpoints<S extends Schema>(binding: SchemaBoundView<S>, wires: readonly Node[]): readonly AnyBoundNode<S>[];
-/** Base read options plus the window growth mode (a `useChildren`-specific extra). */
-export type ShapeOptions = ReadOptions & {
-    window?: 'append' | 'paged';
-};
-/**
- * Subscribe to a memory shape. `null` shape → idle (`null`, no I/O). A cold
- * shape suspends unless `suspend: false`. The returned `LiveResult` is the
- * unified read envelope — callers project `node`/`children`/`nodes`.
- */
-export declare function useShape(shape: ShapeInput | null | undefined, opts?: ShapeOptions): LiveResult | null;
-export declare function useNode<S extends Schema, T extends TypeNames<S>>(schema: S, type: T, ref: NodeRefInput | null | undefined, opts?: ReadOptions): TypedNodeResult<S, T>;
-export declare function useChildren<S extends Schema, T extends TypeNames<S>>(parent: AnyBoundNode<S> | null | undefined, opts: ReadOptions & {
-    type: T;
-    order?: OrderInput;
-    limit?: number;
-    window?: 'append' | 'paged';
-}): TypedChildrenResult<S, T>;
-/** Recover the schema a BoundNode was bound under; a clear error if it is untagged. */
-export declare function requireSchema(node: object): Schema;
-//# sourceMappingURL=bind-read.d.ts.map