@nimblebrain/synapse 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 NimbleBrain, Inc.
+
+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/README.md

@@ -0,0 +1,248 @@
+# @nimblebrain/synapse
+
+[![CI](https://github.com/NimbleBrainInc/synapse/actions/workflows/ci.yml/badge.svg)](https://github.com/NimbleBrainInc/synapse/actions/workflows/ci.yml)
+[![npm version](https://img.shields.io/npm/v/@nimblebrain/synapse)](https://www.npmjs.com/package/@nimblebrain/synapse)
+[![npm downloads](https://img.shields.io/npm/dm/@nimblebrain/synapse)](https://www.npmjs.com/package/@nimblebrain/synapse)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+[![TypeScript](https://img.shields.io/badge/TypeScript-strict-blue)](https://www.typescriptlang.org/)
+[![Node.js](https://img.shields.io/badge/node-%3E%3D20-brightgreen)](https://nodejs.org/)
+
+Agent-aware app SDK for the [NimbleBrain](https://nimblebrain.ai) platform. Typed tool calls, reactive state, and React hooks over the [MCP ext-apps](https://modelcontextprotocol.io/specification/2025-06-18/user-interaction/ext-apps) protocol.
+
+## What is Synapse?
+
+Synapse is an optional enhancement layer over `@modelcontextprotocol/ext-apps`. It wraps the ext-apps protocol handshake and adds:
+
+- **Typed tool calls** — call MCP tools with full TypeScript input/output types
+- **Reactive data sync** — subscribe to data change events from the agent
+- **Theme tracking** — automatic light/dark mode and custom design tokens
+- **State store** — Redux-like store with optional persistence and LLM visibility
+- **Keyboard forwarding** — forward shortcuts from sandboxed iframes to the host
+- **Code generation** — generate TypeScript types from manifests, running servers, or JSON schemas
+
+In non-NimbleBrain hosts (Claude Desktop, VS Code, ChatGPT), NB-specific features degrade gracefully to no-ops while ext-apps baseline behavior is preserved.
+
+## Install
+
+```bash
+npm install @nimblebrain/synapse
+```
+
+**Peer dependency:** `@modelcontextprotocol/ext-apps@^1.3.1`
+
+## Package Exports
+
+| Entry Point | Description |
+|-------------|-------------|
+| `@nimblebrain/synapse` | Vanilla JS core (no framework dependency) |
+| `@nimblebrain/synapse/react` | React hooks and provider |
+| `@nimblebrain/synapse/vite` | Vite plugin for dev mode |
+| `@nimblebrain/synapse/codegen` | CLI + programmatic code generation |
+
+## Quick Start
+
+### Vanilla JS
+
+```typescript
+import { createSynapse } from "@nimblebrain/synapse";
+
+const synapse = createSynapse({
+  name: "my-app",
+  version: "1.0.0",
+});
+
+await synapse.ready;
+
+// Call an MCP tool
+const result = await synapse.callTool("get_items", { limit: 10 });
+console.log(result.data);
+
+// React to data changes from the agent
+synapse.onDataChanged((event) => {
+  console.log(`${event.tool} was called on ${event.server}`);
+});
+
+// Push state visible to the LLM
+synapse.setVisibleState(
+  { selectedItem: "item-42" },
+  "User is viewing item 42",
+);
+```
+
+### React
+
+```tsx
+import { SynapseProvider, useCallTool, useTheme } from "@nimblebrain/synapse/react";
+
+function App() {
+  return (
+    <SynapseProvider name="my-app" version="1.0.0">
+      <ItemList />
+    </SynapseProvider>
+  );
+}
+
+function ItemList() {
+  const { call, data, isPending } = useCallTool<Item[]>("list_items");
+  const theme = useTheme();
+
+  return (
+    <div style={{ colorScheme: theme.mode }}>
+      <button onClick={() => call()} disabled={isPending}>
+        Load Items
+      </button>
+      {data?.map((item) => <div key={item.id}>{item.name}</div>)}
+    </div>
+  );
+}
+```
+
+### Vite Plugin
+
+```typescript
+// vite.config.ts
+import { synapseVite } from "@nimblebrain/synapse/vite";
+
+export default {
+  plugins: [
+    synapseVite({
+      appName: "my-app",
+    }),
+  ],
+};
+```
+
+### Code Generation
+
+Generate TypeScript types from an app manifest:
+
+```bash
+npx synapse --from-manifest ./manifest.json --out src/generated/types.ts
+```
+
+Or from a running MCP server:
+
+```bash
+npx synapse --from-server http://localhost:3000 --out src/generated/types.ts
+```
+
+Or from a directory of `.schema.json` files (generates CRUD tool types):
+
+```bash
+npx synapse --from-schema ./schemas --out src/generated/types.ts
+```
+
+## State Store
+
+Create a typed, reactive store with optional persistence and agent visibility:
+
+```typescript
+import { createSynapse, createStore } from "@nimblebrain/synapse";
+
+const synapse = createSynapse({ name: "my-app", version: "1.0.0" });
+
+const store = createStore(synapse, {
+  initialState: { count: 0, items: [] },
+  actions: {
+    increment: (state) => ({ ...state, count: state.count + 1 }),
+    addItem: (state, item: string) => ({
+      ...state,
+      items: [...state.items, item],
+    }),
+  },
+  persist: true,
+  visibleToAgent: true,
+  summarize: (state) => `${state.items.length} items, count=${state.count}`,
+});
+
+store.dispatch.increment();
+store.dispatch.addItem("hello");
+```
+
+Use `useStore` in React:
+
+```tsx
+import { useStore } from "@nimblebrain/synapse/react";
+
+function Counter() {
+  const { state, dispatch } = useStore(store);
+  return <button onClick={() => dispatch.increment()}>{state.count}</button>;
+}
+```
+
+## API Reference
+
+### `createSynapse(options)`
+
+Creates a Synapse instance. Returns a `Synapse` object.
+
+| Option | Type | Description |
+|--------|------|-------------|
+| `name` | `string` | App name (must match registered bundle name) |
+| `version` | `string` | Semver version |
+| `internal` | `boolean?` | Enable cross-server tool calls (NB internal only) |
+| `forwardKeys` | `KeyForwardConfig[]?` | Custom keyboard forwarding rules |
+
+### `Synapse` Methods
+
+| Method | Description |
+|--------|-------------|
+| `ready` | Promise that resolves after the ext-apps handshake |
+| `isNimbleBrainHost` | Whether the host is a NimbleBrain platform |
+| `callTool(name, args?)` | Call an MCP tool and get typed result |
+| `onDataChanged(cb)` | Subscribe to data change events |
+| `getTheme()` | Get current theme |
+| `onThemeChanged(cb)` | Subscribe to theme changes |
+| `action(name, params?)` | Dispatch a NB platform action |
+| `chat(message, context?)` | Send a chat message to the agent |
+| `setVisibleState(state, summary?)` | Push LLM-visible state (debounced 250ms) |
+| `downloadFile(name, content, mime?)` | Trigger a file download |
+| `openLink(url)` | Open a URL (host-aware) |
+| `destroy()` | Clean up all listeners and timers |
+
+### React Hooks
+
+| Hook | Description |
+|------|-------------|
+| `useSynapse()` | Access the Synapse instance |
+| `useCallTool(name)` | `{ call, data, isPending, error }` for a tool |
+| `useDataSync(cb)` | Subscribe to data change events |
+| `useTheme()` | Reactive theme object |
+| `useAction()` | Dispatch platform actions |
+| `useChat()` | Send chat messages |
+| `useVisibleState()` | Push LLM-visible state |
+| `useStore(store)` | `{ state, dispatch }` for a store |
+
+## Development
+
+```bash
+npm install
+npm run build      # Build ESM + CJS + IIFE
+npm test           # Run tests
+npm run typecheck  # Type-check
+npm run lint       # Lint with Biome
+npm run lint:fix   # Auto-fix lint issues
+npm run ci         # Run full CI pipeline locally (lint → typecheck → build → test)
+```
+
+## Publishing
+
+Requires npm login with access to the `@nimblebrain` org.
+
+```bash
+# First time: log in to npm
+npm login
+
+# Bump version (updates package.json and creates a git tag)
+npm version patch   # or minor / major
+
+# Publish (build runs automatically via prepublishOnly)
+npm publish --access public
+
+# Push the version tag
+git push origin main --tags
+```
+
+## License
+
+[MIT](LICENSE)

package/dist/chunk-AW3YIXLE.cjs

@@ -0,0 +1,248 @@
+'use strict';
+
+var fs = require('fs');
+var path = require('path');
+
+// src/codegen/schema-reader.ts
+function readFromManifest(manifestPath) {
+  if (!fs.existsSync(manifestPath)) {
+    throw new Error(`Manifest not found: ${manifestPath}`);
+  }
+  const raw = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
+  const tools = raw.tools ?? [];
+  if (!Array.isArray(tools)) {
+    return [];
+  }
+  return tools.map((t) => ({
+    name: t.name,
+    description: t.description,
+    inputSchema: t.inputSchema ?? {},
+    outputSchema: t.outputSchema
+  }));
+}
+async function readFromServer(url) {
+  const response = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      jsonrpc: "2.0",
+      method: "tools/list",
+      id: "codegen-1",
+      params: {}
+    })
+  });
+  if (!response.ok) {
+    throw new Error(`Server responded with ${response.status}: ${response.statusText}`);
+  }
+  const result = await response.json();
+  if (result.error) {
+    throw new Error(`Server error: ${result.error.message}`);
+  }
+  const tools = result.result?.tools ?? [];
+  return tools.map((t) => ({
+    name: t.name,
+    description: t.description,
+    inputSchema: t.inputSchema ?? {},
+    outputSchema: t.outputSchema
+  }));
+}
+function readFromSchemaDir(dirPath) {
+  if (!fs.existsSync(dirPath)) {
+    throw new Error(`Schema directory not found: ${dirPath}`);
+  }
+  const files = fs.readdirSync(dirPath).filter((f) => f.endsWith(".schema.json"));
+  const tools = [];
+  for (const file of files) {
+    const schema = JSON.parse(fs.readFileSync(path.join(dirPath, file), "utf-8"));
+    const entityName = path.basename(file, ".schema.json");
+    tools.push(
+      {
+        name: `create_${entityName}`,
+        description: `Create a new ${entityName}`,
+        inputSchema: schema,
+        outputSchema: schema
+      },
+      {
+        name: `read_${entityName}`,
+        description: `Read a ${entityName} by ID`,
+        inputSchema: {
+          type: "object",
+          properties: { id: { type: "string" } },
+          required: ["id"]
+        },
+        outputSchema: schema
+      },
+      {
+        name: `update_${entityName}`,
+        description: `Update an existing ${entityName}`,
+        inputSchema: schema,
+        outputSchema: schema
+      },
+      {
+        name: `delete_${entityName}`,
+        description: `Delete a ${entityName} by ID`,
+        inputSchema: {
+          type: "object",
+          properties: { id: { type: "string" } },
+          required: ["id"]
+        }
+      },
+      {
+        name: `list_${entityName}s`,
+        description: `List all ${entityName}s`,
+        inputSchema: {
+          type: "object",
+          properties: {
+            filter: { type: "string" },
+            limit: { type: "number" }
+          }
+        },
+        outputSchema: {
+          type: "object",
+          properties: {
+            items: { type: "array", items: schema },
+            total: { type: "number" }
+          },
+          required: ["items", "total"]
+        }
+      }
+    );
+  }
+  return tools;
+}
+
+// src/codegen/type-generator.ts
+function generateTypes(tools, appName) {
+  const lines = [];
+  const mapName = `${toPascalCase(appName)}ToolMap`;
+  lines.push("/**");
+  lines.push(` * Auto-generated by @nimblebrain/synapse codegen`);
+  lines.push(` * Source: ${appName}`);
+  lines.push(` *`);
+  lines.push(
+    ` * DO NOT EDIT \u2014 regenerate with: npx synapse codegen --from-manifest ./manifest.json`
+  );
+  lines.push(` */`);
+  lines.push("");
+  const mapEntries = [];
+  for (const tool of tools) {
+    const baseName = toPascalCase(tool.name);
+    const inputName = `${baseName}Input`;
+    lines.push(schemaToInterface(inputName, tool.inputSchema));
+    lines.push("");
+    let outputName = "unknown";
+    if (tool.outputSchema) {
+      outputName = `${baseName}Output`;
+      lines.push(schemaToInterface(outputName, tool.outputSchema));
+      lines.push("");
+    }
+    mapEntries.push(`  ${tool.name}: { input: ${inputName}; output: ${outputName} };`);
+  }
+  lines.push(`/** Tool type map for typed useCallTool */`);
+  lines.push(`export interface ${mapName} {`);
+  for (const entry of mapEntries) {
+    lines.push(entry);
+  }
+  lines.push(`}`);
+  lines.push("");
+  return lines.join("\n");
+}
+function schemaToInterface(name, schema) {
+  const type = schemaToType(schema, name);
+  if (schema.type === "object" || schema.properties) {
+    return generateInterface(name, schema);
+  }
+  return `export type ${name} = ${type};`;
+}
+function generateInterface(name, schema) {
+  const lines = [];
+  lines.push(`export interface ${name} {`);
+  const props = schema.properties ?? {};
+  const required = new Set(schema.required ?? []);
+  for (const [key, propSchema] of Object.entries(props)) {
+    const isRequired = required.has(key);
+    const type = schemaToType(propSchema, name + toPascalCase(key));
+    const desc = propSchema.description;
+    if (desc) {
+      lines.push(`  /** ${desc} */`);
+    }
+    lines.push(`  ${key}${isRequired ? "" : "?"}: ${type};`);
+  }
+  lines.push(`}`);
+  return lines.join("\n");
+}
+function schemaToType(schema, context) {
+  if (schema.enum && Array.isArray(schema.enum)) {
+    return schema.enum.map((v) => typeof v === "string" ? `"${v}"` : String(v)).join(" | ");
+  }
+  if (schema.oneOf && Array.isArray(schema.oneOf)) {
+    return schema.oneOf.map((s, i) => schemaToType(s, `${context}Option${i}`)).join(" | ");
+  }
+  if (schema.anyOf && Array.isArray(schema.anyOf)) {
+    return schema.anyOf.map((s, i) => schemaToType(s, `${context}Option${i}`)).join(" | ");
+  }
+  if (schema.allOf && Array.isArray(schema.allOf)) {
+    return schema.allOf.map((s, i) => schemaToType(s, `${context}Part${i}`)).join(" & ");
+  }
+  const type = schema.type;
+  if (Array.isArray(type)) {
+    return type.map((t) => primitiveType(t)).join(" | ");
+  }
+  switch (type) {
+    case "string":
+      return "string";
+    case "number":
+    case "integer":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "null":
+      return "null";
+    case "array": {
+      const items = schema.items;
+      if (items) {
+        return `${schemaToType(items, `${context}Item`)}[]`;
+      }
+      return "unknown[]";
+    }
+    case "object": {
+      if (schema.properties) {
+        const props = schema.properties;
+        const required = new Set(schema.required ?? []);
+        const fields = Object.entries(props).map(([key, propSchema]) => {
+          const t = schemaToType(propSchema, context + toPascalCase(key));
+          return `${key}${required.has(key) ? "" : "?"}: ${t}`;
+        }).join("; ");
+        return `{ ${fields} }`;
+      }
+      return "Record<string, unknown>";
+    }
+    default:
+      return "unknown";
+  }
+}
+function primitiveType(t) {
+  switch (t) {
+    case "string":
+      return "string";
+    case "number":
+    case "integer":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "null":
+      return "null";
+    default:
+      return "unknown";
+  }
+}
+function toPascalCase(str) {
+  return str.split(/[-_@/]/).filter(Boolean).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
+}
+
+exports.generateTypes = generateTypes;
+exports.readFromManifest = readFromManifest;
+exports.readFromSchemaDir = readFromSchemaDir;
+exports.readFromServer = readFromServer;
+//# sourceMappingURL=chunk-AW3YIXLE.cjs.map
+//# sourceMappingURL=chunk-AW3YIXLE.cjs.map

package/dist/chunk-AW3YIXLE.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/codegen/schema-reader.ts","../src/codegen/type-generator.ts"],"names":["existsSync","readFileSync","readdirSync","join","basename"],"mappings":"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","file":"chunk-AW3YIXLE.cjs","sourcesContent":["import { existsSync, readdirSync, readFileSync } from \"node:fs\";\nimport { basename, join } from \"node:path\";\nimport type { ToolDefinition } from \"../types.js\";\n\n/**\n * Read tool definitions from a manifest.json file.\n * Extracts tools from the MCP standard `tools` array.\n */\nexport function readFromManifest(manifestPath: string): ToolDefinition[] {\n  if (!existsSync(manifestPath)) {\n    throw new Error(`Manifest not found: ${manifestPath}`);\n  }\n\n  const raw = JSON.parse(readFileSync(manifestPath, \"utf-8\"));\n  const tools = raw.tools ?? [];\n\n  if (!Array.isArray(tools)) {\n    return [];\n  }\n\n  return tools.map((t: any) => ({\n    name: t.name as string,\n    description: t.description as string | undefined,\n    inputSchema: (t.inputSchema ?? {}) as Record<string, unknown>,\n    outputSchema: t.outputSchema as Record<string, unknown> | undefined,\n  }));\n}\n\n/**\n * Read tool definitions from a running MCP server via tools/list.\n * Connects to the server's HTTP endpoint and calls the JSON-RPC method.\n */\nexport async function readFromServer(url: string): Promise<ToolDefinition[]> {\n  const response = await fetch(url, {\n    method: \"POST\",\n    headers: { \"Content-Type\": \"application/json\" },\n    body: JSON.stringify({\n      jsonrpc: \"2.0\",\n      method: \"tools/list\",\n      id: \"codegen-1\",\n      params: {},\n    }),\n  });\n\n  if (!response.ok) {\n    throw new Error(`Server responded with ${response.status}: ${response.statusText}`);\n  }\n\n  const result = await response.json();\n  if (result.error) {\n    throw new Error(`Server error: ${result.error.message}`);\n  }\n\n  const tools = result.result?.tools ?? [];\n  return tools.map((t: any) => ({\n    name: t.name as string,\n    description: t.description as string | undefined,\n    inputSchema: (t.inputSchema ?? {}) as Record<string, unknown>,\n    outputSchema: t.outputSchema as Record<string, unknown> | undefined,\n  }));\n}\n\n/**\n * Read entity schemas from a directory and generate CRUD tool definitions.\n * Each .schema.json file becomes create/read/update/delete/list tools.\n */\nexport function readFromSchemaDir(dirPath: string): ToolDefinition[] {\n  if (!existsSync(dirPath)) {\n    throw new Error(`Schema directory not found: ${dirPath}`);\n  }\n\n  const files = readdirSync(dirPath).filter((f: string) => f.endsWith(\".schema.json\"));\n  const tools: ToolDefinition[] = [];\n\n  for (const file of files) {\n    const schema = JSON.parse(readFileSync(join(dirPath, file), \"utf-8\"));\n    const entityName = basename(file, \".schema.json\");\n\n    tools.push(\n      {\n        name: `create_${entityName}`,\n        description: `Create a new ${entityName}`,\n        inputSchema: schema,\n        outputSchema: schema,\n      },\n      {\n        name: `read_${entityName}`,\n        description: `Read a ${entityName} by ID`,\n        inputSchema: {\n          type: \"object\",\n          properties: { id: { type: \"string\" } },\n          required: [\"id\"],\n        },\n        outputSchema: schema,\n      },\n      {\n        name: `update_${entityName}`,\n        description: `Update an existing ${entityName}`,\n        inputSchema: schema,\n        outputSchema: schema,\n      },\n      {\n        name: `delete_${entityName}`,\n        description: `Delete a ${entityName} by ID`,\n        inputSchema: {\n          type: \"object\",\n          properties: { id: { type: \"string\" } },\n          required: [\"id\"],\n        },\n      },\n      {\n        name: `list_${entityName}s`,\n        description: `List all ${entityName}s`,\n        inputSchema: {\n          type: \"object\",\n          properties: {\n            filter: { type: \"string\" },\n            limit: { type: \"number\" },\n          },\n        },\n        outputSchema: {\n          type: \"object\",\n          properties: {\n            items: { type: \"array\", items: schema },\n            total: { type: \"number\" },\n          },\n          required: [\"items\", \"total\"],\n        },\n      },\n    );\n  }\n\n  return tools;\n}\n","import type { ToolDefinition } from \"../types.js\";\n\n/**\n * Generate TypeScript interfaces from tool definitions.\n */\nexport function generateTypes(tools: ToolDefinition[], appName: string): string {\n  const lines: string[] = [];\n  const mapName = `${toPascalCase(appName)}ToolMap`;\n\n  lines.push(\"/**\");\n  lines.push(` * Auto-generated by @nimblebrain/synapse codegen`);\n  lines.push(` * Source: ${appName}`);\n  lines.push(` *`);\n  lines.push(\n    ` * DO NOT EDIT — regenerate with: npx synapse codegen --from-manifest ./manifest.json`,\n  );\n  lines.push(` */`);\n  lines.push(\"\");\n\n  const mapEntries: string[] = [];\n\n  for (const tool of tools) {\n    const baseName = toPascalCase(tool.name);\n\n    // Input type\n    const inputName = `${baseName}Input`;\n    lines.push(schemaToInterface(inputName, tool.inputSchema));\n    lines.push(\"\");\n\n    // Output type\n    let outputName = \"unknown\";\n    if (tool.outputSchema) {\n      outputName = `${baseName}Output`;\n      lines.push(schemaToInterface(outputName, tool.outputSchema));\n      lines.push(\"\");\n    }\n\n    mapEntries.push(`  ${tool.name}: { input: ${inputName}; output: ${outputName} };`);\n  }\n\n  // Tool map\n  lines.push(`/** Tool type map for typed useCallTool */`);\n  lines.push(`export interface ${mapName} {`);\n  for (const entry of mapEntries) {\n    lines.push(entry);\n  }\n  lines.push(`}`);\n  lines.push(\"\");\n\n  return lines.join(\"\\n\");\n}\n\n// ---------------------------------------------------------------------------\n// JSON Schema -> TypeScript conversion\n// ---------------------------------------------------------------------------\n\nfunction schemaToInterface(name: string, schema: Record<string, unknown>): string {\n  const type = schemaToType(schema, name);\n\n  // If the schema is an object, generate a named interface\n  if (schema.type === \"object\" || schema.properties) {\n    return generateInterface(name, schema);\n  }\n\n  // Otherwise, generate a type alias\n  return `export type ${name} = ${type};`;\n}\n\nfunction generateInterface(name: string, schema: Record<string, unknown>): string {\n  const lines: string[] = [];\n  lines.push(`export interface ${name} {`);\n\n  const props = (schema.properties ?? {}) as Record<string, Record<string, unknown>>;\n  const required = new Set((schema.required ?? []) as string[]);\n\n  for (const [key, propSchema] of Object.entries(props)) {\n    const isRequired = required.has(key);\n    const type = schemaToType(propSchema, name + toPascalCase(key));\n    const desc = propSchema.description;\n    if (desc) {\n      lines.push(`  /** ${desc} */`);\n    }\n    lines.push(`  ${key}${isRequired ? \"\" : \"?\"}: ${type};`);\n  }\n\n  lines.push(`}`);\n  return lines.join(\"\\n\");\n}\n\nfunction schemaToType(schema: Record<string, unknown>, context: string): string {\n  // Handle enum\n  if (schema.enum && Array.isArray(schema.enum)) {\n    return (schema.enum as unknown[])\n      .map((v) => (typeof v === \"string\" ? `\"${v}\"` : String(v)))\n      .join(\" | \");\n  }\n\n  // Handle oneOf / anyOf\n  if (schema.oneOf && Array.isArray(schema.oneOf)) {\n    return (schema.oneOf as Record<string, unknown>[])\n      .map((s, i) => schemaToType(s, `${context}Option${i}`))\n      .join(\" | \");\n  }\n  if (schema.anyOf && Array.isArray(schema.anyOf)) {\n    return (schema.anyOf as Record<string, unknown>[])\n      .map((s, i) => schemaToType(s, `${context}Option${i}`))\n      .join(\" | \");\n  }\n\n  // Handle allOf (intersection)\n  if (schema.allOf && Array.isArray(schema.allOf)) {\n    return (schema.allOf as Record<string, unknown>[])\n      .map((s, i) => schemaToType(s, `${context}Part${i}`))\n      .join(\" & \");\n  }\n\n  // Handle type-based conversion\n  const type = schema.type as string | string[] | undefined;\n\n  if (Array.isArray(type)) {\n    // Multi-type (e.g., [\"string\", \"null\"])\n    return type.map((t) => primitiveType(t)).join(\" | \");\n  }\n\n  switch (type) {\n    case \"string\":\n      return \"string\";\n    case \"number\":\n    case \"integer\":\n      return \"number\";\n    case \"boolean\":\n      return \"boolean\";\n    case \"null\":\n      return \"null\";\n    case \"array\": {\n      const items = schema.items as Record<string, unknown> | undefined;\n      if (items) {\n        return `${schemaToType(items, `${context}Item`)}[]`;\n      }\n      return \"unknown[]\";\n    }\n    case \"object\": {\n      if (schema.properties) {\n        // Inline object — generate property types\n        const props = schema.properties as Record<string, Record<string, unknown>>;\n        const required = new Set((schema.required ?? []) as string[]);\n        const fields = Object.entries(props)\n          .map(([key, propSchema]) => {\n            const t = schemaToType(propSchema, context + toPascalCase(key));\n            return `${key}${required.has(key) ? \"\" : \"?\"}: ${t}`;\n          })\n          .join(\"; \");\n        return `{ ${fields} }`;\n      }\n      return \"Record<string, unknown>\";\n    }\n    default:\n      return \"unknown\";\n  }\n}\n\nfunction primitiveType(t: string): string {\n  switch (t) {\n    case \"string\":\n      return \"string\";\n    case \"number\":\n    case \"integer\":\n      return \"number\";\n    case \"boolean\":\n      return \"boolean\";\n    case \"null\":\n      return \"null\";\n    default:\n      return \"unknown\";\n  }\n}\n\nfunction toPascalCase(str: string): string {\n  return str\n    .split(/[-_@/]/)\n    .filter(Boolean)\n    .map((word) => word.charAt(0).toUpperCase() + word.slice(1))\n    .join(\"\");\n}\n"]}