@astrale-os/adapter-cloudflare 0.4.4 → 0.4.6

package/dist/codegen/wrangler.js

@@ -13,7 +13,7 @@
  */
 import { CLIENT_DIST_DIR } from '../client';
 import { deepMergeConfig } from './merge';
-const COMPATIBILITY_DATE = '2025-03-01';
+const COMPATIBILITY_DATE = '2026-07-12';
 export function generateWranglerConfig(opts) {
     const config = {
         name: opts.workerName,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrale-os/adapter-cloudflare",
-  "version": "0.4.4",
+  "version": "0.4.6",
   "description": "Deploy an Astrale domain as a standalone Cloudflare Worker",
   "keywords": [
     "adapter",
@@ -14,7 +14,8 @@
   "files": [
     "dist",
     "src",
-    "template"
+    "template",
+    "!template/pnpm-lock.yaml"
   ],
   "type": "module",
   "main": "./src/index.ts",
@@ -32,7 +33,7 @@
   },
   "dependencies": {
     "jose": "^6.1.3",
-    "@astrale-os/sdk": "^0.4.5"
+    "@astrale-os/sdk": "^0.4.10"
   },
   "devDependencies": {
     "@astrale-os/ox": ">=0.1.0 <1.0.0",

package/src/codegen/wrangler.ts

@@ -41,7 +41,7 @@ export interface WranglerCodegenOptions {
   wrangler?: Record<string, unknown>
 }
 
-const COMPATIBILITY_DATE = '2025-03-01'
+const COMPATIBILITY_DATE = '2026-07-12'
 
 export function generateWranglerConfig(opts: WranglerCodegenOptions): string {
   const config: Record<string, unknown> = {

package/template/CLAUDE.md

@@ -1,26 +1,13 @@
-# astrale-domain
+# Astrale domain
 
-A standalone Astrale domain — a **blank skeleton**: every folder is wired and
-ready, with no classes, views, or integrations yet. The authoring guide is not in
-this repo — it's the `astrale-domain` agent skill. Load it before changing the
-schema or handlers.
-
-## Agent skills
-
-If the `astrale-domain` / `astrale-cli` skills aren't already available in your
-harness, install them once (user-level):
+Load the `astrale-domain` skill before changing schema, runtime, views, integrations, security, or
+simulation code. Install it user-level if needed:
 
 ```bash
-npx skills add astrale-os/cli -g      # both skills · or run `astrale setup`
+npx skills add astrale-os/cli -g
 ```
 
-They install into your agent harness (not this project), so every Astrale
-project picks them up. `astrale update` refreshes them alongside the CLI binary
-and this project's `@astrale-os/*` dependencies.
-
-## Orientation
-
-See `README.md` for the project layout (`schema/`, `icons.ts`, `core/`,
-`integrations/`, `runtime/`, `views/`, `functions/`, `client/`), the dev/deploy
-loop, and the signing-identity note. `domain.ts` is the one place the domain
-contract is declared.
+This scaffold is intentionally empty. Organize schema, runtime, core, simulation, and client code by
+real bounded contexts. Keep I/O out of `core/`, use one explicit file per method or standalone function,
+wrap nondeterministic handler work in `step`, derive graph keys and paths from the compiled schema, and
+batch graph reads or mutations where possible.

package/template/README.md

@@ -1,120 +1,43 @@
-# astrale-domain
+# Astrale domain
 
-A standalone [Astrale](https://astrale.ai) domain, deployed as an Astrale-managed
-service (default) or as a worker on your own Cloudflare account.
-
-This is a **blank skeleton** — every folder is wired up and ready, but the domain
-ships with no classes, interfaces, views, or integrations. Fill in the terrain;
-nothing here is a demo you have to delete.
-
-## For AI agents
-
-The complete domain-authoring guide is the `astrale-domain` skill (schema
-modeling, handlers, kernel calls, external-API patterns — DI, secrets,
-idempotency — views, webhooks, deploys); CLI operations (auth, instances, calls)
-are the `astrale-cli` skill. Install both once, user-level:
-
-```bash
-npx skills add astrale-os/cli -g      # both skills · or run `astrale setup`
-```
-
-Then load `astrale-domain` before making changes. (Skills are installed into your
-agent harness, not committed to this project — `astrale update` keeps them, the
-CLI, and your `@astrale-os/*` deps current.)
-
-> **Requires [Bun](https://bun.sh)** — the `astrale-domain` CLI behind `pnpm dev`
-> / `pnpm prod` imports `astrale.config.ts` and your ★ files directly, so it
-> needs a TypeScript-native runtime.
+A minimal Astrale domain scaffold. It builds, runs, and deploys before you add any domain concepts.
 
 ```bash
 pnpm install
-pnpm dev                          # wrangler dev → prints a local URL
-astrale domain install <url> --direct    # mount it on an instance (CLI)
-pnpm prod                         # deploy prod → prints a URL
+pnpm dev
+pnpm typecheck
+pnpm test
+pnpm prod
 ```
 
-A freshly-scaffolded skeleton deploys and installs as-is (an empty domain with no
-members) — then you add classes and handlers.
+Load the `astrale-domain` skill before authoring the domain:
 
-## What you write
-
-```
-schema/        classes + interfaces + edges (the data model) + compiled accessors
-icons.ts       class icons (raw SVG), attached via nodeClass({ icon })
-core/<context>/ pure, transport-agnostic logic per bounded context
-integrations/  external-API ports + adapters + a lazy registry (built into deps)
-runtime/       the execute() handlers — the composition root (the methods map)
-views/         iframe-mountable UIs (inline HTML or a client/ SPA)
-functions/     standalone Functions (e.g. webhooks, a postInstall seed)
-client/        the SPA served under /ui
-deps.ts        env → typed Deps container (what handlers read as ctx.deps)
-domain.ts      wires it all together — the worker-safe definition
-astrale.config.ts   binds the domain to its deploy adapter (node-only)
+```bash
+npx skills add astrale-os/cli -g
 ```
 
-`schema/`, `runtime/`, `views/`, and `functions/` start with empty registries;
-`core/` and `integrations/` are empty folders with a short README each explaining
-the pattern. `domain.ts` is the one place the domain contract is declared: it
-imports the modules above and passes them to `defineDomain({ schema, methods,
-deps, views, functions, … })` alongside the identity (`origin`, `requires`,
-`postInstall`). Nothing is discovered by folder name — a renamed or mistyped
-module is a compile error at that call, never a silently-missing route. Drop a
-field (`deps`, `views`, `functions`) when the domain has none. `astrale.config.ts`
-then binds that domain to a deploy adapter with `deploy(domain, cloudflare({ … }))`
-and chooses, per env, which `client` assets serve mounted `/ui` views — keeping
-the node-only adapter (wrangler, filesystem, frontend builds) out of the worker
-bundle.
-
-Everything else — the Worker entry, the wrangler config, the signing identity —
-is generated under `.astrale/` (gitignored) by the adapter. You never edit it.
-
-## The signing identity (back it up!)
-
-The first `pnpm dev`/`pnpm prod` generates an Ed25519 keypair at
-`.astrale/identity.ts`. That private key **is** this domain's identity: every
-instance that installs the domain verifies its credentials against it. The file
-is gitignored, so a fresh clone or a CI runner silently mints a **new** key —
-and redeploying with a new key breaks verification on every existing install.
-Back it up, or move it to a managed secret before deploying from more than one
-machine.
-
-## Extra bindings (KV, R2, D1, queues, …)
-
-The adapter owns the wrangler config, but you can declare extra bindings from
-`astrale.config.ts` via a `wrangler` block on any env — it's deep-merged into
-the generated config:
-
-```ts
-adapter: cloudflare({
-  dev: {
-    secrets: '.env.dev',
-    wrangler: {
-      kv_namespaces: [{ binding: 'CACHE', id: '<kv-id>' }],
-      r2_buckets: [{ binding: 'FILES', bucket_name: 'my-bucket' }],
-    },
-  },
-})
+## Shape
+
+```text
+schema/        vocabulary, split by bounded context
+runtime/       method implementations, split by bounded context and one file per method
+core/          pure deterministic logic, paths, defaults, and domain errors
+integrations/  external-system ports and adapters
+simulation/    samples and business scenarios
+client/        React views built on @astrale-os/shell-react
+icons.ts       shared SVG wrapper; named icons stay with their context
+env.ts         worker bindings and secrets
+deps.ts        env-to-runtime dependency composition
+domain.ts      worker-safe domain assembly
 ```
 
-The merge is additive — arrays concat, so your `services` keep the adapter's
-`SELF` binding and your `compatibility_flags` keep `nodejs_compat`. The
-adapter-owned keys `name`, `main`, `assets`, `routes` are rejected (use
-`workerName` and `route`/`zone`); don't reuse the reserved binding names
-`SELF`/`ASSETS`. Durable Objects aren't supported through this field yet.
-
-## The loop
-
-- **Edit a handler** (`core/` logic or `runtime/` wiring) → hot-reloads at the same URL. Nothing to reinstall.
-- **Edit the schema** (`schema/`) → rebuilds the graph; reinstall with `astrale domain install <url> --direct`.
-- **`postInstall`** — author a standalone `seed` function in `functions/`, reference
-  it from `domain.ts` (`postInstall: functions.seed`), and the kernel runs it once
-  after install, as the system identity, so the domain can lay down its initial
-  graph and set its own grants. Functions are first-class domain members,
-  addressable at `/:origin:function.seed`.
+Keep `schema/index.ts` and `runtime/index.ts` as composition roots. Put standalone functions in the
+bounded context that owns them, then wire them from `domain.ts`; do not create a generic functions
+junk drawer. The same rule applies to views and client code.
 
-## Identity
+The client includes Tailwind CSS v4 and an empty shadcn `radix-nova` setup. Add only the components a
+real view needs with `pnpm exec shadcn add <component>`; component source stays in the project and can
+be adapted to the domain's visual language.
 
-`origin` (in `astrale.config.ts`, defaulting to `schema.domain`) is the domain's
-stable name — the same in every env; only the URL changes. The deployed Worker
-computes its own `binding.remoteUrl` at install from its public URL, so there's
-no hardcoded URL anywhere in your code.
+The adapter generates worker plumbing under `.astrale/`. Do not edit it. The signing identity in
+`.astrale/identity.ts` is gitignored; back it up before deploying from more than one machine.

package/template/client/__tests__/app.test.tsx

@@ -1,66 +1,15 @@
-import { cleanup, render, renderHook, screen, waitFor } from '@testing-library/react'
-import { afterEach, beforeEach, describe, expect, it } from 'vitest'
+import { cleanup, render, screen } from '@testing-library/react'
+import { afterEach, describe, expect, it } from 'vitest'
 
 import { App } from '@/app'
-import { useShell } from '@/shell'
-
-import { installFakeParent, type FakeParent } from './harness'
-
-/**
- * The router picks a view from `window.location.pathname`. This skeleton has no
- * views registered, so every path falls through to the fallback — that's the
- * test below. The second block exercises the shell handshake plumbing (via the
- * fake parent) so you know the seam works the moment you add a real view.
- *
- * `replaceState` rewrites the happy-dom location without a reload.
- */
-function mountAt(path: string) {
-  window.history.replaceState({}, '', path)
-}
-
-beforeEach(() => {
-  mountAt('/ui/anything')
-})
 
 afterEach(cleanup)
 
-describe('router fallback (no views registered)', () => {
-  it('renders the self-describing fallback for any path', () => {
+describe('domain client', () => {
+  it('renders a standalone preview outside the Astrale shell', () => {
     render(<App />)
-    expect(screen.getByText('No view here')).toBeTruthy()
-    expect(screen.getByText(/No view registered for/)).toBeTruthy()
-  })
-})
-
-describe('shell handshake plumbing', () => {
-  let parent: FakeParent | undefined
-
-  afterEach(() => {
-    parent?.restore()
-    parent = undefined
-  })
-
-  it('reaches `ready` with a kernel session after the parent handshake', async () => {
-    parent = installFakeParent({
-      windowId: 'w-1',
-      kernelUrl: 'https://k.example.test/api',
-      functionId: 'fn-1',
-      delegationToken: 'tok-A',
-      tokenExpiresAt: Date.now() + 60_000,
-      targetNodeId: 'node-1',
-    })
-
-    const { result } = renderHook(() => useShell())
-    // waitFor polls inside `act`, so the handshake's async state updates land
-    // wrapped — the parent's `ack` promise need not be awaited separately.
-    await waitFor(() => expect(result.current.status).toBe('ready'))
-    expect(result.current.session).not.toBeNull()
-    expect(result.current.nodeId).toBe('node-1')
-  })
 
-  it('falls back to a standalone preview with no parent', async () => {
-    const { result } = renderHook(() => useShell())
-    await waitFor(() => expect(result.current.status).toBe('standalone'))
-    expect(result.current.session).toBeNull()
+    expect(screen.getByText('Domain client')).toBeTruthy()
+    expect(screen.getByRole('heading', { name: 'Ready to build.' })).toBeTruthy()
   })
 })

package/template/client/components.json

@@ -0,0 +1,25 @@
+{
+  "$schema": "https://ui.shadcn.com/schema.json",
+  "style": "radix-nova",
+  "rsc": false,
+  "tsx": true,
+  "tailwind": {
+    "config": "",
+    "css": "src/styles.css",
+    "baseColor": "neutral",
+    "cssVariables": true,
+    "prefix": ""
+  },
+  "iconLibrary": "lucide",
+  "rtl": false,
+  "aliases": {
+    "components": "@/components",
+    "utils": "@/components/ui/cn",
+    "ui": "@/components/ui",
+    "lib": "@/lib",
+    "hooks": "@/hooks"
+  },
+  "menuColor": "default",
+  "menuAccent": "subtle",
+  "registries": {}
+}

package/template/client/index.html

@@ -3,7 +3,7 @@
   <head>
     <meta charset="utf-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1" />
-    <title>astrale-domain · view</title>
+    <title>Domain view</title>
   </head>
   <body>
     <div id="root"></div>

package/template/client/package.json

@@ -11,16 +11,24 @@
     "test": "vitest run"
   },
   "dependencies": {
-    "@astrale-os/shell": ">=0.3.1 <1.0.0",
+    "@astrale-os/shell-react": ">=0.2.5 <1.0.0",
+    "@fontsource-variable/instrument-sans": "^5.2.8",
+    "@fontsource/ibm-plex-mono": "^5.2.7",
+    "clsx": "^2.1.1",
     "react": "^19.2.0",
-    "react-dom": "^19.2.0"
+    "react-dom": "^19.2.0",
+    "shadcn": "^4.13.0",
+    "tailwind-merge": "^3.6.0",
+    "tw-animate-css": "^1.4.0"
   },
   "devDependencies": {
+    "@tailwindcss/vite": "^4.3.2",
     "@testing-library/react": "^16.3.0",
     "@types/react": "^19.2.0",
     "@types/react-dom": "^19.2.0",
     "@vitejs/plugin-react": "^5.0.4",
     "happy-dom": "^20.0.0",
+    "tailwindcss": "^4.3.2",
     "vite": "^7.1.7",
     "vitest": "^3.2.4"
   }

package/template/client/src/app.tsx

@@ -1,43 +1,52 @@
-/**
- * Path-based view router for the domain's SPA bundle. The shell mounts each Astrale
- * View in its own iframe at its own mount path, so inside the iframe
- * `window.location.pathname` IS that path. `App` reads it (via `resolveView`) and
- * renders the matching view; an unregistered path shows a self-describing fallback.
- *
- * `ROUTES` starts EMPTY — this is a blank skeleton, so every path falls through to
- * `UnknownView`. Add a view by
- *   1. writing a `ViewComponent` (usually wrapping `ViewFrame` — see `@/shell`),
- *   2. adding a `ROUTES` entry keyed by its mount path,
- *   3. registering a matching `defineView({ mount: '/ui/<path>' })` in the domain's
- *      `views/`.
- */
+import { ShellProvider, useTargetNode, type ShellConfig } from '@astrale-os/shell-react'
 
-import { resolveView, useShell, type ViewRoutes } from '@/shell'
-
-const ROUTES: ViewRoutes = {}
+const SHELL_CONFIG: ShellConfig = { mode: 'sandboxed', initTimeoutMs: 8_000 }
 
 export function App() {
-  const shell = useShell()
-  const View = resolveView(ROUTES)
+  if (typeof window === 'undefined' || window.parent === window) return <Preview />
+  return (
+    <ShellProvider config={SHELL_CONFIG} fallback={<Loading />}>
+      <DomainView />
+    </ShellProvider>
+  )
+}
+
+function DomainView() {
+  const target = useTargetNode()
 
-  if (!View) return <UnknownView />
+  return (
+    <main className="mx-auto flex min-h-screen w-full max-w-5xl flex-col justify-center gap-5 px-6 py-20">
+      <p className="font-mono text-xs font-semibold tracking-[0.16em] text-primary uppercase">
+        Domain view
+      </p>
+      <h1 className="max-w-3xl text-5xl leading-[0.95] font-semibold tracking-[-0.055em] md:text-7xl">
+        {target.pending ? 'Loading target…' : 'Ready to build.'}
+      </h1>
+      <p className="max-w-xl text-base text-muted-foreground">
+        Replace this component with the view for your first bounded context.
+      </p>
+    </main>
+  )
+}
 
-  return <>{View(shell)}</>
+function Preview() {
+  return (
+    <main className="mx-auto flex min-h-screen w-full max-w-5xl flex-col justify-center gap-5 px-6 py-20">
+      <p className="font-mono text-xs font-semibold tracking-[0.16em] text-primary uppercase">
+        Domain client
+      </p>
+      <h1 className="max-w-3xl text-5xl leading-[0.95] font-semibold tracking-[-0.055em] md:text-7xl">
+        Ready to build.
+      </h1>
+      <p className="max-w-xl text-base text-muted-foreground">
+        Views run inside the Astrale shell. Start with a bounded context, then add its view.
+      </p>
+    </main>
+  )
 }
 
-/** Fallback when the iframe's mount path has no registered view. */
-function UnknownView() {
+function Loading() {
   return (
-    <div className="wrap">
-      <div className="card">
-        <h1 className="title">No view here</h1>
-        <p className="subline">Astrale view SPA</p>
-        <div className="banner">
-          No view registered for {window.location.pathname}. Add a ROUTES entry in{' '}
-          <code>src/app.tsx</code> (and a matching <code>defineView({'{ mount }'})</code> in the
-          domain's <code>views/</code>).
-        </div>
-      </div>
-    </div>
+    <main className="grid min-h-screen place-items-center text-muted-foreground">Connecting…</main>
   )
 }

package/template/client/src/components/ui/cn.ts

@@ -0,0 +1,6 @@
+import { clsx, type ClassValue } from 'clsx'
+import { twMerge } from 'tailwind-merge'
+
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs))
+}