create-frootjs 0.0.0-stage → 1.0.1

package/dist/templates/mvc.js

@@ -0,0 +1,239 @@
+/**
+ * MVC / Layered Architecture Template
+ * Organizes code by layer: Routes -> Controllers -> Services -> Models.
+ */
+import { COMMON_GITIGNORE, COMMON_TSCONFIG } from './types.js';
+export const mvcTemplate = {
+    id: 'mvc',
+    name: 'MVC / Layered Architecture',
+    description: 'Structured enterprise layout: routes, controllers, services, and models',
+    generate: (projectName) => {
+        return {
+            'package.json': JSON.stringify({
+                name: projectName,
+                version: '1.0.0',
+                type: 'module',
+                scripts: {
+                    dev: 'node --experimental-strip-types src/server.ts',
+                    build: 'tsc',
+                    start: 'node dist/server.js',
+                    test: 'node --test tests/*.test.ts',
+                },
+                dependencies: {
+                    frootjs: '^1.0.1',
+                },
+                devDependencies: {
+                    '@types/node': '^22.10.0',
+                    typescript: '^5.8.0',
+                },
+            }, null, 2) + '\n',
+            'tsconfig.json': COMMON_TSCONFIG,
+            '.gitignore': COMMON_GITIGNORE,
+            'README.md': `# ${projectName}
+
+Froot application built with the **MVC / Layered Architecture** pattern.
+
+## Directory Structure
+
+\`\`\`
+src/
+├── controllers/    # Request handlers & HTTP response formatting
+│   ├── health.controller.ts
+│   └── user.controller.ts
+├── services/       # Core business logic & database interaction
+│   └── user.service.ts
+├── models/         # TypeScript interfaces & domain types
+│   └── user.model.ts
+├── routes/         # Froot route definitions & sub-app mounting
+│   ├── health.routes.ts
+│   ├── user.routes.ts
+│   └── index.ts
+├── middleware/     # Custom onion middleware
+│   └── request-logger.ts
+├── app.ts          # Application assembly
+└── server.ts       # Server entry point
+\`\`\`
+
+## Getting Started
+
+\`\`\`bash
+# 1. Install dependencies
+pnpm install
+
+# 2. Run in development mode
+pnpm run dev
+
+# 3. Build for production
+pnpm run build
+pnpm start
+\`\`\`
+`,
+            'src/models/user.model.ts': `export interface User {
+  id: string;
+  name: string;
+  email: string;
+  role: 'admin' | 'user' | 'guest';
+  createdAt: string;
+}
+
+export interface CreateUserInput {
+  name: string;
+  email: string;
+  role?: 'admin' | 'user' | 'guest';
+}
+`,
+            'src/services/user.service.ts': `import type { User, CreateUserInput } from '../models/user.model.js';
+
+// In-memory mock database
+const usersTable = new Map<string, User>([
+  ['usr_1', { id: 'usr_1', name: 'Alice Smith', email: 'alice@example.com', role: 'admin', createdAt: new Date().toISOString() }],
+  ['usr_2', { id: 'usr_2', name: 'Bob Jones', email: 'bob@example.com', role: 'user', createdAt: new Date().toISOString() }],
+]);
+
+export class UserService {
+  static async findAll(): Promise<User[]> {
+    return Array.from(usersTable.values());
+  }
+
+  static async findById(id: string): Promise<User | null> {
+    return usersTable.get(id) ?? null;
+  }
+
+  static async create(input: CreateUserInput): Promise<User> {
+    const id = 'usr_' + Math.random().toString(36).substring(2, 9);
+    const user: User = {
+      id,
+      name: input.name,
+      email: input.email,
+      role: input.role ?? 'user',
+      createdAt: new Date().toISOString(),
+    };
+    usersTable.set(id, user);
+    return user;
+  }
+
+  static async delete(id: string): Promise<boolean> {
+    return usersTable.delete(id);
+  }
+}
+`,
+            'src/controllers/health.controller.ts': `import type { Context } from 'frootjs';
+
+export class HealthController {
+  static getHealth(c: Context) {
+    return c.json({
+      status: 'ok',
+      uptime: process.uptime(),
+      timestamp: new Date().toISOString(),
+    });
+  }
+}
+`,
+            'src/controllers/user.controller.ts': `import type { Context } from 'frootjs';
+import { UserService } from '../services/user.service.js';
+import type { CreateUserInput } from '../models/user.model.js';
+
+export class UserController {
+  static async list(c: Context) {
+    const users = await UserService.findAll();
+    return c.json(users);
+  }
+
+  static async getById(c: Context) {
+    const id = c.req.param('id');
+    const user = await UserService.findById(id);
+    if (!user) {
+      return c.json({ error: 'User not found' }, 404);
+    }
+    return c.json(user);
+  }
+
+  static async create(c: Context) {
+    const body = await c.req.json<CreateUserInput>();
+    if (!body.name || !body.email) {
+      return c.json({ error: 'Name and email are required' }, 400);
+    }
+    const user = await UserService.create(body);
+    return c.json(user, 201);
+  }
+
+  static async remove(c: Context) {
+    const id = c.req.param('id');
+    const ok = await UserService.delete(id);
+    if (!ok) {
+      return c.json({ error: 'User not found' }, 404);
+    }
+    return c.json({ success: true, message: 'User deleted' });
+  }
+}
+`,
+            'src/routes/health.routes.ts': `import { Froot } from 'frootjs';
+import { HealthController } from '../controllers/health.controller.js';
+
+export const healthRoutes = new Froot();
+
+healthRoutes.get('/health', HealthController.getHealth);
+`,
+            'src/routes/user.routes.ts': `import { Froot } from 'frootjs';
+import { UserController } from '../controllers/user.controller.js';
+
+export const userRoutes = new Froot();
+
+userRoutes.get('/users', UserController.list);
+userRoutes.get('/users/:id', UserController.getById);
+userRoutes.post('/users', UserController.create);
+userRoutes.delete('/users/:id', UserController.remove);
+`,
+            'src/routes/index.ts': `import { Froot } from 'frootjs';
+import { healthRoutes } from './health.routes.js';
+import { userRoutes } from './user.routes.js';
+
+export const apiRoutes = new Froot();
+
+// Mount sub-apps
+apiRoutes.route('/api', healthRoutes);
+apiRoutes.route('/api', userRoutes);
+`,
+            'src/middleware/request-logger.ts': `import type { MiddlewareHandler } from 'frootjs';
+
+export const requestLogger: MiddlewareHandler = async (c, next) => {
+  const start = performance.now();
+  await next();
+  const duration = (performance.now() - start).toFixed(2);
+  console.log(\`[\${c.req.method}] \${c.req.path} - \${c.statusCode} (\${duration}ms)\`);
+};
+`,
+            'src/app.ts': `import { Froot } from 'frootjs';
+import { cors } from 'frootjs/cors';
+import { requestLogger } from './middleware/request-logger.js';
+import { apiRoutes } from './routes/index.js';
+
+export const app = new Froot();
+
+// Global middleware
+app.use(cors());
+app.use(requestLogger);
+
+// Mount API routes
+app.route('', apiRoutes);
+
+// Root route
+app.get('/', (c) => {
+  return c.json({
+    message: 'Welcome to Froot MVC API',
+    docs: '/api/health',
+  });
+});
+`,
+            'src/server.ts': `import { app } from './app.js';
+
+const PORT = Number(process.env.PORT) || 3000;
+
+app.listen(PORT, () => {
+  console.log(\`Server is running on http://localhost:\${PORT}\`);
+});
+`,
+        };
+    },
+};
+//# sourceMappingURL=mvc.js.map

package/dist/templates/mvc.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mvc.js","sourceRoot":"","sources":["../../src/templates/mvc.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAuC,gBAAgB,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAEpG,MAAM,CAAC,MAAM,WAAW,GAAuB;IAC7C,EAAE,EAAE,KAAK;IACT,IAAI,EAAE,4BAA4B;IAClC,WAAW,EAAE,yEAAyE;IACtF,QAAQ,EAAE,CAAC,WAAmB,EAAmB,EAAE;QACjD,OAAO;YACL,cAAc,EAAE,IAAI,CAAC,SAAS,CAC5B;gBACE,IAAI,EAAE,WAAW;gBACjB,OAAO,EAAE,OAAO;gBAChB,IAAI,EAAE,QAAQ;gBACd,OAAO,EAAE;oBACP,GAAG,EAAE,+CAA+C;oBACpD,KAAK,EAAE,KAAK;oBACZ,KAAK,EAAE,qBAAqB;oBAC5B,IAAI,EAAE,6BAA6B;iBACpC;gBACD,YAAY,EAAE;oBACZ,OAAO,EAAE,QAAQ;iBAClB;gBACD,eAAe,EAAE;oBACf,aAAa,EAAE,UAAU;oBACzB,UAAU,EAAE,QAAQ;iBACrB;aACF,EACD,IAAI,EACJ,CAAC,CACF,GAAG,IAAI;YAER,eAAe,EAAE,eAAe;YAChC,YAAY,EAAE,gBAAgB;YAE9B,WAAW,EAAE,KAAK,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsClC;YAEK,0BAA0B,EAAE;;;;;;;;;;;;;CAajC;YAEK,8BAA8B,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkCrC;YAEK,sCAAsC,EAAE;;;;;;;;;;;CAW7C;YAEK,oCAAoC,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqC3C;YAEK,6BAA6B,EAAE;;;;;;CAMpC;YAEK,2BAA2B,EAAE;;;;;;;;;CASlC;YAEK,qBAAqB,EAAE;;;;;;;;;CAS5B;YAEK,kCAAkC,EAAE;;;;;;;;CAQzC;YAEK,YAAY,EAAE;;;;;;;;;;;;;;;;;;;;;CAqBnB;YAEK,eAAe,EAAE;;;;;;;CAOtB;SACI,CAAC;IACJ,CAAC;CACF,CAAC"}

package/dist/templates/openapi.d.ts

@@ -0,0 +1,7 @@
+/**
+ * OpenAPI 3.1 & Scalar Docs Template
+ * Self-documenting REST API with schema validation, OpenAPI 3.1 JSON, and Scalar interactive UI.
+ */
+import { TemplateDefinition } from './types.js';
+export declare const openapiTemplate: TemplateDefinition;
+//# sourceMappingURL=openapi.d.ts.map

package/dist/templates/openapi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openapi.d.ts","sourceRoot":"","sources":["../../src/templates/openapi.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,kBAAkB,EAAsD,MAAM,YAAY,CAAC;AAEpG,eAAO,MAAM,eAAe,EAAE,kBAgN7B,CAAC"}

package/dist/templates/openapi.js

@@ -0,0 +1,206 @@
+/**
+ * OpenAPI 3.1 & Scalar Docs Template
+ * Self-documenting REST API with schema validation, OpenAPI 3.1 JSON, and Scalar interactive UI.
+ */
+import { COMMON_GITIGNORE, COMMON_TSCONFIG } from './types.js';
+export const openapiTemplate = {
+    id: 'openapi',
+    name: 'OpenAPI 3.1 & Interactive Docs',
+    description: 'Self-documenting REST API with auto-generated OpenAPI 3.1 spec & Scalar reference UI',
+    generate: (projectName) => {
+        return {
+            'package.json': JSON.stringify({
+                name: projectName,
+                version: '1.0.0',
+                type: 'module',
+                scripts: {
+                    dev: 'node --experimental-strip-types src/server.ts',
+                    build: 'tsc',
+                    start: 'node dist/server.js',
+                    test: 'node --test tests/*.test.ts',
+                },
+                dependencies: {
+                    frootjs: '^1.0.1',
+                },
+                devDependencies: {
+                    '@types/node': '^22.10.0',
+                    typescript: '^5.8.0',
+                },
+            }, null, 2) + '\n',
+            'tsconfig.json': COMMON_TSCONFIG,
+            '.gitignore': COMMON_GITIGNORE,
+            'README.md': `# ${projectName}
+
+Froot application built with the **OpenAPI 3.1 & Interactive Docs** pattern.
+
+## Features
+
+- **Automatic OpenAPI 3.1 Spec**: Machine-readable spec available at \`/openapi.json\`
+- **Scalar Interactive UI**: Modern, high-performance API reference documentation at \`/docs\`
+- **Typed Schema Contracts**: Schemas defined inline with routes, supporting JSON Schema, Standard Schema v1, and Zod
+
+## Getting Started
+
+\`\`\`bash
+# 1. Install dependencies
+pnpm install
+
+# 2. Run in development mode
+pnpm run dev
+
+# 3. Explore Interactive Docs
+http://localhost:3000/docs
+\`\`\`
+`,
+            'src/schemas.ts': `export const TaskSchema = {
+  type: 'object',
+  properties: {
+    id: { type: 'string', description: 'Unique task identifier' },
+    title: { type: 'string', description: 'Task title' },
+    completed: { type: 'boolean', description: 'Completion status' },
+    createdAt: { type: 'string', format: 'date-time' },
+  },
+  required: ['id', 'title', 'completed', 'createdAt'],
+};
+
+export const CreateTaskInputSchema = {
+  type: 'object',
+  properties: {
+    title: { type: 'string', description: 'Title of the new task' },
+  },
+  required: ['title'],
+};
+
+export const ErrorResponseSchema = {
+  type: 'object',
+  properties: {
+    error: { type: 'string', description: 'Error message' },
+  },
+  required: ['error'],
+};
+`,
+            'src/routes/tasks.ts': `import { Froot } from 'frootjs';
+import { TaskSchema, CreateTaskInputSchema, ErrorResponseSchema } from '../schemas.js';
+
+export interface Task {
+  id: string;
+  title: string;
+  completed: boolean;
+  createdAt: string;
+}
+
+const tasks: Task[] = [
+  { id: 'task_1', title: 'Spin up Froot project', completed: true, createdAt: new Date().toISOString() },
+  { id: 'task_2', title: 'Explore Scalar documentation at /docs', completed: false, createdAt: new Date().toISOString() },
+];
+
+export const taskRoutes = new Froot();
+
+// List tasks
+taskRoutes.get(
+  '/tasks',
+  {
+    summary: 'List all tasks',
+    description: 'Retrieves the complete list of scheduled tasks.',
+    tags: ['Tasks'],
+    operationId: 'listTasks',
+    response: {
+      type: 'array',
+      items: TaskSchema,
+    },
+  },
+  (c) => c.json(tasks)
+);
+
+// Get task by ID
+taskRoutes.get(
+  '/tasks/:id',
+  {
+    summary: 'Get task by ID',
+    tags: ['Tasks'],
+    operationId: 'getTaskById',
+    params: {
+      type: 'object',
+      properties: {
+        id: { type: 'string', description: 'Task ID' },
+      },
+      required: ['id'],
+    },
+    response: TaskSchema,
+    errors: {
+      404: ErrorResponseSchema,
+    },
+  },
+  (c) => {
+    const id = c.req.param('id');
+    const task = tasks.find((t) => t.id === id);
+    if (!task) {
+      return c.json({ error: 'Task not found' }, 404);
+    }
+    return c.json(task);
+  }
+);
+
+// Create task
+taskRoutes.post(
+  '/tasks',
+  {
+    summary: 'Create a new task',
+    tags: ['Tasks'],
+    operationId: 'createTask',
+    body: CreateTaskInputSchema,
+    response: TaskSchema,
+    errors: {
+      400: ErrorResponseSchema,
+    },
+  },
+  async (c) => {
+    const body = await c.req.json<{ title?: string }>();
+    if (!body.title) {
+      return c.json({ error: 'Title is required' }, 400);
+    }
+    const newTask: Task = {
+      id: 'task_' + Math.random().toString(36).substring(2, 9),
+      title: body.title,
+      completed: false,
+      createdAt: new Date().toISOString(),
+    };
+    tasks.push(newTask);
+    return c.json(newTask, 201);
+  }
+);
+`,
+            'src/server.ts': `import { Froot } from 'frootjs';
+import { cors } from 'frootjs/cors';
+import { taskRoutes } from './routes/tasks.js';
+
+export const app = new Froot();
+
+app.use(cors());
+
+// Mount sub-routes
+app.route('/api', taskRoutes);
+
+// Root redirect to /docs
+app.get('/', (c) => {
+  return c.redirect('/docs');
+});
+
+// Auto-mount OpenAPI 3.1 specification (/openapi.json) and Scalar UI (/docs)
+app.openapi({
+  title: '${projectName} API',
+  version: '1.0.0',
+  description: 'Self-documenting API powered by Froot OpenAPI 3.1 & Scalar Reference UI.',
+});
+
+const PORT = Number(process.env.PORT) || 3000;
+app.listen(PORT, () => {
+  console.log(\`Server running on http://localhost:\${PORT}\`);
+  console.log(\`Interactive Docs available at http://localhost:\${PORT}/docs\`);
+  console.log(\`OpenAPI JSON available at http://localhost:\${PORT}/openapi.json\`);
+});
+`,
+        };
+    },
+};
+//# sourceMappingURL=openapi.js.map

package/dist/templates/openapi.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"openapi.js","sourceRoot":"","sources":["../../src/templates/openapi.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAuC,gBAAgB,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAEpG,MAAM,CAAC,MAAM,eAAe,GAAuB;IACjD,EAAE,EAAE,SAAS;IACb,IAAI,EAAE,gCAAgC;IACtC,WAAW,EAAE,sFAAsF;IACnG,QAAQ,EAAE,CAAC,WAAmB,EAAmB,EAAE;QACjD,OAAO;YACL,cAAc,EAAE,IAAI,CAAC,SAAS,CAC5B;gBACE,IAAI,EAAE,WAAW;gBACjB,OAAO,EAAE,OAAO;gBAChB,IAAI,EAAE,QAAQ;gBACd,OAAO,EAAE;oBACP,GAAG,EAAE,+CAA+C;oBACpD,KAAK,EAAE,KAAK;oBACZ,KAAK,EAAE,qBAAqB;oBAC5B,IAAI,EAAE,6BAA6B;iBACpC;gBACD,YAAY,EAAE;oBACZ,OAAO,EAAE,QAAQ;iBAClB;gBACD,eAAe,EAAE;oBACf,aAAa,EAAE,UAAU;oBACzB,UAAU,EAAE,QAAQ;iBACrB;aACF,EACD,IAAI,EACJ,CAAC,CACF,GAAG,IAAI;YAER,eAAe,EAAE,eAAe;YAChC,YAAY,EAAE,gBAAgB;YAE9B,WAAW,EAAE,KAAK,WAAW;;;;;;;;;;;;;;;;;;;;;;CAsBlC;YAEK,gBAAgB,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;CA0BvB;YAEK,qBAAqB,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0F5B;YAEK,eAAe,EAAE;;;;;;;;;;;;;;;;;;YAkBX,WAAW;;;;;;;;;;;CAWtB;SACI,CAAC;IACJ,CAAC;CACF,CAAC"}

package/dist/templates/streaming.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Streaming & Server-Sent Events (SSE) Template
+ * Demonstrates real-time SSE streaming, LLM-style token streaming, and an interactive HTML live client.
+ */
+import { TemplateDefinition } from './types.js';
+export declare const streamingTemplate: TemplateDefinition;
+//# sourceMappingURL=streaming.d.ts.map

package/dist/templates/streaming.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"streaming.d.ts","sourceRoot":"","sources":["../../src/templates/streaming.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,kBAAkB,EAAsD,MAAM,YAAY,CAAC;AAEpG,eAAO,MAAM,iBAAiB,EAAE,kBAmN/B,CAAC"}

package/dist/templates/streaming.js

@@ -0,0 +1,211 @@
+/**
+ * Streaming & Server-Sent Events (SSE) Template
+ * Demonstrates real-time SSE streaming, LLM-style token streaming, and an interactive HTML live client.
+ */
+import { COMMON_GITIGNORE, COMMON_TSCONFIG } from './types.js';
+export const streamingTemplate = {
+    id: 'streaming',
+    name: 'Real-Time Streaming & SSE',
+    description: 'Server-Sent Events, AI token streaming simulation, and interactive web dashboard',
+    generate: (projectName) => {
+        return {
+            'package.json': JSON.stringify({
+                name: projectName,
+                version: '1.0.0',
+                type: 'module',
+                scripts: {
+                    dev: 'node --experimental-strip-types src/server.ts',
+                    build: 'tsc',
+                    start: 'node dist/server.js',
+                },
+                dependencies: {
+                    frootjs: '^1.0.1',
+                },
+                devDependencies: {
+                    '@types/node': '^22.10.0',
+                    typescript: '^5.8.0',
+                },
+            }, null, 2) + '\n',
+            'tsconfig.json': COMMON_TSCONFIG,
+            '.gitignore': COMMON_GITIGNORE,
+            'README.md': `# ${projectName}
+
+Froot application built with the **Real-Time Streaming & Server-Sent Events (SSE)** pattern.
+
+## Features
+
+- **SSE Telemetry Channel**: Streams real-time metrics (CPU memory, active requests) using \`streamSSE\`
+- **AI Token Streamer**: Demonstrates streaming LLM-style markdown tokens chunk-by-chunk using \`streamText\`
+- **Live Interactive Dashboard**: Embedded web client displaying real-time graphs and live chat stream
+
+## Getting Started
+
+\`\`\`bash
+# 1. Install dependencies
+pnpm install
+
+# 2. Run in development mode
+pnpm run dev
+
+# 3. Open in browser
+http://localhost:3000
+\`\`\`
+`,
+            'src/server.ts': `import { Froot } from 'frootjs';
+import { cors } from 'frootjs/cors';
+import { streamSSE, streamText, sleep } from 'frootjs/streaming';
+
+export const app = new Froot();
+
+app.use(cors());
+
+// Embedded Dashboard HTML
+app.get('/', (c) => {
+  return c.html(\`<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Froot Streaming Demo</title>
+  <style>
+    * { box-sizing: border-box; margin: 0; padding: 0; }
+    body { font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif; background: #0f172a; color: #f8fafc; padding: 2rem; }
+    .container { max-width: 800px; margin: 0 auto; display: flex; flex-direction: column; gap: 1.5rem; }
+    .card { background: #1e293b; border: 1px solid #334155; border-radius: 8px; padding: 1.5rem; }
+    h1 { color: #10b981; font-size: 1.75rem; margin-bottom: 0.5rem; }
+    h2 { font-size: 1.25rem; margin-bottom: 1rem; color: #38bdf8; }
+    pre { background: #0b0f19; padding: 1rem; border-radius: 6px; overflow-x: auto; font-size: 0.9rem; line-height: 1.4; }
+    .metrics { display: grid; grid-template-columns: repeat(3, 1fr); gap: 1rem; margin-bottom: 1rem; }
+    .metric-box { background: #0b0f19; padding: 1rem; border-radius: 6px; text-align: center; }
+    .metric-value { font-size: 1.5rem; font-weight: bold; color: #10b981; }
+    .metric-label { font-size: 0.8rem; color: #94a3b8; text-transform: uppercase; margin-top: 0.25rem; }
+    button { background: #10b981; color: #0f172a; border: none; padding: 0.6rem 1.2rem; border-radius: 6px; font-weight: bold; cursor: pointer; }
+    button:hover { background: #059669; }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <div>
+      <h1>Froot Streaming Engine</h1>
+      <p style="color: #94a3b8;">High-throughput Server-Sent Events & chunked HTTP streaming</p>
+    </div>
+
+    <!-- SSE Metrics Card -->
+    <div class="card">
+      <h2>Live Telemetry Stream (SSE)</h2>
+      <div class="metrics">
+        <div class="metric-box">
+          <div id="m-memory" class="metric-value">--</div>
+          <div class="metric-label">Memory (MB)</div>
+        </div>
+        <div class="metric-box">
+          <div id="m-uptime" class="metric-value">--</div>
+          <div class="metric-label">Uptime (s)</div>
+        </div>
+        <div class="metric-box">
+          <div id="m-count" class="metric-value">0</div>
+          <div class="metric-label">Events Received</div>
+        </div>
+      </div>
+      <pre id="sse-log">Connecting to /sse/metrics...</pre>
+    </div>
+
+    <!-- LLM Stream Card -->
+    <div class="card">
+      <h2>AI Token Stream Simulation</h2>
+      <div style="margin-bottom: 1rem;">
+        <button id="btn-stream">Generate Streaming Text</button>
+      </div>
+      <pre id="stream-output">Click button to trigger token-by-token stream...</pre>
+    </div>
+  </div>
+
+  <script>
+    // SSE Stream
+    let count = 0;
+    const es = new EventSource('/sse/metrics');
+    const log = document.getElementById('sse-log');
+    es.addEventListener('telemetry', (e) => {
+      const data = JSON.parse(e.data);
+      count++;
+      document.getElementById('m-memory').textContent = data.memoryUsageMB;
+      document.getElementById('m-uptime').textContent = data.uptimeSec;
+      document.getElementById('m-count').textContent = count;
+      log.textContent = 'Last event: ' + JSON.stringify(data, null, 2);
+    });
+
+    // Token Stream
+    const btn = document.getElementById('btn-stream');
+    const output = document.getElementById('stream-output');
+    btn.addEventListener('click', async () => {
+      btn.disabled = true;
+      output.textContent = '';
+      const response = await fetch('/api/chat/stream');
+      const reader = response.body.getReader();
+      const decoder = new TextDecoder();
+      while (true) {
+        const { value, done } = await reader.read();
+        if (done) break;
+        output.textContent += decoder.decode(value);
+      }
+      btn.disabled = false;
+    });
+  </script>
+</body>
+</html>\`);
+});
+
+// Real-time SSE Telemetry endpoint
+app.get('/sse/metrics', (c) => {
+  return streamSSE(
+    c,
+    async (stream) => {
+      let eventId = 1;
+      while (!stream.signal.aborted) {
+        const mem = process.memoryUsage();
+        const payload = {
+          memoryUsageMB: Math.round(mem.rss / 1024 / 1024),
+          uptimeSec: Math.floor(process.uptime()),
+          timestamp: new Date().toISOString(),
+        };
+
+        await stream.writeSSE({
+          event: 'telemetry',
+          id: String(eventId++),
+          data: JSON.stringify(payload),
+        });
+
+        await sleep(1000, stream.signal);
+      }
+    },
+    { heartbeatMs: 15_000 }
+  );
+});
+
+// AI Token Streaming Simulation endpoint
+app.get('/api/chat/stream', (c) => {
+  const sampleResponse = [
+    'Hello! ', 'I ', 'am ', 'streaming ', 'from ', 'a ', 'Froot ', 'server. ',
+    'Each ', 'token ', 'is ', 'dispatched ', 'with ', 'zero-copy ', 'efficiency.\\n\\n',
+    'Froot ', 'supports ', 'standards-compliant ', 'WHATWG ', 'ReadableStream ',
+    'pipelines ', 'compatible ', 'with ', 'all ', 'modern ', 'edge ', 'runtimes.',
+  ];
+
+  return streamText(c, async (stream) => {
+    for (const chunk of sampleResponse) {
+      if (stream.signal.aborted) break;
+      await stream.write(chunk);
+      await sleep(60, stream.signal);
+    }
+  });
+});
+
+const PORT = Number(process.env.PORT) || 3000;
+app.listen(PORT, () => {
+  console.log(\`Streaming server running on http://localhost:\${PORT}\`);
+});
+`,
+        };
+    },
+};
+//# sourceMappingURL=streaming.js.map

package/dist/templates/streaming.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"streaming.js","sourceRoot":"","sources":["../../src/templates/streaming.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAuC,gBAAgB,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAEpG,MAAM,CAAC,MAAM,iBAAiB,GAAuB;IACnD,EAAE,EAAE,WAAW;IACf,IAAI,EAAE,2BAA2B;IACjC,WAAW,EAAE,kFAAkF;IAC/F,QAAQ,EAAE,CAAC,WAAmB,EAAmB,EAAE;QACjD,OAAO;YACL,cAAc,EAAE,IAAI,CAAC,SAAS,CAC5B;gBACE,IAAI,EAAE,WAAW;gBACjB,OAAO,EAAE,OAAO;gBAChB,IAAI,EAAE,QAAQ;gBACd,OAAO,EAAE;oBACP,GAAG,EAAE,+CAA+C;oBACpD,KAAK,EAAE,KAAK;oBACZ,KAAK,EAAE,qBAAqB;iBAC7B;gBACD,YAAY,EAAE;oBACZ,OAAO,EAAE,QAAQ;iBAClB;gBACD,eAAe,EAAE;oBACf,aAAa,EAAE,UAAU;oBACzB,UAAU,EAAE,QAAQ;iBACrB;aACF,EACD,IAAI,EACJ,CAAC,CACF,GAAG,IAAI;YAER,eAAe,EAAE,eAAe;YAChC,YAAY,EAAE,gBAAgB;YAE9B,WAAW,EAAE,KAAK,WAAW;;;;;;;;;;;;;;;;;;;;;;CAsBlC;YAEK,eAAe,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyJtB;SACI,CAAC;IACJ,CAAC;CACF,CAAC"}