@forinda/kickjs-cli 5.8.1 → 5.8.3

package/dist/generator-extension-ChoCJW23.mjs

@@ -1,3072 +0,0 @@
-/**
- * @forinda/kickjs-cli v5.8.1
- *
- * Copyright (c) Felix Orinda
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- * @license MIT
- */
-import{t as e}from"./project-root-BaUzB3D7.mjs";import{createRequire as t}from"node:module";import{dirname as n,extname as r,join as i,resolve as a}from"node:path";import{existsSync as o,readFileSync as s}from"node:fs";import{access as c,mkdir as l,readFile as u,writeFile as d}from"node:fs/promises";import*as f from"@clack/prompts";import p from"picocolors";import m from"pluralize";import{execFileSync as h,execSync as g}from"node:child_process";import{fileURLToPath as _,pathToFileURL as v}from"node:url";let y=!1;function ee(e){y=e}const te=new Set([`.ts`,`.tsx`,`.js`,`.jsx`,`.mjs`,`.cjs`,`.json`,`.md`]);async function b(e,t){y||(await l(n(e),{recursive:!0}),await d(e,t,`utf-8`),te.has(r(e))&&await re(e,t).catch(()=>{}))}let x;async function ne(e){if(x!==void 0)return x;try{x=await import(t(i(e,`package.json`)).resolve(`oxfmt`))}catch{x=null}return x}async function re(e,t){let n=await ne(process.cwd());if(!n)return;let r=await ie(e);if(r===null)return;let i=await n.format(e,t,r);i.code!==t&&await d(e,i.code,`utf-8`)}const S=new Map;async function ie(e){let t=n(e),r=t;if(S.has(r))return S.get(r);for(;;){let e=i(t,`.oxfmtrc.json`);if(o(e))try{let t=await u(e,`utf-8`),n=JSON.parse(t);return delete n.$schema,delete n.ignorePatterns,S.set(r,n),n}catch{return S.set(r,null),null}let a=n(t);if(a===t)return S.set(r,null),null;t=a}}async function C(e){try{return await c(e),!0}catch{return!1}}const ae={GET:p.green,POST:p.cyan,PUT:p.yellow,PATCH:p.magenta,DELETE:p.red};function oe(e){return(ae[e]??p.dim)(e.padEnd(7))}function se(e){let t=`[${e}]`.padEnd(10);switch(e){case`CRITICAL`:return p.red(t);case`WARNING`:return p.yellow(t);case`INFO`:return p.blue(p.dim(t));default:return t}}p.green(`✓`),p.red(`✖`),p.yellow(`⚠`),p.blue(`ℹ`);function ce(e){f.intro(p.bgCyan(p.black(` ${e} `)))}function le(e){f.outro(e)}function w(e){f.isCancel(e)&&(f.cancel(`Operation cancelled.`),process.exit(0))}async function ue(e){let t=await f.text(e);return w(t),t}async function de(e){let t=await f.select(e);return w(t),t}async function fe(e){let t=await f.multiselect(e);return w(t),t}async function T(e){let t=await f.confirm(e);return w(t),t}function pe(){return f.spinner()}const E=f.log;function D(e){return e.replace(/[-_\s]+(.)?/g,(e,t)=>t?t.toUpperCase():``).replace(/^(.)/,e=>e.toUpperCase())}function O(e){let t=D(e);return t.charAt(0).toLowerCase()+t.slice(1)}function k(e){return e.replace(/([a-z])([A-Z])/g,`$1-$2`).replace(/[\s_]+/g,`-`).toLowerCase()}function A(e){return m.plural(e)}function me(e){return m.plural(e)}function j(e){return e.replace(/[.*+?^${}()|[\]\\]/g,`\\$&`)}const he={inmemory:`in-memory`,drizzle:`Drizzle`,prisma:`Prisma`};function M(e){return e.charAt(0).toUpperCase()+e.slice(1).replace(/-([a-z])/g,(e,t)=>t.toUpperCase())}function ge(e){return e.replace(/([a-z])([A-Z])/g,`$1-$2`).toLowerCase()}function N(e){return he[e]??M(e)}function P(e,t,n){let r={inmemory:`InMemory${e}Repository`,drizzle:`Drizzle${e}Repository`,prisma:`Prisma${e}Repository`},i={inmemory:`in-memory-${t}`,drizzle:`drizzle-${t}`,prisma:`prisma-${t}`};return{repoClass:r[n]??`${M(n)}${e}Repository`,repoFile:i[n]??`${ge(n)}-${t}`}}function F(e){return e??`define`}function _e(e){let{pascal:t,kebab:n,plural:r=``,repo:i,style:a}=e,{repoClass:o,repoFile:s}=P(t,n,i),c=F(a),l=`/**
- * ${t} Module
- *
- * Self-contained feature module following Domain-Driven Design (DDD).
- * Registers dependencies in the DI container and declares HTTP routes.
- *
- * Structure:
- *   presentation/    — HTTP controllers (entry points)
- *   application/     — Use cases (orchestration) and DTOs (validation)
- *   domain/          — Entities, value objects, repository interfaces, domain services
- *   infrastructure/  — Repository implementations (currently ${N(i)})
- */`,u=`import { ${t.toUpperCase()}_REPOSITORY } from './domain/repositories/${n}.repository'
-import { ${o} } from './infrastructure/repositories/${s}.repository'
-import { ${t}Controller } from './presentation/${n}.controller'
-
-// Eagerly load decorated classes so @Service()/@Repository() decorators register in the DI container
-import.meta.glob(
-  ['./domain/services/**/*.ts', './application/use-cases/**/*.ts', '!./**/*.test.ts'],
-  { eager: true },
-)`,d=`    /**
-     * Declare HTTP routes for this module. Return value shape:
-     *
-     *   - \`path\`        — URL prefix for this route set, mounted under
-     *                     \`/{apiPrefix}/v{version}{path}\`.
-     *   - \`controller\`  — Controller class. Used both for the route
-     *                     handler bindings and OpenAPI spec generation.
-     *   - \`version\`     — Optional. Overrides the app-wide API version
-     *                     for this route set only.
-     *
-     * Return an **array** to mount multiple route sets under the
-     * same module (e.g. side-by-side v1 + v2 controllers):
-     *
-     *   return [
-     *     { path: '/${r}', version: 1, controller: ${t}V1Controller },
-     *     { path: '/${r}', version: 2, controller: ${t}V2Controller },
-     *   ]
-     */`;return c===`class`?`${l}
-import { Container, type AppModule, type ModuleRoutes } from '@forinda/kickjs'
-${u}
-
-export class ${t}Module implements AppModule {
-  /**
-   * Register module dependencies in the DI container.
-   * Bind repository interface tokens to their implementations here.
-   * Currently wired to ${N(i)}. To swap implementations, change the factory target.
-   */
-  register(container: Container): void {
-    container.registerFactory(${t.toUpperCase()}_REPOSITORY, () =>
-      container.resolve(${o}),
-    )
-  }
-
-${d.replace(/^ {4}/gm,`  `).replace(/^ {6}/gm,`    `)}
-  routes(): ModuleRoutes {
-    return {
-      path: '/${r}',
-      controller: ${t}Controller,
-    }
-  }
-}
-`:`${l}
-import { defineModule } from '@forinda/kickjs'
-${u}
-
-export const ${t}Module = defineModule({
-  name: '${t}Module',
-  build: () => ({
-    /**
-     * Register module dependencies in the DI container.
-     * Bind repository interface tokens to their implementations here.
-     * Currently wired to ${N(i)}. To swap implementations, change the factory target.
-     */
-    register(container) {
-      container.registerFactory(${t.toUpperCase()}_REPOSITORY, () =>
-        container.resolve(${o}),
-      )
-    },
-
-${d}
-    routes() {
-      return {
-        path: '/${r}',
-        controller: ${t}Controller,
-      }
-    },
-  }),
-})
-`}function ve(e){let{pascal:t,kebab:n,plural:r=``,repo:i,style:a}=e,{repoClass:o,repoFile:s}=P(t,n,i),c=F(a),l=`/**
- * ${t} Module
- *
- * REST module with a flat folder structure.
- * Controller delegates to service, service wraps the repository.
- *
- * Structure:
- *   ${n}.controller.ts  — HTTP routes (CRUD)
- *   ${n}.service.ts     — Business logic
- *   ${n}.repository.ts  — Repository interface
- *   ${s}.repository.ts — Repository implementation
- *   dtos/                   — Request/response schemas
- */`,u=`import { ${t.toUpperCase()}_REPOSITORY } from './${n}.repository'
-import { ${o} } from './${s}.repository'
-import { ${t}Controller } from './${n}.controller'
-
-// Eagerly load decorated classes so @Service()/@Repository() decorators register in the DI container
-import.meta.glob(['./**/*.service.ts', './**/*.repository.ts', '!./**/*.test.ts'], { eager: true })`,d=`    /**
-     * Declare HTTP routes for this module. Return value shape:
-     *
-     *   - \`path\`        — URL prefix for this route set.
-     *   - \`controller\`  — Controller class (also drives OpenAPI).
-     *   - \`version\`     — Optional. Overrides the app-wide API version.
-     *
-     * Return an **array** to mount multiple route sets — admin
-     * surfaces, side-by-side v1 + v2 controllers, etc:
-     *
-     *   return [
-     *     { path: '/${r}', version: 1, controller: ${t}V1Controller },
-     *     { path: '/${r}', version: 2, controller: ${t}V2Controller },
-     *   ]
-     */`;return c===`class`?`${l}
-import { Container, type AppModule, type ModuleRoutes } from '@forinda/kickjs'
-${u}
-
-export class ${t}Module implements AppModule {
-  register(container: Container): void {
-    container.registerFactory(${t.toUpperCase()}_REPOSITORY, () =>
-      container.resolve(${o}),
-    )
-  }
-
-${d.replace(/^ {4}/gm,`  `).replace(/^ {6}/gm,`    `)}
-  routes(): ModuleRoutes {
-    return {
-      path: '/${r}',
-      controller: ${t}Controller,
-    }
-  }
-}
-`:`${l}
-import { defineModule } from '@forinda/kickjs'
-${u}
-
-export const ${t}Module = defineModule({
-  name: '${t}Module',
-  build: () => ({
-    register(container) {
-      container.registerFactory(${t.toUpperCase()}_REPOSITORY, () =>
-        container.resolve(${o}),
-      )
-    },
-
-${d}
-    routes() {
-      return {
-        path: '/${r}',
-        controller: ${t}Controller,
-      }
-    },
-  }),
-})
-`}function ye(e){let{pascal:t,kebab:n,plural:r=``,style:i}=e,a=F(i),o=`    /**
-     * Declare HTTP routes. Return value shape:
-     *
-     *   - \`path\`        — URL prefix for this route set.
-     *   - \`controller\`  — Controller class (also drives OpenAPI).
-     *   - \`version\`     — Optional. Overrides the app-wide API version.
-     *
-     * Return an array to mount multiple route sets:
-     *
-     *   return [
-     *     { path: '/${r}', version: 1, controller: ${t}V1Controller },
-     *     { path: '/${r}', version: 2, controller: ${t}V2Controller },
-     *   ]
-     */`;return a===`class`?`import { type AppModule, type ModuleRoutes } from '@forinda/kickjs'
-import { ${t}Controller } from './${n}.controller'
-
-export class ${t}Module implements AppModule {
-${o.replace(/^ {4}/gm,`  `).replace(/^ {6}/gm,`    `)}
-  routes(): ModuleRoutes {
-    return {
-      path: '/${r}',
-      controller: ${t}Controller,
-    }
-  }
-}
-`:`import { defineModule } from '@forinda/kickjs'
-import { ${t}Controller } from './${n}.controller'
-
-export const ${t}Module = defineModule({
-  name: '${t}Module',
-  build: () => ({
-${o}
-    routes() {
-      return {
-        path: '/${r}',
-        controller: ${t}Controller,
-      }
-    },
-  }),
-})
-`}function be(e){let{pascal:t,kebab:n,plural:r=``,pluralPascal:i=``}=e;return`import { Controller, Get, Post, Put, Delete, Autowired, ApiQueryParams, type Ctx } from '@forinda/kickjs'
-import { ApiTags } from '@forinda/kickjs-swagger'
-import { Create${t}UseCase } from '../application/use-cases/create-${n}.use-case'
-import { Get${t}UseCase } from '../application/use-cases/get-${n}.use-case'
-import { List${i}UseCase } from '../application/use-cases/list-${r}.use-case'
-import { Update${t}UseCase } from '../application/use-cases/update-${n}.use-case'
-import { Delete${t}UseCase } from '../application/use-cases/delete-${n}.use-case'
-import { create${t}Schema } from '../application/dtos/create-${n}.dto'
-import { update${t}Schema } from '../application/dtos/update-${n}.dto'
-import { ${t.toUpperCase()}_QUERY_CONFIG } from '../constants'
-
-// Each handler annotates its \`ctx\` with \`Ctx<KickRoutes.${t}Controller['<method>']>\`
-// so \`ctx.params\`, \`ctx.body\`, and \`ctx.query\` are typed end-to-end.
-// The \`KickRoutes\` namespace is generated by \`kick typegen\` (auto-run on
-// \`kick dev\`) — see https://forinda.github.io/kick-js/guide/typegen.
-
-@Controller()
-export class ${t}Controller {
-  @Autowired() private readonly create${t}UseCase!: Create${t}UseCase
-  @Autowired() private readonly get${t}UseCase!: Get${t}UseCase
-  @Autowired() private readonly list${i}UseCase!: List${i}UseCase
-  @Autowired() private readonly update${t}UseCase!: Update${t}UseCase
-  @Autowired() private readonly delete${t}UseCase!: Delete${t}UseCase
-
-  @Get('/')
-  @ApiTags('${t}')
-  @ApiQueryParams(${t.toUpperCase()}_QUERY_CONFIG)
-  async list(ctx: Ctx<KickRoutes.${t}Controller['list']>) {
-    return ctx.paginate(
-      (parsed) => this.list${i}UseCase.execute(parsed),
-      ${t.toUpperCase()}_QUERY_CONFIG,
-    )
-  }
-
-  @Get('/:id')
-  @ApiTags('${t}')
-  async getById(ctx: Ctx<KickRoutes.${t}Controller['getById']>) {
-    const result = await this.get${t}UseCase.execute(ctx.params.id)
-    if (!result) return ctx.notFound('${t} not found')
-    ctx.json(result)
-  }
-
-  @Post('/', { body: create${t}Schema, name: 'Create${t}' })
-  @ApiTags('${t}')
-  async create(ctx: Ctx<KickRoutes.${t}Controller['create']>) {
-    const result = await this.create${t}UseCase.execute(ctx.body)
-    ctx.created(result)
-  }
-
-  @Put('/:id', { body: update${t}Schema, name: 'Update${t}' })
-  @ApiTags('${t}')
-  async update(ctx: Ctx<KickRoutes.${t}Controller['update']>) {
-    const result = await this.update${t}UseCase.execute(ctx.params.id, ctx.body)
-    ctx.json(result)
-  }
-
-  @Delete('/:id')
-  @ApiTags('${t}')
-  async remove(ctx: Ctx<KickRoutes.${t}Controller['remove']>) {
-    await this.delete${t}UseCase.execute(ctx.params.id)
-    ctx.noContent()
-  }
-}
-`}function xe(e){let{pascal:t,kebab:n}=e,r=t.charAt(0).toLowerCase()+t.slice(1);return`import { Controller, Get, Post, Put, Delete, Autowired, ApiQueryParams, type Ctx } from '@forinda/kickjs'
-import { ApiTags } from '@forinda/kickjs-swagger'
-import { ${t}Service } from './${n}.service'
-import { create${t}Schema } from './dtos/create-${n}.dto'
-import { update${t}Schema } from './dtos/update-${n}.dto'
-import { ${t.toUpperCase()}_QUERY_CONFIG } from './${n}.constants'
-
-// Each handler annotates its \`ctx\` with \`Ctx<KickRoutes.${t}Controller['<method>']>\`
-// so \`ctx.params\`, \`ctx.body\`, and \`ctx.query\` are typed end-to-end.
-// The \`KickRoutes\` namespace is generated by \`kick typegen\` (auto-run on
-// \`kick dev\`) — see https://forinda.github.io/kick-js/guide/typegen.
-
-@Controller()
-export class ${t}Controller {
-  @Autowired() private readonly ${r}Service!: ${t}Service
-
-  @Get('/')
-  @ApiTags('${t}')
-  @ApiQueryParams(${t.toUpperCase()}_QUERY_CONFIG)
-  async list(ctx: Ctx<KickRoutes.${t}Controller['list']>) {
-    return ctx.paginate(
-      (parsed) => this.${r}Service.findPaginated(parsed),
-      ${t.toUpperCase()}_QUERY_CONFIG,
-    )
-  }
-
-  @Get('/:id')
-  @ApiTags('${t}')
-  async getById(ctx: Ctx<KickRoutes.${t}Controller['getById']>) {
-    const result = await this.${r}Service.findById(ctx.params.id)
-    if (!result) return ctx.notFound('${t} not found')
-    ctx.json(result)
-  }
-
-  @Post('/', { body: create${t}Schema, name: 'Create${t}' })
-  @ApiTags('${t}')
-  async create(ctx: Ctx<KickRoutes.${t}Controller['create']>) {
-    const result = await this.${r}Service.create(ctx.body)
-    ctx.created(result)
-  }
-
-  @Put('/:id', { body: update${t}Schema, name: 'Update${t}' })
-  @ApiTags('${t}')
-  async update(ctx: Ctx<KickRoutes.${t}Controller['update']>) {
-    const result = await this.${r}Service.update(ctx.params.id, ctx.body)
-    ctx.json(result)
-  }
-
-  @Delete('/:id')
-  @ApiTags('${t}')
-  async remove(ctx: Ctx<KickRoutes.${t}Controller['remove']>) {
-    await this.${r}Service.delete(ctx.params.id)
-    ctx.noContent()
-  }
-}
-`}function Se(e){let{pascal:t}=e;return`import type { QueryParamsConfig } from '@forinda/kickjs'
-
-export const ${t.toUpperCase()}_QUERY_CONFIG: QueryParamsConfig = {
-  filterable: ['name'],
-  sortable: ['name', 'createdAt'],
-  searchable: ['name'],
-}
-`}function I(e){let{pascal:t}=e;return`import { z } from 'zod'
-
-/**
- * Create ${t} DTO — Zod schema for validating POST request bodies.
- * This schema is passed to @Post('/', { body: create${t}Schema }) for automatic validation.
- * It also generates OpenAPI request body docs when SwaggerAdapter is used.
- *
- * Add more fields as needed. Supported Zod types:
- *   z.string(), z.number(), z.boolean(), z.enum([...]),
- *   z.array(), z.object(), .optional(), .default(), .transform()
- */
-export const create${t}Schema = z.object({
-  name: z.string().min(1, 'Name is required').max(200),
-})
-
-export type Create${t}DTO = z.infer<typeof create${t}Schema>
-`}function L(e){let{pascal:t}=e;return`import { z } from 'zod'
-
-export const update${t}Schema = z.object({
-  name: z.string().min(1).max(200).optional(),
-})
-
-export type Update${t}DTO = z.infer<typeof update${t}Schema>
-`}function R(e){let{pascal:t}=e;return`export interface ${t}ResponseDTO {
-  id: string
-  name: string
-  createdAt: string
-  updatedAt: string
-}
-`}function Ce(e){let{pascal:t,kebab:n,plural:r=``,pluralPascal:i=``}=e;return[{file:`create-${n}.use-case.ts`,content:`/**
- * Create ${t} Use Case
- *
- * Application layer — orchestrates a single business operation.
- * Use cases are thin: validate input (via DTO), call domain/repo, return response.
- * Keep business rules in the domain service, not here.
- */
-import { Service, Inject } from '@forinda/kickjs'
-import { ${t.toUpperCase()}_REPOSITORY, type I${t}Repository } from '../../domain/repositories/${n}.repository'
-import type { Create${t}DTO } from '../dtos/create-${n}.dto'
-import type { ${t}ResponseDTO } from '../dtos/${n}-response.dto'
-
-@Service()
-export class Create${t}UseCase {
-  constructor(
-    @Inject(${t.toUpperCase()}_REPOSITORY) private readonly repo: I${t}Repository,
-  ) {}
-
-  async execute(dto: Create${t}DTO): Promise<${t}ResponseDTO> {
-    return this.repo.create(dto)
-  }
-}
-`},{file:`get-${n}.use-case.ts`,content:`import { Service, Inject } from '@forinda/kickjs'
-import { ${t.toUpperCase()}_REPOSITORY, type I${t}Repository } from '../../domain/repositories/${n}.repository'
-import type { ${t}ResponseDTO } from '../dtos/${n}-response.dto'
-
-@Service()
-export class Get${t}UseCase {
-  constructor(
-    @Inject(${t.toUpperCase()}_REPOSITORY) private readonly repo: I${t}Repository,
-  ) {}
-
-  async execute(id: string): Promise<${t}ResponseDTO | null> {
-    return this.repo.findById(id)
-  }
-}
-`},{file:`list-${r}.use-case.ts`,content:`import { Service, Inject } from '@forinda/kickjs'
-import { ${t.toUpperCase()}_REPOSITORY, type I${t}Repository } from '../../domain/repositories/${n}.repository'
-import type { ParsedQuery } from '@forinda/kickjs'
-
-@Service()
-export class List${i}UseCase {
-  constructor(
-    @Inject(${t.toUpperCase()}_REPOSITORY) private readonly repo: I${t}Repository,
-  ) {}
-
-  async execute(parsed: ParsedQuery) {
-    return this.repo.findPaginated(parsed)
-  }
-}
-`},{file:`update-${n}.use-case.ts`,content:`import { Service, Inject } from '@forinda/kickjs'
-import { ${t.toUpperCase()}_REPOSITORY, type I${t}Repository } from '../../domain/repositories/${n}.repository'
-import type { Update${t}DTO } from '../dtos/update-${n}.dto'
-import type { ${t}ResponseDTO } from '../dtos/${n}-response.dto'
-
-@Service()
-export class Update${t}UseCase {
-  constructor(
-    @Inject(${t.toUpperCase()}_REPOSITORY) private readonly repo: I${t}Repository,
-  ) {}
-
-  async execute(id: string, dto: Update${t}DTO): Promise<${t}ResponseDTO> {
-    return this.repo.update(id, dto)
-  }
-}
-`},{file:`delete-${n}.use-case.ts`,content:`import { Service, Inject } from '@forinda/kickjs'
-import { ${t.toUpperCase()}_REPOSITORY, type I${t}Repository } from '../../domain/repositories/${n}.repository'
-
-@Service()
-export class Delete${t}UseCase {
-  constructor(
-    @Inject(${t.toUpperCase()}_REPOSITORY) private readonly repo: I${t}Repository,
-  ) {}
-
-  async execute(id: string): Promise<void> {
-    await this.repo.delete(id)
-  }
-}
-`}]}function z(e){let{pascal:t,kebab:n,dtoPrefix:r=`../../application/dtos`,tokenScope:i=`app`}=e;return`/**
- * ${t} Repository Interface
- *
- * Defines the contract for data access.
- * The interface declares what operations are available;
- * implementations (in-memory, Drizzle, Prisma) fulfill the contract.
- *
- * To swap implementations, change the factory in the module's register() method.
- */
-import { createToken } from '@forinda/kickjs'
-import type { ${t}ResponseDTO } from '${r}/${n}-response.dto'
-import type { Create${t}DTO } from '${r}/create-${n}.dto'
-import type { Update${t}DTO } from '${r}/update-${n}.dto'
-import type { ParsedQuery } from '@forinda/kickjs'
-
-export interface I${t}Repository {
-  findById(id: string): Promise<${t}ResponseDTO | null>
-  findAll(): Promise<${t}ResponseDTO[]>
-  findPaginated(parsed: ParsedQuery): Promise<{ data: ${t}ResponseDTO[]; total: number }>
-  create(dto: Create${t}DTO): Promise<${t}ResponseDTO>
-  update(id: string, dto: Update${t}DTO): Promise<${t}ResponseDTO>
-  delete(id: string): Promise<void>
-}
-
-/**
- * Collision-safe DI token bound to \`I${t}Repository\`.
- * \`container.resolve(${t.toUpperCase()}_REPOSITORY)\` and
- * \`@Inject(${t.toUpperCase()}_REPOSITORY)\` both return the typed
- * interface — no manual generic, no \`any\` cast.
- *
- * The \`'${i}/'\` prefix matches the project scope so
- * \`kick-lint\`'s \`token-reserved-prefix\` rule never fires —
- * adopters must NOT use the reserved \`'kick/'\` namespace.
- */
-export const ${t.toUpperCase()}_REPOSITORY = createToken<I${t}Repository>('${i}/${t}/repository')
-`}function B(e){let{pascal:t,kebab:n,repoPrefix:r=`../../domain/repositories`,dtoPrefix:i=`../../application/dtos`}=e;return`/**
- * In-Memory ${t} Repository
- *
- * Implements the repository interface using a Map.
- * Useful for prototyping and testing. Replace with a database implementation
- * (Drizzle, Prisma, etc.) for production use.
- *
- * @Repository() registers this class in the DI container as a singleton.
- */
-import { randomUUID } from 'node:crypto'
-import { Repository, HttpException } from '@forinda/kickjs'
-import type { ParsedQuery } from '@forinda/kickjs'
-import type { I${t}Repository } from '${r}/${n}.repository'
-import type { ${t}ResponseDTO } from '${i}/${n}-response.dto'
-import type { Create${t}DTO } from '${i}/create-${n}.dto'
-import type { Update${t}DTO } from '${i}/update-${n}.dto'
-
-@Repository()
-export class InMemory${t}Repository implements I${t}Repository {
-  private store = new Map<string, ${t}ResponseDTO>()
-
-  async findById(id: string): Promise<${t}ResponseDTO | null> {
-    return this.store.get(id) ?? null
-  }
-
-  async findAll(): Promise<${t}ResponseDTO[]> {
-    return Array.from(this.store.values())
-  }
-
-  async findPaginated(parsed: ParsedQuery): Promise<{ data: ${t}ResponseDTO[]; total: number }> {
-    const all = Array.from(this.store.values())
-    const data = all.slice(parsed.pagination.offset, parsed.pagination.offset + parsed.pagination.limit)
-    return { data, total: all.length }
-  }
-
-  async create(dto: Create${t}DTO): Promise<${t}ResponseDTO> {
-    const now = new Date().toISOString()
-    const entity: ${t}ResponseDTO = {
-      id: randomUUID(),
-      name: dto.name,
-      createdAt: now,
-      updatedAt: now,
-    }
-    this.store.set(entity.id, entity)
-    return entity
-  }
-
-  async update(id: string, dto: Update${t}DTO): Promise<${t}ResponseDTO> {
-    const existing = this.store.get(id)
-    if (!existing) throw HttpException.notFound('${t} not found')
-    const updated = { ...existing, ...dto, updatedAt: new Date().toISOString() }
-    this.store.set(id, updated)
-    return updated
-  }
-
-  async delete(id: string): Promise<void> {
-    if (!this.store.has(id)) throw HttpException.notFound('${t} not found')
-    this.store.delete(id)
-  }
-}
-`}function V(e){let{pascal:t,kebab:n,repoType:r=``,repoPrefix:i=`../../domain/repositories`,dtoPrefix:a=`../../application/dtos`}=e,o=r.charAt(0).toUpperCase()+r.slice(1).replace(/-([a-z])/g,(e,t)=>t.toUpperCase());return`/**
- * ${o} ${t} Repository
- *
- * Stub implementation for a custom '${r}' repository.
- * Implements the repository interface using an in-memory Map as a placeholder.
- *
- * TODO: Replace the in-memory Map with your ${r} data-access logic.
- * See I${t}Repository for the interface contract.
- *
- * @Repository() registers this class in the DI container as a singleton.
- */
-import { randomUUID } from 'node:crypto'
-import { Repository, HttpException } from '@forinda/kickjs'
-import type { ParsedQuery } from '@forinda/kickjs'
-import type { I${t}Repository } from '${i}/${n}.repository'
-import type { ${t}ResponseDTO } from '${a}/${n}-response.dto'
-import type { Create${t}DTO } from '${a}/create-${n}.dto'
-import type { Update${t}DTO } from '${a}/update-${n}.dto'
-
-@Repository()
-export class ${o}${t}Repository implements I${t}Repository {
-  // TODO: Replace with your ${r} client/connection
-  private store = new Map<string, ${t}ResponseDTO>()
-
-  async findById(id: string): Promise<${t}ResponseDTO | null> {
-    // TODO: Implement with ${r}
-    return this.store.get(id) ?? null
-  }
-
-  async findAll(): Promise<${t}ResponseDTO[]> {
-    // TODO: Implement with ${r}
-    return Array.from(this.store.values())
-  }
-
-  async findPaginated(parsed: ParsedQuery): Promise<{ data: ${t}ResponseDTO[]; total: number }> {
-    // TODO: Implement with ${r}
-    const all = Array.from(this.store.values())
-    const data = all.slice(parsed.pagination.offset, parsed.pagination.offset + parsed.pagination.limit)
-    return { data, total: all.length }
-  }
-
-  async create(dto: Create${t}DTO): Promise<${t}ResponseDTO> {
-    // TODO: Implement with ${r}
-    const now = new Date().toISOString()
-    const entity: ${t}ResponseDTO = {
-      id: randomUUID(),
-      name: dto.name,
-      createdAt: now,
-      updatedAt: now,
-    }
-    this.store.set(entity.id, entity)
-    return entity
-  }
-
-  async update(id: string, dto: Update${t}DTO): Promise<${t}ResponseDTO> {
-    // TODO: Implement with ${r}
-    const existing = this.store.get(id)
-    if (!existing) throw HttpException.notFound('${t} not found')
-    const updated = { ...existing, ...dto, updatedAt: new Date().toISOString() }
-    this.store.set(id, updated)
-    return updated
-  }
-
-  async delete(id: string): Promise<void> {
-    // TODO: Implement with ${r}
-    if (!this.store.has(id)) throw HttpException.notFound('${t} not found')
-    this.store.delete(id)
-  }
-}
-`}function we(e){let{pascal:t,kebab:n}=e;return`/**
- * ${t} Domain Service
- *
- * Domain layer — contains business rules that don't belong to a single entity.
- * Use this for cross-entity logic, validation rules, and domain invariants.
- * Keep it free of HTTP/framework concerns.
- */
-import { Service, Inject, HttpException } from '@forinda/kickjs'
-import { ${t.toUpperCase()}_REPOSITORY, type I${t}Repository } from '../repositories/${n}.repository'
-
-@Service()
-export class ${t}DomainService {
-  constructor(
-    @Inject(${t.toUpperCase()}_REPOSITORY) private readonly repo: I${t}Repository,
-  ) {}
-
-  async ensureExists(id: string): Promise<void> {
-    const entity = await this.repo.findById(id)
-    if (!entity) {
-      throw HttpException.notFound('${t} not found')
-    }
-  }
-}
-`}function Te(e){let{pascal:t,kebab:n}=e;return`/**
- * ${t} Entity
- *
- * Domain layer — the core business object.
- * Uses a private constructor with static factory methods (create, reconstitute)
- * to enforce invariants. Properties are accessed via getters to maintain encapsulation.
- *
- * Patterns used:
- *   - Private constructor: prevents direct instantiation
- *   - create(): factory for new entities (generates ID, sets timestamps)
- *   - reconstitute(): factory for rebuilding from persistence (no side effects)
- *   - changeName(): mutation method that enforces business rules
- */
-import { ${t}Id } from '../value-objects/${n}-id.vo'
-
-interface ${t}Props {
-  id: ${t}Id
-  name: string
-  createdAt: Date
-  updatedAt: Date
-}
-
-export class ${t} {
-  private constructor(private props: ${t}Props) {}
-
-  static create(params: { name: string }): ${t} {
-    const now = new Date()
-    return new ${t}({
-      id: ${t}Id.create(),
-      name: params.name,
-      createdAt: now,
-      updatedAt: now,
-    })
-  }
-
-  static reconstitute(props: ${t}Props): ${t} {
-    return new ${t}(props)
-  }
-
-  get id(): ${t}Id {
-    return this.props.id
-  }
-  get name(): string {
-    return this.props.name
-  }
-  get createdAt(): Date {
-    return this.props.createdAt
-  }
-  get updatedAt(): Date {
-    return this.props.updatedAt
-  }
-
-  changeName(name: string): void {
-    if (!name || name.trim().length === 0) {
-      throw new Error('Name cannot be empty')
-    }
-    this.props.name = name.trim()
-    this.props.updatedAt = new Date()
-  }
-
-  toJSON() {
-    return {
-      id: this.props.id.toString(),
-      name: this.props.name,
-      createdAt: this.props.createdAt.toISOString(),
-      updatedAt: this.props.updatedAt.toISOString(),
-    }
-  }
-}
-`}function Ee(e){let{pascal:t}=e;return`/**
- * ${t} ID Value Object
- *
- * Domain layer — wraps a primitive ID with type safety and validation.
- * Value objects are immutable and compared by value, not reference.
- *
- *   ${t}Id.create()    — generate a new UUID
- *   ${t}Id.from(id)    — wrap an existing ID string (validates non-empty)
- *   id.equals(other)  — compare two IDs by value
- */
-import { randomUUID } from 'node:crypto'
-
-export class ${t}Id {
-  private constructor(private readonly value: string) {}
-
-  static create(): ${t}Id {
-    return new ${t}Id(randomUUID())
-  }
-
-  static from(id: string): ${t}Id {
-    if (!id || id.trim().length === 0) {
-      throw new Error('${t}Id cannot be empty')
-    }
-    return new ${t}Id(id)
-  }
-
-  toString(): string {
-    return this.value
-  }
-
-  equals(other: ${t}Id): boolean {
-    return this.value === other.value
-  }
-}
-`}function H(e){let{pascal:t,kebab:n,plural:r=``}=e;return`import { describe, it, expect, beforeEach } from 'vitest'
-import { Container } from '@forinda/kickjs'
-
-describe('${t}Controller', () => {
-  beforeEach(() => {
-    Container.reset()
-  })
-
-  it('should be defined', () => {
-    expect(true).toBe(true)
-  })
-
-  describe('POST /${r}', () => {
-    it('should create a new ${n}', async () => {
-      // TODO: Set up test module, call create endpoint, assert 201
-      expect(true).toBe(true)
-    })
-  })
-
-  describe('GET /${r}', () => {
-    it('should return paginated ${r}', async () => {
-      // TODO: Set up test module, call list endpoint, assert { data, meta }
-      expect(true).toBe(true)
-    })
-  })
-
-  describe('GET /${r}/:id', () => {
-    it('should return a ${n} by id', async () => {
-      // TODO: Create a ${n}, then fetch by id, assert match
-      expect(true).toBe(true)
-    })
-
-    it('should return 404 for non-existent ${n}', async () => {
-      // TODO: Fetch non-existent id, assert 404
-      expect(true).toBe(true)
-    })
-  })
-
-  describe('PUT /${r}/:id', () => {
-    it('should update an existing ${n}', async () => {
-      // TODO: Create, update, assert changes
-      expect(true).toBe(true)
-    })
-  })
-
-  describe('DELETE /${r}/:id', () => {
-    it('should delete a ${n}', async () => {
-      // TODO: Create, delete, assert gone
-      expect(true).toBe(true)
-    })
-  })
-})
-`}function U(e){let{pascal:t,kebab:n,plural:r=``,repoPrefix:i=`../infrastructure/repositories/in-memory-${n}.repository`}=e;return`import { describe, it, expect, beforeEach } from 'vitest'
-import { InMemory${t}Repository } from '${i}'
-
-describe('InMemory${t}Repository', () => {
-  let repo: InMemory${t}Repository
-
-  beforeEach(() => {
-    repo = new InMemory${t}Repository()
-  })
-
-  it('should create and retrieve a ${n}', async () => {
-    const created = await repo.create({ name: 'Test ${t}' })
-    expect(created).toBeDefined()
-    expect(created.name).toBe('Test ${t}')
-    expect(created.id).toBeDefined()
-
-    const found = await repo.findById(created.id)
-    expect(found).toEqual(created)
-  })
-
-  it('should return null for non-existent id', async () => {
-    const found = await repo.findById('non-existent')
-    expect(found).toBeNull()
-  })
-
-  it('should list all ${r}', async () => {
-    await repo.create({ name: '${t} 1' })
-    await repo.create({ name: '${t} 2' })
-
-    const all = await repo.findAll()
-    expect(all).toHaveLength(2)
-  })
-
-  it('should return paginated results', async () => {
-    await repo.create({ name: '${t} 1' })
-    await repo.create({ name: '${t} 2' })
-    await repo.create({ name: '${t} 3' })
-
-    const result = await repo.findPaginated({
-      filters: [],
-      sort: [],
-      search: '',
-      pagination: { page: 1, limit: 2, offset: 0 },
-    })
-
-    expect(result.data).toHaveLength(2)
-    expect(result.total).toBe(3)
-  })
-
-  it('should update a ${n}', async () => {
-    const created = await repo.create({ name: 'Original' })
-    const updated = await repo.update(created.id, { name: 'Updated' })
-    expect(updated.name).toBe('Updated')
-  })
-
-  it('should delete a ${n}', async () => {
-    const created = await repo.create({ name: 'To Delete' })
-    await repo.delete(created.id)
-    const found = await repo.findById(created.id)
-    expect(found).toBeNull()
-  })
-})
-`}function De(e){let{pascal:t,kebab:n}=e;return`import { Service, Inject, HttpException } from '@forinda/kickjs'
-import type { ParsedQuery } from '@forinda/kickjs'
-import { ${t.toUpperCase()}_REPOSITORY, type I${t}Repository } from './${n}.repository'
-import type { ${t}ResponseDTO } from './dtos/${n}-response.dto'
-import type { Create${t}DTO } from './dtos/create-${n}.dto'
-import type { Update${t}DTO } from './dtos/update-${n}.dto'
-
-@Service()
-export class ${t}Service {
-  constructor(
-    @Inject(${t.toUpperCase()}_REPOSITORY) private readonly repo: I${t}Repository,
-  ) {}
-
-  async findById(id: string): Promise<${t}ResponseDTO | null> {
-    return this.repo.findById(id)
-  }
-
-  async findAll(): Promise<${t}ResponseDTO[]> {
-    return this.repo.findAll()
-  }
-
-  async findPaginated(parsed: ParsedQuery) {
-    return this.repo.findPaginated(parsed)
-  }
-
-  async create(dto: Create${t}DTO): Promise<${t}ResponseDTO> {
-    return this.repo.create(dto)
-  }
-
-  async update(id: string, dto: Update${t}DTO): Promise<${t}ResponseDTO> {
-    return this.repo.update(id, dto)
-  }
-
-  async delete(id: string): Promise<void> {
-    await this.repo.delete(id)
-  }
-}
-`}function W(e){let{pascal:t}=e;return`import type { QueryFieldConfig } from '@forinda/kickjs'
-
-export const ${t.toUpperCase()}_QUERY_CONFIG: QueryFieldConfig = {
-  filterable: ['name'],
-  sortable: ['name', 'createdAt'],
-  searchable: ['name'],
-}
-`}function Oe(e){let{pascal:t,kebab:n,plural:r=``,repo:i,style:a}=e,o={inmemory:`InMemory${t}Repository`,drizzle:`Drizzle${t}Repository`,prisma:`Prisma${t}Repository`},s={inmemory:`in-memory-${n}`,drizzle:`drizzle-${n}`,prisma:`prisma-${n}`},c=o[i]??o.inmemory,l=s[i]??s.inmemory,u=a??`define`,d=`/**
- * ${t} Module — CQRS Pattern
- *
- * Separates read (queries) and write (commands) operations.
- * Events are emitted after state changes and can be handled via
- * WebSocket broadcasts, queue jobs, or ETL pipelines.
- *
- * Structure:
- *   commands/       — Write operations (create, update, delete)
- *   queries/        — Read operations (get, list)
- *   events/         — Domain events + handlers (WS broadcast, queue dispatch)
- *   dtos/           — Request/response schemas
- */`,f=`import { ${t.toUpperCase()}_REPOSITORY } from './${n}.repository'
-import { ${c} } from './${l}.repository'
-import { ${t}Controller } from './${n}.controller'
-
-// Eagerly load decorated classes
-import.meta.glob(
-  [
-    './commands/**/*.ts',
-    './queries/**/*.ts',
-    './events/**/*.ts',
-    '!./**/*.test.ts',
-  ],
-  { eager: true },
-)`,p=`    /**
-     * Declare HTTP routes for this CQRS module. Return value shape:
-     *
-     *   - \`path\`        — URL prefix for this route set.
-     *   - \`controller\`  — Controller class (also drives OpenAPI).
-     *   - \`version\`     — Optional. Overrides the app-wide API version.
-     *
-     * Return an array to mount multiple route sets:
-     *
-     *   return [
-     *     { path: '/${r}', version: 1, controller: ${t}V1Controller },
-     *     { path: '/${r}', version: 2, controller: ${t}V2Controller },
-     *   ]
-     */`;return u===`class`?`${d}
-import { Container, type AppModule, type ModuleRoutes } from '@forinda/kickjs'
-${f}
-
-export class ${t}Module implements AppModule {
-  register(container: Container): void {
-    container.registerFactory(${t.toUpperCase()}_REPOSITORY, () =>
-      container.resolve(${c}),
-    )
-  }
-
-${p.replace(/^ {4}/gm,`  `).replace(/^ {6}/gm,`    `)}
-  routes(): ModuleRoutes {
-    return {
-      path: '/${r}',
-      controller: ${t}Controller,
-    }
-  }
-}
-`:`${d}
-import { defineModule } from '@forinda/kickjs'
-${f}
-
-export const ${t}Module = defineModule({
-  name: '${t}Module',
-  build: () => ({
-    register(container) {
-      container.registerFactory(${t.toUpperCase()}_REPOSITORY, () =>
-        container.resolve(${c}),
-      )
-    },
-
-${p}
-    routes() {
-      return {
-        path: '/${r}',
-        controller: ${t}Controller,
-      }
-    },
-  }),
-})
-`}function ke(e){let{pascal:t,kebab:n,plural:r=``,pluralPascal:i=``}=e;return`import { Controller, Get, Post, Put, Delete, Autowired, ApiQueryParams, type Ctx } from '@forinda/kickjs'
-import { ApiTags } from '@forinda/kickjs-swagger'
-import { Create${t}Command } from './commands/create-${n}.command'
-import { Update${t}Command } from './commands/update-${n}.command'
-import { Delete${t}Command } from './commands/delete-${n}.command'
-import { Get${t}Query } from './queries/get-${n}.query'
-import { List${i}Query } from './queries/list-${r}.query'
-import { create${t}Schema } from './dtos/create-${n}.dto'
-import { update${t}Schema } from './dtos/update-${n}.dto'
-import { ${t.toUpperCase()}_QUERY_CONFIG } from './${n}.constants'
-
-// Each handler annotates its \`ctx\` with \`Ctx<KickRoutes.${t}Controller['<method>']>\`
-// so \`ctx.params\`, \`ctx.body\`, and \`ctx.query\` are typed end-to-end.
-// The \`KickRoutes\` namespace is generated by \`kick typegen\` (auto-run on
-// \`kick dev\`) — see https://forinda.github.io/kick-js/guide/typegen.
-
-@Controller()
-export class ${t}Controller {
-  @Autowired() private readonly create${t}Command!: Create${t}Command
-  @Autowired() private readonly update${t}Command!: Update${t}Command
-  @Autowired() private readonly delete${t}Command!: Delete${t}Command
-  @Autowired() private readonly get${t}Query!: Get${t}Query
-  @Autowired() private readonly list${i}Query!: List${i}Query
-
-  @Get('/')
-  @ApiTags('${t}')
-  @ApiQueryParams(${t.toUpperCase()}_QUERY_CONFIG)
-  async list(ctx: Ctx<KickRoutes.${t}Controller['list']>) {
-    return ctx.paginate(
-      (parsed) => this.list${i}Query.execute(parsed),
-      ${t.toUpperCase()}_QUERY_CONFIG,
-    )
-  }
-
-  @Get('/:id')
-  @ApiTags('${t}')
-  async getById(ctx: Ctx<KickRoutes.${t}Controller['getById']>) {
-    const result = await this.get${t}Query.execute(ctx.params.id)
-    if (!result) return ctx.notFound('${t} not found')
-    ctx.json(result)
-  }
-
-  @Post('/', { body: create${t}Schema, name: 'Create${t}' })
-  @ApiTags('${t}')
-  async create(ctx: Ctx<KickRoutes.${t}Controller['create']>) {
-    const result = await this.create${t}Command.execute(ctx.body)
-    ctx.created(result)
-  }
-
-  @Put('/:id', { body: update${t}Schema, name: 'Update${t}' })
-  @ApiTags('${t}')
-  async update(ctx: Ctx<KickRoutes.${t}Controller['update']>) {
-    const result = await this.update${t}Command.execute(ctx.params.id, ctx.body)
-    ctx.json(result)
-  }
-
-  @Delete('/:id')
-  @ApiTags('${t}')
-  async remove(ctx: Ctx<KickRoutes.${t}Controller['remove']>) {
-    await this.delete${t}Command.execute(ctx.params.id)
-    ctx.noContent()
-  }
-}
-`}function Ae(e){let{pascal:t,kebab:n}=e;return[{file:`create-${n}.command.ts`,content:`import { Service, Inject } from '@forinda/kickjs'
-import { ${t.toUpperCase()}_REPOSITORY, type I${t}Repository } from '../${n}.repository'
-import type { Create${t}DTO } from '../dtos/create-${n}.dto'
-import type { ${t}ResponseDTO } from '../dtos/${n}-response.dto'
-import { ${t}Events } from '../events/${n}.events'
-
-@Service()
-export class Create${t}Command {
-  constructor(
-    @Inject(${t.toUpperCase()}_REPOSITORY) private readonly repo: I${t}Repository,
-    @Inject(${t}Events) private readonly events: ${t}Events,
-  ) {}
-
-  async execute(dto: Create${t}DTO): Promise<${t}ResponseDTO> {
-    const result = await this.repo.create(dto)
-    this.events.emit('${n}.created', result)
-    return result
-  }
-}
-`},{file:`update-${n}.command.ts`,content:`import { Service, Inject } from '@forinda/kickjs'
-import { ${t.toUpperCase()}_REPOSITORY, type I${t}Repository } from '../${n}.repository'
-import type { Update${t}DTO } from '../dtos/update-${n}.dto'
-import type { ${t}ResponseDTO } from '../dtos/${n}-response.dto'
-import { ${t}Events } from '../events/${n}.events'
-
-@Service()
-export class Update${t}Command {
-  constructor(
-    @Inject(${t.toUpperCase()}_REPOSITORY) private readonly repo: I${t}Repository,
-    @Inject(${t}Events) private readonly events: ${t}Events,
-  ) {}
-
-  async execute(id: string, dto: Update${t}DTO): Promise<${t}ResponseDTO> {
-    const result = await this.repo.update(id, dto)
-    this.events.emit('${n}.updated', result)
-    return result
-  }
-}
-`},{file:`delete-${n}.command.ts`,content:`import { Service, Inject } from '@forinda/kickjs'
-import { ${t.toUpperCase()}_REPOSITORY, type I${t}Repository } from '../${n}.repository'
-import { ${t}Events } from '../events/${n}.events'
-
-@Service()
-export class Delete${t}Command {
-  constructor(
-    @Inject(${t.toUpperCase()}_REPOSITORY) private readonly repo: I${t}Repository,
-    @Inject(${t}Events) private readonly events: ${t}Events,
-  ) {}
-
-  async execute(id: string): Promise<void> {
-    await this.repo.delete(id)
-    this.events.emit('${n}.deleted', { id })
-  }
-}
-`}]}function je(e){let{pascal:t,kebab:n,plural:r=``,pluralPascal:i=``}=e;return[{file:`get-${n}.query.ts`,content:`import { Service, Inject } from '@forinda/kickjs'
-import { ${t.toUpperCase()}_REPOSITORY, type I${t}Repository } from '../${n}.repository'
-import type { ${t}ResponseDTO } from '../dtos/${n}-response.dto'
-
-@Service()
-export class Get${t}Query {
-  constructor(
-    @Inject(${t.toUpperCase()}_REPOSITORY) private readonly repo: I${t}Repository,
-  ) {}
-
-  async execute(id: string): Promise<${t}ResponseDTO | null> {
-    return this.repo.findById(id)
-  }
-}
-`},{file:`list-${r}.query.ts`,content:`import { Service, Inject } from '@forinda/kickjs'
-import { ${t.toUpperCase()}_REPOSITORY, type I${t}Repository } from '../${n}.repository'
-import type { ParsedQuery } from '@forinda/kickjs'
-
-@Service()
-export class List${i}Query {
-  constructor(
-    @Inject(${t.toUpperCase()}_REPOSITORY) private readonly repo: I${t}Repository,
-  ) {}
-
-  async execute(parsed: ParsedQuery) {
-    return this.repo.findPaginated(parsed)
-  }
-}
-`}]}function Me(e){let{pascal:t,kebab:n}=e;return[{file:`${n}.events.ts`,content:`import { Service } from '@forinda/kickjs'
-import { EventEmitter } from 'node:events'
-import type { ${t}ResponseDTO } from '../dtos/${n}-response.dto'
-
-/**
- * ${t} domain event types.
- *
- * These events are emitted by commands after state changes.
- * Subscribe to them in event handlers for side effects:
- *   - WebSocket broadcasts (real-time UI updates)
- *   - Queue jobs (async processing, ETL pipelines)
- *   - Audit logging
- *   - Cache invalidation
- */
-export interface ${t}EventMap {
-  '${n}.created': ${t}ResponseDTO
-  '${n}.updated': ${t}ResponseDTO
-  '${n}.deleted': { id: string }
-}
-
-@Service()
-export class ${t}Events {
-  private emitter = new EventEmitter()
-
-  emit<K extends keyof ${t}EventMap>(event: K, data: ${t}EventMap[K]): void {
-    this.emitter.emit(event, data)
-  }
-
-  on<K extends keyof ${t}EventMap>(event: K, handler: (data: ${t}EventMap[K]) => void): void {
-    this.emitter.on(event, handler)
-  }
-
-  off<K extends keyof ${t}EventMap>(event: K, handler: (data: ${t}EventMap[K]) => void): void {
-    this.emitter.off(event, handler)
-  }
-}
-`},{file:`on-${n}-change.handler.ts`,content:`import { Service, Autowired } from '@forinda/kickjs'
-import { ${t}Events } from './${n}.events'
-
-/**
- * ${t} Change Event Handler
- *
- * Reacts to domain events emitted by commands.
- * Wire up side effects here:
- *
- * 1. WebSocket broadcast — notify connected clients in real-time
- *    import { WsGateway } from '@forinda/kickjs-ws'
- *    this.ws.broadcast('${n}-channel', { event, data })
- *
- * 2. Queue dispatch — offload heavy processing to background workers
- *    import { QueueService } from '@forinda/kickjs-queue'
- *    this.queue.add('${n}-etl', { action: event, payload: data })
- *
- * 3. ETL pipeline — transform and load data to external systems
- *    await this.etlPipeline.process(data)
- */
-@Service()
-export class On${t}ChangeHandler {
-  @Autowired() private events!: ${t}Events
-
-  // Uncomment to inject WebSocket and Queue services:
-  // @Autowired() private ws!: WsGateway
-  // @Autowired() private queue!: QueueService
-
-  onInit(): void {
-    this.events.on('${n}.created', (data) => {
-      console.log('[${t}] Created:', data.id)
-      // TODO: Broadcast via WebSocket
-      // this.ws.broadcast('${n}-channel', { event: '${n}.created', data })
-      // TODO: Dispatch to queue for async processing / ETL
-      // this.queue.add('${n}-etl', { action: 'create', payload: data })
-    })
-
-    this.events.on('${n}.updated', (data) => {
-      console.log('[${t}] Updated:', data.id)
-      // TODO: Broadcast via WebSocket
-      // this.ws.broadcast('${n}-channel', { event: '${n}.updated', data })
-    })
-
-    this.events.on('${n}.deleted', (data) => {
-      console.log('[${t}] Deleted:', data.id)
-      // TODO: Broadcast via WebSocket
-      // this.ws.broadcast('${n}-channel', { event: '${n}.deleted', data })
-    })
-  }
-}
-`}]}function G(e){let{pascal:t,kebab:n,repoPrefix:r=`../../domain/repositories`,dtoPrefix:i=`../../application/dtos`}=e;return`/**
- * Drizzle ${t} Repository
- *
- * Implements the repository interface using Drizzle ORM.
- * Uses buildFromColumns() with Column objects for type-safe query building.
- *
- * TODO: Update the schema import to match your Drizzle schema file.
- * TODO: Replace DRIZZLE_DB injection token with your actual database token.
- *
- * @Repository() registers this class in the DI container as a singleton.
- */
-import { eq, ne, gt, gte, lt, lte, ilike, inArray, between, and, or, asc, desc, count, sql } from 'drizzle-orm'
-import { Repository, HttpException, Inject } from '@forinda/kickjs'
-import { DRIZZLE_DB, DrizzleQueryAdapter } from '@forinda/kickjs-drizzle'
-import type { ParsedQuery } from '@forinda/kickjs'
-import type { I${t}Repository } from '${r}/${n}.repository'
-import type { ${t}ResponseDTO } from '${i}/${n}-response.dto'
-import type { Create${t}DTO } from '${i}/create-${n}.dto'
-import type { Update${t}DTO } from '${i}/update-${n}.dto'
-import { ${t.toUpperCase()}_QUERY_CONFIG } from '../../constants'
-
-// TODO: Import your Drizzle schema table — e.g.:
-// import { ${n}s } from '@/db/schema'
-
-const queryAdapter = new DrizzleQueryAdapter({
-  eq, ne, gt, gte, lt, lte, ilike, inArray, between, and, or, asc, desc,
-})
-
-@Repository()
-export class Drizzle${t}Repository implements I${t}Repository {
-  constructor(@Inject(DRIZZLE_DB) private db: any) {}
-
-  async findById(id: string): Promise<${t}ResponseDTO | null> {
-    // TODO: Implement with Drizzle
-    // const row = this.db.select().from(${n}s).where(eq(${n}s.id, id)).get()
-    // return row ?? null
-    throw new Error('Drizzle ${t} repository not yet implemented — update schema imports and queries')
-  }
-
-  async findAll(): Promise<${t}ResponseDTO[]> {
-    // TODO: Implement with Drizzle
-    // return this.db.select().from(${n}s).all()
-    throw new Error('Drizzle ${t} repository not yet implemented')
-  }
-
-  async findPaginated(parsed: ParsedQuery): Promise<{ data: ${t}ResponseDTO[]; total: number }> {
-    // TODO: Use buildFromColumns() with your query config for type-safe filtering
-    // const query = queryAdapter.buildFromColumns(parsed, ${t.toUpperCase()}_QUERY_CONFIG)
-    //
-    // const data = this.db
-    //   .select().from(${n}s).$dynamic()
-    //   .where(query.where).orderBy(...query.orderBy)
-    //   .limit(query.limit).offset(query.offset).all()
-    //
-    // const totalResult = this.db
-    //   .select({ count: count() }).from(${n}s)
-    //   .$dynamic().where(query.where).get()
-    //
-    // return { data, total: totalResult?.count ?? 0 }
-    throw new Error('Drizzle ${t} repository not yet implemented')
-  }
-
-  async create(dto: Create${t}DTO): Promise<${t}ResponseDTO> {
-    // TODO: Implement with Drizzle
-    // return this.db.insert(${n}s).values(dto).returning().get()
-    throw new Error('Drizzle ${t} repository not yet implemented')
-  }
-
-  async update(id: string, dto: Update${t}DTO): Promise<${t}ResponseDTO> {
-    // TODO: Implement with Drizzle
-    // const row = this.db.update(${n}s).set(dto).where(eq(${n}s.id, id)).returning().get()
-    // if (!row) throw HttpException.notFound('${t} not found')
-    // return row
-    throw new Error('Drizzle ${t} repository not yet implemented')
-  }
-
-  async delete(id: string): Promise<void> {
-    // TODO: Implement with Drizzle
-    // this.db.delete(${n}s).where(eq(${n}s.id, id)).run()
-    throw new Error('Drizzle ${t} repository not yet implemented')
-  }
-}
-`}function Ne(e){let{pascal:t,kebab:n}=e;return`import type { DrizzleQueryParamsConfig } from '@forinda/kickjs-drizzle'
-// TODO: Import your schema table and reference actual columns for type safety
-// import { ${n}s } from '@/db/schema'
-
-export const ${t.toUpperCase()}_QUERY_CONFIG: DrizzleQueryParamsConfig = {
-  columns: {
-    // Replace with actual Drizzle Column references for type-safe filtering:
-    // name: ${n}s.name,
-    // status: ${n}s.status,
-  },
-  sortable: {
-    // name: ${n}s.name,
-    // createdAt: ${n}s.createdAt,
-  },
-  searchColumns: [
-    // ${n}s.name,
-  ],
-}
-`}function K(e){let{pascal:t,kebab:n,repoPrefix:r=`../../domain/repositories`,dtoPrefix:i=`../../application/dtos`}=e,a=n.replace(/-([a-z])/g,(e,t)=>t.toUpperCase());return`/**
- * Prisma ${t} Repository
- *
- * Implements the repository interface using Prisma Client.
- * Requires a PrismaClient instance injected via the DI container.
- *
- * Ensure your Prisma schema has a '${t}' model defined.
- *
- * For full Prisma field-level type safety, replace PrismaModelDelegate with your PrismaClient:
- *   @Inject(PRISMA_CLIENT) private prisma!: PrismaClient
- *
- * @Repository() registers this class in the DI container as a singleton.
- */
-import { Repository, HttpException, Inject } from '@forinda/kickjs'
-import { PRISMA_CLIENT, type PrismaModelDelegate } from '@forinda/kickjs-prisma'
-import type { ParsedQuery } from '@forinda/kickjs'
-import type { I${t}Repository } from '${r}/${n}.repository'
-import type { ${t}ResponseDTO } from '${i}/${n}-response.dto'
-import type { Create${t}DTO } from '${i}/create-${n}.dto'
-import type { Update${t}DTO } from '${i}/update-${n}.dto'
-
-@Repository()
-export class Prisma${t}Repository implements I${t}Repository {
-  @Inject(PRISMA_CLIENT) private prisma!: { ${a}: PrismaModelDelegate }
-
-  async findById(id: string): Promise<${t}ResponseDTO | null> {
-    return this.prisma.${a}.findUnique({ where: { id } }) as Promise<${t}ResponseDTO | null>
-  }
-
-  async findAll(): Promise<${t}ResponseDTO[]> {
-    return this.prisma.${a}.findMany() as Promise<${t}ResponseDTO[]>
-  }
-
-  async findPaginated(parsed: ParsedQuery): Promise<{ data: ${t}ResponseDTO[]; total: number }> {
-    const [data, total] = await Promise.all([
-      this.prisma.${a}.findMany({
-        skip: parsed.pagination.offset,
-        take: parsed.pagination.limit,
-      }) as Promise<${t}ResponseDTO[]>,
-      this.prisma.${a}.count(),
-    ])
-    return { data, total }
-  }
-
-  async create(dto: Create${t}DTO): Promise<${t}ResponseDTO> {
-    return this.prisma.${a}.create({ data: dto as Record<string, unknown> }) as Promise<${t}ResponseDTO>
-  }
-
-  async update(id: string, dto: Update${t}DTO): Promise<${t}ResponseDTO> {
-    const existing = await this.prisma.${a}.findUnique({ where: { id } })
-    if (!existing) throw HttpException.notFound('${t} not found')
-    return this.prisma.${a}.update({ where: { id }, data: dto as Record<string, unknown> }) as Promise<${t}ResponseDTO>
-  }
-
-  async delete(id: string): Promise<void> {
-    await this.prisma.${a}.deleteMany({ where: { id } })
-  }
-}
-`}function Pe(e,t,n,r=[]){switch(t){case`cqrs`:{let t=[],i=[];return r.includes(`devtools`)&&(t.push(`import { DevToolsAdapter } from '@forinda/kickjs-devtools'`),i.push(`    DevToolsAdapter(),`)),r.includes(`swagger`)&&(t.push(`import { SwaggerAdapter } from '@forinda/kickjs-swagger'`),i.push(`    SwaggerAdapter({\n      info: { title: '${e}', version: '${n}' },\n    }),`)),`import 'reflect-metadata'
-// Side-effect import — registers the extended env schema with kickjs
-// **before** any controller / service / @Value gets resolved. Without
-// this line ConfigService.get('YOUR_KEY') returns undefined because the
-// cached schema would still be the base shape. See guide/configuration.
-import './config'
-import { bootstrap } from '@forinda/kickjs'
-// import { WsAdapter } from '@forinda/kickjs-ws'
-// import { QueueAdapter, BullMQProvider } from '@forinda/kickjs-queue'
-${t.length?t.join(`
-`)+`
-`:``}import { modules } from './modules'
-
-// Export the app for the Vite plugin (dev mode)
-export const app = await bootstrap({
-  modules,${t.length?`\n  adapters: [\n${i.join(`
-`)}\n    // Uncomment for WebSocket support:\n    // WsAdapter(),\n    // Uncomment when Redis is available:\n    // QueueAdapter({\n    //   provider: new BullMQProvider({ host: 'localhost', port: 6379 }),\n    // }),\n  ],`:`
-  adapters: [
-    // Uncomment for WebSocket support:
-    // WsAdapter(),
-    // Uncomment when Redis is available:
-    // QueueAdapter({
-    //   provider: new BullMQProvider({ host: 'localhost', port: 6379 }),
-    // }),
-  ],`}
-})
-`}case`minimal`:{let t=[],i=[];return r.includes(`swagger`)&&(t.push(`import { SwaggerAdapter } from '@forinda/kickjs-swagger'`),i.push(`    SwaggerAdapter({ info: { title: '${e}', version: '${n}' } }),`)),r.includes(`devtools`)&&(t.push(`import { DevToolsAdapter } from '@forinda/kickjs-devtools'`),i.push(`    DevToolsAdapter(),`)),`import 'reflect-metadata'
-// Side-effect import — registers the extended env schema with kickjs
-// **before** any controller / service / @Value gets resolved. Without
-// this line ConfigService.get('YOUR_KEY') returns undefined because the
-// cached schema would still be the base shape. See guide/configuration.
-import './config'
-import { bootstrap } from '@forinda/kickjs'
-${t.length?t.join(`
-`)+`
-`:``}import { modules } from './modules'
-
-// Export the app for the Vite plugin (dev mode)
-export const app = await bootstrap({ modules${i.length?`,\n  adapters: [\n${i.join(`
-`)}\n  ]`:``} })
-`}default:{let t=[],i=[];return r.includes(`devtools`)&&(t.push(`import { DevToolsAdapter } from '@forinda/kickjs-devtools'`),i.push(`    DevToolsAdapter(),`)),r.includes(`swagger`)&&(t.push(`import { SwaggerAdapter } from '@forinda/kickjs-swagger'`),i.push(`    SwaggerAdapter({\n      info: { title: '${e}', version: '${n}' },\n    }),`)),`import 'reflect-metadata'
-// Side-effect import — registers the extended env schema with kickjs
-// **before** any controller / service / @Value gets resolved. Without
-// this line ConfigService.get('YOUR_KEY') returns undefined because the
-// cached schema would still be the base shape. See guide/configuration.
-import './config'
-import express from 'express'
-import {
-  bootstrap,
-  requestId,
-  requestLogger,
-  helmet,
-  cors,
-} from '@forinda/kickjs'
-${t.length?t.join(`
-`)+`
-`:``}import { modules } from './modules'
-
-// Export the app for the Vite plugin (dev mode)
-export const app = await bootstrap({
-  modules,${i.length?`\n  adapters: [\n${i.join(`
-`)}\n  ],`:``}
-  middleware: [
-    helmet(),
-    cors({ origin: '*' }),
-    requestId(),
-    requestLogger(),
-    express.json(),
-  ],
-})
-`}}}function Fe(){return`import { defineModules } from '@forinda/kickjs'
-import { HelloModule } from './hello/hello.module'
-
-// Remove HelloModule and run: kick g module <name>
-// \`defineModules()\` returns a chainable list — \`kick g module\` appends
-// \`.mount(NewModule())\` to the chain on every generation.
-export const modules = defineModules().mount(HelloModule())
-`}function Ie(){return`import { defineEnv, loadEnv } from '@forinda/kickjs/config'
-import { z } from 'zod'
-
-/**
- * Project environment schema.
- *
- * Extend the base schema with your application's variables. The
- * default export is the contract \`kick typegen\` reads to populate
- * the global \`KickEnv\` registry — that's what makes \`@Value('FOO')\`
- * autocomplete and \`process.env.FOO\` typed.
- *
- * @example
- *   DATABASE_URL: z.string().url(),
- *   JWT_SECRET: z.string().min(32),
- *   REDIS_URL: z.string().url().optional(),
- */
-const envSchema = defineEnv((base) =>
-  base.extend({
-    // DATABASE_URL: z.string().url(),
-  }),
-)
-
-/**
- * IMPORTANT — side effect: register the schema with kickjs's env cache
- * **at module-load time**. \`ConfigService\` and \`@Value()\` both consume
- * this cache, and they will fall back to the base schema (or undefined)
- * if no extended schema has been registered before they're resolved.
- *
- * As long as \`src/index.ts\` imports this file (\`import './env'\`) at the
- * top — before \`bootstrap()\` runs — every controller and service in the
- * app sees the typed extended values.
- */
-export const env = loadEnv(envSchema)
-
-export default envSchema
-`}function Le(){return`import { Service } from '@forinda/kickjs'
-
-@Service()
-export class HelloService {
-  greet(name: string) {
-    return { message: \`Hello \${name} from KickJS!\`, timestamp: new Date().toISOString() }
-  }
-
-  healthCheck() {
-    return { status: 'ok', uptime: process.uptime() }
-  }
-}
-`}function Re(){return`import { Controller, Get, Autowired, type Ctx } from '@forinda/kickjs'
-import { HelloService } from './hello.service'
-
-// \`Ctx<KickRoutes.HelloController['<method>']>\` is generated by
-// \`kick typegen\` (auto-run on \`kick dev\`). The first run after a fresh
-// scaffold creates \`.kickjs/types/routes.ts\` so this file typechecks.
-// See https://forinda.github.io/kick-js/guide/typegen.
-
-@Controller()
-export class HelloController {
-  @Autowired() private readonly helloService!: HelloService
-
-  @Get('/')
-  index(ctx: Ctx<KickRoutes.HelloController['index']>) {
-    ctx.json(this.helloService.greet('World'))
-  }
-
-  @Get('/health')
-  health(ctx: Ctx<KickRoutes.HelloController['health']>) {
-    ctx.json(this.helloService.healthCheck())
-  }
-}
-`}function ze(){return`import { defineModule } from '@forinda/kickjs'
-import { HelloController } from './hello.controller'
-
-export const HelloModule = defineModule({
-  name: 'HelloModule',
-  build: () => ({
-    // \`register(container)\` is optional — only implement it when you need
-    // to bind a token to a concrete implementation, e.g.
-    //   register(container) {
-    //     container.registerFactory(USER_REPOSITORY, () => container.resolve(InMemoryUserRepository))
-    //   }
-    // The HelloService uses @Service() so the decorator handles registration.
-
-    routes() {
-      return {
-        path: '/hello',
-        controller: HelloController,
-      }
-    },
-  }),
-})
-`}function Be(e,t=`inmemory`,n=`pnpm`){return`import { defineConfig } from '@forinda/kickjs-cli'
-
-export default defineConfig({
-  pattern: '${e}',
-  // Pinned so \`kick add\` and other dep-installing commands always use the
-  // project's intended package manager, regardless of which lockfile exists.
-  packageManager: '${n}',
-  modules: {
-    dir: 'src/modules',
-    repo: ${[`drizzle`,`inmemory`,`prisma`].includes(t)?`'${t}'`:`{ name: '${t}' }`},
-    pluralize: true,
-  },
-
-  // \`kick typegen\` populates \`.kickjs/types/\` so \`Ctx<KickRoutes.X['method']>\`
-  // resolves to fully-typed params/body/query. Auto-runs on \`kick dev\`.
-  // Set \`schemaValidator: false\` to skip schema-driven body typing entirely.
-  typegen: {
-    schemaValidator: 'zod',
-  },
-
-  commands: [
-    {
-      name: 'test',
-      description: 'Run tests with Vitest',
-      steps: 'npx vitest run',
-    },
-    {
-      name: 'format',
-      description: 'Format code with Prettier',
-      steps: 'npx prettier --write src/',
-    },
-    {
-      name: 'format:check',
-      description: 'Check formatting without writing',
-      steps: 'npx prettier --check src/',
-    },
-    {
-      name: 'ci:check',
-      description: 'Run typecheck + format check',
-      steps: ['npx tsc --noEmit', 'npx prettier --check src/'],
-      aliases: ['verify'],
-    },
-  ],
-})
-`}async function Ve(e){let{pascal:t,kebab:n,plural:r,style:i,write:a}=e;await a(`${n}.module.ts`,ye({pascal:t,kebab:n,plural:r,style:i})),await a(`${n}.controller.ts`,`import { Controller, Get, type Ctx } from '@forinda/kickjs'
-
-// \`Ctx<KickRoutes.${t}Controller['<method>']>\` is generated by
-// \`kick typegen\` (auto-run on \`kick dev\`).
-
-@Controller()
-export class ${t}Controller {
-  @Get('/')
-  async list(ctx: Ctx<KickRoutes.${t}Controller['list']>) {
-    ctx.json({ message: '${t} list' })
-  }
-}
-`)}async function He(e){let{pascal:t,kebab:n,plural:r,pluralPascal:i,repo:a,noTests:o,prismaClientPath:s,tokenScope:c,style:l,write:u}=e;await u(`${n}.module.ts`,ve({pascal:t,kebab:n,plural:r,repo:a,style:l})),await u(`${n}.constants.ts`,W({pascal:t,kebab:n})),await u(`${n}.controller.ts`,xe({pascal:t,kebab:n,plural:r,pluralPascal:i})),await u(`${n}.service.ts`,De({pascal:t,kebab:n})),await u(`dtos/create-${n}.dto.ts`,I({pascal:t,kebab:n})),await u(`dtos/update-${n}.dto.ts`,L({pascal:t,kebab:n})),await u(`dtos/${n}-response.dto.ts`,R({pascal:t,kebab:n})),await u(`${n}.repository.ts`,z({pascal:t,kebab:n,dtoPrefix:`./dtos`,tokenScope:c}));let d={inmemory:`in-memory-${n}`,drizzle:`drizzle-${n}`,prisma:`prisma-${n}`},f={inmemory:()=>B({pascal:t,kebab:n,repoPrefix:`.`,dtoPrefix:`./dtos`}),drizzle:()=>G({pascal:t,kebab:n,repoPrefix:`.`,dtoPrefix:`./dtos`}),prisma:()=>K({pascal:t,kebab:n,repoPrefix:`.`,dtoPrefix:`./dtos`,prismaClientPath:s})},p=d[a]??`${k(a)}-${n}`,m=f[a]??(()=>V({pascal:t,kebab:n,repoType:a,repoPrefix:`.`,dtoPrefix:`./dtos`}));await u(`${p}.repository.ts`,m()),o||(a!==`inmemory`&&await u(`in-memory-${n}.repository.ts`,B({pascal:t,kebab:n,repoPrefix:`.`,dtoPrefix:`./dtos`})),await u(`__tests__/${n}.controller.test.ts`,H({pascal:t,kebab:n,plural:r})),await u(`__tests__/${n}.repository.test.ts`,U({pascal:t,kebab:n,plural:r,repoPrefix:`../${d.inmemory??`in-memory-${n}`}.repository`})))}async function Ue(e){let{pascal:t,kebab:n,plural:r,pluralPascal:i,repo:a,noTests:o,prismaClientPath:s,tokenScope:c,style:l,write:u}=e;await u(`${n}.module.ts`,Oe({pascal:t,kebab:n,plural:r,repo:a,style:l})),await u(`${n}.constants.ts`,W({pascal:t,kebab:n})),await u(`${n}.controller.ts`,ke({pascal:t,kebab:n,plural:r,pluralPascal:i})),await u(`dtos/create-${n}.dto.ts`,I({pascal:t,kebab:n})),await u(`dtos/update-${n}.dto.ts`,L({pascal:t,kebab:n})),await u(`dtos/${n}-response.dto.ts`,R({pascal:t,kebab:n}));let d=Ae({pascal:t,kebab:n});for(let e of d)await u(`commands/${e.file}`,e.content);let f=je({pascal:t,kebab:n,plural:r,pluralPascal:i});for(let e of f)await u(`queries/${e.file}`,e.content);let p=Me({pascal:t,kebab:n});for(let e of p)await u(`events/${e.file}`,e.content);await u(`${n}.repository.ts`,z({pascal:t,kebab:n,dtoPrefix:`./dtos`,tokenScope:c}));let m={inmemory:`in-memory-${n}`,drizzle:`drizzle-${n}`,prisma:`prisma-${n}`},h={inmemory:()=>B({pascal:t,kebab:n,repoPrefix:`.`,dtoPrefix:`./dtos`}),drizzle:()=>G({pascal:t,kebab:n,repoPrefix:`.`,dtoPrefix:`./dtos`}),prisma:()=>K({pascal:t,kebab:n,repoPrefix:`.`,dtoPrefix:`./dtos`,prismaClientPath:s})},g=m[a]??`${k(a)}-${n}`,_=h[a]??(()=>V({pascal:t,kebab:n,repoType:a,repoPrefix:`.`,dtoPrefix:`./dtos`}));await u(`${g}.repository.ts`,_()),o||(a!==`inmemory`&&await u(`in-memory-${n}.repository.ts`,B({pascal:t,kebab:n,repoPrefix:`.`,dtoPrefix:`./dtos`})),await u(`__tests__/${n}.controller.test.ts`,H({pascal:t,kebab:n,plural:r})),await u(`__tests__/${n}.repository.test.ts`,U({pascal:t,kebab:n,plural:r,repoPrefix:`../${m.inmemory??`in-memory-${n}`}.repository`})))}async function We(e){let{pascal:t,kebab:n,plural:r,pluralPascal:i,repo:a,noEntity:o,noTests:s,prismaClientPath:c,tokenScope:l,style:u,write:d}=e;await d(`${n}.module.ts`,_e({pascal:t,kebab:n,plural:r,repo:a,style:u})),await d(`constants.ts`,a===`drizzle`?Ne({pascal:t,kebab:n}):Se({pascal:t,kebab:n})),await d(`presentation/${n}.controller.ts`,be({pascal:t,kebab:n,plural:r,pluralPascal:i})),await d(`application/dtos/create-${n}.dto.ts`,I({pascal:t,kebab:n})),await d(`application/dtos/update-${n}.dto.ts`,L({pascal:t,kebab:n})),await d(`application/dtos/${n}-response.dto.ts`,R({pascal:t,kebab:n}));let f=Ce({pascal:t,kebab:n,plural:r,pluralPascal:i});for(let e of f)await d(`application/use-cases/${e.file}`,e.content);await d(`domain/repositories/${n}.repository.ts`,z({pascal:t,kebab:n,tokenScope:l})),await d(`domain/services/${n}-domain.service.ts`,we({pascal:t,kebab:n}));let p={inmemory:`in-memory-${n}`,drizzle:`drizzle-${n}`,prisma:`prisma-${n}`},m={inmemory:()=>B({pascal:t,kebab:n}),drizzle:()=>G({pascal:t,kebab:n}),prisma:()=>K({pascal:t,kebab:n,prismaClientPath:c})},h=p[a]??`${k(a)}-${n}`,g=m[a]??(()=>V({pascal:t,kebab:n,repoType:a}));await d(`infrastructure/repositories/${h}.repository.ts`,g()),o||(await d(`domain/entities/${n}.entity.ts`,Te({pascal:t,kebab:n})),await d(`domain/value-objects/${n}-id.vo.ts`,Ee({pascal:t,kebab:n}))),s||(a!==`inmemory`&&await d(`infrastructure/repositories/in-memory-${n}.repository.ts`,B({pascal:t,kebab:n})),await d(`__tests__/${n}.controller.test.ts`,H({pascal:t,kebab:n,plural:r})),await d(`__tests__/${n}.repository.test.ts`,U({pascal:t,kebab:n,plural:r})))}function Ge(e){return e?typeof e==`string`?e:e.name:`inmemory`}async function Ke(e){let{name:t,modulesDir:n,noEntity:r,noTests:a,repo:o=`inmemory`,force:s,dryRun:c}=e,l=e.pluralize!==!1,u=e.pattern??`ddd`;e.minimal&&(u=`minimal`);let d=k(t),f=D(t),m=l?A(d):d,h=l?me(f):f,g=i(n,m),_=[],v=s??!1,y={kebab:d,pascal:f,plural:m,pluralPascal:h,moduleDir:g,repo:o,noEntity:r??!1,noTests:a??!1,prismaClientPath:e.prismaClientPath??`@prisma/client`,tokenScope:e.tokenScope??`app`,style:e.style??`define`,write:async(e,t)=>{let n=i(g,e);if(c){_.push(n);return}if(!v&&await C(n)&&!await T({message:`File exists: ${p.dim(e)}. Overwrite?`,initialValue:!1})){E.warn(`Skipped: ${e}`);return}await b(n,t),_.push(n)},files:_};switch(u){case`minimal`:await Ve(y);break;case`rest`:await He(y);break;case`cqrs`:await Ue(y);break;default:await We(y);break}return c||await q(n,f,m,d,y.style),_}async function q(e,t,n,r,a=`define`){let o=i(e,`index.ts`),s=await C(o),c=`./${n}/${r}.module`,l=a===`class`?`${t}Module`:`${t}Module()`;if(!s){await b(o,a===`class`?`import type { AppModuleEntry } from '@forinda/kickjs'
-import { ${t}Module } from '${c}'
-
-export const modules: AppModuleEntry[] = [${l}]
-`:`import { defineModules } from '@forinda/kickjs'
-import { ${t}Module } from '${c}'
-
-export const modules = defineModules().mount(${l})
-`);return}let f=await u(o,`utf-8`),p=`import { ${t}Module } from '${c}'`,m=j(c);if(!RegExp(`^import\\s*\\{[^}]*\\b${j(t)}Module\\b[^}]*\\}\\s*from\\s*['"]${m}['"]`,`m`).test(f)){let e=f.lastIndexOf(`import `);if(e!==-1){let t=f.indexOf(`
-`,e);f=f.slice(0,t+1)+p+`
-`+f.slice(t+1)}else f=p+`
-`+f}let h=Y(f);if(h){let e=f.slice(h.rhsStart,h.rhsEnd+1);RegExp(`\\b${j(t)}Module\\b`).test(e)||(f=J(f,l))}else f=J(f,l);await d(o,f,`utf-8`)}function J(e,t){let n=Y(e);if(!n)return e;if(n.shape===`array`){let r=e.slice(n.rhsStart+1,n.rhsEnd),i=r.trim(),a;if(!i)a=`[${t}]`;else{let e=i.endsWith(`,`)?``:`,`;a=`[${r.trimEnd()}${e} ${t}]`}return e.slice(0,n.rhsStart)+a+e.slice(n.rhsEnd+1)}return`${e.slice(0,n.chainEnd)}\n  .mount(${t})${e.slice(n.chainEnd)}`}function Y(e){let t=/export\s+const\s+modules\b[^=]*=/.exec(e);if(!t)return null;let n=t.index+t[0].length;for(;n<e.length&&/\s/.test(e[n]??``);)n++;if(e[n]===`[`){let t=Je(e,n);return t===-1?null:{shape:`array`,rhsStart:n,rhsEnd:t}}if(e.slice(n,n+13)===`defineModules`){let t=qe(e,n);return t===-1?null:{shape:`chain`,rhsStart:n,rhsEnd:t-1,chainEnd:t}}return null}function qe(e,t=0){let n=/defineModules\s*\(/g;n.lastIndex=t;let r=n.exec(e);if(!r)return-1;let i=r.index+r[0].length-1;if(e[i]!==`(`||(i=Z(e,i),i===-1))return-1;for(i++;;){let t=i;for(;t<e.length&&/\s/.test(e[t]??``);)t++;if(e[t]!==`.`||e.slice(t,t+6)!==`.mount`)break;for(t+=6;t<e.length&&/\s/.test(e[t]??``);)t++;if(e[t]!==`(`)break;let n=Z(e,t);if(n===-1)break;i=n+1}return i}function X(e,t){let n=e.slice(t,t+2);if(n===`//`){for(t+=2;t<e.length&&e[t]!==`
-`;)t++;return t}if(n===`/*`){for(t+=2;t+1<e.length&&!(e[t]===`*`&&e[t+1]===`/`);)t++;return t+2}return t}function Je(e,t){if(e[t]!==`[`)return-1;let n=1,r=t+1;for(;r<e.length;){let t=e.slice(r,r+2);if(t===`//`||t===`/*`){r=X(e,r);continue}let i=e[r]??``;if(i===`'`||i===`"`||i==="`"){let t=i;for(r++;r<e.length&&e[r]!==t;)e[r]===`\\`&&r++,r++;r<e.length&&r++;continue}if(i===`[`)n++;else if(i===`]`&&(n--,n===0))return r;r++}return-1}function Z(e,t){if(e[t]!==`(`)return-1;let n=1,r=t+1;for(;r<e.length;){let t=e.slice(r,r+2);if(t===`//`||t===`/*`){r=X(e,r);continue}let i=e[r]??``;if(i===`'`||i===`"`||i==="`"){let t=i;for(r++;r<e.length&&e[r]!==t;)e[r]===`\\`&&r++,r++;r<e.length&&r++;continue}if(i===`(`)n++;else if(i===`)`&&(n--,n===0))return r;r++}return-1}async function Ye(e){let{name:t,outDir:n}=e,r=k(t),a=D(t),o=[],s=i(n,`${r}.adapter.ts`);return await b(s,`import {
-  defineAdapter,
-  type AdapterContext,
-  type AdapterMiddleware,
-  type ContributorRegistrations,
-  type Constructor,
-} from '@forinda/kickjs'
-
-/**
- * Configuration for the ${a} adapter.
- *
- * Adapters typically take a small config object so callers can tune
- * behaviour at bootstrap time. Keep the shape narrow — anything
- * derived from the environment should be read inside the build
- * function via getEnv(), not forced onto the caller.
- */
-export interface ${a}AdapterConfig {
-  // Add your adapter configuration here, e.g.:
-  // enabled?: boolean
-  // apiKey?: string
-}
-
-/**
- * ${a} adapter — built via \`defineAdapter()\` so callers get the
- * factory's call / \`.scoped()\` / \`.async()\` surfaces for free.
- *
- * Hooks into the Application lifecycle to add middleware, routes,
- * Context Contributors, or external service connections.
- *
- * Every lifecycle hook below is OPTIONAL. The scaffold emits all of
- * them so adopters can browse what's available and delete what they
- * don't need — \`build()\` returning \`{}\` is also valid for an adapter
- * that only contributes config defaults.
- *
- * @example
- * \`\`\`ts
- * import { bootstrap } from '@forinda/kickjs'
- * import { ${a}Adapter } from './adapters/${r}.adapter'
- *
- * bootstrap({
- *   modules,
- *   adapters: [${a}Adapter({ /* config overrides *\\/ })],
- * })
- * \`\`\`
- */
-export const ${a}Adapter = defineAdapter<${a}AdapterConfig>({
-  name: '${a}Adapter',
-  defaults: {
-    // Default config values go here. The adopter's overrides shallow-merge
-    // on top of these before \`build()\` runs.
-  },
-  build: (_config, { name: _name }) => {
-    // Closures inside \`build()\` are how each adapter instance owns its
-    // own state (database client, Map, timer handle, …). The same
-    // \`_config\` is visible to every hook below.
-
-    return {
-      /**
-       * Express middleware entries the Application mounts at named phases.
-       *
-       * \`phase\` controls where each handler sits in the pipeline:
-       *   'beforeGlobal' | 'afterGlobal' | 'beforeRoutes' | 'afterRoutes'.
-       *
-       * \`path\` (optional) scopes the entry to a path prefix.
-       *
-       * Delete this hook entirely if you don't add middleware.
-       */
-      middleware(): AdapterMiddleware[] {
-        return [
-          // Example: add a custom header to all responses
-          // {
-          //   phase: 'beforeGlobal',
-          //   handler: (_req, res, next) => {
-          //     res.setHeader('X-${a}', 'true')
-          //     next()
-          //   },
-          // },
-          // Example: scope a rate limiter to one path prefix
-          // {
-          //   phase: 'beforeRoutes',
-          //   path: '/api/v1/auth',
-          //   handler: rateLimit({ max: 10 }),
-          // },
-        ]
-      },
-
-      /**
-       * Runs BEFORE global middleware. Mount routes that should bypass the
-       * middleware stack — health checks, docs UI, static assets, OAuth
-       * callbacks. Anything you want reachable even if a global middleware
-       * later in the chain rejects requests.
-       *
-       * Delete this hook if you have no early routes.
-       */
-      beforeMount(_ctx: AdapterContext): void {
-        // Example:
-        // _ctx.app.get('/${r}/status', (_req, res) => res.json({ status: 'ok' }))
-      },
-
-      /**
-       * Fires once per controller class as the router mounts. Use this to
-       * collect route metadata for OpenAPI specs, dependency graphs, route
-       * inventories, devtools dashboards.
-       *
-       * Delete this hook unless your adapter introspects the route registry.
-       */
-      onRouteMount(_controllerClass: Constructor, _mountPath: string): void {
-        // Example (Swagger-style): collect routes for the spec.
-        // openApiSpec.addController(_controllerClass, _mountPath)
-      },
-
-      /**
-       * Runs AFTER modules + routes are wired, BEFORE the server starts.
-       * Right place for late-stage DI registrations or final config validation.
-       *
-       * Delete this hook if there's nothing to wire post-modules.
-       */
-      beforeStart(_ctx: AdapterContext): void {
-        // Example: _ctx.container.registerInstance(MY_TOKEN, new MyService(_config))
-      },
-
-      /**
-       * Runs AFTER the HTTP server is listening. The raw \`http.Server\` is
-       * available on \`ctx.server\` — attach upgrade handlers (Socket.IO,
-       * gRPC, GraphQL subscriptions), warm caches, log a banner.
-       *
-       * Delete this hook if you don't need the running server reference.
-       */
-      afterStart(_ctx: AdapterContext): void {
-        // Example: const io = new Server(_ctx.server)
-      },
-
-      /**
-       * Returns Context Contributors to merge into every route's pipeline
-       * at the \`'adapter'\` precedence level. Per-route handlers can
-       * override the value at the method / class / module level.
-       *
-       * Delete this hook unless your adapter ships typed per-request values
-       * (auth user, tenant, locale, feature flags, geo, etc).
-       */
-      contributors(): ContributorRegistrations {
-        return [
-          // Example:
-          // import { defineHttpContextDecorator } from '@forinda/kickjs'
-          // declare module '@forinda/kickjs' { interface ContextMeta { ${r}: { id: string } } }
-          // const Load${a} = defineHttpContextDecorator({
-          //   key: '${r}',
-          //   resolve: (ctx) => ({ id: ctx.req.headers['x-${r}-id'] as string }),
-          // })
-          // return [Load${a}.registration]
-        ]
-      },
-
-      /**
-       * Runs on graceful shutdown (SIGINT/SIGTERM). Clean up long-lived
-       * resources the adapter owns: close connections, flush buffers,
-       * cancel timers. The framework runs every adapter's \`shutdown\`
-       * concurrently via \`Promise.allSettled\` — one failure won't block
-       * sibling adapters.
-       *
-       * Delete this hook if your adapter holds no resources.
-       */
-      async shutdown(): Promise<void> {
-        // Example: await this.pool.end()
-        // Example: clearInterval(this.heartbeatTimer)
-      },
-    }
-  },
-})
-`),o.push(s),o}const Xe={controller:`presentation`,service:`domain/services`,dto:`application/dtos`,guard:`presentation/guards`,middleware:`middleware`},Ze={controller:``,service:``,dto:`dtos`,guard:`guards`,middleware:`middleware`},Qe={controller:``,service:``,dto:`dtos`,guard:`guards`,middleware:`middleware`,command:`commands`,query:`queries`,event:`events`};function Q(e){let{type:t,outDir:n,moduleName:r,modulesDir:o=`src/modules`,defaultDir:s,pattern:c=`ddd`,shouldPluralize:l=!0}=e;if(n)return a(n);if(r){let e=c===`ddd`?Xe:c===`cqrs`?Qe:Ze,n=k(r),s=l?A(n):n,u=e[t]??``,d=i(o,s);return a(u?i(d,u):d)}return a(s)}async function $e(e){let{name:t,moduleName:n,modulesDir:r,pattern:a}=e,o=Q({type:`middleware`,outDir:e.outDir,moduleName:n,modulesDir:r,defaultDir:`src/middleware`,pattern:a,shouldPluralize:e.pluralize??!0}),s=k(t),c=O(t),l=[],u=i(o,`${s}.middleware.ts`);return await b(u,`import type { Request, Response, NextFunction } from 'express'
-
-export interface ${D(t)}Options {
-  // Add configuration options here. The factory below closes over the
-  // resolved options object; pass them at the call site —
-  // \`${c}({ foo: 'bar' })\` — and the closure preserves them across
-  // every request.
-}
-
-/**
- * ${D(t)} middleware.
- *
- * Usage in bootstrap (fires on every request):
- *   middleware: [${c}()]
- *
- * Usage with adapter — phase controls *when* the handler runs:
- *
- *   middleware() {
- *     return [{ handler: ${c}(), phase: 'afterGlobal' }]
- *   }
- *
- * Phase semantics (see \`MiddlewarePhase\` JSDoc for the full contract):
- *   - 'beforeGlobal' / 'afterGlobal' / 'beforeRoutes' — fire on every
- *     request, before module routes run.
- *   - 'afterRoutes' — fires ONLY when no route matched (404 fall-through)
- *     OR a route handler called \`next()\` without ending the response.
- *     Controllers that call \`ctx.json(…)\` end the chain and skip this
- *     phase. For per-response work (logging, metrics) attach to
- *     \`res.on('finish', …)\` from an earlier-phase middleware instead.
- *
- * Optional path scope — string, RegExp, or array of either:
- *   middleware() {
- *     return [{
- *       handler: ${c}({ region: 'eu' }),
- *       phase: 'afterGlobal',
- *       path: ['/api', /^\\/admin/],
- *     }]
- *   }
- *
- * Usage with @Middleware decorator:
- *   @Middleware(${c}())
- */
-export function ${c}(options: ${D(t)}Options = {}) {
-  return (req: Request, res: Response, next: NextFunction) => {
-    // Implement your middleware logic here. \`options\` is captured by
-    // closure — log or read it anywhere in this handler body.
-    void options
-    next()
-  }
-}
-`),l.push(u),l}async function et(e){let{name:t,moduleName:n,modulesDir:r,pattern:a}=e,o=Q({type:`guard`,outDir:e.outDir,moduleName:n,modulesDir:r,defaultDir:`src/guards`,pattern:a,shouldPluralize:e.pluralize??!0}),s=k(t),c=O(t),l=D(t),u=[],d=i(o,`${s}.guard.ts`);return await b(d,`import { Container, HttpException } from '@forinda/kickjs'
-import type { RequestContext } from '@forinda/kickjs'
-
-/**
- * ${l} guard.
- *
- * Guards protect routes by checking conditions before the handler runs.
- * Return early with an error response to block access.
- *
- * Usage:
- *   @Middleware(${c}Guard)
- *   @Get('/protected')
- *   async handler(ctx: RequestContext) { ... }
- */
-export async function ${c}Guard(ctx: RequestContext, next: () => void): Promise<void> {
-  // Example: check for an authorization header
-  const header = ctx.headers.authorization
-  if (!header?.startsWith('Bearer ')) {
-    ctx.res.status(401).json({ message: 'Missing or invalid authorization header' })
-    return
-  }
-
-  const token = header.slice(7)
-
-  try {
-    // Verify the token using a service from the DI container
-    // const container = Container.getInstance()
-    // const authService = container.resolve(AuthService)
-    // const payload = authService.verifyToken(token)
-    // ctx.set('auth', payload)
-
-    next()
-  } catch {
-    ctx.res.status(401).json({ message: 'Invalid or expired token' })
-  }
-}
-`),u.push(d),u}async function tt(e){let{name:t,moduleName:n,modulesDir:r,pattern:a}=e,o=Q({type:`service`,outDir:e.outDir,moduleName:n,modulesDir:r,defaultDir:`src/services`,pattern:a,shouldPluralize:e.pluralize??!0}),s=k(t),c=D(t),l=[],u=i(o,`${s}.service.ts`);return await b(u,`import { Service } from '@forinda/kickjs'
-
-@Service()
-export class ${c}Service {
-  // Inject dependencies via constructor
-  // constructor(
-  //   @Inject(MY_REPO) private readonly repo: IMyRepository,
-  // ) {}
-}
-`),l.push(u),l}async function nt(e){let{name:t,moduleName:n,modulesDir:r,pattern:a}=e,o=Q({type:`controller`,outDir:e.outDir,moduleName:n,modulesDir:r,defaultDir:`src/controllers`,pattern:a,shouldPluralize:e.pluralize??!0}),s=k(t),c=D(t),l=[],u=i(o,`${s}.controller.ts`);return await b(u,`import { Controller, Get, Post, type Ctx } from '@forinda/kickjs'
-
-// \`Ctx<KickRoutes.${c}Controller['<method>']>\` is generated by
-// \`kick typegen\` (auto-run on \`kick dev\`). After the first run, your IDE
-// will autocomplete \`ctx.params\`, \`ctx.body\`, and \`ctx.query\`.
-// See https://forinda.github.io/kick-js/guide/typegen for details.
-
-@Controller()
-export class ${c}Controller {
-  // @Autowired() private readonly myService!: MyService
-
-  @Get('/')
-  async list(ctx: Ctx<KickRoutes.${c}Controller['list']>) {
-    ctx.json({ message: '${c} list' })
-  }
-
-  @Post('/')
-  async create(ctx: Ctx<KickRoutes.${c}Controller['create']>) {
-    ctx.created({ message: '${c} created', data: ctx.body })
-  }
-}
-`),l.push(u),l}async function rt(e){let{name:t,moduleName:n,modulesDir:r,pattern:a}=e,o=Q({type:`dto`,outDir:e.outDir,moduleName:n,modulesDir:r,defaultDir:`src/dtos`,pattern:a,shouldPluralize:e.pluralize??!0}),s=k(t),c=D(t),l=O(t),u=[],d=i(o,`${s}.dto.ts`);return await b(d,`import { z } from 'zod'
-
-export const ${l}Schema = z.object({
-  // Define your schema fields here
-  name: z.string().min(1).max(200),
-})
-
-export type ${c}DTO = z.infer<typeof ${l}Schema>
-`),u.push(d),u}const it={swagger:`@forinda/kickjs-swagger`,ws:`@forinda/kickjs-ws`,queue:`@forinda/kickjs-queue`,devtools:`@forinda/kickjs-devtools`};function $(e,t){let n=e[t];if(!n)throw Error(`generatePackageJson: missing resolved version for ${t}. Add it to SIBLING_PACKAGES in generators/project.ts.`);return n}function at(e,t,n,r=[]){let i={"@forinda/kickjs":$(n,`@forinda/kickjs`),dotenv:`^17.3.1`,express:`^5.1.0`,"reflect-metadata":`^0.2.2`,zod:`^4.3.6`,pino:`^10.3.1`,"pino-pretty":`^13.1.3`};for(let e of r){let t=it[e];t&&!i[t]&&(i[t]=$(n,t))}return JSON.stringify({name:e,version:`0.0.0`,type:`module`,scripts:{dev:`vite`,"dev:debug":`kick dev:debug`,build:`kick build`,start:`kick start`,test:`vitest run`,"test:watch":`vitest`,typecheck:`tsc --noEmit`,typegen:`kick typegen`,lint:`eslint src/`,format:`prettier --write src/`},dependencies:i,devDependencies:{"@forinda/kickjs-cli":$(n,`@forinda/kickjs-cli`),"@forinda/kickjs-vite":$(n,`@forinda/kickjs-vite`),"@swc/core":`^1.15.21`,"@types/express":`^5.0.6`,"@types/node":`^25.0.0`,"unplugin-swc":`^1.5.9`,vite:`^8.0.3`,vitest:`^4.1.2`,typescript:`^6.0.3`,prettier:`^3.8.1`}},null,2)}function ot(){return`import { defineConfig } from 'vite'
-import { resolve } from 'node:path'
-import swc from 'unplugin-swc'
-import { kickjsVitePlugin, envWatchPlugin } from '@forinda/kickjs-vite'
-
-export default defineConfig({
-  oxc: false,
-  plugins: [
-    swc.vite(),
-    kickjsVitePlugin({ entry: 'src/index.ts' }),
-    // Watches .env files and triggers a full reload on change so the
-    // dev server picks up env tweaks without a manual restart.
-    envWatchPlugin(),
-  ],
-  resolve: {
-    alias: {
-      '@': resolve(__dirname, 'src'),
-    },
-  },
-  ssr: {
-    // Don't bundle pino — its worker-thread transport needs Node.js resolution
-    // to find pino-pretty at runtime for colored log output
-    external: ['pino', 'pino-pretty'],
-  },
-  build: {
-    target: 'node20',
-    ssr: true,
-    outDir: 'dist',
-    sourcemap: true,
-    rollupOptions: {
-      input: resolve(__dirname, 'src/index.ts'),
-      output: { format: 'esm' },
-    },
-  },
-})
-`}function st(){return JSON.stringify({compilerOptions:{target:`ES2022`,module:`ESNext`,moduleResolution:`bundler`,lib:[`ES2022`],types:[`node`,`vite/client`],strict:!0,esModuleInterop:!0,skipLibCheck:!0,sourceMap:!0,declaration:!0,experimentalDecorators:!0,emitDecoratorMetadata:!0,outDir:`dist`,paths:{"@/*":[`./src/*`]}},include:[`src`,`.kickjs/types/**/*.d.ts`,`.kickjs/types/**/*.ts`]},null,2)}function ct(){return JSON.stringify({semi:!1,singleQuote:!0,trailingComma:`all`,printWidth:100,tabWidth:2},null,2)}function lt(){return`# https://editorconfig.org
-root = true
-
-[*]
-indent_style = space
-indent_size = 2
-end_of_line = lf
-charset = utf-8
-trim_trailing_whitespace = true
-insert_final_newline = true
-
-[*.md]
-trim_trailing_whitespace = false
-`}function ut(){return`node_modules/
-dist/
-.env
-coverage/
-.DS_Store
-*.tsbuildinfo
-.kickjs/
-`}function dt(){return`# Auto-detect text files and normalise line endings to LF
-* text=auto eol=lf
-
-# Explicitly mark generated / binary files
-*.png binary
-*.jpg binary
-*.jpeg binary
-*.gif binary
-*.ico binary
-*.woff binary
-*.woff2 binary
-*.ttf binary
-*.eot binary
-
-# Lock files — treat as generated
-pnpm-lock.yaml -diff linguist-generated
-yarn.lock -diff linguist-generated
-package-lock.json -diff linguist-generated
-`}function ft(){return`PORT=3000
-NODE_ENV=development
-`}function pt(){return`PORT=3000
-NODE_ENV=development
-`}function mt(){return`import { defineConfig } from 'vitest/config'
-import swc from 'unplugin-swc'
-
-export default defineConfig({
-  plugins: [swc.vite()],
-  test: {
-    globals: true,
-    environment: 'node',
-    include: ['src/**/*.test.ts'],
-  },
-})
-`}function ht(e,t,n){let r={rest:`REST API`,ddd:`Domain-Driven Design`,cqrs:`CQRS + Event-Driven`,minimal:`Minimal`},i=[`@forinda/kickjs`,`@forinda/kickjs-vite`];return t!==`minimal`&&i.push(`@forinda/kickjs-swagger`,`@forinda/kickjs-devtools`),t===`cqrs`&&i.push(`@forinda/kickjs-queue`,`@forinda/kickjs-ws`),`# ${e}
-
-A **${r[t]??`REST API`}** built with [KickJS](https://forinda.github.io/kick-js/) — a decorator-driven Node.js framework on Express 5 and TypeScript.
-
-## Getting Started
-
-\`\`\`bash
-${n} install
-kick dev
-\`\`\`
-
-## Scripts
-
-| Command | Description |
-|---|---|
-| \`kick dev\` | Start dev server with Vite HMR |
-| \`kick build\` | Production build |
-| \`kick start\` | Run production build |
-| \`${n} run test\` | Run tests with Vitest |
-| \`kick g module <name>\` | Generate a DDD module |
-| \`kick g scaffold <name> <fields...>\` | Generate CRUD from field definitions |
-| \`kick add <package>\` | Add a KickJS package |
-
-## Project Structure
-
-\`\`\`
-src/
-├── index.ts           # Application entry point
-├── modules/           # Feature modules (controllers, services, repos)
-│   └── index.ts       # Module registry
-└── ...
-\`\`\`
-
-## Packages
-
-${i.map(e=>`- \`${e}\``).join(`
-`)}
-
-## Adding Features
-
-\`\`\`bash
-kick add auth          # Authentication (JWT, API key, OAuth)
-kick add swagger       # OpenAPI documentation
-kick add ws            # WebSocket support
-kick add queue         # Background job processing
-kick add --list        # Show all available packages
-\`\`\`
-
-For email, scheduled tasks, multi-tenancy, OpenTelemetry, GraphQL, and notifications use the BYO recipes in the [KickJS guides](https://forinda.github.io/kick-js/guide/) — they wire the upstream library through \`defineAdapter()\` / \`definePlugin()\` directly, so you keep control of the integration.
-
-## Environment Variables
-
-Copy \`.env.example\` to \`.env\` and configure:
-
-| Variable | Default | Description |
-|---|---|---|
-| \`PORT\` | \`3000\` | Server port |
-| \`NODE_ENV\` | \`development\` | Environment |
-
-## Learn More
-
-- [KickJS Documentation](https://forinda.github.io/kick-js/)
-- [CLI Reference](https://forinda.github.io/kick-js/api/cli.html)
-`}function gt(e,t,n){return`# CLAUDE.md — ${e}
-
-**Read \`./.agents/AGENTS.md\` first.** It is the canonical, multi-agent
-reference for this project (Claude, Copilot, Codex, Gemini, etc.) —
-project conventions, structure, decorator patterns, env wiring, CLI
-generators, every gotcha.
-
-**Then browse \`./.agents/skills/\`.** Each subdirectory is a single
-task-oriented skill (\`add-module/\`, \`write-controller-test/\`,
-\`bootstrap-export/\`, \`deny-list/\`, …) containing a \`SKILL.md\`
-with YAML frontmatter (\`name\`, \`description\`) and the recipe body.
-The structure follows the Claude Code skills convention — agents that
-auto-load skills from \`.agents/skills/\` will pick each up by its
-frontmatter. Use this directory as the playbook when executing common
-KickJS workflows.
-
-This file is a thin Claude-specific layer on top of those two; when
-they disagree on anything substantive, treat \`.agents/AGENTS.md\` as
-authoritative and flag the discrepancy.
-
-## Why \`.agents/\` + this thin pointer
-
-\`.agents/AGENTS.md\` is what every agent reads (Codex, Cursor, Gemini,
-Copilot, Aider, …) — one canonical source so the prose doesn't drift
-across copies. \`CLAUDE.md\` is what Claude Code automatically loads as
-project context on each conversation, so it stays at the project root.
-Keeping CLAUDE.md slim and pointing at \`.agents/\` avoids two
-out-of-sync copies of the same content. Per-agent files
-(\`.agents/GEMINI.md\`, \`.agents/COPILOT.md\`) live alongside
-\`AGENTS.md\` for tool-specific notes that don't belong in the shared
-prose.
-
-## Claude-specific notes
-
-- **Slash commands** — \`/help\` for Claude Code commands; \`/init\`
-  to refresh project memory if AGENTS.md changes substantially.
-- **Feedback** — file issues at <https://github.com/anthropics/claude-code/issues>.
-- **Persistent memory** — Claude maintains user/feedback/project/
-  reference memories under \`.claude/memory/\`. If you ask for
-  something that contradicts a remembered preference, Claude flags
-  it before acting; corrections update memory automatically.
-- **Long-running tasks** — \`/loop\` and \`/schedule\` for recurring
-  or background work. Useful for "wait for the deploy then open a
-  cleanup PR" or "every Monday triage the issue board" patterns.
-
-## Quick reference (full version in .agents/AGENTS.md)
-
-\`\`\`bash
-${n} install            # Install dependencies
-kick dev                 # Dev server with HMR + typegen
-kick build && kick start # Production
-${n} run test           # Vitest
-${n} run typecheck      # tsc --noEmit
-${n} run format         # Prettier
-\`\`\`
-
-## v4 framework reminders
-
-When generating or modifying code in this project, stay aligned with the v4 conventions documented in \`.agents/AGENTS.md\`:
-
-- **Adapters**: \`defineAdapter()\` factory — never \`class implements AppAdapter\`.
-- **Plugins**: \`definePlugin()\` factory — never plain function returning \`KickPlugin\`.
-- **DI tokens**: \`<scope>/<PascalKey>[/<suffix>]\` — scope is lowercase, the key segment is **PascalCase** (e.g. \`'app/Users/repository'\`, \`'mycorp/Cache/redis'\`). First-party uses the reserved \`'kick/'\` prefix; this project owns its own scope.
-- **Decorators**: \`@Controller()\` (no path arg — mount prefix comes from \`routes().path\`).
-- **Module entry file** MUST be named \`<name>.module.ts\` and live under \`src/modules/<name>/\`. The Vite plugin auto-discovers \`*.module.[tj]sx?\` for graceful HMR — a misnamed \`projects.ts\` silently degrades every save into a full restart.
-- **Env**: schema lives in \`src/config/index.ts\`; \`import './config'\` MUST be the first import in \`src/index.ts\` (side-effect registers the schema before any \`@Value\` resolves).
-- **Assets**: drop new template files into \`src/templates/<namespace>/\`; the dev watcher auto-rebuilds the \`KickAssets\` augmentation + \`assets.x.y()\` re-walks on next call. No restart, no manual build.
-- **Context Contributors** (\`defineContextDecorator\`) over \`@Middleware()\` for ctx-population work.
-- **Repos under tests**: \`Container.create()\` for isolation — never \`new Container()\` or \`getInstance().reset()\`.
-- **Bootstrap export**: \`src/index.ts\` must end with \`export const app = await bootstrap({ ... })\`. The Vite plugin and \`createTestApp\` import the named \`app\`; without the export, HMR silently degrades to full restarts.
-- **Thin entry file**: aggregate \`modules\`, \`middleware\`, \`plugins\`, \`adapters\` in their own folders (\`src/modules/index.ts\`, \`src/middleware/index.ts\`, …) and pass them by name to \`bootstrap()\` — never inline the lists in \`src/index.ts\`.
-- **Refresh these files**: \`kick g agents -f\` regenerates \`CLAUDE.md\` at the project root and \`.agents/AGENTS.md\` + \`.agents/GEMINI.md\` + \`.agents/COPILOT.md\` + every \`.agents/skills/<name>/SKILL.md\` from the latest CLI templates. Hand-edited content is overwritten — keep customisation in \`.agents/AGENTS.local.md\` or per-skill \`SKILL.local.md\` files alongside.
-
-For everything else (controllers, services, modules, RequestContext API, generators, CLI commands, package additions, env wiring, troubleshooting) → \`.agents/AGENTS.md\`.
-`}function _t(e,t,n){return`# AGENTS.md — AI Agent Guide for ${e}
-
-This guide is the **canonical, multi-agent reference** for this KickJS
-application — Claude, Copilot, Codex, Gemini, etc. all read it first.
-Per-agent files (\`CLAUDE.md\`, \`GEMINI.md\`, etc.) are thin layers that
-add tool-specific affordances on top.
-
-## Before You Start
-
-1. Run \`${n} install\` to install dependencies
-2. Run \`kick dev\` to verify the app starts
-3. Read the [KickJS documentation](https://forinda.github.io/kick-js/) for framework details
-
-## v4 Conventions (don't skip)
-
-KickJS v4 made a handful of structural changes from v3. Internalise these
-before generating or modifying code — they are the source of most agent
-mistakes:
-
-- **Adapters** — \`defineAdapter()\` factory. Never write \`class Foo implements AppAdapter\`.
-
-  \`\`\`ts
-  export const MyAdapter = defineAdapter<MyOptions>({
-    name: 'MyAdapter',
-    defaults: { ... },
-    build: (config) => ({
-      beforeMount({ app }) { /* ... */ },
-      afterStart({ server }) { /* ... */ },
-    }),
-  })
-  \`\`\`
-
-- **Plugins** — \`definePlugin()\` factory. Same shape, never plain function returning \`KickPlugin\`.
-
-- **DI tokens** — \`<scope>/<PascalKey>[/<suffix>]\`. Scope is lowercase,
-  the key segment is **PascalCase** (the regex enforces both):
-
-  \`\`\`ts
-  const USERS_REPO = createToken<UsersRepo>('app/Users/repository')
-  const DB         = createToken<Database>('app/Db/connection')
-  \`\`\`
-
-  The \`kick/\` prefix is reserved for first-party packages; this project
-  owns its own scope (\`app/\`, your domain name, etc.).
-
-- **\`@Controller()\`** takes **no path argument**. Mount prefix comes from
-  the module's \`routes()\` return value, not the decorator. \`@Controller('/users')\`
-  is a v3 leftover; the linter and codegen reject it.
-
-- **Env wiring** — \`src/config/index.ts\` calls \`loadEnv(envSchema)\` as a
-  side effect. \`src/index.ts\` MUST have \`import './config'\` as its **first**
-  import (before \`bootstrap()\`). Without it, \`ConfigService.get('YOUR_KEY')\`
-  returns \`undefined\` and \`@Value()\` only works via raw \`process.env\` fallback
-  (Zod coercion + defaults silently skipped).
-
-- **Module entry files MUST be named \`<name>.module.ts\`** — see the Vite
-  HMR contract at the top of "Module Pattern" below. The CLI enforces this;
-  hand-rolled files must too.
-
-- **Assets** — drop new template files into \`src/templates/<namespace>/\`
-  (or wherever \`kick.config.ts\` points). The dev watcher auto-rebuilds the
-  \`KickAssets\` augmentation; \`assets.x.y()\` re-walks on next call. No restart,
-  no manual build step.
-
-- **Context over \`@Middleware()\`** — when a middleware's only job is to
-  populate \`ctx.set('key', value)\`, use \`defineHttpContextDecorator()\`
-  (HTTP) or \`defineContextDecorator()\` (transport-agnostic) instead.
-  Typed via \`ContextMeta\`, ordered via \`dependsOn\`, validated at boot.
-  Reserve \`@Middleware()\` for response short-circuit / stream mutation /
-  pre-route-matching work.
-
-  Two ground rules around the data flow — both stem from the fact that
-  every per-request stage gets its OWN \`RequestContext\` instance, all
-  reading/writing the SAME \`AsyncLocalStorage\`-backed Map:
-  - **\`resolve\` and \`onError\` must RETURN the value.** The runner
-    writes it via \`ctx.set(reg.key, value)\` on your behalf. Direct
-    property assignment (\`ctx.tenant = …\`) sticks to the contributor
-    instance only — the handler instance never sees it.
-  - **Read across instances via \`ctx.set\` / \`ctx.get\`** (or
-    \`getRequestValue(key)\` from a service that has no \`ctx\` reference
-    — typed via \`MetaValue<K>\`). \`ctx.req\` works because the underlying
-    Express request is shared; bespoke property assignments don't.
-
-- **Test isolation** — default to \`Container.create()\` for fresh DI state.
-  Never \`new Container()\` and never \`getInstance().reset()\` — both leak
-  registrations between tests.
-
-  \`\`\`ts
-  const container = Container.create()
-  // ... register test-scoped providers, run, discard
-  \`\`\`
-
-- **Bootstrap export** — \`src/index.ts\` MUST end with
-  \`export const app = await bootstrap({ ... })\`. The Vite plugin imports
-  the named \`app\` symbol to drive HMR module swaps; testing helpers
-  (\`createTestApp\`) and the OpenAPI introspector also rely on it. Drop
-  the \`export\` and \`kick dev\` will silently fall back to a full restart
-  on every save while \`createTestApp\` complains about a missing handle.
-
-- **Keep \`src/index.ts\` thin** — collect plugins, modules, middleware, and
-  adapters in dedicated folders and re-export aggregated arrays. Do **not**
-  inline registration in the entry file:
-
-  \`\`\`ts
-  // src/modules/index.ts — fluent chain (default for \`modules.style: 'define'\`)
-  export const modules = defineModules().mount(HelloModule()).mount(UsersModule())
-  // OR with \`modules.style: 'class'\`:
-  //   export const modules: AppModuleEntry[] = [HelloModule, UsersModule]
-
-  // src/middleware/index.ts
-  export const middleware = [helmet(), cors(), requestId(), ...]
-
-  // src/plugins/index.ts
-  export const plugins = [MetricsPlugin(), AuditPlugin()]
-
-  // src/adapters/index.ts
-  export const adapters = [SwaggerAdapter({ ... }), DevToolsAdapter()]
-  \`\`\`
-
-  \`\`\`ts
-  // src/index.ts — stays small; one import per category
-  import 'reflect-metadata'
-  import './config'
-  import { bootstrap } from '@forinda/kickjs'
-  import { modules } from './modules'
-  import { middleware } from './middleware'
-  import { plugins } from './plugins'
-  import { adapters } from './adapters'
-
-  export const app = await bootstrap({ modules, middleware, plugins, adapters })
-  \`\`\`
-
-  This keeps the entry file diff-friendly, scales to dozens of modules
-  without git churn, and lets each domain own its own registration list.
-  The generators (\`kick g module\`, \`kick g middleware\`, \`kick g plugin\`,
-  \`kick g adapter\`) follow this layout — manual additions should too.
-
-Everything else (controllers, services, modules, RequestContext API, generators,
-package additions, env access patterns, troubleshooting) is detailed below.
-
-## Where to Find Things
-
-### Application Structure
-
-| What | Where |
-|------|-------|
-| Entry point | \`src/index.ts\` |
-| Module registry | \`src/modules/index.ts\` |
-| Feature modules | \`src/modules/<module-name>/\` |
-| **Module entry file** | \`src/modules/<name>/<name>.module.ts\` (filename suffix is required — see Vite HMR contract below) |
-| Env values | \`.env\` |
-| Env schema (Zod) | \`src/config/index.ts\` |
-| TypeScript config | \`tsconfig.json\` |
-| Vite config (HMR) | \`vite.config.ts\` |
-| Vitest config | \`vitest.config.ts\` |
-| Prettier config | \`.prettierrc\` |
-| CLI config | \`kick.config.ts\` |
-
-### Module Pattern (${t.toUpperCase()})
-
-> **Vite HMR auto-discovery contract:** module files **must** be named \`<name>.module.ts\` (or \`.tsx\`/\`.js\`/\`.jsx\`) and live under \`src/modules/\`. The Vite plugin scans for \`*.module.[tj]sx?\` to drive graceful HMR rebuilds; renaming a file to \`projects.ts\` (no \`.module\`) silently breaks HMR — saves trigger a full restart instead of a swap. The CLI generator (\`kick g module <name>\`) follows the convention; manual files must too.
-
-Each module in \`src/modules/<name>/\` typically contains:
-
-${t===`ddd`?`\`\`\`
-<name>/
-├── <name>.controller.ts     # HTTP routes (@Controller)
-├── <name>.service.ts        # Business logic (@Service)
-├── <name>.repository.ts     # Data access (@Repository)
-├── <name>.dto.ts            # Request/response schemas (Zod)
-├── <name>.entity.ts         # Domain entity (optional)
-└── <name>.module.ts         # Module definition (defineModule factory)
-\`\`\`
-`:t===`cqrs`?`\`\`\`
-<name>/
-├── commands/                # Write operations
-│   ├── create-<name>.command.ts
-│   └── create-<name>.handler.ts
-├── queries/                 # Read operations
-│   ├── get-<name>.query.ts
-│   └── get-<name>.handler.ts
-├── events/                  # Domain events
-│   └── <name>-created.event.ts
-├── <name>.controller.ts     # HTTP routes
-├── <name>.repository.ts     # Data access
-└── <name>.module.ts         # Module definition (defineModule factory)
-\`\`\`
-`:t===`rest`?`\`\`\`
-<name>/
-├── <name>.controller.ts     # HTTP routes (@Controller)
-├── <name>.service.ts        # Business logic (@Service)
-├── <name>.dto.ts            # Request/response schemas (Zod)
-└── <name>.module.ts         # Module definition (defineModule factory)
-\`\`\`
-`:"```\nsrc/\n├── index.ts                 # Add routes here\n└── ...                      # Custom structure\n```\n"}
-
-## Checklist: Adding a Feature
-
-### New Module (Recommended)
-
-Use the CLI generator for consistency:
-
-\`\`\`bash
-kick g module <name>              # Generate full module
-# or
-kick g scaffold <name> <fields>   # Generate CRUD from fields
-\`\`\`
-
-Then:
-- [ ] Review generated files in \`src/modules/<name>/\`
-- [ ] Verify module is registered in \`src/modules/index.ts\`
-- [ ] Update DTOs in \`<name>.dto.ts\` if needed
-- [ ] Implement business logic in \`<name>.service.ts\`
-- [ ] Run \`kick dev\` to test with HMR
-- [ ] Write tests in \`<name>.test.ts\`
-
-### Manual Controller
-
-If not using generators:
-
-- [ ] Create \`src/modules/<name>/<name>.controller.ts\`
-- [ ] Add \`@Controller()\` decorator
-- [ ] Add route handlers with \`@Get()\`, \`@Post()\`, etc.
-- [ ] Create module file with \`defineModule({ name, build: () => ({ routes() { return { path, controller } } }) })\` — the framework derives the Express router from the controller. Class-form (\`class XModule implements AppModule\`) is the legacy alternative; toggle via \`kick.config.ts > modules.style\`.
-- [ ] Register module in \`src/modules/index.ts\`. Default form is the fluent chain: \`defineModules().mount(MyModule()).mount(...)\`. \`kick g module <name>\` appends \`.mount(NewModule())\` automatically.
-- [ ] Test with \`kick dev\`
-
-### Manual Service
-
-- [ ] Create \`src/modules/<name>/<name>.service.ts\`
-- [ ] Add \`@Service()\` decorator
-- [ ] Inject dependencies with \`@Autowired()\`
-- [ ] Inject via \`@Autowired()\` where needed
-- [ ] Write unit tests
-
-### New Middleware
-
-- [ ] Create \`src/middleware/<name>.middleware.ts\`
-- [ ] Export middleware function (Express format)
-- [ ] Register in \`src/index.ts\` or attach to routes with \`@Middleware()\`
-- [ ] Test with sample requests
-
-### Adding a Package
-
-Use \`kick add\` to install KickJS packages with correct peer dependencies:
-
-- [ ] Run \`kick add <package>\` (e.g., \`kick add auth\`)
-- [ ] Follow package-specific setup in terminal output
-- [ ] Update \`src/index.ts\` to register adapter (if needed)
-- [ ] Configure environment variables in \`.env\`
-- [ ] Test integration with \`kick dev\`
-
-## Common Tasks
-
-### Generate CRUD Module
-
-\`\`\`bash
-kick g scaffold user name:string email:string:optional age:number
-\`\`\`
-
-Append \`:optional\` for optional fields (shell-safe, no quoting needed).
-Quoted \`?\` syntax also works: \`"email:string?"\` or \`"email?:string"\`.
-
-This creates a full CRUD module with:
-- Controller with GET, POST, PUT, DELETE routes
-- Service with business logic
-- Repository with data access
-- DTOs with Zod validation
-
-### Add Authentication
-
-\`\`\`bash
-kick add auth
-\`\`\`
-
-Then configure in \`src/index.ts\`:
-
-\`\`\`ts
-import { AuthAdapter, JwtStrategy } from '@forinda/kickjs-auth'
-
-bootstrap({
-  modules,
-  adapters: [
-    AuthAdapter({
-      strategies: [JwtStrategy({ secret: process.env.JWT_SECRET! })],
-    }),
-  ],
-})
-\`\`\`
-
-### Add Database (Prisma)
-
-\`\`\`bash
-kick add prisma
-${n} install prisma @prisma/client
-npx prisma init
-# Edit prisma/schema.prisma
-npx prisma migrate dev --name init
-kick g module user --repo prisma
-\`\`\`
-
-### Add WebSocket Support
-
-\`\`\`bash
-kick add ws
-\`\`\`
-
-Then add adapter in \`src/index.ts\`:
-
-\`\`\`ts
-import { WsAdapter } from '@forinda/kickjs-ws'
-
-bootstrap({
-  modules,
-  adapters: [WsAdapter()],
-})
-\`\`\`
-
-Create WebSocket controller:
-
-\`\`\`bash
-kick g controller chat --ws
-\`\`\`
-
-## Testing Guidelines
-
-All tests use Vitest:
-
-\`\`\`ts
-import { describe, it, expect, beforeEach } from 'vitest'
-import { Container } from '@forinda/kickjs'
-import { createTestApp } from '@forinda/kickjs-testing'
-
-describe('UserController', () => {
-  it('should return users', async () => {
-    // Container.create() — isolated DI state per test, never new Container()
-    // and never getInstance().reset() (both leak registrations between tests).
-    const container = Container.create()
-    const app = await createTestApp([UserModule], { container })
-    const res = await app.get('/users')
-
-    expect(res.status).toBe(200)
-    expect(res.body).toHaveProperty('users')
-  })
-})
-\`\`\`
-
-Run tests:
-- \`${n} run test\` — run all tests once
-- \`${n} run test:watch\` — watch mode
-- Individual file: \`${n} run test src/modules/user/user.test.ts\`
-
-## Environment Variables
-
-Schema is declared in \`src/config/index.ts\` (extends the base
-\`PORT\`/\`NODE_ENV\`/\`LOG_LEVEL\` shape via \`defineEnv\`) and registered
-with kickjs at module load. \`src/index.ts\` imports it via
-\`import './config'\` **before** \`bootstrap()\` so the cache is populated
-in time for DI. Add new keys to the schema, drop their values into
-\`.env\`, and they're typed everywhere.
-
-Access patterns:
-
-1. **@Value() decorator** (recommended for known-at-construction keys):
-\`\`\`ts
-@Value('DATABASE_URL')
-private dbUrl!: string
-\`\`\`
-
-2. **ConfigService** (recommended for dynamic / method-scoped access):
-\`\`\`ts
-@Autowired()
-private config!: ConfigService
-
-const port = this.config.get('PORT')  // typed: number
-\`\`\`
-
-3. **Standalone utilities** (no DI — works in scripts, CLI, plain files):
-\`\`\`ts
-import { loadEnv, getEnv, reloadEnv, resetEnvCache } from '@forinda/kickjs/config'
-
-const env = loadEnv(schema)         // Parse + validate all vars
-const port = getEnv('PORT')         // Single value lookup
-reloadEnv()                         // Re-read .env from disk
-resetEnvCache()                     // Full reset (for tests)
-\`\`\`
-
-4. **Direct \`process.env\`** — avoid in app code; bypasses Zod
-   coercion and the typed \`KickEnv\` registry.
-
-> **Pitfall**: never delete \`import './config'\` from \`src/index.ts\`.
-> If the schema is not registered before DI runs, \`config.get()\`
-> returns \`undefined\` for user keys (the base shape only) and
-> \`@Value()\` only works because of its raw \`process.env\` fallback —
-> Zod coercion + schema defaults are silently skipped.
-
-## Standalone Utilities (No DI Required)
-
-These work anywhere — scripts, plain files, outside \`@Service\`/\`@Controller\`:
-
-| Utility | Import | Example |
-|---------|--------|---------|
-| \`Logger.for(name)\` | \`@forinda/kickjs\` | \`const log = Logger.for('MyScript')\` |
-| \`createLogger(name)\` | \`@forinda/kickjs\` | \`const log = createLogger('Worker')\` |
-| \`createToken<T>(name)\` | \`@forinda/kickjs\` | \`const TOKEN = createToken<string>('app/Db/url')\` |
-| \`ref(value)\` | \`@forinda/kickjs\` | \`const count = ref(0)\` |
-| \`computed(fn)\` | \`@forinda/kickjs\` | \`const doubled = computed(() => count.value * 2)\` |
-| \`watch(source, cb)\` | \`@forinda/kickjs\` | \`watch(() => count.value, (v) => log(v))\` |
-| \`reactive(obj)\` | \`@forinda/kickjs\` | \`const state = reactive({ count: 0 })\` |
-| \`HttpException\` | \`@forinda/kickjs\` | \`throw new HttpException(404, 'Not found')\` |
-| \`HttpStatus\` | \`@forinda/kickjs\` | \`HttpStatus.NOT_FOUND // 404\` |
-
-## Key Decorators
-
-### HTTP Routes
-| Decorator | Purpose |
-|-----------|---------|
-| \`@Controller()\` | Define route prefix |
-| \`@Get('/'), @Post('/')\` | HTTP method handlers |
-| \`@Middleware(fn)\` | Attach middleware |
-| \`@Public()\` | Skip auth (requires auth adapter) |
-| \`@Roles('admin')\` | Role-based access |
-
-### Dependency Injection
-| Decorator | Purpose |
-|-----------|---------|
-| \`defineModule({...})\` | Define feature module (factory; preferred — paired with \`defineModules()\` registry) |
-| \`defineModules()\` | Build the modules registry as a chainable list (\`.mount(X())\`) |
-| \`AppModule\` interface | Legacy module shape — \`class X implements AppModule\` (toggle via \`modules.style: 'class'\`) |
-| \`@Service()\` | Register singleton service |
-| \`@Repository()\` | Register repository |
-| \`@Autowired()\` | Property injection |
-| \`@Inject('token')\` | Token-based injection |
-| \`@Value('VAR')\` | Inject env variable |
-
-### Context Decorators
-
-Typed, ordered way to populate \`ctx.set/get\` keys before the handler runs.
-Use this **instead of \`@Middleware()\`** when the middleware's only output
-is a value other code reads off \`ctx\`.
-
-| Concept | Where it lives |
-|---------|----------------|
-| \`defineContextDecorator({ key, deps, dependsOn, optional, onError, resolve })\` | \`@forinda/kickjs\` |
-| Method/class decorator | \`@LoadX\` on a controller method/class |
-| Module hook | \`build: () => ({ contributors() { return [...] } })\` (\`defineModule\`) — or \`AppModule.contributors?()\` for class form |
-| Adapter hook | \`AppAdapter.contributors?(): ContributorRegistration[]\` |
-| Global registration | \`bootstrap({ contributors: [LoadX.registration] })\` |
-| Type augmentation | \`declare module '@forinda/kickjs' { interface ContextMeta { ... } }\` |
-
-Precedence high → low: **method > class > module > adapter > global**.
-Cycles and missing \`dependsOn\` keys throw at \`app.setup()\` (boot fails
-fast). The \`onError\` hook is async-permitted.
-
-Full guide: <https://forinda.github.io/kick-js/guide/context-decorators>.
-
-${t===`cqrs`?`### Background Jobs
-| Decorator | Purpose |
-|-----------|---------|
-| \`@Job('name')\` | Queue job handler |
-| \`@Process('queue')\` | Queue processor |
-| \`@Cron('0 * * * *')\` | Cron schedule |
-| \`@WsController()\` | WebSocket controller |
-
-`:``}## Common Pitfalls
-
-1. **Forgot to register module** — Add to \`src/modules/index.ts\` exports array
-2. **DI not working** — Ensure \`reflect-metadata\` is imported in \`src/index.ts\`
-3. **Tests failing randomly** — Sharing the global container between tests. Default to \`Container.create()\` per test (or per \`beforeEach\`) instead of \`new Container()\` / \`getInstance().reset()\`
-4. **Routes not found** — Check controller path and module registration
-5. **HMR not working** — Two checks: (a) \`vite.config.ts\` has \`hmr: true\`; (b) module file is named \`<name>.module.ts\` (or \`.tsx\`/\`.js\`/\`.jsx\`) and lives under \`src/modules/\`. The Vite plugin auto-discovers \`*.module.[tj]sx?\` for graceful HMR — a misnamed module file (e.g., \`projects.ts\`) silently degrades to a full restart on every save.
-6. **Decorators not working** — Check \`tsconfig.json\` has \`experimentalDecorators: true\`
-7. **\`config.get('YOUR_KEY')\` returns \`undefined\`** — \`src/index.ts\` is missing \`import './config'\`. That side-effect import registers the env schema with kickjs (\`loadEnv(envSchema)\` runs at module load). Without it, \`ConfigService\` falls back to the base schema (\`PORT\`/\`NODE_ENV\`/\`LOG_LEVEL\` only) and every user-defined key reads as \`undefined\`. \`@Value()\` may *appear* to work because of a raw \`process.env\` fallback, but Zod coercion and schema defaults are silently skipped — investigate \`src/index.ts\` and \`src/config/index.ts\` first.
-8. **Used \`@Middleware()\` to compute a value for \`ctx\`** — prefer \`defineContextDecorator()\` (see Context Decorators above). It's typed via \`ContextMeta\`, supports \`dependsOn\` for ordering, and validates the pipeline at boot. \`@Middleware()\` is for response short-circuiting, stream mutation, and pre-route-matching work.
-9. **Context contributor's \`dependsOn\` key not produced anywhere** — boot throws \`MissingContributorError\` naming the dependent and the route. Either remove the dep or register a contributor that produces the key (at any precedence level: method/class/module/adapter/global).
-10. **\`bootstrap()\` not exported** — \`src/index.ts\` calls \`await bootstrap({ ... })\` but discards the return value (no \`export const app = ...\`). Vite HMR can't locate the running instance, so module saves degrade to full restarts; \`createTestApp\`/\`@forinda/kickjs-testing\` consumers can't import the handle either. Always: \`export const app = await bootstrap({ ... })\`.
-11. **Refresh AGENTS.md / CLAUDE.md after a framework upgrade** — these files are scaffolded by the CLI and don't auto-update. Run \`kick g agents -f\` (or \`kick g agent-docs -f\`) to regenerate from the latest CLI templates after \`kick add\` / version bumps. Hand-edited sections will be overwritten — keep customisation in a separate file like \`AGENTS.local.md\`.
-
-## CLI Commands Reference
-
-| Command | Description |
-|---------|-------------|
-| \`kick dev\` | Dev server with HMR |
-| \`kick dev:debug\` | Dev server with debugger |
-| \`kick build\` | Production build |
-| \`kick start\` | Run production build |
-| \`kick g module <names...>\` | Generate one or more modules |
-| \`kick g scaffold <name> <fields>\` | Generate CRUD |
-| \`kick g controller <name>\` | Generate controller |
-| \`kick g service <name>\` | Generate service |
-| \`kick g middleware <name>\` | Generate middleware |
-| \`kick add <package>\` | Add KickJS package |
-| \`kick add --list\` | List available packages |
-| \`kick rm module <names...>\` | Remove one or more modules |
-
-> **Note:** When using \`kick new\` in scripts or CI, pass \`-t\` (or \`--template\`) and \`-r\` (or \`--repo\`) flags to bypass interactive prompts:
-> \`\`\`bash
-> kick new my-api -t ddd -r prisma --pm ${n} --no-git --no-install -f
-> \`\`\`
-
-## Learn More
-
-- [KickJS Docs](https://forinda.github.io/kick-js/)
-- [CLI Reference](https://forinda.github.io/kick-js/api/cli.html)
-- [Decorators Guide](https://forinda.github.io/kick-js/guide/decorators.html)
-- [DI System](https://forinda.github.io/kick-js/guide/dependency-injection.html)
-- [Testing](https://forinda.github.io/kick-js/api/testing.html)
-`}function vt(e,t,n){let r=`<!-- Generated by \`kick g agents\` for ${e}. Edits are overwritten on the next refresh; keep customisation in a SKILL.local.md alongside. -->`;return[{slug:`add-module`,frontmatterName:`kickjs-add-module`,description:`Use when the user asks to add a new feature module (controller + service + repo + DTOs).`,body:`**Trigger phrases**: "add a users module", "scaffold tasks", "new feature for X".
-
-**Steps**:
-1. Run \`kick g module <name>\` (use plural form if the project pluralizes — check \`kick.config.ts\`).
-2. Verify the new folder under \`src/modules/<name>/\` contains \`<name>.module.ts\` (filename suffix is mandatory for Vite HMR).
-3. Confirm the module appears in \`src/modules/index.ts\` exports — generator does this automatically; verify if you bypassed it.
-4. Open \`<name>.dto.ts\` and tighten the Zod schemas to real fields (the generator emits placeholders).
-5. Run \`${n} run typecheck\` and \`${n} run test\` before claiming done.
-
-**Canonical module shape** — \`defineModule\` factory, never \`class implements AppModule\`:
-
-\`\`\`ts
-export const TodosModule = defineModule({
-  name: 'TodosModule',
-  build: () => ({
-    register(container) {
-      container.registerFactory(TODO_REPO, () => container.resolve(InMemoryTodoRepository))
-    },
-    routes() {
-      return { path: '/todos', controller: TodosController }
-    },
-  }),
-})
-\`\`\`
-
-The module file MUST include \`import.meta.glob([...], { eager: true })\` for every \`@Service\` / \`@Repository\` / \`@Component\` class — without it, decorators never fire and DI silently resolves to \`undefined\`.
-
-**Multiple route sets / versioning** — \`routes()\` may return an array with per-entry \`version\` override:
-
-\`\`\`ts
-routes() {
-  return [
-    { path: '/todos', controller: TodosController },               // /api/v1/todos
-    { path: '/todos', version: 2, controller: TodosV2Controller }, // /api/v2/todos
-  ]
-}
-\`\`\`
-
-**Conditional / per-tenant mounting** — use \`bootstrap({ setup(registry) { registry.mount(...) } })\`, not the static \`modules\` array.
-
-**Composition** — \`defineModules().mount(TodosModule()).mount(UsersModule())\` (fluent) or \`AppModuleEntry[]\` (array form).
-
-**Red flags** (stop and ask):
-- File created as \`<name>.ts\` instead of \`<name>.module.ts\` — Vite plugin's \`*.module.[tj]sx?\` glob doesn't pick it up; every save becomes a full restart.
-- \`@Controller('/path')\` with a path argument combined with module \`routes().path\` — duplicates the prefix. The decorator path is OpenAPI metadata only.
-- \`TodosModule\` in \`bootstrap({ modules: [TodosModule] })\` instead of \`TodosModule()\` — passing the factory instead of the invoked instance.
-- \`routes()\` returning \`router: …\` when a \`controller:\` would do — controller form is required for OpenAPI/Swagger introspection.
-- Module not registered in \`src/modules/index.ts\`.`},{slug:`add-adapter`,frontmatterName:`kickjs-add-adapter`,description:`Use when wiring a single-concern lifecycle integration (Swagger, DevTools, Sentry, Redis client).`,body:"**Steps**:\n1. `kick g adapter <name>` to scaffold the boilerplate, OR install via `kick add <package>` for first-party adapters.\n2. The generated file uses `defineAdapter()` — never `class implements AppAdapter`.\n3. Add the adapter instance (note the parens) to `src/adapters/index.ts` — don't inline in `src/index.ts`.\n4. Pick the right hook and middleware phase deliberately.\n5. Verify with `kick dev` that the adapter's lifecycle logs fire.\n\n**Canonical shape** — factory closure owns instance state:\n\n```ts\nexport const RedisAdapter = defineAdapter<RedisConfig>({\n  name: 'RedisAdapter',\n  defaults: { url: 'redis://localhost' },\n  build: (config) => {\n    const client = createClient(config.url)\n    return {\n      beforeStart: ({ container }) => {\n        container.registerInstance(REDIS_CLIENT, client)\n      },\n      afterStart: () => client.connect(),\n      shutdown: () => client.quit(),\n    }\n  },\n})\n\n// In src/adapters/index.ts:\nexport const adapters = [RedisAdapter({ url: env.REDIS_URL })] // <-- note parens\n```\n\n**Lifecycle hook decision tree**:\n- `beforeMount` — register early routes that should bypass middleware (health, docs UI).\n- `beforeStart` — DI ready, server not listening yet. **Use this for `container.registerInstance(...)` calls** so they work under `createTestApp` too.\n- `afterStart` — server has `ctx.server` available. Only use for things that need a listening server (Socket.IO upgrades, port logging). **Doesn't fire under `createTestApp`.**\n- `shutdown` — runs concurrently via `Promise.allSettled`, so one failure doesn't block siblings (but errors are swallowed — log inside).\n\n**Middleware phases** (see `MiddlewarePhase` JSDoc):\n`beforeGlobal` | `afterGlobal` (default) | `beforeRoutes` | `afterRoutes` (fires only on fall-through — matched routes that respond skip it).\n\n**Multi-instance** — `.scoped('cache', { url: ... })` makes `name` become `RedisAdapter:cache`. **Deferred config** — `.async({ inject, useFactory })` for config that depends on DI-resolved services.\n\n**Red flags**:\n- `bootstrap({ adapters: [MyAdapter] })` — passed the factory, not the instance. Call it: `MyAdapter()`.\n- Inlining the adapter list directly in `src/index.ts` — entry file should stay thin.\n- Returning a plain object instead of going through `defineAdapter()` — type inference for `config` will be wrong.\n- Using `.async()` for an adapter that returns `middleware()` / `contributors()` / `beforeMount()` / `onRouteMount()` — those hooks have already run by the time `.async()` resolves and are silently skipped.\n- Cross-adapter ordering via array position when it's load-bearing — use `dependsOn: ['OtelAdapter']`; cycles throw `MountCycleError` at boot.\n- Using an adapter when the integration ships **modules + DI bindings + middleware** together → that's a plugin. Promote to `definePlugin()` (see `add-plugin` skill).\n\n**Nuances**:\n- `AdapterContext.server` is `undefined` outside `afterStart`.\n- `shutdown` errors are swallowed by `Promise.allSettled` — wrap in try/catch and log if you care."},{slug:`add-plugin`,frontmatterName:`kickjs-add-plugin`,description:`Use when scaffolding a feature that bundles modules + DI + middleware + adapters together (auth, monitoring suite, multi-tenant scaffolding).`,body:"**When plugin > adapter**: a plugin is the right answer when the integration ships **more than one** of: a module, a DI binding, middleware, or another adapter. If you have a single hook (`beforeStart`) and no other contributions, use `defineAdapter` instead.\n\n**Canonical shape**:\n\n```ts\nimport { definePlugin } from '@forinda/kickjs'\n\nexport const AuthPlugin = definePlugin({\n  name: 'AuthPlugin',\n  defaults: { tokenTtl: '1h' },\n  build: (config, { name }) => ({\n    modules: () => [AuthModule()],\n    adapters: () => [JwtAdapter({ ttl: config.tokenTtl })],\n    middleware: () => [requestIdMiddleware()],\n    register(container) {\n      container.registerFactory(TOKEN_SIGNER, () => createSigner(config))\n    },\n    contributors() {\n      return [LoadCurrentUser.registration]\n    },\n    onReady({ server }) {\n      log.info(`AuthPlugin listening on port ${server.address().port}`)\n    },\n  }),\n})\n\n// In bootstrap:\nbootstrap({ plugins: [AuthPlugin({ tokenTtl: env.TOKEN_TTL })] }) // <-- parens\n```\n\n**Inline plugin literal** — the canonical answer for one-off DI bindings. There's no top-level `register:` on `bootstrap` itself:\n\n```ts\nbootstrap({\n  plugins: [{ name: 'vector-store', register(c) { c.registerInstance(VECTOR_STORE, store) } }],\n})\n```\n\n**Execution order** (memorize):\nplugin `register()` → plugin `middleware()` → plugin `modules()` + user modules → plugin `adapters()` + user adapters → server listens → plugin `onReady()`.\n\n**Static vs dynamic modules**: `modules()` returning an array is introspectable (Swagger, DevTools see it). `setup(registry)` is imperative — pick the latter when the module set depends on resolved config.\n\n**Multi-instance** — `.scoped('users', { url })`; derive unique DI tokens from `ctx.name` inside `build`:\n\n```ts\nbuild: (config, { name }) => ({\n  register(c) {\n    c.registerInstance(createToken(`cache/${name}`), client)\n  },\n})\n```\n\n**Precedence**: plugin contributors land at `'adapter'` precedence — beat global, lose to module/class/method same-key.\n\n**Red flags**:\n- `bootstrap({ plugins: [AuthPlugin] })` — passed factory. Call it: `AuthPlugin()`.\n- Reaching for a plugin when an adapter would do (no modules, no DI bindings, no contributors) — overkill; use `defineAdapter()`.\n- `.async()` plugin that depends on `modules()` / `middleware()` / `adapters()` / `contributors()` — those are dropped. `.async()` only resolves `register()` + `onReady()`.\n- Confusing CLI plugins (`defineCliPlugin` from `@forinda/kickjs-cli`) with runtime plugins (`definePlugin` from `@forinda/kickjs`) — different surfaces, different registration sites.\n- `dependsOn: ['SomePlugin']` referring to a plugin not in the boot list — throws `MissingMountDepError` at boot.\n\n**Nuances**:\n- `definition` is `Object.freeze`'d metadata; useful for version checks (`compare(AuthPlugin.definition.version, '1.2.0')`) — not mountable."},{slug:`write-controller-test`,frontmatterName:`kickjs-write-controller-test`,description:`Use when adding a Vitest test that exercises an HTTP route or DI graph.`,body:"**Template** (copy/paste, adjust):\n\n```ts\nimport { describe, it, expect, beforeEach } from 'vitest'\nimport { Container } from '@forinda/kickjs'\nimport { createTestApp } from '@forinda/kickjs-testing'\n\nbeforeEach(() => {\n  Container.reset() // isolated DI per test\n})\n\ndescribe('UserController', () => {\n  it('returns users', async () => {\n    const app = await createTestApp([UserModule])\n    const res = await app.get('/api/v1/users')\n    expect(res.status).toBe(200)\n  })\n})\n```\n\n**Typed handler signature** — pair with `kick typegen` so `ctx.body` / `params` / `query` are typed by the route's Zod schema:\n\n```ts\n@Post('/', { body: createTodoSchema })\ncreate(ctx: Ctx<KickRoutes.TodoController['create']>) {\n  // ctx.body is typed from createTodoSchema; ctx.params from the route\n  ctx.created(await this.service.create(ctx.body))\n}\n```\n\n**Red flags**:\n- `new Container()` — wrong; use `Container.reset()` in `beforeEach` or `Container.create()` for fully isolated graphs.\n- `Container.getInstance().reset()` — wrong; same fix.\n- Sharing a container instance across `it()` blocks — leaks registrations between tests.\n- Injecting a `Scope.REQUEST` service into a `SINGLETON` — container throws at resolve. Singletons must resolve request-scoped services explicitly per call.\n- Calling `getRequestValue<string>('traceId')` — the generic slot is the **key** type, not the value type; widens key and bypasses typed lookup.\n- Asserting on `res.body.requestId` when `requestId()` middleware isn't mounted in the test app — value will be `undefined`.\n- Using `Scope.REQUEST` services in a test without mounting `requestScopeMiddleware()` — `getRequestValue` silently returns `undefined`; `getRequestStore` throws.\n\n**Nuances**:\n- `@Inject` and `@Autowired` are interchangeable — same runtime, same types; pick by readability.\n- `@Value('MISSING_KEY')` with no default **throws on property access**, not at construction — tests that exercise the getter will surface the missing-env issue."},{slug:`env-wiring-check`,frontmatterName:`kickjs-env-wiring-check`,description:`Use when ConfigService.get('SOME_KEY') returns undefined or @Value silently falls back to process.env.`,body:"**Diagnosis (in order)**:\n1. Open `src/index.ts`. The **first non-`reflect-metadata`** import MUST be `import './config'`.\n2. Open `src/config/index.ts`. It MUST call `loadEnv(envSchema)` as a top-level side effect — not just declare the schema:\n   ```ts\n   import { loadEnv, defineEnv } from '@forinda/kickjs'\n   const envSchema = defineEnv((base) => base.extend({ DATABASE_URL: z.string().url() }))\n   export const env = loadEnv(envSchema)\n   ```\n3. The new key MUST be declared in the Zod schema. `@Value('NEW_KEY')` accepts any string at the type level and **falls back to raw `process.env`** when the schema doesn't know the key — silently skipping Zod coercion.\n4. After adding a key, re-run `kick typegen` (or restart `kick dev` if the typegen watcher missed it) so the global `KickEnv` augmentation picks it up.\n\n**Why `@Value` \"works\" but `ConfigService.get` doesn't**: `@Value` has the `process.env` fallback that masks missing-side-effect-import bugs; `ConfigService` has none. If `@Value('FOO')` returns a value but `ConfigService.get('FOO')` returns `undefined`, the side-effect import of `./config` is missing.\n\n**`reloadEnv` vs `resetEnvCache`** — distinct, frequently mixed up:\n- `reloadEnv()` — re-reads `process.env` against the **already registered** schema. Use in HMR plugins after `.env` file changes. Schema survives.\n- `resetEnvCache()` — drops the registered schema entirely. **Test-only.** Calling it between dev requests drops the project's keys.\n\n**Nuances**:\n- `loadEnv()` cache is **sticky**: once `loadEnv(extendedSchema)` runs anywhere, no-arg calls reuse it — but only if it actually ran. Schema downgrades silently if `src/config/index.ts` isn't imported.\n- `createConfigService(envSchema)` is deprecated; the typegen-driven `ConfigService` covers it.\n- `dotenv` is an **optional peer dep** in v5+ — projects upgrading from older versions may need to add it explicitly.\n- For HMR-friendly `.env` edits, add `envWatchPlugin()` to `vite.config.ts` — calls `reloadEnv()` automatically.\n\n**Fix recipe**: add the key to the schema; add `import './config'` as the first non-reflect-metadata import in `src/index.ts`; re-run `kick typegen`."},{slug:`bootstrap-export`,frontmatterName:`kickjs-bootstrap-export`,description:`Use when HMR is silently doing full restarts on every save, or createTestApp can't find the app handle.`,body:"**Check** `src/index.ts`'s last line:\n\n```ts\n// CORRECT — Vite plugin + createTestApp import the named `app` symbol\nexport const app = await bootstrap({ ... })\n\n// WRONG — HMR degrades to full restart, createTestApp loses the handle\nawait bootstrap({ ... })\n```\n\nThe Vite plugin imports the named `app` symbol via `virtual:kickjs/app`; testing helpers do too. Without the export, both fall back to slower paths (full restart on save, mock handle in tests) **without warning**.\n\n**Red flags**:\n- A bare `await bootstrap(...)` with no `export` — fix by adding `export const app =`.\n- Re-assigning `app` later in the file (`app = somethingElse`) — Vite imports by reference at module-load time; reassignments don't propagate.\n- Multiple files calling `bootstrap()` — only the entry should. Tests use `createTestApp` instead."},{slug:`thin-entry-file`,frontmatterName:`kickjs-thin-entry-file`,description:`Use when src/index.ts is accumulating module/middleware/plugin/adapter literals.`,body:`**Refactor target**:
-
-\`\`\`ts
-// src/modules/index.ts — fluent chain (default for \`modules.style: 'define'\`)
-export const modules = defineModules().mount(HelloModule()).mount(UsersModule())
-// OR for class-form projects (\`modules.style: 'class'\`):
-//   export const modules: AppModuleEntry[] = [HelloModule, UsersModule]
-
-// src/middleware/index.ts — global middleware uses RAW EXPRESS signature
-//                            (req, res, next), NOT (ctx, next)
-export const middleware = [requestId(), express.json(), helmet(), cors(), traceContext()]
-
-// src/plugins/index.ts
-export const plugins = [MetricsPlugin(), AuthPlugin({ tokenTtl: env.TOKEN_TTL })]
-
-// src/adapters/index.ts
-export const adapters = [SwaggerAdapter({ ... }), DevToolsAdapter()]
-
-// src/index.ts — stays small
-import 'reflect-metadata'
-import './config' // MUST be early — side-effect schema load
-import { bootstrap } from '@forinda/kickjs'
-import { modules } from './modules'
-import { middleware } from './middleware'
-import { plugins } from './plugins'
-import { adapters } from './adapters'
-export const app = await bootstrap({ modules, middleware, plugins, adapters })
-\`\`\`
-
-**One-off DI binding** — inline a literal plugin inside \`plugins\`, not a top-level option:
-
-\`\`\`ts
-plugins: [
-  ...plugins,
-  { name: 'vector-store', register(c) { c.registerInstance(VECTOR_STORE, store) } },
-]
-\`\`\`
-
-**Red flags**:
-- Any \`new SomeAdapter()\` / \`SomePlugin()\` literal inside \`bootstrap({ ... })\` instead of imported from a category folder.
-- Mixing middleware signatures: \`bootstrap({ middleware })\` is **raw Express** \`(req, res, next)\`; \`@Middleware()\` decorators are \`(ctx, next)\`; adapter middleware is raw Express again. Wrong shape in the wrong slot throws "Cannot read properties of undefined".
-- \`bootstrap({ register: ... })\` — that option doesn't exist. Use an inline plugin.`},{slug:`context-contributor`,frontmatterName:`kickjs-context-contributor`,description:`Use when a middleware's only job is to set ctx values consumed elsewhere — replace with defineHttpContextDecorator (HTTP) or defineContextDecorator (transport-agnostic).`,body:"**Pattern** (HTTP — most common):\n\n```ts\nimport { defineHttpContextDecorator, type RequestContext } from '@forinda/kickjs'\n\n// Augment ContextMeta — required for ctx.get('tenant') to be typed\ndeclare module '@forinda/kickjs' {\n  interface ContextMeta {\n    tenant: { id: string; name: string }\n  }\n}\n\n// Optionally publish discoverability for tooling (Swagger, DevTools)\ndefineAugmentation('ContextMeta', {\n  description: 'Per-request tenant resolved from x-tenant-id header.',\n  example: { id: 'acme', name: 'Acme Inc' },\n})\n\nconst LoadTenant = defineHttpContextDecorator({\n  key: 'tenant',\n  deps: { repo: TENANT_REPO }, // typed DI\n  resolve: (ctx, { repo }) => repo.findById(ctx.req.headers['x-tenant-id'] as string),\n})\n\nconst LoadProject = defineHttpContextDecorator({\n  key: 'project',\n  dependsOn: ['tenant'], // typo'd key = tsc error\n  resolve: (ctx) => projectsRepo.find(ctx.get('tenant')!.id, ctx.params.id),\n})\n\n@LoadTenant\n@LoadProject\n@Get('/projects/:id')\ngetProject(ctx: RequestContext) {\n  ctx.json(ctx.get('project'))\n}\n```\n\nUse `defineContextDecorator` (no Http prefix) only when the contributor must run across HTTP, WebSocket, queue, and cron transports — `Ctx` defaults to the smaller `ExecutionContext` surface (`get` / `set` / `requestId` only, no `req`).\n\n**Five precedence levels** (high → low):\n**method > class > module > adapter > global**\n\nSame-key collisions WITHIN a precedence level throw `DuplicateContributorError`. Across levels, the higher precedence silently overrides — a feature, not a bug, but debug it by giving resolvers distinguishable return values.\n\n**Boot-time validation**:\n- Cycles in `dependsOn` → `ContributorCycleError`.\n- `dependsOn` referring to an unknown key → `MissingContributorError`.\n- Both errors fail boot, not first request.\n\n**Critical rules — all stem from the same shared-via-ALS instance model**:\n- Every per-request stage (middleware → contributors → handler) gets its OWN `RequestContext` instance, but they all read/write the SAME `AsyncLocalStorage`-backed bag.\n- **`resolve` and `onError` must RETURN the value** — the runner writes it via `ctx.set(key, value)`. Direct property assignment (`ctx.tenant = …`) sticks to one instance only and the handler instance never sees it.\n- `ctx.set('tenant', x)` then `ctx.get('tenant')` works across instances. `ctx.req.headers[...]` works (the underlying Express request is shared).\n- Services with no `ctx` reference: `getRequestValue('tenant')` returns `MetaValue<'tenant'> | undefined` (typed via the augmented `ContextMeta`). For `requestId` use `getRequestStore()`.\n- **No `setRequestValue` — writes flow through `ctx.set` or a contributor's return value.** Avoids \"spooky action at a distance\" where any service can pollute the per-request bag.\n\n**Error matrix**:\n- `optional: true` — `resolve` throws → key left unset; downstream sees `ctx.get(key) === undefined`.\n- `optional: false` (default) + `onError` — return a fallback value to write; return `undefined` to skip; throw to forward to the request error handler.\n- `optional: false` + no `onError` — throw propagates straight to the request error handler.\n\n**Don't use this for**: response short-circuit, stream mutation, or pre-route-matching work — keep `@Middleware()` for those.\n\n**Red flags**:\n- `ctx.tenant = x` instead of returning the value from `resolve` — sticks to one instance only.\n- `defineAugmentation` without the `declare module` block (or vice-versa) — discoverability and types drift apart; `ctx.get('tenant')` becomes `unknown`.\n- Plugin / adapter authors using bare keys (`'state'`) instead of namespaced (`'@my-plugin/state'`) — collides with adopter keys.\n- `getRequestValue<string>('traceId')` — generic is the **key** type, not value type."},{slug:`query-parsing-list-endpoint`,frontmatterName:`kickjs-query-parsing-list-endpoint`,description:`Use when adding a paginated/filterable list route — emit ctx.qs + ctx.paginate with an allow-list.`,body:"**Canonical list endpoint**:\n\n```ts\n@Get('/')\nasync list(ctx: Ctx<KickRoutes.TodoController['list']>) {\n  const parsed = ctx.qs({\n    filterable: ['status', 'priority', 'assigneeId'], // allow-list, MUST be set\n    sortable: ['createdAt', 'updatedAt', 'priority'],\n    searchColumns: ['title', 'description'], // free-text search targets\n  })\n\n  return ctx.paginate(async () => {\n    const { data, total } = await this.service.list(parsed)\n    return { data, total }\n  }, parsed)\n}\n```\n\n**Operator format** (fixed): `?filter=field:op:value` where `op ∈ eq | neq | gt | gte | lt | lte | between | in | contains | starts | ends`. Sort is `?sort=field:asc|desc`. Only the first two colons are delimiters, so timestamps work (`createdAt:gt:2026-01-01T00:00:00Z`).\n\n**Drizzle adopters** — pass a `DrizzleQueryParamsConfig` with column refs:\n\n```ts\nconst TASK_QUERY_CONFIG = {\n  filterable: { status: tasks.status, priority: tasks.priority },\n  sortable: { createdAt: tasks.createdAt },\n  searchColumns: [tasks.title, tasks.description],\n}\nconst parsed = ctx.qs(TASK_QUERY_CONFIG)\n```\n\n**ORM-agnostic builders** — implement `QueryBuilderAdapter<TResult, TConfig>` with `build(parsed, config)`. The Drizzle + Prisma adapters live here.\n\n**Red flags**:\n- Reading `req.query.status` directly — bypasses the allow-list; opens unbounded filtering. Use `ctx.qs({ filterable })`.\n- Omitting `filterable` / `sortable` allow-list — every client-supplied filter is **silently dropped** (security default, but looks like a bug).\n- Hand-building the pagination meta in the controller — inconsistent response shape across endpoints. Always use `ctx.paginate()`.\n- Returning a bare array from a list endpoint when pagination is implied — breaks the `PaginatedResponse<T>` contract.\n- Mixing string `searchable` config with column `searchColumns` (Drizzle) — silently no-ops.\n\n**Nuances**:\n- `limit` is capped at 100 server-side; `q` (search) is truncated to 200 chars. Don't re-validate client-side.\n- Sort direction defaults to `asc` when omitted (`?sort=createdAt` ≡ `?sort=createdAt:asc`)."},{slug:`use-asset-manager`,frontmatterName:`kickjs-use-asset-manager`,description:`Use when code reads template files / JSON fixtures via fs.readFile + path arithmetic — switch to assets.<ns>.<key>() and the kick.config.ts assetMap.`,body:"**Configure** `kick.config.ts`:\n\n```ts\nexport default defineConfig({\n  assetMap: {\n    mails: { src: 'src/templates/mails' },\n    reports: { src: 'src/templates/reports', glob: '**/*.{ejs,html}' },\n  },\n})\n```\n\n**Consume** via the typed Proxy — no `__dirname` arithmetic, dev/prod paths handled:\n\n```ts\nimport { assets } from '@forinda/kickjs'\n\nconst html = await assets.mails.welcome() // typed: tsc errors on bad key\n```\n\n**Class-field decorator** (lazy getter, swappable in tests):\n\n```ts\nclass WelcomeMailService {\n  @Asset('mails/welcome') private welcomeTemplate!: () => Promise<string>\n\n  async send(to: string) {\n    const body = await this.welcomeTemplate()\n  }\n}\n```\n\n**Dynamic dispatch** (CMS templates, codegen) — `resolveAsset(ns, key)` throws `UnknownAssetError` with `{ namespace, key }` fields when the key is missing.\n\n**Test fixtures** — swap via env override + cache clear:\n\n```ts\nbeforeEach(() => {\n  process.env.KICK_ASSETS_ROOT = path.resolve('__fixtures__/assets')\n  clearAssetCache()\n})\nafterEach(() => {\n  delete process.env.KICK_ASSETS_ROOT\n  clearAssetCache()\n})\n```\n\n**Red flags**:\n- Hand-rolled `process.env.NODE_ENV === 'production' ? join(__dirname, '../templates') : join(__dirname, 'templates')` — exactly what the asset manager replaces.\n- `keys: 'strip'` setting in `assetMap.<ns>` when basenames may collide — silent last-walk-wins data loss. Default `'auto'` keeps extensions only for colliding groups.\n- Non-default Vite `outDir` without mirroring in `kick.config.ts` — manifest writes at `dist/.kickjs-assets.json` but the resolver can't find it. Mirror via `build.outDir`.\n- Forgetting to re-run `kick typegen` after adding files — `assets.mails.newTemplate` is a tsc error even though the file ships. `kick dev` does this on-change; one-shot CI builds need `kick build` (or `kick build:assets` for manifest-only).\n- Same-name `welcome.ejs` + `welcome/login.ejs` — directory wins in the typed surface; the `.ejs` file still copies but isn't addressable.\n\n**Nuances**:\n- Resolution pipeline (cached): `KICK_ASSETS_ROOT` env override > built manifest at `build.outDir` / `dist` / `build` / `out` > dev-fallback in-memory walk. Manifest presence = \"running from built dist.\"\n- Dev-mode glob matcher is a lite implementation — `**/*`, `**/*.ext`, `**/*.{a,b}` are guaranteed; exotic globs warn-once and accept everything. Run `kick build:assets` to exercise the real glob engine."},{slug:`cli-commands-cheatsheet`,frontmatterName:`kickjs-cli-commands-cheatsheet`,description:`Use as a quick reference for the most common kick CLI workflows — scaffolding, dev/build/start, generation, inspection.`,body:`**Top commands**:
-- \`kick new <name>\` — start a new project (prompts for template / repo / pm).
-- \`kick dev\` — local dev server with Vite HMR.
-- \`kick build\` — production bundle via Vite.
-- \`kick start\` — run the built artifact (\`NODE_ENV=production\` auto-set).
-- \`kick g module <name>\` — add a feature module; structure follows \`pattern\` in \`kick.config.ts\`.
-- \`kick g scaffold <Name> <field:type>...\` — full CRUD module from field definitions.
-- \`kick add <pkg>\` — install optional packages (auto-resolves peer deps + package manager).
-- \`kick g --list\` — list every available generator (built-ins + plugin-shipped).
-- \`kick info\` — environment / version dump for bug reports.
-- \`kick inspect\` — introspect a running app: routes, middleware, adapters, DI graph.
-
-**Useful flag combos**:
-
-\`\`\`bash
-kick new my-api --yes                                  # CI-safe: minimal + inmemory, no prompts
-kick new my-api -t ddd --pm ${n} --no-git --install   # Fully scriptable DDD scaffold
-kick new . --yes --force                               # Scaffold into current dir, clear existing files
-kick g scaffold Post title:string body:text:optional   # Shell-safe optional field syntax
-kick g agents -f --only skills                         # Refresh just the skills after upgrade
-kick add queue:bullmq                                  # Package + peer deps (bullmq + ioredis) in one shot
-kick inspect --port 4000 --json                        # Machine-readable route/adapter dump
-kick g config --force --repo drizzle                   # Drop a kick.config.ts into a legacy project
-\`\`\`
-
-**Lesser-known, high-value**:
-- \`kick inspect --watch\` — live route/middleware/adapter table that re-renders on hot reload; faster than re-curling \`/_debug\`.
-- \`kick g agents -f\` — regenerates \`CLAUDE.md\` (root) and \`.agents/AGENTS.md\` / \`GEMINI.md\` / \`COPILOT.md\` + every \`.agents/skills/<slug>/SKILL.md\` from the current CLI templates.
-- \`kick dev:debug\` — same flags as \`kick dev\` but opens a Node inspector port for IDE attach.
-- \`kick list --all\` (alias \`kick ls --all\`) — full optional-package catalog at this CLI version.
-- \`kick typegen --watch\` — standalone typegen watcher when \`kick dev\` isn't running.
-- \`kick check\` — preflight gate (typecheck + lint + format) before commit.
-- \`kick codemod\` — automated AST-level migration between framework versions.
-
-**Red flags**:
-- Using globally-installed \`@forinda/kickjs-cli\` while contributing to the monorepo — \`pnpm link --global\` from \`packages/cli\` so generators match the framework.
-- Writing \`"name:type?"\` for optional scaffold fields — \`?\` is a shell glob in bash/zsh; use \`name:type:optional\`.
-- Running \`kick new <name> --yes\` in a non-empty directory expecting it to wipe — \`--yes\` aborts without \`--force\`; pair them when destruction is intended.
-- Skipping \`kick g config\` on a legacy project then wondering why generators ignore \`modules.dir\` / \`modules.repo\`.
-- Editing \`kick.config.ts\` with deprecated top-level \`modulesDir\` / \`defaultRepo\` / \`schemaDir\` / \`pluralize\` instead of the nested \`modules\` block.`},{slug:`refresh-agent-docs`,frontmatterName:`kickjs-refresh-agent-docs`,description:`Use after a KickJS version bump to sync the .agents/ docs with the latest CLI templates.`,body:"**Steps**:\n1. `kick g agents -f --only both` — overwrites `CLAUDE.md` (root) and `.agents/AGENTS.md`.\n2. `kick g agents -f --only skills` — refreshes every `.agents/skills/<slug>/SKILL.md`.\n3. `kick g agents -f --only gemini` / `--only copilot` — refresh the per-agent files when needed.\n4. Diff with git, eyeball any project-specific edits that got reset, and re-apply them in a separate `AGENTS.local.md` or per-skill `SKILL.local.md` alongside.\n5. Commit as `docs(agents): sync from CLI vX.Y`.\n\n**`.agents/` layout** (post-restructure):\n\n```\nCLAUDE.md                 # at root — Claude Code auto-loads from here\n.agents/\n├── AGENTS.md             # canonical multi-agent reference\n├── GEMINI.md             # Gemini-specific notes\n├── COPILOT.md            # Copilot CLI notes\n└── skills/\n    ├── add-module/SKILL.md\n    ├── add-adapter/SKILL.md\n    └── …                 # one SKILL.md per skill, frontmatter-namespaced\n```\n\nCustomisation goes in `.local.md` siblings (`AGENTS.local.md`, `skills/<slug>/SKILL.local.md`) — those are never overwritten."},{slug:`deny-list`,frontmatterName:`kickjs-deny-list`,description:`Patterns to refuse outright when the user asks for them — they break v4 invariants.`,body:"**Module / adapter / plugin shape**:\n- `class implements AppAdapter` → use `defineAdapter()`.\n- `class implements KickPlugin` / function returning `KickPlugin` → use `definePlugin()`.\n- `class implements AppModule` for new code → use `defineModule()`.\n- `bootstrap({ adapters: [MyAdapter] })` (factory) → `MyAdapter()` (instance, with parens).\n- `@Controller('/path')` with a path argument → drop the path; set the mount via `routes().path`. The decorator path is OpenAPI metadata only.\n- Module file named `<name>.ts` (no `.module` suffix) → rename to `<name>.module.ts`. Vite HMR's glob doesn't pick up the unsuffixed form.\n\n**DI**:\n- `new Container()` or `Container.getInstance().reset()` in tests → use `Container.reset()` in `beforeEach` (or `Container.create()` for fully isolated graphs).\n- DI tokens with `:` separator (`'app:db:url'`) or in PascalCase → use slash-delimited lower-case (`'app/db/url'`). First-party uses reserved `'kick/'` prefix.\n- `Symbol.for(...)` for DI tokens — globally interned, **collides across files**. Use `createToken<T>('name')`.\n- Raw string tokens (`@Inject('config')`) — silent collisions; widens to `unknown`. Use `createToken<T>`.\n- Injecting a `Scope.REQUEST` service into a `SINGLETON` — container throws at resolve time.\n\n**Bootstrap / entry file**:\n- `bootstrap({ ... })` without `export const app = ...` → always export. HMR degrades to full restart and `createTestApp` loses the handle.\n- `bootstrap({ register: ... })` — that option doesn't exist. Use an inline plugin in `plugins`.\n\n**Middleware**:\n- Using `(ctx, next)` for global middleware in `bootstrap({ middleware })` — global middleware uses raw Express `(req, res, next)`. Wrong signature throws \"Cannot read properties of undefined\".\n- Using `(req, res, next)` for an `@Middleware()` decorator — those use `(ctx, next)`.\n- `@Middleware()` whose only output is `ctx.set('x', v)` — should be a context decorator (typed, ordered, testable).\n\n**Context contributors**:\n- `ctx.tenant = x` from a contributor — only sticks to one `RequestContext` instance. **Return the value** so the runner writes it via `ctx.set(key, value)`.\n- `defineAugmentation('ContextMeta', ...)` without the matching `declare module '@forinda/kickjs'` block (or vice-versa).\n- `getRequestValue<string>('traceId')` — generic is the **key** type, not value type.\n\n**Env / config**:\n- `@Value('NEW_KEY')` without the key in the Zod schema — silent fallback to raw `process.env`, no coercion.\n- `resetEnvCache()` outside tests — drops the registered schema.\n\n**List endpoints**:\n- Reading `req.query.status` directly — bypasses the allow-list. Use `ctx.qs({ filterable })`.\n- Returning a bare array from a list endpoint — breaks the `PaginatedResponse<T>` contract. Use `ctx.paginate()`.\n\n**Assets**:\n- Hand-rolled `__dirname` arithmetic for template paths — use `assets.<ns>.<key>()` and add the namespace to `kick.config.ts assetMap`."}].map(e=>({slug:e.slug,content:`---
-name: ${e.frontmatterName}
-description: ${e.description}
----
-
-${r}
-
-${e.body}
-`}))}function yt(e,t,n){return`# kickjs-skills.md — Task Skills for AI Agents (${e})
-
-This file is the agent-facing **skills index** for KickJS work in this
-repo. Each block below is a short, rigid workflow keyed to a specific
-trigger ("user wants to add a module", "tests are leaking state", etc.).
-
-- Reference docs (narrative, exhaustive) → \`AGENTS.md\`.
-- Tool-specific notes → \`CLAUDE.md\`, \`GEMINI.md\`, etc.
-- **This file** → step-by-step recipes the agent should *execute*.
-
-Re-run \`kick g agents -f --only skills\` after framework upgrades to refresh.
-
----
-
-## Skill: add-module
-
-\`\`\`yaml
-name: kickjs-add-module
-description: Use when the user asks to add a new feature module (controller + service + repo + DTOs).
-\`\`\`
-
-**Trigger phrases**: "add a users module", "scaffold tasks", "new feature for X".
-
-**Steps**:
-1. Run \`kick g module <name>\` (use plural form if the project pluralizes — check \`kick.config.ts\`).
-2. Verify the new folder under \`src/modules/<name>/\` contains \`<name>.module.ts\` (filename suffix is mandatory for HMR).
-3. Confirm the module appears in \`src/modules/index.ts\` exports — generator does this automatically; verify if you bypassed it.
-4. Open \`<name>.dto.ts\` and tighten the Zod schemas to real fields (the generator emits placeholders).
-5. Run \`${n} run typecheck\` and \`${n} run test\` before claiming done.
-
-**Red flags** (stop and ask):
-- File created as \`<name>.ts\` instead of \`<name>.module.ts\` — Vite won't HMR it.
-- Module not registered in \`src/modules/index.ts\`.
-- \`@Controller('/path')\` with a path argument — that's a v3 pattern; remove it (mount comes from \`routes().path\`).
-
----
-
-## Skill: add-adapter
-
-\`\`\`yaml
-name: kickjs-add-adapter
-description: Use when wiring a new lifecycle integration (Swagger, DevTools, Auth, custom).
-\`\`\`
-
-**Steps**:
-1. \`kick g adapter <name>\` to scaffold the boilerplate, OR install via \`kick add <package>\` for first-party adapters.
-2. The generated file uses \`defineAdapter()\` — never \`class implements AppAdapter\`.
-3. Add the adapter instance to \`src/adapters/index.ts\` (don't inline in \`src/index.ts\`).
-4. If the adapter contributes to \`ctx.set/get\`, prefer \`AppAdapter.contributors?()\` over a wrapping middleware.
-5. Verify with \`kick dev\` that the adapter's lifecycle logs fire.
-
-**Red flags**:
-- Inlining the adapter list directly in \`src/index.ts\` (entry file should stay thin).
-- Returning a plain object instead of going through \`defineAdapter()\` — type inference for \`config\` will be wrong.
-
----
-
-## Skill: write-controller-test
-
-\`\`\`yaml
-name: kickjs-write-controller-test
-description: Use when adding a Vitest test that exercises an HTTP route or DI graph.
-\`\`\`
-
-**Template** (copy/paste, adjust):
-
-\`\`\`ts
-import { describe, it, expect } from 'vitest'
-import { Container } from '@forinda/kickjs'
-import { createTestApp } from '@forinda/kickjs-testing'
-
-describe('UserController', () => {
-  it('returns users', async () => {
-    const container = Container.create()           // isolated DI per test
-    const app = await createTestApp([UserModule], { container })
-    const res = await app.get('/users')
-    expect(res.status).toBe(200)
-  })
-})
-\`\`\`
-
-**Red flags**:
-- \`new Container()\` — wrong; use \`Container.create()\`.
-- \`Container.getInstance().reset()\` — wrong; same fix.
-- Sharing a container across \`it()\` blocks — leaks registrations.
-
----
-
-## Skill: env-wiring-check
-
-\`\`\`yaml
-name: kickjs-env-wiring-check
-description: Use when ConfigService.get('SOME_KEY') returns undefined or @Value silently falls back to process.env.
-\`\`\`
-
-**Diagnosis**:
-1. Open \`src/index.ts\`. The **first non-\`reflect-metadata\`** import MUST be \`import './config'\`.
-2. Open \`src/config/index.ts\`. It MUST call \`loadEnv(envSchema)\` as a top-level side effect.
-3. The new key MUST be declared in the Zod schema there. \`@Value('NEW_KEY')\` won't work without a schema entry (it'll fall back to raw \`process.env\` and skip Zod coercion silently).
-
-**Fix**: add the key to the schema; ensure both side-effect imports above are present.
-
----
-
-## Skill: bootstrap-export
-
-\`\`\`yaml
-name: kickjs-bootstrap-export
-description: Use when HMR is silently doing full restarts on every save, or createTestApp can't find the app handle.
-\`\`\`
-
-**Check** \`src/index.ts\`'s last line:
-
-\`\`\`ts
-// CORRECT
-export const app = await bootstrap({ ... })
-
-// WRONG (HMR degrades to full restart, createTestApp loses the handle)
-await bootstrap({ ... })
-\`\`\`
-
-The Vite plugin imports the named \`app\` symbol; testing helpers do too.
-
----
-
-## Skill: thin-entry-file
-
-\`\`\`yaml
-name: kickjs-thin-entry-file
-description: Use when src/index.ts is accumulating module/middleware/plugin/adapter literals.
-\`\`\`
-
-**Refactor target**:
-
-\`\`\`ts
-// src/modules/index.ts — fluent chain (default for \`modules.style: 'define'\`)
-export const modules = defineModules().mount(HelloModule()).mount(UsersModule())
-// OR for class-form projects (\`modules.style: 'class'\`):
-//   export const modules: AppModuleEntry[] = [HelloModule, UsersModule]
-
-// src/middleware/index.ts
-export const middleware = [helmet(), cors(), requestId(), ...]
-
-// src/plugins/index.ts
-export const plugins = [MetricsPlugin(), ...]
-
-// src/adapters/index.ts
-export const adapters = [SwaggerAdapter({ ... }), DevToolsAdapter()]
-
-// src/index.ts — stays small
-import 'reflect-metadata'
-import './config'
-import { bootstrap } from '@forinda/kickjs'
-import { modules } from './modules'
-import { middleware } from './middleware'
-import { plugins } from './plugins'
-import { adapters } from './adapters'
-export const app = await bootstrap({ modules, middleware, plugins, adapters })
-\`\`\`
-
-**Red flags**: any \`new SomeAdapter()\` or \`SomePlugin()\` literal inside \`bootstrap({ ... })\` instead of imported from a category folder.
-
----
-
-## Skill: context-contributor
-
-\`\`\`yaml
-name: kickjs-context-contributor
-description: Use when a middleware's only job is to set ctx values consumed elsewhere — replace with defineHttpContextDecorator (HTTP) or defineContextDecorator (transport-agnostic).
-\`\`\`
-
-**Pattern** (HTTP — most common):
-
-\`\`\`ts
-import { defineHttpContextDecorator, type RequestContext } from '@forinda/kickjs'
-
-const LoadTenant = defineHttpContextDecorator({
-  key: 'tenant',
-  deps: { repo: TENANT_REPO },
-  resolve: (ctx, { repo }) => repo.findById(ctx.req.headers['x-tenant-id'] as string),
-})
-
-const LoadProject = defineHttpContextDecorator({
-  key: 'project',
-  dependsOn: ['tenant'],
-  resolve: (ctx) => projectsRepo.find(ctx.get('tenant')!.id, ctx.params.id),
-})
-
-@LoadTenant
-@LoadProject
-@Get('/projects/:id')
-getProject(ctx: RequestContext) { ctx.json(ctx.get('project')) }
-\`\`\`
-
-Use \`defineContextDecorator\` (no Http prefix) when authoring a contributor that must run across HTTP, WebSocket, queue, and cron transports — \`Ctx\` defaults to the smaller \`ExecutionContext\` surface (\`get\` / \`set\` / \`requestId\` only, no \`req\`).
-
-Precedence high → low: **method > class > module > adapter > global**.
-Cycles or unmet \`dependsOn\` keys throw \`MissingContributorError\` at boot.
-
-**Critical rules — all stem from the same shared-via-ALS instance model**:
-- Every per-request stage (middleware → contributors → handler) gets its OWN \`RequestContext\` instance, but they all read/write the SAME \`AsyncLocalStorage\`-backed bag.
-- **\`resolve\` and \`onError\` must RETURN the value** — the runner writes it via \`ctx.set(key, value)\`. Direct property assignment (\`ctx.tenant = …\`) sticks to one instance only and the handler instance never sees it.
-- \`ctx.set('tenant', x)\` then \`ctx.get('tenant')\` works across instances. \`ctx.req.headers[...]\` works (the underlying Express request is shared).
-- Services with no \`ctx\` reference: \`getRequestValue('tenant')\` returns \`MetaValue<'tenant'> | undefined\` (typed via the augmented \`ContextMeta\`). For \`requestId\` use \`getRequestStore()\`.
-- **No \`setRequestValue\` — writes flow through \`ctx.set\` or a contributor's return value.** Avoids "spooky action at a distance" where any service can pollute the per-request bag.
-
-**Don't use this for**: response short-circuit, stream mutation, or
-pre-route-matching work — keep \`@Middleware()\` for those.
-
----
-
-## Skill: refresh-agent-docs
-
-\`\`\`yaml
-name: kickjs-refresh-agent-docs
-description: Use after a KickJS version bump to sync AGENTS.md / CLAUDE.md / kickjs-skills.md with the latest CLI templates.
-\`\`\`
-
-**Steps**:
-1. \`kick g agents -f --only both\` — overwrites \`AGENTS.md\` and \`CLAUDE.md\`.
-2. \`kick g agents -f --only skills\` — refreshes \`kickjs-skills.md\` (this file).
-3. Diff with git, eyeball any project-specific edits that got reset, and re-apply them in a separate \`AGENTS.local.md\` or appended section.
-4. Commit as \`docs(agents): sync from CLI vX.Y\`.
-
----
-
-## Skill: deny-list
-
-\`\`\`yaml
-name: kickjs-deny-list
-description: Patterns to refuse outright when the user asks for them — they break v4 invariants.
-\`\`\`
-
-- \`class implements AppAdapter\` → use \`defineAdapter()\`.
-- \`class implements KickPlugin\` / function returning \`KickPlugin\` → use \`definePlugin()\`.
-- \`@Controller('/path')\` with a path argument → drop the path; set the mount via \`routes().path\`.
-- \`new Container()\` or \`Container.getInstance().reset()\` in tests → use \`Container.create()\`.
-- DI tokens with \`:\` separator (\`'app:db:url'\`) or in PascalCase → use slash-delimited lower-case (\`'app/db/url'\`).
-- \`bootstrap({ ... })\` without \`export const app = ...\` → always export.
-- Module file named \`<name>.ts\` (no \`.module\` suffix) → rename to \`<name>.module.ts\`.
-
----
-
-## Learn More
-
-- [KickJS Docs](https://forinda.github.io/kick-js/)
-- [Decorators](https://forinda.github.io/kick-js/guide/decorators.html)
-- [Context Decorators](https://forinda.github.io/kick-js/guide/context-decorators.html)
-- [Testing](https://forinda.github.io/kick-js/api/testing.html)
-`}function bt(e,t,n){return`# GEMINI.md — ${e}
-
-**Read \`./AGENTS.md\` first.** It is the canonical, multi-agent
-reference for this project — every convention, structure, decorator
-pattern, env wiring rule, generator usage. This file is a thin
-Gemini-specific layer; when the two disagree on anything substantive,
-treat \`AGENTS.md\` as authoritative and flag the discrepancy.
-
-## Why this file
-
-Gemini CLI auto-loads \`GEMINI.md\` when it lives alongside the
-agent-context files. Keeping it in \`.agents/\` next to \`AGENTS.md\`
-means Gemini reads the same shared prose as Codex / Cursor / Copilot
-without us copy-pasting.
-
-## Gemini-specific notes
-
-- **Skills activation** — Gemini activates skills via
-  \`activate_skill\` (its native MCP-style tool); the equivalent on
-  Claude Code is the \`Skill\` tool. Cross-reference the
-  \`kickjs-skills.md\` index for the available triggers.
-- **Tool naming** — Gemini's tool names differ from Claude Code's
-  (e.g. \`read_file\` vs \`Read\`, \`run_terminal_command\` vs
-  \`Bash\`). The shared prose in \`AGENTS.md\` describes intents, not
-  tool names; consult Gemini's docs for the concrete invocation.
-- **File ops** — Gemini's file edits are sandboxed; large refactors
-  may need explicit confirmation. Prefer the smallest-possible-edit
-  pattern.
-
-## Refreshing this file
-
-\`kick g agents --only gemini -f\` regenerates this file from the
-CLI template. Hand-edited content is overwritten — keep customisation
-in \`.agents/GEMINI.local.md\`.
-`}function xt(e,t,n){return`# COPILOT.md — ${e}
-
-**Read \`./AGENTS.md\` first.** It is the canonical, multi-agent
-reference for this project — every convention, structure, decorator
-pattern, env wiring rule, generator usage. This file is a thin
-Copilot-specific layer; when the two disagree on anything substantive,
-treat \`AGENTS.md\` as authoritative and flag the discrepancy.
-
-## Why this file
-
-GitHub Copilot CLI auto-loads \`COPILOT.md\` when it lives alongside
-the agent-context files. Keeping it in \`.agents/\` next to
-\`AGENTS.md\` means Copilot reads the same shared prose as
-Codex / Cursor / Gemini / Claude Code without copy-pasting.
-
-## Copilot-specific notes
-
-- **Skills** — Copilot CLI auto-discovers skills from installed
-  plugins; cross-reference \`kickjs-skills.md\` for available
-  triggers in this project.
-- **Tool naming** — Copilot's tool names differ from Claude Code's
-  (\`edit\` vs \`Edit\`, \`shell\` vs \`Bash\`, etc.). The shared
-  prose in \`AGENTS.md\` describes intents, not tool names; consult
-  Copilot's docs for the concrete invocation.
-- **Confirmation flows** — Copilot CLI surfaces destructive
-  operations through an explicit approval gate. Stage edits with
-  short, focused diffs so each one is easy to review at the prompt.
-
-## Refreshing this file
-
-\`kick g agents --only copilot -f\` regenerates this file from the
-CLI template. Hand-edited content is overwritten — keep customisation
-in \`.agents/COPILOT.local.md\`.
-`}const St=n(_(import.meta.url)),Ct=JSON.parse(s(i(St,`..`,`package.json`),`utf-8`)),wt=`^${Ct.version}`,Tt=[`@forinda/kickjs`,`@forinda/kickjs-cli`,`@forinda/kickjs-vite`,`@forinda/kickjs-swagger`,`@forinda/kickjs-ws`,`@forinda/kickjs-queue`,`@forinda/kickjs-devtools`,`@forinda/kickjs-testing`];async function Et(){let e=await Promise.all(Tt.map(async e=>{try{let t=h(`npm`,[`view`,e,`version`],{encoding:`utf-8`,timeout:5e3,stdio:[`ignore`,`pipe`,`ignore`]}).toString().trim();if(t&&/^\d+\.\d+\.\d+/.test(t))return[e,`^${t}`]}catch{}return[e,wt]}));return Object.fromEntries(e)}async function Dt(e){let{name:t,directory:n,packageManager:r=`pnpm`,template:a=`rest`,defaultRepo:o=`inmemory`,packages:s=[]}=e,c=n,l=e=>console.log(`  ${e}`);console.log(`\n  Creating KickJS project: ${t}\n`),l(`Resolving package versions...`);let u=await Et();if(await b(i(c,`package.json`),at(t,a,u,s)),await b(i(c,`vite.config.ts`),ot()),await b(i(c,`tsconfig.json`),st()),await b(i(c,`.prettierrc`),ct()),await b(i(c,`.editorconfig`),lt()),await b(i(c,`.gitignore`),ut()),await b(i(c,`.gitattributes`),dt()),await b(i(c,`.env`),ft()),await b(i(c,`.env.example`),pt()),await b(i(c,`src/config/index.ts`),Ie()),await b(i(c,`src/index.ts`),Pe(t,a,Ct.version,s)),await b(i(c,`src/modules/index.ts`),Fe()),await b(i(c,`src/modules/hello/hello.service.ts`),Le()),await b(i(c,`src/modules/hello/hello.controller.ts`),Re()),await b(i(c,`src/modules/hello/hello.module.ts`),ze()),await b(i(c,`kick.config.ts`),Be(a,o,r)),await b(i(c,`vitest.config.ts`),mt()),await b(i(c,`README.md`),ht(t,a,r)),await b(i(c,`CLAUDE.md`),gt(t,a,r)),await b(i(c,`AGENTS.md`),_t(t,a,r)),await b(i(c,`kickjs-skills.md`),yt(t,a,r)),e.installDeps){console.log(`\n  Installing dependencies with ${r}...\n`);try{g(`${r} install`,{cwd:c,stdio:`inherit`}),console.log(`
-  Dependencies installed successfully!`)}catch{console.log(`\n  Warning: ${r} install failed. Run it manually.`)}}try{let{runTypegen:e}=await import(`./typegen-B8lAhWXz.mjs`).then(e=>e.r);await e({cwd:c,allowDuplicates:!0,silent:!0})}catch{}if(e.initGit)try{g(`git init`,{cwd:c,stdio:`pipe`}),g(`git branch -M main`,{cwd:c,stdio:`pipe`}),g(`git add -A`,{cwd:c,stdio:`pipe`}),g(`git commit -m "chore: initial commit from kick new"`,{cwd:c,stdio:`pipe`}),l(`Git repository initialized`)}catch{l(`Warning: git init failed (git may not be installed)`)}console.log(`
-  Project scaffolded successfully!`),console.log();let d=c!==process.cwd();l(`Next steps:`),d&&l(`  cd ${t}`),e.installDeps||l(`  ${r} install`);let f={rest:`kick g module user`,ddd:`kick g module user --repo drizzle`,cqrs:`kick g module user --pattern cqrs`,minimal:`# add your routes to src/index.ts`};l(`  ${f[a]??f.rest}`),l(`  kick dev`),l(``),l(`Commands:`),l(`  kick dev                  Start dev server with Vite HMR`),l(`  kick build                Production build via Vite`),l(`  kick start                Run production build`),l(``),l(`Generators:`),l(`  kick g module <name>      Full DDD module (controller, DTOs, use-cases, repo)`),l(`  kick g scaffold <n> <f..> CRUD module from field definitions`),l(`  kick g controller <name>  Standalone controller`),l(`  kick g service <name>     @Service() class`),l(`  kick g middleware <name>   Express middleware`),l(`  kick g guard <name>       Route guard (auth, roles, etc.)`),l(`  kick g adapter <name>     AppAdapter with lifecycle hooks`),l(`  kick g dto <name>         Zod DTO schema`),a===`cqrs`&&l(`  kick g job <name>         Queue job processor`),l(`  kick g config             Generate kick.config.ts`),l(``),l(`Add packages:`),l(`  kick add <pkg>            Install a KickJS package + peers`),l(`  kick add --list           Show all available packages`),l(``),l(`Available: auth, swagger, drizzle, prisma, ws, queue, devtools, mcp, testing`),l(``)}function Ot(e){return e}function kt(e){return k(e).replace(/-/g,`_`)}function At(t){let n=t.cwd??process.cwd(),r=t.projectRoot??e(n),i=t.pluralize??!0,a=D(t.name),o=O(t.name),s=k(t.name),c=kt(t.name),l={name:t.name,pascal:a,camel:o,kebab:s,snake:c,modulesDir:t.modulesDir??`src/modules`,cwd:n,projectRoot:r,args:t.args??[],flags:t.flags??{}};if(i){let e=A(s);l.pluralKebab=e,l.pluralPascal=D(e),l.pluralCamel=O(e)}return l}function jt(e,t){return a(e.cwd,t)}async function Mt(e){return import(v(e).href)}const Nt=new Map;async function Pt(e){let t=Nt.get(e);if(t)return t;let n=Ft(e);return Nt.set(e,n),n}async function Ft(e){let r=a(e,`package.json`);if(!o(r))return{generators:[],loaded:[],failed:[]};let i=It(JSON.parse(await u(r,`utf-8`))),s=t(a(e,`package.json`)),c=[],l=[],d=[];for(let e of i){let t;try{t=s.resolve(`${e}/package.json`)}catch{continue}let r;try{r=JSON.parse(await u(t,`utf-8`))}catch(t){d.push({source:e,reason:`failed to parse package.json: ${t}`});continue}if(!r.kickjs?.generators)continue;let i=r.kickjs.generators,f=a(n(t),i);if(!o(f)){d.push({source:e,reason:`kickjs.generators points to missing file: ${i}`});continue}let p;try{p=await Mt(f)}catch(t){d.push({source:e,reason:`failed to import manifest: ${t}`});continue}let m=p.default;if(!Array.isArray(m)){d.push({source:e,reason:`manifest's default export is not an array of GeneratorSpec`});continue}for(let t of m){if(!Lt(t)){d.push({source:e,reason:`manifest entry is not a valid GeneratorSpec (missing name/files)`});continue}c.push({source:e,spec:t})}l.push(e)}return{generators:c,loaded:l,failed:d}}function It(e){let t=new Set;for(let n of[e.dependencies,e.devDependencies,e.peerDependencies])if(n)for(let e of Object.keys(n))t.add(e);return Array.from(t)}function Lt(e){if(!e||typeof e!=`object`)return!1;let t=e;return typeof t.name==`string`&&typeof t.files==`function`}async function Rt(e,t=[]){let n=e.cwd??process.cwd(),r=t.find(t=>t.spec.name===e.generatorName);if(r)return Vt(r.spec,r.source,e,n);let i=Bt(await Pt(n),e.generatorName);return i?Vt(i.spec,i.source,e,n):null}async function zt(e,t=[]){let n=await Pt(e),r=new Set(t.map(e=>e.spec.name)),i=n.generators.filter(e=>!r.has(e.spec.name));return{generators:[...t,...i],loaded:n.loaded,failed:n.failed}}function Bt(e,t){return e.generators.find(e=>e.spec.name===t)}async function Vt(e,t,n,r){let i=At({name:n.itemName,args:n.args,flags:n.flags,modulesDir:n.modulesDir,pluralize:n.pluralize,cwd:r,projectRoot:n.projectRoot}),a=await e.files(i),o=[];for(let e of a){let t=jt(i,e.path);await b(t,e.content),o.push(t)}return{files:o,source:t}}export{fe as A,b as B,me as C,T as D,D as E,oe as F,p as I,se as L,de as M,pe as N,ce as O,ue as P,C as R,A as S,k as T,q as _,Dt as a,Ge as b,xt as c,rt as d,nt as f,Ye as g,$e as h,Ot as i,le as j,E as k,bt as l,et as m,Rt as n,_t as o,tt as p,At as r,gt as s,zt as t,vt as u,Y as v,O as w,j as x,Ke as y,ee as z};
-//# sourceMappingURL=generator-extension-ChoCJW23.mjs.map