@stone-js/starters 0.8.8 → 0.8.10

package/README.md

@@ -2,7 +2,7 @@
 
 [![License: MIT](https://img.shields.io/npm/l/@stone-js/starters)](https://opensource.org/licenses/MIT)
 [![Maintenance](https://img.shields.io/maintenance/yes/2026)](https://stonejs.dev)
-[![Used by Stone CLI](https://img.shields.io/badge/Used%20by-Stone%20CLI-blue)](https://github.com/stone-foundation/stone-js-cli)
+[![Used by Stone CLI](https://img.shields.io/badge/Used%20by-Stone%20CLI-blue)](https://github.com/stone-foundation/stone-js-framework)
 
 This repository contains official **starter templates** for Stone.js applications.
 
@@ -98,4 +98,4 @@ Explore the full documentation: [https://stonejs.dev](https://stonejs.dev)
 
 ## Contributing
 
-See [Contributing Guide](https://github.com/stone-foundation/stone-js-starters/blob/main/CONTRIBUTING.md)
+See [Contributing Guide](https://github.com/stone-foundation/stone-js-framework/blob/main/CONTRIBUTING.md)

package/basic-react-declarative/app/Application.tsx

@@ -1,6 +1,5 @@
 import { JSX } from 'react'
 import { Browser } from '@stone-js/browser-adapter'
-import { NodeConsole } from '@stone-js/node-cli-adapter'
 import { ILogger, LogLevel, Promiseable, StoneApp } from '@stone-js/core'
 import { ReactIncomingEvent, UseReact, HeadContext, IPage, PageHeadContext, PageRenderContext } from '@stone-js/use-react'
 
@@ -15,7 +14,6 @@ import { ReactIncomingEvent, UseReact, HeadContext, IPage, PageHeadContext, Page
  */
 @Browser()
 @UseReact()
-@NodeConsole()
 @StoneApp({ logger: { level: LogLevel.INFO } })
 export class Application implements IPage<ReactIncomingEvent> {
   /**

package/basic-react-declarative/package.json

@@ -14,22 +14,22 @@
     "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": {
     "react": "^19.0.0",
     "react-dom": "^19.0.0",
-    "@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/core": "^0.8.10",
+    "@stone-js/use-react": "^0.8.10",
+    "@stone-js/browser-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/basic-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/basic-react-declarative/tests/Application.spec.ts

@@ -1,105 +1,30 @@
-import { ILogger } from '@stone-js/core'
-import { Application } from '../app/Application'
-import { renderToString } from 'react-dom/server'
-import { ReactIncomingEvent } from '@stone-js/use-react'
-
-// We must mock decorators to lighten the test environment
-vi.mock('@stone-js/core', async (importOriginal) => {
-  const actual: any = await importOriginal()
-  return {
-    ...actual,
-    StoneApp: vi.fn(() => vi.fn()),
-  }
-})
-
-// We must mock decorators to lighten the test environment
-vi.mock('@stone-js/node-cli-adapter', async (importOriginal) => {
-  const actual: any = await importOriginal()
-  return {
-    ...actual,
-    NodeConsole: vi.fn(() => vi.fn()),
-  }
-})
-
-// We must mock decorators to lighten the test environment
-vi.mock('@stone-js/browser-adapter', async (importOriginal) => {
-  const actual: any = await importOriginal()
-  return {
-    ...actual,
-    Browser: vi.fn(() => vi.fn()),
-  }
-})
-
-// We must mock decorators to lighten the test environment
-vi.mock('@stone-js/use-react', async (importOriginal) => {
-  const actual: any = await importOriginal()
-  return {
-    ...actual,
-    UseReact: vi.fn(() => vi.fn()),
-  }
-})
-
-describe('Application', () => {
-  let app: Application
-  let mockedLogger: ILogger
-
-  beforeEach(() => {
-    mockedLogger = {
-      info: vi.fn(),
-    } as unknown as ILogger
-
-    app = new Application({ logger: mockedLogger })
-  })
-
-  it('should create an application instance', () => {
-    // Assert
-    expect(app).toBeInstanceOf(Application)
+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('get head values', async () => {
-    // Arrange
-    const event = { get: () => 'World' } as unknown as ReactIncomingEvent
+  it('renders without a name', async () => {
+    const app = await createTestApp()
 
-    // Act
-    const head = await app.head({ event })
+    const response = await app.send(makeIncomingHttpEvent({ method: 'GET', url: '/' }))
 
-    // Assert
-    expect(head).toHaveProperty('metas')
-    expect(head.title).toContain('Welcome to Stone.js')
-    expect(head.title).toContain('World')
-    expect(head).toHaveProperty('description')
+    expect(response.statusCode).toBe(200)
   })
-
-  it('should handle incoming events', () => {
-    // Arrange
-    const expectedMessage = 'Hello World!'
-    const event = { get: () => 'World' } as unknown as ReactIncomingEvent
-
-    // Act
-    const response = app.handle(event) as { message: string }
-
-    // Assert
-    expect(response.message).toBe(expectedMessage)
-    expect(mockedLogger.info).toHaveBeenCalledWith(expectedMessage)
-  })
-
-  it('should render the message', () => {
-    // Arrange
-    const message = 'Hello World!'
-
-    // Act
-    const response = renderToString(app.render({ data: { message } } as any))
-
-    // Assert
-    expect(response).toContain(message)
-  })
-
-  it('should render the Stone.js logo', () => {
-    // Act
-    const response = renderToString(app.render({ data: { message: 'Hello World!' } } as any))
-
-    // Assert
-    expect(response).toContain('/logo.svg')
-    expect(response).toContain('alt="Stone.js"')
-  })
-})
+})

package/basic-react-imperative/app/Application.tsx

@@ -1,7 +1,6 @@
 import { JSX } from 'react'
 import { browserAdapterBlueprint } from '@stone-js/browser-adapter'
-import { defineConfig, IBlueprint, ILogger, isNotEmpty, Promiseable } from '@stone-js/core'
-import { defineCommand, FactoryCommandHandler, NODE_CONSOLE_PLATFORM, nodeConsoleAdapterBlueprint } from '@stone-js/node-cli-adapter'
+import { ILogger, Promiseable } from '@stone-js/core'
 import { defineStoneReactApp, HeadContext, IPage, PageHeadContext, PageRenderContext, ReactIncomingEvent } from '@stone-js/use-react'
 
 /**
@@ -73,23 +72,9 @@ export const FactoryHandler = ({ logger }: AppOptions): IPage<ReactIncomingEvent
 export const Application = defineStoneReactApp(
   FactoryHandler,
   { debug: true, isFactory: true },
-  [browserAdapterBlueprint, nodeConsoleAdapterBlueprint]
+  [browserAdapterBlueprint]
 )
 
-/**
- * Application configuration.
- */
-export const AppConfig = defineConfig({
-  afterConfigure (blueprint: IBlueprint) {
-    if (
-      isNotEmpty<FactoryCommandHandler>(FactoryHandler) &&
-      blueprint.is('stone.adapter.platform', NODE_CONSOLE_PLATFORM)
-    ) {
-      blueprint.set(defineCommand(FactoryHandler, { name: '*', isFactory: true }))
-    }
-  }
-})
-
 /**
  * Application options.
  */

package/basic-react-imperative/package.json

@@ -14,22 +14,22 @@
     "build": "stone build",
     "preview": "stone preview",
     "typings": "stone typings",
-    "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/use-react": "^0.8.8",
-    "@stone-js/browser-adapter": "^0.8.8",
-    "@stone-js/node-cli-adapter": "^0.8.8"
+    "@stone-js/core": "^0.8.10",
+    "@stone-js/use-react": "^0.8.10",
+    "@stone-js/browser-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/basic-react-imperative/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/basic-react-imperative/tests/Application.spec.ts

@@ -1,91 +1,30 @@
-import { renderToString } from 'react-dom/server'
-import { ILogger, IncomingEvent } from '@stone-js/core'
-import { FactoryHandler, AppConfig } 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
-  }
-})
-
-describe('Application', () => {
-  let app: any
-  let mockedLogger: ILogger
-
-  beforeEach(() => {
-    mockedLogger = {
-      info: vi.fn(),
-    } as unknown as ILogger
-
-    app = FactoryHandler({ logger: mockedLogger })
-  })
-
-  it('should create an application instance', () => {
-    // Assert
-    expect(app).toBeInstanceOf(Object)
-  })
-
-  it('get head values', async () => {
-    // Arrange
-    const event = { get: () => 'World' } as unknown as IncomingEvent
-
-    // Act
-    const head = await app.head({ event })
-
-    // Assert
-    expect(head).toHaveProperty('metas')
-    expect(head.title).toContain('Welcome to Stone.js')
-    expect(head.title).toContain('World')
-    expect(head).toHaveProperty('description')
+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('should handle incoming events', () => {
-    // Arrange
-    const expectedMessage = 'Hello World!'
-    const event = { get: () => 'World' } as unknown as IncomingEvent
+  it('renders without a name', async () => {
+    const app = await createTestApp()
 
-    // Act
-    const response = app.handle(event) as { message: string }
+    const response = await app.send(makeIncomingHttpEvent({ method: 'GET', url: '/' }))
 
-    // Assert
-    expect(response.message).toBe(expectedMessage)
-    expect(mockedLogger.info).toHaveBeenCalledWith(expectedMessage)
+    expect(response.statusCode).toBe(200)
   })
-
-  it('should render the message', () => {
-    // Arrange
-    const message = 'Hello World!'
-
-    // Act
-    const response = renderToString(app.render({ data: { message } } as any))
-
-    // Assert
-    expect(response).toContain(message)
-  })
-
-  it('should render the Stone.js logo', () => {
-    // Act
-    const response = renderToString(app.render({ data: { message: 'Hello World!' } } as any))
-
-    // Assert
-    expect(response).toContain('/logo.svg')
-    expect(response).toContain('alt="Stone.js"')
-    expect(response).toContain('Welcome to')
-    expect(response).toContain('Stone.js')
-  })
-
-  it('should get config', () => {
-    // Arrange
-    const config: any = AppConfig
-    const blueprint: any = { is: () => true, set: vi.fn() }
-
-    // Act
-    config.afterConfigure(blueprint)
-
-    // Assert
-    expect(blueprint.set).toHaveBeenCalled()
-  })
-})
+})

package/basic-react-native-declarative/App.tsx

@@ -0,0 +1,192 @@
+import { stoneApp } from '@stone-js/core'
+import { StatusBar } from 'expo-status-bar'
+import { useEffect, useState } from 'react'
+import { Application } from './app/Application'
+import { WelcomeData, WelcomeController } from './app/WelcomeController'
+import { nativeEventSource } from './adapter/NativeEventSource'
+import { onNativeError, onNativeRender } from './adapter/renderSink'
+import { Pressable, ScrollView, StyleSheet, Text, View } from 'react-native'
+
+/**
+ * One platform self-check, shown as a green or red row on screen.
+ */
+interface PlatformCheck {
+  label: string
+  passed: boolean
+  detail: string
+}
+
+/**
+ * A minimal stage-3 decorator writing into `context.metadata`: if Babel emits
+ * the 2023-11 semantics correctly under Metro/Hermes, the value is readable
+ * back through `Symbol.metadata` (or its `Symbol.for` fallback, the one
+ * Stone.js core uses).
+ */
+const probe: any = (_value: unknown, context: { metadata: Record<PropertyKey, unknown> }): undefined => {
+  context.metadata.stonePoc = 'ok'
+}
+
+@probe
+class MetadataProbe {}
+
+/**
+ * Run the runtime platform checks Stone.js depends on.
+ *
+ * @returns The list of checks with their outcome.
+ */
+function runPlatformChecks (): PlatformCheck[] {
+  const checks: PlatformCheck[] = []
+
+  const metadataSymbol: symbol = (Symbol as any).metadata ?? Symbol.for('Symbol.metadata')
+  const probeMetadata = (MetadataProbe as any)[metadataSymbol]
+  checks.push({
+    label: 'Decorators 2023-11 + Symbol.metadata',
+    passed: probeMetadata?.stonePoc === 'ok',
+    detail: probeMetadata?.stonePoc === 'ok' ? 'context.metadata readable' : 'metadata missing'
+  })
+
+  let urlPassed = false
+  let urlDetail = 'URL API incomplete'
+  try {
+    const url = new URL('stone://app/hello/Noowow?from=poc')
+    urlPassed = url.pathname === '/hello/Noowow' && url.searchParams.get('from') === 'poc'
+    urlDetail = urlPassed ? 'pathname + searchParams OK' : `pathname=${String(url.pathname)}`
+  } catch (error: any) {
+    urlDetail = String(error?.message ?? error)
+  }
+  checks.push({ label: 'WHATWG URL (polyfill)', passed: urlPassed, detail: urlDetail })
+
+  const encoderPassed = typeof globalThis.TextEncoder !== 'undefined' &&
+    new TextEncoder().encode('stone').byteLength === 5
+  checks.push({
+    label: 'TextEncoder',
+    passed: encoderPassed,
+    detail: encoderPassed ? 'available' : 'missing'
+  })
+
+  return checks
+}
+
+/**
+ * The proof-of-concept screen: boots the Stone.js application through the
+ * native adapter, shows the platform checks and lets you navigate between
+ * routes of the same domain you would deploy on any other platform.
+ */
+export default function App (): React.JSX.Element {
+  const [checks, setChecks] = useState<PlatformCheck[]>([])
+  const [payload, setPayload] = useState<WelcomeData>()
+  const [error, setError] = useState<string>()
+  const [booted, setBooted] = useState(false)
+
+  useEffect(() => {
+    setChecks(runPlatformChecks())
+
+    onNativeRender((response) => {
+      setError(undefined)
+      setBooted(true)
+      setPayload(response.content as WelcomeData)
+    })
+
+    onNativeError((err) => {
+      setError(String(err?.message ?? err))
+    })
+
+    stoneApp({ modules: [Application, WelcomeController] })
+      .run()
+      .catch((err: Error) => setError(String(err?.message ?? err)))
+  }, [])
+
+  const allPassed = checks.every((check) => check.passed) && booted && error === undefined
+
+  return (
+    <View style={styles.container}>
+      <StatusBar style='light' />
+      <ScrollView contentContainerStyle={styles.content}>
+        <Text style={styles.title}>Stone.js × React Native</Text>
+        <Text style={styles.subtitle}>Continuum proof of concept</Text>
+
+        <View style={[styles.banner, allPassed ? styles.bannerOk : styles.bannerKo]}>
+          <Text style={styles.bannerText}>
+            {allPassed ? 'ALL CHECKS GREEN' : (booted ? 'CHECKS FAILING' : 'BOOTING…')}
+          </Text>
+        </View>
+
+        {checks.map((check) => (
+          <View key={check.label} style={styles.checkRow}>
+            <Text style={check.passed ? styles.checkOk : styles.checkKo}>
+              {check.passed ? '✓' : '✗'} {check.label}
+            </Text>
+            <Text style={styles.checkDetail}>{check.detail}</Text>
+          </View>
+        ))}
+
+        <View style={styles.checkRow}>
+          <Text style={booted ? styles.checkOk : styles.checkKo}>
+            {booted ? '✓' : '…'} Kernel boot + router dispatch
+          </Text>
+          <Text style={styles.checkDetail}>
+            {booted ? `matched ${String(payload?.route)}` : 'waiting for the first render'}
+          </Text>
+        </View>
+
+        {error !== undefined && (
+          <View style={styles.errorBox}>
+            <Text style={styles.errorText}>{error}</Text>
+          </View>
+        )}
+
+        {payload !== undefined && (
+          <View style={styles.payloadBox}>
+            <Text style={styles.payloadMessage}>{payload.message}</Text>
+            <Text style={styles.payloadMeta}>
+              {payload.framework.name} · {payload.framework.tagline}
+            </Text>
+          </View>
+        )}
+
+        <Text style={styles.sectionTitle}>Navigate the same domain</Text>
+        <View style={styles.buttons}>
+          <NavButton label='Home' url='stone://app/' />
+          <NavButton label='Hello Noowow' url='stone://app/hello/Noowow' />
+          <NavButton label='Hello Mr. Stone' url='stone://app/hello/Mr.%20Stone' />
+          <NavButton label='Unknown route' url='stone://app/nowhere' />
+        </View>
+      </ScrollView>
+    </View>
+  )
+}
+
+/**
+ * A navigation button emitting an intent into the native event source.
+ */
+function NavButton ({ label, url }: { label: string, url: string }): React.JSX.Element {
+  return (
+    <Pressable style={styles.button} onPress={() => nativeEventSource.navigate(url)}>
+      <Text style={styles.buttonText}>{label}</Text>
+    </Pressable>
+  )
+}
+
+const styles = StyleSheet.create({
+  container: { flex: 1, backgroundColor: '#141210' },
+  content: { padding: 24, paddingTop: 72 },
+  title: { color: '#f5f1ea', fontSize: 26, fontWeight: '700' },
+  subtitle: { color: '#b8b0a4', fontSize: 14, marginTop: 4, marginBottom: 20 },
+  banner: { borderRadius: 8, paddingVertical: 10, alignItems: 'center', marginBottom: 20 },
+  bannerOk: { backgroundColor: '#1f5130' },
+  bannerKo: { backgroundColor: '#5e2b1e' },
+  bannerText: { color: '#f5f1ea', fontWeight: '700', letterSpacing: 1 },
+  checkRow: { marginBottom: 12 },
+  checkOk: { color: '#7fd39a', fontSize: 15, fontWeight: '600' },
+  checkKo: { color: '#e88d70', fontSize: 15, fontWeight: '600' },
+  checkDetail: { color: '#8d8578', fontSize: 12, marginLeft: 18, marginTop: 2 },
+  errorBox: { backgroundColor: '#3a1f18', borderRadius: 8, padding: 12, marginTop: 8 },
+  errorText: { color: '#e88d70', fontSize: 13 },
+  payloadBox: { backgroundColor: '#221e1a', borderRadius: 8, padding: 16, marginTop: 16 },
+  payloadMessage: { color: '#f5f1ea', fontSize: 16, fontWeight: '600' },
+  payloadMeta: { color: '#b8b0a4', fontSize: 12, marginTop: 6 },
+  sectionTitle: { color: '#f5f1ea', fontSize: 16, fontWeight: '700', marginTop: 28, marginBottom: 12 },
+  buttons: { gap: 10 },
+  button: { backgroundColor: '#2e2823', borderRadius: 8, paddingVertical: 12, alignItems: 'center' },
+  buttonText: { color: '#f5f1ea', fontSize: 15, fontWeight: '600' }
+})

package/basic-react-native-declarative/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015-present 650 Industries, Inc. (aka Expo)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/basic-react-native-declarative/README.md

@@ -0,0 +1,35 @@
+# Stone.js · Basic React Native starter (declarative API)
+
+The same Stone.js domain you deploy on Node, serverless, edge or the browser, running as a **native mobile application** with React Native and Expo.
+
+## What this starter demonstrates
+
+- A Stone.js domain (`app/`) written with the declarative API: `@StoneApp`, `@Routing`, `@Controller`, `@Match`. The domain never knows it runs inside a native application.
+- The canonical activation paths: modules are enabled by their decorator, and the local adapter blueprint is activated through `@StoneApp(options, [blueprints])`.
+- Stage-3 decorators (2023-11) with `Symbol.metadata`, transformed by Babel under Metro (see `babel.config.js`: the semantics are set through `babel-preset-expo`'s `decorators` option).
+- The universal Stone router matching navigation intents (`stone://app/hello/:name`) exactly like it matches URLs in a browser SPA or paths behind an HTTP adapter.
+- A minimal native adapter (`adapter/`): it captures navigation intents, normalizes them into `IncomingBrowserEvent` and executes the render effect. It prefigures `@stone-js/react-native-adapter` and will be replaced by it once published.
+- The platform polyfills React Native needs (`index.ts`): the WHATWG `URL` API and, on older Hermes versions, `TextEncoder`.
+
+The start screen is a live self-check: decorators, URL API, TextEncoder, kernel boot and router dispatch are verified at runtime and shown as green or red rows.
+
+## Run it
+
+```bash
+npm install
+npm run ios      # opens the iOS simulator directly
+npm start        # or the interactive way: then press i (iOS) or a (Android)
+```
+
+## Test it
+
+The whole chain (domain, router, adapter) is pure JavaScript, so the exact modules the application boots are also tested under Node:
+
+```bash
+npm test
+npm run typecheck
+```
+
+## What is shared with your other platforms
+
+Domain, routing, services and data loading. Not the UI components: native screens are React Native components, browser pages are DOM components.