@specverse/engines 4.1.0

package/libs/instance-factories/tools/templates/vscode/vscode-extension-generator.ts

@@ -0,0 +1,300 @@
+/**
+ * VSCode Extension Generator
+ *
+ * Generates a complete VSCode extension package from the SpecVerse spec.
+ * - package.json with commands derived from CLI spec + entity types
+ * - Ships static assets (tmLanguage, themes, schemas, extension.ts)
+ *
+ * The spec's ToolsSupport component describes WHAT the extension provides.
+ * This generator decides HOW to package it.
+ */
+
+import type { TemplateContext } from '@specverse/types';
+import { readFileSync, existsSync, readdirSync, statSync, mkdirSync, writeFileSync, copyFileSync } from 'fs';
+import { join, dirname, resolve } from 'path';
+import { fileURLToPath } from 'url';
+
+const __generatorDir = dirname(fileURLToPath(import.meta.url));
+
+export default function generateVSCodeExtension(context: TemplateContext): string {
+  const { spec, outputDir } = context;
+
+  const extensionDir = join(outputDir || '.', 'tools', 'vscode-extension');
+  if (!existsSync(extensionDir)) mkdirSync(extensionDir, { recursive: true });
+
+  // 1. Check for distribution spec (new entity type)
+  const distribution = extractDistribution(spec);
+
+  // 2. Extract CLI commands — from distribution, spec, or standard defaults
+  let cliCommands: Array<{ command: string; title: string; category: string }> = [];
+  if (distribution?.commands) {
+    cliCommands = distribution.commands.map((cmd: any) => {
+      const parts = (cmd.from || cmd.command || '').split('.');
+      const name = parts[parts.length - 1] || 'unknown';
+      return {
+        command: `specverse.${name}`,
+        title: cmd.title || `${capitalize(name)}: ${cmd.description || ''}`,
+        category: 'SpecVerse',
+      };
+    });
+  }
+  if (cliCommands.length === 0) {
+    cliCommands = extractCLICommands(spec);
+  }
+  if (cliCommands.length === 0) {
+    cliCommands = getStandardCommands();
+  }
+
+  // 3. Extract entity types for syntax highlighting keywords
+  const entityTypes = extractEntityTypes(spec);
+
+  // 4. Generate package.json — use distribution metadata if available
+  const specVersion = distribution?.version || spec?.metadata?.version || spec?.version || '4.0.0';
+  const packageJson = generatePackageJson(cliCommands, entityTypes, specVersion);
+
+  // Override package.json with distribution-specific values
+  if (distribution) {
+    if (distribution.displayName) packageJson.displayName = distribution.displayName;
+    if (distribution.publisher) packageJson.publisher = distribution.publisher;
+    if (distribution.description) packageJson.description = distribution.description;
+
+    // Languages from distribution
+    if (distribution.languages && distribution.languages.length > 0) {
+      packageJson.contributes.languages = distribution.languages.map((lang: any) => ({
+        id: lang.id,
+        aliases: lang.aliases || [lang.id],
+        extensions: lang.extensions || [],
+        configuration: `./language-configuration.json`,
+      }));
+      packageJson.contributes.grammars = distribution.languages
+        .filter((lang: any) => lang.grammar)
+        .map((lang: any) => ({
+          language: lang.id,
+          scopeName: lang.grammar,
+          path: `./syntaxes/${lang.id}.tmLanguage.json`,
+        }));
+    }
+
+    // Themes from distribution
+    if (distribution.themes && distribution.themes.length > 0) {
+      packageJson.contributes.themes = distribution.themes.map((theme: any) => ({
+        label: theme.name,
+        uiTheme: theme.type === 'dark' ? 'vs-dark' : theme.type === 'light' ? 'vs' : 'hc-black',
+        path: `./themes/${theme.name.toLowerCase().replace(/\s+/g, '-')}-theme.json`,
+      }));
+    }
+  }
+  writeFileSync(join(extensionDir, 'package.json'), JSON.stringify(packageJson, null, 2) + '\n');
+
+  // 4. Copy static assets — check both source and compiled locations
+  let staticDir = join(__generatorDir, 'static');
+  if (!existsSync(staticDir)) {
+    staticDir = join(__generatorDir.replace('/dist/libs/', '/libs/'), 'static');
+  }
+  if (existsSync(staticDir)) {
+    copyRecursive(staticDir, extensionDir);
+  }
+
+  // 5. Create src directory and copy extension.ts
+  const srcDir = join(extensionDir, 'src');
+  if (!existsSync(srcDir)) mkdirSync(srcDir, { recursive: true });
+  const extTs = join(staticDir, 'extension.ts');
+  if (existsSync(extTs)) {
+    copyFileSync(extTs, join(srcDir, 'extension.ts'));
+  }
+
+  // 6. Generate build script
+  const buildScript = `const esbuild = require('esbuild');
+esbuild.build({
+  entryPoints: ['src/extension.ts'],
+  bundle: true,
+  outfile: 'dist/extension.js',
+  external: ['vscode'],
+  format: 'cjs',
+  platform: 'node',
+}).catch(() => process.exit(1));
+`;
+  const scriptsDir = join(extensionDir, 'scripts');
+  if (!existsSync(scriptsDir)) mkdirSync(scriptsDir, { recursive: true });
+  writeFileSync(join(scriptsDir, 'build.js'), buildScript);
+
+  return `VSCode extension generated in: ${extensionDir}\n  ${cliCommands.length} commands, ${entityTypes.length} entity keywords`;
+}
+
+function extractDistribution(spec: any): any | null {
+  const allDistributions: any[] = [];
+
+  // Check top-level distributions (AI-optimized spec format)
+  if (spec?.distributions) {
+    const entries = Array.isArray(spec.distributions)
+      ? spec.distributions
+      : Object.entries(spec.distributions).map(([name, data]) => ({ name, ...(data as any) }));
+    allDistributions.push(...entries);
+  }
+
+  // Search components for distributions sections
+  const components = spec?.components || {};
+  const componentList = Array.isArray(components) ? components : Object.values(components);
+
+  for (const comp of componentList) {
+    const distributions = (comp as any)?.distributions;
+    if (!distributions) continue;
+    const distEntries = Array.isArray(distributions)
+      ? distributions
+      : Object.entries(distributions).map(([name, data]) => ({ name, ...(data as any) }));
+    allDistributions.push(...distEntries);
+  }
+
+  // Prefer IDE type
+  for (const dist of allDistributions) {
+    if ((dist as any).type === 'ide') return dist;
+  }
+  return allDistributions.length > 0 ? allDistributions[0] : null;
+}
+
+function extractCLICommands(spec: any): Array<{ command: string; title: string; category: string }> {
+  const commands: Array<{ command: string; title: string; category: string }> = [];
+
+  // Walk components looking for CLI commands section
+  // Handles both object form (raw spec: components.CLI.commands) and array form (inferred)
+  const components = spec?.components || {};
+  const componentList = Array.isArray(components) ? components : Object.entries(components).map(([name, data]) => ({ name, ...(data as any) }));
+
+  for (const comp of componentList) {
+    const cliCommands = (comp as any)?.commands;
+    if (!cliCommands) continue;
+
+    for (const [rootName, rootDef] of Object.entries(cliCommands as Record<string, any>)) {
+      const subcommands = (rootDef as any)?.subcommands || {};
+      for (const [subName, subDef] of Object.entries(subcommands as Record<string, any>)) {
+        const sub = subDef as any;
+        const nestedSubs = sub?.subcommands;
+        if (nestedSubs) {
+          for (const [nestedName, nestedDef] of Object.entries(nestedSubs as Record<string, any>)) {
+            commands.push({
+              command: `specverse.${subName}.${nestedName}`,
+              title: `${capitalize(subName)} ${capitalize(nestedName)}: ${(nestedDef as any).description || ''}`,
+              category: 'SpecVerse',
+            });
+          }
+        } else {
+          commands.push({
+            command: `specverse.${subName}`,
+            title: `${capitalize(subName)}: ${sub.description || ''}`,
+            category: 'SpecVerse',
+          });
+        }
+      }
+    }
+  }
+
+  return commands;
+}
+
+function extractEntityTypes(spec: any): string[] {
+  const types = new Set<string>();
+  const components = spec?.components || [];
+  for (const component of Array.isArray(components) ? components : Object.values(components)) {
+    const comp = component as any;
+    const models = comp?.models;
+    if (models) {
+      if (Array.isArray(models)) {
+        models.forEach((m: any) => types.add(m.name));
+      } else {
+        Object.keys(models).forEach(name => types.add(name));
+      }
+    }
+  }
+  return [...types];
+}
+
+function generatePackageJson(
+  commands: Array<{ command: string; title: string; category: string }>,
+  _entityTypes: string[],
+  specVersion: string = '1.0.0'
+) {
+  return {
+    name: 'specverse',
+    displayName: 'SpecVerse',
+    description: 'SpecVerse specification language support — syntax highlighting, validation, IntelliSense',
+    version: specVersion,
+    publisher: 'specverse',
+    engines: { vscode: '^1.80.0' },
+    categories: ['Programming Languages', 'Linters', 'Snippets'],
+    activationEvents: ['onLanguage:specverse'],
+    main: './dist/extension.js',
+    contributes: {
+      languages: [{
+        id: 'specverse',
+        aliases: ['SpecVerse', 'specly'],
+        extensions: ['.specly', '.specverse'],
+        configuration: './language-configuration.json',
+      }],
+      grammars: [{
+        language: 'specverse',
+        scopeName: 'source.specverse',
+        path: './syntaxes/specverse.tmLanguage.json',
+      }],
+      jsonValidation: [{
+        fileMatch: ['*.specly', '*.specverse'],
+        url: './schemas/specverse-v3-schema.json',
+      }],
+      themes: [
+        { label: 'SpecVerse Dark', uiTheme: 'vs-dark', path: './themes/specverse-complete-theme.json' },
+        { label: 'SpecVerse Basic', uiTheme: 'vs-dark', path: './themes/specverse-basic-theme.json' },
+      ],
+      commands: commands.map(c => ({
+        command: c.command,
+        title: c.title,
+        category: c.category,
+      })),
+    },
+    scripts: {
+      'vscode:prepublish': 'npm run build',
+      build: 'node scripts/build.js',
+      package: 'npx @vscode/vsce package',
+    },
+    devDependencies: {
+      '@types/vscode': '^1.80.0',
+      '@vscode/vsce': '^3.0.0',
+      esbuild: '^0.19.0',
+    },
+  };
+}
+
+function copyRecursive(src: string, dest: string) {
+  for (const entry of readdirSync(src)) {
+    if (entry === 'extension.ts') continue; // Handled separately into src/
+    const srcPath = join(src, entry);
+    const destPath = join(dest, entry);
+    if (statSync(srcPath).isDirectory()) {
+      if (!existsSync(destPath)) mkdirSync(destPath, { recursive: true });
+      copyRecursive(srcPath, destPath);
+    } else {
+      copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+function getStandardCommands(): Array<{ command: string; title: string; category: string }> {
+  return [
+    { command: 'specverse.validate', title: 'Validate specification', category: 'SpecVerse' },
+    { command: 'specverse.infer', title: 'Infer full architecture', category: 'SpecVerse' },
+    { command: 'specverse.realize', title: 'Generate code from specification', category: 'SpecVerse' },
+    { command: 'specverse.init', title: 'Initialize new project', category: 'SpecVerse' },
+    { command: 'specverse.gen.diagrams', title: 'Generate Mermaid diagrams', category: 'SpecVerse' },
+    { command: 'specverse.gen.docs', title: 'Generate documentation', category: 'SpecVerse' },
+    { command: 'specverse.gen.uml', title: 'Generate UML diagrams', category: 'SpecVerse' },
+    { command: 'specverse.dev.format', title: 'Format .specly file', category: 'SpecVerse' },
+    { command: 'specverse.dev.watch', title: 'Watch and validate on change', category: 'SpecVerse' },
+    { command: 'specverse.dev.quick', title: 'Quick validation', category: 'SpecVerse' },
+    { command: 'specverse.cache', title: 'Manage import cache', category: 'SpecVerse' },
+    { command: 'specverse.ai.docs', title: 'Generate AI implementation prompt', category: 'SpecVerse' },
+    { command: 'specverse.ai.suggest', title: 'Get spec improvement suggestions', category: 'SpecVerse' },
+    { command: 'specverse.ai.template', title: 'Load AI prompt template', category: 'SpecVerse' },
+  ];
+}
+
+function capitalize(str: string): string {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}

package/libs/instance-factories/tools/vscode.yaml

@@ -0,0 +1,35 @@
+name: VSCodeExtension
+version: "4.0.0"
+category: tools
+description: "VSCode extension with language support, commands, themes, and schema validation"
+
+metadata:
+  author: "SpecVerse Team"
+  license: "MIT"
+  tags: [vscode, ide, extension, language-support]
+
+compatibility:
+  specverse: "^4.0.0"
+  node: ">=18.0.0"
+
+capabilities:
+  provides:
+    - "tools.vscode"
+    - "tools.ide"
+  requires: []
+
+technology:
+  runtime: "node"
+  language: "typescript"
+  framework: "vscode"
+
+dependencies:
+  runtime:
+    - name: "vscode"
+      version: "^1.85.0"
+
+codeTemplates:
+  vscode-extension:
+    engine: typescript
+    generator: "libs/instance-factories/tools/templates/vscode/vscode-extension-generator.ts"
+    outputPattern: "tools/vscode-extension/"

package/libs/instance-factories/validation/README.md

@@ -0,0 +1,38 @@
+# Validation Instance Factory
+
+Generates Zod runtime validation schemas from SpecVerse model definitions, with optional JSON Schema output for Fastify integration.
+
+## Definition
+
+- **`zod.yaml`** -- Single definition (category: `service`, no external dependencies required).
+
+## Generator
+
+- `templates/zod/validation-generator.ts` -- Wraps `generate-validation.js`. Produces per-model validation files.
+
+## Capabilities
+
+| Capability | Description |
+|---|---|
+| `validation.runtime` | Zod schemas for runtime type checking |
+| `validation.zod` | Zod-specific schema generation |
+| `validation.jsonschema` | JSON Schema output (for Fastify route validation) |
+
+## Output Pattern
+
+```
+src/validation/{model}.validation.ts
+```
+
+Each file contains Zod schema definitions with inferred TypeScript types, plus optional JSON Schema equivalents.
+
+## Default Configuration
+
+- **Framework**: Zod 3.22+
+- **JSON Schema generation**: Enabled
+- **Strip unknown keys**: Enabled
+- **Abort early**: Disabled (collect all errors)
+
+## Status
+
+Wrapper implementation. Future TODO to split into dedicated generators for Zod schemas, JSON Schemas, and validation helper functions.

package/libs/instance-factories/validation/templates/zod/validation-generator.ts

@@ -0,0 +1,46 @@
+/**
+ * Zod Validation Generator Wrapper
+ *
+ * Wraps the existing generate-validation.js script for use with the
+ * implementation types system.
+ *
+ * NOTE: This is a wrapper around scripts/generate-validation.js
+ * TODO: Convert generate-validation.js to native TypeScript template generator
+ *       See zod-validation.yaml for conversion notes.
+ */
+
+import type { TemplateContext } from '@specverse/types';
+import { generateValidation } from '../../../../../scripts/generate-validation.js';
+
+/**
+ * Generate validation schemas by delegating to the existing generator
+ */
+export default function generateValidationSchemas(context: TemplateContext): string {
+  const { spec, implType, outputDir } = context;
+
+  if (!spec) {
+    throw new Error('Specification is required in template context');
+  }
+
+  // Extract configuration from implementation type
+  const config = implType.configuration || {};
+
+  const options = {
+    framework: config.framework || 'zod',
+    generateJsonSchema: config.generateJsonSchema !== false,
+    stripUnknown: config.stripUnknown !== false,
+    abortEarly: config.abortEarly || false
+  };
+
+  // Call the existing generator
+  const result = generateValidation(spec, outputDir || './validation', options);
+
+  // Return summary information
+  return JSON.stringify({
+    message: 'Validation schemas generated successfully',
+    modelCount: result.modelCount,
+    schemaCount: result.schemaCount,
+    outputDir: result.outputDir,
+    files: result.files
+  }, null, 2);
+}

package/libs/instance-factories/validation/zod.yaml

@@ -0,0 +1,56 @@
+name: ZodValidation
+version: "1.0.0"
+category: service
+description: "Zod schema generator for runtime validation with type inference"
+
+metadata:
+  author: "SpecVerse Team"
+  license: "MIT"
+  tags: [zod, validation, typescript, schema]
+
+compatibility:
+  specverse: ">=3.3.0"
+  node: ">=18.0.0"
+
+capabilities:
+  provides:
+    - "validation.runtime"
+    - "validation.zod"
+    - "validation.jsonschema"
+  requires: []  # Fixed: removed incorrect api.rest dependency
+
+technology:
+  runtime: "node"
+  language: "typescript"
+  framework: "zod"
+  validation: "zod"
+
+dependencies:
+  runtime:
+    - name: "zod"
+      version: "^3.22.0"
+  dev:
+    - name: "@types/node"
+      version: "^20.8.0"
+    - name: "typescript"
+      version: "^5.2.0"
+
+codeTemplates:
+  validation:
+    engine: typescript
+    generator: "libs/instance-factories/validation/templates/zod/validation-generator.ts"
+    outputPattern: "src/validation/{model}.validation.ts"
+
+configuration:
+  framework: "zod"
+  generateJsonSchema: true
+  stripUnknown: true
+  abortEarly: false
+
+# NOTE: This implementation type wraps the existing generate-validation.js script
+# TODO: Future enhancement - Convert generate-validation.js to native TypeScript template generator
+#       The current script generates Zod schemas, JSON schemas, and validation functions.
+#       Converting to native templates would require breaking it into multiple template files:
+#       - zod-schema-generator.ts (Zod schema definitions)
+#       - json-schema-generator.ts (JSON Schema for Fastify)
+#       - validation-function-generator.ts (validation helper functions)

package/libs/instance-factories/views/README.md

@@ -0,0 +1,62 @@
+# Views Factory
+
+React component generation from spec views with adapter support and routing.
+
+## Definition
+
+| File | Description |
+|------|-------------|
+| `react-components.yaml` | React 18 components with TypeScript, hooks, forms, and routing |
+
+## Generated Output
+
+### Components (`react/`)
+
+| Generator | Output | Purpose |
+|-----------|--------|---------|
+| `components-generator` | `frontend/src/components/{view}.tsx` | Direct React components from spec views (uses real model attributes) |
+| `forms-generator` | `frontend/src/components/forms/{model}Form.tsx` | Form components with react-hook-form and Zod validation |
+| `hooks-generator` | `frontend/src/hooks/use{model}.ts` | Custom hooks for data fetching and mutations |
+| `types-generator` | `frontend/src/types/{model}.ts` | TypeScript interfaces from spec models |
+| `app-generator` | `frontend/src/App.tsx` | Root component with React Query and Router setup |
+| `router-generator` | `frontend/src/router.tsx` | React Router v6 routes from spec views |
+| `router-generic-generator` | (alternative router) | Generic routing variant |
+| `main-tsx-generator` | `frontend/src/main.tsx` | React DOM render entry |
+| `vite-config-generator` | `frontend/vite.config.ts` | Vite bundler configuration |
+| `index-html-generator` | `frontend/index.html` | HTML shell |
+| `index-css-generator` | `frontend/src/index.css` | Base styles |
+| `frontend-package-json-generator` | `frontend/package.json` | Frontend dependencies |
+| `spec-json-generator` | (spec metadata) | Serialized spec for frontend consumption |
+| `views-metadata-generator` | (view metadata) | View definitions for runtime rendering |
+
+### Adapters (`react/adapters/`)
+
+| Adapter | UI Library |
+|---------|-----------|
+| `shadcn-adapter` | shadcn/ui |
+| `mui-adapter` | Material UI |
+| `antd-adapter` | Ant Design |
+
+### Shared Infrastructure (`shared/`)
+
+- `base-generator` — Abstract base class for all component generators
+- `adapter-types` — TypeScript types for UI library adapters
+- `property-mapper` — Maps spec properties to component props
+- `syntax-mapper` — Maps spec syntax to framework-specific JSX
+- `atomic-components-registry` — Registry of atomic UI components
+- `component-metadata` — Component metadata extraction
+- `composite-patterns` — Composite pattern support (master-detail, wizard, etc.)
+- `pattern-validator` — Validates view patterns against spec
+
+### Runtime (`runtime/`)
+
+- `runtime-view-renderer` — Dynamic view renderer from spec metadata
+
+## Technology
+
+- **Framework**: React ^18.2.0 with TypeScript
+- **Routing**: React Router ^6.18.0
+- **Data**: TanStack React Query ^5.0.0
+- **Forms**: react-hook-form ^7.48.0 + Zod ^3.22.0
+- **Bundler**: Vite ^5.0.0
+- **Styling**: Tailwind CSS (BEM class naming)

package/libs/instance-factories/views/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * View Instance Factories - Public API
+ *
+ * Exports all view generation and rendering components
+ */
+export * from './templates/shared/base-generator.js';
+export * from './templates/shared/property-mapper.js';
+export * from './templates/shared/syntax-mapper.js';
+export * from './templates/shared/component-metadata.js';
+export * from './templates/shared/adapter-types.js';
+export * from './templates/react/react-component-generator.js';
+export * from './templates/runtime/runtime-view-renderer.js';
+//# sourceMappingURL=index.d.ts.map

package/libs/instance-factories/views/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,cAAc,sCAAsC,CAAC;AACrD,cAAc,uCAAuC,CAAC;AACtD,cAAc,qCAAqC,CAAC;AACpD,cAAc,0CAA0C,CAAC;AACzD,cAAc,qCAAqC,CAAC;AAGpD,cAAc,gDAAgD,CAAC;AAG/D,cAAc,8CAA8C,CAAC"}

package/libs/instance-factories/views/index.js

@@ -0,0 +1,18 @@
+/**
+ * View Instance Factories - Public API
+ *
+ * Exports all view generation and rendering components
+ */
+// Shared components
+export * from './templates/shared/base-generator.js';
+export * from './templates/shared/property-mapper.js';
+export * from './templates/shared/syntax-mapper.js';
+export * from './templates/shared/component-metadata.js';
+export * from './templates/shared/adapter-types.js';
+// React generator
+export * from './templates/react/react-component-generator.js';
+// Runtime renderer
+export * from './templates/runtime/runtime-view-renderer.js';
+// Adapters registry (when we add adapters)
+// export * from './adapters/index.js';
+//# sourceMappingURL=index.js.map

package/libs/instance-factories/views/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,oBAAoB;AACpB,cAAc,sCAAsC,CAAC;AACrD,cAAc,uCAAuC,CAAC;AACtD,cAAc,qCAAqC,CAAC;AACpD,cAAc,0CAA0C,CAAC;AACzD,cAAc,qCAAqC,CAAC;AAEpD,kBAAkB;AAClB,cAAc,gDAAgD,CAAC;AAE/D,mBAAmB;AACnB,cAAc,8CAA8C,CAAC;AAE7D,2CAA2C;AAC3C,uCAAuC"}

package/libs/instance-factories/views/index.ts

@@ -0,0 +1,45 @@
+/**
+ * View Instance Factories - Public API
+ *
+ * Exports all view generation and rendering components
+ */
+
+// Shared components
+export {
+  BaseComponentGenerator,
+  ViewSpec,
+  StateDefinition,
+  EventDefinition,
+  UIComponent,
+  RenderContext,
+  GeneratorConfig,
+  extractComponentTypes,
+  countComponents,
+  validateNestingDepth
+} from './templates/shared/base-generator.js';
+
+export * from './templates/shared/property-mapper.js';
+export * from './templates/shared/syntax-mapper.js';
+export * from './templates/shared/component-metadata.js';
+export {
+  ATOMIC_COMPONENTS_REGISTRY,
+  AtomicComponentDefinition
+} from './templates/shared/atomic-components-registry.js';
+export {
+  ComponentAdapter,
+  ComponentLibraryAdapter,
+  ComponentMapping,
+  renderProps,
+  indent,
+  wrapWithChildren
+} from './templates/shared/adapter-types.js';
+
+// React generator
+export * from './templates/react/react-component-generator.js';
+
+// Runtime renderer - exported from @specverse/lang/views/runtime instead
+// (not compiled with libs because it has React dependencies)
+// export * from './templates/runtime/runtime-view-renderer.js';
+
+// Adapters registry (when we add adapters)
+// export * from './adapters/index.js';