@xemahq/create-biome 0.1.2 → 0.2.0

package/dist/lib/template-files.js

@@ -1,263 +1,514 @@
-import { BiomeTemplateId } from './template.js';
-export function renderTemplateFiles(templateId, ctx) {
-    switch (templateId) {
-        case BiomeTemplateId.Connector:
-            return renderConnectorTemplate(ctx);
-        case BiomeTemplateId.WorkflowsOnly:
-            return renderWorkflowsOnlyTemplate(ctx);
-    }
+import { apiNameForBiome } from './manifest-builder.js';
+function camelize(kebab) {
+    return kebab.replaceAll(/-([a-z0-9])/g, (_, ch) => ch.toUpperCase());
 }
-const TSCONFIG = `{
-  "extends": "../../tsconfig.base.json",
-  "compilerOptions": {
-    "outDir": "dist",
-    "rootDir": "src",
-    "module": "ESNext",
-    "moduleResolution": "Bundler"
-  },
-  "include": ["src/**/*.ts"]
+function pascalize(kebab) {
+    const camel = camelize(kebab);
+    return camel.charAt(0).toUpperCase() + camel.slice(1);
 }
-`;
-const GITIGNORE = `node_modules
-dist
-`;
-const VITEST_CONFIG = `import { defineConfig } from 'vitest/config';
+function constCase(kebab) {
+    return kebab.replaceAll('-', '_').toUpperCase();
+}
+function serverBiomeRootFiles(ctx) {
+    return {
+        'README.md': `# ${ctx.displayName}
 
-export default defineConfig({
-  test: {
-    environment: 'node',
-    include: ['src/**/*.test.ts'],
-  },
-});
-`;
-function readmeFor(ctx, summary) {
-    return `# ${ctx.displayName}
+${ctx.description}
+
+A first-party Xema **server biome** scaffolded by \`@xemahq/create-biome\`.
 
-${summary}
+## Layout
 
-## Develop
+- \`xema-biome.json\` — the biome manifest (validated by \`BiomeManifestSchema\` at boot).
+- \`api/${apiNameForBiome(ctx.biomeId)}/\` — the NestJS service this biome ships,
+  bootstrapped by \`XemaServiceModule.forBiome(...)\`.
+- \`skills/\` — Skill folder bundles (\`<slug>/SKILL.md\`) seeded into the agent runtime.
+- \`agents/\` — Agent definitions (\`<slug>.md\`); declare each in \`xema.agents[]\`.
+- \`contributions/\` — \`*.contribution.json\` envelopes (capabilities, etc.).
+- \`workspace-manifests/\` — \`<slug>.workspace.yaml\` agent workspace manifests.
+
+## After scaffolding
 
 \`\`\`sh
+# from the monorepo root
 pnpm install
-pnpm build
-pnpm test
+node tooling/codegen/generate-service-bootstrap.mjs   # emit the bootstrap descriptor
+pnpm refresh                                           # openapi -> client -> build
 \`\`\`
+`,
+        'skills/README.md': `# Skills
+
+Drop Skill folder bundles here, one per directory:
 
-## Manifest
+\`\`\`
+skills/<slug>/SKILL.md
+\`\`\`
 
-Edit \`xema-biome.json\` to adjust capabilities, integration requirements, or contributions.
-The Xema biome host validates the manifest on boot — fail-fast errors point at the field to fix.
+\`SKILL.md\` is the only strict file (YAML frontmatter \`name\` + \`description\`,
+then a free-form markdown body). \`reference/\`, \`scripts/\`, and \`assets/\` are
+optional and mounted as-is. \`scope\` and \`phases\` are NOT frontmatter — they
+are server-resolved.
+`,
+        'agents/README.md': `# Agents
 
-## Publish
+Drop agent definitions here, one \`<slug>.md\` per agent. Each agent MUST also
+be declared in \`xema-biome.json\` under \`xema.agents[]\` (\`slug\` + \`mode\`) AND
+\`xema.ships.content\` must include \`"agents"\` — the boot-time cross-validator
+enforces parity between the manifest roster and the on-disk files.
+`,
+        'contributions/.gitkeep': '',
+        'workspace-manifests/README.md': `# Workspace manifests
 
-Biomes are npm packages. Set the version in \`package.json\` and publish to your registry.
-Operators install them on Xema by adding \`@xemahq-biomes/${ctx.biomeId}\` to their org's biome catalog.
-`;
+Drop agent workspace manifests here, one \`<slug>.workspace.yaml\` per agent
+workspace. See \`xema://manifest/primary-agent-base\` for the base to extend.
+`,
+    };
 }
-function renderConnectorTemplate(ctx) {
+function serverApiFiles(ctx) {
+    const apiName = apiNameForBiome(ctx.biomeId);
+    const apiDir = `api/${apiName}`;
+    const constName = `${constCase(apiName)}_BOOTSTRAP`;
+    const pascal = pascalize(ctx.biomeId);
+    const featureModule = `${pascal}Module`;
+    const featureController = `${pascal}Controller`;
+    const featureService = `${pascal}Service`;
     return {
-        'tsconfig.json': TSCONFIG,
-        '.gitignore': GITIGNORE,
-        'vitest.config.ts': VITEST_CONFIG,
-        'README.md': readmeFor(ctx, 'Integration provider biome scaffolded by `@xemahq/create-biome`. Ships a webhook verifier, event mapper, credential kind declaration, and a placeholder resource lister. Replace the placeholders with calls into the upstream provider SDK.'),
-        'contracts/index.ts': renderContractsIndex(ctx),
-        'agents/index.ts': renderAgentsIndex(ctx),
-        'src/integration-provider/index.ts': renderProviderModuleSource(ctx),
-        'src/integration-provider/index.test.ts': renderProviderModuleTest(ctx),
-        'test/manifest.test.ts': renderManifestTest(ctx),
+        [`${apiDir}/package.json`]: `${JSON.stringify({
+            name: apiName,
+            version: '0.1.0',
+            private: true,
+            scripts: {
+                clean: 'rm -rf dist',
+                build: 'nest build',
+                format: 'prettier --write "src/**/*.ts"',
+                start: 'nest start',
+                'start:dev': 'nest start --watch',
+                lint: 'eslint "src/**/*.ts"',
+                'lint:fix': 'eslint "src/**/*.ts" --fix',
+                typecheck: 'tsc --noEmit',
+                openapi: 'NODE_PATH=node_modules xema-openapi',
+                'client:generate': 'xema-client-generate',
+            },
+            dependencies: {
+                '@nestjs/common': 'catalog:',
+                '@nestjs/config': 'catalog:',
+                '@nestjs/core': 'catalog:',
+                '@nestjs/platform-express': 'catalog:',
+                '@nestjs/swagger': 'catalog:',
+                '@xemahq/identity-client': 'catalog:',
+                '@xemahq/kernel-contracts': 'catalog:',
+                '@xemahq/platform-common': 'catalog:',
+                '@xemahq/service-registry-nest': 'catalog:',
+                '@xemahq/xema-decorators': 'catalog:',
+                '@xemahq/xema-service-nest': 'catalog:',
+                'class-transformer': 'catalog:',
+                'class-validator': 'catalog:',
+                'reflect-metadata': 'catalog:',
+                rxjs: 'catalog:',
+                'swagger-ui-express': 'catalog:',
+            },
+            devDependencies: {
+                '@eslint/js': 'catalog:',
+                '@nestjs/cli': 'catalog:',
+                '@nestjs/schematics': 'catalog:',
+                '@types/express': 'catalog:',
+                '@types/node': 'catalog:',
+                '@xemahq/api-client-generator': 'catalog:',
+                dotenv: 'catalog:',
+                eslint: 'catalog:',
+                'eslint-config-prettier': 'catalog:',
+                orval: 'catalog:',
+                prettier: 'catalog:',
+                typescript: 'catalog:',
+                'typescript-eslint': 'catalog:',
+            },
+            xema: {
+                api: {
+                    serviceId: apiName,
+                    biomeId: ctx.biomeId,
+                    title: `${ctx.displayName} API`,
+                    description: ctx.description,
+                },
+            },
+        }, null, 2)}\n`,
+        [`${apiDir}/tsconfig.json`]: `${JSON.stringify({
+            extends: '../../../../tsconfig.base.json',
+            compilerOptions: {
+                outDir: 'dist',
+                rootDir: 'src',
+                types: ['node'],
+                baseUrl: '.',
+            },
+            include: ['src/**/*.ts'],
+            exclude: ['node_modules', 'dist'],
+        }, null, 2)}\n`,
+        [`${apiDir}/nest-cli.json`]: `${JSON.stringify({
+            $schema: 'https://json.schemastore.org/nest-cli',
+            collection: '@nestjs/schematics',
+            sourceRoot: 'src',
+            compilerOptions: {
+                deleteOutDir: true,
+                plugins: [
+                    {
+                        name: '@nestjs/swagger',
+                        options: {
+                            classValidatorShim: true,
+                            introspectComments: true,
+                        },
+                    },
+                ],
+            },
+        }, null, 2)}\n`,
+        [`${apiDir}/.gitignore`]: `node_modules
+dist
+.turbo
+openapi.*.json
+`,
+        [`${apiDir}/src/generated/${apiName}.bootstrap.generated.ts`]: renderBootstrapPlaceholder(apiName, constName, `${ctx.displayName} API`, ctx.biomeId),
+        [`${apiDir}/src/main.ts`]: renderMainTs(apiName, ctx),
+        [`${apiDir}/src/app.module.ts`]: renderAppModule(apiName, constName, featureModule),
+        [`${apiDir}/src/config/index.ts`]: renderConfigIndex(),
+        [`${apiDir}/src/health/health.module.ts`]: HEALTH_MODULE,
+        [`${apiDir}/src/health/health.controller.ts`]: HEALTH_CONTROLLER,
+        [`${apiDir}/src/${ctx.biomeId}/${ctx.biomeId}.module.ts`]: renderFeatureModule(ctx.biomeId, featureModule, featureController, featureService),
+        [`${apiDir}/src/${ctx.biomeId}/${ctx.biomeId}.controller.ts`]: renderFeatureController(ctx.biomeId, featureController, featureService),
+        [`${apiDir}/src/${ctx.biomeId}/${ctx.biomeId}.service.ts`]: renderFeatureService(ctx.biomeId, featureService),
     };
 }
-function renderContractsIndex(_ctx) {
-    return `// Biome-local contract types. Export shared types used by both the
-// integration provider and any activity handlers shipped with this biome.
-export {};
+function renderBootstrapPlaceholder(apiName, constName, displayName, biomeId) {
+    return `// AUTO-GENERATED by tooling/codegen/generate-service-bootstrap.mjs — DO NOT EDIT.
+// Source of truth: biomes/${biomeId}/xema-biome.json (xema.ships.apis[] + top-level version).
+// Regenerate: \`node tooling/codegen/generate-service-bootstrap.mjs\`.
+import {
+  ServiceKind,
+  type BiomeServiceDescriptor,
+} from '@xemahq/xema-service-nest';
+
+/**
+ * Bootstrap identity for ${apiName}, consumed by
+ * \`XemaServiceModule.forBiome(${constName})\`. Edit the biome manifest,
+ * not this file.
+ */
+export const ${constName}: BiomeServiceDescriptor = {
+  name: '${apiName}',
+  semver: '0.1.0',
+  serviceKind: ServiceKind.BiomeApi,
+  displayName: '${displayName}',
+  requiresServices: ['identity-api'],
+  exposesCapabilities: [],
+};
 `;
 }
-function renderAgentsIndex(_ctx) {
-    return `// Agent definitions contributed by this biome. Export agent config
-// objects that the biome host registers with llm-registry-api on boot.
-export {};
+function renderMainTs(apiName, ctx) {
+    return `import { bootstrapXemaService } from '@xemahq/xema-service-nest';
+
+import { AppModule } from './app.module';
+import { requiredEnvVars } from './config';
+
+const swaggerDescription = \`
+${ctx.description}
+\`.trim();
+
+void bootstrapXemaService({
+  appModule: AppModule,
+  serviceName: '${apiName}',
+  swaggerTitle: '${ctx.displayName} API',
+  swaggerDescription,
+  requiredEnvVars,
+});
 `;
 }
-function renderProviderModuleSource(ctx) {
-    return `import {
-  adapterError,
-  defineIntegrationProvider,
-  err,
-  ok,
-  type EventMapper,
-  type IdempotencyKeyExtractor,
-  type IntegrationProviderModule,
-  type WebhookVerifier,
-} from '@xemahq/biome-sdk/adapter';
-import {
-  BuiltInAdapterKind,
-  CredentialFieldTransform,
-  CredentialFieldType,
-  CredentialKind,
-  IntegrationOnboardingKind,
-  ProjectBindingAdapterKey,
-  type ProviderOnboardingManifest,
-} from '@xemahq/kernel-contracts/connector';
-
-// Replace the placeholder verifier below with the real signature
-// algorithm your provider uses. The kernel ships hmac-sha256,
-// hmac-sha1, ed25519, and 'none' (static-token); biomes re-use the
-// same primitive so the registry never has to know provider-specific
-// details.
-const verifier: WebhookVerifier = {
-  signatureHeader: 'x-${ctx.biomeId}-signature',
-  algorithm: 'hmac-sha256',
-  secretSource: 'org-integration-secret',
-  verify(_input) {
-    return err(
-      adapterError('internal', 'replace this with a real verify() before shipping'),
-    );
-  },
-};
-
-const eventMapper: EventMapper = {
-  map({ rawEvent, headers }) {
-    // Discriminate on the provider's event header or payload field,
-    // then map onto the canonical envelope for your AdapterKind.
-    if (!rawEvent || typeof rawEvent !== 'object') {
-      return err(adapterError('malformed-payload', 'event body is not an object'));
-    }
-    // \`headers\` is lower-cased; useful when the discriminator lives
-    // on a header instead of the payload.
-    void headers;
-    return ok(null);
-  },
-};
+function renderAppModule(apiName, constName, featureModule) {
+    const featureFile = featureModule
+        .replace(/Module$/, '')
+        .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+        .toLowerCase();
+    return `import { Module } from '@nestjs/common';
+import { ConfigModule } from '@nestjs/config';
+import { APP_INTERCEPTOR } from '@nestjs/core';
+import { ResponseEnvelopeInterceptor } from '@xemahq/platform-common';
+import { XemaServiceModule } from '@xemahq/xema-service-nest';
 
-const idempotencyKeyExtractor: IdempotencyKeyExtractor = ({ headers }) => {
-  const id = headers['x-${ctx.biomeId}-delivery'];
-  if (typeof id === 'string' && id.length > 0) {return \`${ctx.biomeId}:\${id}\`;}
-  return \`${ctx.biomeId}:fallback:\${Date.now().toString(36)}\`;
-};
+import { appConfig } from './config';
+import { ${constName} } from './generated/${apiName}.bootstrap.generated';
+import { HealthModule } from './health/health.module';
+import { ${featureModule} } from './${featureFile}/${featureFile}.module';
 
-// Install-wizard onboarding manifest. Declares the "Connect" surface
-// the frontend renders for this provider — display copy, icon, and the
-// credential field schema (or APP_INSTALL launch copy for app-install
-// providers). Replace placeholder strings before shipping.
-const onboarding: ProviderOnboardingManifest = {
-  provider: '${ctx.biomeId}',
-  displayName: '${ctx.displayName}',
-  description: 'Replace this with a one-sentence provider description.',
-  iconName: 'Globe',
-  kind: IntegrationOnboardingKind.CREDENTIALS,
-  // Declare which project-binding adapter kinds your provider supports.
-  // Keep this list explicit — an empty array means the provider has no
-  // project-level bindings today and the project Bind dialog will hide
-  // it. Available keys: SCM, TRACKER, DOCUMENTATION.
-  supportedProjectBindingAdapterKinds: [] as readonly ProjectBindingAdapterKey[],
-  fields: [
-    {
-      key: 'apiToken',
-      label: 'API Token',
-      type: CredentialFieldType.PASSWORD,
-      required: true,
-      placeholder: 'Paste the provider API token',
-      transform: CredentialFieldTransform.TRIM,
-    },
+@Module({
+  imports: [
+    ConfigModule.forRoot({ isGlobal: true, load: [appConfig] }),
+    // One-call platform bootstrap: Service Registry + Identity bootstrap +
+    // Auth (JWT + request context) + the runtime route/capability scanner.
+    // Service identity is the single source of truth in xema-biome.json,
+    // surfaced via the generated descriptor.
+    XemaServiceModule.forBiome(${constName}),
+    HealthModule,
+    ${featureModule},
   ],
-  hint: 'Issue a token under your provider settings — minimum scopes documented in the biome README.',
-};
+  providers: [
+    { provide: APP_INTERCEPTOR, useClass: ResponseEnvelopeInterceptor },
+  ],
+})
+export class AppModule {}
+`;
+}
+function renderConfigIndex() {
+    return `import { registerAs } from '@nestjs/config';
 
-export const ${camelize(ctx.biomeId)}ProviderModule: IntegrationProviderModule = defineIntegrationProvider({
-  adapterKind: BuiltInAdapterKind.Tracker,
-  provider: '${ctx.biomeId}',
-  displayName: '${ctx.displayName}',
-  webhook: {
-    verifier,
-    eventMapper,
-    idempotencyKeyExtractor,
-  },
-  credentialKind: CredentialKind.OAuthUser,
-  resources: {},
-  actions: {},
-  onboarding,
-});
+/**
+ * Environment variables this service requires at boot. \`bootstrapXemaService\`
+ * fail-fasts if any is missing. The platform bootstrap injects the registry /
+ * identity wiring; add service-specific required vars here as the biome grows.
+ */
+export const requiredEnvVars: readonly string[] = ['IDENTITY_API_URL'];
 
-export default [${camelize(ctx.biomeId)}ProviderModule];
+export const appConfig = registerAs('app', () => ({
+  port: Number(process.env.PORT ?? '3000'),
+}));
 `;
 }
-function renderProviderModuleTest(ctx) {
-    return `import { describe, expect, it } from 'vitest';
+const HEALTH_MODULE = `import { Module } from '@nestjs/common';
 
-import { ${camelize(ctx.biomeId)}ProviderModule } from './index.js';
+import { HealthController } from './health.controller';
 
-describe('${ctx.displayName} provider module', () => {
-  it('declares an adapter kind and a provider slug', () => {
-    expect(${camelize(ctx.biomeId)}ProviderModule.provider).toBe('${ctx.biomeId}');
-    expect(${camelize(ctx.biomeId)}ProviderModule.adapterKind).toBeTruthy();
-  });
-});
+@Module({ controllers: [HealthController] })
+export class HealthModule {}
 `;
+const HEALTH_CONTROLLER = `import { Controller, Get } from '@nestjs/common';
+import { XemaPublicRoute } from '@xemahq/xema-decorators';
+
+@Controller('health')
+export class HealthController {
+  @Get('live')
+  @XemaPublicRoute()
+  live(): { status: 'ok' } {
+    return { status: 'ok' };
+  }
+
+  @Get('ready')
+  @XemaPublicRoute()
+  ready(): { status: 'ok' } {
+    return { status: 'ok' };
+  }
 }
-function renderManifestTest(ctx) {
-    return `import { describe, expect, it } from 'vitest';
-import { readFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import { BiomeManifestSchema } from '@xemahq/kernel-contracts/biome';
-
-describe('xema-biome.json', () => {
-  it('parses against the BiomeManifestSchema', async () => {
-    const raw = await readFile(join(import.meta.dirname, '..', 'xema-biome.json'), 'utf8');
-    const parsed = BiomeManifestSchema.safeParse(JSON.parse(raw));
-    if (!parsed.success) {
-      throw new Error(\`xema-biome.json validation failed:\\n\${JSON.stringify(parsed.error.issues, null, 2)}\`);
-    }
-    expect(parsed.data.id).toBe('${ctx.biomeId}');
-  });
-});
+`;
+function renderFeatureModule(biomeId, featureModule, featureController, featureService) {
+    const file = biomeId;
+    return `import { Module } from '@nestjs/common';
+
+import { ${featureController} } from './${file}.controller';
+import { ${featureService} } from './${file}.service';
+
+@Module({
+  controllers: [${featureController}],
+  providers: [${featureService}],
+})
+export class ${featureModule} {}
 `;
 }
-function renderWorkflowsOnlyTemplate(ctx) {
-    return {
-        'tsconfig.json': TSCONFIG,
-        '.gitignore': GITIGNORE,
-        'vitest.config.ts': VITEST_CONFIG,
-        'README.md': readmeFor(ctx, 'Workflow-only biome scaffolded by `@xemahq/create-biome`. Ships YAML workflows under `workflow-config/` plus an empty TS shell for activity handlers.'),
-        'contracts/index.ts': renderContractsIndex(ctx),
-        'agents/index.ts': renderAgentsIndex(ctx),
-        'workflow-config/workflows/sample.yaml': renderSampleWorkflow(ctx),
-        'src/index.ts': `// Biomes without modules export an empty placeholder. Add typed
-// helpers here if your YAML workflows reference custom activities.
-// defineBiome() will be called here once you add contributions.
-export {};
-`,
-        'src/index.test.ts': `import { describe, it, expect } from 'vitest';
+function renderFeatureController(biomeId, featureController, featureService) {
+    const file = biomeId;
+    const serviceVar = camelize(biomeId);
+    return `import { Controller, Get } from '@nestjs/common';
+import { ApiOkResponse, ApiTags } from '@nestjs/swagger';
+import { XemaRoute } from '@xemahq/xema-decorators';
 
-describe('${ctx.displayName}', () => {
-  it('boots', () => {
-    expect(true).toBe(true);
-  });
-});
-`,
-        'test/manifest.test.ts': renderManifestTest(ctx),
+import { ${featureService} } from './${file}.service';
+import { ${pascalizeForDto(biomeId)}StatusDto } from './${file}.service';
+
+@ApiTags('${biomeId}')
+@Controller('${biomeId}')
+export class ${featureController} {
+  constructor(private readonly ${serviceVar}Service: ${featureService}) {}
+
+  @Get('status')
+  @XemaRoute()
+  @ApiOkResponse({ type: ${pascalizeForDto(biomeId)}StatusDto })
+  status(): ${pascalizeForDto(biomeId)}StatusDto {
+    return this.${serviceVar}Service.status();
+  }
+}
+`;
+}
+function pascalizeForDto(biomeId) {
+    return pascalize(biomeId);
+}
+function renderFeatureService(biomeId, featureService) {
+    const pascal = pascalize(biomeId);
+    return `import { Injectable } from '@nestjs/common';
+import { ApiProperty } from '@nestjs/swagger';
+
+/** Sample response DTO — replace with the biome's real domain types. */
+export class ${pascal}StatusDto {
+  @ApiProperty({ example: '${biomeId}' })
+  biome!: string;
+
+  @ApiProperty({ example: 'ok' })
+  status!: string;
+}
+
+@Injectable()
+export class ${featureService} {
+  status(): ${pascal}StatusDto {
+    return { biome: '${biomeId}', status: 'ok' };
+  }
+}
+`;
+}
+export function webBiomeFiles(ctx) {
+    const pageComponent = `${pascalize(ctx.biomeId)}Page`;
+    const navId = ctx.biomeId;
+    return {
+        'package.json': `${JSON.stringify({
+            name: `@xemahq/biomes-${ctx.webBiomeId}`,
+            version: '0.1.0',
+            description: ctx.description,
+            license: 'Apache-2.0',
+            private: true,
+            type: 'module',
+            main: 'src/index.tsx',
+            types: 'src/index.tsx',
+            files: ['src', 'xema-biome.json'],
+            scripts: {
+                typecheck: 'tsc --noEmit',
+                lint: 'tsc --noEmit',
+                format: 'prettier --write "src/**/*.{ts,tsx}"',
+            },
+            peerDependencies: {
+                '@tanstack/react-query': '^5.0.0',
+                react: '^18.3.1',
+                'react-dom': '^18.3.1',
+            },
+            devDependencies: {
+                '@tanstack/react-query': '^5.83.0',
+                '@types/react': '^18.3.0',
+                '@types/react-dom': '^18.3.0',
+                'lucide-react': '^0.462.0',
+                prettier: '3.6.2',
+                react: '^18.3.1',
+                'react-dom': '^18.3.1',
+                typescript: '5.9.3',
+            },
+        }, null, 2)}\n`,
+        'tsconfig.json': WEB_TSCONFIG,
+        'src/index.tsx': renderWebIndex(ctx, pageComponent, navId),
+        [`src/pages/${pageComponent}.tsx`]: renderWebPage(ctx, pageComponent),
     };
 }
-function renderSampleWorkflow(ctx) {
-    return `id: ${ctx.biomeId}-sample
-name: ${ctx.displayName} sample workflow
-on:
-  manual:
-    inputs:
-      message:
-        type: string
-        required: true
-jobs:
-  log:
-    steps:
-      - id: emit
-        uses: xema/log@v1
-        with:
-          level: info
-          message: \${{ inputs.message }}
+const WEB_TSCONFIG = `{
+  "compilerOptions": {
+    "target": "ES2022",
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "jsx": "react-jsx",
+    "noEmit": true,
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "allowSyntheticDefaultImports": true,
+    "isolatedModules": true,
+    "useDefineForClassFields": true,
+    // Mirror the HOST root tsconfig — biome sources import host primitives
+    // authored under the host's compiler flags.
+    "exactOptionalPropertyTypes": false,
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["../../../src/*"],
+      "@xemahq/ui-kernel": ["../../../src/lib/shared/ui-kernel/index.ts"],
+      "@xemahq/ui-kernel/*": ["../../../src/lib/shared/ui-kernel/*"],
+      "@xemahq/*": ["../../../src/lib/shared/*", "../../../src/lib/api/orval/clients/*"]
+    }
+  },
+  "include": ["src/**/*.ts", "src/**/*.tsx"]
+}
+`;
+function renderWebIndex(ctx, pageComponent, navId) {
+    return `import {
+  type FrontendBiome,
+  type FrontendBiomeFactory,
+  type HostBridge,
+} from '@xemahq/ui-kernel';
+import { LayoutGrid } from 'lucide-react';
+import { Suspense, createElement, lazy } from 'react';
+
+// Lazy-load the page so its dependency graph is fetched only when the user
+// navigates into the route, not at biome registration.
+const ${pageComponent} = lazy(() => import('./pages/${pageComponent}'));
+
+/**
+ * Frontend module entry-point for the \`${ctx.webBiomeId}\` biome.
+ *
+ * The host bootstrap fetches \`GET /platform/biomes/web\`, dynamically imports
+ * this module for any entry where \`enabled === true\`, then calls this default
+ * export with its concrete \`HostBridge\` and registers the result via
+ * \`registerFrontendBiome()\` from \`@xemahq/ui-kernel\`.
+ */
+const ${camelize(ctx.webBiomeId)}Biome: FrontendBiomeFactory = (
+  _bridge: HostBridge,
+): FrontendBiome => {
+  return {
+    id: '${ctx.webBiomeId}',
+    displayName: '${ctx.navLabel}',
+    navItems: [
+      {
+        id: '${navId}',
+        label: '${ctx.navLabel}',
+        route: '${navId}',
+        icon: LayoutGrid,
+        section: 'Workspace',
+        weight: 50,
+      },
+    ],
+    routes: [
+      {
+        path: '${navId}',
+        projectScoped: true,
+        element: () =>
+          createElement(
+            Suspense,
+            { fallback: null },
+            createElement(${pageComponent}),
+          ),
+      },
+    ],
+  };
+};
+
+export default ${camelize(ctx.webBiomeId)}Biome;
 `;
 }
-function camelize(kebab) {
-    return kebab.replaceAll(/-([a-z0-9])/g, (_, ch) => ch.toUpperCase());
+function renderWebPage(ctx, pageComponent) {
+    return `import { useBiomeRouteParams } from '@/lib/biomes/biome-host-next';
+
+/**
+ * Sample project-scoped page for the \`${ctx.webBiomeId}\` biome. Reads the
+ * project id bound by the biome route matcher via the host
+ * \`useBiomeRouteParams\` bridge hook (NEVER \`next/navigation\` — biome pages
+ * must go through the host's route-params context).
+ */
+export default function ${pageComponent}(): JSX.Element {
+  const { projectId } = useBiomeRouteParams<{ projectId?: string }>();
+
+  return (
+    <div className="p-6">
+      <h1 className="text-xl font-semibold">${ctx.navLabel}</h1>
+      <p className="mt-2 text-sm text-muted-foreground">
+        ${ctx.description}
+      </p>
+      <p className="mt-4 text-sm">
+        Project scope:{' '}
+        <code>{projectId ?? '(none — open from a project)'}</code>
+      </p>
+    </div>
+  );
+}
+`;
+}
+export function renderServerBiomeFiles(ctx) {
+    return {
+        ...serverBiomeRootFiles(ctx),
+        ...serverApiFiles(ctx),
+    };
 }
 //# sourceMappingURL=template-files.js.map