@astrale-os/shell-react 0.2.4 → 0.2.6

package/dist/index.d.ts

@@ -26,8 +26,8 @@ export { SelectionScope, useSelection } from './selection/index.js';
 export type { Selection, SelectionScopeProps } from './selection/index.js';
 export { useCloseGuard, useTargetNode, useViewsFor, useWindow, useWindowList, useWindows, ViewHost, ViewStage, } from './window/index.js';
 export type { CloseGuard, CloseVerdict, ViewDescriptor, ViewHostProps, ViewSource, ViewHostHandle, ViewsForResult, WindowListEntry, WindowState, WindowView, } from './window/index.js';
-export { useIntent, useSendIntent } from './intents/index.js';
-export type { IntentCtx, IntentPayload, IntentReply, SendIntent } from './intents/index.js';
+export { useEmitIntent, useIntent, useSendIntent } from './intents/index.js';
+export type { EmitIntent, IntentCtx, IntentPayload, IntentReply, SendIntent, } from './intents/index.js';
 export { AppHost, AppLogo, useApps, useCurrentSpace, useOpenApp, useRoles, useSpace, useSpaces, useUser, } from './application/index.js';
 export type { AppHostFallbackState, AppHostProps, AppLogoProps, AppsResult, CurrentSpaceResult, RolesResult, SpaceResult, SpacesResult, } from './application/index.js';
 export type { ApplicationNode, AppSession, RoleNode, SpaceNode, UserNode } from '@astrale-os/shell';

package/dist/index.d.ts.map

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

package/dist/index.js

@@ -25,7 +25,7 @@ export { SelectionScope, useSelection } from './selection/index.js';
 // ─── window (§10) ────────────────────────────────────────────────────────────
 export { useCloseGuard, useTargetNode, useViewsFor, useWindow, useWindowList, useWindows, ViewHost, ViewStage, } from './window/index.js';
 // ─── intents (§11) ───────────────────────────────────────────────────────────
-export { useIntent, useSendIntent } from './intents/index.js';
+export { useEmitIntent, useIntent, useSendIntent } from './intents/index.js';
 // ─── application — the OS plane (§12) ────────────────────────────────────────
 export { AppHost, AppLogo, useApps, useCurrentSpace, useOpenApp, useRoles, useSpace, useSpaces, useUser, } from './application/index.js';
 // ─── error taxonomy (§1.4) — guards + classes, re-exported from kernel-client ─

package/dist/intents/emit-intent.hook.d.ts

@@ -0,0 +1,17 @@
+import type { IntentRegistry } from '@astrale-os/shell';
+import type { IntentPayload } from './envelope.js';
+/** Fire-and-forget intent sender returned by {@link useEmitIntent}. */
+export interface EmitIntent {
+    <K extends keyof IntentRegistry>(name: K, payload: IntentPayload<K>, 
+    /** `to`: `'parent'` (reserved) or a child windowId. Default: the parent, if any. */
+    opts?: {
+        to?: 'parent' | string;
+    }): void;
+}
+/**
+ * Return a stable sender for intents that do not need a reply. Emitted messages
+ * carry no correlation id, so listeners can handle navigation and notifications
+ * without retaining a pending request.
+ */
+export declare function useEmitIntent(): EmitIntent;
+//# sourceMappingURL=emit-intent.hook.d.ts.map

package/dist/intents/emit-intent.hook.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"emit-intent.hook.d.ts","sourceRoot":"","sources":["../../src/intents/emit-intent.hook.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA;AAIvD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;AAMlD,uEAAuE;AACvE,MAAM,WAAW,UAAU;IACzB,CAAC,CAAC,SAAS,MAAM,cAAc,EAC7B,IAAI,EAAE,CAAC,EACP,OAAO,EAAE,aAAa,CAAC,CAAC,CAAC;IACzB,oFAAoF;IACpF,IAAI,CAAC,EAAE;QAAE,EAAE,CAAC,EAAE,QAAQ,GAAG,MAAM,CAAA;KAAE,GAChC,IAAI,CAAA;CACR;AAED;;;;GAIG;AACH,wBAAgB,aAAa,IAAI,UAAU,CAgB1C"}

package/dist/intents/emit-intent.hook.js

@@ -0,0 +1,22 @@
+import { useCallback } from 'react';
+import { useShell } from '../session/shell.hook.js';
+import { intentMessage } from './envelope.js';
+import { resolveIntentTarget } from './resolve-intent-target.js';
+/**
+ * Return a stable sender for intents that do not need a reply. Emitted messages
+ * carry no correlation id, so listeners can handle navigation and notifications
+ * without retaining a pending request.
+ */
+export function useEmitIntent() {
+    const shell = useShell();
+    return useCallback((name, payload, opts) => {
+        const target = resolveIntentTarget(shell, opts?.to);
+        if (target.kind === 'invalid')
+            throw new Error(`useEmitIntent: ${target.reason}`);
+        const message = intentMessage(name, payload);
+        if (target.kind === 'parent')
+            shell.parent.send(message);
+        else
+            shell.children.send(target.windowId, message);
+    }, [shell]);
+}

package/dist/intents/index.d.ts

@@ -1,5 +1,7 @@
 export { useIntent } from './listen-intent.hook.js';
 export type { IntentCtx } from './listen-intent.hook.js';
+export { useEmitIntent } from './emit-intent.hook.js';
+export type { EmitIntent } from './emit-intent.hook.js';
 export { useSendIntent } from './send-intent.hook.js';
 export type { SendIntent } from './send-intent.hook.js';
 export type { IntentPayload, IntentReply } from './envelope.js';

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/intents/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AACnD,YAAY,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AACxD,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAA;AACrD,YAAY,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAA;AACvD,YAAY,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/intents/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AACnD,YAAY,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AACxD,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAA;AACrD,YAAY,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAA;AACvD,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAA;AACrD,YAAY,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAA;AACvD,YAAY,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA"}

package/dist/intents/index.js

@@ -1,3 +1,4 @@
 // intents — API §11 (useIntent, useSendIntent). See SHELL_REACT_API.md.
 export { useIntent } from './listen-intent.hook.js';
+export { useEmitIntent } from './emit-intent.hook.js';
 export { useSendIntent } from './send-intent.hook.js';

package/dist/intents/resolve-intent-target.d.ts

@@ -0,0 +1,12 @@
+import type { Shell } from '@astrale-os/shell';
+export type IntentTarget = {
+    readonly kind: 'parent';
+} | {
+    readonly kind: 'child';
+    readonly windowId: string;
+} | {
+    readonly kind: 'invalid';
+    readonly reason: string;
+};
+export declare function resolveIntentTarget(shell: Shell, to: string | undefined): IntentTarget;
+//# sourceMappingURL=resolve-intent-target.d.ts.map

package/dist/intents/resolve-intent-target.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-intent-target.d.ts","sourceRoot":"","sources":["../../src/intents/resolve-intent-target.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAA;AAE9C,MAAM,MAAM,YAAY,GACpB;IAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;CAAE,GAC3B;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GACrD;IAAE,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAA;AAEzD,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE,EAAE,MAAM,GAAG,SAAS,GAAG,YAAY,CAYtF"}

package/dist/intents/resolve-intent-target.js

@@ -0,0 +1,13 @@
+export function resolveIntentTarget(shell, to) {
+    if (to === undefined) {
+        return shell.parent !== null
+            ? { kind: 'parent' }
+            : { kind: 'invalid', reason: 'no target — pass opts.to (a child windowId) from a root shell' };
+    }
+    if (to === 'parent') {
+        return shell.parent !== null
+            ? { kind: 'parent' }
+            : { kind: 'invalid', reason: "opts.to 'parent' but this shell has no parent channel" };
+    }
+    return { kind: 'child', windowId: to };
+}

package/dist/intents/send-intent.hook.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"send-intent.hook.d.ts","sourceRoot":"","sources":["../../src/intents/send-intent.hook.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAiB,cAAc,EAAS,MAAM,mBAAmB,CAAA;AAW7E,OAAO,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AAK/D,0DAA0D;AAC1D,MAAM,WAAW,UAAU;IACzB,CAAC,CAAC,SAAS,MAAM,cAAc,EAC7B,IAAI,EAAE,CAAC,EACP,OAAO,EAAE,aAAa,CAAC,CAAC,CAAC;IACzB,oFAAoF;IACpF,IAAI,CAAC,EAAE;QAAE,EAAE,CAAC,EAAE,QAAQ,GAAG,MAAM,CAAA;KAAE,GAChC,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAA;CAClC;AAqBD,wBAAgB,aAAa,IAAI,UAAU,CAiE1C"}
+{"version":3,"file":"send-intent.hook.d.ts","sourceRoot":"","sources":["../../src/intents/send-intent.hook.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAiB,cAAc,EAAE,MAAM,mBAAmB,CAAA;AAWtE,OAAO,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AAM/D,0DAA0D;AAC1D,MAAM,WAAW,UAAU;IACzB,CAAC,CAAC,SAAS,MAAM,cAAc,EAC7B,IAAI,EAAE,CAAC,EACP,OAAO,EAAE,aAAa,CAAC,CAAC,CAAC;IACzB,oFAAoF;IACpF,IAAI,CAAC,EAAE;QAAE,EAAE,CAAC,EAAE,QAAQ,GAAG,MAAM,CAAA;KAAE,GAChC,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAA;CAClC;AAED,wBAAgB,aAAa,IAAI,UAAU,CAiE1C"}

package/dist/intents/send-intent.hook.js

@@ -8,19 +8,7 @@
 import { useCallback, useEffect, useRef } from 'react';
 import { useShell } from '../session/shell.hook.js';
 import { INTENT_REPLY, NOOP, intentMessage } from './envelope.js';
-function resolveTarget(shell, to) {
-    if (to === undefined) {
-        return shell.parent !== null
-            ? { kind: 'parent' }
-            : { kind: 'invalid', reason: 'no target — pass opts.to (a child windowId) from a root shell' };
-    }
-    if (to === 'parent') {
-        return shell.parent !== null
-            ? { kind: 'parent' }
-            : { kind: 'invalid', reason: "opts.to 'parent' but this shell has no parent channel" };
-    }
-    return { kind: 'child', windowId: to };
-}
+import { resolveIntentTarget } from './resolve-intent-target.js';
 export function useSendIntent() {
     const shell = useShell();
     // Unmount settlers for in-flight sends, so a pending reply resolves on teardown.
@@ -34,7 +22,7 @@ export function useSendIntent() {
         };
     }, []);
     return useCallback((name, payload, opts) => {
-        const target = resolveTarget(shell, opts?.to);
+        const target = resolveIntentTarget(shell, opts?.to);
         if (target.kind === 'invalid') {
             return Promise.reject(new Error(`useSendIntent: ${target.reason}`));
         }

package/dist/schema/binding.d.ts

@@ -4,7 +4,7 @@
  * `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).
+ * back) and its raw node 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';

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

@@ -1 +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,2BAA2B,CAAA;AAQ5D;;;;;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;AAyCD,YAAY,EAAE,YAAY,EAAE,CAAA"}
+{"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,2BAA2B,CAAA;AAQ5D;;;;;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;AAmGD,YAAY,EAAE,YAAY,EAAE,CAAA"}

package/dist/schema/binding.js

@@ -1,6 +1,6 @@
 import { createSchemaBoundView } from '@astrale-os/kernel-client';
 import { tagSchema } from './tag.js';
-import { recordPath, writableFor } from './write.js';
+import { recordNode, writableFor } from './write.js';
 /** One tagged binding per (kernel, schema) — shared across the whole tree. */
 const bindingCache = new WeakMap();
 /**
@@ -18,38 +18,82 @@ export function bindingFor(kernel, schema, memory) {
     const cached = bySchema.get(schema);
     if (cached !== undefined)
         return cached;
-    const { writable, pathIndex } = writableFor(kernel, memory);
-    const binding = tagBinding(createSchemaBoundView(writable, schema), schema, pathIndex);
+    const { writable, nodeIndex } = writableFor(kernel, memory);
+    const binding = tagBinding(createSchemaBoundView(writable, schema), schema, nodeIndex);
     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
+ * bound wire node is recorded with its class and path (the write cap's index); the
  * class handles and every other member pass straight through.
  */
-function tagBinding(binding, schema, pathIndex) {
+function tagBinding(binding, schema, nodeIndex) {
+    let taggedClasses;
     const handler = {
         get: (target, prop, receiver) => {
             const value = Reflect.get(target, prop, receiver);
+            if (prop === 'node' || prop === 'create') {
+                return async (...args) => tagBoundResult(await value(...args), schema, nodeIndex);
+            }
             if (prop === 'bind') {
                 return (type, node, opts) => {
-                    recordPath(pathIndex, node);
+                    recordNode(nodeIndex, node);
                     return tagSchema(value(type, node, opts), schema);
                 };
             }
             if (prop === 'bindAny') {
                 return (node) => {
-                    recordPath(pathIndex, node);
+                    recordNode(nodeIndex, node);
                     return tagSchema(value(node), schema);
                 };
             }
+            if (prop === 'classes') {
+                taggedClasses ??= tagClassHandles(value, schema, nodeIndex);
+                return taggedClasses;
+            }
             if (prop === 'as') {
                 const as = value;
-                return (credential) => tagBinding(as(credential), schema, pathIndex);
+                return (credential) => tagBinding(as(credential), schema, nodeIndex);
+            }
+            if (prop === 'withSchema') {
+                return (next) => tagBinding(value(next), next, nodeIndex);
             }
             return value;
         },
     };
     return new Proxy(binding, handler);
 }
+function tagClassHandles(classes, schema, nodeIndex) {
+    const handles = new Map();
+    return new Proxy(classes, {
+        get(target, prop, receiver) {
+            const cached = handles.get(prop);
+            if (cached !== undefined)
+                return cached;
+            const handle = Reflect.get(target, prop, receiver);
+            if (typeof handle !== 'function')
+                return handle;
+            const tagged = new Proxy(handle, {
+                get(handleTarget, member, handleReceiver) {
+                    const value = Reflect.get(handleTarget, member, handleReceiver);
+                    if (member !== 'get')
+                        return value;
+                    return async (...args) => tagBoundResult(await value(...args), schema, nodeIndex);
+                },
+            });
+            handles.set(prop, tagged);
+            return tagged;
+        },
+    });
+}
+function tagBoundResult(result, schema, nodeIndex) {
+    const nodes = Array.isArray(result) ? result : [result];
+    for (const node of nodes) {
+        if (node !== null && typeof node === 'object') {
+            recordNode(nodeIndex, node);
+            tagSchema(node, schema);
+        }
+    }
+    return result;
+}

package/dist/schema/write.d.ts

@@ -1,4 +1,5 @@
 import type { GraphMemory } from '@astrale-os/kernel-client/store';
+import type { Node } from '@astrale-os/kernel-core';
 import type { SessionView } from '../auth/act-as.context.js';
 /**
  * One memory-backed writable kernel per (effective) session view, plus the
@@ -7,9 +8,9 @@ import type { SessionView } from '../auth/act-as.context.js';
  */
 export interface WritableKernel {
     readonly writable: SessionView;
-    readonly pathIndex: Map<string, string>;
+    readonly nodeIndex: Map<string, Node>;
 }
 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;
+/** Record a bound node's raw value so the write cap retains its class and tree path. */
+export declare function recordNode(nodeIndex: Map<string, Node>, node: unknown): void;
 //# sourceMappingURL=write.d.ts.map

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

@@ -1 +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,2BAA2B,CAAA;AAE5D;;;;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;AAkDD,8EAA8E;AAC9E,wBAAgB,UAAU,CAAC,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,IAAI,EAAE,OAAO,GAAG,IAAI,CAK9E"}
+{"version":3,"file":"write.d.ts","sourceRoot":"","sources":["../../src/schema/write.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAA;AAClE,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,yBAAyB,CAAA;AAEnD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAA;AAE5D;;;;GAIG;AACH,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAA;IAC9B,QAAQ,CAAC,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,CAAA;CACtC;AAGD,wBAAgB,WAAW,CAAC,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,WAAW,GAAG,cAAc,CAQpF;AAqDD,wFAAwF;AACxF,wBAAgB,UAAU,CAAC,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,EAAE,IAAI,EAAE,OAAO,GAAG,IAAI,CAO5E"}

package/dist/schema/write.js

@@ -2,8 +2,8 @@ const writableCache = new WeakMap();
 export function writableFor(kernel, memory) {
     let entry = writableCache.get(kernel);
     if (entry === undefined) {
-        const pathIndex = new Map();
-        entry = { writable: withMemoryWrites(kernel, memory, pathIndex), pathIndex };
+        const nodeIndex = new Map();
+        entry = { writable: withMemoryWrites(kernel, memory, nodeIndex), nodeIndex };
         writableCache.set(kernel, entry);
     }
     return entry;
@@ -11,41 +11,46 @@ export function writableFor(kernel, memory) {
 /**
  * Wrap a session view so `updateNode`/`createNode` route through the memory's
  * optimistic write shorthands. `BoundNode.update` addresses a node by `@<id>`,
- * but the memory indexes entities by tree path — so an `@<id>` ref is translated
- * through `pathIndex` (populated at bind time). A ref that is NOT indexed (a node
- * that was never read through a hook) falls back to the raw kernel-client floor:
+ * but the memory needs the node's class and tree path — so an `@<id>` ref is translated
+ * through `nodeIndex` (populated at bind time). A ref that is NOT indexed (a node
+ * that was never bound) falls back to the raw kernel-client floor:
  * it still dispatches, just without the overlay — matching the imperative floor.
  */
-function withMemoryWrites(kernel, memory, pathIndex) {
+function withMemoryWrites(kernel, memory, nodeIndex) {
     const base = kernel;
     const rawUpdate = base.updateNode.bind(base);
     return extendCapabilities(kernel, {
         updateNode: (cls, ref, props) => {
-            const path = treePathFor(pathIndex, ref);
-            return path !== null ? memory.update(path, props) : rawUpdate(cls, ref, props);
+            const node = indexedNode(nodeIndex, ref);
+            return node !== null ? memory.update(node, props) : rawUpdate(cls, ref, props);
         },
         createNode: (cls, at, props) => memory.create(cls, at, props),
         // Credential rebind stays on the raw kernel-client floor (§6 note).
         as: (cred) => base.as(cred),
     });
 }
-/** Clone the complete session capability object before overlaying memory writes. */
+/** Overlay memory writes without materializing a possibly virtual session surface. */
 function extendCapabilities(base, extension) {
-    const result = Object.create(Object.getPrototypeOf(base));
-    Object.defineProperties(result, Object.getOwnPropertyDescriptors(base));
-    Object.defineProperties(result, Object.getOwnPropertyDescriptors(extension));
-    return result;
+    return new Proxy(base, {
+        get(target, prop, receiver) {
+            return Object.prototype.hasOwnProperty.call(extension, prop)
+                ? Reflect.get(extension, prop, extension)
+                : Reflect.get(target, prop, receiver);
+        },
+    });
 }
 /** The tree path an `@<id>` write ref maps to, via the bind-time index; else null. */
-function treePathFor(pathIndex, ref) {
+function indexedNode(nodeIndex, ref) {
     if (typeof ref !== 'string' || !ref.startsWith('@'))
         return null;
-    return pathIndex.get(ref.slice(1)) ?? null;
+    return nodeIndex.get(ref.slice(1)) ?? null;
 }
-/** Record a bound node's `id → tree path` so the write cap can address it. */
-export function recordPath(pathIndex, node) {
-    const n = node;
+/** Record a bound node's raw value so the write cap retains its class and tree path. */
+export function recordNode(nodeIndex, node) {
+    const wrapped = node;
+    const candidate = wrapped?.raw !== null && typeof wrapped?.raw === 'object' ? wrapped.raw : node;
+    const n = candidate;
     if (n !== null && typeof n.id === 'string' && typeof n.path?.raw === 'string') {
-        pathIndex.set(n.id, n.path.raw);
+        nodeIndex.set(n.id, candidate);
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrale-os/shell-react",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "description": "Astrale shell-react — the React face of the shell (provider, hooks, view components)",
   "license": "Apache-2.0",
   "repository": {
@@ -26,7 +26,7 @@
   },
   "dependencies": {
     "@astrale-domains/shell-schema": ">=0.3.2 <1.0.0",
-    "@astrale-os/kernel-client": ">=0.4.6 <1.0.0",
+    "@astrale-os/kernel-client": ">=0.4.7 <1.0.0",
     "@astrale-os/kernel-core": ">=0.7.5 <1.0.0",
     "@astrale-os/kernel-dsl": ">=0.1.4 <1.0.0",
     "jose": "^6.2.3",
@@ -44,7 +44,7 @@
     "react-dom": "^19.2.0",
     "typescript": "~6.0.1-rc",
     "vitest": "^3.2.4",
-    "@astrale-os/shell": "0.3.3"
+    "@astrale-os/shell": "0.3.4"
   },
   "peerDependencies": {
     "@astrale-os/shell": ">=0.2.0 <1.0.0",

package/src/index.ts

@@ -117,8 +117,14 @@ export type {
 } from './window/index.js'
 
 // ─── intents (§11) ───────────────────────────────────────────────────────────
-export { useIntent, useSendIntent } from './intents/index.js'
-export type { IntentCtx, IntentPayload, IntentReply, SendIntent } from './intents/index.js'
+export { useEmitIntent, useIntent, useSendIntent } from './intents/index.js'
+export type {
+  EmitIntent,
+  IntentCtx,
+  IntentPayload,
+  IntentReply,
+  SendIntent,
+} from './intents/index.js'
 
 // ─── application — the OS plane (§12) ────────────────────────────────────────
 export {

package/src/intents/emit-intent.hook.ts

@@ -0,0 +1,42 @@
+import type { IntentRegistry } from '@astrale-os/shell'
+
+import { useCallback } from 'react'
+
+import type { IntentPayload } from './envelope.js'
+
+import { useShell } from '../session/shell.hook.js'
+import { intentMessage } from './envelope.js'
+import { resolveIntentTarget } from './resolve-intent-target.js'
+
+/** Fire-and-forget intent sender returned by {@link useEmitIntent}. */
+export interface EmitIntent {
+  <K extends keyof IntentRegistry>(
+    name: K,
+    payload: IntentPayload<K>,
+    /** `to`: `'parent'` (reserved) or a child windowId. Default: the parent, if any. */
+    opts?: { to?: 'parent' | string },
+  ): void
+}
+
+/**
+ * Return a stable sender for intents that do not need a reply. Emitted messages
+ * carry no correlation id, so listeners can handle navigation and notifications
+ * without retaining a pending request.
+ */
+export function useEmitIntent(): EmitIntent {
+  const shell = useShell()
+  return useCallback(
+    <K extends keyof IntentRegistry>(
+      name: K,
+      payload: IntentPayload<K>,
+      opts?: { to?: 'parent' | string },
+    ): void => {
+      const target = resolveIntentTarget(shell, opts?.to)
+      if (target.kind === 'invalid') throw new Error(`useEmitIntent: ${target.reason}`)
+      const message = intentMessage(name, payload)
+      if (target.kind === 'parent') shell.parent!.send(message)
+      else shell.children.send(target.windowId, message)
+    },
+    [shell],
+  )
+}

package/src/intents/index.ts

@@ -1,6 +1,8 @@
 // intents — API §11 (useIntent, useSendIntent). See SHELL_REACT_API.md.
 export { useIntent } from './listen-intent.hook.js'
 export type { IntentCtx } from './listen-intent.hook.js'
+export { useEmitIntent } from './emit-intent.hook.js'
+export type { EmitIntent } from './emit-intent.hook.js'
 export { useSendIntent } from './send-intent.hook.js'
 export type { SendIntent } from './send-intent.hook.js'
 export type { IntentPayload, IntentReply } from './envelope.js'

package/src/intents/resolve-intent-target.ts

@@ -0,0 +1,20 @@
+import type { Shell } from '@astrale-os/shell'
+
+export type IntentTarget =
+  | { readonly kind: 'parent' }
+  | { readonly kind: 'child'; readonly windowId: string }
+  | { readonly kind: 'invalid'; readonly reason: string }
+
+export function resolveIntentTarget(shell: Shell, to: string | undefined): IntentTarget {
+  if (to === undefined) {
+    return shell.parent !== null
+      ? { kind: 'parent' }
+      : { kind: 'invalid', reason: 'no target — pass opts.to (a child windowId) from a root shell' }
+  }
+  if (to === 'parent') {
+    return shell.parent !== null
+      ? { kind: 'parent' }
+      : { kind: 'invalid', reason: "opts.to 'parent' but this shell has no parent channel" }
+  }
+  return { kind: 'child', windowId: to }
+}

package/src/intents/send-intent.hook.ts

@@ -1,4 +1,4 @@
-import type { IntentMessage, IntentRegistry, Shell } from '@astrale-os/shell'
+import type { IntentMessage, IntentRegistry } from '@astrale-os/shell'
 
 /**
  * useSendIntent (API §11) — a stable typed sender. Each call attaches a
@@ -13,6 +13,7 @@ import type { IntentPayload, IntentReply } from './envelope.js'
 
 import { useShell } from '../session/shell.hook.js'
 import { INTENT_REPLY, NOOP, intentMessage } from './envelope.js'
+import { resolveIntentTarget } from './resolve-intent-target.js'
 
 /** The typed sender returned by {@link useSendIntent}. */
 export interface SendIntent {
@@ -24,25 +25,6 @@ export interface SendIntent {
   ): Promise<IntentReply<K> | void>
 }
 
-type Target =
-  | { readonly kind: 'parent' }
-  | { readonly kind: 'child'; readonly windowId: string }
-  | { readonly kind: 'invalid'; readonly reason: string }
-
-function resolveTarget(shell: Shell, to: string | undefined): Target {
-  if (to === undefined) {
-    return shell.parent !== null
-      ? { kind: 'parent' }
-      : { kind: 'invalid', reason: 'no target — pass opts.to (a child windowId) from a root shell' }
-  }
-  if (to === 'parent') {
-    return shell.parent !== null
-      ? { kind: 'parent' }
-      : { kind: 'invalid', reason: "opts.to 'parent' but this shell has no parent channel" }
-  }
-  return { kind: 'child', windowId: to }
-}
-
 export function useSendIntent(): SendIntent {
   const shell = useShell()
   // Unmount settlers for in-flight sends, so a pending reply resolves on teardown.
@@ -61,7 +43,7 @@ export function useSendIntent(): SendIntent {
       payload: IntentPayload<K>,
       opts?: { to?: 'parent' | string },
     ): Promise<IntentReply<K> | void> => {
-      const target = resolveTarget(shell, opts?.to)
+      const target = resolveIntentTarget(shell, opts?.to)
       if (target.kind === 'invalid') {
         return Promise.reject(new Error(`useSendIntent: ${target.reason}`))
       }

package/src/schema/binding.ts

@@ -4,7 +4,7 @@
  * `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).
+ * back) and its raw node 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'
@@ -16,7 +16,7 @@ import { createSchemaBoundView } from '@astrale-os/kernel-client'
 import type { SessionView } from '../auth/act-as.context.js'
 
 import { tagSchema } from './tag.js'
-import { recordPath, writableFor } from './write.js'
+import { recordNode, writableFor } from './write.js'
 
 /** One tagged binding per (kernel, schema) — shared across the whole tree. */
 const bindingCache = new WeakMap<object, WeakMap<Schema, unknown>>()
@@ -40,28 +40,37 @@ export function bindingFor<S extends Schema>(
   const cached = bySchema.get(schema)
   if (cached !== undefined) return cached as SchemaBoundView<S, FnMap>
 
-  const { writable, pathIndex } = writableFor(kernel, memory)
-  const binding = tagBinding(createSchemaBoundView(writable, schema), schema, pathIndex)
+  const { writable, nodeIndex } = writableFor(kernel, memory)
+  const binding = tagBinding(createSchemaBoundView(writable, schema), schema, nodeIndex)
   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
+ * bound wire node is recorded with its class and path (the write cap's index); the
  * class handles and every other member pass straight through.
  */
 function tagBinding<S extends Schema>(
   binding: SchemaBoundView<S, FnMap>,
   schema: S,
-  pathIndex: Map<string, string>,
+  nodeIndex: Map<string, Node>,
 ): SchemaBoundView<S, FnMap> {
+  let taggedClasses: unknown
   const handler: ProxyHandler<SchemaBoundView<S, FnMap>> = {
     get: (target, prop, receiver) => {
       const value = Reflect.get(target, prop, receiver) as unknown
+      if (prop === 'node' || prop === 'create') {
+        return async (...args: unknown[]) =>
+          tagBoundResult(
+            await (value as (...callArgs: unknown[]) => Promise<unknown>)(...args),
+            schema,
+            nodeIndex,
+          )
+      }
       if (prop === 'bind') {
         return (type: string, node: Node, opts?: unknown) => {
-          recordPath(pathIndex, node)
+          recordNode(nodeIndex, node)
           return tagSchema(
             (value as (t: string, n: Node, o?: unknown) => unknown)(type, node, opts),
             schema,
@@ -70,14 +79,22 @@ function tagBinding<S extends Schema>(
       }
       if (prop === 'bindAny') {
         return (node: Node) => {
-          recordPath(pathIndex, node)
+          recordNode(nodeIndex, node)
           return tagSchema((value as (n: Node) => unknown)(node), schema)
         }
       }
+      if (prop === 'classes') {
+        taggedClasses ??= tagClassHandles(value as object, schema, nodeIndex)
+        return taggedClasses
+      }
       if (prop === 'as') {
         const as = value as SchemaBoundView<S, FnMap>['as']
         return (credential: Parameters<typeof as>[0]) =>
-          tagBinding(as(credential), schema, pathIndex)
+          tagBinding(as(credential), schema, nodeIndex)
+      }
+      if (prop === 'withSchema') {
+        return <S2 extends Schema>(next: S2) =>
+          tagBinding((value as SchemaBoundView<S, FnMap>['withSchema'])(next), next, nodeIndex)
       }
       return value
     },
@@ -85,4 +102,45 @@ function tagBinding<S extends Schema>(
   return new Proxy(binding, handler)
 }
 
+function tagClassHandles<S extends Schema>(
+  classes: object,
+  schema: S,
+  nodeIndex: Map<string, Node>,
+): object {
+  const handles = new Map<PropertyKey, unknown>()
+  return new Proxy(classes, {
+    get(target, prop, receiver) {
+      const cached = handles.get(prop)
+      if (cached !== undefined) return cached
+      const handle = Reflect.get(target, prop, receiver) as unknown
+      if (typeof handle !== 'function') return handle
+      const tagged = new Proxy(handle, {
+        get(handleTarget, member, handleReceiver) {
+          const value = Reflect.get(handleTarget, member, handleReceiver) as unknown
+          if (member !== 'get') return value
+          return async (...args: unknown[]) =>
+            tagBoundResult(
+              await (value as (...callArgs: unknown[]) => Promise<unknown>)(...args),
+              schema,
+              nodeIndex,
+            )
+        },
+      })
+      handles.set(prop, tagged)
+      return tagged
+    },
+  })
+}
+
+function tagBoundResult<R>(result: R, schema: Schema, nodeIndex: Map<string, Node>): R {
+  const nodes = Array.isArray(result) ? result : [result]
+  for (const node of nodes) {
+    if (node !== null && typeof node === 'object') {
+      recordNode(nodeIndex, node)
+      tagSchema(node, schema)
+    }
+  }
+  return result
+}
+
 export type { NodeRefInput }

package/src/schema/write.ts

@@ -9,6 +9,7 @@
 import type { CredentialInput } from '@astrale-os/kernel-client'
 import type { PathLike, Properties } from '@astrale-os/kernel-client/graph'
 import type { GraphMemory } from '@astrale-os/kernel-client/store'
+import type { Node } from '@astrale-os/kernel-core'
 
 import type { SessionView } from '../auth/act-as.context.js'
 
@@ -19,15 +20,15 @@ import type { SessionView } from '../auth/act-as.context.js'
  */
 export interface WritableKernel {
   readonly writable: SessionView
-  readonly pathIndex: Map<string, string>
+  readonly nodeIndex: Map<string, Node>
 }
 const writableCache = new WeakMap<object, WritableKernel>()
 
 export function writableFor(kernel: SessionView, memory: GraphMemory): WritableKernel {
   let entry = writableCache.get(kernel)
   if (entry === undefined) {
-    const pathIndex = new Map<string, string>()
-    entry = { writable: withMemoryWrites(kernel, memory, pathIndex), pathIndex }
+    const nodeIndex = new Map<string, Node>()
+    entry = { writable: withMemoryWrites(kernel, memory, nodeIndex), nodeIndex }
     writableCache.set(kernel, entry)
   }
   return entry
@@ -36,15 +37,15 @@ export function writableFor(kernel: SessionView, memory: GraphMemory): WritableK
 /**
  * Wrap a session view so `updateNode`/`createNode` route through the memory's
  * optimistic write shorthands. `BoundNode.update` addresses a node by `@<id>`,
- * but the memory indexes entities by tree path — so an `@<id>` ref is translated
- * through `pathIndex` (populated at bind time). A ref that is NOT indexed (a node
- * that was never read through a hook) falls back to the raw kernel-client floor:
+ * but the memory needs the node's class and tree path — so an `@<id>` ref is translated
+ * through `nodeIndex` (populated at bind time). A ref that is NOT indexed (a node
+ * that was never bound) falls back to the raw kernel-client floor:
  * it still dispatches, just without the overlay — matching the imperative floor.
  */
 function withMemoryWrites(
   kernel: SessionView,
   memory: GraphMemory,
-  pathIndex: Map<string, string>,
+  nodeIndex: Map<string, Node>,
 ): SessionView {
   const base = kernel as unknown as {
     updateNode(cls: PathLike, ref: PathLike, props: Properties): Promise<void>
@@ -54,8 +55,8 @@ function withMemoryWrites(
   const rawUpdate = base.updateNode.bind(base)
   return extendCapabilities(kernel, {
     updateNode: (cls: PathLike, ref: PathLike, props: Properties): Promise<void> => {
-      const path = treePathFor(pathIndex, ref)
-      return path !== null ? memory.update(path, props) : rawUpdate(cls, ref, props)
+      const node = indexedNode(nodeIndex, ref)
+      return node !== null ? memory.update(node, props) : rawUpdate(cls, ref, props)
     },
     createNode: (cls: PathLike, at: PathLike, props?: Properties): Promise<string> =>
       memory.create(cls, at, props),
@@ -64,27 +65,32 @@ function withMemoryWrites(
   })
 }
 
-/** Clone the complete session capability object before overlaying memory writes. */
+/** Overlay memory writes without materializing a possibly virtual session surface. */
 function extendCapabilities<Base extends object, Extension extends object>(
   base: Base,
   extension: Extension,
 ): Base & Extension {
-  const result = Object.create(Object.getPrototypeOf(base)) as Base & Extension
-  Object.defineProperties(result, Object.getOwnPropertyDescriptors(base))
-  Object.defineProperties(result, Object.getOwnPropertyDescriptors(extension))
-  return result
+  return new Proxy(base as Base & Extension, {
+    get(target, prop, receiver) {
+      return Object.prototype.hasOwnProperty.call(extension, prop)
+        ? Reflect.get(extension, prop, extension)
+        : Reflect.get(target, prop, receiver)
+    },
+  })
 }
 
 /** The tree path an `@<id>` write ref maps to, via the bind-time index; else null. */
-function treePathFor(pathIndex: Map<string, string>, ref: PathLike): string | null {
+function indexedNode(nodeIndex: Map<string, Node>, ref: PathLike): Node | null {
   if (typeof ref !== 'string' || !ref.startsWith('@')) return null
-  return pathIndex.get(ref.slice(1)) ?? null
+  return nodeIndex.get(ref.slice(1)) ?? null
 }
 
-/** Record a bound node's `id → tree path` so the write cap can address it. */
-export function recordPath(pathIndex: Map<string, string>, node: unknown): void {
-  const n = node as { id?: unknown; path?: { raw?: unknown } } | null
+/** Record a bound node's raw value so the write cap retains its class and tree path. */
+export function recordNode(nodeIndex: Map<string, Node>, node: unknown): void {
+  const wrapped = node as { raw?: unknown } | null
+  const candidate = wrapped?.raw !== null && typeof wrapped?.raw === 'object' ? wrapped.raw : node
+  const n = candidate as { id?: unknown; path?: { raw?: unknown } } | null
   if (n !== null && typeof n.id === 'string' && typeof n.path?.raw === 'string') {
-    pathIndex.set(n.id, n.path.raw)
+    nodeIndex.set(n.id, candidate as Node)
   }
 }