@astrale-os/adapter-cloudflare 0.4.2 → 0.4.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrale-os/adapter-cloudflare",
-  "version": "0.4.2",
+  "version": "0.4.3",
   "description": "Deploy an Astrale domain as a standalone Cloudflare Worker",
   "keywords": [
     "adapter",
@@ -32,7 +32,7 @@
   },
   "dependencies": {
     "jose": "^6.1.3",
-    "@astrale-os/sdk": "^0.4.2"
+    "@astrale-os/sdk": "^0.4.4"
   },
   "devDependencies": {
     "@astrale-os/ox": ">=0.1.0 <1.0.0",

package/template/client/__tests__/harness.ts

@@ -21,6 +21,8 @@
  * the child believes it is framed.
  */
 
+import { createKernelClientAdapter } from '@astrale-os/shell'
+
 import type { KernelClient } from '@/shell'
 
 const INIT_REQUEST_TYPE = 'astrale-shell/init-request'
@@ -204,37 +206,25 @@ export function ok(result: unknown): { result: unknown } {
 
 /**
  * A `KernelClient` for unit tests that exercise feature hooks WITHOUT a
- * handshake. Its `call` POSTs the kernel JSON envelope (`{ method, params, id }`)
- * so the `installFakeKernel` fetch stub records it and `body.method`/
- * `body.params` assertions hold — same wire the real `shell.kernel` speaks to a
- * JSON kernel. The credential surface (`mintDelegation`/`authToken`/`url`) is
- * stubbed minimally — the isolated hooks under test only ever touch `call`.
+ * handshake — the REAL bound client over the fake `fetch`. `call` (and the graph
+ * sugar `get`/`query`/`mutate`/…) POST the kernel JSON envelope
+ * (`{ method, params, id }`) that `installFakeKernel` records, so `body.method`/
+ * `body.params` assertions hold — the same wire `shell.kernel` speaks. Built on
+ * `createKernelClientAdapter` so it always satisfies `KernelClient` as that
+ * surface grows; the deprecated iframe extras (`mintDelegation`/`authToken`/
+ * `url`) are stubbed, exactly as the shell adds them around the same bound view.
  */
 export function fakeKernelSession(kernelUrl = 'https://k.example.test/api'): KernelClient {
-  let idSeq = 0
-  return {
-    async call(method: string, params: unknown = {}): Promise<unknown> {
-      idSeq += 1
-      const res = await fetch(kernelUrl, {
-        method: 'POST',
-        headers: {
-          'content-type': 'application/vnd.astrale.kernel+json',
-          accept: 'application/vnd.astrale.kernel+json',
-          authorization: 'tok-A',
-        },
-        body: JSON.stringify({ method, params, id: `c${idSeq}` }),
-      })
-      const obj = (await res.json()) as Record<string, unknown>
-      if (obj.error && typeof obj.error === 'object') {
-        const err = obj.error as { code?: unknown; message?: unknown }
-        const code = typeof err.code === 'number' ? err.code : 5000
-        const message = typeof err.message === 'string' ? err.message : 'Unknown error'
-        throw new Error(`${code}: ${message}`)
-      }
-      return obj.result
-    },
+  const adapter = createKernelClientAdapter({
+    url: kernelUrl,
+    // Read `globalThis.fetch` per request so `installFakeKernel` (which swaps it
+    // in after this session is built) is the one that answers.
+    fetch: (input, init) => globalThis.fetch(input as RequestInfo, init),
+  })
+  const view = adapter.boundView(() => 'tok-A')
+  return Object.assign(view, {
     mintDelegation: async () => '<fake>',
-    authToken: () => '<fake>',
+    authToken: () => 'tok-A',
     url: kernelUrl,
-  }
+  })
 }

package/template/client/src/shell/use-node.ts

@@ -4,10 +4,27 @@ import { useCallback, useEffect, useState } from 'react'
 
 import { errorMessage, type KernelNode } from './client'
 
-type KernelReadClient = KernelClient & {
-  get(
-    path: string,
-  ): Promise<{ node: { id: string } | null; wire: { nodes: readonly KernelNode[] } }>
+/**
+ * The node shape `shell.kernel.get()` resolves — a graph `Node` ({@link
+ * KernelClient.get} returns `Node | null`). Derived from the client's own
+ * return type so this file never imports server schema; mapped onto the plain
+ * {@link KernelNode} the view helpers consume by `toKernelNode`.
+ */
+type GraphNode = NonNullable<Awaited<ReturnType<KernelClient['get']>>>
+
+/**
+ * Project a graph `Node` onto the plain, schema-free {@link KernelNode}. `path`
+ * and `class` arrive as typed `Path` instances over the wire — `String()` yields
+ * their raw form (and is the identity on a plain string), so this stays correct
+ * whether or not the client hydrates them.
+ */
+function toKernelNode(node: GraphNode): KernelNode {
+  return {
+    id: String(node.id),
+    path: String(node.path),
+    class: String(node.class),
+    props: { ...node.props },
+  }
 }
 
 export type NodeState =
@@ -38,21 +55,16 @@ export function useNode(
     }
 
     let cancelled = false
-    const kernel = session as KernelReadClient
     setState({ status: 'loading' })
-    kernel
+    session
       .get(`@${nodeId}`)
-      .then((result) => {
+      .then((node) => {
         if (cancelled) return
-        const node =
-          result.node === null
-            ? null
-            : (result.wire.nodes.find((n) => n.id === result.node?.id) ?? null)
         if (node === null) {
           setState({ status: 'error', message: 'Node not found or not visible' })
           return
         }
-        setState({ status: 'ok', node })
+        setState({ status: 'ok', node: toKernelNode(node) })
       })
       .catch((err: unknown) => {
         if (!cancelled) {

package/template/client/vitest.config.ts

@@ -15,10 +15,13 @@ export default defineConfig({
     environment: 'happy-dom',
     globals: true,
     include: ['__tests__/**/*.test.{ts,tsx}', 'src/**/*.test.{ts,tsx}'],
-    // `@astrale-os/*` ship bundler-targeted ESM (extensionless relative imports).
-    // vitest externalizes node_modules and uses Node's stricter ESM resolver,
-    // which wants explicit `.js`; inlining the scope makes vitest transform them
-    // through vite — the same context the build uses. Standard for these deps.
-    server: { deps: { inline: [/@astrale-os\//] } },
+    // `@astrale-os/*` ship bundler-targeted ESM (extensionless relative imports);
+    // Node's stricter ESM resolver, which vitest uses for externalized deps,
+    // wants explicit `.js`. Pre-bundle the scope's entrypoint with esbuild (a
+    // bundler — it resolves extensionless imports), which pulls the whole
+    // transitive `@astrale-os/*` graph (shell → kernel-client → kernel-core) into
+    // one resolvable module. `web` (not `ssr`) is the optimizer the happy-dom
+    // environment runs. Standard workaround for these deps.
+    deps: { optimizer: { web: { enabled: true, include: ['@astrale-os/shell'] } } },
   },
 })