acrylblends 0.7.8 → 0.8.1

package/templates/chat/test/chat.test.ts

@@ -0,0 +1,198 @@
+import assert from 'node:assert/strict'
+import { mkdirSync } from 'node:fs'
+import { mkdtemp, rm } from 'node:fs/promises'
+import { join } from 'node:path'
+import { after, test } from 'node:test'
+import { fileURLToPath } from 'node:url'
+import type {} from '../plugins/acryl-db/src/cordis.ts'
+import type { Db } from '../plugins/acryl-db/src/index.ts'
+import { pinnedInstance, withPort } from '../plugins/instance/index.ts'
+import { createApp as boot } from '../src/app.ts'
+import { createApp } from '../src/chat-app.ts'
+import type { Llm } from '../src/llm.ts'
+
+/** Throwaway homes and databases live inside the project (`.acrylblends/` is ignored by git), because a sandboxed agent may not write to the system temp folder. */
+const scratch = join(fileURLToPath(new URL('..', import.meta.url)), '.acrylblends', 'test')
+mkdirSync(scratch, { recursive: true })
+
+const projectRoot = fileURLToPath(new URL('..', import.meta.url))
+
+/**
+ * A fresh database file in a throwaway home with the real migrations, opened by the app's own `db` row (the whole Cordis app boots, so the test exercises the same
+ * composition as production). Every app is stopped, and its home removed, when the tests end.
+ */
+const stops: (() => Promise<void>)[] = []
+after(() => Promise.all(stops.map((stop) => stop())))
+async function booted() {
+  const home = await mkdtemp(join(scratch, 'chat-test-'))
+  const app = await boot(withPort(pinnedInstance(home, { root: projectRoot }), 0), {
+    database: join(home, 'test.sqlite'),
+    listen: false,
+  })
+  stops.push(async () => {
+    await app.stop()
+    await rm(home, { recursive: true, force: true })
+  })
+  return app
+}
+async function memoryDb(): Promise<Db> {
+  return (await booted()).root.db
+}
+
+/** A model that answers with fixed pieces and records what it was asked. */
+function mock(pieces: string[]) {
+  const asked: { role: string; content: string }[][] = []
+  const llm: Llm = async function* (messages) {
+    asked.push(messages)
+    for (const piece of pieces) yield piece
+  }
+  return { llm, asked }
+}
+
+const post = (body: unknown): RequestInit => ({
+  method: 'POST',
+  headers: { 'content-type': 'application/json' },
+  body: JSON.stringify(body),
+})
+
+/** Parse a Server-Sent Events body into [event, data] pairs. */
+function events(text: string): [string, string][] {
+  return text
+    .split('\n\n')
+    .filter(Boolean)
+    .map((block) => {
+      const event = /^event: (.*)$/m.exec(block)?.[1] ?? 'message'
+      const data = /^data: (.*)$/m.exec(block)?.[1] ?? ''
+      return [event, data]
+    })
+}
+
+test('the answer streams as events: meta, one token per piece, done', async () => {
+  const { llm } = mock(['Hel', 'lo ', 'there\nline'])
+  const app = createApp(await memoryDb(), llm)
+  const res = await app.request('/api/chat', post({ message: 'hi' }))
+  assert.equal(res.status, 200)
+  assert.match(res.headers.get('content-type') ?? '', /text\/event-stream/)
+  const got = events(await res.text())
+  assert.deepEqual(
+    got.map(([e]) => e),
+    ['meta', 'token', 'token', 'token', 'done'],
+  )
+  assert.equal(
+    got
+      .filter(([e]) => e === 'token')
+      .map(([, d]) => JSON.parse(d) as string)
+      .join(''),
+    'Hello there\nline',
+  )
+})
+
+test('history is stored, sent back to the model, and listed', async () => {
+  const { llm, asked } = mock(['ok'])
+  const app = createApp(await memoryDb(), llm)
+  const first = events(
+    await (await app.request('/api/chat', post({ message: 'first question' }))).text(),
+  )
+  const id = (JSON.parse(first[0]![1]) as { conversation: number }).conversation
+  await (await app.request('/api/chat', post({ message: 'second', conversation: id }))).text()
+  assert.deepEqual(
+    asked[1]?.map((m) => m.content),
+    ['first question', 'ok', 'second'],
+  )
+  const one = (await (await app.request(`/api/conversations/${id}`)).json()) as {
+    messages: { role: string }[]
+  }
+  assert.deepEqual(
+    one.messages.map((m) => m.role),
+    ['user', 'assistant', 'user', 'assistant'],
+  )
+  const list = (await (await app.request('/api/conversations')).json()) as {
+    conversations: { title: string }[]
+  }
+  assert.equal(list.conversations[0]?.title, 'first question')
+  const page = await (await app.request(`/?c=${id}`)).text()
+  assert.match(page, /first question/)
+  assert.match(page, /src="\/client\/chat\.tsx"/)
+})
+
+test('a bad message answers 400 with a message, an unknown conversation 404, and nothing reaches the model', async () => {
+  const { llm, asked } = mock(['x'])
+  const app = createApp(await memoryDb(), llm)
+  const empty = await app.request('/api/chat', post({ message: '  ' }))
+  assert.equal(empty.status, 400)
+  assert.match(JSON.stringify(await empty.json()), /Write a message/)
+  assert.equal(
+    (await app.request('/api/chat', post({ message: 'hi', conversation: 99 }))).status,
+    404,
+  )
+  assert.equal(asked.length, 0)
+})
+
+test('a conversation can be deleted', async () => {
+  const app = createApp(await memoryDb(), mock(['a']).llm)
+  const first = events(await (await app.request('/api/chat', post({ message: 'hi' }))).text())
+  const id = (JSON.parse(first[0]![1]) as { conversation: number }).conversation
+  assert.equal((await app.request(`/api/conversations/${id}`, { method: 'DELETE' })).status, 200)
+  assert.equal((await app.request(`/api/conversations/${id}`)).status, 404)
+  assert.equal((await app.request(`/api/conversations/${id}`, { method: 'DELETE' })).status, 404)
+})
+
+test('a failing model sends an error event with a plain message and no detail', async () => {
+  const llm: Llm = async function* () {
+    yield 'partial '
+    throw new Error('upstream secret detail')
+  }
+  const app = createApp(await memoryDb(), llm)
+  const text = await (await app.request('/api/chat', post({ message: 'hi' }))).text()
+  assert.doesNotMatch(text, /secret detail/)
+  const last = events(text).at(-1)
+  assert.equal(last?.[0], 'error')
+  assert.match(last?.[1] ?? '', /could not answer/)
+})
+
+test('when the client goes away the model call is aborted and what arrived is kept', async () => {
+  let sawAbort: (value: boolean) => void = () => {}
+  const aborted = new Promise<boolean>((resolve) => {
+    sawAbort = resolve
+  })
+  const llm: Llm = async function* (_messages, signal) {
+    yield 'first '
+    // The signal may already be aborted by the time the model is asked for more: an abort event that has fired does not fire again.
+    if (!signal.aborted)
+      await new Promise<void>((resolve) =>
+        signal.addEventListener('abort', () => resolve(), { once: true }),
+      )
+    sawAbort(signal.aborted)
+    if (signal.aborted) throw new DOMException('aborted', 'AbortError')
+    yield 'never sent'
+  }
+  const db = await memoryDb()
+  const app = createApp(db, llm)
+  const controller = new AbortController()
+  const res = await app.request('/api/chat', {
+    ...post({ message: 'hi' }),
+    signal: controller.signal,
+  })
+  const reader = res.body!.getReader()
+  const decoder = new TextDecoder()
+  let seen = ''
+  while (!seen.includes('first')) seen += decoder.decode((await reader.read()).value)
+  controller.abort()
+  assert.equal(await aborted, true)
+  await new Promise((resolve) => setTimeout(resolve, 50))
+  const rows = await db.all<{ role: string; content: string }>(
+    'SELECT role, content FROM messages ORDER BY id',
+  )
+  assert.deepEqual(
+    rows.map((r) => `${r.role}:${r.content}`),
+    ['user:hi', 'assistant:first '],
+  )
+})
+
+test('the chat page loads its client component, served by the running app', async () => {
+  const running = await booted()
+  const module = await running.root.router.request('/client/chat.tsx')
+  assert.equal(module.status, 200)
+  assert.match(module.headers.get('content-type') ?? '', /javascript/)
+  assert.equal((await running.root.router.request('/client/@acrylblends/jsx-dom.js')).status, 200)
+})

package/templates/chat/test/server.test.ts

@@ -0,0 +1,78 @@
+import assert from 'node:assert/strict'
+import { spawn } from 'node:child_process'
+import { once } from 'node:events'
+import { mkdirSync, mkdtempSync } from 'node:fs'
+import { createServer } from 'node:net'
+import { join } from 'node:path'
+import { test } from 'node:test'
+import { fileURLToPath } from 'node:url'
+
+/** Throwaway homes and databases live inside the project (`.acrylblends/` is ignored by git), because a sandboxed agent may not write to the system temp folder. */
+const scratch = join(fileURLToPath(new URL('..', import.meta.url)), '.acrylblends', 'test')
+mkdirSync(scratch, { recursive: true })
+
+/** A sandbox may forbid listening on a port (Codex's workspace-write does); the tests that start the real server are skipped there, and every other test runs in process. */
+const canListen = await new Promise<boolean>((done) => {
+  const probe = createServer()
+  probe.once('error', () => done(false))
+  probe.listen(0, '127.0.0.1', () => probe.close(() => done(true)))
+})
+const skip = canListen ? false : 'this environment does not allow listening on a port'
+if (!canListen)
+  console.log(
+    `skipped: the tests that start the real server (${skip}); every other test ran in process`,
+  )
+
+/** Start `src/main.ts` the way `npm start` does, on a port the system chooses, and read the address it prints. */
+async function start(env: Record<string, string> = {}) {
+  const child = spawn(
+    process.execPath,
+    ['--import', './plugins/acryl-node-server/src/register.ts', 'src/main.ts'],
+    {
+      env: {
+        ...process.env,
+        PORT: '0',
+        ACRYL_DOOR: 'off',
+        ACRYLBLENDS_HOME: mkdtempSync(join(scratch, 'chat-home-')),
+        CHAT_DB: join(mkdtempSync(join(scratch, 'chat-')), 'chat.sqlite'),
+        ...env,
+      },
+      stdio: ['ignore', 'pipe', 'inherit'],
+    },
+  )
+  let out = ''
+  const address = await new Promise<string>((resolve, reject) => {
+    child.once('exit', (code) =>
+      reject(new Error(`the server exited with ${code} before it listened`)),
+    )
+    child.stdout.on('data', (chunk) => {
+      out += chunk
+      const match = /listening on (http:\/\/\S+)/.exec(out)
+      if (match?.[1]) resolve(match[1])
+    })
+  })
+  return { child, address }
+}
+
+test('the server listens on 127.0.0.1 unless HOST says otherwise', { skip }, async () => {
+  const { child, address } = await start()
+  try {
+    assert.match(address, /^http:\/\/127\.0\.0\.1:\d+$/)
+  } finally {
+    child.kill('SIGTERM')
+    await once(child, 'exit')
+  }
+})
+
+for (const signal of ['SIGTERM', 'SIGINT'] as const) {
+  test(`${signal} stops the server cleanly and frees the port`, { skip }, async () => {
+    const { child, address } = await start()
+    assert.equal((await fetch(`${address}/`)).status, 200)
+    const started = Date.now()
+    child.kill(signal)
+    const [code] = await once(child, 'exit')
+    assert.equal(code, 0)
+    assert.ok(Date.now() - started < 5000, 'the server took too long to stop')
+    await assert.rejects(fetch(address), 'the port should be free')
+  })
+}

package/templates/chat/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2024",
+    "lib": ["ES2024", "DOM", "DOM.Iterable"],
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "noImplicitOverride": true,
+    "verbatimModuleSyntax": true,
+    "erasableSyntaxOnly": true,
+    "allowImportingTsExtensions": true,
+    "noEmit": true,
+    "skipLibCheck": true,
+    "types": ["node"],
+    "jsx": "react-jsx",
+    "jsxImportSource": "#acryl-jsx"
+  },
+  "include": ["src", "test", "plugins"],
+  "exclude": ["src/client"]
+}

package/templates/nodejs/AGENTS.md

@@ -0,0 +1,9 @@
+
+## This app (nodejs)
+
+A web app: routes, a server-rendered JSX page, and a client component, all plugins of a Cordis app. `src/routes.ts` is the app's own plugin: it builds an `Acryl` app
+(`pages`) and mounts it with `ctx.router.route`, and mounts `clientModules` at `/client`. `blend.yaml` lists the plugins that are mounted. `acrylblends add <plugin>` copies
+another library plugin (for example `acryl-state` or `db`) into `plugins/`. Test a route by booting the app (`createApp` in `src/app.ts`, see `test/app.test.ts`) and calling it with `fetch`.
+
+- **Client components** (run in the browser) live in `src/client/`, which has its own `tsconfig.json` (DOM types, no Node types); `clientModules` compiles them when the browser asks, and `npm run build` compiles them once into `dist/client` for production (`NODE_ENV=production` serves only that folder). See `src/client/counter.tsx` and `docs/framework/guides/client-modules.md`.
+- The server listens on `127.0.0.1`; `PORT` chooses the port and `HOST=0.0.0.0` is for a container only.

package/templates/nodejs/blend.yaml

@@ -0,0 +1,29 @@
+# The app as data, in ACRYL's Blend format (blends.acryl.dev/v1alpha1): which plugins it mounts, in what order, with what config.
+# Edit this, not app.ts, to switch a plugin off (disabled: true) or change its config. `npm run lock` records what the app is built from.
+apiVersion: blends.acryl.dev/v1alpha1
+kind: Blueprint
+metadata:
+  id: acrylblends.__APP_NAME__
+  name: __APP_NAME__
+  version: 0.1.0
+  visibility: private # `npm run save` never pushes a private app to a public remote
+spec:
+  runtime: cordis
+  parameters:
+    # The address the server listens on.
+    hostname: { type: string, default: 127.0.0.1 }
+  rows:
+    - id: router
+      name: acryl-router
+    - id: routes
+      name: routes
+    # Plugins installed while the app runs (the door's `plugin add`): development only, src/app.ts leaves it out when NODE_ENV=production.
+    - id: extensions
+      name: extensions
+    - id: server
+      name: acryl-node-server
+      config:
+        hostname: "{{parameters.hostname}}"
+    # The door: an agent working in this folder looks at the page and acts on it through .acryl/bin/acryl. Development only: src/app.ts leaves it out when NODE_ENV=production.
+    - id: acryl-door
+      name: acryl-door

package/templates/nodejs/gitignore

@@ -0,0 +1,3 @@
+node_modules/
+.acrylblends/
+.acryl/

package/templates/nodejs/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "__APP_NAME__",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "imports": {
+    "#acryl-jsx/jsx-runtime": "./plugins/acryl-router/src/core/jsx/jsx-runtime.ts",
+    "#acryl-jsx/jsx-dev-runtime": "./plugins/acryl-router/src/core/jsx/jsx-dev-runtime.ts"
+  },
+  "engines": {
+    "node": ">=22.19.0"
+  },
+  "scripts": {
+    "start": "node --import ./plugins/acryl-node-server/src/register.ts src/main.ts",
+    "dev": "node --watch --import ./plugins/acryl-node-server/src/register.ts src/main.ts",
+    "test": "acrylblends check-deps && node --import ./plugins/acryl-node-server/src/register.ts --test \"test/**/*.test.{ts,tsx}\"",
+    "check": "tsc --noEmit && tsc --noEmit -p src/client && acrylblends check-deps",
+    "build": "acrylblends build-client",
+    "lock": "node plugins/manifest/lock.ts",
+    "save": "node plugins/save/cli.ts",
+    "upgrade": "node plugins/manifest/upgrade-cli.ts"
+  },
+  "dependencies": {
+    "acrylblends": "__ACRYLBLENDS_RANGE__",
+    "typescript": "6.0.3"
+  },
+  "devDependencies": {
+    "@types/node": "^24.0.0"
+  }
+}

package/templates/nodejs/src/app.ts

@@ -0,0 +1,95 @@
+import { join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { Context, type Fiber } from '@deepseek-ai/cordis'
+import * as door from '../plugins/acryl-door/src/index.ts'
+import * as nodeServer from '../plugins/acryl-node-server/src/index.ts'
+import * as router from '../plugins/acryl-router/src/index.ts'
+import { extensions } from '../plugins/extensions/index.ts'
+import { type AppInstance, instance } from '../plugins/instance/index.ts'
+import {
+  blueprintsIn,
+  compose,
+  loadManifest,
+  type ParameterValue,
+} from '../plugins/manifest/index.ts'
+import { doorEnabled } from './door.ts'
+import { routes } from './routes.ts'
+
+/** The plugins this app's code provides. `blend.yaml` chooses, orders and configures them. */
+export const registry = {
+  'acryl-router': router,
+  'acryl-node-server': nodeServer,
+  'acryl-door': door,
+  extensions,
+  routes,
+}
+
+const projectRoot = fileURLToPath(new URL('..', import.meta.url))
+
+/** The manifest next to this app's source. */
+export const MANIFEST = join(projectRoot, 'blend.yaml')
+
+/**
+ * The app's manifest, resolved. A Blend finds its Blueprint in `blueprints/<id>.yaml`; an app that is itself a Blueprint never looks.
+ * `createApp` and the tests read it the same way.
+ */
+export function readManifest(values?: Readonly<Record<string, ParameterValue>>) {
+  return loadManifest(MANIFEST, {
+    known: Object.keys(registry),
+    getBlueprint: blueprintsIn(join(projectRoot, 'blueprints')),
+    ...(values ? { values } : {}),
+  })
+}
+
+/** The manifest without some rows: without its server (and so its door) the app is reached in process, through `root.router.request`; the door is also left out in production. */
+function without<M extends { plugins: readonly { use: string }[] }>(
+  manifest: M,
+  ...uses: string[]
+): M {
+  return {
+    ...manifest,
+    plugins: manifest.plugins.map((row) =>
+      uses.includes(row.use) ? { ...row, disabled: true } : row,
+    ),
+  }
+}
+
+export interface App {
+  readonly root: Context
+  /** The address the server listens on; empty when the app was made with `listen: false`. */
+  readonly url: string
+  stop(): Promise<void>
+}
+
+/** The app: `instance` first (where it lives, chosen at run time), then the manifest's rows in order. */
+export async function createApp(
+  chosen: AppInstance,
+  options: { values?: Readonly<Record<string, ParameterValue>>; listen?: boolean } = {},
+): Promise<App> {
+  const read = readManifest(options.values)
+  const listen = options.listen
+  // Rows left out: the server (and the door, which needs it) when the app is reached in process; the door when it is switched off; live plugin installs in production.
+  const leaveOut = new Set<string>()
+  if (listen === false) leaveOut.add('acryl-node-server').add('acryl-door')
+  if (!doorEnabled()) leaveOut.add('acryl-door')
+  if (process.env.NODE_ENV === 'production') leaveOut.add('extensions')
+  const manifest = without(read, ...leaveOut)
+  const root = new Context()
+  const first = root.plugin(instance, chosen)
+  await first.await()
+  const fibers: Fiber[] = [
+    first,
+    ...(await compose(root, manifest, registry, {
+      // What is installed while the app runs lives in plugins/, next to the plugins copied from the library (plugins/library.json lists those, so they are not installed twice).
+      extensions: { sources: [{ dir: join(projectRoot, 'plugins'), trust: 'install' }] },
+      server: { port: chosen.port.start, scan: chosen.port.scan ? 20 : 0 },
+    })),
+  ]
+  return {
+    root,
+    url: listen === false ? '' : root.nodeServer.url,
+    async stop() {
+      for (const fiber of [...fibers].reverse()) await fiber.dispose()
+    },
+  }
+}

package/templates/nodejs/src/client/counter.tsx

@@ -0,0 +1,12 @@
+import { render, useState } from 'acrylblends/jsx/dom'
+
+const Counter = () => {
+  const [count, setCount] = useState(0)
+  return (
+    <button type="button" onClick={() => setCount(count + 1)}>
+      Count {count}
+    </button>
+  )
+}
+
+render(<Counter />, document.getElementById('counter')!)

package/templates/nodejs/src/client/tsconfig.json

@@ -0,0 +1,26 @@
+{
+  "compilerOptions": {
+    "target": "ES2024",
+    "lib": ["ES2024", "DOM", "DOM.Iterable"],
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "noEmit": true,
+    "allowImportingTsExtensions": true,
+    "jsx": "react-jsx",
+    "jsxImportSource": "acrylblends/jsx/dom",
+    "types": [],
+    "paths": {
+      "acrylblends/jsx/dom": ["../../plugins/acryl-router/src/browser/jsx-dom.ts"],
+      "acrylblends/jsx/dom/jsx-runtime": [
+        "../../plugins/acryl-router/src/core/jsx/dom/jsx-runtime.ts"
+      ],
+      "acrylblends/jsx/dom/jsx-dev-runtime": [
+        "../../plugins/acryl-router/src/core/jsx/dom/jsx-dev-runtime.ts"
+      ],
+      "acrylblends/jsx/dom/client": ["../../plugins/acryl-router/src/browser/jsx-dom.ts"],
+      "acrylblends/client": ["../../plugins/acryl-router/src/browser/client.ts"]
+    }
+  },
+  "include": ["**/*.ts", "**/*.tsx"]
+}

package/templates/nodejs/src/door.ts

@@ -0,0 +1,7 @@
+/**
+ * The door (`plugins/acryl-door`) lets an agent working in this folder look at the running page and act on it, through `.acryl/bin/acryl`. It is on in development
+ * and off in production (`NODE_ENV=production`) and when `ACRYL_DOOR=off`: `src/app.ts` leaves its row out then, and the pages leave its script tag out. One process
+ * at a time serves a folder's door, so the tests that start the real server set `ACRYL_DOOR=off` and a second `npm start` beside a running one does not fail on it.
+ */
+export const doorEnabled = (): boolean =>
+  process.env.NODE_ENV !== 'production' && process.env.ACRYL_DOOR !== 'off'

package/templates/nodejs/src/main.ts

@@ -0,0 +1,25 @@
+import { fileURLToPath } from 'node:url'
+import { selectInstance } from '../plugins/instance/index.ts'
+import { createApp } from './app.ts'
+import { APP_NAME } from './routes.ts'
+
+// The composition root: the one place that reads the environment (through selectInstance) and chooses where the app lives.
+const chosen = selectInstance({
+  projectRoot: fileURLToPath(new URL('..', import.meta.url)),
+  // PORT and HOST are the names hosting platforms set; ACRYLBLENDS_PORT and ACRYLBLENDS_HOST win when both are given.
+  env: {
+    ...(process.env.PORT ? { ACRYLBLENDS_PORT: process.env.PORT } : {}),
+    ...(process.env.HOST ? { ACRYLBLENDS_HOST: process.env.HOST } : {}),
+    ...process.env,
+  },
+})
+const app = await createApp(chosen)
+console.log(`${APP_NAME} listening on ${app.url} (data in ${chosen.home})`)
+
+const stop = async () => {
+  await app.stop()
+  console.log('stopped')
+  process.exit(0)
+}
+process.once('SIGINT', stop)
+process.once('SIGTERM', stop)

package/templates/nodejs/src/page.tsx

@@ -0,0 +1,29 @@
+import { doorEnabled } from './door.ts'
+
+/** A page written in JSX: Node.js runs it through plugins/acryl-node-server/src/register.ts (see the scripts in package.json), which compiles .tsx with this app's own typescript. */
+const About = () => (
+  <main>
+    <h1>About</h1>
+    <p>Rendered on the server with the JSX runtime in plugins/acryl-router.</p>
+  </main>
+)
+
+export const aboutPage = (): string => (<About />).toString()
+
+/** Throws on purpose: the template's test checks that the stack names this file, so a failure in your own pages points at the .tsx line. */
+export const failingPage = (): string => {
+  throw new Error('a page failed')
+}
+
+/** A page with one client component: `src/client/counter.tsx` runs in the browser, compiled on request by `clientModules` (see src/routes.ts). */
+export const counterPage = (): string =>
+  (
+    <html lang="en">
+      <body>
+        <h1>Counter</h1>
+        <div id="counter" />
+        <script type="module" src="/client/counter.tsx" />
+        {doorEnabled() ? <script type="module" src="/api/acryl-door/page.js" /> : null}
+      </body>
+    </html>
+  ).toString()

package/templates/nodejs/src/routes.ts

@@ -0,0 +1,40 @@
+import { createRequire } from 'node:module'
+import { dirname, join } from 'node:path'
+import type { Context } from '@deepseek-ai/cordis'
+import { clientModules } from '../plugins/acryl-node-server/src/client-modules.ts'
+import { Acryl } from '../plugins/acryl-router/src/index.ts'
+import { aboutPage, counterPage } from './page.tsx'
+
+/** The browser builds of the DOM renderer and the typed client, shipped by the `acrylblends` package this app depends on. */
+const runtimeDir = join(
+  dirname(createRequire(import.meta.url).resolve('acrylblends/package.json')),
+  'lib',
+  'browser',
+)
+
+export const APP_NAME = '__APP_NAME__'
+
+/** The routes, in a file that does not import the Node adapter's server, so browser code can import the type: `import type { AppType } from '../routes.ts'`. */
+export const pages = new Acryl()
+  .get('/', (c) => c.json({ app: APP_NAME, ok: true }))
+  .get('/health', (c) => c.json({ ok: true }))
+  .get('/about', (c) => c.html(aboutPage()))
+  .get('/counter', (c) => c.html(counterPage()))
+
+export type AppType = typeof pages
+
+/**
+ * The app's own plugin: the routes above, and the client components without a bundler (`src/client` is compiled when the browser asks; `npm run build`
+ * compiles it once for production, and `NODE_ENV=production` then serves only `dist/client`). The mounts are removed when the plugin is disposed.
+ */
+export const routes = {
+  name: 'routes',
+  inject: ['router'],
+  apply(ctx: Context) {
+    ctx.router.route('/', pages)
+    ctx.router.route(
+      '/client',
+      clientModules({ root: 'src/client', compiled: 'dist/client', runtimeDir }),
+    )
+  },
+}

package/templates/nodejs/template.json

@@ -0,0 +1,11 @@
+{
+  "plugins": [
+    "instance",
+    "acryl-router",
+    "acryl-node-server",
+    "manifest",
+    "save",
+    "extensions",
+    "acryl-door"
+  ]
+}