@venizia/ignis-boot 0.2.0-6 → 0.2.0-8

package/README.md

@@ -4,216 +4,148 @@
 
 # :fire: IGNIS - `@venizia/ignis-boot`
 
-**Convention-based discovery and bootstrapping.**
+**Generates one static registration file from your decorated classes.**
 
 [![Docs](https://img.shields.io/badge/Docs-ignis.venizia.ai-2563EB.svg?style=flat-square)](https://ignis.venizia.ai/references/base/bootstrapping)
 [![npm](https://img.shields.io/npm/v/@venizia/ignis-boot.svg?style=flat-square&color=cb3837&label=@venizia/ignis-boot)](https://www.npmjs.com/package/@venizia/ignis-boot)
 [![License: MIT](https://img.shields.io/badge/License-MIT-3DA639.svg?style=flat-square)](LICENSE.md)
 [![TypeScript](https://img.shields.io/badge/TypeScript-6.x-3178C6.svg?style=flat-square&logo=typescript&logoColor=white)](https://www.typescriptlang.org/)
 
-[Bootstrapping reference](https://ignis.venizia.ai/references/base/bootstrapping) •
-[Application](https://ignis.venizia.ai/references/base/application) •
-[Dependency injection](https://ignis.venizia.ai/references/base/dependency-injection)
+[Artifact registration reference](https://ignis.venizia.ai/references/base/bootstrapping) •
+[Registering artifacts guide](https://ignis.venizia.ai/guides/core-concepts/application/bootstrapping) •
+[Changelog](https://ignis.venizia.ai/changelogs/2026-09-03-deprecated-boot-api-removed)
 
 </div>
 
 ---
 
-Finds your controllers, services, repositories, and datasources by filename, then binds each one into
-the IoC container - so you never maintain a registration list that drifts from the files on disk.
+`ignis-artifacts` walks a source root with the TypeScript compiler API, finds every named,
+non-abstract class that carries an IGNIS stereotype decorator (`@service`, `@controller`, ...), and
+writes one file of plain static imports: `src/generated/artifacts.ts`. The application passes that
+file as `configs.artifacts`; `@venizia/ignis`'s `registerArtifacts` boot step binds it.
 
-**Most applications never import this package.** `BaseApplication` from `@venizia/ignis` already depends
-on it, registers the four built-in booters, and exposes `boot()`. You reach for it directly only to
-write a custom booter for an artifact type of your own.
+**This package runs at build time only.** No decorator runs and no class is imported while
+scanning - detection reads source text, so a datasource that opens a pool at import stays inert.
 
 ## Install
 
 ```bash
-bun add @venizia/ignis-boot
+bun add -d @venizia/ignis-boot
 ```
 
-Already a transitive dependency of `@venizia/ignis`.
+`ignis-artifacts` runs at build time; the generated file imports nothing from this package, so a
+deployed application installs nothing extra for it at runtime.
 
 ## Use it
 
-Convention boot is opt-in: call `boot()` before `start()`.
+Decorate the classes you want registered:
 
 ```typescript
-import { BaseApplication, IApplicationInfo } from '@venizia/ignis';
+import { component, service } from '@venizia/ignis';
 
-class App extends BaseApplication {
-  getAppInfo(): IApplicationInfo {
-    return { name: 'my-app', version: '1.0.0', description: 'My app' };
-  }
-
-  staticConfigure() {}
-  preConfigure() {}
-  postConfigure() {}
-  setupMiddlewares() {}
-}
+@service()
+export class PricingService extends BaseService {}
 
-const application = new App({
-  scope: 'App',
-  config: {
-    host: '0.0.0.0',
-    port: 3000,
-    path: { base: '/api', isStrict: false },
-    bootOptions: {}, // the defaults cover the conventional layout
-  },
-});
-
-await application.boot(); // discover and bind every artifact
-await application.start();
+@component()
+export class MetricsComponent extends BaseComponent {}
 ```
 
-Given the layout below, `boot()` binds `datasources.PostgresDataSource`, `repositories.UserRepository`,
-`services.UserService`, and `controllers.UserController` - no further code.
+Add the generator scripts and run one:
 
+```json
+{
+  "scripts": {
+    "generate:artifacts": "ignis-artifacts generate --root src --out src/generated/artifacts.ts",
+    "check:artifacts": "ignis-artifacts check --root src --out src/generated/artifacts.ts"
+  }
+}
 ```
-<projectRoot>/
-  datasources/postgres.datasource.js
-  repositories/user.repository.js
-  services/user.service.js
-  controllers/user.controller.js
-```
-
-## Discovery conventions
-
-Each booter has a default directory and a default file suffix, and binds into its own namespace.
-
-| Booter | Default dir | Default suffix | Binding key | Tag | Scope |
-| :--- | :--- | :--- | :--- | :--- | :--- |
-| `DatasourceBooter` | `datasources` | `.datasource.js` | `datasources.<ClassName>` | `datasources` | singleton |
-| `RepositoryBooter` | `repositories` | `.repository.js` | `repositories.<ClassName>` | `repositories` | transient |
-| `ServiceBooter` | `services` | `.service.js` | `services.<ClassName>` | `services` | transient |
-| `ControllerBooter` | `controllers` | `.controller.js` | `controllers.<ClassName>` | `controllers` | transient |
-
-Datasources are singletons because a connection pool must be shared; everything else resolves per use.
-Directories resolve relative to the application's `getProjectRoot()`, which defaults to `process.cwd()`.
-Subdirectories are included - `isNested` defaults to `true`.
 
-Booters are registered datasources -> repositories -> services -> controllers, so a repository can
-always resolve the datasource it injects.
+```bash
+bun run generate:artifacts
+```
 
-> [!IMPORTANT]
-> **The default suffixes end in `.js`, not `.ts`.** Discovery globs files on disk and `import`s them, and
-> it is designed to run against your **compiled output**. Build first, and have `getProjectRoot()` point
-> at the built directory - returning `__dirname` from the compiled entrypoint does exactly that. If
-> `boot()` reports zero artifacts, this is almost always why. To boot from TypeScript sources instead,
-> set the extensions explicitly: `{ controllers: { extensions: ['.controller.ts'] } }`.
+Pass the generated index to your application:
 
-## Phases
+```typescript
+import { GeneratedArtifacts } from './generated/artifacts';
 
-`Bootstrapper.boot()` runs three phases across **all** booters - phase by phase, not booter by booter.
+export const configs: IApplicationConfigs = {
+  path: { base: '/api', isStrict: true },
+  artifacts: GeneratedArtifacts,
+};
+```
 
-| Phase | What happens |
-| :--- | :--- |
-| `configure` | Fill in defaults for `dirs`, `extensions`, `isNested`, then build the glob pattern |
-| `discover` | Run the glob under the project root, collecting absolute file paths |
-| `load` | `import()` each file, keep the exported classes, bind them into the container |
+Commit the generated file; never edit it by hand - the next `generate` overwrites it. Full
+walkthrough: [Registering artifacts](https://ignis.venizia.ai/guides/core-concepts/application/bootstrapping).
 
-`boot()` resolves to an `IBootReport`: the booter class names that ran, per-phase `durationMs`, and
-`totalDurationMs`. A throw in any phase is rewrapped naming both the phase and the booter, with the
-original error kept as `cause`.
+## CLI
 
-## Configuring discovery
+Shipped as the `ignis-artifacts` binary. Requires `typescript >= 5` (peer dependency) and runs
+under bun.
 
-Pass `bootOptions` in the application config. Every artifact type takes the same `IArtifactOptions`.
+```
+ignis-artifacts <generate|check> [--root src] [--out src/generated/artifacts.ts] [--ignore a,b] [--export GeneratedArtifacts]
+```
 
-| Option | Type | Meaning |
+| Flag | Default | Meaning |
 | :--- | :--- | :--- |
-| `dirs` | `string[]` | Directories to scan, relative to the project root |
-| `extensions` | `string[]` | File suffixes to match |
-| `isNested` | `boolean` | Include subdirectories - default `true` |
-| `glob` | `string` | Raw glob pattern; overrides the three above |
+| `--root` | `src` | Directory to scan, recursively |
+| `--out` | `src/generated/artifacts.ts` | Output path; import paths are relative to it |
+| `--ignore` | `**/__tests__/**`, `**/*.test.ts`, `**/*.spec.ts`, `**/generated/**` | Comma-separated globs, merged with the default ignore list - never replaces it |
+| `--export` | `GeneratedArtifacts` | Name of the exported constant |
 
-```typescript
-bootOptions: {
-  controllers: { dirs: ['controllers', 'api'], extensions: ['.controller.js'] },
-  services: { glob: 'modules/**/*.service.js' },
-}
-```
+| Command | Effect | Exit code |
+| :--- | :--- | :--- |
+| `generate` | Writes `--out` when its content changed | `0` |
+| `check` | Renders in memory and compares with `--out`; fails a stale index | `0` fresh, `1` stale |
 
-A key that is present but `undefined` - the shape `dirs: process.env.APP_DIRS?.split(',')` produces - is
-treated as not provided and falls back to the default. An empty `dirs` or `extensions` array is not: it
-throws when the pattern is built.
+Default ignore list: `**/__tests__/**`, `**/*.test.ts`, `**/*.spec.ts`, `**/generated/**`.
 
-## Custom booters
+## Detection rules
 
-Extend `BaseArtifactBooter` and implement its three hooks. The base class handles configure, discover,
-and load; you decide only where to look and what to bind.
+A class is emitted when every rule holds. Every miss is logged with its reason.
 
-```typescript
-import { BaseArtifactBooter, IApplication, IBootOptions } from '@venizia/ignis-boot';
-import { BindingKeys, inject } from '@venizia/ignis-inversion';
-
-export class ObserverBooter extends BaseArtifactBooter {
-  constructor(
-    @inject({ key: '@app/project_root' }) root: string,
-    @inject({ key: '@app/instance' }) private readonly application: IApplication,
-    @inject({ key: '@app/boot-options' }) bootOptions: IBootOptions,
-  ) {
-    super({ scope: ObserverBooter.name, root, artifactOptions: bootOptions.observers ?? {} });
-  }
+- Named export (`export class`), not `export default`, not module-private.
+- Not `abstract`.
+- Decorated with `component`, `controller`, `service`, `repository` or `datasource`, imported from
+  `@venizia/ignis` or `@venizia/ignis-kernel` (import aliases resolved) - or with
+  `injectable({ type })` where `type` is a string literal or `ArtifactTypes.<NAME>`.
 
-  protected override getDefaultDirs(): string[] {
-    return ['observers'];
-  }
+`model` classes are recognised and never emitted - a model is reached through its repository.
 
-  protected override getDefaultExtensions(): string[] {
-    return ['.observer.js'];
-  }
+## Programmatic API
 
-  protected override async bind(): Promise<void> {
-    for (const cls of this.loadedClasses) {
-      const key = BindingKeys.build({ namespace: 'observers', key: cls.name });
-      this.application.bind({ key }).toClass(cls).setTags('observers');
-    }
-  }
-}
-```
+`@venizia/ignis-boot/generator` exports the same machinery as functions, for a caller that is not
+a shell script.
 
-`IBootOptions` carries an index signature, so `bootOptions.observers` type-checks with no change to the
-framework. Booters are found by the `booter` tag, so registering is all that remains - and it must
-happen before `boot()` runs, which is earlier than `preConfigure()`:
+| Export | What it is |
+| :--- | :--- |
+| `generateArtifactIndex(opts)` | Renders and writes `opts.out` when the content changed |
+| `checkArtifactIndex(opts)` | Renders in memory and compares with `opts.out`, without writing |
+| `IGenerateOptions` | `{ root, out, ignore?, exportName? }` - shared options for both |
+| `ArtifactScanner.getInstance().scan({ root, ignore? })` | The scan step alone, as `IScannedArtifact[]` |
+| `ArtifactIndexEmitter.render({ artifacts, outFile, exportName })` | The render step alone, as text |
+| `ArtifactStereotypes`, `ArtifactTypes`, `ArtifactIndexFields` | The decorator-to-type map and the emitted field names |
 
 ```typescript
-override async boot() {
-  this.booter(ObserverBooter);
-  return super.boot();
-}
-```
+import { checkArtifactIndex } from '@venizia/ignis-boot/generator';
 
-Every constructor parameter must carry `@inject` - a container-instantiated class with one bare
-parameter is refused at boot.
+const { isFresh } = checkArtifactIndex({ root: 'src', out: 'src/generated/artifacts.ts' });
+```
 
 ## What you must know
 
-- **Every exported class in a matched file is bound**, not only the one whose name matches the file.
-  Keep helper classes out of `*.controller.js` and friends, or move them to their own module.
-- **Discovery is filename-driven, not decorator-driven.** A correctly decorated controller in the wrong
-  directory is invisible to it - register that one manually with `this.controller(...)`.
-- Calling `boot()` twice does not double-register: the bootstrapper resets its booter list on each run.
-- `reflect-metadata` must be imported once at your entrypoint, and `experimentalDecorators` plus
-  `emitDecoratorMetadata` must be `true` **inline** in your `tsconfig.json` - Bun does not resolve them
-  through `extends`, and `@inject` is silently dropped without them.
+- **Output is deterministic.** Imports sorted by path, class names sorted within each field, one
+  field per kind, empty arrays kept. A field wider than 100 columns wraps one name per line, so the
+  file passes the repo's `prettier -l` unchanged.
+- **The scanner never executes a module.** No decorator runs and no import side effect fires while
+  scanning, so a stereotype re-exported through a local wrapper module is not recognised - the
+  import must name an IGNIS module directly.
+- **`check` belongs where lint runs**, not only in CI - a stale index should fail locally before a
+  push reaches the pipeline.
 
-## Surface
-
-| Export | What it is |
-| :--- | :--- |
-| `BaseArtifactBooter` | Abstract base implementing the three phases; extend it for custom artifacts |
-| `Bootstrapper` | Runs the phases across every `booter`-tagged binding and returns the report |
-| `BootMixin` | Adds `boot()`, `bootOptions`, and the four built-in booters to a raw `Container` |
-| `ControllerBooter` / `ServiceBooter` / `RepositoryBooter` / `DatasourceBooter` | The built-in booters |
-| `discoverFiles` / `loadClasses` | The glob and dynamic-import primitives, usable standalone |
-| `BootPhases` | `configure`, `discover`, `load` |
-| `IBootOptions` / `IArtifactOptions` / `IBootReport` / `IBooter` | Public types |
-
-`BootMixin` is for applications not built on `BaseApplication` - it wires the same four booters onto any
-`Container`. `BaseApplication` does its own registration and does not use the mixin.
-
-Full detail: [Bootstrapping reference](https://ignis.venizia.ai/references/base/bootstrapping).
+Full detail: [Artifact registration reference](https://ignis.venizia.ai/references/base/bootstrapping).
 
 ## Links
 
@@ -223,8 +155,5 @@ Full detail: [Bootstrapping reference](https://ignis.venizia.ai/references/base/
 [Best practices](https://ignis.venizia.ai/best-practices/) &#8226;
 [Changelog](https://ignis.venizia.ai/changelogs/)
 
-Inspired by [LoopBack 4's boot system](https://loopback.io/doc/en/lb4/Booting-an-Application.html).
-
 MIT licensed - see [LICENSE.md](LICENSE.md).
 Questions: [GitHub Issues](https://github.com/VENIZIA-AI/ignis/issues) &#8226; developer@venizia.ai
-</content>

package/dist/cjs/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env bun
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/cjs/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../../src/cli.ts"],"names":[],"mappings":""}

package/dist/cjs/cli.js

@@ -0,0 +1,50 @@
+#!/usr/bin/env bun
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_util_1 = require("node:util");
+const generator_1 = require("./generator");
+const USAGE = 'ignis-artifacts <generate|check> [--root src] [--out src/generated/artifacts.ts] [--ignore a,b] [--export GeneratedArtifacts]';
+const { positionals, values } = (0, node_util_1.parseArgs)({
+    args: process.argv.slice(2),
+    allowPositionals: true,
+    options: {
+        root: { type: 'string', default: 'src' },
+        out: { type: 'string', default: 'src/generated/artifacts.ts' },
+        ignore: { type: 'string' },
+        export: { type: 'string', default: 'GeneratedArtifacts' },
+    },
+});
+const options = {
+    root: values.root,
+    out: values.out,
+    ignore: values.ignore
+        ?.split(',')
+        .map(pattern => pattern.trim())
+        .filter(Boolean),
+    exportName: values.export,
+};
+/** Exit code of the command, so the process exits in exactly one place. */
+const run = () => {
+    switch (positionals[0]) {
+        case 'generate': {
+            const result = (0, generator_1.generateArtifactIndex)(options);
+            console.log(`${result.written ? 'wrote' : 'up to date'} ${options.out} | ${result.artifacts.length} artifact(s)`);
+            return 0;
+        }
+        case 'check': {
+            const result = (0, generator_1.checkArtifactIndex)(options);
+            if (result.isFresh) {
+                console.log(`fresh ${options.out}`);
+                return 0;
+            }
+            console.error(`stale ${options.out} - run: ignis-artifacts generate --root ${options.root} --out ${options.out}`);
+            return 1;
+        }
+        default: {
+            console.error(USAGE);
+            return 2;
+        }
+    }
+};
+process.exit(run());
+//# sourceMappingURL=cli.js.map

package/dist/cjs/cli.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.js","sourceRoot":"","sources":["../../src/cli.ts"],"names":[],"mappings":";;;AACA,yCAAsC;AACtC,2CAAwE;AAExE,MAAM,KAAK,GACT,+HAA+H,CAAC;AAElI,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,GAAG,IAAA,qBAAS,EAAC;IACxC,IAAI,EAAE,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;IAC3B,gBAAgB,EAAE,IAAI;IACtB,OAAO,EAAE;QACP,IAAI,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,KAAK,EAAE;QACxC,GAAG,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,4BAA4B,EAAE;QAC9D,MAAM,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;QAC1B,MAAM,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,oBAAoB,EAAE;KAC1D;CACF,CAAC,CAAC;AAEH,MAAM,OAAO,GAAG;IACd,IAAI,EAAE,MAAM,CAAC,IAAI;IACjB,GAAG,EAAE,MAAM,CAAC,GAAG;IACf,MAAM,EAAE,MAAM,CAAC,MAAM;QACnB,EAAE,KAAK,CAAC,GAAG,CAAC;SACX,GAAG,CAAC,OAAO,CAAC,EAAE,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC;SAC9B,MAAM,CAAC,OAAO,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC,MAAM;CAC1B,CAAC;AAEF,2EAA2E;AAC3E,MAAM,GAAG,GAAG,GAAW,EAAE;IACvB,QAAQ,WAAW,CAAC,CAAC,CAAC,EAAE,CAAC;QACvB,KAAK,UAAU,CAAC,CAAC,CAAC;YAChB,MAAM,MAAM,GAAG,IAAA,iCAAqB,EAAC,OAAO,CAAC,CAAC;YAC9C,OAAO,CAAC,GAAG,CACT,GAAG,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,YAAY,IAAI,OAAO,CAAC,GAAG,MAAM,MAAM,CAAC,SAAS,CAAC,MAAM,cAAc,CACrG,CAAC;YACF,OAAO,CAAC,CAAC;QACX,CAAC;QACD,KAAK,OAAO,CAAC,CAAC,CAAC;YACb,MAAM,MAAM,GAAG,IAAA,8BAAkB,EAAC,OAAO,CAAC,CAAC;YAC3C,IAAI,MAAM,CAAC,OAAO,EAAE,CAAC;gBACnB,OAAO,CAAC,GAAG,CAAC,SAAS,OAAO,CAAC,GAAG,EAAE,CAAC,CAAC;gBACpC,OAAO,CAAC,CAAC;YACX,CAAC;YACD,OAAO,CAAC,KAAK,CACX,SAAS,OAAO,CAAC,GAAG,2CAA2C,OAAO,CAAC,IAAI,UAAU,OAAO,CAAC,GAAG,EAAE,CACnG,CAAC;YACF,OAAO,CAAC,CAAC;QACX,CAAC;QACD,OAAO,CAAC,CAAC,CAAC;YACR,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YACrB,OAAO,CAAC,CAAC;QACX,CAAC;IACH,CAAC;AACH,CAAC,CAAC;AAEF,OAAO,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC"}

package/dist/cjs/generator/common/constants.d.ts

@@ -0,0 +1,39 @@
+import type { TConstValue } from '@venizia/ignis-helpers';
+/** Mirrors the kernel's `ArtifactTypes` values; boot must not depend on kernel (`{boot, kernel} -> core` in the build chain). */
+export declare class ArtifactTypes {
+    static readonly COMPONENT = "component";
+    static readonly CONTROLLER = "controller";
+    static readonly SERVICE = "service";
+    static readonly REPOSITORY = "repository";
+    static readonly DATASOURCE = "datasource";
+    static readonly MODEL = "model";
+    static readonly SCHEME_SET: Set<string>;
+    static isValid(value: string): boolean;
+}
+export type TArtifactType = TConstValue<typeof ArtifactTypes>;
+/** Mirrors the kernel's `ArtifactIndexFields` - the keys of the object the emitter writes and `registerArtifacts` reads. */
+export declare class ArtifactIndexFields {
+    static readonly DATA_SOURCES = "dataSources";
+    static readonly COMPONENTS = "components";
+    static readonly REPOSITORIES = "repositories";
+    static readonly SERVICES = "services";
+    static readonly CONTROLLERS = "controllers";
+    static readonly SCHEME_SET: Set<string>;
+    static isValid(value: string): boolean;
+}
+export type TArtifactIndexField = TConstValue<typeof ArtifactIndexFields>;
+export declare class ArtifactStereotypes {
+    /** Decorator name as imported from `@venizia/ignis` or `@venizia/ignis-kernel` -> artifact type. */
+    static readonly BY_DECORATOR: Readonly<Record<string, TArtifactType>>;
+    static readonly ROOT_DECORATOR = "injectable";
+    static readonly SCHEME_SET: Set<string>;
+    static isValid(value: string): boolean;
+    static readonly SOURCE_MODULES: RegExp;
+    static readonly DEFAULT_IGNORE: string[];
+    /** The kernel's `registerArtifacts` order; `model` is never emitted. */
+    static readonly EMIT_ORDER: ReadonlyArray<{
+        type: TArtifactType;
+        field: TArtifactIndexField;
+    }>;
+}
+//# sourceMappingURL=constants.d.ts.map

package/dist/cjs/generator/common/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../src/generator/common/constants.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAE1D,iIAAiI;AACjI,qBAAa,aAAa;IACxB,MAAM,CAAC,QAAQ,CAAC,SAAS,eAAe;IACxC,MAAM,CAAC,QAAQ,CAAC,UAAU,gBAAgB;IAC1C,MAAM,CAAC,QAAQ,CAAC,OAAO,aAAa;IACpC,MAAM,CAAC,QAAQ,CAAC,UAAU,gBAAgB;IAC1C,MAAM,CAAC,QAAQ,CAAC,UAAU,gBAAgB;IAC1C,MAAM,CAAC,QAAQ,CAAC,KAAK,WAAW;IAEhC,MAAM,CAAC,QAAQ,CAAC,UAAU,cAOvB;IAEH,MAAM,CAAC,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;CAGvC;AAED,MAAM,MAAM,aAAa,GAAG,WAAW,CAAC,OAAO,aAAa,CAAC,CAAC;AAE9D,4HAA4H;AAC5H,qBAAa,mBAAmB;IAC9B,MAAM,CAAC,QAAQ,CAAC,YAAY,iBAAiB;IAC7C,MAAM,CAAC,QAAQ,CAAC,UAAU,gBAAgB;IAC1C,MAAM,CAAC,QAAQ,CAAC,YAAY,kBAAkB;IAC9C,MAAM,CAAC,QAAQ,CAAC,QAAQ,cAAc;IACtC,MAAM,CAAC,QAAQ,CAAC,WAAW,iBAAiB;IAE5C,MAAM,CAAC,QAAQ,CAAC,UAAU,cAMvB;IAEH,MAAM,CAAC,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;CAGvC;AAED,MAAM,MAAM,mBAAmB,GAAG,WAAW,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAE1E,qBAAa,mBAAmB;IAC9B,oGAAoG;IACpG,MAAM,CAAC,QAAQ,CAAC,YAAY,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC,CAOnE;IAEF,MAAM,CAAC,QAAQ,CAAC,cAAc,gBAAgB;IAE9C,MAAM,CAAC,QAAQ,CAAC,UAAU,cAAoE;IAE9F,MAAM,CAAC,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;IAItC,MAAM,CAAC,QAAQ,CAAC,cAAc,SAAiC;IAE/D,MAAM,CAAC,QAAQ,CAAC,cAAc,WAK5B;IAEF,wEAAwE;IACxE,MAAM,CAAC,QAAQ,CAAC,UAAU,EAAE,aAAa,CAAC;QAAE,IAAI,EAAE,aAAa,CAAC;QAAC,KAAK,EAAE,mBAAmB,CAAA;KAAE,CAAC,CAM5F;CACH"}

package/dist/cjs/generator/common/constants.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArtifactStereotypes = exports.ArtifactIndexFields = exports.ArtifactTypes = void 0;
+/** Mirrors the kernel's `ArtifactTypes` values; boot must not depend on kernel (`{boot, kernel} -> core` in the build chain). */
+class ArtifactTypes {
+    static { this.COMPONENT = 'component'; }
+    static { this.CONTROLLER = 'controller'; }
+    static { this.SERVICE = 'service'; }
+    static { this.REPOSITORY = 'repository'; }
+    static { this.DATASOURCE = 'datasource'; }
+    static { this.MODEL = 'model'; }
+    static { this.SCHEME_SET = new Set([
+        this.COMPONENT,
+        this.CONTROLLER,
+        this.SERVICE,
+        this.REPOSITORY,
+        this.DATASOURCE,
+        this.MODEL,
+    ]); }
+    static isValid(value) {
+        return this.SCHEME_SET.has(value);
+    }
+}
+exports.ArtifactTypes = ArtifactTypes;
+/** Mirrors the kernel's `ArtifactIndexFields` - the keys of the object the emitter writes and `registerArtifacts` reads. */
+class ArtifactIndexFields {
+    static { this.DATA_SOURCES = 'dataSources'; }
+    static { this.COMPONENTS = 'components'; }
+    static { this.REPOSITORIES = 'repositories'; }
+    static { this.SERVICES = 'services'; }
+    static { this.CONTROLLERS = 'controllers'; }
+    static { this.SCHEME_SET = new Set([
+        this.DATA_SOURCES,
+        this.COMPONENTS,
+        this.REPOSITORIES,
+        this.SERVICES,
+        this.CONTROLLERS,
+    ]); }
+    static isValid(value) {
+        return this.SCHEME_SET.has(value);
+    }
+}
+exports.ArtifactIndexFields = ArtifactIndexFields;
+class ArtifactStereotypes {
+    /** Decorator name as imported from `@venizia/ignis` or `@venizia/ignis-kernel` -> artifact type. */
+    static { this.BY_DECORATOR = {
+        component: ArtifactTypes.COMPONENT,
+        controller: ArtifactTypes.CONTROLLER,
+        service: ArtifactTypes.SERVICE,
+        repository: ArtifactTypes.REPOSITORY,
+        datasource: ArtifactTypes.DATASOURCE,
+        model: ArtifactTypes.MODEL,
+    }; }
+    static { this.ROOT_DECORATOR = 'injectable'; }
+    static { this.SCHEME_SET = new Set(Object.values(ArtifactStereotypes.BY_DECORATOR)); }
+    static isValid(value) {
+        return this.SCHEME_SET.has(value);
+    }
+    static { this.SOURCE_MODULES = /^@venizia\/ignis(-kernel)?$/; }
+    static { this.DEFAULT_IGNORE = [
+        '**/__tests__/**',
+        '**/*.test.ts',
+        '**/*.spec.ts',
+        '**/generated/**',
+    ]; }
+    /** The kernel's `registerArtifacts` order; `model` is never emitted. */
+    static { this.EMIT_ORDER = [
+        { type: ArtifactTypes.DATASOURCE, field: ArtifactIndexFields.DATA_SOURCES },
+        { type: ArtifactTypes.COMPONENT, field: ArtifactIndexFields.COMPONENTS },
+        { type: ArtifactTypes.REPOSITORY, field: ArtifactIndexFields.REPOSITORIES },
+        { type: ArtifactTypes.SERVICE, field: ArtifactIndexFields.SERVICES },
+        { type: ArtifactTypes.CONTROLLER, field: ArtifactIndexFields.CONTROLLERS },
+    ]; }
+}
+exports.ArtifactStereotypes = ArtifactStereotypes;
+//# sourceMappingURL=constants.js.map

package/dist/cjs/generator/common/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../../../src/generator/common/constants.ts"],"names":[],"mappings":";;;AAEA,iIAAiI;AACjI,MAAa,aAAa;aACR,cAAS,GAAG,WAAW,CAAC;aACxB,eAAU,GAAG,YAAY,CAAC;aAC1B,YAAO,GAAG,SAAS,CAAC;aACpB,eAAU,GAAG,YAAY,CAAC;aAC1B,eAAU,GAAG,YAAY,CAAC;aAC1B,UAAK,GAAG,OAAO,CAAC;aAEhB,eAAU,GAAG,IAAI,GAAG,CAAS;QAC3C,IAAI,CAAC,SAAS;QACd,IAAI,CAAC,UAAU;QACf,IAAI,CAAC,OAAO;QACZ,IAAI,CAAC,UAAU;QACf,IAAI,CAAC,UAAU;QACf,IAAI,CAAC,KAAK;KACX,CAAC,CAAC;IAEH,MAAM,CAAC,OAAO,CAAC,KAAa;QAC1B,OAAO,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;IACpC,CAAC;;AAnBH,sCAoBC;AAID,4HAA4H;AAC5H,MAAa,mBAAmB;aACd,iBAAY,GAAG,aAAa,CAAC;aAC7B,eAAU,GAAG,YAAY,CAAC;aAC1B,iBAAY,GAAG,cAAc,CAAC;aAC9B,aAAQ,GAAG,UAAU,CAAC;aACtB,gBAAW,GAAG,aAAa,CAAC;aAE5B,eAAU,GAAG,IAAI,GAAG,CAAS;QAC3C,IAAI,CAAC,YAAY;QACjB,IAAI,CAAC,UAAU;QACf,IAAI,CAAC,YAAY;QACjB,IAAI,CAAC,QAAQ;QACb,IAAI,CAAC,WAAW;KACjB,CAAC,CAAC;IAEH,MAAM,CAAC,OAAO,CAAC,KAAa;QAC1B,OAAO,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;IACpC,CAAC;;AAjBH,kDAkBC;AAID,MAAa,mBAAmB;IAC9B,oGAAoG;aACpF,iBAAY,GAA4C;QACtE,SAAS,EAAE,aAAa,CAAC,SAAS;QAClC,UAAU,EAAE,aAAa,CAAC,UAAU;QACpC,OAAO,EAAE,aAAa,CAAC,OAAO;QAC9B,UAAU,EAAE,aAAa,CAAC,UAAU;QACpC,UAAU,EAAE,aAAa,CAAC,UAAU;QACpC,KAAK,EAAE,aAAa,CAAC,KAAK;KAC3B,CAAC;aAEc,mBAAc,GAAG,YAAY,CAAC;aAE9B,eAAU,GAAG,IAAI,GAAG,CAAS,MAAM,CAAC,MAAM,CAAC,mBAAmB,CAAC,YAAY,CAAC,CAAC,CAAC;IAE9F,MAAM,CAAC,OAAO,CAAC,KAAa;QAC1B,OAAO,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;IACpC,CAAC;aAEe,mBAAc,GAAG,6BAA6B,CAAC;aAE/C,mBAAc,GAAG;QAC/B,iBAAiB;QACjB,cAAc;QACd,cAAc;QACd,iBAAiB;KAClB,CAAC;IAEF,wEAAwE;aACxD,eAAU,GAAuE;QAC/F,EAAE,IAAI,EAAE,aAAa,CAAC,UAAU,EAAE,KAAK,EAAE,mBAAmB,CAAC,YAAY,EAAE;QAC3E,EAAE,IAAI,EAAE,aAAa,CAAC,SAAS,EAAE,KAAK,EAAE,mBAAmB,CAAC,UAAU,EAAE;QACxE,EAAE,IAAI,EAAE,aAAa,CAAC,UAAU,EAAE,KAAK,EAAE,mBAAmB,CAAC,YAAY,EAAE;QAC3E,EAAE,IAAI,EAAE,aAAa,CAAC,OAAO,EAAE,KAAK,EAAE,mBAAmB,CAAC,QAAQ,EAAE;QACpE,EAAE,IAAI,EAAE,aAAa,CAAC,UAAU,EAAE,KAAK,EAAE,mBAAmB,CAAC,WAAW,EAAE;KAC3E,CAAC;;AAnCJ,kDAoCC"}

package/dist/{esm → cjs/generator}/common/index.d.ts

@@ -1,3 +1,3 @@
-export * from './types';
 export * from './constants';
+export * from './types';
 //# sourceMappingURL=index.d.ts.map

package/dist/cjs/generator/common/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/generator/common/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,SAAS,CAAC"}

package/dist/cjs/{common → generator/common}/index.js

@@ -14,6 +14,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./types"), exports);
 __exportStar(require("./constants"), exports);
+__exportStar(require("./types"), exports);
 //# sourceMappingURL=index.js.map

package/dist/cjs/generator/common/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/generator/common/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,8CAA4B;AAC5B,0CAAwB"}

package/dist/cjs/generator/common/types.d.ts

@@ -0,0 +1,13 @@
+import type { TArtifactType } from './constants';
+export interface IScannedArtifact {
+    className: string;
+    /** Absolute path of the declaring file. */
+    filePath: string;
+    type: TArtifactType;
+}
+export interface IScanOptions {
+    root: string;
+    /** Glob patterns relative to `root`; defaults to `ArtifactStereotypes.DEFAULT_IGNORE`. */
+    ignore?: string[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/cjs/generator/common/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/generator/common/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAEjD,MAAM,WAAW,gBAAgB;IAC/B,SAAS,EAAE,MAAM,CAAC;IAClB,2CAA2C;IAC3C,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,aAAa,CAAC;CACrB;AAED,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,0FAA0F;IAC1F,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;CACnB"}

package/dist/cjs/generator/common/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/cjs/generator/common/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../src/generator/common/types.ts"],"names":[],"mappings":""}

package/dist/cjs/generator/emitter.d.ts

@@ -0,0 +1,16 @@
+import { type IScannedArtifact } from './common';
+/** Renders the generated index: deterministic text, plain static imports, no IGNIS import - the object is type-checked where `registerArtifacts` receives it. */
+export declare class ArtifactIndexEmitter {
+    /** Mirrors `printWidth` in @venizia/dev-configs prettier settings. */
+    static readonly PRINT_WIDTH = 100;
+    static readonly HEADER = "// AUTO-GENERATED by @venizia/ignis-boot - do not edit. Regenerate: ignis-artifacts generate --root src --out src/generated/artifacts.ts";
+    static render(opts: {
+        artifacts: IScannedArtifact[];
+        outFile: string;
+        exportName: string;
+    }): string;
+    /** One line while it fits the repo's prettier width, else one name per line - so `prettier -l` on the generated file stays quiet. */
+    private static renderField;
+    private static importPath;
+}
+//# sourceMappingURL=emitter.d.ts.map

package/dist/cjs/generator/emitter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"emitter.d.ts","sourceRoot":"","sources":["../../../src/generator/emitter.ts"],"names":[],"mappings":"AACA,OAAO,EAAsC,KAAK,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAErF,iKAAiK;AACjK,qBAAa,oBAAoB;IAC/B,sEAAsE;IACtE,MAAM,CAAC,QAAQ,CAAC,WAAW,OAAO;IAElC,MAAM,CAAC,QAAQ,CAAC,MAAM,8IACuH;IAE7I,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE;QAClB,SAAS,EAAE,gBAAgB,EAAE,CAAC;QAC9B,OAAO,EAAE,MAAM,CAAC;QAChB,UAAU,EAAE,MAAM,CAAC;KACpB,GAAG,MAAM;IAgCV,qIAAqI;IACrI,OAAO,CAAC,MAAM,CAAC,WAAW;IAW1B,OAAO,CAAC,MAAM,CAAC,UAAU;CAI1B"}

package/dist/cjs/generator/emitter.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArtifactIndexEmitter = void 0;
+const node_path_1 = require("node:path");
+const common_1 = require("./common");
+/** Renders the generated index: deterministic text, plain static imports, no IGNIS import - the object is type-checked where `registerArtifacts` receives it. */
+class ArtifactIndexEmitter {
+    /** Mirrors `printWidth` in @venizia/dev-configs prettier settings. */
+    static { this.PRINT_WIDTH = 100; }
+    static { this.HEADER = '// AUTO-GENERATED by @venizia/ignis-boot - do not edit. Regenerate: ignis-artifacts generate --root src --out src/generated/artifacts.ts'; }
+    static render(opts) {
+        const { artifacts, outFile, exportName } = opts;
+        const emitted = artifacts.filter(artifact => artifact.type !== common_1.ArtifactTypes.MODEL);
+        const imports = emitted
+            .map(artifact => ({
+            name: artifact.className,
+            path: ArtifactIndexEmitter.importPath({ from: outFile, to: artifact.filePath }),
+        }))
+            .sort((a, b) => a.path.localeCompare(b.path) || a.name.localeCompare(b.name))
+            .map(entry => `import { ${entry.name} } from '${entry.path}';`);
+        const fields = common_1.ArtifactStereotypes.EMIT_ORDER.flatMap(({ type, field }) => {
+            const names = emitted
+                .filter(artifact => artifact.type === type)
+                .map(artifact => artifact.className)
+                .sort((a, b) => a.localeCompare(b));
+            return ArtifactIndexEmitter.renderField({ field, names });
+        });
+        return [
+            ArtifactIndexEmitter.HEADER,
+            ...imports,
+            '',
+            `export const ${exportName} = {`,
+            ...fields,
+            '};',
+            '',
+        ].join('\n');
+    }
+    /** One line while it fits the repo's prettier width, else one name per line - so `prettier -l` on the generated file stays quiet. */
+    static renderField(opts) {
+        const { field, names } = opts;
+        const singleLine = `  ${field}: [${names.join(', ')}],`;
+        if (singleLine.length <= ArtifactIndexEmitter.PRINT_WIDTH) {
+            return [singleLine];
+        }
+        return [`  ${field}: [`, ...names.map(name => `    ${name},`), '  ],'];
+    }
+    static importPath(opts) {
+        const raw = (0, node_path_1.relative)((0, node_path_1.dirname)(opts.from), opts.to).split(node_path_1.sep).join('/').replace(/\.ts$/, '');
+        return raw.startsWith('.') ? raw : `./${raw}`;
+    }
+}
+exports.ArtifactIndexEmitter = ArtifactIndexEmitter;
+//# sourceMappingURL=emitter.js.map