@forinda/kickjs-cli 6.0.1 → 6.1.1

package/dist/index.d.mts

@@ -494,6 +494,20 @@ interface KickConfig {
    * ```
    */
   typegen?: TypegenConfig;
+  /**
+   * Dev-server (`kick dev`) settings.
+   */
+  dev?: {
+    /**
+     * Run the project's TypeScript checker (`tsgo --noEmit`, falling
+     * back to `tsc --noEmit`) after each debounced change and surface
+     * diagnostics in the dev console + a `kickjs:typecheck` HMR event.
+     * Equivalent to the `kick dev --typecheck` flag.
+     *
+     * @default false
+     */
+    typecheck?: boolean;
+  };
   /**
    * Database settings — schema path, migrations dir, dialect,
    * connection string, optional adapter factory. Consumed by
@@ -1000,6 +1014,13 @@ interface ScanOptions {
    */
   cacheDir?: string;
 }
+/** A precise set of filesystem changes, as reported by a watcher. */
+interface ScanDelta {
+  /** Files added or modified since the last scan (absolute or cwd-relative). */
+  changed: string[];
+  /** Files deleted since the last scan. */
+  removed: string[];
+}
 //#endregion
 //#region src/typegen/plugin.d.ts
 interface TypegenLogger {
@@ -1090,6 +1111,271 @@ interface TypegenPluginResult {
  */
 declare function defineTypegen(spec: TypegenPlugin): TypegenPlugin;
 //#endregion
+//#region src/typegen/token-conventions.d.ts
+interface TokenConventionWarning {
+  token: string;
+  variable: string | null;
+  filePath: string;
+  reason: string;
+  suggestion?: string;
+}
+//#endregion
+//#region src/typegen/index.d.ts
+/**
+ * Result of a typegen run — useful for logging and tests. Computed from
+ * the scan result + asset discovery; the per-file emission itself is now
+ * owned entirely by the typegen plugins (see `builtin/`).
+ */
+interface GenerateResult {
+  /** Number of registry-decorated classes (KickJsRegistry entries) */
+  registryEntries: number;
+  /** Number of unique service tokens (classes + createToken + @Inject literals) */
+  serviceTokens: number;
+  /** Number of module tokens */
+  moduleTokens: number;
+  /** Number of route entries */
+  routeEntries: number;
+  /** Number of unique plugin/adapter names */
+  pluginEntries: number;
+  /** Number of unique `defineAugmentation` calls */
+  augmentationEntries: number;
+  /** Number of typed asset entries */
+  assetEntries: number;
+  /** Whether a typed env augmentation will be emitted */
+  envWritten: boolean;
+  /** Files written this pass (barrel + plugin outputs), for the sweep */
+  written: string[];
+  /** Number of collisions (only > 0 with allowDuplicates) */
+  resolvedCollisions: number;
+}
+/** Options for `runTypegen` */
+interface RunTypegenOptions {
+  /** Project root (defaults to `process.cwd()`) */
+  cwd?: string;
+  /** Source directory to scan (defaults to `src`) */
+  srcDir?: string;
+  /** Output directory (defaults to `.kickjs/types`) */
+  outDir?: string;
+  /** Suppress console output */
+  silent?: boolean;
+  /**
+   * When `true`, duplicate class names are auto-namespaced by file path
+   * instead of throwing. `kick dev` enables this so the dev server is
+   * never blocked by an in-progress rename. CLI default is `false` so
+   * `kick typegen` (and CI) catches collisions early. */
+  allowDuplicates?: boolean;
+  /**
+   * Disable the persistent per-file scan cache (`.kickjs/cache/scan.json`).
+   * Every file is re-read + re-extracted from cold. Escape hatch for the
+   * rare `mtimeMs:size` signature collision (a file edited so fast its
+   * mtime + size are unchanged) where the cache would serve a stale
+   * extract. Wired to `kick typegen --no-cache` / `kick dev --no-typegen-cache`.
+   */
+  noCache?: boolean;
+  /**
+   * Schema validator used to derive `body`/`query`/`params` types from
+   * route metadata. Currently only `'zod'` is supported; `false` (the
+   * default) leaves these fields as `unknown`. Loaded from
+   * `kick.config.ts` `typegen.schemaValidator` when invoked via the CLI.
+   */
+  schemaValidator?: 'zod' | 'kickjs-schema' | false;
+  /**
+   * Path to the env schema file (relative to `cwd`). The file must
+   * default-export a `defineEnv(...)` schema for the typed `KickEnv`
+   * augmentation to be emitted. Defaults to `'src/env.ts'`. Set to
+   * `false` to disable env typing entirely.
+   */
+  envFile?: string | false;
+  /**
+   * Asset map from `kick.config.ts`. When set, `runTypegen` walks
+   * each entry's `src` directory + emits `.kickjs/types/assets.d.ts`
+   * augmenting `KickAssets` for autocomplete on `assets.x.y()` and
+   * `@Asset('x/y')`. Omit to skip the asset typegen pass entirely.
+   */
+  assetMap?: Record<string, AssetMapEntry>;
+  /**
+   * Whether `runTypegen` should also run the TypegenPlugin pipeline
+   * (`runAllPluginTypegens`) after the legacy generator pass. Defaults
+   * to `true` so single-shot callers (kick g, commands/typegen, tests)
+   * keep getting a fully-refreshed `.kickjs/types/` from one entry
+   * point. `watchTypegen` flips this to `false` because it manages
+   * the plugin pass itself + would otherwise double-run it on every
+   * filesystem trigger.
+   */
+  runPlugins?: boolean;
+  /**
+   * Exact watcher delta (Vite chokidar events). When present, the scan
+   * runs incrementally — re-extracting only the changed files and
+   * skipping the directory walk — and the same delta is forwarded to
+   * the plugin pass. `kick dev` supplies this on every file change.
+   */
+  changedFiles?: ScanDelta;
+}
+/**
+ * Run a single typegen pass: scan source files, generate `.d.ts` files.
+ *
+ * Returns the discovered scan result alongside the generation result so
+ * callers (`kick dev`, devtools) can log them or feed them to other tools.
+ *
+ * Throws `TokenCollisionError` if duplicate class names are found and
+ * `allowDuplicates` is false.
+ */
+declare function runTypegen(opts?: RunTypegenOptions): Promise<{
+  scan: ScanResult;
+  result: GenerateResult; /** Token convention warnings — empty when every literal matches §22.2. */
+  tokenWarnings: TokenConventionWarning[];
+}>;
+/**
+ * Post-plugin-pass finalisation: write the `.kickjs/.gitignore` guard
+ * and sweep stale legacy files. Shared by `runTypegen` (single-shot
+ * mode) and the split-mode callers (`kick typegen` / `kick dev` /
+ * watch) so the artifact-writing + sweep stay identical across both.
+ *
+ * No barrel `index.d.ts` is emitted: the scaffolded tsconfig pulls
+ * `.kickjs/types/**` in via `include` globs, so every `declare module`
+ * / `declare global` augmentation in the per-plugin files applies by
+ * inclusion. The old barrel + its `ServiceToken`/`ModuleToken`
+ * re-exports were redundant; they're swept as legacy orphans.
+ *
+ * Returns the list of files considered "written" this pass (the plugin
+ * outputs) for the caller's bookkeeping.
+ */
+declare function writeTypegenArtifacts(outDir: string, pluginResults: readonly TypegenPluginResult[], silent: boolean): Promise<string[]>;
+//#endregion
+//#region src/typegen/run-plugins.d.ts
+interface RunAllPluginTypegensOptions {
+  cwd: string;
+  /** Pre-loaded kick.config.ts (saves a re-read). */
+  config: KickConfig | null;
+  /** Suppress per-plugin status logging. Errors still swallowed when true. */
+  silent?: boolean;
+  /** CI gate — fail (do not write) on the first plugin whose output drifted. */
+  check?: boolean;
+  /**
+   * Exact watcher delta. Forwarded to the scanner so the plugin pass
+   * scans incrementally (changed files only) instead of re-walking the
+   * whole tree. Used by `kick dev`'s file-change handler.
+   */
+  changedFiles?: ScanDelta;
+}
+declare function runAllPluginTypegens(opts: RunAllPluginTypegensOptions): Promise<TypegenPluginResult[]>;
+//#endregion
+//#region src/asset-manager/build.d.ts
+/** Wire-format version for `dist/.kickjs-assets.json`. Bump on shape change. */
+declare const ASSET_MANIFEST_VERSION: 1;
+/** On-disk manifest format (`dist/.kickjs-assets.json`). */
+interface AssetManifest {
+  version: typeof ASSET_MANIFEST_VERSION;
+  /**
+   * Logical key → manifest-relative path. Logical key is
+   * `<namespace>/<key>` where `<key>` is the file path under `src`
+   * with the extension stripped + path separators normalised.
+   *
+   * Path values are relative to the manifest file's directory so the
+   * runtime can resolve them with a single `path.resolve(manifestDir,
+   * entry)` regardless of where dist/ lives.
+   */
+  entries: Record<string, string>;
+}
+interface BuildAssetsOptions {
+  /** Project root — resolved for every relative path in the entry. */
+  cwd: string;
+  /**
+   * Output dir for the manifest + per-namespace asset copies. When
+   * omitted, falls back to `config.build?.outDir` (resolved against
+   * `cwd`), then to `dist/` under cwd. Adopters with a custom Vite
+   * `build.outDir` should set `kick.config.ts.build.outDir` to match.
+   */
+  distDir?: string;
+  /** Suppress per-entry log lines. Default: false. */
+  silent?: boolean;
+}
+/** One entry in the per-build summary returned by `buildAssets`. */
+interface BuildAssetsEntryResult {
+  namespace: string;
+  src: string;
+  dest: string;
+  /**
+   * Number of files actually written this run. On an incremental
+   * rebuild where nothing changed this is 0 even though the manifest
+   * still lists every matched file.
+   */
+  filesCopied: number;
+}
+/** Aggregated outcome of `buildAssets`. */
+interface BuildAssetsResult {
+  manifestPath: string;
+  entries: BuildAssetsEntryResult[];
+  /** `entries` merged into a single record — useful for tests + tooling. */
+  manifest: AssetManifest;
+}
+/**
+ * Run the full asset build for a loaded config:
+ *
+ * 1. For each `assetMap` entry, glob → copy → manifest stub.
+ * 2. Write `dist/.kickjs-assets.json`.
+ *
+ * Returns a summary including the manifest contents. No-op (and no
+ * manifest written) when `assetMap` is empty / missing — the build
+ * pipeline shouldn't litter `dist/` with empty manifests for
+ * adopters who don't use the feature.
+ */
+declare function buildAssets(config: KickConfig | null, opts: BuildAssetsOptions): Promise<BuildAssetsResult | null>;
+//#endregion
+//#region src/typegen/dev-watcher.d.ts
+/**
+ * `globalThis` key claiming typegen ownership for the current process.
+ * Set by `kick dev` (which boots Vite in-process) so the vite plugin's
+ * own watcher never double-runs the pipeline.
+ */
+declare const TYPEGEN_OWNER_KEY = "__kickjs_typegen_owner";
+type TypegenWatchEvent = 'add' | 'change' | 'unlink' | 'unlinkDir';
+/** Injectable pipeline — production uses the real functions. */
+interface TypegenDevPipeline {
+  runTypegen: typeof runTypegen;
+  runAllPluginTypegens: typeof runAllPluginTypegens;
+  writeTypegenArtifacts: typeof writeTypegenArtifacts;
+  buildAssets: typeof buildAssets;
+}
+interface TypegenDevWatcherOptions {
+  cwd: string;
+  /** Pre-loaded kick.config.ts (null when the project has none). */
+  config: KickConfig | null;
+  /**
+   * Warning sink — wired by the caller to `console.warn` plus whatever
+   * HMR broadcast it has (e.g. the `kickjs:typegen-error` custom event).
+   */
+  emitWarning: (message: string) => void;
+  /**
+   * Invoked after each pass's plugin chain settles (success or failure).
+   * `kick dev` uses it to schedule the `--typecheck` worker against
+   * fresh `.kickjs/types`.
+   */
+  onPassComplete?: () => void;
+  /** Debounce window in ms. @default 100 */
+  debounceMs?: number;
+  /** Test seam — defaults to the real typegen pipeline. */
+  pipeline?: TypegenDevPipeline;
+}
+interface TypegenDevWatcher {
+  /** Feed a chokidar-style watcher event into the debounce window. */
+  handleWatchEvent(event: TypegenWatchEvent, file: string): void;
+  /**
+   * Run one full (non-incremental) pass immediately — startup catch-up
+   * for callers that didn't run typegen before the server booted.
+   */
+  runOnce(): void;
+  /**
+   * Absolute `assetMap.<ns>.src` roots. Vite's default watcher ignores
+   * extensions it doesn't compile, so callers should `watcher.add(...)`
+   * these to receive template-file events at all.
+   */
+  assetSrcRoots: readonly string[];
+  /** Cancel any pending debounced pass. */
+  dispose(): void;
+}
+declare function createTypegenDevWatcher(opts: TypegenDevWatcherOptions): TypegenDevWatcher;
+//#endregion
 //#region src/generator-extension/discover.d.ts
 /**
  * One row in the discovered registry. `source` is the npm package name
@@ -1156,5 +1442,5 @@ declare function toKebabCase(name: string): string;
  */
 declare function pluralize(name: string): string;
 //#endregion
-export { type DiscoveredGenerator, type DiscoveryResult, type DoctorCheck, type DoctorContext, type DoctorExtension, type DoctorResult, type GeneratorArg, type GeneratorContext, type GeneratorFile, type GeneratorFlag, type GeneratorSpec, type KickCliPlugin, type KickCliPluginContext, type KickCommandDefinition, type KickConfig, type KickDbConfigBlock, KickPluginConflictError, type TypegenContext, type TypegenPlugin, type TypegenPluginResult, buildGeneratorContext, defineCliPlugin, defineConfig, defineDoctorCheck, defineDoctorExtension, defineGenerator, defineTypegen, findProjectRoot, generateAdapter, generateController, generateDto, generateGuard, generateMiddleware, generateModule, generateService, initProject, loadKickConfig, pluralize, toCamelCase, toKebabCase, toPascalCase };
+export { type DiscoveredGenerator, type DiscoveryResult, type DoctorCheck, type DoctorContext, type DoctorExtension, type DoctorResult, type GeneratorArg, type GeneratorContext, type GeneratorFile, type GeneratorFlag, type GeneratorSpec, type KickCliPlugin, type KickCliPluginContext, type KickCommandDefinition, type KickConfig, type KickDbConfigBlock, KickPluginConflictError, TYPEGEN_OWNER_KEY, type TypegenContext, type TypegenDevWatcher, type TypegenDevWatcherOptions, type TypegenPlugin, type TypegenPluginResult, type TypegenWatchEvent, buildGeneratorContext, createTypegenDevWatcher, defineCliPlugin, defineConfig, defineDoctorCheck, defineDoctorExtension, defineGenerator, defineTypegen, findProjectRoot, generateAdapter, generateController, generateDto, generateGuard, generateMiddleware, generateModule, generateService, initProject, loadKickConfig, pluralize, toCamelCase, toKebabCase, toPascalCase };
 //# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../src/commands/doctor.ts","../src/plugin/types.ts","../src/config.ts","../src/generators/templates/types.ts","../src/generators/module.ts","../src/generators/adapter.ts","../src/generators/middleware.ts","../src/generators/guard.ts","../src/generators/service.ts","../src/generators/controller.ts","../src/generators/dto.ts","../src/generators/project.ts","../src/utils/project-root.ts","../src/typegen/scanner.ts","../src/typegen/plugin.ts","../src/generator-extension/discover.ts","../src/generator-extension/context.ts","../src/utils/naming.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/commands/doctor.ts","../src/plugin/types.ts","../src/config.ts","../src/generators/templates/types.ts","../src/generators/module.ts","../src/generators/adapter.ts","../src/generators/middleware.ts","../src/generators/guard.ts","../src/generators/service.ts","../src/generators/controller.ts","../src/generators/dto.ts","../src/generators/project.ts","../src/utils/project-root.ts","../src/typegen/scanner.ts","../src/typegen/plugin.ts","../src/typegen/token-conventions.ts","../src/typegen/index.ts","../src/typegen/run-plugins.ts","../src/asset-manager/build.ts","../src/typegen/dev-watcher.ts","../src/generator-extension/discover.ts","../src/generator-extension/context.ts","../src/utils/naming.ts"],"mappings":"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"}

package/dist/index.mjs

@@ -1,5 +1,5 @@
 /**
- * @forinda/kickjs-cli v6.0.1
+ * @forinda/kickjs-cli v6.1.1
  *
  * Copyright (c) Felix Orinda
  *
@@ -8,5 +8,5 @@
  *
  * @license MIT
  */
-import{A as e,M as t,O as n,c as r,d as i,f as a,h as o,j as s,l as c,n as l,o as u,p as d,s as f,t as p,u as m,v as h}from"./doctor-559QZlHi.mjs";import{i as g,r as _}from"./config-DSpcRefL.mjs";import{t as v}from"./project-root-BdTe6EpE.mjs";import{n as y,t as b}from"./types-BKKzf_bU.mjs";function x(e){return e}export{b as KickPluginConflictError,u as buildGeneratorContext,y as defineCliPlugin,_ as defineConfig,p as defineDoctorCheck,l as defineDoctorExtension,f as defineGenerator,x as defineTypegen,v as findProjectRoot,o as generateAdapter,m as generateController,c as generateDto,a as generateGuard,d as generateMiddleware,h as generateModule,i as generateService,r as initProject,g as loadKickConfig,n as pluralize,e as toCamelCase,s as toKebabCase,t as toPascalCase};
+import{A as e,M as t,N as n,P as r,_ as i,b as a,c as o,d as s,f as c,h as l,l as u,m as d,n as f,o as p,p as m,s as h,t as g,u as _}from"./doctor-CcVNNzGj.mjs";import{i as v,r as y}from"./config-DLy6JCCy.mjs";import{t as b}from"./project-root-yLxS5CqO.mjs";import{n as x,t as S}from"./types-D7d_Y66D.mjs";function C(e){return e}export{S as KickPluginConflictError,o as TYPEGEN_OWNER_KEY,p as buildGeneratorContext,u as createTypegenDevWatcher,x as defineCliPlugin,y as defineConfig,g as defineDoctorCheck,f as defineDoctorExtension,h as defineGenerator,C as defineTypegen,b as findProjectRoot,i as generateAdapter,c as generateController,s as generateDto,d as generateGuard,l as generateMiddleware,a as generateModule,m as generateService,_ as initProject,v as loadKickConfig,e as pluralize,t as toCamelCase,n as toKebabCase,r as toPascalCase};
 //# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":[],"sources":["../src/typegen/plugin.ts"],"sourcesContent":["// TypegenPlugin contract — M2.B-T7.\n//\n// Each plugin owns a single `.kickjs/types/<id>.d.ts` file. The runner\n// invokes `generate(ctx)` per plugin, prepends a banner, writes only on\n// content change, and surfaces drift in --check mode (CI gate).\n//\n// Built-in plugins (kick/routes, kick/env, kick/assets, kick/db) live under\n// `./builtin`. Adopters register additional plugins via kick.config.ts.\n\nimport type { KickConfig } from '../config'\nimport type { ScanOptions, ScanResult } from './scanner'\n\nexport interface TypegenLogger {\n  info(msg: string): void\n  warn(msg: string): void\n  error(msg: string): void\n}\n\nexport interface TypegenContext {\n  cwd: string\n  config: KickConfig\n  /** Dynamic-import a TS module (Node loader). Used by plugins that need to\n   * read the adopter's schema / route map / asset registry at generate time. */\n  importTs<T = unknown>(absPath: string): Promise<T>\n  /** Write under `cwd`. Caller passes a relPath (e.g. `.kickjs/types/foo.d.ts`). */\n  writeFile(relPath: string, contents: string): Promise<void>\n  /**\n   * Run `scanProject` once per typegen pass, memoizing the result so\n   * multiple plugins (`kick/routes`, `kick/env`, future adopter plugins)\n   * share a single fs walk + AST extraction.\n   *\n   * The runner uses an order-independent cache key derived from the\n   * resolved options (`root`, `cwd`, `extensions`, `exclude`, `envFile`)\n   * — semantically equal options hit the cache regardless of how the\n   * caller built the literal. (We deliberately don't `JSON.stringify`\n   * the options for caching since that would be sensitive to property\n   * insertion order.) Plugins that don't need scanner data can ignore\n   * this method entirely.\n   *\n   * Implementation lives in the runner so test harnesses can inject\n   * a stub scanner; plugins only see the function.\n   */\n  getScanResult(opts: ScanOptions): Promise<ScanResult>\n  log: TypegenLogger\n}\n\nexport interface TypegenPlugin {\n  /** Stable id — used as filename: `.kickjs/types/${id}<outExtension>` (slashes → `__`). */\n  id: string\n  /** Glob patterns the Vite watcher subscribes to; change → re-run this plugin. */\n  inputs: string[]\n  /**\n   * Output filename extension. Default `.d.ts` — the right choice for\n   * pure module-augmentation plugins (kick/db, kick/assets) since\n   * declaration files don't need the runtime-import dance.\n   *\n   * `kick/routes` overrides to `.ts` because it emits hoisted\n   * `import type {...} from '...'` lines at the top of the file. Inline\n   * `import('...').X` references inside `.d.ts` silently degrade to\n   * `unknown` under `moduleResolution: 'bundler'`; emitting `.ts`\n   * sidesteps that quirk and gets full type resolution.\n   *\n   * Adopter-supplied plugins should leave this unset unless they hit\n   * the same hoisted-import constraint.\n   */\n  outExtension?: string\n  /**\n   * Return the augmentation source (without banner — runner prepends).\n   * Return null to skip emission (e.g. no schema file present).\n   */\n  generate(ctx: TypegenContext): Promise<string | null>\n}\n\nexport interface TypegenPluginResult {\n  id: string\n  status: 'written' | 'unchanged' | 'skipped' | 'error'\n  outFile?: string\n}\n\n/**\n * Identity factory for {@link TypegenPlugin}. Returns the spec verbatim.\n * Exists for type inference and forward-compatibility — future\n * fields can be added with defaults without breaking adopters.\n *\n * Mirrors {@link defineGenerator} ergonomics. Use at the call site so\n * the plugin's `generate(ctx)` body gets a fully-typed `ctx` without\n * an explicit annotation:\n *\n * @example\n * ```ts\n * import { defineTypegen } from '@forinda/kickjs-cli'\n *\n * export const drizzleTypegen = defineTypegen({\n *   id: 'drizzle',\n *   inputs: ['src/db/schema.ts'],\n *   async generate(ctx) {\n *     const schema = await ctx.importTs(`${ctx.cwd}/src/db/schema.ts`)\n *     return `// declare module …`\n *   },\n * })\n * ```\n */\nexport function defineTypegen(spec: TypegenPlugin): TypegenPlugin {\n  return spec\n}\n"],"mappings":";;;;;;;;;;oSAsGA,SAAgB,EAAc,EAAoC,CAChE,OAAO,CACT"}
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/typegen/plugin.ts"],"sourcesContent":["// TypegenPlugin contract — M2.B-T7.\n//\n// Each plugin owns a single `.kickjs/types/<id>.d.ts` file. The runner\n// invokes `generate(ctx)` per plugin, prepends a banner, writes only on\n// content change, and surfaces drift in --check mode (CI gate).\n//\n// Built-in plugins (kick/routes, kick/env, kick/assets, kick/db) live under\n// `./builtin`. Adopters register additional plugins via kick.config.ts.\n\nimport type { KickConfig } from '../config'\nimport type { ScanOptions, ScanResult } from './scanner'\n\nexport interface TypegenLogger {\n  info(msg: string): void\n  warn(msg: string): void\n  error(msg: string): void\n}\n\nexport interface TypegenContext {\n  cwd: string\n  config: KickConfig\n  /** Dynamic-import a TS module (Node loader). Used by plugins that need to\n   * read the adopter's schema / route map / asset registry at generate time. */\n  importTs<T = unknown>(absPath: string): Promise<T>\n  /** Write under `cwd`. Caller passes a relPath (e.g. `.kickjs/types/foo.d.ts`). */\n  writeFile(relPath: string, contents: string): Promise<void>\n  /**\n   * Run `scanProject` once per typegen pass, memoizing the result so\n   * multiple plugins (`kick/routes`, `kick/env`, future adopter plugins)\n   * share a single fs walk + AST extraction.\n   *\n   * The runner uses an order-independent cache key derived from the\n   * resolved options (`root`, `cwd`, `extensions`, `exclude`, `envFile`)\n   * — semantically equal options hit the cache regardless of how the\n   * caller built the literal. (We deliberately don't `JSON.stringify`\n   * the options for caching since that would be sensitive to property\n   * insertion order.) Plugins that don't need scanner data can ignore\n   * this method entirely.\n   *\n   * Implementation lives in the runner so test harnesses can inject\n   * a stub scanner; plugins only see the function.\n   */\n  getScanResult(opts: ScanOptions): Promise<ScanResult>\n  log: TypegenLogger\n}\n\nexport interface TypegenPlugin {\n  /** Stable id — used as filename: `.kickjs/types/${id}<outExtension>` (slashes → `__`). */\n  id: string\n  /** Glob patterns the Vite watcher subscribes to; change → re-run this plugin. */\n  inputs: string[]\n  /**\n   * Output filename extension. Default `.d.ts` — the right choice for\n   * pure module-augmentation plugins (kick/db, kick/assets) since\n   * declaration files don't need the runtime-import dance.\n   *\n   * `kick/routes` overrides to `.ts` because it emits hoisted\n   * `import type {...} from '...'` lines at the top of the file. Inline\n   * `import('...').X` references inside `.d.ts` silently degrade to\n   * `unknown` under `moduleResolution: 'bundler'`; emitting `.ts`\n   * sidesteps that quirk and gets full type resolution.\n   *\n   * Adopter-supplied plugins should leave this unset unless they hit\n   * the same hoisted-import constraint.\n   */\n  outExtension?: string\n  /**\n   * Return the augmentation source (without banner — runner prepends).\n   * Return null to skip emission (e.g. no schema file present).\n   */\n  generate(ctx: TypegenContext): Promise<string | null>\n}\n\nexport interface TypegenPluginResult {\n  id: string\n  status: 'written' | 'unchanged' | 'skipped' | 'error'\n  outFile?: string\n}\n\n/**\n * Identity factory for {@link TypegenPlugin}. Returns the spec verbatim.\n * Exists for type inference and forward-compatibility — future\n * fields can be added with defaults without breaking adopters.\n *\n * Mirrors {@link defineGenerator} ergonomics. Use at the call site so\n * the plugin's `generate(ctx)` body gets a fully-typed `ctx` without\n * an explicit annotation:\n *\n * @example\n * ```ts\n * import { defineTypegen } from '@forinda/kickjs-cli'\n *\n * export const drizzleTypegen = defineTypegen({\n *   id: 'drizzle',\n *   inputs: ['src/db/schema.ts'],\n *   async generate(ctx) {\n *     const schema = await ctx.importTs(`${ctx.cwd}/src/db/schema.ts`)\n *     return `// declare module …`\n *   },\n * })\n * ```\n */\nexport function defineTypegen(spec: TypegenPlugin): TypegenPlugin {\n  return spec\n}\n"],"mappings":";;;;;;;;;;kTAsGA,SAAgB,EAAc,EAAoC,CAChE,OAAO,CACT"}

package/dist/{plugin-DK01q7wy.mjs → plugin-C6jhcq0N.mjs}

@@ -1,5 +1,5 @@
 /**
- * @forinda/kickjs-cli v6.0.1
+ * @forinda/kickjs-cli v6.1.1
  *
  * Copyright (c) Felix Orinda
  *
@@ -8,5 +8,5 @@
  *
  * @license MIT
  */
-import{t as e}from"./rolldown-runtime-CoN4EDcd.mjs";import{t}from"./types-BKKzf_bU.mjs";function n(e,n=[]){let r=new Map;for(let n of e){let e=(r.get(n.name)??0)+1;if(r.set(n.name,e),e===2)throw new t(`plugin`,n.name,[n.name,n.name])}let i=new Map,a=[];for(let n of e)for(let e of n.commands??[]){let r=i.get(e.name);if(r)throw new t(`command`,e.name,[r,n.name]);i.set(e.name,n.name),a.push(e)}let o=new Set(n.map(e=>e.name)),s=[...a.filter(e=>!o.has(e.name)),...n],c=new Map,l=[];for(let n of e)for(let e of n.typegens??[]){let r=c.get(e.id);if(r)throw new t(`typegen`,e.id,[r,n.name]);c.set(e.id,n.name),l.push(e)}let u=new Map,d=[];for(let n of e)for(let e of n.generators??[]){let r=u.get(e.name);if(r)throw new t(`generator`,e.name,[r,n.name]);u.set(e.name,n.name),d.push({source:n.name,spec:e})}return{commands:s,typegens:l,generators:d,register:async(t,n)=>{let r;if(n)r={generators:d,...n};else{let{findProjectRoot:e}=await import(`./project-root-BdTe6EpE.mjs`).then(e=>e.n),t=process.cwd();r={cwd:t,projectRoot:e(t),config:null,log:()=>{},generators:d}}for(let n of e)n.register&&await n.register(t,r)}}}var r=e({mergeCliPlugins:()=>n});export{n,r as t};
-//# sourceMappingURL=plugin-DK01q7wy.mjs.map
+import{t as e}from"./rolldown-runtime-BnMWUWuC.mjs";import{t}from"./types-D7d_Y66D.mjs";function n(e,n=[]){let r=new Map;for(let n of e){let e=(r.get(n.name)??0)+1;if(r.set(n.name,e),e===2)throw new t(`plugin`,n.name,[n.name,n.name])}let i=new Map,a=[];for(let n of e)for(let e of n.commands??[]){let r=i.get(e.name);if(r)throw new t(`command`,e.name,[r,n.name]);i.set(e.name,n.name),a.push(e)}let o=new Set(n.map(e=>e.name)),s=[...a.filter(e=>!o.has(e.name)),...n],c=new Map,l=[];for(let n of e)for(let e of n.typegens??[]){let r=c.get(e.id);if(r)throw new t(`typegen`,e.id,[r,n.name]);c.set(e.id,n.name),l.push(e)}let u=new Map,d=[];for(let n of e)for(let e of n.generators??[]){let r=u.get(e.name);if(r)throw new t(`generator`,e.name,[r,n.name]);u.set(e.name,n.name),d.push({source:n.name,spec:e})}return{commands:s,typegens:l,generators:d,register:async(t,n)=>{let r;if(n)r={generators:d,...n};else{let{findProjectRoot:e}=await import(`./project-root-yLxS5CqO.mjs`).then(e=>e.n),t=process.cwd();r={cwd:t,projectRoot:e(t),config:null,log:()=>{},generators:d}}for(let n of e)n.register&&await n.register(t,r)}}}var r=e({mergeCliPlugins:()=>n});export{n,r as t};
+//# sourceMappingURL=plugin-C6jhcq0N.mjs.map

package/dist/{plugin-DK01q7wy.mjs.map → plugin-C6jhcq0N.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"plugin-DK01q7wy.mjs","names":[],"sources":["../src/plugin/merge.ts","../src/plugin/index.ts"],"sourcesContent":["// Plugin → unified registry merge.\n//\n// Resolution rules (per the v1 spec + dogfood pivot):\n//   - duplicate plugin `name` across the input array → conflict error.\n//     Catches the double-install case (built-in shipped twice, or\n//     adopter requiring the same plugin twice).\n//   - plugin commands appear first in the merged list, then adopter\n//     commands; adopter `commands` of the same name override the\n//     plugin entry (filter pass).\n//   - duplicate command name across two plugins → conflict error\n//     listing both plugin names. Adopter overriding a plugin is\n//     allowed and not an error.\n//   - duplicate typegen id across two plugins → same error. Typegens\n//     have no adopter override path; only plugins contribute them.\n//   - register() functions are collected in input order; the caller\n//     invokes each one against the same Command program. They have no\n//     id-level conflict surface — owners are responsible for picking\n//     non-colliding command names inside their own register().\n//   - plugin order = array order. No implicit precedence rules.\n\nimport type { Command } from 'commander'\n\nimport type { KickCommandDefinition } from '../config'\nimport type { TypegenPlugin } from '../typegen/plugin'\nimport type { GeneratorSpec } from '../generator-extension/define'\nimport type { DiscoveredGenerator } from '../generator-extension/discover'\nimport { KickPluginConflictError, type KickCliPlugin, type KickCliPluginContext } from './types'\n\nexport interface MergedPlugins {\n  commands: KickCommandDefinition[]\n  typegens: TypegenPlugin[]\n  /** DiscoveredGenerator shape so this list slots into the existing\n   * dispatch path next to package.json-discovered entries. `source`\n   * carries the plugin name for error attribution. */\n  generators: DiscoveredGenerator[]\n  /**\n   * Apply every plugin's register() in input order. ctx is optional so\n   * tests + lightweight callers can invoke `register(program)` without\n   * constructing a full context; it falls back to cwd=process.cwd(),\n   * config=null, log=no-op.\n   */\n  register: (program: Command, ctx?: KickCliPluginContext) => Promise<void>\n}\n\nexport function mergeCliPlugins(\n  plugins: readonly KickCliPlugin[],\n  adopterCommands: readonly KickCommandDefinition[] = [],\n): MergedPlugins {\n  // Plugin-name dedup — catches double-install.\n  const seenPluginNames = new Map<string, number>()\n  for (const p of plugins) {\n    const count = (seenPluginNames.get(p.name) ?? 0) + 1\n    seenPluginNames.set(p.name, count)\n    if (count === 2) {\n      throw new KickPluginConflictError('plugin', p.name, [p.name, p.name])\n    }\n  }\n\n  const commandOwners = new Map<string, string>()\n  const pluginCommands: KickCommandDefinition[] = []\n  for (const p of plugins) {\n    for (const cmd of p.commands ?? []) {\n      const prior = commandOwners.get(cmd.name)\n      if (prior) {\n        throw new KickPluginConflictError('command', cmd.name, [prior, p.name])\n      }\n      commandOwners.set(cmd.name, p.name)\n      pluginCommands.push(cmd)\n    }\n  }\n\n  const adopterNames = new Set(adopterCommands.map((c) => c.name))\n  const filteredPlugin = pluginCommands.filter((c) => !adopterNames.has(c.name))\n  const commands = [...filteredPlugin, ...adopterCommands]\n\n  const typegenOwners = new Map<string, string>()\n  const typegens: TypegenPlugin[] = []\n  for (const p of plugins) {\n    for (const tg of p.typegens ?? []) {\n      const prior = typegenOwners.get(tg.id)\n      if (prior) {\n        throw new KickPluginConflictError('typegen', tg.id, [prior, p.name])\n      }\n      typegenOwners.set(tg.id, p.name)\n      typegens.push(tg)\n    }\n  }\n\n  const generatorOwners = new Map<string, string>()\n  const generators: DiscoveredGenerator[] = []\n  for (const p of plugins) {\n    for (const spec of p.generators ?? []) {\n      const prior = generatorOwners.get(spec.name)\n      if (prior) {\n        throw new KickPluginConflictError('generator', spec.name, [prior, p.name])\n      }\n      generatorOwners.set(spec.name, p.name)\n      generators.push({ source: p.name, spec: spec satisfies GeneratorSpec })\n    }\n  }\n\n  /**\n   * Apply every plugin's `register()` callback in input order against the\n   * given Commander program. Each callback receives a {@link KickCliPluginContext}:\n   * caller-supplied ctx wins (test fixtures can inject a different\n   * workspace boundary); otherwise a default ctx is built with\n   * `findProjectRoot(process.cwd())` as the project root, `cwd` matching\n   * `process.cwd()`, null config, no-op log, and the merged generator set\n   * threaded through so the `kick/generate` built-in can surface each as\n   * a Commander subcommand. The dynamic import of `findProjectRoot` keeps\n   * the caller-supplied fast path zero-cost.\n   */\n  const register = async (program: Command, ctx?: KickCliPluginContext): Promise<void> => {\n    let resolved: KickCliPluginContext\n    if (ctx) {\n      resolved = { generators, ...ctx }\n    } else {\n      const { findProjectRoot } = await import('../utils/project-root')\n      const cwd = process.cwd()\n      resolved = {\n        cwd,\n        projectRoot: findProjectRoot(cwd),\n        config: null,\n        log: () => {},\n        generators,\n      }\n    }\n    for (const p of plugins) {\n      if (p.register) await p.register(program, resolved)\n    }\n  }\n\n  return { commands, typegens, generators, register }\n}\n","// Barrel intentionally omits `./builtins` — that module top-level-imports\n// every register*Command, which pulls heavy modules (project scaffolders,\n// fs reads at import time) into the graph. Importers that need the\n// builtin list go through `./plugin/builtins` directly; tests + adopter\n// plugins consuming only the contract types import from here.\n\nexport type { KickCliPlugin } from './types'\nexport { defineCliPlugin, KickPluginConflictError } from './types'\nexport { mergeCliPlugins, type MergedPlugins } from './merge'\n"],"mappings":";;;;;;;;;;wFA4CA,SAAgB,EACd,EACA,EAAoD,CAAC,EACtC,CAEf,IAAM,EAAkB,IAAI,IAC5B,IAAK,IAAM,KAAK,EAAS,CACvB,IAAM,GAAS,EAAgB,IAAI,EAAE,IAAI,GAAK,GAAK,EAEnD,GADA,EAAgB,IAAI,EAAE,KAAM,CAAK,EAC7B,IAAU,EACZ,MAAM,IAAI,EAAwB,SAAU,EAAE,KAAM,CAAC,EAAE,KAAM,EAAE,IAAI,CAAC,CAExE,CAEA,IAAM,EAAgB,IAAI,IACpB,EAA0C,CAAC,EACjD,IAAK,IAAM,KAAK,EACd,IAAK,IAAM,KAAO,EAAE,UAAY,CAAC,EAAG,CAClC,IAAM,EAAQ,EAAc,IAAI,EAAI,IAAI,EACxC,GAAI,EACF,MAAM,IAAI,EAAwB,UAAW,EAAI,KAAM,CAAC,EAAO,EAAE,IAAI,CAAC,EAExE,EAAc,IAAI,EAAI,KAAM,EAAE,IAAI,EAClC,EAAe,KAAK,CAAG,CACzB,CAGF,IAAM,EAAe,IAAI,IAAI,EAAgB,IAAK,GAAM,EAAE,IAAI,CAAC,EAEzD,EAAW,CAAC,GADK,EAAe,OAAQ,GAAM,CAAC,EAAa,IAAI,EAAE,IAAI,CAC1C,EAAG,GAAG,CAAe,EAEjD,EAAgB,IAAI,IACpB,EAA4B,CAAC,EACnC,IAAK,IAAM,KAAK,EACd,IAAK,IAAM,KAAM,EAAE,UAAY,CAAC,EAAG,CACjC,IAAM,EAAQ,EAAc,IAAI,EAAG,EAAE,EACrC,GAAI,EACF,MAAM,IAAI,EAAwB,UAAW,EAAG,GAAI,CAAC,EAAO,EAAE,IAAI,CAAC,EAErE,EAAc,IAAI,EAAG,GAAI,EAAE,IAAI,EAC/B,EAAS,KAAK,CAAE,CAClB,CAGF,IAAM,EAAkB,IAAI,IACtB,EAAoC,CAAC,EAC3C,IAAK,IAAM,KAAK,EACd,IAAK,IAAM,KAAQ,EAAE,YAAc,CAAC,EAAG,CACrC,IAAM,EAAQ,EAAgB,IAAI,EAAK,IAAI,EAC3C,GAAI,EACF,MAAM,IAAI,EAAwB,YAAa,EAAK,KAAM,CAAC,EAAO,EAAE,IAAI,CAAC,EAE3E,EAAgB,IAAI,EAAK,KAAM,EAAE,IAAI,EACrC,EAAW,KAAK,CAAE,OAAQ,EAAE,KAAY,MAA6B,CAAC,CACxE,CAkCF,MAAO,CAAE,WAAU,WAAU,aAAY,eApBjB,EAAkB,IAA8C,CACtF,IAAI,EACJ,GAAI,EACF,EAAW,CAAE,aAAY,GAAG,CAAI,MAC3B,CACL,GAAM,CAAE,mBAAoB,MAAM,OAAO,8BAAwB,CAAA,KAAA,GAAA,EAAA,CAAA,EAC3D,EAAM,QAAQ,IAAI,EACxB,EAAW,CACT,MACA,YAAa,EAAgB,CAAG,EAChC,OAAQ,KACR,QAAW,CAAC,EACZ,YACF,CACF,CACA,IAAK,IAAM,KAAK,EACV,EAAE,UAAU,MAAM,EAAE,SAAS,EAAS,CAAQ,CAEtD,CAEkD,CACpD"}
+{"version":3,"file":"plugin-C6jhcq0N.mjs","names":[],"sources":["../src/plugin/merge.ts","../src/plugin/index.ts"],"sourcesContent":["// Plugin → unified registry merge.\n//\n// Resolution rules (per the v1 spec + dogfood pivot):\n//   - duplicate plugin `name` across the input array → conflict error.\n//     Catches the double-install case (built-in shipped twice, or\n//     adopter requiring the same plugin twice).\n//   - plugin commands appear first in the merged list, then adopter\n//     commands; adopter `commands` of the same name override the\n//     plugin entry (filter pass).\n//   - duplicate command name across two plugins → conflict error\n//     listing both plugin names. Adopter overriding a plugin is\n//     allowed and not an error.\n//   - duplicate typegen id across two plugins → same error. Typegens\n//     have no adopter override path; only plugins contribute them.\n//   - register() functions are collected in input order; the caller\n//     invokes each one against the same Command program. They have no\n//     id-level conflict surface — owners are responsible for picking\n//     non-colliding command names inside their own register().\n//   - plugin order = array order. No implicit precedence rules.\n\nimport type { Command } from 'commander'\n\nimport type { KickCommandDefinition } from '../config'\nimport type { TypegenPlugin } from '../typegen/plugin'\nimport type { GeneratorSpec } from '../generator-extension/define'\nimport type { DiscoveredGenerator } from '../generator-extension/discover'\nimport { KickPluginConflictError, type KickCliPlugin, type KickCliPluginContext } from './types'\n\nexport interface MergedPlugins {\n  commands: KickCommandDefinition[]\n  typegens: TypegenPlugin[]\n  /** DiscoveredGenerator shape so this list slots into the existing\n   * dispatch path next to package.json-discovered entries. `source`\n   * carries the plugin name for error attribution. */\n  generators: DiscoveredGenerator[]\n  /**\n   * Apply every plugin's register() in input order. ctx is optional so\n   * tests + lightweight callers can invoke `register(program)` without\n   * constructing a full context; it falls back to cwd=process.cwd(),\n   * config=null, log=no-op.\n   */\n  register: (program: Command, ctx?: KickCliPluginContext) => Promise<void>\n}\n\nexport function mergeCliPlugins(\n  plugins: readonly KickCliPlugin[],\n  adopterCommands: readonly KickCommandDefinition[] = [],\n): MergedPlugins {\n  // Plugin-name dedup — catches double-install.\n  const seenPluginNames = new Map<string, number>()\n  for (const p of plugins) {\n    const count = (seenPluginNames.get(p.name) ?? 0) + 1\n    seenPluginNames.set(p.name, count)\n    if (count === 2) {\n      throw new KickPluginConflictError('plugin', p.name, [p.name, p.name])\n    }\n  }\n\n  const commandOwners = new Map<string, string>()\n  const pluginCommands: KickCommandDefinition[] = []\n  for (const p of plugins) {\n    for (const cmd of p.commands ?? []) {\n      const prior = commandOwners.get(cmd.name)\n      if (prior) {\n        throw new KickPluginConflictError('command', cmd.name, [prior, p.name])\n      }\n      commandOwners.set(cmd.name, p.name)\n      pluginCommands.push(cmd)\n    }\n  }\n\n  const adopterNames = new Set(adopterCommands.map((c) => c.name))\n  const filteredPlugin = pluginCommands.filter((c) => !adopterNames.has(c.name))\n  const commands = [...filteredPlugin, ...adopterCommands]\n\n  const typegenOwners = new Map<string, string>()\n  const typegens: TypegenPlugin[] = []\n  for (const p of plugins) {\n    for (const tg of p.typegens ?? []) {\n      const prior = typegenOwners.get(tg.id)\n      if (prior) {\n        throw new KickPluginConflictError('typegen', tg.id, [prior, p.name])\n      }\n      typegenOwners.set(tg.id, p.name)\n      typegens.push(tg)\n    }\n  }\n\n  const generatorOwners = new Map<string, string>()\n  const generators: DiscoveredGenerator[] = []\n  for (const p of plugins) {\n    for (const spec of p.generators ?? []) {\n      const prior = generatorOwners.get(spec.name)\n      if (prior) {\n        throw new KickPluginConflictError('generator', spec.name, [prior, p.name])\n      }\n      generatorOwners.set(spec.name, p.name)\n      generators.push({ source: p.name, spec: spec satisfies GeneratorSpec })\n    }\n  }\n\n  /**\n   * Apply every plugin's `register()` callback in input order against the\n   * given Commander program. Each callback receives a {@link KickCliPluginContext}:\n   * caller-supplied ctx wins (test fixtures can inject a different\n   * workspace boundary); otherwise a default ctx is built with\n   * `findProjectRoot(process.cwd())` as the project root, `cwd` matching\n   * `process.cwd()`, null config, no-op log, and the merged generator set\n   * threaded through so the `kick/generate` built-in can surface each as\n   * a Commander subcommand. The dynamic import of `findProjectRoot` keeps\n   * the caller-supplied fast path zero-cost.\n   */\n  const register = async (program: Command, ctx?: KickCliPluginContext): Promise<void> => {\n    let resolved: KickCliPluginContext\n    if (ctx) {\n      resolved = { generators, ...ctx }\n    } else {\n      const { findProjectRoot } = await import('../utils/project-root')\n      const cwd = process.cwd()\n      resolved = {\n        cwd,\n        projectRoot: findProjectRoot(cwd),\n        config: null,\n        log: () => {},\n        generators,\n      }\n    }\n    for (const p of plugins) {\n      if (p.register) await p.register(program, resolved)\n    }\n  }\n\n  return { commands, typegens, generators, register }\n}\n","// Barrel intentionally omits `./builtins` — that module top-level-imports\n// every register*Command, which pulls heavy modules (project scaffolders,\n// fs reads at import time) into the graph. Importers that need the\n// builtin list go through `./plugin/builtins` directly; tests + adopter\n// plugins consuming only the contract types import from here.\n\nexport type { KickCliPlugin } from './types'\nexport { defineCliPlugin, KickPluginConflictError } from './types'\nexport { mergeCliPlugins, type MergedPlugins } from './merge'\n"],"mappings":";;;;;;;;;;wFA4CA,SAAgB,EACd,EACA,EAAoD,CAAC,EACtC,CAEf,IAAM,EAAkB,IAAI,IAC5B,IAAK,IAAM,KAAK,EAAS,CACvB,IAAM,GAAS,EAAgB,IAAI,EAAE,IAAI,GAAK,GAAK,EAEnD,GADA,EAAgB,IAAI,EAAE,KAAM,CAAK,EAC7B,IAAU,EACZ,MAAM,IAAI,EAAwB,SAAU,EAAE,KAAM,CAAC,EAAE,KAAM,EAAE,IAAI,CAAC,CAExE,CAEA,IAAM,EAAgB,IAAI,IACpB,EAA0C,CAAC,EACjD,IAAK,IAAM,KAAK,EACd,IAAK,IAAM,KAAO,EAAE,UAAY,CAAC,EAAG,CAClC,IAAM,EAAQ,EAAc,IAAI,EAAI,IAAI,EACxC,GAAI,EACF,MAAM,IAAI,EAAwB,UAAW,EAAI,KAAM,CAAC,EAAO,EAAE,IAAI,CAAC,EAExE,EAAc,IAAI,EAAI,KAAM,EAAE,IAAI,EAClC,EAAe,KAAK,CAAG,CACzB,CAGF,IAAM,EAAe,IAAI,IAAI,EAAgB,IAAK,GAAM,EAAE,IAAI,CAAC,EAEzD,EAAW,CAAC,GADK,EAAe,OAAQ,GAAM,CAAC,EAAa,IAAI,EAAE,IAAI,CAC1C,EAAG,GAAG,CAAe,EAEjD,EAAgB,IAAI,IACpB,EAA4B,CAAC,EACnC,IAAK,IAAM,KAAK,EACd,IAAK,IAAM,KAAM,EAAE,UAAY,CAAC,EAAG,CACjC,IAAM,EAAQ,EAAc,IAAI,EAAG,EAAE,EACrC,GAAI,EACF,MAAM,IAAI,EAAwB,UAAW,EAAG,GAAI,CAAC,EAAO,EAAE,IAAI,CAAC,EAErE,EAAc,IAAI,EAAG,GAAI,EAAE,IAAI,EAC/B,EAAS,KAAK,CAAE,CAClB,CAGF,IAAM,EAAkB,IAAI,IACtB,EAAoC,CAAC,EAC3C,IAAK,IAAM,KAAK,EACd,IAAK,IAAM,KAAQ,EAAE,YAAc,CAAC,EAAG,CACrC,IAAM,EAAQ,EAAgB,IAAI,EAAK,IAAI,EAC3C,GAAI,EACF,MAAM,IAAI,EAAwB,YAAa,EAAK,KAAM,CAAC,EAAO,EAAE,IAAI,CAAC,EAE3E,EAAgB,IAAI,EAAK,KAAM,EAAE,IAAI,EACrC,EAAW,KAAK,CAAE,OAAQ,EAAE,KAAY,MAA6B,CAAC,CACxE,CAkCF,MAAO,CAAE,WAAU,WAAU,aAAY,eApBjB,EAAkB,IAA8C,CACtF,IAAI,EACJ,GAAI,EACF,EAAW,CAAE,aAAY,GAAG,CAAI,MAC3B,CACL,GAAM,CAAE,mBAAoB,MAAM,OAAO,8BAAwB,CAAA,KAAA,GAAA,EAAA,CAAA,EAC3D,EAAM,QAAQ,IAAI,EACxB,EAAW,CACT,MACA,YAAa,EAAgB,CAAG,EAChC,OAAQ,KACR,QAAW,CAAC,EACZ,YACF,CACF,CACA,IAAK,IAAM,KAAK,EACV,EAAE,UAAU,MAAM,EAAE,SAAS,EAAS,CAAQ,CAEtD,CAEkD,CACpD"}

package/dist/{project-docs-CrfNQIZA.mjs → project-docs-CqOymvmb.mjs}

@@ -1,5 +1,5 @@
 /**
- * @forinda/kickjs-cli v6.0.1
+ * @forinda/kickjs-cli v6.1.1
  *
  * Copyright (c) Felix Orinda
  *
@@ -825,4 +825,4 @@ Codex / Cursor / Gemini / Claude Code without copy-pasting.
 CLI template. Hand-edited content is overwritten — keep customisation
 in \`.agents/COPILOT.local.md\`.
 `}export{C as _,I as a,m as b,w as c,T as d,O as f,u as g,S as h,L as i,M as l,D as m,P as n,N as o,j as p,R as r,A as s,F as t,k as u,b as v,f as y};
-//# sourceMappingURL=project-docs-CrfNQIZA.mjs.map
+//# sourceMappingURL=project-docs-CqOymvmb.mjs.map