@devcraft-ts/diadem 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,22 @@
+# diadem
+
+## 0.1.0
+
+Initial release.
+
+- SSR-safe, framework-agnostic DI container (`DiademContainer`) with direct,
+  singleton, transient, lazy-singleton, and **async** lifecycles.
+- Decorators: `@singleton` / `@factory` / `@lazy` / `@lazySingleton` with
+  optional environment filtering.
+- **Build-time manifest generator** (`diadem build`) — AST analysis of
+  constructor dependencies, token-first resolution, topological ordering, and a
+  `--strict` mode that fails on cycles, ambiguous tokens, or unresolved
+  required dependencies. No runtime reflection, no `reflect-metadata`.
+- **Compiled emit** (`--emit=compiled`) — generates straight-line `createContainer()`
+  wiring (no runtime interpretation), the same codegen approach as Dagger/Micronaut,
+  plus a **compile-time-checked `createServices()` accessor**: resolving an
+  unregistered token is a `tsc` error, with no custom TypeScript transformer.
+- Container lifecycle: `Disposable` support, `onDispose`, and `dispose()`;
+  child scopes via `createChild()`.
+- Pluggable, silent-by-default logging (`setLogger` / `consoleLogger`).
+- Ships ESM + CJS + type declarations; entry points `@devcraft-ts/diadem` and `@devcraft-ts/diadem/setup`.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jai Sachdeva
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,306 @@
+# diadem
+
+![types: included](https://img.shields.io/badge/types-included-blue)
+![runtime deps: 0](https://img.shields.io/badge/runtime%20deps-0-brightgreen)
+![reflect-metadata: none](https://img.shields.io/badge/reflect--metadata-none-brightgreen)
+![license: MIT](https://img.shields.io/badge/license-MIT-green)
+
+> Build-time, manifest-driven dependency injection for TypeScript — SSR-safe, framework-agnostic, zero runtime reflection.
+
+**diadem** wires your services from a manifest that is generated at build time. A
+generator analyses your decorated classes, extracts each constructor's
+dependencies, topologically sorts them, and emits a manifest module. At runtime
+the container reads that manifest and autowires everything — **no
+`reflect-metadata`, no runtime constructor parsing, no global state**. You create
+and own the container (usually one per application); because the library keeps no
+hidden global container, it is safe in concurrent/SSR environments, and you can
+spin up child scopes for per-request isolation when you need it.
+
+```
+   decorated classes  ──►  build-time generator  ──►  service-manifest.ts
+                                                              │
+                                                              ▼
+                              configureManifest(manifest) ──► DiademContainer
+```
+
+> **Status:** early but complete (`0.1.0`). The runtime container, decorators,
+> dependency resolver, and the **`diadem build` manifest generator** are all in
+> place. You can also hand-write a manifest conforming to `ServiceManifestModule`
+> (see [`examples/basic.ts`](examples/basic.ts)).
+
+## Install
+
+```bash
+npm install @devcraft-ts/diadem
+```
+
+Requires TypeScript with `experimentalDecorators` enabled (legacy decorator
+syntax) and Node ≥ 18. `typescript` is an (optional) peer dependency — needed
+only to run the `diadem build` generator.
+
+```jsonc
+// tsconfig.json
+{
+  "compilerOptions": {
+    "experimentalDecorators": true
+  }
+}
+```
+
+## Generating the manifest
+
+Run the generator after writing or changing decorated services:
+
+```bash
+npx diadem build
+```
+
+It scans your source, finds DI-decorated classes via the TypeScript AST,
+extracts and topologically sorts their constructor dependencies, and writes a
+manifest module (default: `src/generated/service-manifest.ts`). Import paths in
+the output are computed relative to the manifest file, so no path aliases are
+required.
+
+Configure via flags or a `diadem.config.json` in the project root (flags win):
+
+```jsonc
+// diadem.config.json
+{
+  "scanDirs": ["src"],
+  "outFile": "src/generated/service-manifest.ts",
+  "include": ["\\.ts$"],            // optional perf narrowing, e.g. ["Service\\.ts$"]
+  "environments": ["development", "production", "test"]
+}
+```
+
+```bash
+diadem build --scan-dir src --out src/generated/service-manifest.ts --strict
+```
+
+`--strict` exits non-zero on dependency cycles, ambiguous (duplicated) tokens, or
+required dependencies with no implementing service — turning runtime surprises
+into build failures. (`--fail-on-cycle` is the narrower cycles-only variant.)
+Wire it into your build, e.g. `"prebuild": "diadem build --strict"`.
+
+### Compiled mode (zero-overhead wiring)
+
+`--emit=compiled` generates **straight-line wiring code** instead of an
+interpreted data manifest — the same approach Dagger/Micronaut take on the JVM.
+There's no manifest to parse, no resolver loop, and no per-dependency lookup
+during construction; services are just constructed in topological order with
+direct references:
+
+```bash
+diadem build --emit=compiled --target-env production --out src/generated/container.ts
+```
+
+```ts
+// generated container.ts (abridged)
+export function createContainer(): DiademContainer {
+  const c = new DiademContainer()
+  const _ConsoleLogger = new ConsoleLogger()
+  c.register(token(ConsoleLogger), _ConsoleLogger)
+  const _Greeter = new Greeter(_ConsoleLogger) // ← direct reference, no lookup
+  c.register(token(Greeter), _Greeter)
+  c.setReady()
+  return c
+}
+```
+
+```ts
+import { createContainer } from './generated/container'
+const container = createContainer() // fully wired, ready
+const greeter = container.resolve(IGreeter)
+```
+
+This is the fastest path — wiring compiles down to the `new` calls you'd write
+by hand, and bundlers can tree-shake unused services from the output.
+
+**Type-safe access.** Compiled mode also emits a `createServices()` accessor
+whose surface contains *only the registered tokens*, each typed to its token —
+so resolving something that isn't wired is a **compile error**, not a runtime
+throw:
+
+```ts
+import { createServices } from './generated/container'
+
+const services = createServices()
+const greeting: string = services.IGreeter.greet('world') // ✓ correctly typed
+services.INope // ✗ tsc error: Property 'INope' does not exist on type 'DiademServices'
+```
+
+That's the compile-time guarantee of `typed-inject`/`@wessberg/di` — but reached
+through decorators + auto-discovery, with no custom TypeScript transformer.
+(Ambiguous or unlocatable tokens are omitted from the typed surface but still
+wired into `createContainer()`.)
+
+Trade-offs vs. the default manifest emit:
+- One environment is **baked in** per build (`--target-env`, default: all) — no
+  runtime env branching.
+- `lazySingleton` is treated as **eager** (its instance is referenced up front).
+- No runtime mock/override registration — use the manifest emit for dev/test if
+  you rely on that dynamism.
+
+## Concepts
+
+| Concept | What it is |
+| --- | --- |
+| **Token** | An abstract class used as the injection key. |
+| **Decorator** | `@singleton` / `@factory` / `@lazy` / `@lazySingleton` tag an implementation with its token, lifecycle, and optional environment. |
+| **Manifest** | Build-time output describing every service, its dependencies, and a topological registration order. Conforms to `ServiceManifestModule`. |
+| **Container** | `DiademContainer` — reads the manifest and resolves instances. Usually app-scoped; `createChild()` makes an isolated scope when needed. |
+
+### Lifecycles
+
+- `singleton` — one instance per container, created eagerly on registration.
+- `lazySingleton` — one instance per container, created on first resolve.
+- `lazy` / `factory` — a new instance on every resolve.
+
+## Quick start
+
+```ts
+import { DiademContainer, configureManifest, singleton } from '@devcraft-ts/diadem'
+import * as manifest from './generated/service-manifest' // your build output
+
+abstract class ILogger {
+  abstract log(msg: string): void
+}
+
+@singleton(ILogger)
+class ConsoleLogger extends ILogger {
+  log(msg: string) {
+    console.log(msg)
+  }
+}
+
+// Register the generated manifest once at startup.
+configureManifest(manifest)
+
+// Create your application container (once):
+const container = new DiademContainer()
+await container.autoRegisterDiscovered(process.env.NODE_ENV)
+container.setReady()
+
+const logger = container.resolve(ILogger)
+logger.log('wired with diadem')
+```
+
+See [`examples/basic.ts`](examples/basic.ts) for a complete, runnable example
+including a hand-written manifest that documents the generator contract.
+
+## Manual registration
+
+You don't have to use the manifest — the container is a perfectly good explicit
+DI container on its own:
+
+```ts
+const container = new DiademContainer()
+container.registerSingleton(ILogger, () => new ConsoleLogger())
+container.registerFactory(IClock, () => new SystemClock())
+container.register(IConfig, loadedConfig)
+container.setReady()
+```
+
+## Logging
+
+Diadem is **silent by default** — it writes nothing unless you opt in. Register a
+logger to surface its diagnostics:
+
+```ts
+import { setLogger, consoleLogger } from '@devcraft-ts/diadem'
+
+setLogger(consoleLogger) // or your own pino/winston adapter implementing `Logger`
+setLogger(null) // back to silent
+```
+
+## Async services
+
+Some services need awaited construction (open a connection, read a secret).
+Register them as async and resolve with `resolveAsync`:
+
+```ts
+container.registerAsyncSingleton(IDatabase, async () => {
+  const db = new Database()
+  await db.connect()
+  return db
+})
+
+const db = await container.resolveAsync(IDatabase) // awaited once, then cached
+```
+
+`registerAsyncFactory` gives a fresh awaited instance per `resolveAsync`. Calling
+the synchronous `resolve()` on an async-only token throws a clear error.
+
+## Lifecycle & disposal
+
+Singletons and directly-registered values that implement `Disposable`
+(`{ dispose(): void | Promise<void> }`) are torn down automatically when the
+container is disposed. You can also register arbitrary teardown callbacks:
+
+```ts
+container.registerSingleton(IPool, () => new ConnectionPool()) // has dispose()
+container.onDispose(() => clearInterval(timer))
+
+await container.dispose() // runs teardown in reverse order, then clears the container
+```
+
+Child scopes share parent-owned instances by reference and never dispose them —
+only resources a child registers itself are released with it. Transient
+(`factory`) instances are owned by the caller and are not auto-disposed.
+
+## API surface
+
+- `@devcraft-ts/diadem` — `DiademContainer`, decorators (`singleton`/`factory`/`lazy`/
+  `lazySingleton`), the manifest contract (`configureManifest`,
+  `ServiceManifestModule`, `ServiceManifestEntry`, …), `Disposable`,
+  auto-discovery utilities, and logging (`setLogger`, `consoleLogger`, `Logger`).
+- `@devcraft-ts/diadem/setup` — environment-aware container factories,
+  `validateAutoRegistration`, and `logSetupInfo`.
+- `diadem build` — the manifest generator CLI (`bin`).
+
+## How it compares
+
+Most TS/JS DI lives in two camps. **Reflection + decorators** (InversifyJS,
+tsyringe, TypeDI, NestJS) is ergonomic but needs `reflect-metadata` and reads
+constructor types *at runtime*. **Type-safe manual** (typed-inject, brandi,
+ditox) has no decorators and no reflection — the compiler verifies the graph,
+but you wire everything by hand.
+
+`diadem` is a third path: decorator ergonomics **and** auto-discovery, but the
+dependency analysis happens in a **build step** that emits a static manifest —
+so there's **no `reflect-metadata` and nothing reflective on the runtime path**.
+On the JVM this is the Spring → **Dagger / Micronaut / Quarkus** shift (runtime
+reflection → build-time wiring); `diadem` brings that shift to TypeScript.
+
+| | reflect-metadata | decorators | auto-discovery | graph analysis at |
+| --- | --- | --- | --- | --- |
+| Inversify / tsyringe / Nest | required | yes | yes | runtime |
+| typed-inject / brandi / ditox | no | no | no | compile (type-checked) |
+| **diadem** | **no** | yes | yes | **build (`diadem build`)** |
+
+For maximum runtime performance **and** type safety, `diadem build
+--emit=compiled` emits straight-line wiring (no runtime interpretation — the same
+codegen approach as Dagger/Micronaut, the fastest DI path in TS/npm) plus a
+`createServices()` accessor that is **compile-time checked**: resolving an
+unregistered token is a `tsc` error. That matches `typed-inject`/`@wessberg/di`
+on safety, but without their cost — `@wessberg/di` needs a custom TypeScript
+transformer (and `ts-patch`/`ttypescript`, which broke at TS 5.0), whereas
+`diadem` emits plain `.ts` that any toolchain (tsc, esbuild, swc, vite, bun)
+compiles as-is.
+
+Trade-offs to know: build-time graph validation is name-based (`--strict` turns
+unresolved/ambiguous tokens into build errors) rather than fully type-driven; a
+singleton's factory runs at registration, so **registration order matters** (the
+generator emits services in topological order for you; use `lazySingleton` to
+defer construction); and the generated manifest grows with the number of
+services. It uses legacy (`experimentalDecorators`) decorators.
+
+## Roadmap
+
+- Richer dependency-graph diagnostics from the generator (visualization, unused
+  service detection).
+- A `--check` dry-run mode and a benchmark harness.
+
+## License
+
+[MIT](LICENSE) © Jai Sachdeva

package/dist/auto-discovery-5IV22D5D.cjs

@@ -0,0 +1,73 @@
+'use strict';
+
+var chunkFHQRDO5C_cjs = require('./chunk-FHQRDO5C.cjs');
+
+// src/core/auto-discovery.ts
+var discoveryCache = /* @__PURE__ */ new Map();
+function clearDiscoveryCache() {
+  discoveryCache.clear();
+}
+async function discoverServices(config = {}) {
+  const { environment, useCache = true } = config;
+  const cacheKey = environment ?? "all";
+  if (useCache) {
+    const cached = discoveryCache.get(cacheKey);
+    if (cached) {
+      return {
+        services: cached,
+        totalFound: cached.length,
+        totalDecorated: cached.length,
+        fromCache: true,
+        manifestAvailable: true
+      };
+    }
+  }
+  if (!chunkFHQRDO5C_cjs.hasManifest()) {
+    chunkFHQRDO5C_cjs.getLogger().warn(
+      "Diadem: no manifest configured \u2014 service discovery found nothing. Call configureManifest(...) at startup."
+    );
+    return {
+      services: [],
+      totalFound: 0,
+      totalDecorated: 0,
+      fromCache: false,
+      manifestAvailable: false
+    };
+  }
+  const manifest = await chunkFHQRDO5C_cjs.loadManifest();
+  const entries = manifest.getServicesForEnvironment(environment);
+  const imported = await manifest.importAllServices(entries);
+  const services = imported.map((item) => item.serviceClass).filter(
+    (serviceClass) => typeof serviceClass === "function" && chunkFHQRDO5C_cjs.hasDIMetadata(serviceClass)
+  );
+  if (useCache) {
+    discoveryCache.set(cacheKey, services);
+  }
+  chunkFHQRDO5C_cjs.getLogger().debug(
+    `Diadem: discovered ${services.length}/${entries.length} services for "${cacheKey}"`
+  );
+  return {
+    services,
+    totalFound: entries.length,
+    totalDecorated: services.length,
+    fromCache: false,
+    manifestAvailable: true
+  };
+}
+function isManifestAvailable() {
+  return chunkFHQRDO5C_cjs.hasManifest();
+}
+async function getManifestStats() {
+  if (!chunkFHQRDO5C_cjs.hasManifest()) {
+    return null;
+  }
+  const manifest = await chunkFHQRDO5C_cjs.loadManifest();
+  return manifest.MANIFEST_STATS ?? null;
+}
+
+exports.clearDiscoveryCache = clearDiscoveryCache;
+exports.discoverServices = discoverServices;
+exports.getManifestStats = getManifestStats;
+exports.isManifestAvailable = isManifestAvailable;
+//# sourceMappingURL=auto-discovery-5IV22D5D.cjs.map
+//# sourceMappingURL=auto-discovery-5IV22D5D.cjs.map

package/dist/auto-discovery-5IV22D5D.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/auto-discovery.ts"],"names":["hasManifest","getLogger","loadManifest","hasDIMetadata"],"mappings":";;;;;AAiCA,IAAM,cAAA,uBAAqB,GAAA,EAAmC;AAGvD,SAAS,mBAAA,GAA4B;AAC1C,EAAA,cAAA,CAAe,KAAA,EAAM;AACvB;AAKA,eAAsB,gBAAA,CACpB,MAAA,GAA8B,EAAC,EACE;AACjC,EAAA,MAAM,EAAE,WAAA,EAAa,QAAA,GAAW,IAAA,EAAK,GAAI,MAAA;AACzC,EAAA,MAAM,WAAW,WAAA,IAAe,KAAA;AAEhC,EAAA,IAAI,QAAA,EAAU;AACZ,IAAA,MAAM,MAAA,GAAS,cAAA,CAAe,GAAA,CAAI,QAAQ,CAAA;AAC1C,IAAA,IAAI,MAAA,EAAQ;AACV,MAAA,OAAO;AAAA,QACL,QAAA,EAAU,MAAA;AAAA,QACV,YAAY,MAAA,CAAO,MAAA;AAAA,QACnB,gBAAgB,MAAA,CAAO,MAAA;AAAA,QACvB,SAAA,EAAW,IAAA;AAAA,QACX,iBAAA,EAAmB;AAAA,OACrB;AAAA,IACF;AAAA,EACF;AAEA,EAAA,IAAI,CAACA,+BAAY,EAAG;AAClB,IAAAC,2BAAA,EAAU,CAAE,IAAA;AAAA,MACV;AAAA,KAEF;AACA,IAAA,OAAO;AAAA,MACL,UAAU,EAAC;AAAA,MACX,UAAA,EAAY,CAAA;AAAA,MACZ,cAAA,EAAgB,CAAA;AAAA,MAChB,SAAA,EAAW,KAAA;AAAA,MACX,iBAAA,EAAmB;AAAA,KACrB;AAAA,EACF;AAEA,EAAA,MAAM,QAAA,GAAW,MAAMC,8BAAA,EAAa;AACpC,EAAA,MAAM,OAAA,GAAU,QAAA,CAAS,yBAAA,CAA0B,WAAW,CAAA;AAC9D,EAAA,MAAM,QAAA,GAAW,MAAM,QAAA,CAAS,iBAAA,CAAkB,OAAO,CAAA;AAEzD,EAAA,MAAM,WAAW,QAAA,CACd,GAAA,CAAI,CAAC,IAAA,KAAS,IAAA,CAAK,YAAY,CAAA,CAC/B,MAAA;AAAA,IACC,CAAC,YAAA,KACC,OAAO,YAAA,KAAiB,UAAA,IACxBC,gCAAc,YAAmC;AAAA,GACrD;AAEF,EAAA,IAAI,QAAA,EAAU;AACZ,IAAA,cAAA,CAAe,GAAA,CAAI,UAAU,QAAQ,CAAA;AAAA,EACvC;AAEA,EAAAF,2BAAA,EAAU,CAAE,KAAA;AAAA,IACV,sBAAsB,QAAA,CAAS,MAAM,IAAI,OAAA,CAAQ,MAAM,kBAAkB,QAAQ,CAAA,CAAA;AAAA,GACnF;AAEA,EAAA,OAAO;AAAA,IACL,QAAA;AAAA,IACA,YAAY,OAAA,CAAQ,MAAA;AAAA,IACpB,gBAAgB,QAAA,CAAS,MAAA;AAAA,IACzB,SAAA,EAAW,KAAA;AAAA,IACX,iBAAA,EAAmB;AAAA,GACrB;AACF;AAGO,SAAS,mBAAA,GAA+B;AAC7C,EAAA,OAAOD,6BAAA,EAAY;AACrB;AAGA,eAAsB,gBAAA,GAAqC;AACzD,EAAA,IAAI,CAACA,+BAAY,EAAG;AAClB,IAAA,OAAO,IAAA;AAAA,EACT;AACA,EAAA,MAAM,QAAA,GAAW,MAAME,8BAAA,EAAa;AACpC,EAAA,OAAO,SAAS,cAAA,IAAkB,IAAA;AACpC","file":"auto-discovery-5IV22D5D.cjs","sourcesContent":["/**\n * Automatic service discovery from a configured build-time manifest.\n *\n * Discovery is cheap: the manifest is an in-memory module registered via\n * `configureManifest`, so this just reads its entries for the requested\n * environment, resolves the corresponding classes, and keeps those carrying DI\n * metadata. Results are cached per environment.\n */\n\nimport { hasDIMetadata } from './decorators'\nimport { getLogger } from './logger'\nimport { hasManifest, loadManifest } from './manifest'\nimport type { ConcreteConstructor } from './types'\n\n/** Configuration for auto-discovery. */\nexport interface AutoDiscoveryConfig {\n  /** Environment filter; omit (or 'all') to discover every service. */\n  environment?: string\n  /** Whether to use the per-environment discovery cache. Defaults to true. */\n  useCache?: boolean\n}\n\n/** Result of a discovery pass. */\nexport interface ServiceDiscoveryResult {\n  services: ConcreteConstructor[]\n  /** Number of manifest entries considered for the environment. */\n  totalFound: number\n  /** Number of discovered services carrying DI metadata. */\n  totalDecorated: number\n  fromCache: boolean\n  manifestAvailable: boolean\n}\n\nconst discoveryCache = new Map<string, ConcreteConstructor[]>()\n\n/** Clear the per-environment discovery cache. */\nexport function clearDiscoveryCache(): void {\n  discoveryCache.clear()\n}\n\n/**\n * Discover all DI-decorated services from the configured manifest.\n */\nexport async function discoverServices(\n  config: AutoDiscoveryConfig = {}\n): Promise<ServiceDiscoveryResult> {\n  const { environment, useCache = true } = config\n  const cacheKey = environment ?? 'all'\n\n  if (useCache) {\n    const cached = discoveryCache.get(cacheKey)\n    if (cached) {\n      return {\n        services: cached,\n        totalFound: cached.length,\n        totalDecorated: cached.length,\n        fromCache: true,\n        manifestAvailable: true\n      }\n    }\n  }\n\n  if (!hasManifest()) {\n    getLogger().warn(\n      'Diadem: no manifest configured — service discovery found nothing. ' +\n        'Call configureManifest(...) at startup.'\n    )\n    return {\n      services: [],\n      totalFound: 0,\n      totalDecorated: 0,\n      fromCache: false,\n      manifestAvailable: false\n    }\n  }\n\n  const manifest = await loadManifest()\n  const entries = manifest.getServicesForEnvironment(environment)\n  const imported = await manifest.importAllServices(entries)\n\n  const services = imported\n    .map((item) => item.serviceClass)\n    .filter(\n      (serviceClass): serviceClass is ConcreteConstructor =>\n        typeof serviceClass === 'function' &&\n        hasDIMetadata(serviceClass as ConcreteConstructor)\n    )\n\n  if (useCache) {\n    discoveryCache.set(cacheKey, services)\n  }\n\n  getLogger().debug(\n    `Diadem: discovered ${services.length}/${entries.length} services for \"${cacheKey}\"`\n  )\n\n  return {\n    services,\n    totalFound: entries.length,\n    totalDecorated: services.length,\n    fromCache: false,\n    manifestAvailable: true\n  }\n}\n\n/** Whether a manifest has been configured. */\nexport function isManifestAvailable(): boolean {\n  return hasManifest()\n}\n\n/** The configured manifest's `MANIFEST_STATS`, or null if unavailable. */\nexport async function getManifestStats(): Promise<unknown> {\n  if (!hasManifest()) {\n    return null\n  }\n  const manifest = await loadManifest()\n  return manifest.MANIFEST_STATS ?? null\n}\n"]}

package/dist/auto-discovery-RPCKK3PB.js

@@ -0,0 +1,68 @@
+import { hasManifest, getLogger, loadManifest, hasDIMetadata } from './chunk-W7NA3ZZF.js';
+
+// src/core/auto-discovery.ts
+var discoveryCache = /* @__PURE__ */ new Map();
+function clearDiscoveryCache() {
+  discoveryCache.clear();
+}
+async function discoverServices(config = {}) {
+  const { environment, useCache = true } = config;
+  const cacheKey = environment ?? "all";
+  if (useCache) {
+    const cached = discoveryCache.get(cacheKey);
+    if (cached) {
+      return {
+        services: cached,
+        totalFound: cached.length,
+        totalDecorated: cached.length,
+        fromCache: true,
+        manifestAvailable: true
+      };
+    }
+  }
+  if (!hasManifest()) {
+    getLogger().warn(
+      "Diadem: no manifest configured \u2014 service discovery found nothing. Call configureManifest(...) at startup."
+    );
+    return {
+      services: [],
+      totalFound: 0,
+      totalDecorated: 0,
+      fromCache: false,
+      manifestAvailable: false
+    };
+  }
+  const manifest = await loadManifest();
+  const entries = manifest.getServicesForEnvironment(environment);
+  const imported = await manifest.importAllServices(entries);
+  const services = imported.map((item) => item.serviceClass).filter(
+    (serviceClass) => typeof serviceClass === "function" && hasDIMetadata(serviceClass)
+  );
+  if (useCache) {
+    discoveryCache.set(cacheKey, services);
+  }
+  getLogger().debug(
+    `Diadem: discovered ${services.length}/${entries.length} services for "${cacheKey}"`
+  );
+  return {
+    services,
+    totalFound: entries.length,
+    totalDecorated: services.length,
+    fromCache: false,
+    manifestAvailable: true
+  };
+}
+function isManifestAvailable() {
+  return hasManifest();
+}
+async function getManifestStats() {
+  if (!hasManifest()) {
+    return null;
+  }
+  const manifest = await loadManifest();
+  return manifest.MANIFEST_STATS ?? null;
+}
+
+export { clearDiscoveryCache, discoverServices, getManifestStats, isManifestAvailable };
+//# sourceMappingURL=auto-discovery-RPCKK3PB.js.map
+//# sourceMappingURL=auto-discovery-RPCKK3PB.js.map

package/dist/auto-discovery-RPCKK3PB.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/auto-discovery.ts"],"names":[],"mappings":";;;AAiCA,IAAM,cAAA,uBAAqB,GAAA,EAAmC;AAGvD,SAAS,mBAAA,GAA4B;AAC1C,EAAA,cAAA,CAAe,KAAA,EAAM;AACvB;AAKA,eAAsB,gBAAA,CACpB,MAAA,GAA8B,EAAC,EACE;AACjC,EAAA,MAAM,EAAE,WAAA,EAAa,QAAA,GAAW,IAAA,EAAK,GAAI,MAAA;AACzC,EAAA,MAAM,WAAW,WAAA,IAAe,KAAA;AAEhC,EAAA,IAAI,QAAA,EAAU;AACZ,IAAA,MAAM,MAAA,GAAS,cAAA,CAAe,GAAA,CAAI,QAAQ,CAAA;AAC1C,IAAA,IAAI,MAAA,EAAQ;AACV,MAAA,OAAO;AAAA,QACL,QAAA,EAAU,MAAA;AAAA,QACV,YAAY,MAAA,CAAO,MAAA;AAAA,QACnB,gBAAgB,MAAA,CAAO,MAAA;AAAA,QACvB,SAAA,EAAW,IAAA;AAAA,QACX,iBAAA,EAAmB;AAAA,OACrB;AAAA,IACF;AAAA,EACF;AAEA,EAAA,IAAI,CAAC,aAAY,EAAG;AAClB,IAAA,SAAA,EAAU,CAAE,IAAA;AAAA,MACV;AAAA,KAEF;AACA,IAAA,OAAO;AAAA,MACL,UAAU,EAAC;AAAA,MACX,UAAA,EAAY,CAAA;AAAA,MACZ,cAAA,EAAgB,CAAA;AAAA,MAChB,SAAA,EAAW,KAAA;AAAA,MACX,iBAAA,EAAmB;AAAA,KACrB;AAAA,EACF;AAEA,EAAA,MAAM,QAAA,GAAW,MAAM,YAAA,EAAa;AACpC,EAAA,MAAM,OAAA,GAAU,QAAA,CAAS,yBAAA,CAA0B,WAAW,CAAA;AAC9D,EAAA,MAAM,QAAA,GAAW,MAAM,QAAA,CAAS,iBAAA,CAAkB,OAAO,CAAA;AAEzD,EAAA,MAAM,WAAW,QAAA,CACd,GAAA,CAAI,CAAC,IAAA,KAAS,IAAA,CAAK,YAAY,CAAA,CAC/B,MAAA;AAAA,IACC,CAAC,YAAA,KACC,OAAO,YAAA,KAAiB,UAAA,IACxB,cAAc,YAAmC;AAAA,GACrD;AAEF,EAAA,IAAI,QAAA,EAAU;AACZ,IAAA,cAAA,CAAe,GAAA,CAAI,UAAU,QAAQ,CAAA;AAAA,EACvC;AAEA,EAAA,SAAA,EAAU,CAAE,KAAA;AAAA,IACV,sBAAsB,QAAA,CAAS,MAAM,IAAI,OAAA,CAAQ,MAAM,kBAAkB,QAAQ,CAAA,CAAA;AAAA,GACnF;AAEA,EAAA,OAAO;AAAA,IACL,QAAA;AAAA,IACA,YAAY,OAAA,CAAQ,MAAA;AAAA,IACpB,gBAAgB,QAAA,CAAS,MAAA;AAAA,IACzB,SAAA,EAAW,KAAA;AAAA,IACX,iBAAA,EAAmB;AAAA,GACrB;AACF;AAGO,SAAS,mBAAA,GAA+B;AAC7C,EAAA,OAAO,WAAA,EAAY;AACrB;AAGA,eAAsB,gBAAA,GAAqC;AACzD,EAAA,IAAI,CAAC,aAAY,EAAG;AAClB,IAAA,OAAO,IAAA;AAAA,EACT;AACA,EAAA,MAAM,QAAA,GAAW,MAAM,YAAA,EAAa;AACpC,EAAA,OAAO,SAAS,cAAA,IAAkB,IAAA;AACpC","file":"auto-discovery-RPCKK3PB.js","sourcesContent":["/**\n * Automatic service discovery from a configured build-time manifest.\n *\n * Discovery is cheap: the manifest is an in-memory module registered via\n * `configureManifest`, so this just reads its entries for the requested\n * environment, resolves the corresponding classes, and keeps those carrying DI\n * metadata. Results are cached per environment.\n */\n\nimport { hasDIMetadata } from './decorators'\nimport { getLogger } from './logger'\nimport { hasManifest, loadManifest } from './manifest'\nimport type { ConcreteConstructor } from './types'\n\n/** Configuration for auto-discovery. */\nexport interface AutoDiscoveryConfig {\n  /** Environment filter; omit (or 'all') to discover every service. */\n  environment?: string\n  /** Whether to use the per-environment discovery cache. Defaults to true. */\n  useCache?: boolean\n}\n\n/** Result of a discovery pass. */\nexport interface ServiceDiscoveryResult {\n  services: ConcreteConstructor[]\n  /** Number of manifest entries considered for the environment. */\n  totalFound: number\n  /** Number of discovered services carrying DI metadata. */\n  totalDecorated: number\n  fromCache: boolean\n  manifestAvailable: boolean\n}\n\nconst discoveryCache = new Map<string, ConcreteConstructor[]>()\n\n/** Clear the per-environment discovery cache. */\nexport function clearDiscoveryCache(): void {\n  discoveryCache.clear()\n}\n\n/**\n * Discover all DI-decorated services from the configured manifest.\n */\nexport async function discoverServices(\n  config: AutoDiscoveryConfig = {}\n): Promise<ServiceDiscoveryResult> {\n  const { environment, useCache = true } = config\n  const cacheKey = environment ?? 'all'\n\n  if (useCache) {\n    const cached = discoveryCache.get(cacheKey)\n    if (cached) {\n      return {\n        services: cached,\n        totalFound: cached.length,\n        totalDecorated: cached.length,\n        fromCache: true,\n        manifestAvailable: true\n      }\n    }\n  }\n\n  if (!hasManifest()) {\n    getLogger().warn(\n      'Diadem: no manifest configured — service discovery found nothing. ' +\n        'Call configureManifest(...) at startup.'\n    )\n    return {\n      services: [],\n      totalFound: 0,\n      totalDecorated: 0,\n      fromCache: false,\n      manifestAvailable: false\n    }\n  }\n\n  const manifest = await loadManifest()\n  const entries = manifest.getServicesForEnvironment(environment)\n  const imported = await manifest.importAllServices(entries)\n\n  const services = imported\n    .map((item) => item.serviceClass)\n    .filter(\n      (serviceClass): serviceClass is ConcreteConstructor =>\n        typeof serviceClass === 'function' &&\n        hasDIMetadata(serviceClass as ConcreteConstructor)\n    )\n\n  if (useCache) {\n    discoveryCache.set(cacheKey, services)\n  }\n\n  getLogger().debug(\n    `Diadem: discovered ${services.length}/${entries.length} services for \"${cacheKey}\"`\n  )\n\n  return {\n    services,\n    totalFound: entries.length,\n    totalDecorated: services.length,\n    fromCache: false,\n    manifestAvailable: true\n  }\n}\n\n/** Whether a manifest has been configured. */\nexport function isManifestAvailable(): boolean {\n  return hasManifest()\n}\n\n/** The configured manifest's `MANIFEST_STATS`, or null if unavailable. */\nexport async function getManifestStats(): Promise<unknown> {\n  if (!hasManifest()) {\n    return null\n  }\n  const manifest = await loadManifest()\n  return manifest.MANIFEST_STATS ?? null\n}\n"]}