@astrale-os/adapter-cloudflare 0.4.4 → 0.4.6

package/template/domain.ts

@@ -1,37 +1,11 @@
-/**
- * domain.ts — the WORKER-SAFE domain definition: what the domain IS (its
- * `schema`, `methods`, `deps`, `views`, `functions`) plus its identity
- * (`origin` defaults to `schema.domain`; `requires`; optional `postInstall`).
- * Everything is wired EXPLICITLY here — a renamed or mistyped module is a
- * compile error at this call, never a silently-missing route. The handlers live
- * in `runtime/` (the composition root), the pure logic in `core/`, the
- * external-API ports in `integrations/` — but the worker only ever sees this one
- * wired definition.
- *
- * The maps it wires (`methods`, `views`, `functions`) start empty — this is a
- * blank skeleton. Fill them in their folders and they flow through here with no
- * change needed. Add `postInstall: functions.<key>` once you author a seed
- * function — the kernel calls it once after install, as __SYSTEM__.
- *
- * The generated worker (`.astrale/worker.gen.ts`) imports THIS and spreads it,
- * so your folder layout is invisible to it — reorganize freely; only this wiring
- * has to stay put. The deploy adapter is attached separately in
- * `astrale.config.ts` via `deploy(domain, …)`, keeping its node-only code
- * (wrangler, filesystem, frontend builds) out of the worker bundle.
- */
 import { defineDomain } from '@astrale-os/sdk'
 
 import { deps } from './deps'
-import { functions } from './functions'
 import { methods } from './runtime'
 import { schema } from './schema'
-import { views } from './views'
 
 export const domain = defineDomain({
   schema,
   methods,
   deps,
-  views,
-  functions,
-  requires: [],
 })

package/template/env.ts

@@ -1,24 +1,8 @@
-/**
- * Worker runtime env. The adapter injects `WORKER_URL` and the bindings; your
- * handlers receive this (mapped by `deps.ts`) as `ctx.deps`. Secrets from
- * `.env.<env>` arrive as extra string fields here. Add typed fields as you
- * reference new secrets/vars.
- */
+/** Cloudflare bindings and secrets available to the domain worker. */
 export interface Env {
-  /** The worker's canonical serving URL (its `iss` identity), injected by the
-   * adapter for routed deploys. Optional — dev / workers.dev resolve it from the
-   * per-request Host. */
   WORKER_URL?: string
-  /** Workers Assets binding (serves the client SPA under /ui/*), when present. */
   ASSETS?: { fetch(request: Request): Promise<Response> }
-  /** Self service binding (autobinding — a handler calling its own domain).
-   * Present on Cloudflare deploys AND on current managed runtimes (the host
-   * binds every service to itself). Optional — hosts predating log/SELF
-   * support omit it; for graph reads from views/functions prefer
-   * `ctx.fn.kernel()`. */
   SELF?: { fetch(request: Request): Promise<Response> }
-  /** Dev-only: forward /ui/* to a running Vite dev server. */
   VIEW_DEV_URL?: string
-
   [key: string]: unknown
 }

package/template/icons.ts

@@ -1,25 +1,4 @@
-/**
- * Class icons — raw SVG markup attached to a class via `nodeClass({ icon })`.
- * The kernel materializes the icon onto the class `self` node (the `Iconable`
- * interface) at boot; clients resolve an instance's icon through its class.
- *
- * Markup is raw inner SVG — lift glyphs verbatim from lucide (ISC) and the
- * `svg()` wrapper supplies the `<svg>` shell. `stroke="currentColor"` so the
- * glyph follows text color. Add one constant per class:
- *
- *   import { BOX_ICON } from '../icons'
- *   export const Widget = nodeClass({ icon: BOX_ICON, props: { … } })
- */
-
-const svg = (inner: string): string =>
-  `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round">${inner}</svg>`
-
-/** lucide `box` — a generic starter glyph for your first class. */
-export const BOX_ICON = svg(
-  '<path d="M21 8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16Z"/><path d="m3.3 7 8.7 5 8.7-5"/><path d="M12 22V12"/>',
-)
-
-/** lucide `sparkles` — for an AI / generative class. */
-export const SPARKLES_ICON = svg(
-  '<path d="M9.937 15.5A2 2 0 0 0 8.5 14.063l-6.135-1.582a.5.5 0 0 1 0-.962L8.5 9.936A2 2 0 0 0 9.937 8.5l1.582-6.135a.5.5 0 0 1 .962 0L14.063 8.5A2 2 0 0 0 15.5 9.937l6.135 1.581a.5.5 0 0 1 0 .964L15.5 14.063a2 2 0 0 0-1.437 1.437l-1.582 6.135a.5.5 0 0 1-.962 0z"/><path d="M20 3v4"/><path d="M22 5h-4"/><path d="M4 17v2"/><path d="M5 18H3"/>',
-)
+/** Wrap raw SVG paths for a schema class icon. Keep each named icon with its bounded context. */
+export function icon(paths: string): string {
+  return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round">${paths}</svg>`
+}

package/template/integrations/README.md

@@ -1,22 +1,7 @@
-# integrations/ — external-API ports + adapters
+# Integrations
 
-This is the seam between your domain's logic and the outside world (an HTTP API,
-an SDK, a queue, …). The pattern keeps `runtime/` logic depending on a narrow
-**port** (an interface), never on `fetch` or a vendor SDK directly — so a handler
-is testable against a fake and the backend can be swapped per env or per node.
+External-system ports and adapters live here, grouped by the system they integrate with. Runtime code
+depends on narrow ports; adapters own network I/O and vendor SDKs. Simulation fakes belong under
+`simulation/`, not beside production adapters.
 
-```
-integrations/<service>/
-  port.ts       the interface the logic depends on (the narrowest surface)
-  http.ts       a real adapter implementing the port
-  mock.ts       an offline/deterministic adapter, for tests
-  registry.ts   picks an adapter from `Env` (and optionally the target node),
-                exposed to handlers as part of `Deps`
-```
-
-`deps.ts` builds the registry from the worker `Env` once per isolate and mounts
-it as `ctx.deps`; handlers resolve the concrete port per request. Until you add a
-port, `deps.ts` is a passthrough (`Deps = Env`).
-
-Delete this README once you add your first integration. Load the
-`astrale-domain` skill for the DI / secrets / idempotency patterns.
+Delete this file after adding the first integration.

package/template/package.json

@@ -11,13 +11,14 @@
     "prod": "astrale-domain prod",
     "deploy": "astrale-domain deploy",
     "build": "astrale-domain build",
-    "typecheck": "tsgo --noEmit"
+    "typecheck": "tsgo --noEmit",
+    "test": "vitest run --config vitest.config.ts --passWithNoTests"
   },
   "dependencies": {
-    "@astrale-os/adapter-cloudflare": ">=0.3.2 <1.0.0",
-    "@astrale-os/kernel-core": ">=0.7.3 <1.0.0",
-    "@astrale-os/kernel-dsl": ">=0.1.2 <1.0.0",
-    "@astrale-os/sdk": ">=0.4.4 <1.0.0",
+    "@astrale-os/adapter-cloudflare": ">=0.4.4 <1.0.0",
+    "@astrale-os/kernel-core": ">=0.7.5 <1.0.0",
+    "@astrale-os/kernel-dsl": ">=0.1.4 <1.0.0",
+    "@astrale-os/sdk": ">=0.4.9 <1.0.0",
     "@hono/node-server": "^1.19.0",
     "zod": "^4.3.6"
   },
@@ -25,6 +26,7 @@
     "@types/node": "^22.0.0",
     "@typescript/native-preview": "latest",
     "typescript": "~6.0.1-rc",
+    "vitest": "^3.2.4",
     "wrangler": "^4.0.0"
   },
   "engines": {

package/template/pnpm-workspace.yaml

@@ -24,6 +24,7 @@ allowBuilds:
   '@astrale-os/kernel-server': false
   '@astrale-os/sdk': false
   '@astrale-os/shell': false
+  '@astrale-os/shell-react': false
 
 # @astrale-os packages ship a guarded no-op preinstall (a workspace-dev guard
 # that exits instantly outside the monorepo); declare them intentionally
@@ -36,6 +37,7 @@ ignoredBuiltDependencies:
   - '@astrale-os/kernel-server'
   - '@astrale-os/sdk'
   - '@astrale-os/shell'
+  - '@astrale-os/shell-react'
 
 # pnpm v11 gates `pnpm run` on a deps-status check that misfires on the
 # ignored preinstalls above.

package/template/runtime/index.ts

@@ -1,33 +1,6 @@
-/**
- * Runtime composition root — the ONLY place request context (kernel/self/params/
- * auth) and `deps` meet the per-feature logic. The `methods` map is what
- * `domain.ts` mounts: one entry per class method, each delegating to the pure
- * logic in `core/` and resolving its ports from `deps`. No business logic lives
- * here — this file is just the wiring.
- *
- * It starts EMPTY (`class: {}`). Once you declare a class with methods in
- * `schema/`, wire its handlers here:
- *
- *   import { remoteClassMethods, remoteMethod } from '@astrale-os/sdk'
- *   const method = remoteMethod<Deps>()
- *   const classMethods = remoteClassMethods<Deps>()
- *
- *   const greetMethod = method(schema, 'Greeter', 'greet', {
- *     authorize: async () => undefined,
- *     execute: ({ params }) => ({ message: `hi ${params.name}` }),
- *   })
- *
- *   export const methods: SchemaMethodsImpl<typeof schema, Deps> = {
- *     class: { Greeter: classMethods(schema, 'Greeter', { greet: greetMethod }) },
- *   }
- *
- * Load the `astrale-domain` skill for the full handler/authorize/port patterns.
- */
 import type { SchemaMethodsImpl } from '@astrale-os/sdk'
 
 import type { Deps } from '../deps'
-// While the map is empty, `schema` is only referenced as a type (`typeof schema`).
-// Drop the `type` keyword once you pass `schema` to `method()` / `classMethods()`.
 import type { schema } from '../schema'
 
 export const methods: SchemaMethodsImpl<typeof schema, Deps> = {

package/template/schema/index.ts

@@ -1,17 +1,3 @@
-/**
- * Schema assembly — the one place the domain's contexts come together, and the
- * single source of the domain's stable identity. `schema.domain` (the first arg
- * to `defineSchema`) IS the origin: `astrale.config.ts` defaults `origin` to it,
- * and the worker signs JWTs under it. The scaffolder set this string from your
- * slug; change it here to rename the domain's identity.
- *
- * The maps start EMPTY — this is prepared terrain, not a working domain. Add a
- * context by authoring `schema/<context>.ts` (declare classes with `nodeClass`,
- * interfaces with `nodeInterface`, edges with `edgeClass`), then import its
- * members and list them in the `interfaces` / `classes` maps below. Wire the
- * matching handlers in `runtime/`. Load the `astrale-domain` skill for the
- * authoring patterns.
- */
 import { defineSchema, KernelSchema } from '@astrale-os/kernel-core'
 import { compileDomain, type Domain } from '@astrale-os/kernel-core/domain'
 
@@ -21,10 +7,4 @@ export const schema = defineSchema('astrale-domain.example.dev', {
   imports: [KernelSchema],
 })
 
-/**
- * The compiled domain — resolved class/interface paths + qualified prop keys.
- * `compileDomain` is pure (no env), so this is safe to import from the worker
- * and from build tooling alike. Read graph-facing strings (class paths, prop
- * keys) off `D` once you add classes — never hand-write them.
- */
 export const D: Domain<typeof schema> = compileDomain(schema)

package/template/simulation/README.md

@@ -0,0 +1,12 @@
+# Simulation
+
+Keep domain-level samples and real business scenarios here, organized by bounded context:
+
+```text
+simulation/
+  samples/<context>/
+  scenarios/<business-flow>.test.ts
+```
+
+Use Vitest for scenarios. Prefer the real schema, handlers, and kernel test harness; fake only external
+systems. Demo data must never leak into core data or install hooks.

package/template/tsconfig.json

@@ -17,13 +17,12 @@
     "core",
     "integrations",
     "runtime",
-    "views",
-    "functions",
     "deps.ts",
     "env.ts",
     "domain.ts",
     "icons.ts",
-    "astrale.config.ts"
+    "astrale.config.ts",
+    "vitest.config.ts"
   ],
   "exclude": ["node_modules", ".astrale", ".dist"]
 }

package/template/vitest.config.ts

@@ -0,0 +1,7 @@
+import { defineConfig } from 'vitest/config'
+
+export default defineConfig({
+  test: {
+    include: ['simulation/**/*.test.ts'],
+  },
+})

package/template/.domain-studio/comments.json

@@ -1,4 +0,0 @@
-{
-  "schemaVersion": "",
-  "comments": []
-}

package/template/client/README.md

@@ -1,104 +0,0 @@
-# astrale-domain-client — SPA for domain views
-
-A small React + Vite SPA that renders the domain's Views. It is loaded inside an
-iframe mounted by the Astrale shell, runs the shell handshake (via the real
-`@astrale-os/shell`) to learn its target node id and a kernel session, fetches
-that node from the kernel, and renders it. The bundled status view loads a
-StatusPage, follows its watched Monitor links, and renders the roll-up beside
-the monitored targets, probe timestamps, latency, and HTTP status. "Check now"
-calls the page's `check` instance method and reloads the page plus monitor rows.
-Built into `../.dist/` and served by the generated worker (`.astrale/`) under
-`/ui/*` via its `ASSETS` binding.
-
-## Built on the real shell SDK
-
-This client consumes `@astrale-os/shell` for the child handshake AND the kernel
-client: `src/shell/use-shell.ts` boots `createShell({ mode: 'sandboxed' })`, and
-feature hooks call kernel methods through `shell.kernel` (token refresh, codec
-negotiation, redirect following, and delegation are all handled by the SDK — no
-inline wire code). `@` is aliased to `src/` (mirrors `tsconfig` paths), so feature
-code imports `@/shell`, `@/ui`, `@/status`.
-
-## Layout
-
-Feature-first: each feature owns its types/api/mappers/hooks/components. The
-`shell/` and `ui/` folders are the generic, domain-neutral seams every feature
-builds on. The template ships ONE feature, `status/`, over a StatusPage and its
-watched Monitor nodes.
-
-```
-src/
-  main.tsx              # entry → createRoot(App)
-  app.tsx               # path router: ROUTES { '/ui/status-page': StatusView }
-  styles.css            # self-contained styles (no Tailwind), design tokens
-  shell/                # GENERIC kernel/shell adapter on @astrale-os/shell
-    client.ts           #   prop readers (PROP, readProp, readPropBySuffix) + errors
-    invoke.ts           #   callMethod / invokeNode (@<id>::<method>) / nodeAddr
-    use-shell.ts        #   useShell() → createShell({ mode: 'sandboxed' })
-    use-node.ts         #   useNode(session, id) → @<id>::get (+ reload)
-    use-async.ts        #   generic reloadable async resource
-    use-capability.ts   #   write lifecycle (idle → running → done/failed)
-    transformers.ts     #   qualified-prop / link / node-array shaping
-    view-router.tsx     #   resolveView(routes) + ViewFrame (handshake gate)
-    index.ts            #   barrel → @/shell
-  ui/                   # PURE presentation — no kernel, no hooks
-    surface.tsx         #   Panel / ErrorBanner / EmptyState / Spinner
-    StatusBadge.tsx     #   StatusBadge (up | degraded | down | unknown)
-    value.tsx           #   KV / Mono / ExternalLink
-    format.ts           #   relativeTime
-    index.ts            #   barrel → @/ui
-  status/               # THE status feature — StatusPage + watched Monitors
-    status.types.ts     #   StatusPanelRecord / CheckableRecord
-    status.api.ts       #   check(session, id) → @<id>::check
-    status.mappers.ts   #   checkableFromNode (node → record)
-    hooks/              #   useCheckable.query / useCheck.mutation
-    components/         #   StatusCard (container: hooks + @/ui)
-    index.ts            #   barrel → @/status
-  views/
-    status.tsx          #   StatusView = <ViewFrame>…<StatusCard/></ViewFrame>
-__tests__/
-  harness.ts            # fake shell parent (real protocol) + fake kernel (fetch stub)
-  app.test.tsx          # handshake → render → check now → setTarget → fallback
-  seam.test.tsx         # pure @/ui + @/status hooks in isolation (no handshake)
-  kernel.test.ts        # pure helpers: prop readers, mapper, relativeTime
-```
-
-## Dev loops
-
-```bash
-pnpm dev       # vite build --watch → ../.dist/ (worker auto-reloads, no HMR)
-pnpm dev:hmr   # vite dev on http://127.0.0.1:5173/ (React fast-refresh)
-pnpm test      # vitest run (happy-dom; fake parent speaks the real shell protocol)
-```
-
-For HMR, set `VIEW_DEV_URL=http://127.0.0.1:5173` in the worker's `.dev.vars`;
-the generated worker forwards `/ui/*` to vite.
-
-## How it connects
-
-1. The domain declares each View in `../views/` with `mount: '/ui/<path>'`. The
-   SDK points the View node's iframe at `<serving url>/ui/<path>`.
-2. The shell mounts that iframe and completes the handshake (a transferred
-   `MessagePort` + a `ctrl:handshake` carrying `kernelUrl`, the delegation token,
-   and the `targetNodeId`). `useShell()` boots `@astrale-os/shell`, surfaces the
-   kernel session, and tracks `setTarget` hot-swaps.
-3. A feature loads its node through the session: `useNode(session, nodeId)` calls
-   `@<id>::get` over `shell.kernel`, and a mapper (`checkableFromNode`) projects
-   it to a typed record. Domain props are read by key SUFFIX (`.property.status`,
-   …) because the domain origin is unknown at build time; the name uses the kernel
-   `Named.name` key.
-4. Writes go through `useCapability`: "Check now" runs `@<id>::check`, then calls
-   `useCheckable`'s `reload()` so the fresh status re-renders. The shell's kernel
-   client owns the credential and refreshes it before expiry — features never
-   touch the token.
-
-## Adding a view
-
-1. Write a `ViewComponent` (usually wrapping `ViewFrame`) under `src/views/`.
-2. Add a `ROUTES` entry keyed by its mount path in `src/app.tsx`.
-3. Register a matching `defineView({ mount: '/ui/<path>' })` in the domain's
-   `views/` so the shell mounts an iframe there.
-
-For a NEW feature, mirror `src/status/`: a `*.types.ts`, `*.api.ts`,
-`*.mappers.ts`, a `hooks/` folder of `.query`/`.mutation` hooks, and a
-`components/` folder of containers that compose `@/ui`.

package/template/client/__tests__/harness.ts

@@ -1,230 +0,0 @@
-/**
- * Test harness — a FAKE shell parent + a FAKE kernel, so the client's shell
- * handshake (now `@astrale-os/shell`, `createShell({ mode: 'sandboxed' })`) and
- * its kernel calls can be exercised with no real GUI/kernel.
- *
- * `fakeKernelSession()` is the unit-test counterpart: a `KernelClient` whose
- * `call` hits the fake kernel directly (no handshake), for hooks tested in
- * isolation.
- *
- * The fake parent mirrors `runParentHandshake`
- * (`shell/packages/shell/src/application/windowing/handshake.ts`):
- *   - replies to `astrale-shell/init-request` with `init-response` + a
- *     transferred `MessagePort` (`MessageChannel.port2`),
- *   - posts `ctrl:handshake` over the port with the session data,
- *   - resolves once it receives the child's `ctrl:handshakeAck`,
- *   - then lets a test push `setTarget` intents and `ctrl:tokenRefresh`.
- *
- * The happy-dom env exposes Node's REAL `MessageChannel` (its own `MessagePort`
- * is a no-op stub), so port delivery actually works. `MessageEvent` carries
- * `source`/`ports` via its constructor, and `window.parent` is overridden so
- * 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'
-const INIT_RESPONSE_TYPE = 'astrale-shell/init-response'
-
-export type HandshakePayload = {
-  windowId: string
-  kernelUrl: string
-  functionId: string
-  delegationToken: string
-  tokenExpiresAt: number
-  targetNodeId?: string
-  mintIdentity?: string
-}
-
-export type FakeParent = {
-  /** Resolves once the child acks the handshake (mirrors runParentHandshake). */
-  readonly ack: Promise<void>
-  /** Hot-swap the target node via a `setTarget` intent. */
-  setTarget(nodeId: string): void
-  /** Push a fresh delegation token via `ctrl:tokenRefresh`. */
-  tokenRefresh(delegationToken: string, tokenExpiresAt: number): void
-  /** Restore `window.parent` and detach listeners. */
-  restore(): void
-}
-
-/**
- * Install a fake shell parent. MUST be called BEFORE the child mounts (the
- * child posts `init-request` to `window.parent` in a mount effect).
- */
-export function installFakeParent(payload: HandshakePayload): FakeParent {
-  const originalParentDesc = Object.getOwnPropertyDescriptor(window, 'parent')
-
-  let port: MessagePort | null = null
-  let ackResolve!: () => void
-  const ack = new Promise<void>((r) => {
-    ackResolve = r
-  })
-
-  // The fake parent object — its `postMessage` receives the child's init-request.
-  const fakeParent = {
-    postMessage(message: unknown, _targetOrigin?: string) {
-      if (
-        message !== null &&
-        typeof message === 'object' &&
-        (message as { type?: unknown }).type === INIT_REQUEST_TYPE
-      ) {
-        onInitRequest()
-      }
-    },
-  }
-
-  function onInitRequest() {
-    const channel = new MessageChannel()
-    port = channel.port1
-
-    port.onmessage = (ev: MessageEvent) => {
-      const msg = ev.data as { type?: string; action?: string } | null
-      if (msg && msg.type === 'ctrl' && msg.action === 'handshakeAck') {
-        ackResolve()
-      }
-    }
-    port.start()
-
-    // Transfer port2 to the child via an init-response on `window`.
-    window.dispatchEvent(
-      new MessageEvent('message', {
-        data: { type: INIT_RESPONSE_TYPE, version: 1, windowId: payload.windowId },
-        source: fakeParent as unknown as Window,
-        ports: [channel.port2],
-      }),
-    )
-
-    // Then the handshake control message carrying the session data.
-    port.postMessage({
-      type: 'ctrl',
-      version: 1,
-      action: 'handshake',
-      data: {
-        delegationToken: payload.delegationToken,
-        tokenExpiresAt: payload.tokenExpiresAt,
-        windowId: payload.windowId,
-        kernelUrl: payload.kernelUrl,
-        functionId: payload.functionId,
-        targetNodeId: payload.targetNodeId,
-        mintIdentity: payload.mintIdentity,
-      },
-    })
-  }
-
-  Object.defineProperty(window, 'parent', { value: fakeParent, configurable: true })
-
-  return {
-    ack,
-    setTarget(nodeId: string) {
-      port?.postMessage({
-        type: 'intent',
-        version: 1,
-        envelope: { name: 'setTarget', payload: { nodeId }, sender: { windowId: '<parent>' } },
-      })
-    },
-    tokenRefresh(delegationToken: string, tokenExpiresAt: number) {
-      port?.postMessage({
-        type: 'ctrl',
-        version: 1,
-        action: 'tokenRefresh',
-        data: { delegationToken, tokenExpiresAt },
-      })
-    },
-    restore() {
-      if (port) {
-        port.onmessage = null
-        port.close()
-      }
-      if (originalParentDesc) Object.defineProperty(window, 'parent', originalParentDesc)
-    },
-  }
-}
-
-// ─── Fake kernel (fetch stub) ────────────────────────────────────────────────
-
-export type CapturedRequest = {
-  url: string
-  method: string
-  headers: Record<string, string>
-  body: { method: string; params: unknown; id: unknown }
-}
-
-export type FakeKernel = {
-  /** Every request the client made, in order. */
-  readonly calls: CapturedRequest[]
-  /** Restore the global `fetch`. */
-  restore(): void
-}
-
-/**
- * Replace global `fetch` with a stub that records each kernel request and
- * returns whatever `respond` yields for it (a kernel envelope value, JSON-
- * encoded). `respond` sees the parsed envelope body and the call index.
- */
-export function installFakeKernel(
-  respond: (body: CapturedRequest['body'], index: number) => unknown,
-): FakeKernel {
-  const calls: CapturedRequest[] = []
-  const original = globalThis.fetch
-
-  globalThis.fetch = (async (input: RequestInfo | URL, init?: RequestInit) => {
-    const url = typeof input === 'string' ? input : input.toString()
-    const headers: Record<string, string> = {}
-    const h = init?.headers
-    if (h && typeof h === 'object' && !Array.isArray(h)) {
-      for (const [k, v] of Object.entries(h)) headers[k.toLowerCase()] = String(v)
-    }
-    const body = JSON.parse(String(init?.body ?? '{}')) as CapturedRequest['body']
-    const captured: CapturedRequest = {
-      url,
-      method: String(init?.method ?? 'GET'),
-      headers,
-      body,
-    }
-    calls.push(captured)
-    const envelope = respond(body, calls.length - 1)
-    return new Response(JSON.stringify(envelope), {
-      status: 200,
-      headers: { 'content-type': 'application/vnd.astrale.kernel+json' },
-    })
-  }) as typeof fetch
-
-  return {
-    calls,
-    restore() {
-      globalThis.fetch = original
-    },
-  }
-}
-
-/** Wrap a value as a success envelope `{ result }` (what the kernel returns). */
-export function ok(result: unknown): { result: unknown } {
-  return { result }
-}
-
-/**
- * A `KernelClient` for unit tests that exercise feature hooks WITHOUT a
- * 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 {
-  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: () => 'tok-A',
-    url: kernelUrl,
-  })
-}

package/template/client/__tests__/shell.test.ts

@@ -1,46 +0,0 @@
-/**
- * The kernel-boundary plumbing every view builds on, tested with ZERO
- * infrastructure — no shell, no kernel, no session. Props in, values out. These
- * are the helpers `@/shell` exposes for reading qualified node props (which the
- * kernel stores under domain-prefixed keys) plus the shared display formatters.
- * Your feature mappers (`<feature>.mappers.ts`) build on these.
- */
-import { describe, expect, it } from 'vitest'
-
-import { qualifiedString, readProp, readPropBySuffix } from '@/shell'
-import { relativeTime } from '@/ui'
-
-describe('prop readers', () => {
-  it('readProp returns the string value at the exact key', () => {
-    expect(readProp({ a: 'x', b: 1 }, 'a')).toBe('x')
-    expect(readProp({ a: 'x' }, 'missing')).toBeUndefined()
-    expect(readProp({ a: 1 }, 'a')).toBeUndefined() // non-string
-  })
-
-  it('readPropBySuffix matches the first key ending with the suffix', () => {
-    const props = {
-      'acme.example.dev:class.Widget.property.label': 'Hello',
-      'kernel.astrale.ai:interface.Named.property.name': 'n',
-    }
-    expect(readPropBySuffix(props, '.property.label')).toBe('Hello')
-    expect(readPropBySuffix(props, '.property.status')).toBeUndefined()
-  })
-
-  it('qualifiedString prefers a domain key over the kernel one for the same suffix', () => {
-    const props = {
-      'kernel.astrale.ai:interface.Named.property.name': 'kernel name',
-      'acme.example.dev:class.Widget.property.name': 'domain name',
-    }
-    expect(qualifiedString(props, 'name')).toBe('domain name')
-  })
-})
-
-describe('relativeTime', () => {
-  const now = Date.parse('2026-06-14T12:00:00Z')
-  it('renders coarse buckets and a dash for missing input', () => {
-    expect(relativeTime(undefined, now)).toBe('—')
-    expect(relativeTime('2026-06-14T11:55:00Z', now)).toBe('5m ago')
-    expect(relativeTime('2026-06-14T10:00:00Z', now)).toBe('2h ago')
-    expect(relativeTime('not-a-date', now)).toBe('not-a-date')
-  })
-})