@emeryld/create-rrroutes 0.1.0

package/dist/index.js

@@ -0,0 +1,1524 @@
+#!/usr/bin/env node
+#!/usr/bin/env node
+
+// src/index.ts
+import path6 from "path";
+
+// src/generators/client.ts
+import path2 from "path";
+
+// src/utils/fs.ts
+import fs from "fs/promises";
+import path from "path";
+async function ensureDir(dir) {
+  await fs.mkdir(dir, { recursive: true });
+}
+async function pathExists(target) {
+  try {
+    await fs.access(target);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function writeFileIfMissing(filePath, contents) {
+  const dir = path.dirname(filePath);
+  await ensureDir(dir);
+  if (await pathExists(filePath)) {
+    return "skipped";
+  }
+  await fs.writeFile(filePath, contents, "utf8");
+  return "created";
+}
+async function writeFileForce(filePath, contents) {
+  const dir = path.dirname(filePath);
+  await ensureDir(dir);
+  await fs.writeFile(filePath, contents, "utf8");
+}
+
+// src/utils/log.ts
+var log = {
+  info(msg) {
+    console.log(msg);
+  },
+  step(msg) {
+    console.log(`\u2022 ${msg}`);
+  },
+  created(target) {
+    console.log(`  created ${target}`);
+  },
+  skipped(target) {
+    console.log(`  skipped ${target} (already exists)`);
+  },
+  warn(msg) {
+    console.warn(`  warning: ${msg}`);
+  },
+  error(msg) {
+    console.error(`  error: ${msg}`);
+  }
+};
+
+// src/generators/client.ts
+function baseTsConfig() {
+  return {
+    extends: "../../tsconfig.base.json",
+    compilerOptions: {
+      outDir: "dist",
+      rootDir: "src",
+      types: ["vite/client"]
+    },
+    include: ["src/**/*", "vite.config.ts"]
+  };
+}
+function viteConfig() {
+  return `import { defineConfig } from 'vite'
+import react from '@vitejs/plugin-react'
+
+export default defineConfig({
+  plugins: [react()],
+})
+`;
+}
+function queryClient(contractImport) {
+  return `import { QueryClient } from '@tanstack/react-query'
+import { createRouteClient } from '@emeryld/rrroutes-client'
+import { registry } from '${contractImport}'
+
+const baseUrl = import.meta.env.VITE_API_URL ?? 'http://localhost:4000'
+
+export const queryClient = new QueryClient()
+
+export const routeClient = createRouteClient({
+  baseUrl,
+  queryClient,
+  environment: import.meta.env.MODE === 'production' ? 'production' : 'development',
+})
+
+export const healthGet = routeClient.build(registry.byKey['GET /api/health'])
+export const healthPost = routeClient.build(registry.byKey['POST /api/health'])
+`;
+}
+function socketProvider(contractImport) {
+  return `import React from 'react'
+import { io, type Socket } from 'socket.io-client'
+import {
+  buildSocketProvider,
+  type SocketClientOptions,
+} from '@emeryld/rrroutes-client'
+import { socketConfig, socketEvents } from '${contractImport}'
+
+const socketUrl = import.meta.env.VITE_SOCKET_URL ?? 'http://localhost:4000'
+const socketPath = import.meta.env.VITE_SOCKET_PATH ?? '/socket.io'
+
+const sysEvents: SocketClientOptions<
+  typeof socketEvents,
+  typeof socketConfig
+>['sys'] = {
+  'sys:connect': async ({ socket }) => {
+    console.info('socket connected', socket.id)
+  },
+  'sys:disconnect': async ({ reason }) => {
+    console.info('socket disconnected', reason)
+  },
+  'sys:reconnect': async ({ attempt, socket }) => {
+    console.info('socket reconnect', attempt, socket?.id)
+  },
+  'sys:connect_error': async ({ error }) => {
+    console.warn('socket connect error', error)
+  },
+  'sys:ping': () => ({
+    note: 'client-heartbeat',
+    sentAt: new Date().toISOString(),
+  }),
+  'sys:pong': async ({ payload }) => {
+    console.info('socket pong', payload)
+  },
+  'sys:room_join': async ({ rooms }) => {
+    console.info('joining rooms', rooms)
+    return true
+  },
+  'sys:room_leave': async ({ rooms }) => {
+    console.info('leaving rooms', rooms)
+    return true
+  },
+}
+
+const baseOptions: Omit<
+  SocketClientOptions<typeof socketEvents, typeof socketConfig>,
+  'socket'
+> = {
+  config: socketConfig,
+  sys: sysEvents,
+  environment: import.meta.env.MODE === 'production' ? 'production' : 'development',
+  heartbeat: { intervalMs: 15_000, timeoutMs: 7_500 },
+  debug: {
+    connection: true,
+    heartbeat: true,
+  },
+}
+
+const { SocketProvider, useSocketClient, useSocketConnection } =
+  buildSocketProvider({
+    events: socketEvents,
+    options: baseOptions,
+  })
+
+function getSocket(): Promise<Socket> {
+  return Promise.resolve(
+    io(socketUrl, {
+      path: socketPath,
+      transports: ['websocket'],
+    }),
+  )
+}
+
+export const roomMeta = { room: 'health' }
+
+export function AppSocketProvider(props: React.PropsWithChildren) {
+  return (
+    <SocketProvider
+      getSocket={getSocket}
+      destroyLeaveMeta={roomMeta}
+      fallback={<p>Connecting socket\u2026</p>}
+    >
+      {props.children}
+    </SocketProvider>
+  )
+}
+
+export { useSocketClient, useSocketConnection }
+`;
+}
+var MAIN_TSX = `import React from 'react'
+import ReactDOM from 'react-dom/client'
+import App from './App'
+import './styles.css'
+
+ReactDOM.createRoot(document.getElementById('root')!).render(
+  <React.StrictMode>
+    <App />
+  </React.StrictMode>,
+)
+`;
+function appTsx() {
+  return `import React from 'react'
+import { QueryClientProvider } from '@tanstack/react-query'
+import { queryClient } from './lib/queryClient'
+import { AppSocketProvider } from './lib/socket'
+import { HealthPage } from './pages/HealthPage'
+
+export default function App() {
+  return (
+    <QueryClientProvider client={queryClient}>
+      <AppSocketProvider>
+        <HealthPage />
+      </AppSocketProvider>
+    </QueryClientProvider>
+  )
+}
+`;
+}
+var STYLES = `:root {
+  font-family: 'Inter', system-ui, -apple-system, sans-serif;
+  color: #0b1021;
+  background: #f7f8fb;
+}
+
+body {
+  margin: 0;
+  background: radial-gradient(circle at 20% 20%, #eef2ff, #f7f8fb 45%);
+  min-height: 100vh;
+}
+
+.health {
+  max-width: 960px;
+  margin: 0 auto;
+  padding: 32px;
+  display: flex;
+  flex-direction: column;
+  gap: 16px;
+}
+
+.grid {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(280px, 1fr));
+  gap: 16px;
+}
+
+.card {
+  background: #fff;
+  border: 1px solid #e5e7eb;
+  border-radius: 12px;
+  padding: 16px;
+  box-shadow: 0 8px 24px rgba(12, 18, 32, 0.05);
+}
+
+button {
+  background: #0f172a;
+  color: #fff;
+  border: none;
+  border-radius: 8px;
+  padding: 10px 12px;
+  cursor: pointer;
+  font-weight: 600;
+}
+
+button.secondary {
+  background: #e2e8f0;
+  color: #0f172a;
+}
+
+button + button {
+  margin-left: 8px;
+}
+
+textarea {
+  width: 100%;
+  min-height: 80px;
+}
+
+.logs {
+  font-family: ui-monospace, SFMono-Regular, Consolas, 'Liberation Mono', Menlo,
+    monospace;
+  background: #0f172a;
+  color: #e2e8f0;
+  padding: 12px;
+  border-radius: 8px;
+  min-height: 160px;
+  white-space: pre-line;
+}
+`;
+function healthPage(contractImport) {
+  return `import React from 'react'
+import { healthGet, healthPost } from '../lib/queryClient'
+import { roomMeta, useSocketClient, useSocketConnection } from '../lib/socket'
+
+const now = () => new Date().toLocaleTimeString()
+
+function useLogs() {
+  const [logs, setLogs] = React.useState<string[]>([])
+  return {
+    logs,
+    push: (msg: string) =>
+      setLogs((prev) => [\`[\${now()}] \${msg}\`, ...prev].slice(0, 60)),
+    clear: () => setLogs([]),
+  }
+}
+
+export function HealthPage() {
+  const [echo, setEcho] = React.useState('hello rrroute')
+  const httpGet = healthGet.useEndpoint()
+  const httpPost = healthPost.useEndpoint()
+  const socket = useSocketClient<typeof import('${contractImport}').socketEvents>()
+  const { logs, push, clear } = useLogs()
+
+  useSocketConnection({
+    event: 'health:connected',
+    rooms: ['health'],
+    joinMeta: roomMeta,
+    leaveMeta: roomMeta,
+    onMessage: (payload) => {
+      push(\`socket connected (\${payload.socketId})\`)
+    },
+  })
+
+  useSocketConnection({
+    event: 'health:pong',
+    rooms: ['health'],
+    joinMeta: roomMeta,
+    leaveMeta: roomMeta,
+    onMessage: (payload) => {
+      push(
+        \`pong at \${payload.at}\${payload.echo ? \` (echo: \${payload.echo})\` : ''}\`,
+      )
+    },
+  })
+
+  return (
+    <div className="health">
+      <h1>RRRoutes health sandbox</h1>
+      <div className="grid">
+        <div className="card">
+          <h2>HTTP endpoints</h2>
+          <p>GET and POST against the shared contract.</p>
+          <div>
+            <button onClick={() => httpGet.refetch()}>GET /health</button>
+          </div>
+          <div style={{ marginTop: 12 }}>
+            <input
+              value={echo}
+              onChange={(e) => setEcho(e.target.value)}
+              placeholder="echo payload"
+              style={{ width: '100%', padding: '8px' }}
+            />
+            <div style={{ marginTop: 8 }}>
+              <button
+                onClick={() =>
+                  httpPost.mutateAsync({ echo }).then(() => {
+                    push('POST /health ok')
+                  })
+                }
+              >
+                POST /health
+              </button>
+            </div>
+          </div>
+          <div style={{ marginTop: 12 }}>
+            <strong>GET data</strong>
+            <pre>{JSON.stringify(httpGet.data, null, 2) ?? 'none'}</pre>
+            <strong>POST data</strong>
+            <pre>{JSON.stringify(httpPost.data, null, 2) ?? 'none'}</pre>
+          </div>
+        </div>
+
+        <div className="card">
+          <h2>Socket</h2>
+          <p>Connect, ping, and watch lifecycle events.</p>
+          <div style={{ display: 'flex', gap: 8, flexWrap: 'wrap' }}>
+            <button onClick={() => socket.connect()}>Connect</button>
+            <button className="secondary" onClick={() => socket.disconnect()}>
+              Disconnect
+            </button>
+            <button
+              onClick={() =>
+                socket.emit('health:ping', { note: 'ping from client' })
+              }
+            >
+              Emit ping
+            </button>
+            <button
+              className="secondary"
+              onClick={() => socket.joinRooms(['health'], roomMeta)}
+            >
+              Join room
+            </button>
+            <button
+              className="secondary"
+              onClick={() => socket.leaveRooms(['health'], roomMeta)}
+            >
+              Leave room
+            </button>
+          </div>
+        </div>
+
+        <div className="card">
+          <h2>Socket logs</h2>
+          <button className="secondary" onClick={clear}>
+            Clear
+          </button>
+          <div className="logs">
+            {logs.length === 0 ? 'No messages yet' : logs.join('\\n')}
+          </div>
+        </div>
+      </div>
+    </div>
+  )
+}
+`;
+}
+function indexHtml() {
+  return `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>RRRoutes starter</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>
+`;
+}
+var CLIENT_ENV = `VITE_API_URL=http://localhost:4000
+VITE_SOCKET_URL=http://localhost:4000
+VITE_SOCKET_PATH=/socket.io
+`;
+function nativePackageJson(clientName, contractName) {
+  return {
+    name: clientName,
+    version: "0.1.0",
+    private: true,
+    main: "expo/AppEntry",
+    scripts: {
+      start: "expo start",
+      android: "expo start --android",
+      ios: "expo start --ios",
+      web: "expo start --web",
+      test: 'echo "add tests"'
+    },
+    dependencies: {
+      [contractName]: "workspace:*",
+      "@emeryld/rrroutes-client": "^2.5.3",
+      "@tanstack/react-query": "^5.90.12",
+      expo: "~52.0.8",
+      "expo-constants": "~16.0.2",
+      "expo-status-bar": "~2.0.1",
+      react: "18.3.1",
+      "react-native": "0.76.6",
+      "react-native-safe-area-context": "4.12.0",
+      "react-native-screens": "4.4.0",
+      "socket.io-client": "^4.8.3",
+      zod: "^4.2.1"
+    },
+    devDependencies: {
+      "@babel/core": "^7.25.2",
+      "@types/react": "~18.2.79",
+      "@types/react-native": "~0.73.0",
+      typescript: "^5.9.3"
+    }
+  };
+}
+function nativeAppJson(appSlug) {
+  return {
+    expo: {
+      name: `${appSlug}-client`,
+      slug: `${appSlug}-client`,
+      version: "0.1.0",
+      orientation: "portrait",
+      scheme: appSlug,
+      platforms: ["ios", "android", "web"],
+      userInterfaceStyle: "light",
+      extra: {
+        apiUrl: "http://localhost:4000",
+        socketUrl: "http://localhost:4000",
+        socketPath: "/socket.io"
+      },
+      experiments: {
+        typedRoutes: false
+      }
+    }
+  };
+}
+var NATIVE_BABEL = `module.exports = function (api) {
+  api.cache(true)
+  return {
+    presets: ['babel-preset-expo'],
+  }
+}
+`;
+var NATIVE_TS_CONFIG = {
+  extends: "../../tsconfig.base.json",
+  compilerOptions: {
+    jsx: "react-native",
+    types: ["react-native", "react"]
+  },
+  include: ["**/*.ts", "**/*.tsx"],
+  exclude: ["node_modules", "babel.config.js", "metro.config.js"]
+};
+function nativeQueryClient(contractImport) {
+  return `import Constants from 'expo-constants'
+import { QueryClient } from '@tanstack/react-query'
+import { createRouteClient } from '@emeryld/rrroutes-client'
+import { registry } from '${contractImport}'
+
+const { apiUrl } = (Constants.expoConfig?.extra ?? {}) as Record<string, string>
+
+export const queryClient = new QueryClient()
+
+export const routeClient = createRouteClient({
+  baseUrl: apiUrl ?? 'http://localhost:4000',
+  queryClient,
+})
+
+export const healthGet = routeClient.build(registry.byKey['GET /api/health'])
+export const healthPost = routeClient.build(registry.byKey['POST /api/health'])
+`;
+}
+function nativeSocket(contractImport) {
+  return `import React from 'react'
+import Constants from 'expo-constants'
+import { io, type Socket } from 'socket.io-client'
+import {
+  buildSocketProvider,
+  type SocketClientOptions,
+} from '@emeryld/rrroutes-client'
+import { socketConfig, socketEvents } from '${contractImport}'
+
+const extras = (Constants.expoConfig?.extra ?? {}) as Record<string, string>
+const socketUrl = extras.socketUrl ?? 'http://localhost:4000'
+const socketPath = extras.socketPath ?? '/socket.io'
+
+const sysEvents: SocketClientOptions<
+  typeof socketEvents,
+  typeof socketConfig
+>['sys'] = {
+  'sys:connect': async ({ socket }) => {
+    console.log('socket connected', socket.id)
+  },
+  'sys:disconnect': async ({ reason }) => console.log('disconnected', reason),
+  'sys:reconnect': async ({ attempt, socket }) =>
+    console.log('reconnect', attempt, socket?.id),
+  'sys:connect_error': async ({ error }) =>
+    console.warn('socket connect error', error),
+  'sys:ping': () => ({
+    note: 'client-heartbeat',
+    sentAt: new Date().toISOString(),
+  }),
+  'sys:pong': async ({ payload }) => console.log('pong', payload),
+  'sys:room_join': async ({ rooms }) => {
+    console.log('join rooms', rooms)
+    return true
+  },
+  'sys:room_leave': async ({ rooms }) => {
+    console.log('leave rooms', rooms)
+    return true
+  },
+}
+
+const baseOptions: Omit<
+  SocketClientOptions<typeof socketEvents, typeof socketConfig>,
+  'socket'
+> = {
+  config: socketConfig,
+  sys: sysEvents,
+  heartbeat: { intervalMs: 15_000, timeoutMs: 7_500 },
+  debug: { connection: true },
+}
+
+const { SocketProvider, useSocketClient, useSocketConnection } =
+  buildSocketProvider({
+    events: socketEvents,
+    options: baseOptions,
+  })
+
+function getSocket(): Promise<Socket> {
+  return Promise.resolve(
+    io(socketUrl, {
+      path: socketPath,
+      transports: ['websocket'],
+    }),
+  )
+}
+
+export const roomMeta = { room: 'health' }
+
+export function AppSocketProvider(props: React.PropsWithChildren) {
+  return (
+    <SocketProvider
+      getSocket={getSocket}
+      destroyLeaveMeta={roomMeta}
+      fallback={<></>}
+    >
+      {props.children}
+    </SocketProvider>
+  )
+}
+
+export { useSocketClient, useSocketConnection }
+`;
+}
+function nativeAppTsx() {
+  return `import React from 'react'
+import { SafeAreaView, ScrollView, StatusBar, StyleSheet } from 'react-native'
+import { QueryClientProvider } from '@tanstack/react-query'
+import { queryClient } from './src/queryClient'
+import { AppSocketProvider } from './src/socket'
+import { HealthScreen } from './src/screens/HealthScreen'
+
+export default function App() {
+  return (
+    <QueryClientProvider client={queryClient}>
+      <AppSocketProvider>
+        <StatusBar barStyle="dark-content" />
+        <SafeAreaView style={styles.container}>
+          <ScrollView contentInsetAdjustmentBehavior="automatic">
+            <HealthScreen />
+          </ScrollView>
+        </SafeAreaView>
+      </AppSocketProvider>
+    </QueryClientProvider>
+  )
+}
+
+const styles = StyleSheet.create({
+  container: {
+    flex: 1,
+    padding: 16,
+    backgroundColor: '#f4f5fb',
+  },
+})
+`;
+}
+function nativeHealthScreen(contractImport) {
+  return `import React from 'react'
+import {
+  Button,
+  StyleSheet,
+  Text,
+  TextInput,
+  View,
+} from 'react-native'
+import { healthGet, healthPost } from '../queryClient'
+import { roomMeta, useSocketClient, useSocketConnection } from '../socket'
+
+const now = () => new Date().toLocaleTimeString()
+
+function useLogs() {
+  const [logs, setLogs] = React.useState<string[]>([])
+  return {
+    logs,
+    push: (msg: string) =>
+      setLogs((prev) => [\`[\${now()}] \${msg}\`, ...prev].slice(0, 60)),
+    clear: () => setLogs([]),
+  }
+}
+
+export function HealthScreen() {
+  const [echo, setEcho] = React.useState('hello rrroute')
+  const httpGet = healthGet.useEndpoint()
+  const httpPost = healthPost.useEndpoint()
+  const socket = useSocketClient<typeof import('${contractImport}').socketEvents>()
+  const { logs, push, clear } = useLogs()
+
+  useSocketConnection({
+    event: 'health:connected',
+    rooms: ['health'],
+    joinMeta: roomMeta,
+    leaveMeta: roomMeta,
+    onMessage: (payload) => push(\`connected \${payload.socketId}\`),
+  })
+
+  useSocketConnection({
+    event: 'health:pong',
+    rooms: ['health'],
+    joinMeta: roomMeta,
+    leaveMeta: roomMeta,
+    onMessage: (payload) =>
+      push(\`pong at \${payload.at}\${payload.echo ? \` (echo: \${payload.echo})\` : ''}\`),
+  })
+
+  return (
+    <View style={styles.card}>
+      <Text style={styles.title}>RRRoutes health sandbox</Text>
+      <View style={styles.section}>
+        <Text style={styles.heading}>HTTP</Text>
+        <Button title="GET /health" onPress={() => httpGet.refetch()} />
+        <View style={{ height: 12 }} />
+        <TextInput
+          style={styles.input}
+          value={echo}
+          onChangeText={setEcho}
+          placeholder="echo payload"
+        />
+        <Button
+          title="POST /health"
+          onPress={() =>
+            httpPost
+              .mutateAsync({ echo })
+              .then(() => push('POST /health ok'))
+          }
+        />
+        <Text style={styles.label}>GET data</Text>
+        <Text style={styles.code}>
+          {JSON.stringify(httpGet.data ?? {}, null, 2)}
+        </Text>
+        <Text style={styles.label}>POST data</Text>
+        <Text style={styles.code}>
+          {JSON.stringify(httpPost.data ?? {}, null, 2)}
+        </Text>
+      </View>
+
+      <View style={styles.section}>
+        <Text style={styles.heading}>Socket</Text>
+        <View style={styles.row}>
+          <Button title="Connect" onPress={() => socket.connect()} />
+          <Button title="Disconnect" onPress={() => socket.disconnect()} />
+        </View>
+        <View style={{ height: 8 }} />
+        <Button
+          title="Emit ping"
+          onPress={() => socket.emit('health:ping', { note: 'ping from app' })}
+        />
+        <View style={{ height: 8 }} />
+        <View style={styles.row}>
+          <Button
+            title="Join room"
+            onPress={() => socket.joinRooms(['health'], roomMeta)}
+          />
+          <Button
+            title="Leave room"
+            onPress={() => socket.leaveRooms(['health'], roomMeta)}
+          />
+        </View>
+      </View>
+
+      <View style={styles.section}>
+        <Text style={styles.heading}>Socket logs</Text>
+        <Button title="Clear logs" onPress={clear} />
+        <Text style={styles.code}>
+          {logs.length === 0 ? 'No messages yet' : logs.join('\\n')}
+        </Text>
+      </View>
+    </View>
+  )
+}
+
+const styles = StyleSheet.create({
+  card: {
+    backgroundColor: '#fff',
+    borderRadius: 12,
+    padding: 16,
+    gap: 12,
+    shadowColor: '#000',
+    shadowOpacity: 0.05,
+    shadowRadius: 8,
+  },
+  title: { fontSize: 20, fontWeight: '700' },
+  section: { gap: 8 },
+  heading: { fontWeight: '600', fontSize: 16 },
+  row: { flexDirection: 'row', gap: 8, justifyContent: 'space-between' },
+  input: {
+    borderWidth: 1,
+    borderColor: '#d0d4de',
+    borderRadius: 8,
+    padding: 8,
+  },
+  label: { marginTop: 6, fontWeight: '600' },
+  code: {
+    backgroundColor: '#0f172a',
+    color: '#e2e8f0',
+    padding: 8,
+    borderRadius: 8,
+    fontFamily: 'Courier',
+  },
+})
+`;
+}
+var NATIVE_ENV = `API_URL=http://localhost:4000
+SOCKET_URL=http://localhost:4000
+SOCKET_PATH=/socket.io
+`;
+async function scaffoldClient(ctx) {
+  return ctx.clientKind === "react-native" ? scaffoldNativeClient(ctx) : scaffoldWebClient(ctx);
+}
+async function scaffoldWebClient(ctx) {
+  const baseDir = path2.join(ctx.rootDir, "packages", "client");
+  await ensureDir(path2.join(baseDir, "src", "lib"));
+  await ensureDir(path2.join(baseDir, "src", "pages"));
+  const pkgJson = {
+    name: ctx.packageNames.client,
+    version: "0.1.0",
+    private: true,
+    type: "module",
+    main: "dist/index.js",
+    scripts: {
+      dev: "vite",
+      build: "vite build",
+      preview: "vite preview",
+      typecheck: "tsc -p tsconfig.json --noEmit"
+    },
+    dependencies: {
+      [ctx.packageNames.contract]: "workspace:*",
+      "@emeryld/rrroutes-client": "^2.5.3",
+      "@tanstack/react-query": "^5.90.12",
+      react: "^18.3.1",
+      "react-dom": "^18.3.1",
+      "socket.io-client": "^4.8.3",
+      zod: "^4.2.1"
+    },
+    devDependencies: {
+      "@types/react": "^18.3.27",
+      "@types/react-dom": "^18.3.7",
+      "@vitejs/plugin-react": "^4.3.4",
+      typescript: "^5.9.3",
+      vite: "^6.4.1"
+    }
+  };
+  const files = {
+    "package.json": `${JSON.stringify(pkgJson, null, 2)}
+`,
+    "tsconfig.json": `${JSON.stringify(baseTsConfig(), null, 2)}
+`,
+    "vite.config.ts": viteConfig(),
+    "src/main.tsx": MAIN_TSX,
+    "src/App.tsx": appTsx(),
+    "src/lib/queryClient.ts": queryClient(ctx.packageNames.contract),
+    "src/lib/socket.tsx": socketProvider(ctx.packageNames.contract),
+    "src/pages/HealthPage.tsx": healthPage(ctx.packageNames.contract),
+    "src/styles.css": STYLES,
+    "src/env.d.ts": '/// <reference types="vite/client" />\n',
+    "index.html": indexHtml(),
+    ".env": CLIENT_ENV
+  };
+  for (const [name, contents] of Object.entries(files)) {
+    const fullPath = path2.join(baseDir, name);
+    const writer = name === ".env" ? writeFileForce : writeFileIfMissing;
+    const result = await writer(fullPath, contents);
+    const rel = path2.relative(ctx.rootDir, fullPath);
+    if (result === "created" || result === void 0) log.created(rel);
+    else log.skipped(rel);
+  }
+}
+async function scaffoldNativeClient(ctx) {
+  const baseDir = path2.join(ctx.rootDir, "packages", "client");
+  await ensureDir(path2.join(baseDir, "src", "screens"));
+  const pkgJson = nativePackageJson(
+    ctx.packageNames.client,
+    ctx.packageNames.contract
+  );
+  const files = {
+    "package.json": `${JSON.stringify(pkgJson, null, 2)}
+`,
+    "tsconfig.json": `${JSON.stringify(NATIVE_TS_CONFIG, null, 2)}
+`,
+    "app.json": `${JSON.stringify(nativeAppJson(ctx.appSlug), null, 2)}
+`,
+    "babel.config.js": NATIVE_BABEL,
+    "App.tsx": nativeAppTsx(),
+    "src/queryClient.ts": nativeQueryClient(ctx.packageNames.contract),
+    "src/socket.tsx": nativeSocket(ctx.packageNames.contract),
+    "src/screens/HealthScreen.tsx": nativeHealthScreen(
+      ctx.packageNames.contract
+    ),
+    ".env": NATIVE_ENV
+  };
+  for (const [name, contents] of Object.entries(files)) {
+    const fullPath = path2.join(baseDir, name);
+    const writer = name === ".env" ? writeFileForce : writeFileIfMissing;
+    const result = await writer(fullPath, contents);
+    const rel = path2.relative(ctx.rootDir, fullPath);
+    if (result === "created" || result === void 0) log.created(rel);
+    else log.skipped(rel);
+  }
+}
+
+// src/generators/contract.ts
+import path3 from "path";
+var CONTRACT_TS = `import { defineSocketEvents, finalize, resource } from '@emeryld/rrroutes-contract'
+import { z } from 'zod'
+
+const routes = resource('/api')
+  .sub(
+    resource('health')
+      .get({
+        outputSchema: z.object({
+          status: z.literal('ok'),
+          html: z.string().describe('Tiny HTML heartbeat'),
+        }),
+        description: 'Basic GET health probe for uptime + docs.',
+      })
+      .post({
+        bodySchema: z.object({
+          echo: z.string().optional(),
+        }),
+        outputSchema: z.object({
+          status: z.literal('ok'),
+          received: z.string().optional(),
+        }),
+        description: 'POST health probe that echoes a payload.',
+      })
+      .done(),
+  )
+  .done()
+
+export const registry = finalize(routes)
+
+const sockets = defineSocketEvents(
+  {
+    joinMetaMessage: z.object({ room: z.string().optional() }),
+    leaveMetaMessage: z.object({ room: z.string().optional() }),
+    pingPayload: z.object({
+      note: z.string().default('ping'),
+      sentAt: z.string(),
+    }),
+    pongPayload: z.object({
+      ok: z.literal(true),
+      receivedAt: z.string(),
+      echo: z.string().optional(),
+    }),
+  },
+  {
+    'health:connected': {
+      message: z.object({
+        socketId: z.string(),
+        at: z.string(),
+        message: z.string(),
+      }),
+    },
+    'health:ping': {
+      message: z.object({
+        note: z.string().default('ping'),
+      }),
+    },
+    'health:pong': {
+      message: z.object({
+        ok: z.literal(true),
+        at: z.string(),
+        echo: z.string().optional(),
+      }),
+    },
+  },
+)
+
+export const socketConfig = sockets.config
+export const socketEvents = sockets.events
+export type AppRegistry = typeof registry
+`;
+async function scaffoldContract(ctx) {
+  const baseDir = path3.join(ctx.rootDir, "packages", "contract");
+  await ensureDir(path3.join(baseDir, "src"));
+  const pkgJson = {
+    name: ctx.packageNames.contract,
+    version: "0.1.0",
+    private: false,
+    type: "module",
+    main: "dist/index.js",
+    types: "dist/index.d.ts",
+    files: ["dist"],
+    scripts: {
+      build: "tsc -p tsconfig.json",
+      typecheck: "tsc -p tsconfig.json --noEmit"
+    },
+    dependencies: {
+      "@emeryld/rrroutes-contract": "^2.5.2",
+      zod: "^4.2.1"
+    },
+    devDependencies: {
+      typescript: "^5.9.3"
+    }
+  };
+  const tsconfig = {
+    extends: "../../tsconfig.base.json",
+    compilerOptions: {
+      outDir: "dist",
+      rootDir: "src",
+      declaration: true,
+      sourceMap: true
+    },
+    include: ["src/**/*"]
+  };
+  const files = {
+    "package.json": `${JSON.stringify(pkgJson, null, 2)}
+`,
+    "tsconfig.json": `${JSON.stringify(tsconfig, null, 2)}
+`,
+    "src/index.ts": CONTRACT_TS
+  };
+  for (const [name, contents] of Object.entries(files)) {
+    const fullPath = path3.join(baseDir, name);
+    const result = await writeFileIfMissing(fullPath, contents);
+    if (result === "created") log.created(path3.relative(ctx.rootDir, fullPath));
+    else log.skipped(path3.relative(ctx.rootDir, fullPath));
+  }
+}
+
+// src/generators/root.ts
+import path4 from "path";
+function formatJson(obj) {
+  return `${JSON.stringify(obj, null, 2)}
+`;
+}
+async function scaffoldRoot(ctx) {
+  await ensureDir(ctx.rootDir);
+  const scripts = {
+    build: "npm run build --workspaces",
+    typecheck: "npm run typecheck --workspaces --if-present",
+    lint: "npm run lint --workspaces --if-present"
+  };
+  if (ctx.targets.server) {
+    scripts["dev:server"] = `npm run dev --workspace ${ctx.packageNames.server}`;
+  }
+  if (ctx.targets.client) {
+    scripts["dev:client"] = `npm run dev --workspace ${ctx.packageNames.client}`;
+  }
+  const highlights = ["- Shared contract package (RRRoutes registry + sockets)"];
+  if (ctx.targets.server) {
+    highlights.unshift(
+      "- Backend (Express + Socket.IO + RRRoutes server bindings)"
+    );
+  }
+  if (ctx.targets.client) {
+    highlights.splice(
+      ctx.targets.server ? 1 : 0,
+      0,
+      "- Frontend client (React or React Native) with React Query + sockets"
+    );
+  }
+  const quickstart = ["1) Install deps: `npm install` (workspaces)"];
+  if (ctx.targets.server) {
+    quickstart.push(
+      `${quickstart.length + 1}) Backend env: edit \`packages/server/.env\``
+    );
+  }
+  if (ctx.targets.client) {
+    quickstart.push(
+      `${quickstart.length + 1}) Client env: edit \`packages/client/.env\``
+    );
+  }
+  if (ctx.targets.server || ctx.targets.client) {
+    quickstart.push(
+      `${quickstart.length + 1}) Run dev servers:${ctx.targets.server ? `
+   - API: \`npm run dev:server\`` : ""}${ctx.targets.client ? `
+   - Client: \`npm run dev:client\`` : ""}`
+    );
+  }
+  const pkgJson = {
+    name: `${ctx.appSlug}-stack`,
+    private: true,
+    workspaces: ["packages/*"],
+    scripts,
+    devDependencies: {
+      typescript: "^5.9.3"
+    }
+  };
+  const files = {
+    "package.json": formatJson(pkgJson),
+    "pnpm-workspace.yaml": "packages:\n  - 'packages/*'\n",
+    "tsconfig.base.json": formatJson({
+      $schema: "https://json.schemastore.org/tsconfig",
+      compilerOptions: {
+        target: "ES2020",
+        module: "ESNext",
+        moduleResolution: "Bundler",
+        jsx: "react-jsx",
+        strict: true,
+        skipLibCheck: true,
+        resolveJsonModule: true,
+        forceConsistentCasingInFileNames: true,
+        sourceMap: true,
+        baseUrl: "."
+      }
+    }),
+    ".gitignore": [
+      "node_modules",
+      "dist",
+      ".turbo",
+      ".expo",
+      ".DS_Store",
+      ".env",
+      ".env.local",
+      "npm-debug.log*",
+      "yarn-error.log"
+    ].join("\n"),
+    README: [
+      `# ${ctx.projectName} (RRRoutes starter)`,
+      "",
+      "Generated via `create-rrroutes`. Includes:",
+      ...highlights,
+      "",
+      "## Quickstart",
+      ...quickstart,
+      "",
+      ctx.targets.server ? "Dockerfile for the API lives in `packages/server/Dockerfile`." : "",
+      ""
+    ].filter(Boolean).join("\n")
+  };
+  for (const [name, contents] of Object.entries(files)) {
+    const fullPath = path4.join(ctx.rootDir, name);
+    const result = await writeFileIfMissing(fullPath, contents);
+    if (result === "created") log.created(path4.relative(ctx.rootDir, fullPath));
+    else log.skipped(path4.relative(ctx.rootDir, fullPath));
+  }
+}
+
+// src/generators/server.ts
+import path5 from "path";
+function serverIndexTs() {
+  return `import 'dotenv/config'
+import http from 'node:http'
+import { app } from './http'
+import { createSockets } from './socket'
+import { prisma } from './prisma'
+
+async function main() {
+  const PORT = Number.parseInt(process.env.PORT ?? '4000', 10)
+  const CORS_ORIGIN = process.env.CORS_ORIGIN ?? 'http://localhost:5173'
+  const SOCKET_PATH = process.env.SOCKET_PATH ?? '/socket.io'
+
+  await prisma.$connect()
+
+  const httpServer = http.createServer(app)
+  const sockets = createSockets(httpServer, {
+    corsOrigin: CORS_ORIGIN,
+    socketPath: SOCKET_PATH,
+  })
+
+  httpServer.listen(PORT, () => {
+    console.log(
+      \`API listening on http://localhost:\${PORT} (CORS origin: \${CORS_ORIGIN})\`,
+    )
+  })
+
+  const shutdown = async () => {
+    await sockets.destroy()
+    await prisma.$disconnect()
+  }
+  process.on('SIGTERM', shutdown)
+  process.on('SIGINT', shutdown)
+}
+
+main().catch(async (err) => {
+  console.error(err)
+  await prisma.$disconnect().catch(() => {})
+  process.exit(1)
+})
+`;
+}
+function httpTs(contractImport) {
+  return `import express from 'express'
+import cors from 'cors'
+import { createRRRoute } from '@emeryld/rrroutes-server'
+import { registry } from '${contractImport}'
+import { controllers, type RequestCtx } from './controllers'
+import { prisma } from './prisma'
+
+const CORS_ORIGIN = process.env.CORS_ORIGIN ?? 'http://localhost:5173'
+
+export const app = express()
+app.use(cors({ origin: CORS_ORIGIN, credentials: true }))
+app.use(express.json())
+
+app.get('/', (_req, res) => {
+  res.send('<h1>RRRoutes starter API</h1>')
+})
+
+const routes = createRRRoute<RequestCtx>(app, {
+  buildCtx: async () => ({
+    requestId: Math.random().toString(36).slice(2),
+    prisma,
+    routesLogger: console,
+  }),
+  debug:
+    process.env.NODE_ENV === 'development'
+      ? { request: true, handler: true }
+      : undefined,
+})
+
+routes.registerControllers(registry, controllers)
+routes.warnMissingControllers(registry, console)
+export { routes }
+`;
+}
+function controllersTs(contractImport) {
+  return `import { defineControllers } from '@emeryld/rrroutes-server'
+import type { PrismaClient } from '@prisma/client'
+import { registry } from '${contractImport}'
+
+export type RequestCtx = {
+  prisma: PrismaClient
+  requestId: string
+}
+
+export const controllers = defineControllers<typeof registry, RequestCtx>()({
+  'GET /api/health': {
+    handler: async ({ ctx }) => {
+      await ctx.prisma.healthCheck.create({
+        data: { note: 'GET health' },
+      })
+      return {
+        status: 'ok',
+        html: '<!doctype html><html><body><h1>healthy</h1></body></html>',
+      }
+    },
+  },
+  'POST /api/health': {
+    handler: async ({ ctx, body }) => {
+      await ctx.prisma.healthCheck.create({
+        data: { note: body?.echo ?? 'POST health' },
+      })
+      return {
+        status: 'ok',
+        received: body?.echo ?? 'pong',
+      }
+    },
+  },
+})
+`;
+}
+function socketTs(contractImport) {
+  return `import { Server as SocketIOServer } from 'socket.io'
+import type { Server } from 'node:http'
+import { createSocketConnections } from '@emeryld/rrroutes-server'
+import { socketConfig, socketEvents } from '${contractImport}'
+
+export function createSockets(
+  httpServer: Server,
+  opts: { corsOrigin: string; socketPath: string },
+) {
+  const io = new SocketIOServer(httpServer, {
+    cors: { origin: opts.corsOrigin, credentials: true },
+    path: opts.socketPath,
+  })
+
+  const sockets = createSocketConnections(io, socketEvents, {
+    config: socketConfig,
+    heartbeat: { enabled: true },
+    sys: {
+      'sys:connect': async ({ socket, helper, complete }) => {
+        helper.emit('health:connected', {
+          socketId: socket.id,
+          at: new Date().toISOString(),
+          message: 'connected',
+        })
+        complete()
+      },
+      'sys:disconnect': async ({ cleanup }) => cleanup(),
+      'sys:ping': async ({ ping }) => ({
+        ok: true,
+        receivedAt: new Date().toISOString(),
+        echo: ping.note,
+      }),
+      'sys:room_join': async ({ rooms, join }) => {
+        await Promise.all(rooms.map((room) => join(room)))
+      },
+      'sys:room_leave': async ({ rooms, leave }) => {
+        await Promise.all(rooms.map((room) => leave(room)))
+      },
+    },
+  })
+
+  sockets.on('health:ping', async (payload, ctx) => {
+    sockets.emit(
+      'health:pong',
+      { ok: true, at: new Date().toISOString(), echo: payload.note },
+      ctx.socketId,
+    )
+  })
+
+  return sockets
+}
+`;
+}
+function prismaTs() {
+  return `import { PrismaClient } from '@prisma/client'
+
+export const prisma = new PrismaClient({
+  log: ['warn', 'error'],
+})
+`;
+}
+function prismaSchema() {
+  return `generator client {
+  provider = "prisma-client-js"
+}
+
+datasource db {
+  provider = "postgresql"
+  url      = env("DATABASE_URL")
+}
+
+model HealthCheck {
+  id        String   @id @default(uuid())
+  note      String?
+  createdAt DateTime @default(now())
+}
+`;
+}
+function serverEnv() {
+  return [
+    "PORT=4000",
+    "NODE_ENV=development",
+    "CORS_ORIGIN=http://localhost:5173",
+    "SOCKET_PATH=/socket.io",
+    "DATABASE_URL=postgresql://postgres:postgres@localhost:5432/rrroutes"
+  ].join("\n");
+}
+function dockerfile(serverName, contractName) {
+  return `FROM node:20-alpine
+WORKDIR /app
+
+# Install workspace deps (hoists to /app/node_modules)
+COPY package.json pnpm-workspace.yaml tsconfig.base.json ./
+COPY packages/contract/package.json packages/contract/package.json
+COPY packages/server/package.json packages/server/package.json
+COPY packages/server/prisma/schema.prisma packages/server/prisma/schema.prisma
+RUN npm install
+
+# Copy source and build server + contract
+COPY packages ./packages
+
+# Generate Prisma client
+RUN npx prisma generate --schema packages/server/prisma/schema.prisma
+
+RUN npm run build --workspace ${contractName} && npm run build --workspace ${serverName}
+
+EXPOSE 4000
+CMD ["node", "packages/server/dist/index.js"]
+`;
+}
+async function scaffoldServer(ctx) {
+  const baseDir = path5.join(ctx.rootDir, "packages", "server");
+  await ensureDir(path5.join(baseDir, "src"));
+  await ensureDir(path5.join(baseDir, "prisma"));
+  const pkgJson = {
+    name: ctx.packageNames.server,
+    version: "0.1.0",
+    private: false,
+    type: "module",
+    main: "dist/index.js",
+    types: "dist/index.d.ts",
+    files: ["dist"],
+    scripts: {
+      dev: "ts-node --esm src/index.ts",
+      build: "tsc -p tsconfig.json",
+      typecheck: "tsc -p tsconfig.json --noEmit",
+      start: "node dist/index.js",
+      "prisma:generate": "prisma generate --schema prisma/schema.prisma",
+      "prisma:migrate": "prisma migrate dev --schema prisma/schema.prisma --name init"
+    },
+    dependencies: {
+      [ctx.packageNames.contract]: "workspace:*",
+      "@emeryld/rrroutes-server": "^2.4.1",
+      "@prisma/client": "^5.22.0",
+      "socket.io": "^4.8.1",
+      express: "^5.1.0",
+      cors: "^2.8.5",
+      dotenv: "^16.4.5",
+      zod: "^4.2.1"
+    },
+    devDependencies: {
+      "@types/express": "^5.0.6",
+      "@types/node": "^24.10.2",
+      prisma: "^5.22.0",
+      typescript: "^5.9.3",
+      "ts-node": "^10.9.2"
+    }
+  };
+  const tsconfig = {
+    extends: "../../tsconfig.base.json",
+    compilerOptions: {
+      outDir: "dist",
+      rootDir: "src",
+      declaration: true,
+      sourceMap: true
+    },
+    include: ["src/**/*"]
+  };
+  const files = {
+    "package.json": `${JSON.stringify(pkgJson, null, 2)}
+`,
+    "tsconfig.json": `${JSON.stringify(tsconfig, null, 2)}
+`,
+    "src/index.ts": serverIndexTs(),
+    "src/http.ts": httpTs(ctx.packageNames.contract),
+    "src/controllers.ts": controllersTs(ctx.packageNames.contract),
+    "src/socket.ts": socketTs(ctx.packageNames.contract),
+    "src/prisma.ts": prismaTs(),
+    "prisma/schema.prisma": prismaSchema(),
+    ".env": `${serverEnv()}
+`,
+    Dockerfile: dockerfile(ctx.packageNames.server, ctx.packageNames.contract)
+  };
+  for (const [name, contents] of Object.entries(files)) {
+    const fullPath = path5.join(baseDir, name);
+    const writer = name === ".env" ? writeFileForce : writeFileIfMissing;
+    const result = await writer(fullPath, contents);
+    const rel = path5.relative(ctx.rootDir, fullPath);
+    if (result === "created" || result === void 0) log.created(rel);
+    else log.skipped(rel);
+  }
+}
+
+// src/utils/prompt.ts
+import { createInterface } from "readline/promises";
+import { stdin as input, stdout as output } from "process";
+function createPrompt() {
+  const rl = createInterface({ input, output });
+  return {
+    async text(message, fallback) {
+      const suffix = fallback ? ` (${fallback})` : "";
+      const answer = (await rl.question(`${message}${suffix}: `)).trim();
+      return answer.length > 0 ? answer : fallback;
+    },
+    async confirm(message, fallback = true) {
+      const suffix = fallback ? " (Y/n)" : " (y/N)";
+      const answer = (await rl.question(`${message}${suffix}: `)).trim();
+      if (!answer) return fallback;
+      return ["y", "yes"].includes(answer.toLowerCase());
+    },
+    async select(message, options, fallbackIndex = 0) {
+      console.log(message);
+      options.forEach(
+        (opt, idx2) => console.log(`  [${idx2 + 1}] ${opt.label}`)
+      );
+      const answer = (await rl.question(`Choose 1-${options.length}: `)).trim();
+      const idx = Number.parseInt(answer, 10);
+      const normalized = Number.isNaN(idx) || idx < 1 || idx > options.length ? fallbackIndex : idx - 1;
+      return options[normalized].value;
+    },
+    close() {
+      rl.close();
+    }
+  };
+}
+
+// src/utils/strings.ts
+function slugify(input2, fallback = "rrroutes-app") {
+  const slug = input2.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  return slug.length > 0 ? slug : fallback;
+}
+
+// src/index.ts
+function resolveTargets(choice) {
+  if (choice === "all")
+    return { client: true, server: true, contract: true };
+  if (choice === "client")
+    return { client: true, server: false, contract: true };
+  if (choice === "server")
+    return { client: false, server: true, contract: true };
+  return { client: false, server: false, contract: true };
+}
+async function gatherContext() {
+  const prompt = createPrompt();
+  try {
+    const projectName = await prompt.text("Project name", "rrroutes-starter") ?? "rrroutes-starter";
+    const appSlug = slugify(projectName);
+    const targetDirInput = await prompt.text("Target directory", `./${appSlug}`) ?? `./${appSlug}`;
+    const rootDir = path6.resolve(process.cwd(), targetDirInput);
+    const scopeInput = await prompt.text("NPM scope (without @)", appSlug) ?? appSlug;
+    const packageScope = slugify(scopeInput);
+    const selection = await prompt.select("What should we create?", [
+      {
+        label: "Everything (contract + server + client)",
+        value: "all"
+      },
+      { label: "Contract only", value: "contract" },
+      { label: "Backend only", value: "server" },
+      { label: "Frontend only", value: "client" }
+    ]);
+    const targets = resolveTargets(selection);
+    let clientKind = "react";
+    if (targets.client) {
+      clientKind = await prompt.select(
+        "Frontend runtime",
+        [
+          { label: "React (web, Vite)", value: "react" },
+          { label: "React Native (Expo)", value: "react-native" }
+        ],
+        0
+      );
+    }
+    const packageNames = {
+      contract: `@${packageScope}/contract`,
+      server: `@${packageScope}/server`,
+      client: `@${packageScope}/client`
+    };
+    return {
+      projectName,
+      appSlug,
+      packageScope,
+      rootDir,
+      clientKind,
+      targets,
+      packageNames
+    };
+  } finally {
+    prompt.close();
+  }
+}
+async function main() {
+  const ctx = await gatherContext();
+  log.info(`Scaffolding RRRoutes starter in ${ctx.rootDir}`);
+  await scaffoldRoot(ctx);
+  if (ctx.targets.contract) await scaffoldContract(ctx);
+  if (ctx.targets.server) await scaffoldServer(ctx);
+  if (ctx.targets.client) await scaffoldClient(ctx);
+  log.info("Done. Install dependencies and start hacking!");
+}
+main().catch((err) => {
+  log.error(err instanceof Error ? err.message : String(err));
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map