@astrale-os/shell-react 0.1.0

package/dist/schema/bind-read.js

@@ -0,0 +1,205 @@
+import { BindTypeMismatchError, normalizeRef, } from '@astrale-os/kernel-client';
+import { shapeInputToAST, stableStringify, stripCursors } from '@astrale-os/kernel-client/store';
+import { compileDomain } from '@astrale-os/kernel-core/domain';
+/**
+ * Binder-over-memory composition (API §6, §1.7) — consumed by the `graph/query/`
+ * overloads. Binds wire `Node`s from the shared memory to stable `BoundNode`s
+ * (an unchanged wire node re-binds to the SAME instance), and composes those
+ * binders with a `useSyncExternalStore` read substrate (`useShape`) into the typed
+ * `useNode`/`useChildren` reads. A typed read and its untyped twin ride the SAME
+ * memory shape, so they are one cache entry, one liveness, one overlay.
+ */
+import { useCallback, useMemo, useRef, useSyncExternalStore } from 'react';
+import { useSessionKernel } from '../auth/session-kernel';
+import { idleReadState, isIdleInput } from '../graph/memory/read/idle';
+import { useMemory } from '../graph/memory/scope';
+import { bindingFor } from './binding';
+import { schemaOf, tagSchema } from './tag';
+/** Bind one wire node as `type`; stable while the wire node, binding, and type hold. */
+export function useBoundNode(binding, type, wire) {
+    const ref = useRef(null);
+    const node = wire ?? null;
+    let entry = ref.current;
+    if (entry === null || entry.wire !== node || entry.binding !== binding || entry.type !== type) {
+        entry = {
+            wire: node,
+            binding,
+            type,
+            bound: node === null ? null : binding.bind(type, node),
+        };
+        ref.current = entry;
+    }
+    return entry.bound;
+}
+/**
+ * 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 function useBoundNodes(binding, type, wires, skipMismatch = false) {
+    const ref = useRef(null);
+    if (ref.current === null || ref.current.binding !== binding || ref.current.type !== type) {
+        ref.current = { binding, type, perNode: new WeakMap(), last: [] };
+    }
+    const cache = ref.current;
+    const next = [];
+    for (const w of wires) {
+        let b = cache.perNode.get(w);
+        if (b === undefined) {
+            try {
+                b = binding.bind(type, w);
+            }
+            catch (error) {
+                if (skipMismatch && error instanceof BindTypeMismatchError)
+                    continue;
+                throw error;
+            }
+            cache.perNode.set(w, b);
+        }
+        next.push(b);
+    }
+    if (sameArray(cache.last, next))
+        return cache.last;
+    cache.last = next;
+    return next;
+}
+/** Bind many wire nodes classlessly (traversal endpoints); per-node + stable array. */
+export function useBoundEndpoints(binding, wires) {
+    const ref = useRef(null);
+    if (ref.current === null || ref.current.binding !== binding) {
+        ref.current = { binding, perNode: new WeakMap(), last: [] };
+    }
+    const cache = ref.current;
+    const next = wires.map((w) => {
+        let b = cache.perNode.get(w);
+        if (b === undefined) {
+            b = binding.bindAny(w);
+            cache.perNode.set(w, b);
+        }
+        return b;
+    });
+    if (sameArray(cache.last, next))
+        return cache.last;
+    cache.last = next;
+    return next;
+}
+function sameArray(a, b) {
+    return a.length === b.length && a.every((x, i) => x === b[i]);
+}
+/** Store-facing options — render-time concerns (`suspend`/`keepPrevious`) stay here. */
+function toStoreOptions(opts) {
+    if (opts === undefined)
+        return undefined;
+    const out = {};
+    if (opts.live !== undefined)
+        out.live = opts.live;
+    if (opts.window !== undefined)
+        out.window = opts.window;
+    if (opts.with !== undefined)
+        out.with = opts.with;
+    return out;
+}
+/** A stable string identity for a (shape, options) pair — the subscription key. */
+function keyOf(shape, opts) {
+    const ast = stripCursors(shapeInputToAST(shape));
+    return `${stableStringify(ast)}|${opts?.live === false ? '0' : '1'}|${opts?.window ?? ''}|${opts?.with ?? ''}`;
+}
+/**
+ * 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 function useShape(shape, opts) {
+    const memory = useMemory();
+    const storeOpts = toStoreOptions(opts);
+    const key = isIdleInput(shape) ? null : keyOf(shape, opts);
+    const subscribe = useCallback((onChange) => {
+        if (isIdleInput(shape))
+            return () => { };
+        return memory.subscribe(shape, onChange, storeOpts);
+    }, 
+    // The shape's canonical identity is `key`; the captured `shape` is equivalent.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [memory, key]);
+    const getSnapshot = useCallback(() => (isIdleInput(shape) ? null : memory.getSnapshot(shape, storeOpts)), 
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [memory, key]);
+    const snapshot = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+    if (!isIdleInput(shape) && opts?.suspend !== false && memory.peek(shape, storeOpts) === null) {
+        // Cold FAILURE (§1.4): a rejected fetch with no data throws to the boundary;
+        // re-throwing the promise would re-arm a fetch each retry (infinite loop).
+        if (snapshot !== null && snapshot.error !== undefined)
+            throw snapshot.error;
+        throw memory.promise(shape, storeOpts);
+    }
+    return snapshot;
+}
+// ── typed reads (schema-first useNode, BoundNode-first useChildren) ──────────────
+export function useNode(schema, type, ref, opts) {
+    const binding = bindingFor(useSessionKernel(), schema, useMemory());
+    const shape = isIdleInput(ref) ? null : normalizeRef(ref);
+    const snap = useShape(shape, opts);
+    const wire = snap?.node ?? null;
+    const bound = useBoundNode(binding, type, wire);
+    if (bound !== null)
+        tagSchema(bound, schema);
+    const live = snap === null ? idleReadState() : readStateOf(snap);
+    return useMemo(() => ({ ...live, node: bound }), [bound, live.pending, live.error, live.live, live.seq]);
+}
+export function useChildren(parent, opts) {
+    const kernel = useSessionKernel();
+    const memory = useMemory();
+    const schema = isIdleInput(parent) ? null : requireSchema(parent);
+    const binding = schema === null ? null : bindingFor(kernel, schema, memory);
+    const parentRef = isIdleInput(parent) ? null : `@${parent.id}`;
+    const classRef = schema === null ? undefined : classRefFor(schema, opts.type);
+    const shape = parentRef === null
+        ? null
+        : (q) => q.from(parentRef).children({
+            ...(classRef !== undefined ? { classes: [classRef] } : {}),
+            ...(opts.order !== undefined ? { order: opts.order } : {}),
+            ...(opts.limit !== undefined ? { limit: opts.limit } : {}),
+        });
+    const snap = useShape(shape, opts);
+    const wires = snap?.children ?? EMPTY;
+    const bound = useBoundNodes((binding ?? UNBOUND), opts.type, binding === null ? EMPTY : wires, true);
+    if (schema !== null)
+        for (const b of bound)
+            tagSchema(b, schema);
+    const live = snap === null ? idleReadState() : readStateOf(snap);
+    const more = snap?.more ?? IDLE_MORE;
+    return useMemo(() => ({ ...live, more, children: bound }), [bound, more, live.pending, live.error, live.live, live.seq]);
+}
+// ── helpers ──────────────────────────────────────────────────────────────────
+const EMPTY = Object.freeze([]);
+const IDLE_MORE = { has: false, load: () => Promise.resolve(), pending: false };
+const UNBOUND = {};
+function readStateOf(snap) {
+    return {
+        pending: snap.pending,
+        error: snap.error,
+        live: snap.live,
+        seq: snap.seq,
+        refetch: snap.refetch,
+    };
+}
+/** Recover the schema a BoundNode was bound under; a clear error if it is untagged. */
+export function requireSchema(node) {
+    const schema = schemaOf(node);
+    if (schema === undefined) {
+        throw new Error('useChildren: the parent was not produced by a shell-react typed binding — ' +
+            'obtain it from useNode / useDomain(schema).bind() so its schema is known.');
+    }
+    return schema;
+}
+const compiledCache = new WeakMap();
+/** The descent class ref for a type name (class or interface), or undefined. */
+function classRefFor(schema, type) {
+    let compiled = compiledCache.get(schema);
+    if (compiled === undefined) {
+        compiled = compileDomain(schema);
+        compiledCache.set(schema, compiled);
+    }
+    const accessor = compiled.$;
+    return accessor.c(type)?.path?.class?.raw ?? accessor.i(type)?.path?.class?.raw;
+}

package/dist/schema/binding.d.ts

@@ -0,0 +1,21 @@
+/**
+ * bindingFor(kernel, schema) — memoized `withSchema` handles (API §6). The
+ * `withSchema` handle is a *binding*, never a "view". Memoizes
+ * `createSchemaBoundView` per (session, schema) so a binding — and the BoundNodes
+ * it mints — keep referential identity across renders. Each binding is wrapped so
+ * every BoundNode it hands back is schema-tagged (the traversal hooks read it
+ * back) and its `id → tree path` recorded (the write capability's index).
+ */
+import type { FnMap, NodeRefInput, SchemaBoundView } from '@astrale-os/kernel-client';
+import type { GraphMemory } from '@astrale-os/kernel-client/store';
+import type { Schema } from '@astrale-os/kernel-dsl';
+import type { SessionView } from '../auth/act-as.context';
+/**
+ * Resolve (and memoize) the tagged schema-bound handle for `schema` on `kernel`.
+ * `kernel` is the EFFECTIVE dispatch kernel (root or `<ActAs>` — §4); the cache is
+ * keyed on it, so an acted-as subtree gets its own memoized bindings for free.
+ * `memory` is the SAME scoped memory the read hooks use (1:1 with `kernel`).
+ */
+export declare function bindingFor<S extends Schema>(kernel: SessionView, schema: S, memory: GraphMemory): SchemaBoundView<S, FnMap>;
+export type { NodeRefInput };
+//# sourceMappingURL=binding.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"binding.d.ts","sourceRoot":"","sources":["../../src/schema/binding.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,KAAK,EAAE,KAAK,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAA;AACrF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAA;AAElE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAA;AAIpD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAA;AAUzD;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,CAAC,SAAS,MAAM,EACzC,MAAM,EAAE,WAAW,EACnB,MAAM,EAAE,CAAC,EACT,MAAM,EAAE,WAAW,GAClB,eAAe,CAAC,CAAC,EAAE,KAAK,CAAC,CAa3B;AA0CD,YAAY,EAAE,YAAY,EAAE,CAAA"}

package/dist/schema/binding.js

@@ -0,0 +1,55 @@
+import { createSchemaBoundView } from '@astrale-os/kernel-client';
+import { tagSchema } from './tag';
+import { recordPath, writableFor } from './write';
+/** One tagged binding per (kernel, schema) — shared across the whole tree. */
+const bindingCache = new WeakMap();
+/**
+ * Resolve (and memoize) the tagged schema-bound handle for `schema` on `kernel`.
+ * `kernel` is the EFFECTIVE dispatch kernel (root or `<ActAs>` — §4); the cache is
+ * keyed on it, so an acted-as subtree gets its own memoized bindings for free.
+ * `memory` is the SAME scoped memory the read hooks use (1:1 with `kernel`).
+ */
+export function bindingFor(kernel, schema, memory) {
+    let bySchema = bindingCache.get(kernel);
+    if (bySchema === undefined) {
+        bySchema = new WeakMap();
+        bindingCache.set(kernel, bySchema);
+    }
+    let binding = bySchema.get(schema);
+    if (binding === undefined) {
+        const { writable, pathIndex } = writableFor(kernel, memory);
+        binding = tagBinding(createSchemaBoundView(writable, schema), schema, pathIndex);
+        bySchema.set(schema, binding);
+    }
+    return binding;
+}
+/**
+ * Wrap a binding so `bind`/`bindAny`/`as` outputs carry a schema tag, and every
+ * bound wire node's `id → tree path` is recorded (the write cap's index); the
+ * bare-call dispatch and every other member pass straight through.
+ */
+function tagBinding(binding, schema, pathIndex) {
+    const handler = {
+        apply: (target, _thisArg, args) => target(...args),
+        get: (target, prop, receiver) => {
+            const value = Reflect.get(target, prop, receiver);
+            if (prop === 'bind') {
+                return (type, node, opts) => {
+                    recordPath(pathIndex, node);
+                    return tagSchema(value(type, node, opts), schema);
+                };
+            }
+            if (prop === 'bindAny') {
+                return (node) => {
+                    recordPath(pathIndex, node);
+                    return tagSchema(value(node), schema);
+                };
+            }
+            if (prop === 'as') {
+                return (credential) => tagBinding(value(credential), schema, pathIndex);
+            }
+            return value;
+        },
+    };
+    return new Proxy(binding, handler);
+}

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

@@ -0,0 +1,10 @@
+/**
+ * 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).
+ */
+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>;
+//# sourceMappingURL=domain.hook.d.ts.map

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

@@ -0,0 +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"}

package/dist/schema/domain.hook.js

@@ -0,0 +1,7 @@
+import { useSessionKernel } from '../auth/session-kernel';
+import { useMemory } from '../graph/memory/scope';
+import { bindingFor } from './binding';
+/** The typed domain binding — `kernel.withSchema(schema)`, memoized per (session, schema). */
+export function useDomain(schema) {
+    return bindingFor(useSessionKernel(), schema, useMemory());
+}

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

@@ -0,0 +1,9 @@
+import type { Schema } from '@astrale-os/kernel-dsl';
+import type { Action } from '../graph/action';
+import type { FunctionNames, FunctionParams, FunctionResult } from './types';
+export interface FunctionOptions {
+    /** Extra failure channel; the action still rejects and records `.error`. */
+    onError?: (error: unknown) => void;
+}
+export declare function useFunction<S extends Schema, F extends FunctionNames<S>>(schema: S, fn: F, opts?: FunctionOptions): Action<[FunctionParams<S, F>], FunctionResult<S, F>>;
+//# sourceMappingURL=function.hook.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"function.hook.d.ts","sourceRoot":"","sources":["../../src/schema/function.hook.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAA;AAWpD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAA;AAC7C,OAAO,KAAK,EAAE,aAAa,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAK5E,MAAM,WAAW,eAAe;IAC9B,4EAA4E;IAC5E,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAA;CACnC;AAoBD,wBAAgB,WAAW,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,aAAa,CAAC,CAAC,CAAC,EACtE,MAAM,EAAE,CAAC,EACT,EAAE,EAAE,CAAC,EACL,IAAI,CAAC,EAAE,eAAe,GACrB,MAAM,CAAC,CAAC,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAuBtD"}

package/dist/schema/function.hook.js

@@ -0,0 +1,40 @@
+import { compileDomain } from '@astrale-os/kernel-core/domain';
+/**
+ * `useFunction` (API §6) — `useMethod`'s sibling for a domain's top-level
+ * standalone functions (the `functions` map of `defineSchema`). Dispatched by the
+ * compiled FunctionPath from the compiled-domain accessor, never string-built.
+ * Dispatch is correct but not compile-time typed (see the note in schema/types.ts).
+ */
+import { useCallback, useMemo, useRef } from 'react';
+import { useAction } from '../graph/action';
+import { useDomain } from './domain.hook';
+const compiledCache = new WeakMap();
+/** The dispatch path for a standalone function, from the compiled accessor. */
+function functionPathOf(schema, name) {
+    let compiled = compiledCache.get(schema);
+    if (compiled === undefined) {
+        compiled = compileDomain(schema);
+        compiledCache.set(schema, compiled);
+    }
+    const entry = compiled.$.f(name);
+    if (entry === undefined) {
+        throw new Error(`Unknown function '${name}' in schema '${schema.domain}'`);
+    }
+    return entry.path.domain.raw;
+}
+export function useFunction(schema, fn, opts) {
+    const binding = useDomain(schema);
+    const path = useMemo(() => functionPathOf(schema, String(fn)), [schema, fn]);
+    const onErrorRef = useRef(opts?.onError);
+    onErrorRef.current = opts?.onError;
+    const call = useCallback(async (params) => {
+        try {
+            return (await binding.raw.call(path, params));
+        }
+        catch (error) {
+            onErrorRef.current?.(error);
+            throw error;
+        }
+    }, [binding, path]);
+    return useAction(call);
+}

package/dist/schema/index.d.ts

@@ -0,0 +1,10 @@
+export { useKernel } from './kernel.hook';
+export { useDomain } from './domain.hook';
+export { useNode, useChildren, useBoundNode, useBoundNodes, useBoundEndpoints } from './bind-read';
+export { useOut, useIn } from '../graph/query/neighbors.hook';
+export { useMethod } from './method.hook';
+export type { MethodOptions } from './method.hook';
+export { useFunction } from './function.hook';
+export type { FunctionOptions } from './function.hook';
+export type { AutoMethodAction, BoundMethodAction, EndpointResult, FunctionNames, FunctionParams, FunctionResult, MethodIsStatic, MethodNames, MethodParams, MethodResult, TargetedMethodAction, TypedChildrenResult, TypedNodeResult, } from './types';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/schema/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AACzC,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AACzC,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAA;AAClG,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,+BAA+B,CAAA;AAC7D,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AACzC,YAAY,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;AAClD,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAA;AAC7C,YAAY,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAA;AACtD,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,SAAS,CAAA"}

package/dist/schema/index.js

@@ -0,0 +1,8 @@
+// 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';
+export { useDomain } from './domain.hook';
+export { useNode, useChildren, useBoundNode, useBoundNodes, useBoundEndpoints } from './bind-read';
+export { useOut, useIn } from '../graph/query/neighbors.hook';
+export { useMethod } from './method.hook';
+export { useFunction } from './function.hook';

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

@@ -0,0 +1,10 @@
+/**
+ * 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>;
+//# sourceMappingURL=kernel.hook.d.ts.map

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

@@ -0,0 +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"}

package/dist/schema/kernel.hook.js

@@ -0,0 +1,8 @@
+import { KernelSchema } from '@astrale-os/kernel-core';
+import { useSessionKernel } from '../auth/session-kernel';
+import { useMemory } from '../graph/memory/scope';
+import { bindingFor } from './binding';
+/** The typed kernel — `kernel.withSchema(KernelSchema)`, memoized (§4-scoped). */
+export function useKernel() {
+    return bindingFor(useSessionKernel(), KernelSchema, useMemory());
+}

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

@@ -0,0 +1,14 @@
+import type { NodeRefInput, TypeNames } from '@astrale-os/kernel-client';
+import type { Schema } from '@astrale-os/kernel-dsl';
+import type { AutoMethodAction, BoundMethodAction, MethodNames } from './types';
+export interface MethodOptions {
+    /** Bind the action to this node — dispatch as `action(params)`. */
+    on?: NodeRefInput;
+    /** Extra failure channel; the action still rejects and records `.error`. */
+    onError?: (error: unknown) => void;
+}
+export declare function useMethod<S extends Schema, T extends TypeNames<S>, M extends MethodNames<S, T>>(schema: S, type: T, method: M, opts: MethodOptions & {
+    on: NodeRefInput;
+}): BoundMethodAction<S, T, M>;
+export declare function useMethod<S extends Schema, T extends TypeNames<S>, M extends MethodNames<S, T>>(schema: S, type: T, method: M, opts?: MethodOptions): AutoMethodAction<S, T, M>;
+//# sourceMappingURL=method.hook.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"method.hook.d.ts","sourceRoot":"","sources":["../../src/schema/method.hook.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAA;AACxE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAA;AAcpD,OAAO,KAAK,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAK/E,MAAM,WAAW,aAAa;IAC5B,mEAAmE;IACnE,EAAE,CAAC,EAAE,YAAY,CAAA;IACjB,4EAA4E;IAC5E,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAA;CACnC;AAID,wBAAgB,SAAS,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,SAAS,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,EAC7F,MAAM,EAAE,CAAC,EACT,IAAI,EAAE,CAAC,EACP,MAAM,EAAE,CAAC,EACT,IAAI,EAAE,aAAa,GAAG;IAAE,EAAE,EAAE,YAAY,CAAA;CAAE,GACzC,iBAAiB,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAA;AAC7B,wBAAgB,SAAS,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,SAAS,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,EAC7F,MAAM,EAAE,CAAC,EACT,IAAI,EAAE,CAAC,EACP,MAAM,EAAE,CAAC,EACT,IAAI,CAAC,EAAE,aAAa,GACnB,gBAAgB,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAA"}

package/dist/schema/method.hook.js

@@ -0,0 +1,49 @@
+import { resolveAllMethods } from '@astrale-os/kernel-dsl';
+/**
+ * `useMethod` (API §6) — typed method dispatch with call state. Three forms,
+ * selected by the method's static-ness and whether `on` is given:
+ *   static            → action(params)
+ *   instance + on     → action(params)   (bound to that node)
+ *   instance, no on   → action(ref, params)
+ * Params/result come from the method's Zod contracts.
+ */
+import { useCallback, useMemo, useRef } from 'react';
+import { useAction } from '../graph/action';
+import { useDomain } from './domain.hook';
+export function useMethod(schema, type, method, opts) {
+    const binding = useDomain(schema);
+    const on = opts?.on;
+    const isStatic = useMemo(() => detectStatic(schema, type, String(method)), [schema, type, method]);
+    const onErrorRef = useRef(opts?.onError);
+    onErrorRef.current = opts?.onError;
+    const call = useCallback(async (...args) => {
+        const name = String(method);
+        try {
+            if (on !== undefined)
+                return await instance(binding, type, on, name, args[0]);
+            if (isStatic)
+                return await staticCall(binding, type, name, args[0]);
+            return await instance(binding, type, args[0], name, args[1]);
+        }
+        catch (error) {
+            onErrorRef.current?.(error);
+            throw error;
+        }
+    }, [binding, type, method, on, isStatic]);
+    return useAction(call);
+}
+function staticCall(binding, type, method, params) {
+    return binding(type)[method](params);
+}
+function instance(binding, type, ref, method, params) {
+    return binding(type, ref)[method](params);
+}
+/** Read the method's `static` flag from the schema (own + inherited). */
+function detectStatic(schema, type, method) {
+    const def = schema.classes[type] ??
+        schema.interfaces[type];
+    if (def === undefined)
+        return false;
+    const methods = resolveAllMethods(def);
+    return methods[method]?.config.static === true;
+}

package/dist/schema/tag.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Schema-tagging of raw nodes (API §6, the bindAny bridge). A module-level tag
+ * records the schema each BoundNode was bound under, so the traversal hooks can
+ * recover it from the node alone (`useChildren`/`useOut`/`useIn` re-bind endpoints).
+ */
+import type { Schema } from '@astrale-os/kernel-dsl';
+/** Record the schema a BoundNode was bound under; returns the node unchanged. */
+export declare function tagSchema<N>(node: N, schema: Schema): N;
+/** The schema a BoundNode was bound under, if it came from a shell-react binding. */
+export declare function schemaOf(node: object): Schema | undefined;
+//# sourceMappingURL=tag.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tag.d.ts","sourceRoot":"","sources":["../../src/schema/tag.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAA;AAIpD,iFAAiF;AACjF,wBAAgB,SAAS,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,GAAG,CAAC,CAGvD;AAED,qFAAqF;AACrF,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAEzD"}

package/dist/schema/tag.js

@@ -0,0 +1,11 @@
+const schemaOfNode = new WeakMap();
+/** Record the schema a BoundNode was bound under; returns the node unchanged. */
+export function tagSchema(node, schema) {
+    if (node !== null && typeof node === 'object')
+        schemaOfNode.set(node, schema);
+    return node;
+}
+/** The schema a BoundNode was bound under, if it came from a shell-react binding. */
+export function schemaOf(node) {
+    return schemaOfNode.get(node);
+}

package/dist/schema/types.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Type-level surface for the schema module (API §6): the read envelopes
+ * (`TypedNodeResult`/`TypedChildrenResult`/`EndpointResult`) and the method /
+ * function contract projections. Param inference mirrors the client's proxy
+ * types (Zod optionality preserved), re-derived here because it is not exported.
+ */
+import type { AnyBoundNode, BoundNode, DefOf, EdgeNames, EndpointsOf, NodeRefInput, TypeNames } from '@astrale-os/kernel-client';
+import type { z } from '@astrale-os/kernel-core';
+import type { AllMethods, ExtractMethodNames, ExtractMethodParams, ExtractMethodReturnValue, Schema } from '@astrale-os/kernel-dsl';
+import type { Action } from '../graph/action';
+import type { ReadState, Windowed } from '../graph/memory/read/envelope';
+export interface TypedNodeResult<S extends Schema, T extends TypeNames<S>> extends ReadState {
+    readonly node: BoundNode<DefOf<S, T>, S> | null;
+}
+export interface TypedChildrenResult<S extends Schema, T extends TypeNames<S>> extends ReadState, Windowed {
+    readonly children: readonly BoundNode<DefOf<S, T>, S>[];
+}
+/** Cardinality decides the envelope key: single|null for `1`/`0..1`, array otherwise. */
+export type EndpointResult<S extends Schema, E extends EdgeNames<S>, Side extends 'from' | 'to'> = EndpointsOf<S, E, Side> extends readonly unknown[] ? ReadState & {
+    readonly nodes: EndpointsOf<S, E, Side>;
+} : ReadState & {
+    readonly node: EndpointsOf<S, E, Side>;
+};
+/** Untyped traversal fallback — mirrors the raw `neighbors` shorthand. */
+export interface UntypedEndpointResult<S extends Schema> extends ReadState, Windowed {
+    readonly nodes: readonly AnyBoundNode<S>[];
+}
+/** Dispatchable method names on `type` (own + inherited). */
+export type MethodNames<S extends Schema, T extends TypeNames<S>> = ExtractMethodNames<DefOf<S, T>>;
+type OptionalKeys<P> = {
+    [K in keyof P]: P[K] extends z.ZodOptional<any> | z.ZodDefault<any> ? K : never;
+}[keyof P];
+type RequiredKeys<P> = Exclude<keyof P, OptionalKeys<P>>;
+type InferParams<P> = {
+    [K in RequiredKeys<P>]: P[K] extends z.ZodType<infer T> ? T : never;
+} & {
+    [K in OptionalKeys<P>]?: P[K] extends z.ZodType<infer T> ? T : never;
+};
+type Simplify<T> = {
+    [K in keyof T]: T[K];
+};
+/** Runtime params object for method `M` on `type`. */
+export type MethodParams<S extends Schema, T extends TypeNames<S>, M extends MethodNames<S, T>> = Simplify<InferParams<ExtractMethodParams<DefOf<S, T>, M & string>>>;
+/** Resolved return value of method `M` on `type`. */
+export type MethodResult<S extends Schema, T extends TypeNames<S>, M extends MethodNames<S, T>> = ExtractMethodReturnValue<DefOf<S, T>, M & string>;
+/** True when method `M` on `type` is static. */
+export type MethodIsStatic<S extends Schema, T extends TypeNames<S>, M extends MethodNames<S, T>> = M extends keyof AllMethods<DefOf<S, T>> ? AllMethods<DefOf<S, T>>[M] extends {
+    config: {
+        static: true;
+    };
+} ? true : false : false;
+/** Action for a `on`-bound or static method: `action(params)`. */
+export type BoundMethodAction<S extends Schema, T extends TypeNames<S>, M extends MethodNames<S, T>> = Action<[MethodParams<S, T, M>], MethodResult<S, T, M>>;
+/** Action for an unbound instance method: `action(ref, params)`. */
+export type TargetedMethodAction<S extends Schema, T extends TypeNames<S>, M extends MethodNames<S, T>> = Action<[ref: NodeRefInput, params: MethodParams<S, T, M>], MethodResult<S, T, M>>;
+/** Static → `action(params)`; instance → `action(ref, params)` (no `on`). */
+export type AutoMethodAction<S extends Schema, T extends TypeNames<S>, M extends MethodNames<S, T>> = MethodIsStatic<S, T, M> extends true ? BoundMethodAction<S, T, M> : TargetedMethodAction<S, T, M>;
+/** Standalone top-level function names of the schema (widens to `string` today — see above). */
+export type FunctionNames<S extends Schema> = keyof S['functions'] & string;
+/** Input value of standalone function `F` (`unknown` for a widened `FuncDef` — see above). */
+export type FunctionParams<S extends Schema, F extends FunctionNames<S>> = S['functions'][F] extends {
+    config: {
+        input: infer I;
+    };
+} ? I extends z.ZodType ? z.infer<I> : never : never;
+/** Output value of standalone function `F` (`unknown` for a widened `FuncDef` — see above). */
+export type FunctionResult<S extends Schema, F extends FunctionNames<S>> = S['functions'][F] extends {
+    config: {
+        output: infer O;
+    };
+} ? O extends z.ZodType ? z.infer<O> : never : never;
+export {};
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/schema/types.ts"],"names":[],"mappings":"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"}

package/dist/schema/types.js

@@ -0,0 +1 @@
+export {};

package/dist/schema/write.d.ts

@@ -0,0 +1,15 @@
+import type { GraphMemory } from '@astrale-os/kernel-client/store';
+import type { SessionView } from '../auth/act-as.context';
+/**
+ * One memory-backed writable kernel per (effective) session view, plus the
+ * bind-time `id → tree-path` index it consults. Shared across every schema binding
+ * over the same session so a node bound under any schema resolves for a write.
+ */
+export interface WritableKernel {
+    readonly writable: SessionView;
+    readonly pathIndex: Map<string, string>;
+}
+export declare function writableFor(kernel: SessionView, memory: GraphMemory): WritableKernel;
+/** Record a bound node's `id → tree path` so the write cap can address it. */
+export declare function recordPath(pathIndex: Map<string, string>, node: unknown): void;
+//# sourceMappingURL=write.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"write.d.ts","sourceRoot":"","sources":["../../src/schema/write.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAA;AAElE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAA;AAEzD;;;;GAIG;AACH,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAA;IAC9B,QAAQ,CAAC,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CACxC;AAGD,wBAAgB,WAAW,CAAC,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,WAAW,GAAG,cAAc,CAQpF;AAwCD,8EAA8E;AAC9E,wBAAgB,UAAU,CAAC,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,IAAI,EAAE,OAAO,GAAG,IAAI,CAK9E"}