@astrale-os/shell-react 0.2.1 → 0.2.2

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

@@ -1,6 +1,6 @@
 /**
  * useOut / useIn (API §6) — the public typed traversal read hooks. Resolve
- * endpoints one-shot through `BoundNode.out/in` (`live: false`); become live with
+ * endpoints one-shot through `BoundNode.links.out/in` (`live: false`); become live with
  * no surface change once edge-endpoint ids land. Deviations tracked in API §6/G6.
  */
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
@@ -17,10 +17,7 @@ function useEndpoint(node, edge, side, _opts) {
     const run = useCallback(async () => {
         if (isIdleInput(node))
             return null;
-        // AnyBoundNode omits traversal at the type level; the runtime node (bindAny
-        // → createBoundNode) carries out/in. The edge name is typed by the caller.
-        const t = node;
-        const result = await (side === 'out' ? t.out(edge) : t.in(edge));
+        const result = await (side === 'out' ? node.links.out(edge) : node.links.in(edge));
         if (schema !== undefined)
             tagEndpoints(result, schema);
         return result;

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;AAU5D;;;;;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"}
+{"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"}

package/dist/schema/binding.js

@@ -15,22 +15,21 @@ export function bindingFor(kernel, schema, memory) {
         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);
-    }
+    const cached = bySchema.get(schema);
+    if (cached !== undefined)
+        return cached;
+    const { writable, pathIndex } = writableFor(kernel, memory);
+    const 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.
+ * class handles 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') {
@@ -46,7 +45,8 @@ function tagBinding(binding, schema, pathIndex) {
                 };
             }
             if (prop === 'as') {
-                return (credential) => tagBinding(value(credential), schema, pathIndex);
+                const as = value;
+                return (credential) => tagBinding(as(credential), schema, pathIndex);
             }
             return value;
         },

package/dist/schema/method.hook.js

@@ -33,10 +33,10 @@ export function useMethod(schema, type, method, opts) {
     return useAction(call);
 }
 function staticCall(binding, type, method, params) {
-    return binding(type)[method](params);
+    return binding.classes[type][method](params);
 }
 function instance(binding, type, ref, method, params) {
-    return binding(type, ref)[method](params);
+    return binding.classes[type](ref)[method](params);
 }
 /** Read the method's `static` flag from the schema (own + inherited). */
 function detectStatic(schema, type, method) {

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;AAwCD,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;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"}

package/dist/schema/write.js

@@ -19,8 +19,7 @@ export function writableFor(kernel, memory) {
 function withMemoryWrites(kernel, memory, pathIndex) {
     const base = kernel;
     const rawUpdate = base.updateNode.bind(base);
-    return {
-        ...kernel,
+    return extendCapabilities(kernel, {
         updateNode: (cls, ref, props) => {
             const path = treePathFor(pathIndex, ref);
             return path !== null ? memory.update(path, props) : rawUpdate(cls, ref, props);
@@ -28,7 +27,14 @@ function withMemoryWrites(kernel, memory, pathIndex) {
         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. */
+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;
 }
 /** The tree path an `@<id>` write ref maps to, via the bind-time index; else null. */
 function treePathFor(pathIndex, ref) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrale-os/shell-react",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "description": "Astrale shell-react — the React face of the shell (provider, hooks, view components)",
   "license": "Apache-2.0",
   "repository": {
@@ -25,10 +25,10 @@
     "access": "public"
   },
   "dependencies": {
-    "@astrale-domains/shell-schema": ">=0.3.1 <1.0.0",
-    "@astrale-os/kernel-client": ">=0.4.0 <1.0.0",
-    "@astrale-os/kernel-core": ">=0.7.1 <1.0.0",
-    "@astrale-os/kernel-dsl": ">=0.1.3 <1.0.0",
+    "@astrale-domains/shell-schema": ">=0.3.2 <1.0.0",
+    "@astrale-os/kernel-client": ">=0.4.5 <1.0.0",
+    "@astrale-os/kernel-core": ">=0.7.4 <1.0.0",
+    "@astrale-os/kernel-dsl": ">=0.1.4 <1.0.0",
     "jose": "^6.2.3",
     "zod": "^4.3.6"
   },
@@ -44,7 +44,7 @@
     "react-dom": "^19.2.0",
     "typescript": "~6.0.1-rc",
     "vitest": "^3.2.4",
-    "@astrale-os/shell": "0.3.1"
+    "@astrale-os/shell": "0.3.2"
   },
   "peerDependencies": {
     "@astrale-os/shell": ">=0.2.0 <1.0.0",

package/src/graph/query/neighbors.hook.ts

@@ -3,7 +3,7 @@ import type { Schema } from '@astrale-os/kernel-dsl'
 
 /**
  * useOut / useIn (API §6) — the public typed traversal read hooks. Resolve
- * endpoints one-shot through `BoundNode.out/in` (`live: false`); become live with
+ * endpoints one-shot through `BoundNode.links.out/in` (`live: false`); become live with
  * no surface change once edge-endpoint ids land. Deviations tracked in API §6/G6.
  */
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
@@ -35,24 +35,16 @@ type EndpointEnvelope<S extends Schema> = ReadState & {
   readonly nodes?: readonly AnyBoundNode<S>[]
 }
 
-interface Traversal {
-  out(edge: string): Promise<unknown>
-  in(edge: string): Promise<unknown>
-}
-
 function useEndpoint<S extends Schema>(
   node: AnyBoundNode<S> | null | undefined,
-  edge: string,
+  edge: EdgeNames<S>,
   side: 'out' | 'in',
   _opts?: ReadOptions,
 ): EndpointEnvelope<S> {
   const schema = isIdleInput(node) ? undefined : schemaOf(node)
   const run = useCallback(async (): Promise<unknown> => {
     if (isIdleInput(node)) return null
-    // AnyBoundNode omits traversal at the type level; the runtime node (bindAny
-    // → createBoundNode) carries out/in. The edge name is typed by the caller.
-    const t = node as unknown as Traversal
-    const result = await (side === 'out' ? t.out(edge) : t.in(edge))
+    const result = await (side === 'out' ? node.links.out(edge) : node.links.in(edge))
     if (schema !== undefined) tagEndpoints(result, schema)
     return result
     // eslint-disable-next-line react-hooks/exhaustive-deps

package/src/schema/binding.ts

@@ -18,10 +18,8 @@ import type { SessionView } from '../auth/act-as.context.js'
 import { tagSchema } from './tag.js'
 import { recordPath, writableFor } from './write.js'
 
-type AnyBinding = SchemaBoundView<Schema, FnMap>
-
 /** One tagged binding per (kernel, schema) — shared across the whole tree. */
-const bindingCache = new WeakMap<object, WeakMap<Schema, AnyBinding>>()
+const bindingCache = new WeakMap<object, WeakMap<Schema, unknown>>()
 
 /**
  * Resolve (and memoize) the tagged schema-bound handle for `schema` on `kernel`.
@@ -39,28 +37,26 @@ export function bindingFor<S extends Schema>(
     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) as AnyBinding, schema, pathIndex)
-    bySchema.set(schema, binding)
-  }
-  return binding as SchemaBoundView<S, FnMap>
+  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)
+  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.
+ * class handles and every other member pass straight through.
  */
-function tagBinding(
-  binding: AnyBinding,
-  schema: Schema,
+function tagBinding<S extends Schema>(
+  binding: SchemaBoundView<S, FnMap>,
+  schema: S,
   pathIndex: Map<string, string>,
-): AnyBinding {
-  const handler: ProxyHandler<AnyBinding> = {
-    apply: (target, _thisArg, args) =>
-      (target as unknown as (...a: unknown[]) => unknown)(...(args as unknown[])),
+): SchemaBoundView<S, FnMap> {
+  const handler: ProxyHandler<SchemaBoundView<S, FnMap>> = {
     get: (target, prop, receiver) => {
       const value = Reflect.get(target, prop, receiver) as unknown
       if (prop === 'bind') {
@@ -79,8 +75,9 @@ function tagBinding(
         }
       }
       if (prop === 'as') {
-        return (credential: unknown) =>
-          tagBinding((value as (c: unknown) => AnyBinding)(credential), schema, pathIndex)
+        const as = value as SchemaBoundView<S, FnMap>['as']
+        return (credential: Parameters<typeof as>[0]) =>
+          tagBinding(as(credential), schema, pathIndex)
       }
       return value
     },

package/src/schema/method.hook.ts

@@ -45,7 +45,7 @@ export function useMethod<S extends Schema, T extends TypeNames<S>, M extends Me
   method: M,
   opts?: MethodOptions,
 ): Action<never[], unknown> {
-  const binding = useDomain(schema) as unknown as Dispatcher
+  const binding = useDomain(schema) as unknown as DynamicBinding
   const on = opts?.on
   const isStatic = useMemo(() => detectStatic(schema, type, String(method)), [schema, type, method])
 
@@ -70,26 +70,26 @@ export function useMethod<S extends Schema, T extends TypeNames<S>, M extends Me
   return useAction(call)
 }
 
-/** The bare-call dispatch signature of a `SchemaBoundView`, address-only. */
-type Dispatcher = (type: string, ref?: NodeRefInput) => unknown
+type DynamicClassHandle = Dispatch & ((ref: NodeRefInput) => Dispatch)
+type DynamicBinding = { classes: Record<string, DynamicClassHandle> }
 
 function staticCall(
-  binding: Dispatcher,
+  binding: DynamicBinding,
   type: string,
   method: string,
   params: unknown,
 ): Promise<unknown> {
-  return (binding(type) as unknown as Dispatch)[method]!(params)
+  return binding.classes[type]![method]!(params)
 }
 
 function instance(
-  binding: Dispatcher,
+  binding: DynamicBinding,
   type: string,
   ref: NodeRefInput,
   method: string,
   params: unknown,
 ): Promise<unknown> {
-  return (binding(type, ref) as unknown as Dispatch)[method]!(params)
+  return binding.classes[type]!(ref)[method]!(params)
 }
 
 /** Read the method's `static` flag from the schema (own + inherited). */

package/src/schema/write.ts

@@ -52,8 +52,7 @@ function withMemoryWrites(
     as(cred: CredentialInput | (() => CredentialInput)): SessionView
   }
   const rawUpdate = base.updateNode.bind(base)
-  return {
-    ...(kernel as object),
+  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)
@@ -62,7 +61,18 @@ function withMemoryWrites(
       memory.create(cls, at, props),
     // Credential rebind stays on the raw kernel-client floor (§6 note).
     as: (cred: CredentialInput | (() => CredentialInput)): SessionView => base.as(cred),
-  } as unknown as SessionView
+  })
+}
+
+/** Clone the complete session capability object before overlaying memory writes. */
+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
 }
 
 /** The tree path an `@<id>` write ref maps to, via the bind-time index; else null. */