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

package/dist/navigation/snapshot.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"snapshot.d.ts","sourceRoot":"","sources":["../../src/navigation/snapshot.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAA;AAC3E,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iCAAiC,CAAA;AAC/D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAA;AASlE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AAC9C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAA;AACtD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,eAAe,CAAA;AAEjD,sEAAsE;AACtE,MAAM,MAAM,SAAS,GACjB,MAAM,GACN,QAAQ,GACR,IAAI,GACJ,YAAY,GACZ;IAAE,IAAI,EAAE,MAAM,GAAG,QAAQ,CAAC;IAAC,IAAI,CAAC,EAAE,YAAY,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,CAAA;AAMrF,gFAAgF;AAChF,wBAAgB,eAAe,CAAC,MAAM,EAAE,SAAS,GAAG,kBAAkB,CAgBrE;AAED;;;;;GAKG;AACH,wBAAsB,kBAAkB,CAAC,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAiBhG"}
+{"version":3,"file":"snapshot.d.ts","sourceRoot":"","sources":["../../src/navigation/snapshot.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAA;AACjE,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,4BAA4B,CAAA;AACtD,OAAO,KAAK,EAAY,QAAQ,EAAE,MAAM,4BAA4B,CAAA;AACpE,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,wBAAwB,CAAA;AACjD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAA;AAM9C,OAAO,KAAK,EAAE,UAAU,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAA;AAElE,uFAAuF;AACvF,MAAM,MAAM,SAAS,GACjB,QAAQ,GACR,IAAI,GACJ;IACE,QAAQ,CAAC,IAAI,EAAE,QAAQ,GAAG,IAAI,CAAA;IAC9B,QAAQ,CAAC,IAAI,CAAC,EAAE,GAAG,CAAC,IAAI,CAAA;IACxB,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CACzC,CAAA;AAgBL,qEAAqE;AACrE,wBAAgB,eAAe,CAAC,MAAM,EAAE,SAAS,GAAG,kBAAkB,CAOrE;AAQD,6FAA6F;AAC7F,wBAAsB,kBAAkB,CACtC,OAAO,EAAE,UAAU,EACnB,KAAK,EAAE,UAAU,EACjB,KAAK,EAAE,KAAK,GACX,OAAO,CAAC,OAAO,CAAC,CAkBlB"}

package/dist/navigation/snapshot.js

@@ -1,63 +1,67 @@
-/**
- * NavSnapshot serialize/restore (API §8.1/§8.2) — the `NavTarget` input space, the
- * `serializeTarget` normalization into the id-anchored stored form, and the
- * restore-time `revalidateAndPrune` that drops dead entries against the memory.
- */
-import { normalizeRef } from '@astrale-os/kernel-client';
-function isRecord(x) {
-    return typeof x === 'object' && x !== null;
+import { Path } from '@astrale-os/sdk/graph/path';
+import { Query } from '@astrale-os/sdk/query';
+import { Key as admitKey } from '@astrale-os/sdk/schema';
+function isNode(value) {
+    return typeof value === 'object' && value !== null && 'id' in value && 'class' in value;
 }
-/** Normalize any {@link NavTarget} to its stored, id-anchored serialization. */
+function nodePath(value) {
+    return isNode(value) ? Path.id(value.id).raw : Path.from(value).raw;
+}
+function isComposite(value) {
+    return typeof value === 'object' && value !== null && 'node' in value;
+}
+/** Normalize every target to canonical astrale-node-path-v1 text. */
 export function serializeTarget(target) {
-    if (typeof target === 'string')
-        return { node: normalizeRef(target) };
-    if (isRecord(target) && 'node' in target) {
-        const t = target;
-        return {
-            node: normalizeRef(t.node),
-            ...(t.view !== undefined ? { view: normalizeRef(t.view) } : {}),
-            ...(t.params !== undefined ? { params: { ...t.params } } : {}),
-        };
-    }
-    // A Node / BoundNode carries `id` (id-anchored, so rename/move survive) and `path`;
-    // anything else is a typed `Path` value → its raw address.
-    if (isRecord(target) && 'id' in target && 'path' in target) {
-        return { node: normalizeRef(target.id) };
-    }
-    return { node: normalizeRef(target) };
+    if (!isComposite(target))
+        return { node: nodePath(target) };
+    return {
+        node: nodePath(target.node),
+        ...(target.view === undefined ? {} : { view: viewKey(target.view) }),
+        ...(target.params === undefined ? {} : { params: { ...target.params } }),
+    };
+}
+function viewKey(input) {
+    const key = admitKey(input);
+    if (!admitKey.ref(key).startsWith('view.'))
+        throw new TypeError(`Invalid View key '${input}'.`);
+    return key;
 }
-/**
- * Revalidate a restored stack against the memory and drop dead entries (API §8.2).
- * Each entry is point-read one-shot; a null/failed read is a dead anchor. The
- * cursor re-lands on the surviving current entry, else the nearest survivor
- * before it.
- */
-export async function revalidateAndPrune(history, memory) {
+/** Drop restored entries that no longer resolve under the authenticated Graph capability. */
+export async function revalidateAndPrune(history, store, shell) {
     const { entries, cursor } = history.snapshot();
-    const alive = await Promise.all(entries.map((e) => resolves(memory, e.node)));
+    const alive = await Promise.all(entries.map((entry) => resolves(store, shell, entry)));
     if (alive.every(Boolean))
-        return;
+        return false;
     const survivors = [];
     let newCursor = -1;
     let fallback = -1;
-    entries.forEach((entry, i) => {
-        if (!alive[i])
+    entries.forEach((entry, index) => {
+        if (!alive[index])
             return;
         survivors.push(entry);
-        const idx = survivors.length - 1;
-        if (i === cursor)
-            newCursor = idx;
-        else if (i < cursor)
-            fallback = idx;
+        const next = survivors.length - 1;
+        if (index === cursor)
+            newCursor = next;
+        else if (index < cursor)
+            fallback = next;
     });
     if (newCursor === -1)
         newCursor = fallback !== -1 ? fallback : survivors.length > 0 ? 0 : -1;
     history.reset(survivors, newCursor);
+    return true;
 }
-async function resolves(memory, ref) {
+async function resolves(store, shell, entry) {
     try {
-        const result = await memory.query(ref, { live: false });
-        return result.node !== null;
+        const query = Query.from({ kind: 'node', paths: [entry.node] }).select({ kind: 'graph' });
+        const response = await store.read(query, { page: { size: 1 } });
+        if (response.result.kind !== 'graph' ||
+            response.result.selection.kind !== 'node' ||
+            response.result.selection.ids.length === 0)
+            return false;
+        if (entry.view === undefined)
+            return true;
+        const routes = await shell.views.resolve(entry.node);
+        return routes.some((candidate) => candidate.route.key === entry.view);
     }
     catch {
         return false;

package/dist/schema/action.hook.d.ts

@@ -0,0 +1,44 @@
+import type { InputOf, InstanceMethod, OutputOf, ReceiverOf, RemoteCallableOf } from '@astrale-os/sdk/domain';
+import type { QueryAST } from '@astrale-os/sdk/query';
+import type { schema } from '@astrale-os/sdk/schema';
+import type { DomainInvokeOptions } from '@astrale-os/shell';
+type Callable = RemoteCallableOf<schema.DomainSchema> | InstanceMethod;
+declare const QUERY_REFRESH: unique symbol;
+export interface QueryRefresh {
+    readonly id: string;
+    readonly [QUERY_REFRESH]: () => {
+        readonly ast: QueryAST;
+        readonly page: Readonly<{
+            readonly size: number;
+        }>;
+    };
+}
+type RefreshableQuery<Input, Query extends QueryAST> = {
+    readonly id: string;
+    readonly page: Readonly<{
+        readonly size: number;
+    }>;
+    prepare?(input: Input): Input;
+    build(input: Input): Query;
+};
+/** Pair one exact named Query definition with its admitted input for targeted invalidation. */
+export declare function queryRefresh<Input, Query extends QueryAST>(definition: RefreshableQuery<Input, Query>, input: Input): QueryRefresh;
+export type ActionRefresh = 'all' | 'none' | {
+    readonly queries: readonly QueryRefresh[];
+};
+export interface ActionOptions extends DomainInvokeOptions {
+    readonly refresh?: ActionRefresh;
+    readonly onError?: (error: unknown) => void;
+}
+type ActionArgs<C extends Callable> = C extends InstanceMethod ? [receiver: ReceiverOf<C>, input: InputOf<C>] : [input: InputOf<C>];
+export interface DomainAction<Args extends unknown[], Result> {
+    run(...args: Args): Promise<Result>;
+    readonly pending: boolean;
+    readonly error: unknown;
+    readonly result: Result | undefined;
+    reset(): void;
+}
+/** Invoke one schema-declared Function or Method and invalidate Store by explicit policy. */
+export declare function useAction<C extends Callable>(callable: C, options?: ActionOptions): DomainAction<ActionArgs<C>, OutputOf<C>>;
+export {};
+//# sourceMappingURL=action.hook.d.ts.map

package/dist/schema/action.hook.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"action.hook.d.ts","sourceRoot":"","sources":["../../src/schema/action.hook.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,OAAO,EACP,cAAc,EACd,QAAQ,EACR,UAAU,EACV,gBAAgB,EACjB,MAAM,wBAAwB,CAAA;AAE/B,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAA;AACrD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAA;AACpD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAA;AAW5D,KAAK,QAAQ,GAAG,gBAAgB,CAAC,MAAM,CAAC,YAAY,CAAC,GAAG,cAAc,CAAA;AAEtE,QAAA,MAAM,aAAa,eAAsC,CAAA;AAEzD,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB,QAAQ,CAAC,CAAC,aAAa,CAAC,EAAE,MAAM;QAC9B,QAAQ,CAAC,GAAG,EAAE,QAAQ,CAAA;QACtB,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;YAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;SAAE,CAAC,CAAA;KACnD,CAAA;CACF;AAED,KAAK,gBAAgB,CAAC,KAAK,EAAE,KAAK,SAAS,QAAQ,IAAI;IACrD,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;IAClD,OAAO,CAAC,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK,CAAA;IAC7B,KAAK,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK,CAAA;CAC3B,CAAA;AAED,+FAA+F;AAC/F,wBAAgB,YAAY,CAAC,KAAK,EAAE,KAAK,SAAS,QAAQ,EACxD,UAAU,EAAE,gBAAgB,CAAC,KAAK,EAAE,KAAK,CAAC,EAC1C,KAAK,EAAE,KAAK,GACX,YAAY,CAQd;AAED,MAAM,MAAM,aAAa,GACrB,KAAK,GACL,MAAM,GACN;IACE,QAAQ,CAAC,OAAO,EAAE,SAAS,YAAY,EAAE,CAAA;CAC1C,CAAA;AAEL,MAAM,WAAW,aAAc,SAAQ,mBAAmB;IACxD,QAAQ,CAAC,OAAO,CAAC,EAAE,aAAa,CAAA;IAChC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAA;CAC5C;AAED,KAAK,UAAU,CAAC,CAAC,SAAS,QAAQ,IAAI,CAAC,SAAS,cAAc,GAC1D,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,GAC5C,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,CAAA;AAEvB,MAAM,WAAW,YAAY,CAAC,IAAI,SAAS,OAAO,EAAE,EAAE,MAAM;IAC1D,GAAG,CAAC,GAAG,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;IACnC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAA;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAA;IACnC,KAAK,IAAI,IAAI,CAAA;CACd;AAED,6FAA6F;AAC7F,wBAAgB,SAAS,CAAC,CAAC,SAAS,QAAQ,EAC1C,QAAQ,EAAE,CAAC,EACX,OAAO,GAAE,aAAkB,GAC1B,YAAY,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC,CAyC1C"}

package/dist/schema/action.hook.js

@@ -0,0 +1,72 @@
+import { Path } from '@astrale-os/sdk/graph/path';
+import { useCallback, useMemo, useRef } from 'react';
+import { useAction as useAsyncAction } from '../graph/action.js';
+import { useGraphStore } from '../graph/store.js';
+import { bindingFor } from './domain.hook.js';
+const QUERY_REFRESH = Symbol('shell-react.query-refresh');
+/** Pair one exact named Query definition with its admitted input for targeted invalidation. */
+export function queryRefresh(definition, input) {
+    return Object.freeze({
+        id: definition.id,
+        [QUERY_REFRESH]: () => {
+            const prepared = definition.prepare?.(input) ?? input;
+            return Object.freeze({ ast: definition.build(prepared), page: definition.page });
+        },
+    });
+}
+/** Invoke one schema-declared Function or Method and invalidate Store by explicit policy. */
+export function useAction(callable, options = {}) {
+    const binding = bindingFor(callable);
+    const store = useGraphStore();
+    const callableRef = useRef(callable);
+    callableRef.current = callable;
+    const bindingRef = useRef(binding);
+    bindingRef.current = binding;
+    const optionsRef = useRef(options);
+    optionsRef.current = options;
+    const invoke = useCallback(async (...args) => {
+        const current = callableRef.current;
+        const policy = optionsRef.current;
+        const { refresh: _refresh, onError: _onError, ...request } = policy;
+        try {
+            const invokeExact = bindingRef.current.$.invoke;
+            const result = 'on' in current
+                ? await invokeExact(current, receiverPath(args[0]), args[1], request)
+                : await invokeExact(current, args[0], request);
+            const refresh = policy.refresh ?? 'all';
+            if (refresh === 'all')
+                store.invalidate();
+            else if (refresh !== 'none') {
+                refresh.queries.forEach((query) => {
+                    const target = query[QUERY_REFRESH]();
+                    store.invalidate(target.ast, { page: target.page });
+                });
+            }
+            return result;
+        }
+        catch (error) {
+            policy.onError?.(error);
+            throw error;
+        }
+    }, [store]);
+    const action = useAsyncAction(invoke);
+    return useMemo(() => projectAction(action), [action]);
+}
+function projectAction(action) {
+    return {
+        run: (...args) => action(...args),
+        get pending() {
+            return action.pending;
+        },
+        get error() {
+            return action.error;
+        },
+        get result() {
+            return action.result;
+        },
+        reset: action.reset,
+    };
+}
+function receiverPath(receiver) {
+    return Path.id(receiver.id).raw;
+}

package/dist/schema/domain.hook.d.ts

@@ -1,10 +1,15 @@
+import type { DomainBinding } from '@astrale-os/shell';
+import { schema } from '@astrale-os/sdk/schema';
 /**
- * useDomain(schema) (API §6) — the typed domain binding, `kernel.withSchema(schema)`,
- * memoized per (effective session, schema). The BoundNodes it mints ride the
- * shared scoped memory, so typed writes are optimistic and revalidate (§6).
+ * Resolve an exact verified DomainBinding. The first render suspends while Session snapshot and schema
+ * revision checks complete; later renders return the retained binding synchronously.
  */
-import type { FnMap, SchemaBoundView } from '@astrale-os/kernel-client';
-import type { Schema } from '@astrale-os/kernel-dsl';
-/** The typed domain binding — `kernel.withSchema(schema)`, memoized per (session, schema). */
-export declare function useDomain<S extends Schema>(schema: S): SchemaBoundView<S, FnMap>;
+export declare function useDomain<const S extends schema.DomainSchema>(schema: S): DomainBinding<S>;
+/** Dynamic verified root binding used by tools that intentionally do not carry a schema witness. */
+export declare function useDynamicDomain(): DomainBinding;
+/** Bind several exact installed schemas behind one Suspense boundary and stable named result. */
+export declare function useDomains<const Schemas extends Readonly<Record<string, schema.DomainSchema>>>(schemas: Schemas): {
+    readonly [Name in keyof Schemas]: DomainBinding<Schemas[Name]>;
+};
+export declare function bindingFor(value: object): DomainBinding;
 //# sourceMappingURL=domain.hook.d.ts.map

package/dist/schema/domain.hook.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"domain.hook.d.ts","sourceRoot":"","sources":["../../src/schema/domain.hook.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,KAAK,EAAE,KAAK,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAA;AACvE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAA;AAMpD,8FAA8F;AAC9F,wBAAgB,SAAS,CAAC,CAAC,SAAS,MAAM,EAAE,MAAM,EAAE,CAAC,GAAG,eAAe,CAAC,CAAC,EAAE,KAAK,CAAC,CAEhF"}
+{"version":3,"file":"domain.hook.d.ts","sourceRoot":"","sources":["../../src/schema/domain.hook.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAgB,MAAM,mBAAmB,CAAA;AAEpE,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAA;AAiB/C;;;GAGG;AACH,wBAAgB,SAAS,CAAC,KAAK,CAAC,CAAC,SAAS,MAAM,CAAC,YAAY,EAAE,MAAM,EAAE,CAAC,GAAG,aAAa,CAAC,CAAC,CAAC,CAe1F;AAED,oGAAoG;AACpG,wBAAgB,gBAAgB,IAAI,aAAa,CAUhD;AAED,iGAAiG;AACjG,wBAAgB,UAAU,CAAC,KAAK,CAAC,OAAO,SAAS,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,YAAY,CAAC,CAAC,EAC5F,OAAO,EAAE,OAAO,GACf;IAAE,QAAQ,EAAE,IAAI,IAAI,MAAM,OAAO,GAAG,aAAa,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;CAAE,CAwBpE;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,aAAa,CAMvD"}

package/dist/schema/domain.hook.js

@@ -1,7 +1,104 @@
+import { schema } from '@astrale-os/sdk/schema';
 import { useSessionKernel } from '../auth/session-kernel.js';
-import { useMemory } from '../graph/memory/scope.js';
-import { bindingFor } from './binding.js';
-/** The typed domain binding — `kernel.withSchema(schema)`, memoized per (session, schema). */
+const typed = new WeakMap();
+const dynamic = new WeakMap();
+const aggregates = new WeakMap();
+const bindingByValue = new WeakMap();
+/**
+ * Resolve an exact verified DomainBinding. The first render suspends while Session snapshot and schema
+ * revision checks complete; later renders return the retained binding synchronously.
+ */
 export function useDomain(schema) {
-    return bindingFor(useSessionKernel(), schema, useMemory());
+    const kernel = useSessionKernel();
+    let bySchema = typed.get(kernel);
+    if (bySchema === undefined) {
+        bySchema = new WeakMap();
+        typed.set(kernel, bySchema);
+    }
+    let resource = bySchema.get(schema);
+    if (resource === undefined) {
+        resource = createResource(kernel.domain(schema));
+        bySchema.set(schema, resource);
+    }
+    const binding = read(resource);
+    registerBinding(binding);
+    return binding;
+}
+/** Dynamic verified root binding used by tools that intentionally do not carry a schema witness. */
+export function useDynamicDomain() {
+    const kernel = useSessionKernel();
+    let resource = dynamic.get(kernel);
+    if (resource === undefined) {
+        resource = createResource(kernel.domain());
+        dynamic.set(kernel, resource);
+    }
+    const binding = read(resource);
+    registerBinding(binding);
+    return binding;
+}
+/** Bind several exact installed schemas behind one Suspense boundary and stable named result. */
+export function useDomains(schemas) {
+    const kernel = useSessionKernel();
+    const names = Object.keys(schemas).sort();
+    if (names.length === 0)
+        return Object.freeze({});
+    const key = names
+        .map((name) => `${name}\u0000${schemas[name].origin}\u0000${schema.revision(schemas[name])}`)
+        .join('\u0001');
+    let bySet = aggregates.get(kernel);
+    if (bySet === undefined) {
+        bySet = new Map();
+        aggregates.set(kernel, bySet);
+    }
+    let resource = bySet.get(key);
+    if (resource === undefined) {
+        resource = createResource(Promise.all(names.map(async (name) => [name, await kernel.domain(schemas[name])])).then((entries) => Object.freeze(Object.fromEntries(entries))));
+        bySet.set(key, resource);
+    }
+    const values = read(resource);
+    Object.values(values).forEach(registerBinding);
+    return values;
+}
+export function bindingFor(value) {
+    const binding = bindingByValue.get(value);
+    if (binding === undefined) {
+        throw new Error('The definition is not owned by a Domain bound in this React runtime.');
+    }
+    return binding;
+}
+function registerBinding(binding) {
+    const seen = new WeakSet();
+    const visit = (value, depth) => {
+        if (depth > 4 || value === null || typeof value !== 'object' || seen.has(value))
+            return;
+        seen.add(value);
+        bindingByValue.set(value, binding);
+        for (const [key, child] of Object.entries(value)) {
+            if (key === 'schema' || key === 'publication' || key === 'session')
+                continue;
+            visit(child, depth + 1);
+        }
+    };
+    visit(binding, 0);
+}
+function createResource(promise) {
+    const cell = {
+        status: 'pending',
+        promise: Promise.resolve(),
+    };
+    cell.promise = promise.then((value) => {
+        cell.status = 'ready';
+        cell.value = value;
+    }, (error) => {
+        cell.status = 'failed';
+        cell.error = error;
+    });
+    return cell;
+}
+function read(resource) {
+    if (resource.status === 'pending')
+        throw resource.promise;
+    if (resource.status === 'failed')
+        throw resource.error;
+    return resource.value;
 }

package/dist/schema/index.d.ts

@@ -1,10 +1,11 @@
 export { useKernel } from './kernel.hook.js';
-export { useDomain } from './domain.hook.js';
-export { useNode, useChildren, useBoundNode, useBoundNodes, useBoundEndpoints, } from './bind-read.js';
-export { useOut, useIn } from '../graph/query/neighbors.hook.js';
-export { useMethod } from './method.hook.js';
-export type { MethodOptions } from './method.hook.js';
-export { useFunction } from './function.hook.js';
-export type { FunctionOptions } from './function.hook.js';
-export type { AutoMethodAction, BoundMethodAction, EndpointResult, FunctionNames, FunctionParams, FunctionResult, MethodIsStatic, MethodNames, MethodParams, MethodResult, TargetedMethodAction, TypedChildrenResult, TypedNodeResult, } from './types.js';
+export { useDomain, useDomains, useDynamicDomain } from './domain.hook.js';
+export { queryRefresh, useAction } from './action.hook.js';
+export type { ActionOptions, ActionRefresh, DomainAction, QueryRefresh } from './action.hook.js';
+export { useMutation } from './mutation.hook.js';
+export type { MutationOptions } from './mutation.hook.js';
+export { useDynamicObject, useObject } from './object.hook.js';
+export type { RichReadOptions } from './object.hook.js';
+export { RelationUnavailableError, useRelation } from './relation.hook.js';
+export type { RelationOptions, RelationResource, RelationUnavailable } from './relation.hook.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/schema/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/schema/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAA;AAC5C,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAA;AAC5C,OAAO,EACL,OAAO,EACP,WAAW,EACX,YAAY,EACZ,aAAa,EACb,iBAAiB,GAClB,MAAM,gBAAgB,CAAA;AACvB,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,kCAAkC,CAAA;AAChE,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAA;AAC5C,YAAY,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAA;AACrD,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAA;AAChD,YAAY,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAA;AACzD,YAAY,EACV,gBAAgB,EAChB,iBAAiB,EACjB,cAAc,EACd,aAAa,EACb,cAAc,EACd,cAAc,EACd,cAAc,EACd,WAAW,EACX,YAAY,EACZ,YAAY,EACZ,oBAAoB,EACpB,mBAAmB,EACnB,eAAe,GAChB,MAAM,YAAY,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/schema/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAA;AAC5C,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAA;AAC1E,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAA;AAC1D,YAAY,EAAE,aAAa,EAAE,aAAa,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAA;AAChG,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAA;AAChD,YAAY,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAA;AACzD,OAAO,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAA;AAC9D,YAAY,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AACvD,OAAO,EAAE,wBAAwB,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAA;AAC1E,YAAY,EAAE,eAAe,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAA"}

package/dist/schema/index.js

@@ -1,8 +1,6 @@
-// schema — the typing substrate (API §6). Typed kernel/domain bindings, typed
-// reads, method/function dispatch. See SHELL_REACT_API.md.
 export { useKernel } from './kernel.hook.js';
-export { useDomain } from './domain.hook.js';
-export { useNode, useChildren, useBoundNode, useBoundNodes, useBoundEndpoints, } from './bind-read.js';
-export { useOut, useIn } from '../graph/query/neighbors.hook.js';
-export { useMethod } from './method.hook.js';
-export { useFunction } from './function.hook.js';
+export { useDomain, useDomains, useDynamicDomain } from './domain.hook.js';
+export { queryRefresh, useAction } from './action.hook.js';
+export { useMutation } from './mutation.hook.js';
+export { useDynamicObject, useObject } from './object.hook.js';
+export { RelationUnavailableError, useRelation } from './relation.hook.js';

package/dist/schema/kernel.hook.d.ts

@@ -1,10 +1,5 @@
-/**
- * useKernel (API §6) — the typed kernel, `kernel.withSchema(KernelSchema)`,
- * memoized per (effective) session. The kernel's own schema baked in; dispatch
- * and reads run as the subtree's principal over its scoped memory (§4).
- */
-import type { FnMap, SchemaBoundView } from '@astrale-os/kernel-client';
-import { KernelSchema } from '@astrale-os/kernel-core';
-/** The typed kernel — `kernel.withSchema(KernelSchema)`, memoized (§4-scoped). */
-export declare function useKernel(): SchemaBoundView<typeof KernelSchema, FnMap>;
+import type { DomainBinding } from '@astrale-os/shell';
+import { KernelSchema } from '@astrale-os/sdk/schema/kernel';
+/** The verified, exactly typed Kernel Domain binding. */
+export declare function useKernel(): DomainBinding<typeof KernelSchema>;
 //# sourceMappingURL=kernel.hook.d.ts.map

package/dist/schema/kernel.hook.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"kernel.hook.d.ts","sourceRoot":"","sources":["../../src/schema/kernel.hook.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,KAAK,EAAE,KAAK,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAA;AAEvE,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAA;AAMtD,kFAAkF;AAClF,wBAAgB,SAAS,IAAI,eAAe,CAAC,OAAO,YAAY,EAAE,KAAK,CAAC,CAEvE"}
+{"version":3,"file":"kernel.hook.d.ts","sourceRoot":"","sources":["../../src/schema/kernel.hook.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAA;AAEtD,OAAO,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAA;AAI5D,yDAAyD;AACzD,wBAAgB,SAAS,IAAI,aAAa,CAAC,OAAO,YAAY,CAAC,CAE9D"}

package/dist/schema/kernel.hook.js

@@ -1,8 +1,6 @@
-import { KernelSchema } from '@astrale-os/kernel-core';
-import { useSessionKernel } from '../auth/session-kernel.js';
-import { useMemory } from '../graph/memory/scope.js';
-import { bindingFor } from './binding.js';
-/** The typed kernel — `kernel.withSchema(KernelSchema)`, memoized (§4-scoped). */
+import { KernelSchema } from '@astrale-os/sdk/schema/kernel';
+import { useDomain } from './domain.hook.js';
+/** The verified, exactly typed Kernel Domain binding. */
 export function useKernel() {
-    return bindingFor(useSessionKernel(), KernelSchema, useMemory());
+    return useDomain(KernelSchema);
 }

package/dist/schema/mutation.hook.d.ts

@@ -0,0 +1,9 @@
+import type { MutationDefinition } from '@astrale-os/sdk/mutation';
+import type { DomainAction } from './action.hook.js';
+export interface MutationOptions {
+    readonly optimistic?: boolean;
+    readonly onError?: (error: unknown) => void;
+}
+/** Execute one named SDK Mutation definition through GraphStore optimism/invalidation. */
+export declare function useMutation<Input, Output>(definition: MutationDefinition<Input, Output>, options?: MutationOptions): DomainAction<[Input], Output>;
+//# sourceMappingURL=mutation.hook.d.ts.map

package/dist/schema/mutation.hook.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mutation.hook.d.ts","sourceRoot":"","sources":["../../src/schema/mutation.hook.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAA;AAMlE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAA;AAKpD,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAAA;IAC7B,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAA;CAC5C;AAED,0FAA0F;AAC1F,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,EACvC,UAAU,EAAE,kBAAkB,CAAC,KAAK,EAAE,MAAM,CAAC,EAC7C,OAAO,GAAE,eAAoB,GAC5B,YAAY,CAAC,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC,CAwB/B"}

package/dist/schema/mutation.hook.js

@@ -0,0 +1,41 @@
+import { bindMutations } from '@astrale-os/sdk/mutation';
+import { useCallback, useMemo, useRef } from 'react';
+import { useAction as useAsyncAction } from '../graph/action.js';
+import { useGraphStore } from '../graph/store.js';
+/** Execute one named SDK Mutation definition through GraphStore optimism/invalidation. */
+export function useMutation(definition, options = {}) {
+    const store = useGraphStore();
+    const definitionRef = useRef(definition);
+    definitionRef.current = definition;
+    const optionsRef = useRef(options);
+    optionsRef.current = options;
+    const run = useCallback(async (input) => {
+        const execute = bindMutations((ast) => store.mutate(ast, {
+            optimistic: optionsRef.current.optimistic ?? true,
+        }));
+        try {
+            return await execute(definitionRef.current, input);
+        }
+        catch (error) {
+            optionsRef.current.onError?.(error);
+            throw error;
+        }
+    }, [store]);
+    const action = useAsyncAction(run);
+    return useMemo(() => project(action), [action]);
+}
+function project(action) {
+    return {
+        run: (input) => action(input),
+        get pending() {
+            return action.pending;
+        },
+        get error() {
+            return action.error;
+        },
+        get result() {
+            return action.result;
+        },
+        reset: action.reset,
+    };
+}

package/dist/schema/object.hook.d.ts

@@ -0,0 +1,16 @@
+import type { BoundInstanceOf, Definition } from '@astrale-os/sdk/domain';
+import type { Node } from '@astrale-os/sdk/graph/node';
+import type { PathLike } from '@astrale-os/sdk/graph/path';
+import type { GraphResource } from '../graph/resource.js';
+export interface RichReadOptions {
+    readonly pageSize?: number;
+}
+type ObjectDefinition = Pick<Definition<'class' | 'interface'>, 'kind' | 'origin' | 'name' | 'key' | 'schemaRef' | 'definition'> & {
+    readonly family: 'node';
+};
+/** Read and bind one exact rich object definition exclusively through GraphStore. */
+export declare function useObject<RichDefinition extends ObjectDefinition>(definition: RichDefinition, target: PathLike | null | undefined, options?: RichReadOptions): GraphResource<BoundInstanceOf<RichDefinition> | null>;
+/** Explicitly untyped point read for inspectors; it never impersonates `useObject`. */
+export declare function useDynamicObject(target: PathLike | null | undefined, options?: RichReadOptions): GraphResource<Node | null>;
+export {};
+//# sourceMappingURL=object.hook.d.ts.map

package/dist/schema/object.hook.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"object.hook.d.ts","sourceRoot":"","sources":["../../src/schema/object.hook.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAA;AACzE,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,4BAA4B,CAAA;AACtD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,4BAA4B,CAAA;AAM1D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AAKzD,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAC3B;AAED,KAAK,gBAAgB,GAAG,IAAI,CAC1B,UAAU,CAAC,OAAO,GAAG,WAAW,CAAC,EACjC,MAAM,GAAG,QAAQ,GAAG,MAAM,GAAG,KAAK,GAAG,WAAW,GAAG,YAAY,CAChE,GAAG;IAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAA;AAE/B,qFAAqF;AACrF,wBAAgB,SAAS,CAAC,cAAc,SAAS,gBAAgB,EAC/D,UAAU,EAAE,cAAc,EAC1B,MAAM,EAAE,QAAQ,GAAG,IAAI,GAAG,SAAS,EACnC,OAAO,GAAE,eAAoB,GAC5B,aAAa,CAAC,eAAe,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,CA8BvD;AAED,uFAAuF;AACvF,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,QAAQ,GAAG,IAAI,GAAG,SAAS,EACnC,OAAO,GAAE,eAAoB,GAC5B,aAAa,CAAC,IAAI,GAAG,IAAI,CAAC,CAoB5B"}

package/dist/schema/object.hook.js

@@ -0,0 +1,46 @@
+import { Path } from '@astrale-os/sdk/graph/path';
+import { Query } from '@astrale-os/sdk/query';
+import { useCallback, useMemo } from 'react';
+import { useStoreResource } from '../graph/resource.js';
+import { bindingFor } from './domain.hook.js';
+/** Read and bind one exact rich object definition exclusively through GraphStore. */
+export function useObject(definition, target, options = {}) {
+    const binding = bindingFor(definition);
+    const path = target === null || target === undefined ? null : Path.from(target);
+    const query = useMemo(() => path === null
+        ? null
+        : Query.from({ kind: 'node', paths: [path], binding: 'object' })
+            .filter({ satisfies: definition.schemaRef })
+            .select({ kind: 'graph' }), [definition, path?.raw]);
+    const project = useCallback((response) => {
+        const result = response.result;
+        if (result.kind !== 'graph' || result.selection.kind !== 'node')
+            return null;
+        const id = result.selection.ids[0];
+        const node = id === undefined
+            ? undefined
+            : result.graph.nodes.find((candidate) => candidate.id === id);
+        const bind = binding.$.bind;
+        return node === undefined ? null : bind(definition, node);
+    }, [binding, definition]);
+    return useStoreResource(query, options.pageSize ?? 1, project);
+}
+/** Explicitly untyped point read for inspectors; it never impersonates `useObject`. */
+export function useDynamicObject(target, options = {}) {
+    const path = target === null || target === undefined ? null : Path.from(target);
+    const query = useMemo(() => path === null
+        ? null
+        : Query.from({ kind: 'node', paths: [path], binding: 'dynamic_object' }).select({
+            kind: 'graph',
+        }), [path?.raw]);
+    const project = useCallback((response) => {
+        const result = response.result;
+        if (result.kind !== 'graph' || result.selection.kind !== 'node')
+            return null;
+        const id = result.selection.ids[0];
+        return id === undefined
+            ? null
+            : (result.graph.nodes.find((candidate) => candidate.id === id) ?? null);
+    }, []);
+    return useStoreResource(query, options.pageSize ?? 1, project);
+}