@devcraft-ts/diadem 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,304 @@
+import { A as AbstractConstructor, C as ConcreteConstructor, a as Constructor, D as DiademContainer, b as DIContainer } from './container-C1FFn9_4.js';
+export { c as Disposable, L as LifecycleType, T as Token } from './container-C1FFn9_4.js';
+
+/**
+ * Decorator-driven DI registration using class metadata instead of global state.
+ * This approach is SSR-safe and avoids global state issues.
+ */
+
+type LifecycleType = 'singleton' | 'factory' | 'lazy' | 'lazySingleton';
+interface DIMetadata {
+    token: AbstractConstructor;
+    lifecycle: LifecycleType;
+    environment?: string;
+}
+/**
+ * Get DI metadata from a class constructor
+ */
+declare function getDIMetadata(target: ConcreteConstructor): DIMetadata | null;
+/**
+ * Check if a class has DI metadata
+ */
+declare function hasDIMetadata(target: ConcreteConstructor): boolean;
+/**
+ * Decorator to register a class as a singleton.
+ * The class will be instantiated once per container and reused.
+ *
+ * @param token The interface/abstract class token to register the implementation against
+ * @param env Optional environment filter. If provided, the class will only be registered in that environment.
+ *
+ * @example
+ * ```typescript
+ * @singleton(IMyService)
+ * class MyService implements IMyService {
+ *   // implementation
+ * }
+ *
+ * @singleton(IService, 'production')
+ * class ProductionOnlyService implements IService {
+ *   // only registered in production environment
+ * }
+ * ```
+ */
+declare function singleton<T>(token: AbstractConstructor<T>, env?: string): <U extends ConcreteConstructor<T>>(target: U) => U;
+/**
+ * Decorator to register a class as a factory.
+ * A new instance will be created each time the dependency is resolved.
+ *
+ * @param token The interface/abstract class token to register the implementation against
+ * @param env Optional environment filter. If provided, the class will only be registered in that environment.
+ *
+ * @example
+ * ```typescript
+ * @factory(ITransientService)
+ * class TransientService implements ITransientService {
+ *   // new instance created on each resolve
+ * }
+ * ```
+ */
+declare function factory<T>(token: AbstractConstructor<T>, env?: string): <U extends ConcreteConstructor<T>>(target: U) => U;
+/**
+ * Decorator to register a class as lazy.
+ * The class will be instantiated only when first resolved, then a new instance on each subsequent resolve.
+ *
+ * @param token The interface/abstract class token to register the implementation against
+ * @param env Optional environment filter. If provided, the class will only be registered in that environment.
+ *
+ * @example
+ * ```typescript
+ * @lazy(IExpensiveService)
+ * class ExpensiveService implements IExpensiveService {
+ *   // only instantiated when first needed
+ * }
+ * ```
+ */
+declare function lazy<T>(token: AbstractConstructor<T>, env?: string): <U extends ConcreteConstructor<T>>(target: U) => U;
+/**
+ * Decorator to register a class as a lazy singleton.
+ * The class will be instantiated only when first resolved, then reused.
+ *
+ * @param token The interface/abstract class token to register the implementation against
+ * @param env Optional environment filter. If provided, the class will only be registered in that environment.
+ *
+ * @example
+ * ```typescript
+ * @lazySingleton(IDatabaseConnection)
+ * class DatabaseConnection implements IDatabaseConnection {
+ *   // instantiated only when first needed, then reused
+ * }
+ * ```
+ */
+declare function lazySingleton<T>(token: AbstractConstructor<T>, env?: string): <U extends ConcreteConstructor<T>>(target: U) => U;
+/**
+ * Auto-discovery helper that scans for decorated classes in the current context.
+ * This can be used to automatically find all decorated classes without manual imports.
+ *
+ * @param modules Array of module objects to scan
+ * @returns Combined array of all decorated classes found
+ // Auto-discovery from modules removed - use manifest-based auto-discovery instead
+
+/**
+ * Get registration statistics for debugging
+ */
+declare function getDIRegistrationStats(classes: ConcreteConstructor[]): {
+    total: number;
+    singletons: number;
+    factories: number;
+    lazy: number;
+    lazySingletons: number;
+    environments: string[];
+};
+/**
+ * Check if a class is registered for a specific environment.
+ */
+declare function isClassRegisteredForEnvironment(ClassConstructor: ConcreteConstructor, environment?: string): boolean;
+
+/**
+ * Pluggable logging for Diadem.
+ *
+ * A library must not write to stdout/stderr unless asked to. By default Diadem
+ * uses a no-op logger and stays completely silent. Opt into diagnostics by
+ * registering a logger (e.g. the built-in {@link consoleLogger}, or your own
+ * pino/winston adapter):
+ *
+ * ```ts
+ * import { setLogger, consoleLogger } from '@devcraft-ts/diadem'
+ * setLogger(consoleLogger)
+ * ```
+ */
+interface Logger {
+    debug(...args: unknown[]): void;
+    info(...args: unknown[]): void;
+    warn(...args: unknown[]): void;
+    error(...args: unknown[]): void;
+}
+/** A logger that discards everything. The default. */
+declare const noopLogger: Logger;
+/** A logger that writes to the global `console`. Opt-in. */
+declare const consoleLogger: Logger;
+/**
+ * Set the active logger. Pass `null` to reset to the silent no-op logger.
+ */
+declare function setLogger(logger: Logger | null): void;
+/** Get the active logger. Internal call sites log through this. */
+declare function getLogger(): Logger;
+
+/**
+ * Service manifest contract + injection seam.
+ *
+ * Diadem is a *build-time* DI container: a generator scans the consumer's
+ * source, extracts each service's constructor dependencies, topologically
+ * sorts them, and emits a manifest module. That generated module is NOT part
+ * of this package — it lives in the consumer's project. This file defines the
+ * shape such a module must conform to, and the seam through which it is plugged
+ * in at runtime.
+ *
+ * Usage in a consuming app:
+ * ```ts
+ * import { configureManifest } from '@devcraft-ts/diadem'
+ * import * as manifest from './generated/service-manifest'
+ *
+ * configureManifest(manifest)
+ * ```
+ *
+ * See `examples/basic.ts` for a complete, runnable example.
+ */
+
+/** A single constructor parameter of a service, as analysed at build time. */
+interface ServiceDependency {
+    paramName: string;
+    paramIndex: number;
+    typeName: string;
+    isOptional: boolean;
+    isReadonly?: boolean;
+    isPrivate?: boolean;
+    /** Class name of the service that implements this dependency, if internal. */
+    implementingService?: string;
+    /** True when the dependency is not managed by the container. */
+    external?: boolean;
+}
+/** One service entry in the build-time manifest. */
+interface ServiceManifestEntry {
+    className: string;
+    importPath: string;
+    lifecycle: 'dependency' | 'singleton' | 'factory' | 'lazy' | 'lazySingleton';
+    environment?: string;
+    exported: boolean;
+    filePath: string;
+    registrationOrder: number;
+    dependencies: ServiceDependency[];
+    resolvedDependencies: ServiceDependency[];
+}
+/** A loaded service class, paired with the manifest entry it came from. */
+interface ImportedService {
+    entry: ServiceManifestEntry;
+    serviceClass: AbstractConstructor;
+}
+/**
+ * The shape of a generated manifest module. A consumer's build step emits a
+ * module exporting these members; pass that module to {@link configureManifest}.
+ */
+interface ServiceManifestModule {
+    SERVICE_MANIFEST: ServiceManifestEntry[];
+    SERVICE_CLASSES: Record<string, AbstractConstructor>;
+    SERVICES_BY_ENVIRONMENT?: Record<string, ServiceManifestEntry[]>;
+    MANIFEST_STATS?: unknown;
+    getServicesForEnvironment: (environment?: string) => ServiceManifestEntry[];
+    importService: (entry: ServiceManifestEntry) => Promise<AbstractConstructor>;
+    importAllServices: (entries: ServiceManifestEntry[]) => Promise<ImportedService[]>;
+}
+/**
+ * Register the generated manifest module so the container can discover and
+ * autowire services. Call once at application startup, before constructing a
+ * container that relies on auto-discovery.
+ */
+declare function configureManifest(manifest: ServiceManifestModule): void;
+/** Returns the configured manifest, or null if none has been registered. */
+declare function getManifest(): ServiceManifestModule | null;
+/** True when a manifest has been registered via {@link configureManifest}. */
+declare function hasManifest(): boolean;
+/** Clear the registered manifest. Primarily useful in tests. */
+declare function resetManifest(): void;
+
+/**
+ * Core DI System - Core Module Exports
+ *
+ * This module exports the fundamental building blocks of the dependency injection system:
+ * - Container implementation
+ * - Decorators for service registration
+ * - Type definitions
+ *
+ * @example
+ * ```typescript
+ * import { DiademContainer, singleton, factory } from 'app/infrastructure/di/core'
+ * ```
+ */
+
+/**
+ * Common decorator combinations for convenience
+ */
+declare const decorators: {
+    readonly singleton: typeof singleton;
+    readonly factory: typeof factory;
+    readonly lazy: typeof lazy;
+    readonly lazySingleton: typeof lazySingleton;
+};
+/**
+ * Type helpers for better developer experience
+ */
+type ResolvedType<T> = T extends Constructor<infer U> ? U : never;
+type ResolvedTypes<T extends ReadonlyArray<Constructor<unknown>>> = {
+    [K in keyof T]: T[K] extends Constructor<infer U> ? U : never;
+};
+type ServiceFactory<T> = () => T;
+interface EnvironmentConfig {
+    environment?: string;
+    modules: Array<Record<string, unknown>>;
+}
+/**
+ * Utility functions for advanced usage
+ */
+/** Fluent builder returned by {@link createContainerBuilder}. */
+interface ContainerBuilder {
+    register: <T>(token: Constructor<T>, implementation: T) => ContainerBuilder;
+    registerSingleton: <T>(token: Constructor<T>, factory: ServiceFactory<T>) => ContainerBuilder;
+    registerFactory: <T>(token: Constructor<T>, factory: ServiceFactory<T>) => ContainerBuilder;
+    build: () => DiademContainer;
+}
+declare function createContainerBuilder(): ContainerBuilder;
+declare function createMockContainer(mocks?: Map<Constructor<unknown>, unknown>): DiademContainer;
+/**
+ * Type guards for runtime type checking
+ */
+declare function isDIContainer(obj: unknown): obj is DIContainer;
+declare function isDiademContainer(obj: unknown): obj is DiademContainer;
+
+/**
+ * Diadem — main entry point.
+ *
+ * A build-time, manifest-driven DI container. SSR-safe and framework-agnostic:
+ * registration metadata lives on classes, never in global state.
+ *
+ * ```typescript
+ * import {
+ *   DiademContainer,
+ *   configureManifest,
+ *   singleton,
+ *   factory
+ * } from '@devcraft-ts/diadem'
+ * import * as manifest from './generated/service-manifest'
+ *
+ * configureManifest(manifest)
+ * const container = new DiademContainer()
+ * await container.autoRegisterDiscovered(process.env.NODE_ENV)
+ * const service = container.resolve(IMyService)
+ * ```
+ */
+
+/**
+ * Version and metadata
+ */
+declare const DI_VERSION = "0.1.0";
+declare const DI_FEATURES: readonly ["type-safe", "ssr-safe", "decorator-driven", "auto-registration", "environment-aware", "server-safe", "no-global-state", "metadata-based", "zero-dependencies"];
+
+export { AbstractConstructor, Constructor, type ContainerBuilder, DIContainer, type DIMetadata, DI_FEATURES, DI_VERSION, type LifecycleType as DecoratorLifecycleType, DiademContainer, type EnvironmentConfig, type ImportedService, type Logger, type ResolvedType, type ResolvedTypes, type ServiceDependency, type ServiceFactory, type ServiceManifestEntry, type ServiceManifestModule, configureManifest, consoleLogger, createContainerBuilder, createMockContainer, decorators, factory, getDIMetadata, getDIRegistrationStats, getLogger, getManifest, hasDIMetadata, hasManifest, isClassRegisteredForEnvironment, isDIContainer, isDiademContainer, lazy, lazySingleton, noopLogger, resetManifest, setLogger, singleton };

package/dist/index.js

@@ -0,0 +1,71 @@
+import { DiademContainer } from './chunk-RTX6B4YY.js';
+export { DiademContainer } from './chunk-RTX6B4YY.js';
+import { lazySingleton, lazy, factory, singleton } from './chunk-W7NA3ZZF.js';
+export { configureManifest, consoleLogger, factory, getDIMetadata, getDIRegistrationStats, getLogger, getManifest, hasDIMetadata, hasManifest, isClassRegisteredForEnvironment, lazy, lazySingleton, noopLogger, resetManifest, setLogger, singleton } from './chunk-W7NA3ZZF.js';
+
+// src/core/index.ts
+var decorators = {
+  singleton,
+  factory,
+  lazy,
+  lazySingleton
+};
+function createContainerBuilder() {
+  const container = new DiademContainer();
+  const builder = {
+    register: (token, implementation) => {
+      container.register(token, implementation);
+      return builder;
+    },
+    registerSingleton: (token, factory2) => {
+      container.registerSingleton(token, factory2);
+      return builder;
+    },
+    registerFactory: (token, factory2) => {
+      container.registerFactory(token, factory2);
+      return builder;
+    },
+    build: () => container
+  };
+  return builder;
+}
+function createMockContainer(mocks = /* @__PURE__ */ new Map()) {
+  const container = new DiademContainer();
+  mocks.forEach((implementation, token) => {
+    container.register(token, implementation);
+  });
+  container.setReady();
+  return container;
+}
+function isDIContainer(obj) {
+  if (typeof obj !== "object" || obj === null) {
+    return false;
+  }
+  const c = obj;
+  return typeof c.register === "function" && typeof c.resolve === "function" && typeof c.isReady === "function";
+}
+function isDiademContainer(obj) {
+  if (!isDIContainer(obj)) {
+    return false;
+  }
+  const c = obj;
+  return typeof c.autoRegisterDiscovered === "function" && typeof c.getDiagnostics === "function";
+}
+
+// src/index.ts
+var DI_VERSION = "0.1.0";
+var DI_FEATURES = [
+  "type-safe",
+  "ssr-safe",
+  "decorator-driven",
+  "auto-registration",
+  "environment-aware",
+  "server-safe",
+  "no-global-state",
+  "metadata-based",
+  "zero-dependencies"
+];
+
+export { DI_FEATURES, DI_VERSION, createContainerBuilder, createMockContainer, decorators, isDIContainer, isDiademContainer };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/index.ts","../src/index.ts"],"names":["factory"],"mappings":";;;;;;AAmEO,IAAM,UAAA,GAAa;AAAA,EACxB,SAAA;AAAA,EACA,OAAA;AAAA,EACA,IAAA;AAAA,EACA;AACF;AA0CO,SAAS,sBAAA,GAA2C;AACzD,EAAA,MAAM,SAAA,GAAY,IAAI,eAAA,EAAgB;AAEtC,EAAA,MAAM,OAAA,GAA4B;AAAA,IAChC,QAAA,EAAU,CAAI,KAAA,EAAuB,cAAA,KAAsB;AACzD,MAAA,SAAA,CAAU,QAAA,CAAS,OAAO,cAAc,CAAA;AACxC,MAAA,OAAO,OAAA;AAAA,IACT,CAAA;AAAA,IACA,iBAAA,EAAmB,CACjB,KAAA,EACAA,QAAAA,KACG;AACH,MAAA,SAAA,CAAU,iBAAA,CAAkB,OAAOA,QAAO,CAAA;AAC1C,MAAA,OAAO,OAAA;AAAA,IACT,CAAA;AAAA,IACA,eAAA,EAAiB,CAAI,KAAA,EAAuBA,QAAAA,KAA+B;AACzE,MAAA,SAAA,CAAU,eAAA,CAAgB,OAAOA,QAAO,CAAA;AACxC,MAAA,OAAO,OAAA;AAAA,IACT,CAAA;AAAA,IAEA,OAAO,MAAM;AAAA,GACf;AAEA,EAAA,OAAO,OAAA;AACT;AAGO,SAAS,mBAAA,CACd,KAAA,mBAAQ,IAAI,GAAA,EAAmC,EAC9B;AACjB,EAAA,MAAM,SAAA,GAAY,IAAI,eAAA,EAAgB;AAGtC,EAAA,KAAA,CAAM,OAAA,CAAQ,CAAC,cAAA,EAAgB,KAAA,KAAU;AACvC,IAAA,SAAA,CAAU,QAAA,CAAS,OAAO,cAAc,CAAA;AAAA,EAC1C,CAAC,CAAA;AAED,EAAA,SAAA,CAAU,QAAA,EAAS;AACnB,EAAA,OAAO,SAAA;AACT;AAKO,SAAS,cAAc,GAAA,EAAkC;AAC9D,EAAA,IAAI,OAAO,GAAA,KAAQ,QAAA,IAAY,GAAA,KAAQ,IAAA,EAAM;AAC3C,IAAA,OAAO,KAAA;AAAA,EACT;AACA,EAAA,MAAM,CAAA,GAAI,GAAA;AACV,EAAA,OACE,OAAO,CAAA,CAAE,QAAA,KAAa,UAAA,IACtB,OAAO,EAAE,OAAA,KAAY,UAAA,IACrB,OAAO,CAAA,CAAE,OAAA,KAAY,UAAA;AAEzB;AAEO,SAAS,kBAAkB,GAAA,EAAsC;AACtE,EAAA,IAAI,CAAC,aAAA,CAAc,GAAG,CAAA,EAAG;AACvB,IAAA,OAAO,KAAA;AAAA,EACT;AACA,EAAA,MAAM,CAAA,GAAI,GAAA;AACV,EAAA,OACE,OAAO,CAAA,CAAE,sBAAA,KAA2B,UAAA,IACpC,OAAO,EAAE,cAAA,KAAmB,UAAA;AAEhC;;;ACtJO,IAAM,UAAA,GAAa;AAEnB,IAAM,WAAA,GAAc;AAAA,EACzB,WAAA;AAAA,EACA,UAAA;AAAA,EACA,kBAAA;AAAA,EACA,mBAAA;AAAA,EACA,mBAAA;AAAA,EACA,aAAA;AAAA,EACA,iBAAA;AAAA,EACA,gBAAA;AAAA,EACA;AACF","file":"index.js","sourcesContent":["/**\n * Core DI System - Core Module Exports\n *\n * This module exports the fundamental building blocks of the dependency injection system:\n * - Container implementation\n * - Decorators for service registration\n * - Type definitions\n *\n * @example\n * ```typescript\n * import { DiademContainer, singleton, factory } from 'app/infrastructure/di/core'\n * ```\n */\n\n// Import for local usage\nimport type { Constructor, DIContainer } from './container'\nimport { DiademContainer } from './container'\nimport { factory, lazy, lazySingleton, singleton } from './decorators'\n\n// Container and types\nexport {\n  DiademContainer,\n  type Constructor,\n  type DIContainer,\n  type Disposable,\n  type LifecycleType,\n  type Token\n} from './container'\n\n// Decorators for auto-registration\nexport {\n  factory,\n  getDIMetadata,\n  getDIRegistrationStats,\n  hasDIMetadata,\n  isClassRegisteredForEnvironment,\n  lazy,\n  lazySingleton,\n  singleton,\n  type LifecycleType as DecoratorLifecycleType,\n  type DIMetadata\n} from './decorators'\n\n// Type definitions\nexport type { AbstractConstructor } from './types'\n\n// Pluggable logging (silent by default)\nexport { consoleLogger, getLogger, noopLogger, setLogger } from './logger'\nexport type { Logger } from './logger'\n\n// Service manifest contract + injection seam\nexport {\n  configureManifest,\n  getManifest,\n  hasManifest,\n  resetManifest\n} from './manifest'\nexport type {\n  ImportedService,\n  ServiceDependency,\n  ServiceManifestEntry,\n  ServiceManifestModule\n} from './manifest'\n\n/**\n * Common decorator combinations for convenience\n */\nexport const decorators = {\n  singleton,\n  factory,\n  lazy,\n  lazySingleton\n} as const\n\n/**\n * Type helpers for better developer experience\n */\n\n// Helper type to extract the implementation type from a constructor token\nexport type ResolvedType<T> = T extends Constructor<infer U> ? U : never\n\n// Helper type for multiple dependency resolution\nexport type ResolvedTypes<T extends ReadonlyArray<Constructor<unknown>>> = {\n  [K in keyof T]: T[K] extends Constructor<infer U> ? U : never\n}\n\n// Helper type for service factory functions\nexport type ServiceFactory<T> = () => T\n\n// Helper type for environment-aware service registration\nexport interface EnvironmentConfig {\n  environment?: string\n  modules: Array<Record<string, unknown>>\n}\n\n/**\n * Utility functions for advanced usage\n */\n\n/** Fluent builder returned by {@link createContainerBuilder}. */\nexport interface ContainerBuilder {\n  register: <T>(token: Constructor<T>, implementation: T) => ContainerBuilder\n  registerSingleton: <T>(\n    token: Constructor<T>,\n    factory: ServiceFactory<T>\n  ) => ContainerBuilder\n  registerFactory: <T>(\n    token: Constructor<T>,\n    factory: ServiceFactory<T>\n  ) => ContainerBuilder\n  build: () => DiademContainer\n}\n\n// Create a type-safe container builder\nexport function createContainerBuilder(): ContainerBuilder {\n  const container = new DiademContainer()\n\n  const builder: ContainerBuilder = {\n    register: <T>(token: Constructor<T>, implementation: T) => {\n      container.register(token, implementation)\n      return builder\n    },\n    registerSingleton: <T>(\n      token: Constructor<T>,\n      factory: ServiceFactory<T>\n    ) => {\n      container.registerSingleton(token, factory)\n      return builder\n    },\n    registerFactory: <T>(token: Constructor<T>, factory: ServiceFactory<T>) => {\n      container.registerFactory(token, factory)\n      return builder\n    },\n\n    build: () => container\n  }\n\n  return builder\n}\n\n// Create a mock container for testing\nexport function createMockContainer(\n  mocks = new Map<Constructor<unknown>, unknown>()\n): DiademContainer {\n  const container = new DiademContainer()\n\n  // Register all mocks\n  mocks.forEach((implementation, token) => {\n    container.register(token, implementation)\n  })\n\n  container.setReady()\n  return container\n}\n\n/**\n * Type guards for runtime type checking\n */\nexport function isDIContainer(obj: unknown): obj is DIContainer {\n  if (typeof obj !== 'object' || obj === null) {\n    return false\n  }\n  const c = obj as Record<string, unknown>\n  return (\n    typeof c.register === 'function' &&\n    typeof c.resolve === 'function' &&\n    typeof c.isReady === 'function'\n  )\n}\n\nexport function isDiademContainer(obj: unknown): obj is DiademContainer {\n  if (!isDIContainer(obj)) {\n    return false\n  }\n  const c = obj as unknown as Record<string, unknown>\n  return (\n    typeof c.autoRegisterDiscovered === 'function' &&\n    typeof c.getDiagnostics === 'function'\n  )\n}\n","/**\n * Diadem — main entry point.\n *\n * A build-time, manifest-driven DI container. SSR-safe and framework-agnostic:\n * registration metadata lives on classes, never in global state.\n *\n * ```typescript\n * import {\n *   DiademContainer,\n *   configureManifest,\n *   singleton,\n *   factory\n * } from '@devcraft-ts/diadem'\n * import * as manifest from './generated/service-manifest'\n *\n * configureManifest(manifest)\n * const container = new DiademContainer()\n * await container.autoRegisterDiscovered(process.env.NODE_ENV)\n * const service = container.resolve(IMyService)\n * ```\n */\n\n// Core DI functionality (container, decorators, manifest contract, logging).\n// Setup helpers live at 'diadem/setup'.\nexport * from './core'\n\n/**\n * Version and metadata\n */\nexport const DI_VERSION = '0.1.0'\n\nexport const DI_FEATURES = [\n  'type-safe',\n  'ssr-safe',\n  'decorator-driven',\n  'auto-registration',\n  'environment-aware',\n  'server-safe',\n  'no-global-state',\n  'metadata-based',\n  'zero-dependencies'\n] as const\n"]}

package/dist/setup/index.cjs

@@ -0,0 +1,87 @@
+'use strict';
+
+var chunk72YY5X6T_cjs = require('../chunk-72YY5X6T.cjs');
+var chunkFHQRDO5C_cjs = require('../chunk-FHQRDO5C.cjs');
+
+// src/setup/setup.ts
+async function setupDependencies(container, environment) {
+  await container.autoRegisterDiscovered(environment);
+  container.setReady();
+}
+async function setupTestDependencies(container, mockDependencies, environment) {
+  if (mockDependencies) {
+    mockDependencies.forEach((implementation, token) => {
+      container.register(token, implementation);
+    });
+  }
+  await container.autoRegisterDiscovered(environment);
+  container.setReady();
+}
+async function setupDevelopmentDependencies(container) {
+  await container.autoRegisterDiscovered("development");
+  if (process.env.NODE_ENV === "development") {
+    const diagnostics = container.getDiagnostics();
+    chunkFHQRDO5C_cjs.getLogger().info("DI Container Auto-Registration Diagnostics:", diagnostics);
+    const stats = container.getDiagnostics();
+    chunkFHQRDO5C_cjs.getLogger().info(
+      `Registered ${stats.dependencies + stats.singletons + stats.factories + stats.asyncFactories} services automatically`
+    );
+  }
+  container.setReady();
+}
+async function setupProductionDependencies(container) {
+  await container.autoRegisterDiscovered("production");
+  container.setReady();
+}
+async function createAutoConfiguredContainer(environment, customSetup) {
+  const container = new chunk72YY5X6T_cjs.DiademContainer();
+  if (customSetup) {
+    await customSetup(container);
+  }
+  await container.autoRegisterDiscovered(environment);
+  container.setReady();
+  return container;
+}
+function validateAutoRegistration(container, expectedServices = []) {
+  const diagnostics = container.getDiagnostics();
+  const totalRegistered = diagnostics.dependencies + diagnostics.singletons + diagnostics.factories + diagnostics.asyncFactories;
+  const registeredTokens = container.getRegisteredTokens();
+  const registeredNames = registeredTokens.map((token) => token.name);
+  const missingServices = expectedServices.filter(
+    (serviceName) => !registeredNames.some((name) => name.includes(serviceName))
+  );
+  return {
+    isValid: missingServices.length === 0,
+    missingServices,
+    registeredCount: totalRegistered
+  };
+}
+var setupDependenciesAuto = setupDependencies;
+var setupTestDependenciesAuto = setupTestDependencies;
+var setupDevelopmentDependenciesAuto = setupDevelopmentDependencies;
+var setupProductionDependenciesAuto = setupProductionDependencies;
+
+// src/setup/index.ts
+function logSetupInfo(container) {
+  const diagnostics = container.getDiagnostics();
+  const total = diagnostics.dependencies + diagnostics.singletons + diagnostics.factories + diagnostics.asyncFactories;
+  chunkFHQRDO5C_cjs.getLogger().info("Diadem container setup", {
+    ...diagnostics,
+    total,
+    tokens: container.getRegisteredTokens().map((token) => token.name)
+  });
+}
+
+exports.createAutoConfiguredContainer = createAutoConfiguredContainer;
+exports.logSetupInfo = logSetupInfo;
+exports.setupDependencies = setupDependencies;
+exports.setupDependenciesAuto = setupDependenciesAuto;
+exports.setupDevelopmentDependencies = setupDevelopmentDependencies;
+exports.setupDevelopmentDependenciesAuto = setupDevelopmentDependenciesAuto;
+exports.setupProductionDependencies = setupProductionDependencies;
+exports.setupProductionDependenciesAuto = setupProductionDependenciesAuto;
+exports.setupTestDependencies = setupTestDependencies;
+exports.setupTestDependenciesAuto = setupTestDependenciesAuto;
+exports.validateAutoRegistration = validateAutoRegistration;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map

package/dist/setup/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/setup/setup.ts","../../src/setup/index.ts"],"names":["getLogger","DiademContainer"],"mappings":"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","file":"index.cjs","sourcesContent":["import type { Constructor } from '../core/container'\nimport { DiademContainer } from '../core/container'\nimport { getLogger } from '../core/logger'\n\n/**\n * Auto-registration based dependency setup that uses decorated classes.\n * This replaces the manual setup functions with automatic discovery and registration.\n *\n * @param container The DI container instance to configure\n * @param environment Optional environment filter for environment-specific services\n */\nexport async function setupDependencies(\n  container: DiademContainer,\n  environment?: string\n): Promise<void> {\n  // Auto-register all decorated services using manifest-based discovery\n  await container.autoRegisterDiscovered(environment)\n\n  // Mark container as ready for use\n  container.setReady()\n}\n\n/**\n * Auto-registration setup for testing environments.\n * Allows for custom dependency mocking while using auto-registration for the rest.\n *\n * @param container The DI container instance to configure\n * @param mockDependencies Optional map of tokens to mock implementations\n * @param environment Optional environment filter\n */\nexport async function setupTestDependencies(\n  container: DiademContainer,\n  mockDependencies?: Map<Constructor<unknown>, unknown>,\n  environment?: string\n): Promise<void> {\n  // Register mock dependencies first (they take precedence)\n  if (mockDependencies) {\n    mockDependencies.forEach((implementation, token) => {\n      container.register(token, implementation)\n    })\n  }\n\n  // Auto-register remaining services using manifest-based discovery\n  await container.autoRegisterDiscovered(environment)\n\n  container.setReady()\n}\n\n/**\n * Auto-registration setup for development environment with debugging.\n *\n * @param container The DI container instance to configure\n */\nexport async function setupDevelopmentDependencies(\n  container: DiademContainer\n): Promise<void> {\n  // Auto-register all services for development using manifest-based discovery\n  await container.autoRegisterDiscovered('development')\n\n  // Log diagnostics in development\n  if (process.env.NODE_ENV === 'development') {\n    const diagnostics = container.getDiagnostics()\n    getLogger().info('DI Container Auto-Registration Diagnostics:', diagnostics)\n\n    // Log discovered services\n    const stats = container.getDiagnostics()\n    getLogger().info(\n      `Registered ${stats.dependencies + stats.singletons + stats.factories + stats.asyncFactories} services automatically`\n    )\n  }\n\n  container.setReady()\n}\n\n/**\n * Auto-registration setup for production environment.\n *\n * @param container The DI container instance to configure\n */\nexport async function setupProductionDependencies(\n  container: DiademContainer\n): Promise<void> {\n  // Auto-register all services for production using manifest-based discovery\n  await container.autoRegisterDiscovered('production')\n\n  container.setReady()\n}\n\n/**\n * Create a fully configured container using auto-registration.\n * This is the recommended way to create containers with the new decorator system.\n *\n * @param environment The environment to configure for ('development', 'production', 'test', etc.)\n * @param customSetup Optional custom setup function that runs before auto-registration\n * @returns A fully configured and ready container\n */\nexport async function createAutoConfiguredContainer(\n  environment: string,\n  customSetup?: (container: DiademContainer) => Promise<void>\n): Promise<DiademContainer> {\n  const container = new DiademContainer()\n\n  // Run custom setup first if provided\n  if (customSetup) {\n    await customSetup(container)\n  }\n\n  // Auto-register core services using manifest-based discovery\n  await container.autoRegisterDiscovered(environment)\n  container.setReady()\n\n  return container\n}\n\n/**\n * Validate that the expected services are registered after auto-registration.\n * Useful for debugging and asserting setup in application bootstrap code.\n *\n * @param container The container to validate\n * @param expectedServices Class names the application expects to be registered.\n *   Each is matched as a substring against registered token names. Defaults to\n *   an empty list (validation passes), since the set of services is\n *   application-specific.\n * @returns Object with validation results\n */\nexport function validateAutoRegistration(\n  container: DiademContainer,\n  expectedServices: string[] = []\n): {\n  isValid: boolean\n  missingServices: string[]\n  registeredCount: number\n} {\n  const diagnostics = container.getDiagnostics()\n  const totalRegistered =\n    diagnostics.dependencies +\n    diagnostics.singletons +\n    diagnostics.factories +\n    diagnostics.asyncFactories\n\n  const registeredTokens = container.getRegisteredTokens()\n  const registeredNames = registeredTokens.map((token) => token.name)\n\n  const missingServices = expectedServices.filter(\n    (serviceName) => !registeredNames.some((name) => name.includes(serviceName))\n  )\n\n  return {\n    isValid: missingServices.length === 0,\n    missingServices,\n    registeredCount: totalRegistered\n  }\n}\n\n// Backward compatibility aliases (keep the Auto suffix for existing code)\nexport const setupDependenciesAuto = setupDependencies\nexport const setupTestDependenciesAuto = setupTestDependencies\nexport const setupDevelopmentDependenciesAuto = setupDevelopmentDependencies\nexport const setupProductionDependenciesAuto = setupProductionDependencies\n","/**\n * Setup helpers — environment-aware container factories and validation.\n *\n * @example\n * ```ts\n * import { createAutoConfiguredContainer } from 'diadem/setup'\n *\n * const container = await createAutoConfiguredContainer(process.env.NODE_ENV)\n * const service = container.resolve(IMyService)\n * ```\n */\n\nimport type { DiademContainer } from '../core/container'\nimport { getLogger } from '../core/logger'\n\nexport {\n  createAutoConfiguredContainer,\n  setupDependencies,\n  setupDependenciesAuto,\n  setupDevelopmentDependencies,\n  setupDevelopmentDependenciesAuto,\n  setupProductionDependencies,\n  setupProductionDependenciesAuto,\n  setupTestDependencies,\n  setupTestDependenciesAuto,\n  validateAutoRegistration\n} from './setup'\n\n/**\n * Log a one-line summary of a container's registrations through the active\n * logger (silent unless a logger is configured). Intended for development\n * bootstrap diagnostics.\n */\nexport function logSetupInfo(container: DiademContainer): void {\n  const diagnostics = container.getDiagnostics()\n  const total =\n    diagnostics.dependencies +\n    diagnostics.singletons +\n    diagnostics.factories +\n    diagnostics.asyncFactories\n\n  getLogger().info('Diadem container setup', {\n    ...diagnostics,\n    total,\n    tokens: container.getRegisteredTokens().map((token) => token.name)\n  })\n}\n"]}

package/dist/setup/index.d.cts

@@ -0,0 +1,81 @@
+import { D as DiademContainer, a as Constructor } from '../container-C1FFn9_4.cjs';
+
+/**
+ * Auto-registration based dependency setup that uses decorated classes.
+ * This replaces the manual setup functions with automatic discovery and registration.
+ *
+ * @param container The DI container instance to configure
+ * @param environment Optional environment filter for environment-specific services
+ */
+declare function setupDependencies(container: DiademContainer, environment?: string): Promise<void>;
+/**
+ * Auto-registration setup for testing environments.
+ * Allows for custom dependency mocking while using auto-registration for the rest.
+ *
+ * @param container The DI container instance to configure
+ * @param mockDependencies Optional map of tokens to mock implementations
+ * @param environment Optional environment filter
+ */
+declare function setupTestDependencies(container: DiademContainer, mockDependencies?: Map<Constructor<unknown>, unknown>, environment?: string): Promise<void>;
+/**
+ * Auto-registration setup for development environment with debugging.
+ *
+ * @param container The DI container instance to configure
+ */
+declare function setupDevelopmentDependencies(container: DiademContainer): Promise<void>;
+/**
+ * Auto-registration setup for production environment.
+ *
+ * @param container The DI container instance to configure
+ */
+declare function setupProductionDependencies(container: DiademContainer): Promise<void>;
+/**
+ * Create a fully configured container using auto-registration.
+ * This is the recommended way to create containers with the new decorator system.
+ *
+ * @param environment The environment to configure for ('development', 'production', 'test', etc.)
+ * @param customSetup Optional custom setup function that runs before auto-registration
+ * @returns A fully configured and ready container
+ */
+declare function createAutoConfiguredContainer(environment: string, customSetup?: (container: DiademContainer) => Promise<void>): Promise<DiademContainer>;
+/**
+ * Validate that the expected services are registered after auto-registration.
+ * Useful for debugging and asserting setup in application bootstrap code.
+ *
+ * @param container The container to validate
+ * @param expectedServices Class names the application expects to be registered.
+ *   Each is matched as a substring against registered token names. Defaults to
+ *   an empty list (validation passes), since the set of services is
+ *   application-specific.
+ * @returns Object with validation results
+ */
+declare function validateAutoRegistration(container: DiademContainer, expectedServices?: string[]): {
+    isValid: boolean;
+    missingServices: string[];
+    registeredCount: number;
+};
+declare const setupDependenciesAuto: typeof setupDependencies;
+declare const setupTestDependenciesAuto: typeof setupTestDependencies;
+declare const setupDevelopmentDependenciesAuto: typeof setupDevelopmentDependencies;
+declare const setupProductionDependenciesAuto: typeof setupProductionDependencies;
+
+/**
+ * Setup helpers — environment-aware container factories and validation.
+ *
+ * @example
+ * ```ts
+ * import { createAutoConfiguredContainer } from 'diadem/setup'
+ *
+ * const container = await createAutoConfiguredContainer(process.env.NODE_ENV)
+ * const service = container.resolve(IMyService)
+ * ```
+ */
+
+/**
+ * Log a one-line summary of a container's registrations through the active
+ * logger (silent unless a logger is configured). Intended for development
+ * bootstrap diagnostics.
+ */
+declare function logSetupInfo(container: DiademContainer): void;
+
+export { createAutoConfiguredContainer, logSetupInfo, setupDependencies, setupDependenciesAuto, setupDevelopmentDependencies, setupDevelopmentDependenciesAuto, setupProductionDependencies, setupProductionDependenciesAuto, setupTestDependencies, setupTestDependenciesAuto, validateAutoRegistration };

package/dist/setup/index.d.ts

@@ -0,0 +1,81 @@
+import { D as DiademContainer, a as Constructor } from '../container-C1FFn9_4.js';
+
+/**
+ * Auto-registration based dependency setup that uses decorated classes.
+ * This replaces the manual setup functions with automatic discovery and registration.
+ *
+ * @param container The DI container instance to configure
+ * @param environment Optional environment filter for environment-specific services
+ */
+declare function setupDependencies(container: DiademContainer, environment?: string): Promise<void>;
+/**
+ * Auto-registration setup for testing environments.
+ * Allows for custom dependency mocking while using auto-registration for the rest.
+ *
+ * @param container The DI container instance to configure
+ * @param mockDependencies Optional map of tokens to mock implementations
+ * @param environment Optional environment filter
+ */
+declare function setupTestDependencies(container: DiademContainer, mockDependencies?: Map<Constructor<unknown>, unknown>, environment?: string): Promise<void>;
+/**
+ * Auto-registration setup for development environment with debugging.
+ *
+ * @param container The DI container instance to configure
+ */
+declare function setupDevelopmentDependencies(container: DiademContainer): Promise<void>;
+/**
+ * Auto-registration setup for production environment.
+ *
+ * @param container The DI container instance to configure
+ */
+declare function setupProductionDependencies(container: DiademContainer): Promise<void>;
+/**
+ * Create a fully configured container using auto-registration.
+ * This is the recommended way to create containers with the new decorator system.
+ *
+ * @param environment The environment to configure for ('development', 'production', 'test', etc.)
+ * @param customSetup Optional custom setup function that runs before auto-registration
+ * @returns A fully configured and ready container
+ */
+declare function createAutoConfiguredContainer(environment: string, customSetup?: (container: DiademContainer) => Promise<void>): Promise<DiademContainer>;
+/**
+ * Validate that the expected services are registered after auto-registration.
+ * Useful for debugging and asserting setup in application bootstrap code.
+ *
+ * @param container The container to validate
+ * @param expectedServices Class names the application expects to be registered.
+ *   Each is matched as a substring against registered token names. Defaults to
+ *   an empty list (validation passes), since the set of services is
+ *   application-specific.
+ * @returns Object with validation results
+ */
+declare function validateAutoRegistration(container: DiademContainer, expectedServices?: string[]): {
+    isValid: boolean;
+    missingServices: string[];
+    registeredCount: number;
+};
+declare const setupDependenciesAuto: typeof setupDependencies;
+declare const setupTestDependenciesAuto: typeof setupTestDependencies;
+declare const setupDevelopmentDependenciesAuto: typeof setupDevelopmentDependencies;
+declare const setupProductionDependenciesAuto: typeof setupProductionDependencies;
+
+/**
+ * Setup helpers — environment-aware container factories and validation.
+ *
+ * @example
+ * ```ts
+ * import { createAutoConfiguredContainer } from 'diadem/setup'
+ *
+ * const container = await createAutoConfiguredContainer(process.env.NODE_ENV)
+ * const service = container.resolve(IMyService)
+ * ```
+ */
+
+/**
+ * Log a one-line summary of a container's registrations through the active
+ * logger (silent unless a logger is configured). Intended for development
+ * bootstrap diagnostics.
+ */
+declare function logSetupInfo(container: DiademContainer): void;
+
+export { createAutoConfiguredContainer, logSetupInfo, setupDependencies, setupDependenciesAuto, setupDevelopmentDependencies, setupDevelopmentDependenciesAuto, setupProductionDependencies, setupProductionDependenciesAuto, setupTestDependencies, setupTestDependenciesAuto, validateAutoRegistration };