@stone-js/starters 0.8.8 → 0.8.10

package/basic-react-native-declarative/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "basic-react-native-declarative",
+  "private": true,
+  "version": "1.0.0",
+  "description": "Stone.js's basic starter to create a React Native (Expo) app using the declarative API.",
+  "author": "Mr. Stone <evensstone@gmail.com>",
+  "license": "MIT",
+  "main": "index.ts",
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "scripts": {
+    "start": "expo start",
+    "android": "expo start --android",
+    "ios": "expo start --ios",
+    "web": "expo start --web",
+    "export": "expo export",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:cvg": "npm run test -- --coverage"
+  },
+  "dependencies": {
+    "@stone-js/browser-core": "^0.8.10",
+    "@stone-js/core": "^0.8.10",
+    "@stone-js/router": "^0.8.10",
+    "expo": "~57.0.14",
+    "expo-status-bar": "~57.0.1",
+    "fast-text-encoding": "^1.0.6",
+    "react": "19.2.3",
+    "react-native": "0.86.2",
+    "react-native-url-polyfill": "^3.0.0"
+  },
+  "devDependencies": {
+    "@babel/plugin-proposal-decorators": "^7.28.0",
+    "@types/react": "~19.2.2",
+    "@vitest/coverage-v8": "^3.0.9",
+    "babel-preset-expo": "^57.0.7",
+    "typescript": "~6.0.3",
+    "vitest": "^3.0.9"
+  }
+}

package/basic-react-native-declarative/tests/Application.spec.ts

@@ -0,0 +1,65 @@
+import { stoneApp } from '@stone-js/core'
+import { describe, it, expect, beforeAll } from 'vitest'
+import { Application } from '../app/Application'
+import { OutgoingBrowserResponse } from '@stone-js/browser-core'
+import { nativeEventSource } from '../adapter/NativeEventSource'
+import { WelcomeData, WelcomeController } from '../app/WelcomeController'
+import { onNativeError, onNativeRender } from '../adapter/renderSink'
+
+/**
+ * Behavioral test of the full continuum chain: the exact modules the native
+ * application boots (domain + router + native adapter) are booted here under
+ * Node, navigation intents are emitted, and the rendered payloads asserted.
+ *
+ * The adapter is pure JavaScript, so what passes here is what runs on device;
+ * only the platform checks (URL polyfill, Hermes) need the real application.
+ *
+ * The application boots ONCE for the whole suite, like on a device: default
+ * blueprints are shared module-level objects, so booting the same modules
+ * twice in one process would accumulate route definitions.
+ */
+describe('Stone.js native proof of concept', () => {
+  const rendered: OutgoingBrowserResponse[] = []
+  const errors: Error[] = []
+
+  beforeAll(async () => {
+    onNativeRender((response) => rendered.push(response))
+    onNativeError((error) => errors.push(error))
+    await stoneApp({ modules: [Application, WelcomeController] }).run()
+  })
+
+  it('boots and renders the landing route on startup', () => {
+    expect(errors).toHaveLength(0)
+    expect(rendered).toHaveLength(1)
+
+    const payload = rendered[0].content as WelcomeData
+    expect(payload.route).toBe('/')
+    expect(payload.message).toContain('Welcome to Stone.js on React Native!')
+    expect(payload.framework.name).toBe('Stone.js')
+  })
+
+  it('routes a navigation intent with a parameter to the same domain', async () => {
+    nativeEventSource.navigate('stone://app/hello/Noowow')
+    await new Promise((resolve) => setImmediate(resolve))
+
+    const payload = rendered.at(-1)?.content as WelcomeData
+    expect(payload.route).toBe('/hello/Noowow')
+    expect(payload.message).toContain('Hello Noowow!')
+  })
+
+  it('decodes encoded route parameters', async () => {
+    nativeEventSource.navigate('stone://app/hello/Mr.%20Stone')
+    await new Promise((resolve) => setImmediate(resolve))
+
+    const payload = rendered.at(-1)?.content as WelcomeData
+    expect(payload.message).toContain('Hello Mr. Stone!')
+  })
+
+  it('surfaces unknown routes through the error chain instead of crashing', async () => {
+    nativeEventSource.navigate('stone://app/nowhere')
+    await new Promise((resolve) => setImmediate(resolve))
+
+    const lastPayload = rendered.at(-1)?.content as WelcomeData | undefined
+    expect(lastPayload?.route === '/nowhere').toBe(false)
+  })
+})

package/basic-react-native-declarative/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "extends": "expo/tsconfig.base",
+  "compilerOptions": {
+    "strict": true,
+    "experimentalDecorators": true,
+    "types": ["vitest/globals"]
+  },
+  "include": [
+    "app",
+    "adapter",
+    "tests",
+    "App.tsx",
+    "index.ts",
+    "vitest.config.ts"
+  ]
+}

package/basic-react-native-declarative/vitest.config.ts

@@ -0,0 +1,27 @@
+import { defineConfig } from 'vitest/config'
+
+export default defineConfig({
+  // `experimentalDecorators` is enabled in tsconfig.json for tsc TYPING only
+  // (the framework types its decorators with the legacy signatures). At
+  // RUNTIME Stone.js requires standard 2023-11 decorators, so esbuild must
+  // ignore that flag and emit the standard semantics, `Symbol.metadata`
+  // included (esbuild 0.25+ implements them correctly on its own).
+  esbuild: {
+    tsconfigRaw: {
+      compilerOptions: {
+        experimentalDecorators: false
+      }
+    }
+  },
+  test: {
+    globals: true,
+    environment: 'node',
+    include: ['./tests/**/*.{test,spec}.?(c|m)[jt]s?(x)'],
+    coverage: {
+      provider: 'v8',
+      include: ['app/**/*.ts', 'adapter/**/*.ts'],
+      reporter: ['text', 'html'],
+      reportsDirectory: './coverage'
+    }
+  }
+})

package/basic-service-declarative/app/Application.ts

@@ -1,5 +1,4 @@
 import { NodeHttp } from '@stone-js/node-http-adapter'
-import { NodeConsole } from '@stone-js/node-cli-adapter'
 import { IncomingEvent, IEventHandler, ILogger, LogLevel, StoneApp } from '@stone-js/core'
 
 /**
@@ -10,7 +9,6 @@ import { IncomingEvent, IEventHandler, ILogger, LogLevel, StoneApp } from '@ston
  * @NodeHttp() is used to enable the Node HTTP adapter.
  * @StoneApp() is used to enable the Stone application, it is required.
  */
-@NodeConsole()
 @NodeHttp({ default: true })
 @StoneApp({ logger: { level: LogLevel.INFO } })
 export class Application implements IEventHandler<IncomingEvent> {

package/basic-service-declarative/package.json

@@ -14,19 +14,19 @@
     "build": "stone build",
     "preview": "stone preview dist/server.mjs",
     "typings": "stone typings",
-    "test": "vitest run",
-    "test:cvg": "npm run test -- --coverage"
+    "test": "stone test",
+    "test:cvg": "stone test --coverage"
   },
   "dependencies": {
-    "@stone-js/core": "^0.8.8",
-    "@stone-js/node-cli-adapter": "^0.8.8",
-    "@stone-js/node-http-adapter": "^0.8.8"
+    "@stone-js/core": "^0.8.10",
+    "@stone-js/node-http-adapter": "^0.8.10"
   },
   "devDependencies": {
     "@babel/plugin-proposal-decorators": "^7.25.9",
     "@babel/preset-env": "^7.26.9",
     "@babel/preset-typescript": "^7.27.0",
-    "@stone-js/cli": "^0.8.8",
+    "@stone-js/cli": "^0.8.10",
+    "@stone-js/testing": "^0.8.10",
     "@types/node": "^24.0.7",
     "@vitest/coverage-v8": "^3.0.9",
     "vitest": "^3.0.9"

package/basic-service-declarative/tests/Application.spec.ts

@@ -1,61 +1,28 @@
-import { Application } from '../app/Application'
-import { ILogger, IncomingEvent } from '@stone-js/core'
-
-// We must mock decorators to lighten the test environment
-vi.mock(import("@stone-js/core"), async (importOriginal) => {
-  const actual = await importOriginal()
-  return {
-    ...actual,
-    StoneApp: vi.fn(() => vi.fn()),
-  }
-})
-
-// We must mock decorators to lighten the test environment
-vi.mock(import("@stone-js/node-cli-adapter"), async (importOriginal) => {
-  const actual = await importOriginal()
-  return {
-    ...actual,
-    NodeConsole: vi.fn(() => vi.fn()),
-  }
-})
-
-// We must mock decorators to lighten the test environment
-vi.mock(import("@stone-js/node-http-adapter"), async (importOriginal) => {
-  const actual = await importOriginal()
-  return {
-    ...actual,
-    NodeHttp: vi.fn(() => vi.fn()),
-  }
-})
-
+import { createTestApp, makeIncomingHttpEvent } from '@stone-js/testing'
+
+/**
+ * The whole application, booted in memory and asked a real question.
+ *
+ * Nothing is mocked and nothing is listed: `createTestApp()` discovers `app/**`, and the event goes
+ * through the same kernel production runs. If this passes the application works; if it fails the
+ * application is broken. That is the only kind of test worth shipping in a starter — the previous one
+ * stubbed out the framework's own decorators, which meant it could pass while nothing worked.
+ */
 describe('Application', () => {
-  let app: Application
-  let mockedLogger: ILogger
+  it('answers the caller', async () => {
+    const app = await createTestApp()
 
-  beforeEach(() => {
-    mockedLogger = {
-      info: vi.fn(),
-    } as unknown as ILogger
+    const response = await app.send(makeIncomingHttpEvent({ method: 'GET', url: '/?name=Ada' }))
 
-    app = new Application({ logger: mockedLogger })
+    expect(response.statusCode).toBe(200)
+    expect(response.json()).toMatchObject({ message: expect.stringContaining('Ada') })
   })
 
-  it('should create an application instance', () => {
-    // Assert
-    expect(app).toBeInstanceOf(Application)
-  })
+  it('answers when nobody says who they are', async () => {
+    const app = await createTestApp()
 
-  it('should handle incoming events', () => {
-    // Arrange
-    const expectedMessage = 'Hello World! Welcome to Stone.js.'
-    const event = { get: () => 'World' } as unknown as IncomingEvent
+    const response = await app.send(makeIncomingHttpEvent({ method: 'GET', url: '/' }))
 
-    // Act
-    const response = app.handle(event)
-
-    // Assert
-    expect(response.message).toBe(expectedMessage)
-    expect(response.framework.name).toBe('Stone.js')
-    expect(mockedLogger.info).toHaveBeenCalledWith(expectedMessage)
+    expect(response.statusCode).toBe(200)
   })
-})
+})

package/basic-service-imperative/app/Application.ts

@@ -1,6 +1,5 @@
 import { NODE_HTTP_PLATFORM, nodeHttpAdapterBlueprint } from '@stone-js/node-http-adapter'
-import { defineCommand, NODE_CONSOLE_PLATFORM, nodeConsoleAdapterBlueprint } from '@stone-js/node-cli-adapter'
-import { defineStoneApp, defineConfig, IBlueprint, ILogger, IncomingEvent, FunctionalEventHandler } from '@stone-js/core'
+import { defineStoneApp, ILogger, IncomingEvent, FunctionalEventHandler } from '@stone-js/core'
 
 /**
  * Create an handler using the factory handler.
@@ -40,20 +39,9 @@ export const Application = defineStoneApp(
     isFactory: true,
     adapter: { platform: NODE_HTTP_PLATFORM }
   },
-  [nodeHttpAdapterBlueprint, nodeConsoleAdapterBlueprint]
+  [nodeHttpAdapterBlueprint]
 )
 
-/**
- * Application configuration.
- */
-export const AppConfig = defineConfig({
-  afterConfigure (blueprint: IBlueprint) {
-    if (blueprint.is('stone.adapter.platform', NODE_CONSOLE_PLATFORM)) {
-      blueprint.set(defineCommand(FactoryHandler, { name: '*', isFactory: true }))
-    }
-  }
-})
-
 /**
  * Application options.
  */

package/basic-service-imperative/package.json

@@ -14,19 +14,19 @@
     "build": "stone build",
     "preview": "stone preview dist/server.mjs",
     "typings": "stone typings",
-    "test": "vitest run",
-    "test:cvg": "npm run test -- --coverage"
+    "test": "stone test",
+    "test:cvg": "stone test --coverage"
   },
   "dependencies": {
-    "@stone-js/core": "^0.8.8",
-    "@stone-js/node-cli-adapter": "^0.8.8",
-    "@stone-js/node-http-adapter": "^0.8.8"
+    "@stone-js/core": "^0.8.10",
+    "@stone-js/node-http-adapter": "^0.8.10"
   },
   "devDependencies": {
     "@babel/plugin-proposal-decorators": "^7.25.9",
     "@babel/preset-env": "^7.26.9",
     "@babel/preset-typescript": "^7.27.0",
-    "@stone-js/cli": "^0.8.8",
+    "@stone-js/cli": "^0.8.10",
+    "@stone-js/testing": "^0.8.10",
     "@types/node": "^24.0.7",
     "@vitest/coverage-v8": "^3.0.9",
     "vitest": "^3.0.9"

package/basic-service-imperative/tests/Application.spec.ts

@@ -1,53 +1,28 @@
-import { IncomingHttpEvent } from '@stone-js/http-core'
-import { FunctionalEventHandler, ILogger } from '@stone-js/core'
-import { AppConfig, FactoryHandler, ResponseData } from '../app/Application'
-
-vi.mock('@stone-js/core', async (mod) => {
-  const actual: any = await mod()
-  return {
-    ...actual,
-    isNotEmpty: vi.fn(() => true),
-    defineConfig: (config: any) => config
-  }
-})
-
+import { createTestApp, makeIncomingHttpEvent } from '@stone-js/testing'
+
+/**
+ * The whole application, booted in memory and asked a real question.
+ *
+ * Nothing is mocked and nothing is listed: `createTestApp()` discovers `app/**`, and the event goes
+ * through the same kernel production runs. If this passes the application works; if it fails the
+ * application is broken. That is the only kind of test worth shipping in a starter — the previous one
+ * stubbed out the framework's own decorators, which meant it could pass while nothing worked.
+ */
 describe('Application', () => {
-  let mockedLogger: ILogger
-  let app: FunctionalEventHandler<IncomingHttpEvent, ResponseData>
-
-  beforeEach(() => {
-    mockedLogger = {
-      info: vi.fn(),
-    } as unknown as ILogger
+  it('answers the caller', async () => {
+    const app = await createTestApp()
 
-    app = FactoryHandler({ logger: mockedLogger })
-  })
-
-  it('should create an event handler instance', () => {
-    // Assert
-    expect(app).toBeTypeOf('function')
-  })
+    const response = await app.send(makeIncomingHttpEvent({ method: 'GET', url: '/?name=Ada' }))
 
-  it('should handle incoming http events', async () => {
-    // Arrange
-    const event = { get: () => 'World' } as unknown as IncomingHttpEvent
-    // Act
-    const response = await app(event)
-    // Assert
-    expect(response.message).toBe('Hello World! Welcome to Stone.js.')
-    expect(response.framework.name).toBe('Stone.js')
-    expect(mockedLogger.info).toHaveBeenCalledWith('Hello World! Welcome to Stone.js.')
+    expect(response.statusCode).toBe(200)
+    expect(response.json()).toMatchObject({ message: expect.stringContaining('Ada') })
   })
 
-  it('should get config', () => {
-    // Arrange
-    const config: any = AppConfig
-    const blueprint: any = { is: () => true, set: vi.fn() }
+  it('answers when nobody says who they are', async () => {
+    const app = await createTestApp()
 
-    // Act
-    config.afterConfigure(blueprint)
+    const response = await app.send(makeIncomingHttpEvent({ method: 'GET', url: '/' }))
 
-    // Assert
-    expect(blueprint.set).toHaveBeenCalled()
+    expect(response.statusCode).toBe(200)
   })
 })

package/continuum-showcase/package.json

@@ -9,25 +9,26 @@
     "build": "stone build",
     "build:ssr": "stone build --ssr",
     "preview": "stone preview",
-    "test": "vitest run",
-    "test:cvg": "npm run test -- --coverage"
+    "test": "stone test",
+    "test:cvg": "stone test --coverage"
   },
   "dependencies": {
     "react": "^19.0.0",
     "react-dom": "^19.0.0",
-    "@stone-js/core": "^0.8.8",
-    "@stone-js/router": "^0.8.8",
-    "@stone-js/use-react": "^0.8.8",
-    "@stone-js/http-core": "^0.8.8",
-    "@stone-js/pipeline": "^0.8.8",
-    "@stone-js/browser-adapter": "^0.8.8",
-    "@stone-js/node-http-adapter": "^0.8.8"
+    "@stone-js/core": "^0.8.10",
+    "@stone-js/router": "^0.8.10",
+    "@stone-js/use-react": "^0.8.10",
+    "@stone-js/http-core": "^0.8.10",
+    "@stone-js/pipeline": "^0.8.10",
+    "@stone-js/browser-adapter": "^0.8.10",
+    "@stone-js/node-http-adapter": "^0.8.10"
   },
   "devDependencies": {
     "@babel/plugin-proposal-decorators": "^7.25.9",
     "@babel/preset-env": "^7.26.9",
     "@babel/preset-typescript": "^7.27.0",
-    "@stone-js/cli": "^0.8.8",
+    "@stone-js/cli": "^0.8.10",
+    "@stone-js/testing": "^0.8.10",
     "@types/node": "^24.0.7",
     "@types/react": "^19.0.7",
     "@types/react-dom": "^19.0.3",

package/continuum-showcase/public/favicon.svg

@@ -0,0 +1,16 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 96 96" width="96" height="96" role="img" aria-label="Stone.js">
+  <title>Stone.js</title>
+  <style>
+    .ink { stroke: #1B1613; }
+    @media (prefers-color-scheme: dark) { .ink { stroke: #EFE8DC; } }
+  </style>
+  <defs>
+    <linearGradient id="braise" gradientUnits="userSpaceOnUse" x1="22" y1="14" x2="74" y2="26.1">
+      <stop offset="0" stop-color="#FFC46B" />
+      <stop offset="1" stop-color="#FF5A1F" />
+    </linearGradient>
+  </defs>
+  <path class="ink" d="M 79.96 36.4 A 34 34 0 0 1 53.9 81.5" fill="none" stroke-width="11" stroke-linecap="round" opacity=".85" />
+  <path class="ink" d="M 42.1 81.5 A 34 34 0 0 1 16.05 36.4" fill="none" stroke-width="11" stroke-linecap="round" opacity=".85" />
+  <path d="M 22 26.1 A 34 34 0 0 1 74 26.1" fill="none" stroke="url(#braise)" stroke-width="11" stroke-linecap="round" />
+</svg>

package/continuum-showcase/stone.config.mjs

@@ -1,4 +1,4 @@
-import { defineConfig } from '@stone-js/cli'
+import { defineBuilderConfig } from '@stone-js/cli'
 
 /**
  * Build configuration for the showcase.
@@ -6,7 +6,7 @@ import { defineConfig } from '@stone-js/cli'
  * - `target: 'react'` + `rendering: 'ssr'` exercises the server-rendered head pipeline.
  * - `assets` enables the `@img` / `@css` / `@assets` import aliases used in components.
  */
-export default defineConfig({
+export default defineBuilderConfig({
   target: 'react',
   rendering: 'ssr',
   assets: {

package/continuum-showcase/tests/application.spec.ts

@@ -0,0 +1,30 @@
+import { createTestApp, makeIncomingHttpEvent } from '@stone-js/testing'
+
+/**
+ * The whole application, booted in memory and asked a real question.
+ *
+ * Nothing is mocked and nothing is listed: `createTestApp()` discovers `app/**`, and the event goes
+ * through the same kernel production runs. If this passes the application works; if it fails the
+ * application is broken. That is the only kind of test worth shipping in a starter — the previous one
+ * stubbed out the framework's own decorators, which meant it could pass while nothing worked.
+ */
+describe('Pages', () => {
+  it('renders the home page, data included', async () => {
+    const app = await createTestApp()
+
+    const response = await app.send(makeIncomingHttpEvent({ method: 'GET', url: '/?name=Ada' }))
+
+    expect(response.statusCode).toBe(200)
+    // A page is a handler, so a rendered page is a response whose body is HTML. Query that HTML with
+    // whatever you already use (happy-dom, jsdom, Testing Library): none is bundled here.
+    expect(response.html()).toContain('Ada')
+  })
+
+  it('renders without a name', async () => {
+    const app = await createTestApp()
+
+    const response = await app.send(makeIncomingHttpEvent({ method: 'GET', url: '/' }))
+
+    expect(response.statusCode).toBe(200)
+  })
+})

package/full-react-declarative/app/Application.ts

@@ -2,7 +2,6 @@ import { Routing } from '@stone-js/router'
 import { Browser } from '@stone-js/browser-adapter'
 import { Hook, UseReact } from '@stone-js/use-react'
 import { NodeHttp } from '@stone-js/node-http-adapter'
-import { NodeConsole } from '@stone-js/node-cli-adapter'
 import { IBlueprint, IContainer, ILogger, LogLevel, Promiseable, StoneApp } from '@stone-js/core'
 
 /**
@@ -13,8 +12,6 @@ import { IBlueprint, IContainer, ILogger, LogLevel, Promiseable, StoneApp } from
  * @StoneApp() is used to enable the Stone application, it is mandatory.
  * @Routing() is used to enable the routing feature.
  * @NodeHttp() is used to enable the Node HTTP adapter.
- * @NodeConsole() is used to enable the Node Console adapter.
- * @NodeConsole() requires the incoming event type.
  * BodyEventMiddleware is used to parse the incoming event body.
  * BodyEventMiddleware is imported because it is not installed by default.
  *
@@ -25,7 +22,6 @@ import { IBlueprint, IContainer, ILogger, LogLevel, Promiseable, StoneApp } from
 @Routing()
 @Browser()
 @UseReact()
-@NodeConsole()
 @NodeHttp({ default: true, url: 'http://localhost:3100' })
 @StoneApp({ name: 'My Stone', logger: { level: LogLevel.DEBUG } })
 export class Application {

package/full-react-declarative/package.json

@@ -14,19 +14,18 @@
     "build": "stone build",
     "preview": "stone preview",
     "build:ssr": "stone build --ssr",
-    "test": "vitest run",
-    "test:cvg": "npm run test -- --coverage"
+    "test": "stone test",
+    "test:cvg": "stone test --coverage"
   },
   "dependencies": {
-    "@stone-js/env": "^0.8.8",
-    "@stone-js/http-core": "^0.8.8",
-    "@stone-js/node-http-adapter": "^0.8.8",
-    "@stone-js/router": "^0.8.8",
-    "@stone-js/filesystem": "^0.8.8",
-    "@stone-js/core": "^0.8.8",
-    "@stone-js/use-react": "^0.8.8",
-    "@stone-js/browser-adapter": "^0.8.8",
-    "@stone-js/node-cli-adapter": "^0.8.8",
+    "@stone-js/env": "^0.8.10",
+    "@stone-js/http-core": "^0.8.10",
+    "@stone-js/node-http-adapter": "^0.8.10",
+    "@stone-js/router": "^0.8.10",
+    "@stone-js/filesystem": "^0.8.10",
+    "@stone-js/core": "^0.8.10",
+    "@stone-js/use-react": "^0.8.10",
+    "@stone-js/browser-adapter": "^0.8.10",
     "axios": "^1.7.9",
     "react": "^19.0.0",
     "react-dom": "^19.0.0"
@@ -35,7 +34,8 @@
     "@babel/plugin-proposal-decorators": "^7.25.9",
     "@babel/preset-env": "^7.26.9",
     "@babel/preset-typescript": "^7.27.0",
-    "@stone-js/cli": "^0.8.8",
+    "@stone-js/cli": "^0.8.10",
+    "@stone-js/testing": "^0.8.10",
     "@types/axios": "^0.14.4",
     "@types/node": "^24.0.7",
     "@types/react": "^19.0.7",

package/full-react-declarative/public/favicon.svg

@@ -0,0 +1,16 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 96 96" width="96" height="96" role="img" aria-label="Stone.js">
+  <title>Stone.js</title>
+  <style>
+    .ink { stroke: #1B1613; }
+    @media (prefers-color-scheme: dark) { .ink { stroke: #EFE8DC; } }
+  </style>
+  <defs>
+    <linearGradient id="braise" gradientUnits="userSpaceOnUse" x1="22" y1="14" x2="74" y2="26.1">
+      <stop offset="0" stop-color="#FFC46B" />
+      <stop offset="1" stop-color="#FF5A1F" />
+    </linearGradient>
+  </defs>
+  <path class="ink" d="M 79.96 36.4 A 34 34 0 0 1 53.9 81.5" fill="none" stroke-width="11" stroke-linecap="round" opacity=".85" />
+  <path class="ink" d="M 42.1 81.5 A 34 34 0 0 1 16.05 36.4" fill="none" stroke-width="11" stroke-linecap="round" opacity=".85" />
+  <path d="M 22 26.1 A 34 34 0 0 1 74 26.1" fill="none" stroke="url(#braise)" stroke-width="11" stroke-linecap="round" />
+</svg>

package/full-react-declarative/stone.config.mjs

@@ -1,9 +1,9 @@
-import { defineConfig } from '@stone-js/cli'
+import { defineBuilderConfig } from '@stone-js/cli'
 
 /**
  * Stone build configuration.
  */
-export default defineConfig({
+export default defineBuilderConfig({
   dotenv: {
     private: {
       path: ['.env', '.env.public'],

package/full-react-declarative/tests/application.spec.ts

@@ -0,0 +1,30 @@
+import { createTestApp, makeIncomingHttpEvent } from '@stone-js/testing'
+
+/**
+ * The whole application, booted in memory and asked a real question.
+ *
+ * Nothing is mocked and nothing is listed: `createTestApp()` discovers `app/**`, and the event goes
+ * through the same kernel production runs. If this passes the application works; if it fails the
+ * application is broken. That is the only kind of test worth shipping in a starter — the previous one
+ * stubbed out the framework's own decorators, which meant it could pass while nothing worked.
+ */
+describe('Pages', () => {
+  it('renders the home page, data included', async () => {
+    const app = await createTestApp()
+
+    const response = await app.send(makeIncomingHttpEvent({ method: 'GET', url: '/?name=Ada' }))
+
+    expect(response.statusCode).toBe(200)
+    // A page is a handler, so a rendered page is a response whose body is HTML. Query that HTML with
+    // whatever you already use (happy-dom, jsdom, Testing Library): none is bundled here.
+    expect(response.html()).toContain('Ada')
+  })
+
+  it('renders without a name', async () => {
+    const app = await createTestApp()
+
+    const response = await app.send(makeIncomingHttpEvent({ method: 'GET', url: '/' }))
+
+    expect(response.statusCode).toBe(200)
+  })
+})