@shinigoji/levain-core 1.0.0-rc.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Levain contributors
+
+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,292 @@
+# @shinigoji/levain-core
+
+[![TypeScript](https://img.shields.io/badge/TypeScript-Strict-blue?logo=typescript)](https://www.typescriptlang.org/)
+[![Status](https://img.shields.io/badge/Status-V1%20RC%20Freeze-blue)](#stability)
+[![Runtime](https://img.shields.io/badge/Runtime-Node%20%7C%20Bun-111?logo=javascript)](#runtime-compatibility)
+
+Type-safe dependency injection for TypeScript.
+
+`@shinigoji/levain-core` is built for explicit composition, predictable lifetimes, and safe sync/async resolution without
+decorators or runtime magic.
+
+## Stability
+
+`@shinigoji/levain-core` is in **V1 RC freeze** mode: the public API contract is now treated
+as stable for release-candidate validation before `1.0.0`.
+
+## Install
+
+When published:
+
+```bash
+npm install @shinigoji/levain-core
+```
+
+Inside this monorepo, use the workspace package directly.
+
+## Runtime Compatibility
+
+| Runtime | Status    |
+|---------|-----------|
+| Node.js | Supported |
+| Bun     | Supported |
+
+## 60-Second Quick Start
+
+```ts
+import {createContainer, createDSL} from "@shinigoji/levain-core";
+
+const {token, singleton} = createDSL();
+
+class Logger {
+  info(message: string) {
+    console.log(message);
+  }
+}
+
+class UserService {
+  constructor(private readonly logger: Logger) {}
+}
+
+const LOGGER = token<Logger>("LOGGER");
+const USER_SERVICE = token<UserService>("USER_SERVICE");
+
+const container = createContainer()
+  .register(...singleton(LOGGER, () => new Logger()))
+  .register(...singleton.withDeps(USER_SERVICE, [LOGGER], (logger) => new UserService(logger)));
+
+const service = container.resolve(USER_SERVICE);
+```
+
+## Features
+
+- Hierarchical containers with per-request scopes
+- `singleton`, `scoped`, `transient` lifetimes
+- Async factories with `resolveAsync()`
+- Runtime safety errors with useful metadata
+- Optional static graph validation with `container.validate()`
+
+## API Overview
+
+```ts
+import {
+  createContainer,
+  createDSL,
+  AsyncFactoryInSyncResolveError,
+  CircularDependencyError,
+  DependencyNotFoundError,
+  InvalidLifetimeDependencyError,
+} from "@shinigoji/levain-core";
+```
+
+`createDSL()` returns:
+
+- `token<T>(description)`
+- `singleton`, `scoped`, `transient`
+- `*.withDeps(token, deps, factory)`
+- `*.async(token, asyncFactory)`
+- `*.async.withDeps(token, deps, asyncFactory)`
+
+`createContainer()` returns:
+
+- `register(token, registration)`
+- `registerMany(...entries)`
+- `resolve(token)` / `tryResolve(token)`
+- `resolveAsync(token)` / `tryResolveAsync(token)`
+- `createScope()`
+- `inspect(options?)`
+- `dispose(options?)`
+- `validate()`
+
+## Public API Contract (V1 Hardening)
+
+The public entrypoint is intentionally constrained to `@shinigoji/levain-core` root exports.
+Internal modules (`src/token`, `src/registration`, etc.) are not part of the
+compatibility contract and may change without semver guarantees.
+
+### V1 Stable Contract
+
+The following API surface is intended to be semver-stable for V1:
+
+- `createContainer`, `createDSL`
+- `Container` methods:
+  - `register`
+  - `registerMany`
+  - `resolve` / `tryResolve`
+  - `resolveAsync` / `tryResolveAsync`
+  - `createScope`
+  - `inspect`
+  - `dispose`
+  - `validate`
+- Error classes and metadata:
+  - `DependencyNotFoundError` (`code`, `tokenDescription`, `resolutionPath`)
+  - `CircularDependencyError` (`code`, `resolutionPath`)
+  - `InvalidLifetimeDependencyError` (`code`, `consumer`, `consumerLifetime`, `dependency`, `dependencyLifetime`, `resolutionPath`)
+  - `AsyncFactoryInSyncResolveError` (`code`, `tokenDescription`)
+  - `MissingDependencyMetadataError` (`tokenDescription`)
+- Public type exports from package root:
+  - `Token`
+  - `Lifetime`
+  - `Resolver`, `AsyncResolver`
+  - `Registration`, `AsyncRegistration`
+  - `LevainDSL`, `DSLBuilder`, `AsyncDSLBuilder`
+  - `RegistrationEntry`, `AsyncRegistrationEntry`
+  - `ResolveDeps`, `TokenType`
+  - `ErrorCode`
+  - `InspectOptions`, `DisposeOptions`
+  - `ContainerRegistrationInfo`, `ContainerInspection`
+  - `ValidateOptions`
+
+### Non-Contractual Surface (May Change)
+
+The following are intentionally out of contract before/for V1:
+
+- Deep imports (anything under `@shinigoji/levain-core/src/*`)
+- Internal helper names, file layout, and implementation details
+- Exact error message strings (error classes + metadata are the stable interface)
+- Documentation HTML structure under `docs/api`
+
+### RC Freeze Policy
+
+During `1.0.0-rc`:
+
+- avoid adding new public API surface unless critical
+- accept bug fixes, docs clarifications, and compatibility hardening
+- require explicit migration notes for any behavioral change
+
+Contract checks in this package:
+
+- Runtime export-surface contract: `test/public-api.test.ts`
+- Type-level contract assertions: `test/public-api.contract.ts` (validated by `bun run typecheck`)
+- Packaged tarball smoke checks (runtime + types): `scripts/release-check.sh`
+
+Generated API reference:
+
+- `bun run docs:api` (outputs HTML docs into `docs/api`)
+
+Production guides:
+
+- HTTP request scope: [`docs/guides/http-request-scope.md`](./docs/guides/http-request-scope.md)
+- Worker job scope: [`docs/guides/worker-job-scope.md`](./docs/guides/worker-job-scope.md)
+- CLI command scope: [`docs/guides/cli-command-scope.md`](./docs/guides/cli-command-scope.md)
+
+## Lifetimes
+
+| Lifetime    | Behavior                                 |
+|-------------|------------------------------------------|
+| `singleton` | One instance shared by root + all scopes |
+| `scoped`    | One instance per scope                   |
+| `transient` | New instance on each resolve             |
+
+## Async Rules
+
+- `resolve()` throws if target registration is async
+- `resolveAsync()` works for sync and async registrations
+- Async singleton/scoped cache in-flight promises (prevents double init)
+
+## Validation
+
+```ts
+container.validate();
+container.validate({ requireDepsMetadata: true });
+```
+
+Checks registrations defined with `withDeps` for:
+
+- missing dependencies
+- circular dependencies
+- lifetime violations (`singleton -> scoped`)
+- sync registration depending on async registration
+
+With `requireDepsMetadata: true`, validation also requires every registration
+to be declared with `withDeps(...)` (including zero-dependency factories via
+`withDeps([] as const, ...)`) so the whole graph can be statically verified.
+
+## Introspection
+
+```ts
+const snapshot = container.inspect();
+```
+
+`inspect()` returns a read-only snapshot of visible registrations (including
+inherited ones by default), registration lifetimes, declared deps metadata, and
+cache sizes.
+
+## Disposal
+
+```ts
+await container.dispose();
+```
+
+`dispose()` clears scoped/singleton caches and attempts to call one of:
+
+- `Symbol.asyncDispose`
+- `Symbol.dispose`
+- `dispose()`
+- `close()`
+
+By default it disposes child scopes too. Use:
+
+```ts
+await container.dispose({ includeChildren: false });
+```
+
+## Error Types
+
+- `DependencyNotFoundError`
+- `CircularDependencyError`
+- `InvalidLifetimeDependencyError`
+- `AsyncFactoryInSyncResolveError`
+- `MissingDependencyMetadataError`
+
+## Migration (from manual wiring)
+
+1. Start by introducing typed tokens for existing services.
+2. Register existing factories with `singleton/scoped/transient`.
+3. Replace constructor wiring progressively with `withDeps(...)`.
+4. Add `container.validate()` at startup.
+5. Move async initializers to `*.async` and use `resolveAsync()` in async flows.
+
+## Release Readiness
+
+Run the pre-publish check suite from this package:
+
+```bash
+bun run release:check
+```
+
+Generate API docs from declarations:
+
+```bash
+bun run docs:api
+```
+
+## V1 RC Release Flow
+
+Enable prerelease mode with Changesets:
+
+```bash
+bunx @changesets/cli pre enter rc
+```
+
+Then merge changesets as usual. Release automation will publish RC versions
+(`1.0.0-rc.x`) while prerelease mode is active.
+
+To leave prerelease mode and publish final `1.0.0`:
+
+```bash
+bunx @changesets/cli pre exit
+```
+
+## Design Principles
+
+- Explicit over implicit
+- Type-first API
+- Deterministic runtime behavior
+- Fail fast with actionable errors
+
+## Non-Goals (v1)
+
+- Decorator/reflection-based DI
+- Auto-registration and classpath scanning
+- Framework-specific bindings

package/dist/index.d.ts

@@ -0,0 +1,227 @@
+/**
+ * A typed token used to register and resolve services in a container.
+ * Each token is unique thanks to its `Symbol` key — two tokens with the
+ * same description are distinct.
+ */
+interface Token<T> {
+    readonly key: symbol;
+    readonly description: string;
+}
+/** Creates a new unique {@link Token} with the given description. */
+declare function createToken<T>(description: string): Token<T>;
+
+/** The lifetime strategy for a registration. */
+type Lifetime = "singleton" | "scoped" | "transient";
+/** Synchronous dependency resolver. Passed to sync factory functions. */
+interface Resolver {
+    resolve<T>(token: Token<T>): T;
+    tryResolve<T>(token: Token<T>): T | undefined;
+}
+/** Asynchronous dependency resolver. Passed to async factory functions. */
+interface AsyncResolver {
+    resolveAsync<T>(token: Token<T>): Promise<T>;
+    tryResolveAsync<T>(token: Token<T>): Promise<T | undefined>;
+}
+/** A synchronous service registration with a lifetime and factory. */
+interface Registration<T> {
+    lifetime: Lifetime;
+    factory: (resolver: Resolver) => T;
+    /** Dependency tokens declared via `withDeps`. Used by {@link Container.validate}. */
+    deps?: readonly Token<unknown>[];
+}
+/** An asynchronous service registration with a lifetime and async factory. */
+interface AsyncRegistration<T> {
+    lifetime: Lifetime;
+    factory: (resolver: AsyncResolver) => Promise<T>;
+    async: true;
+    /** Dependency tokens declared via `withDeps`. Used by {@link Container.validate}. */
+    deps?: readonly Token<unknown>[];
+}
+
+type TokenType<TToken> = TToken extends Token<infer T> ? T : never;
+type ResolveDeps<TDeps extends readonly Token<unknown>[]> = {
+    [K in keyof TDeps]: TokenType<TDeps[K]>;
+};
+type RegistrationEntry<T> = readonly [Token<T>, Registration<T>];
+type AsyncRegistrationEntry<T> = readonly [Token<T>, AsyncRegistration<T>];
+interface AsyncDSLBuilder {
+    <T>(token: Token<T>, factory: (resolver: AsyncResolver) => Promise<T>): AsyncRegistrationEntry<T>;
+    withDeps<const TDeps extends readonly Token<unknown>[], T>(token: Token<T>, deps: TDeps, factory: (...deps: ResolveDeps<TDeps>) => Promise<T>): AsyncRegistrationEntry<T>;
+}
+interface DSLBuilder {
+    <T>(token: Token<T>, factory: (resolver: Resolver) => T): RegistrationEntry<T>;
+    withDeps<const TDeps extends readonly Token<unknown>[], T>(token: Token<T>, deps: TDeps, factory: (...deps: ResolveDeps<TDeps>) => T): RegistrationEntry<T>;
+    async: AsyncDSLBuilder;
+}
+interface LevainDSL {
+    token: typeof createToken;
+    singleton: DSLBuilder;
+    scoped: DSLBuilder;
+    transient: DSLBuilder;
+}
+/**
+ * Creates the Levain DSL — the main entry point for defining services.
+ *
+ * Returns builders that produce `[token, registration]` tuples ready
+ * to pass to {@link Container.register}.
+ *
+ * @example
+ * ```ts
+ * const { token, singleton, transient } = createDSL();
+ *
+ * const LOGGER = token<Logger>("LOGGER");
+ * const [logTok, logReg] = singleton(LOGGER, () => new Logger());
+ *
+ * const container = createContainer().register(logTok, logReg);
+ * ```
+ */
+declare function createDSL(): LevainDSL;
+
+interface ValidateOptions {
+    requireDepsMetadata?: boolean;
+}
+interface InspectOptions {
+    includeInherited?: boolean;
+}
+interface DisposeOptions {
+    includeChildren?: boolean;
+}
+interface ContainerRegistrationInfo {
+    tokenDescription: string;
+    lifetime: Lifetime;
+    async: boolean;
+    deps: string[];
+    source: "self" | "inherited";
+}
+interface ContainerInspection {
+    hasParent: boolean;
+    childScopeCount: number;
+    cache: {
+        singleton: number;
+        scoped: number;
+    };
+    registrations: ContainerRegistrationInfo[];
+}
+/**
+ * Dependency injection container with support for hierarchical scoping,
+ * lifetime management, and both sync and async resolution.
+ */
+declare class Container implements Resolver, AsyncResolver {
+    private readonly parent?;
+    private readonly registry;
+    private readonly singletonCache;
+    private readonly scopedCache;
+    private readonly children;
+    private constructor();
+    static createRoot(): Container;
+    /** Registers a service factory for the given token. */
+    register<T>(token: Token<T>, registration: Registration<T> | AsyncRegistration<T>): this;
+    /** Registers multiple [token, registration] entries at once. */
+    registerMany(...entries: ReadonlyArray<readonly [
+        Token<unknown>,
+        Registration<unknown> | AsyncRegistration<unknown>
+    ]>): this;
+    /** Creates a child scope that inherits registrations from this container. */
+    createScope(): Container;
+    /** Returns a read-only snapshot of visible registrations and cache stats. */
+    inspect(options?: InspectOptions): ContainerInspection;
+    /**
+     * Disposes resolved scoped/singleton instances by calling one of:
+     * `Symbol.asyncDispose`, `Symbol.dispose`, `dispose()`, or `close()`.
+     */
+    dispose(options?: DisposeOptions): Promise<void>;
+    /**
+     * Synchronously resolves a service by its token.
+     * @throws {DependencyNotFoundError} If the token is not registered.
+     * @throws {CircularDependencyError} If a circular dependency is detected.
+     * @throws {InvalidLifetimeDependencyError} If lifetime rules are violated.
+     * @throws {AsyncFactoryInSyncResolveError} If the registration is async.
+     */
+    resolve: <T>(token: Token<T>) => T;
+    private resolveWithStack;
+    /** Like {@link resolve}, but returns `undefined` instead of throwing {@link DependencyNotFoundError}. */
+    tryResolve: <T>(token: Token<T>) => T | undefined;
+    /**
+     * Asynchronously resolves a service by its token. Works with both sync
+     * and async registrations. Async singletons and scoped services cache
+     * the `Promise` to prevent double initialization on concurrent calls.
+     */
+    resolveAsync: <T>(token: Token<T>) => Promise<T>;
+    private resolveAsyncWithStack;
+    /** Like {@link resolveAsync}, but returns `undefined` instead of throwing {@link DependencyNotFoundError}. */
+    tryResolveAsync: <T>(token: Token<T>) => Promise<T | undefined>;
+    /**
+     * Statically validates the dependency graph without resolving anything.
+     * Checks registrations that declare dependencies via `withDeps` for:
+     * missing dependencies, circular dependencies, lifetime violations,
+     * and sync-depends-on-async errors. Validates child scopes recursively.
+     */
+    validate(options?: ValidateOptions): void;
+    private validateContainer;
+    private checkCycle;
+    private checkLifetime;
+    private detectStaticCycles;
+    private checkStaticLifetimeRules;
+    private describeKey;
+    private collectRegistrationsForInspection;
+    private disposeCacheValues;
+    private callDisposer;
+    private findRegistration;
+    private createResolverContext;
+}
+/** Creates a new root {@link Container}. */
+declare function createContainer(): Container;
+
+/** Stable machine-readable error code for public DI errors. */
+type ErrorCode = "E_DEP_NOT_FOUND" | "E_CIRCULAR_DEP" | "E_ASYNC_IN_SYNC_RESOLVE" | "E_INVALID_LIFETIME_DEP";
+/** Thrown when resolving a token that has no registration in the container or its parents. */
+declare class DependencyNotFoundError extends Error {
+    readonly code: ErrorCode;
+    readonly tokenDescription: string;
+    readonly resolutionPath: string[];
+    constructor(tokenDescription: string, resolutionPath?: string[]);
+}
+/** Thrown when a circular dependency is detected during resolution. */
+declare class CircularDependencyError extends Error {
+    readonly code: ErrorCode;
+    readonly resolutionPath: string[];
+    constructor(resolutionPath: string[]);
+}
+/**
+ * Thrown when {@link Container.resolve} encounters an async registration.
+ * Use {@link Container.resolveAsync} instead.
+ */
+declare class AsyncFactoryInSyncResolveError extends Error {
+    readonly code: ErrorCode;
+    readonly tokenDescription: string;
+    constructor(tokenDescription: string);
+}
+/**
+ * Thrown when a registration violates lifetime rules.
+ * For example, a singleton depending on a scoped service.
+ */
+declare class InvalidLifetimeDependencyError extends Error {
+    readonly code: ErrorCode;
+    readonly consumer: string;
+    readonly consumerLifetime: string;
+    readonly dependency: string;
+    readonly dependencyLifetime: string;
+    readonly resolutionPath: string[];
+    constructor(args: {
+        consumer: string;
+        consumerLifetime: string;
+        dependency: string;
+        dependencyLifetime: string;
+        resolutionPath: string[];
+    });
+}
+/**
+ * Thrown when strict validation requires dependency metadata but a
+ * registration was not declared via `withDeps`.
+ */
+declare class MissingDependencyMetadataError extends Error {
+    readonly tokenDescription: string;
+    constructor(tokenDescription: string);
+}
+
+export { type AsyncDSLBuilder, AsyncFactoryInSyncResolveError, type AsyncRegistration, type AsyncRegistrationEntry, type AsyncResolver, CircularDependencyError, Container, type ContainerInspection, type ContainerRegistrationInfo, type DSLBuilder, DependencyNotFoundError, type DisposeOptions, type ErrorCode, type InspectOptions, InvalidLifetimeDependencyError, type LevainDSL, type Lifetime, MissingDependencyMetadataError, type Registration, type RegistrationEntry, type ResolveDeps, type Resolver, type Token, type TokenType, type ValidateOptions, createContainer, createDSL };

package/dist/index.js

@@ -0,0 +1,601 @@
+// src/registration.ts
+function isAsyncRegistration(reg) {
+  return "async" in reg && reg.async === true;
+}
+function createAsyncRegistrationBuilder(lifetime) {
+  const builder = ((factory) => {
+    return { lifetime, factory, async: true };
+  });
+  builder.withDeps = (deps, factory) => {
+    return {
+      lifetime,
+      async: true,
+      deps,
+      factory: async (resolver) => {
+        const resolvedDeps = await Promise.all(
+          deps.map((dep) => resolver.resolveAsync(dep))
+        );
+        return factory(...resolvedDeps);
+      }
+    };
+  };
+  return builder;
+}
+function createRegistrationBuilder(lifetime) {
+  const builder = ((factory) => {
+    return { lifetime, factory };
+  });
+  builder.withDeps = (deps, factory) => {
+    return {
+      lifetime,
+      deps,
+      factory: (resolver) => {
+        const resolvedDeps = deps.map((dep) => resolver.resolve(dep));
+        return factory(...resolvedDeps);
+      }
+    };
+  };
+  builder.async = createAsyncRegistrationBuilder(lifetime);
+  return builder;
+}
+var singleton = createRegistrationBuilder("singleton");
+var scoped = createRegistrationBuilder("scoped");
+var transient = createRegistrationBuilder("transient");
+
+// src/token.ts
+function createToken(description) {
+  return { key: Symbol(description), description };
+}
+
+// src/dsl.ts
+function createAsyncDSLBuilder(registrationBuilder) {
+  const builder = ((token, factory) => {
+    return [token, registrationBuilder(factory)];
+  });
+  builder.withDeps = (token, deps, factory) => {
+    return [token, registrationBuilder.withDeps(deps, factory)];
+  };
+  return builder;
+}
+function createDSLBuilder(registrationBuilder) {
+  const builder = ((token, factory) => {
+    return [token, registrationBuilder(factory)];
+  });
+  builder.withDeps = (token, deps, factory) => {
+    return [token, registrationBuilder.withDeps(deps, factory)];
+  };
+  builder.async = createAsyncDSLBuilder(registrationBuilder.async);
+  return builder;
+}
+function createDSL() {
+  return {
+    /** Creates a new unique typed token. */
+    token: createToken,
+    /** Registers a service as a singleton (one instance for the container's lifetime). */
+    singleton: createDSLBuilder(singleton),
+    /** Registers a service as scoped (one instance per scope). */
+    scoped: createDSLBuilder(scoped),
+    /** Registers a service as transient (new instance on every resolution). */
+    transient: createDSLBuilder(transient)
+  };
+}
+
+// src/errors.ts
+var DependencyNotFoundError = class extends Error {
+  code = "E_DEP_NOT_FOUND";
+  tokenDescription;
+  resolutionPath;
+  constructor(tokenDescription, resolutionPath = []) {
+    const pathText = resolutionPath.length > 0 ? `
+Resolution path: ${resolutionPath.join(" -> ")}` : "";
+    super(`No registration found for token: ${tokenDescription}${pathText}`);
+    this.name = "DependencyNotFoundError";
+    this.tokenDescription = tokenDescription;
+    this.resolutionPath = resolutionPath;
+  }
+};
+var CircularDependencyError = class extends Error {
+  code = "E_CIRCULAR_DEP";
+  resolutionPath;
+  constructor(resolutionPath) {
+    super(`Circular dependency detected: ${resolutionPath.join(" -> ")}`);
+    this.name = "CircularDependencyError";
+    this.resolutionPath = resolutionPath;
+  }
+};
+var AsyncFactoryInSyncResolveError = class extends Error {
+  code = "E_ASYNC_IN_SYNC_RESOLVE";
+  tokenDescription;
+  constructor(tokenDescription) {
+    super(
+      `Cannot synchronously resolve async registration: ${tokenDescription}. Use resolveAsync() instead.`
+    );
+    this.name = "AsyncFactoryInSyncResolveError";
+    this.tokenDescription = tokenDescription;
+  }
+};
+var InvalidLifetimeDependencyError = class extends Error {
+  code = "E_INVALID_LIFETIME_DEP";
+  consumer;
+  consumerLifetime;
+  dependency;
+  dependencyLifetime;
+  resolutionPath;
+  constructor(args) {
+    const {
+      consumer,
+      consumerLifetime,
+      dependency,
+      dependencyLifetime,
+      resolutionPath
+    } = args;
+    const pathText = resolutionPath.length > 0 ? `
+Resolution path: ${resolutionPath.join(" -> ")}` : "";
+    super(
+      `Invalid lifetime dependency: ${consumerLifetime} "${consumer}" cannot depend on ${dependencyLifetime} "${dependency}"${pathText}`
+    );
+    this.name = "InvalidLifetimeDependencyError";
+    this.consumer = consumer;
+    this.consumerLifetime = consumerLifetime;
+    this.dependency = dependency;
+    this.dependencyLifetime = dependencyLifetime;
+    this.resolutionPath = resolutionPath;
+  }
+};
+var MissingDependencyMetadataError = class extends Error {
+  tokenDescription;
+  constructor(tokenDescription) {
+    super(
+      `Missing dependency metadata for token: ${tokenDescription}. Use withDeps(...) so validate({ requireDepsMetadata: true }) can statically verify it.`
+    );
+    this.name = "MissingDependencyMetadataError";
+    this.tokenDescription = tokenDescription;
+  }
+};
+
+// src/container.ts
+function describeToken(token) {
+  return token.description ?? token.key.toString();
+}
+function findInvalidLifetimeConsumer(stack, dependencyLifetime) {
+  if (dependencyLifetime === "scoped") {
+    return stack.find((frame) => frame.lifetime === "singleton");
+  }
+  return void 0;
+}
+var Container = class _Container {
+  constructor(parent) {
+    this.parent = parent;
+  }
+  parent;
+  registry = /* @__PURE__ */ new Map();
+  singletonCache = /* @__PURE__ */ new Map();
+  scopedCache = /* @__PURE__ */ new Map();
+  children = /* @__PURE__ */ new Set();
+  static createRoot() {
+    return new _Container();
+  }
+  /** Registers a service factory for the given token. */
+  register(token, registration) {
+    this.registry.set(token.key, registration);
+    return this;
+  }
+  /** Registers multiple [token, registration] entries at once. */
+  registerMany(...entries) {
+    for (const [token, registration] of entries) {
+      this.registry.set(token.key, registration);
+    }
+    return this;
+  }
+  /** Creates a child scope that inherits registrations from this container. */
+  createScope() {
+    const child = new _Container(this);
+    this.children.add(child);
+    return child;
+  }
+  /** Returns a read-only snapshot of visible registrations and cache stats. */
+  inspect(options = {}) {
+    const includeInherited = options.includeInherited ?? true;
+    const registrations = this.collectRegistrationsForInspection(includeInherited).map(({ key, registration, source }) => ({
+      tokenDescription: this.describeKey(key),
+      lifetime: registration.lifetime,
+      async: isAsyncRegistration(registration),
+      deps: registration.deps?.map((dep) => describeToken(dep)) ?? [],
+      source
+    })).sort((a, b) => a.tokenDescription.localeCompare(b.tokenDescription));
+    return {
+      hasParent: this.parent !== void 0,
+      childScopeCount: this.children.size,
+      cache: {
+        singleton: this.singletonCache.size,
+        scoped: this.scopedCache.size
+      },
+      registrations
+    };
+  }
+  /**
+   * Disposes resolved scoped/singleton instances by calling one of:
+   * `Symbol.asyncDispose`, `Symbol.dispose`, `dispose()`, or `close()`.
+   */
+  async dispose(options = {}) {
+    const includeChildren = options.includeChildren ?? true;
+    const disposedValues = /* @__PURE__ */ new Set();
+    const errors = [];
+    if (includeChildren) {
+      for (const child of this.children) {
+        await child.dispose(options).catch((error) => {
+          errors.push(error);
+        });
+      }
+    }
+    await this.disposeCacheValues(this.scopedCache, disposedValues, errors);
+    await this.disposeCacheValues(this.singletonCache, disposedValues, errors);
+    this.scopedCache.clear();
+    this.singletonCache.clear();
+    this.children.clear();
+    if (errors.length > 0) {
+      throw new AggregateError(errors, "Container dispose failed");
+    }
+  }
+  /**
+   * Synchronously resolves a service by its token.
+   * @throws {DependencyNotFoundError} If the token is not registered.
+   * @throws {CircularDependencyError} If a circular dependency is detected.
+   * @throws {InvalidLifetimeDependencyError} If lifetime rules are violated.
+   * @throws {AsyncFactoryInSyncResolveError} If the registration is async.
+   */
+  resolve = (token) => {
+    return this.resolveWithStack(token, []);
+  };
+  resolveWithStack(token, stack) {
+    const found = this.findRegistration(token.key);
+    if (!found) {
+      throw new DependencyNotFoundError(
+        describeToken(token),
+        stack.map((frame) => describeToken(frame.token))
+      );
+    }
+    const { registration, owner } = found;
+    if (isAsyncRegistration(registration)) {
+      throw new AsyncFactoryInSyncResolveError(describeToken(token));
+    }
+    this.checkCycle(token, stack);
+    this.checkLifetime(token, registration, stack);
+    const nextStack = [...stack, {
+      token,
+      lifetime: registration.lifetime
+    }];
+    const resolver = this.createResolverContext(nextStack);
+    if (registration.lifetime === "singleton") {
+      if (owner.singletonCache.has(token.key)) {
+        return owner.singletonCache.get(token.key);
+      }
+      const instance = registration.factory(resolver);
+      owner.singletonCache.set(token.key, instance);
+      return instance;
+    }
+    if (registration.lifetime === "scoped") {
+      if (this.scopedCache.has(token.key)) {
+        return this.scopedCache.get(token.key);
+      }
+      const instance = registration.factory(resolver);
+      this.scopedCache.set(token.key, instance);
+      return instance;
+    }
+    return registration.factory(resolver);
+  }
+  /** Like {@link resolve}, but returns `undefined` instead of throwing {@link DependencyNotFoundError}. */
+  tryResolve = (token) => {
+    try {
+      return this.resolve(token);
+    } catch (error) {
+      if (error instanceof DependencyNotFoundError) {
+        return void 0;
+      }
+      throw error;
+    }
+  };
+  /**
+   * Asynchronously resolves a service by its token. Works with both sync
+   * and async registrations. Async singletons and scoped services cache
+   * the `Promise` to prevent double initialization on concurrent calls.
+   */
+  resolveAsync = async (token) => {
+    return await this.resolveAsyncWithStack(token, []);
+  };
+  async resolveAsyncWithStack(token, stack) {
+    const found = this.findRegistration(token.key);
+    if (!found) {
+      throw new DependencyNotFoundError(
+        describeToken(token),
+        stack.map((frame) => describeToken(frame.token))
+      );
+    }
+    const { registration, owner } = found;
+    this.checkCycle(token, stack);
+    this.checkLifetime(token, registration, stack);
+    const nextStack = [...stack, {
+      token,
+      lifetime: registration.lifetime
+    }];
+    const resolver = this.createResolverContext(nextStack);
+    if (registration.lifetime === "singleton") {
+      if (owner.singletonCache.has(token.key)) {
+        return await owner.singletonCache.get(token.key);
+      }
+      if (isAsyncRegistration(registration)) {
+        const promise = registration.factory(resolver).catch((err) => {
+          owner.singletonCache.delete(token.key);
+          throw err;
+        });
+        owner.singletonCache.set(token.key, promise);
+        return await promise;
+      }
+      const instance = registration.factory(resolver);
+      owner.singletonCache.set(token.key, instance);
+      return instance;
+    }
+    if (registration.lifetime === "scoped") {
+      if (this.scopedCache.has(token.key)) {
+        return await this.scopedCache.get(token.key);
+      }
+      if (isAsyncRegistration(registration)) {
+        const promise = registration.factory(resolver).catch((err) => {
+          this.scopedCache.delete(token.key);
+          throw err;
+        });
+        this.scopedCache.set(token.key, promise);
+        return await promise;
+      }
+      const instance = registration.factory(resolver);
+      this.scopedCache.set(token.key, instance);
+      return instance;
+    }
+    if (isAsyncRegistration(registration)) {
+      return await registration.factory(resolver);
+    }
+    return registration.factory(resolver);
+  }
+  /** Like {@link resolveAsync}, but returns `undefined` instead of throwing {@link DependencyNotFoundError}. */
+  tryResolveAsync = async (token) => {
+    try {
+      return await this.resolveAsync(token);
+    } catch (error) {
+      if (error instanceof DependencyNotFoundError) {
+        return void 0;
+      }
+      throw error;
+    }
+  };
+  /**
+   * Statically validates the dependency graph without resolving anything.
+   * Checks registrations that declare dependencies via `withDeps` for:
+   * missing dependencies, circular dependencies, lifetime violations,
+   * and sync-depends-on-async errors. Validates child scopes recursively.
+   */
+  validate(options = {}) {
+    this.validateContainer(options);
+    for (const child of this.children) {
+      child.validate(options);
+    }
+  }
+  validateContainer(options) {
+    if (options.requireDepsMetadata) {
+      for (const [key, registration] of this.registry) {
+        if (!registration.deps) {
+          throw new MissingDependencyMetadataError(this.describeKey(key));
+        }
+      }
+    }
+    for (const [key, registration] of this.registry) {
+      if (!registration.deps) continue;
+      const token = this.describeKey(key);
+      for (const dep of registration.deps) {
+        const found = this.findRegistration(dep.key);
+        if (!found) {
+          throw new DependencyNotFoundError(
+            describeToken(dep),
+            [token]
+          );
+        }
+        if (!isAsyncRegistration(registration) && isAsyncRegistration(found.registration)) {
+          throw new AsyncFactoryInSyncResolveError(describeToken(dep));
+        }
+      }
+    }
+    this.detectStaticCycles();
+    this.checkStaticLifetimeRules();
+  }
+  checkCycle(token, stack) {
+    const cycleStartIndex = stack.findIndex(
+      (frame) => frame.token.key === token.key
+    );
+    if (cycleStartIndex >= 0) {
+      const cyclePath = [
+        ...stack.slice(cycleStartIndex).map((frame) => describeToken(frame.token)),
+        describeToken(token)
+      ];
+      throw new CircularDependencyError(cyclePath);
+    }
+  }
+  checkLifetime(token, registration, stack) {
+    const invalidConsumer = findInvalidLifetimeConsumer(
+      stack,
+      registration.lifetime
+    );
+    if (invalidConsumer) {
+      throw new InvalidLifetimeDependencyError({
+        consumer: describeToken(invalidConsumer.token),
+        consumerLifetime: invalidConsumer.lifetime,
+        dependency: describeToken(token),
+        dependencyLifetime: registration.lifetime,
+        resolutionPath: [
+          ...stack.map((frame) => describeToken(frame.token)),
+          describeToken(token)
+        ]
+      });
+    }
+  }
+  detectStaticCycles() {
+    const visited = /* @__PURE__ */ new Set();
+    const inStack = /* @__PURE__ */ new Set();
+    const path = [];
+    const visit = (key) => {
+      if (inStack.has(key)) {
+        const description = this.describeKey(key);
+        const cycleStart = path.indexOf(description);
+        const cyclePath = [...path.slice(cycleStart), description];
+        throw new CircularDependencyError(cyclePath);
+      }
+      if (visited.has(key)) return;
+      const registration = this.findRegistration(key)?.registration;
+      if (!registration?.deps) return;
+      visited.add(key);
+      inStack.add(key);
+      path.push(this.describeKey(key));
+      for (const dep of registration.deps) {
+        visit(dep.key);
+      }
+      path.pop();
+      inStack.delete(key);
+    };
+    for (const [key] of this.registry) {
+      visit(key);
+    }
+  }
+  checkStaticLifetimeRules() {
+    const visit = (key, ancestors) => {
+      const found = this.findRegistration(key);
+      if (!found) return;
+      const { registration } = found;
+      const invalidConsumer = findInvalidLifetimeConsumer(ancestors, registration.lifetime);
+      if (invalidConsumer) {
+        throw new InvalidLifetimeDependencyError({
+          consumer: describeToken(invalidConsumer.token),
+          consumerLifetime: invalidConsumer.lifetime,
+          dependency: this.describeKey(key),
+          dependencyLifetime: registration.lifetime,
+          resolutionPath: [
+            ...ancestors.map((f) => describeToken(f.token)),
+            this.describeKey(key)
+          ]
+        });
+      }
+      if (!registration.deps) return;
+      const token = { key, description: this.describeKey(key) };
+      const frame = { token, lifetime: registration.lifetime };
+      for (const dep of registration.deps) {
+        visit(dep.key, [...ancestors, frame]);
+      }
+    };
+    for (const [key, registration] of this.registry) {
+      if (!registration.deps) continue;
+      const token = { key, description: this.describeKey(key) };
+      const frame = { token, lifetime: registration.lifetime };
+      for (const dep of registration.deps) {
+        visit(dep.key, [frame]);
+      }
+    }
+  }
+  describeKey(key) {
+    return key.description ?? key.toString();
+  }
+  collectRegistrationsForInspection(includeInherited) {
+    const visible = /* @__PURE__ */ new Map();
+    for (const [key, registration] of this.registry) {
+      visible.set(key, { registration, source: "self" });
+    }
+    if (includeInherited) {
+      let cursor = this.parent;
+      while (cursor) {
+        for (const [key, registration] of cursor.registry) {
+          if (!visible.has(key)) {
+            visible.set(key, { registration, source: "inherited" });
+          }
+        }
+        cursor = cursor.parent;
+      }
+    }
+    return [...visible.entries()].map(([key, value]) => ({
+      key,
+      registration: value.registration,
+      source: value.source
+    }));
+  }
+  async disposeCacheValues(cache, disposedValues, errors) {
+    for (const value of cache.values()) {
+      try {
+        const resolved = await value;
+        await this.callDisposer(resolved, disposedValues);
+      } catch (error) {
+        errors.push(error);
+      }
+    }
+  }
+  async callDisposer(value, disposedValues) {
+    if (value === null || value === void 0) return;
+    if (typeof value !== "object" && typeof value !== "function") return;
+    if (disposedValues.has(value)) return;
+    disposedValues.add(value);
+    const asyncDisposeSymbol = Symbol.asyncDispose;
+    const syncDisposeSymbol = Symbol.dispose;
+    const candidate = value;
+    if (asyncDisposeSymbol && typeof candidate[asyncDisposeSymbol] === "function") {
+      await candidate[asyncDisposeSymbol]?.();
+      return;
+    }
+    if (syncDisposeSymbol && typeof candidate[syncDisposeSymbol] === "function") {
+      candidate[syncDisposeSymbol]?.();
+      return;
+    }
+    if (typeof candidate.dispose === "function") {
+      await candidate.dispose();
+      return;
+    }
+    if (typeof candidate.close === "function") {
+      await candidate.close();
+    }
+  }
+  findRegistration(key) {
+    const registration = this.registry.get(key);
+    if (registration) {
+      return { registration, owner: this };
+    }
+    return this.parent?.findRegistration(key);
+  }
+  createResolverContext(stack) {
+    return {
+      resolve: (token) => this.resolveWithStack(token, stack),
+      tryResolve: (token) => {
+        try {
+          return this.resolveWithStack(token, stack);
+        } catch (error) {
+          if (error instanceof DependencyNotFoundError) {
+            return void 0;
+          }
+          throw error;
+        }
+      },
+      resolveAsync: async (token) => {
+        return await this.resolveAsyncWithStack(token, stack);
+      },
+      tryResolveAsync: async (token) => {
+        try {
+          return await this.resolveAsyncWithStack(token, stack);
+        } catch (error) {
+          if (error instanceof DependencyNotFoundError) {
+            return void 0;
+          }
+          throw error;
+        }
+      }
+    };
+  }
+};
+function createContainer() {
+  return Container.createRoot();
+}
+
+export { AsyncFactoryInSyncResolveError, CircularDependencyError, Container, DependencyNotFoundError, InvalidLifetimeDependencyError, MissingDependencyMetadataError, createContainer, createDSL };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/registration.ts","../src/token.ts","../src/dsl.ts","../src/errors.ts","../src/container.ts"],"names":[],"mappings":"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","file":"index.js","sourcesContent":["import type {Token} from \"./token\";\n\n/** The lifetime strategy for a registration. */\nexport type Lifetime = \"singleton\" | \"scoped\" | \"transient\";\n\n/** Synchronous dependency resolver. Passed to sync factory functions. */\nexport interface Resolver {\n  resolve<T>(token: Token<T>): T;\n  tryResolve<T>(token: Token<T>): T | undefined;\n}\n\n/** Asynchronous dependency resolver. Passed to async factory functions. */\nexport interface AsyncResolver {\n  resolveAsync<T>(token: Token<T>): Promise<T>;\n  tryResolveAsync<T>(token: Token<T>): Promise<T | undefined>;\n}\n\n/** A synchronous service registration with a lifetime and factory. */\nexport interface Registration<T> {\n  lifetime: Lifetime;\n  factory: (resolver: Resolver) => T;\n  /** Dependency tokens declared via `withDeps`. Used by {@link Container.validate}. */\n  deps?: readonly Token<unknown>[];\n}\n\n/** An asynchronous service registration with a lifetime and async factory. */\nexport interface AsyncRegistration<T> {\n  lifetime: Lifetime;\n  factory: (resolver: AsyncResolver) => Promise<T>;\n  async: true;\n  /** Dependency tokens declared via `withDeps`. Used by {@link Container.validate}. */\n  deps?: readonly Token<unknown>[];\n}\n\nexport type AnyRegistration<T> = Registration<T> | AsyncRegistration<T>;\n\nexport function isAsyncRegistration<T>(\n    reg: AnyRegistration<T>,\n): reg is AsyncRegistration<T> {\n  return \"async\" in reg && reg.async === true;\n}\n\ntype TokenType<TToken> = TToken extends Token<infer T> ? T : never;\n\ntype ResolveDeps<TDeps extends readonly Token<unknown>[]> = {\n  [K in keyof TDeps]: TokenType<TDeps[K]>;\n};\n\ninterface AsyncRegistrationBuilder {\n  <T>(factory: (resolver: AsyncResolver) => Promise<T>): AsyncRegistration<T>;\n  withDeps<const TDeps extends readonly Token<unknown>[], T>(\n      deps: TDeps,\n      factory: (...deps: ResolveDeps<TDeps>) => Promise<T>,\n  ): AsyncRegistration<T>;\n}\n\nexport interface RegistrationBuilder {\n  <T>(factory: (resolver: Resolver) => T): Registration<T>;\n  withDeps<const TDeps extends readonly Token<unknown>[], T>(\n      deps: TDeps,\n      factory: (...deps: ResolveDeps<TDeps>) => T,\n  ): Registration<T>;\n  async: AsyncRegistrationBuilder;\n}\n\nfunction createAsyncRegistrationBuilder(lifetime: Lifetime): AsyncRegistrationBuilder {\n  const builder = (<T>(\n      factory: (resolver: AsyncResolver) => Promise<T>,\n  ): AsyncRegistration<T> => {\n    return { lifetime, factory, async: true };\n  }) as AsyncRegistrationBuilder;\n\n  builder.withDeps = <const TDeps extends readonly Token<unknown>[], T>(\n      deps: TDeps,\n      factory: (...deps: ResolveDeps<TDeps>) => Promise<T>,\n  ): AsyncRegistration<T> => {\n    return {\n      lifetime,\n      async: true,\n      deps,\n      factory: async (resolver) => {\n        const resolvedDeps = await Promise.all(\n            deps.map((dep) => resolver.resolveAsync(dep)),\n        ) as ResolveDeps<TDeps>;\n        return factory(...resolvedDeps);\n      },\n    };\n  };\n\n  return builder;\n}\n\nfunction createRegistrationBuilder(lifetime: Lifetime): RegistrationBuilder {\n  const builder = (<T>(factory: (resolver: Resolver) => T): Registration<T> => {\n    return { lifetime, factory };\n  }) as RegistrationBuilder;\n\n  builder.withDeps = <const TDeps extends readonly Token<unknown>[], T>(\n      deps: TDeps,\n      factory: (...deps: ResolveDeps<TDeps>) => T,\n  ): Registration<T> => {\n    return {\n      lifetime,\n      deps,\n      factory: (resolver) => {\n        const resolvedDeps = deps.map((dep) => resolver.resolve(dep)) as ResolveDeps<TDeps>;\n        return factory(...resolvedDeps);\n      },\n    };\n  };\n\n  builder.async = createAsyncRegistrationBuilder(lifetime);\n\n  return builder;\n}\n\nexport const singleton = createRegistrationBuilder(\"singleton\");\nexport const scoped = createRegistrationBuilder(\"scoped\");\nexport const transient = createRegistrationBuilder(\"transient\");\n","/**\n * A typed token used to register and resolve services in a container.\n * Each token is unique thanks to its `Symbol` key — two tokens with the\n * same description are distinct.\n */\nexport interface Token<T> {\n  readonly key: symbol;\n  readonly description: string;\n}\n\n/** Creates a new unique {@link Token} with the given description. */\nexport function createToken<T>(description: string): Token<T> {\n  return { key: Symbol(description), description };\n}\n","import {\n    type AsyncRegistration,\n    type AsyncResolver,\n    type Registration,\n    type Resolver,\n    scoped,\n    singleton,\n    transient,\n} from \"./registration\";\nimport {createToken, type Token} from \"./token\";\n\nexport type TokenType<TToken> = TToken extends Token<infer T> ? T : never;\n\nexport type ResolveDeps<TDeps extends readonly Token<unknown>[]> = {\n    [K in keyof TDeps]: TokenType<TDeps[K]>;\n};\n\nexport type RegistrationEntry<T> = readonly [Token<T>, Registration<T>];\nexport type AsyncRegistrationEntry<T> = readonly [Token<T>, AsyncRegistration<T>];\n\nexport interface AsyncDSLBuilder {\n    <T>(token: Token<T>, factory: (resolver: AsyncResolver) => Promise<T>): AsyncRegistrationEntry<T>;\n    withDeps<const TDeps extends readonly Token<unknown>[], T>(\n        token: Token<T>,\n        deps: TDeps,\n        factory: (...deps: ResolveDeps<TDeps>) => Promise<T>,\n    ): AsyncRegistrationEntry<T>;\n}\n\nexport interface DSLBuilder {\n    <T>(token: Token<T>, factory: (resolver: Resolver) => T): RegistrationEntry<T>;\n    withDeps<const TDeps extends readonly Token<unknown>[], T>(\n        token: Token<T>,\n        deps: TDeps,\n        factory: (...deps: ResolveDeps<TDeps>) => T,\n    ): RegistrationEntry<T>;\n    async: AsyncDSLBuilder;\n}\n\nexport interface LevainDSL {\n    token: typeof createToken;\n    singleton: DSLBuilder;\n    scoped: DSLBuilder;\n    transient: DSLBuilder;\n}\n\nfunction createAsyncDSLBuilder(\n    registrationBuilder: {\n        <T>(factory: (resolver: AsyncResolver) => Promise<T>): AsyncRegistration<T>;\n        withDeps<const TDeps extends readonly Token<unknown>[], T>(\n            deps: TDeps,\n            factory: (...deps: ResolveDeps<TDeps>) => Promise<T>,\n        ): AsyncRegistration<T>;\n    },\n): AsyncDSLBuilder {\n    const builder = (<T>(\n        token: Token<T>,\n        factory: (resolver: AsyncResolver) => Promise<T>,\n    ): AsyncRegistrationEntry<T> => {\n        return [token, registrationBuilder(factory)] as const;\n    }) as AsyncDSLBuilder;\n\n    builder.withDeps = <const TDeps extends readonly Token<unknown>[], T>(\n        token: Token<T>,\n        deps: TDeps,\n        factory: (...deps: ResolveDeps<TDeps>) => Promise<T>,\n    ): AsyncRegistrationEntry<T> => {\n        return [token, registrationBuilder.withDeps(deps, factory)] as const;\n    };\n\n    return builder;\n}\n\nfunction createDSLBuilder(\n    registrationBuilder: {\n        <T>(factory: (resolver: Resolver) => T): Registration<T>;\n        withDeps<const TDeps extends readonly Token<unknown>[], T>(\n            deps: TDeps,\n            factory: (...deps: ResolveDeps<TDeps>) => T,\n        ): Registration<T>;\n        async: {\n            <T>(factory: (resolver: AsyncResolver) => Promise<T>): AsyncRegistration<T>;\n            withDeps<const TDeps extends readonly Token<unknown>[], T>(\n                deps: TDeps,\n                factory: (...deps: ResolveDeps<TDeps>) => Promise<T>,\n            ): AsyncRegistration<T>;\n        };\n    },\n): DSLBuilder {\n    const builder = (<T>(\n        token: Token<T>,\n        factory: (resolver: Resolver) => T,\n    ): RegistrationEntry<T> => {\n        return [token, registrationBuilder(factory)] as const;\n    }) as DSLBuilder;\n\n    builder.withDeps = <const TDeps extends readonly Token<unknown>[], T>(\n        token: Token<T>,\n        deps: TDeps,\n        factory: (...deps: ResolveDeps<TDeps>) => T,\n    ): RegistrationEntry<T> => {\n        return [token, registrationBuilder.withDeps(deps, factory)] as const;\n    };\n\n    builder.async = createAsyncDSLBuilder(registrationBuilder.async);\n\n    return builder;\n}\n\n/**\n * Creates the Levain DSL — the main entry point for defining services.\n *\n * Returns builders that produce `[token, registration]` tuples ready\n * to pass to {@link Container.register}.\n *\n * @example\n * ```ts\n * const { token, singleton, transient } = createDSL();\n *\n * const LOGGER = token<Logger>(\"LOGGER\");\n * const [logTok, logReg] = singleton(LOGGER, () => new Logger());\n *\n * const container = createContainer().register(logTok, logReg);\n * ```\n */\nexport function createDSL(): LevainDSL {\n    return {\n        /** Creates a new unique typed token. */\n        token: createToken,\n        /** Registers a service as a singleton (one instance for the container's lifetime). */\n        singleton: createDSLBuilder(singleton),\n        /** Registers a service as scoped (one instance per scope). */\n        scoped: createDSLBuilder(scoped),\n        /** Registers a service as transient (new instance on every resolution). */\n        transient: createDSLBuilder(transient),\n    };\n}\n","/** Stable machine-readable error code for public DI errors. */\nexport type ErrorCode =\n    | \"E_DEP_NOT_FOUND\"\n    | \"E_CIRCULAR_DEP\"\n    | \"E_ASYNC_IN_SYNC_RESOLVE\"\n    | \"E_INVALID_LIFETIME_DEP\";\n\n/** Thrown when resolving a token that has no registration in the container or its parents. */\nexport class DependencyNotFoundError extends Error {\n    readonly code: ErrorCode = \"E_DEP_NOT_FOUND\";\n    readonly tokenDescription: string;\n    readonly resolutionPath: string[];\n\n    constructor(tokenDescription: string, resolutionPath: string[] = []) {\n        const pathText =\n            resolutionPath.length > 0\n                ? `\\nResolution path: ${resolutionPath.join(\" -> \")}`\n                : \"\";\n\n        super(`No registration found for token: ${tokenDescription}${pathText}`);\n        this.name = \"DependencyNotFoundError\";\n        this.tokenDescription = tokenDescription;\n        this.resolutionPath = resolutionPath;\n    }\n}\n\n/** Thrown when a circular dependency is detected during resolution. */\nexport class CircularDependencyError extends Error {\n    readonly code: ErrorCode = \"E_CIRCULAR_DEP\";\n    readonly resolutionPath: string[];\n\n    constructor(resolutionPath: string[]) {\n        super(`Circular dependency detected: ${resolutionPath.join(\" -> \")}`);\n        this.name = \"CircularDependencyError\";\n        this.resolutionPath = resolutionPath;\n    }\n}\n\n/**\n * Thrown when {@link Container.resolve} encounters an async registration.\n * Use {@link Container.resolveAsync} instead.\n */\nexport class AsyncFactoryInSyncResolveError extends Error {\n    readonly code: ErrorCode = \"E_ASYNC_IN_SYNC_RESOLVE\";\n    readonly tokenDescription: string;\n\n    constructor(tokenDescription: string) {\n        super(\n            `Cannot synchronously resolve async registration: ${tokenDescription}. Use resolveAsync() instead.`,\n        );\n        this.name = \"AsyncFactoryInSyncResolveError\";\n        this.tokenDescription = tokenDescription;\n    }\n}\n\n/**\n * Thrown when a registration violates lifetime rules.\n * For example, a singleton depending on a scoped service.\n */\nexport class InvalidLifetimeDependencyError extends Error {\n    readonly code: ErrorCode = \"E_INVALID_LIFETIME_DEP\";\n    readonly consumer: string;\n    readonly consumerLifetime: string;\n    readonly dependency: string;\n    readonly dependencyLifetime: string;\n    readonly resolutionPath: string[];\n\n    constructor(args: {\n        consumer: string;\n        consumerLifetime: string;\n        dependency: string;\n        dependencyLifetime: string;\n        resolutionPath: string[];\n    }) {\n        const {\n            consumer,\n            consumerLifetime,\n            dependency,\n            dependencyLifetime,\n            resolutionPath,\n        } = args;\n\n        const pathText =\n            resolutionPath.length > 0\n                ? `\\nResolution path: ${resolutionPath.join(\" -> \")}`\n                : \"\";\n\n        super(\n            `Invalid lifetime dependency: ${consumerLifetime} \"${consumer}\" cannot depend on ${dependencyLifetime} \"${dependency}\"${pathText}`,\n        );\n\n        this.name = \"InvalidLifetimeDependencyError\";\n        this.consumer = consumer;\n        this.consumerLifetime = consumerLifetime;\n        this.dependency = dependency;\n        this.dependencyLifetime = dependencyLifetime;\n        this.resolutionPath = resolutionPath;\n    }\n}\n\n/**\n * Thrown when strict validation requires dependency metadata but a\n * registration was not declared via `withDeps`.\n */\nexport class MissingDependencyMetadataError extends Error {\n    readonly tokenDescription: string;\n\n    constructor(tokenDescription: string) {\n        super(\n            `Missing dependency metadata for token: ${tokenDescription}. ` +\n            \"Use withDeps(...) so validate({ requireDepsMetadata: true }) can statically verify it.\",\n        );\n        this.name = \"MissingDependencyMetadataError\";\n        this.tokenDescription = tokenDescription;\n    }\n}\n","import {\n    AsyncFactoryInSyncResolveError,\n    CircularDependencyError,\n    DependencyNotFoundError,\n    InvalidLifetimeDependencyError,\n    MissingDependencyMetadataError,\n} from \"./errors\";\nimport {\n    type AsyncRegistration,\n    type AnyRegistration,\n    type AsyncResolver,\n    isAsyncRegistration,\n    type Lifetime,\n    type Registration,\n    type Resolver,\n} from \"./registration\";\nimport type {Token} from \"./token\";\n\ntype Key = symbol;\n\ninterface ResolutionFrame {\n  token: Token<unknown>;\n  lifetime: Lifetime;\n}\n\nexport interface ValidateOptions {\n  requireDepsMetadata?: boolean;\n}\n\nexport interface InspectOptions {\n  includeInherited?: boolean;\n}\n\nexport interface DisposeOptions {\n  includeChildren?: boolean;\n}\n\nexport interface ContainerRegistrationInfo {\n  tokenDescription: string;\n  lifetime: Lifetime;\n  async: boolean;\n  deps: string[];\n  source: \"self\" | \"inherited\";\n}\n\nexport interface ContainerInspection {\n  hasParent: boolean;\n  childScopeCount: number;\n  cache: {\n    singleton: number;\n    scoped: number;\n  };\n  registrations: ContainerRegistrationInfo[];\n}\n\nfunction describeToken<T>(token: Token<T>): string {\n  return token.description ?? token.key.toString();\n}\n\nfunction findInvalidLifetimeConsumer(\n    stack: ResolutionFrame[],\n    dependencyLifetime: Lifetime,\n): ResolutionFrame | undefined {\n  if (dependencyLifetime === \"scoped\") {\n    return stack.find((frame) => frame.lifetime === \"singleton\");\n  }\n\n  return undefined;\n}\n\n/**\n * Dependency injection container with support for hierarchical scoping,\n * lifetime management, and both sync and async resolution.\n */\nexport class Container implements Resolver, AsyncResolver {\n  private readonly registry = new Map<Key, AnyRegistration<unknown>>();\n  private readonly singletonCache = new Map<Key, unknown>();\n  private readonly scopedCache = new Map<Key, unknown>();\n  private readonly children = new Set<Container>();\n\n    private constructor(private readonly parent?: Container) {\n    }\n\n    static createRoot(): Container {\n        return new Container();\n  }\n\n  /** Registers a service factory for the given token. */\n  register<T>(token: Token<T>, registration: Registration<T> | AsyncRegistration<T>): this {\n    this.registry.set(token.key, registration as AnyRegistration<unknown>);\n    return this;\n  }\n\n  /** Registers multiple [token, registration] entries at once. */\n  registerMany(\n      ...entries: ReadonlyArray<readonly [\n        Token<unknown>,\n        Registration<unknown> | AsyncRegistration<unknown>,\n      ]>\n  ): this {\n    for (const [token, registration] of entries) {\n      this.registry.set(token.key, registration as AnyRegistration<unknown>);\n    }\n\n    return this;\n  }\n\n  /** Creates a child scope that inherits registrations from this container. */\n  createScope(): Container {\n      const child = new Container(this);\n    this.children.add(child);\n    return child;\n  }\n\n  /** Returns a read-only snapshot of visible registrations and cache stats. */\n  inspect(options: InspectOptions = {}): ContainerInspection {\n    const includeInherited = options.includeInherited ?? true;\n    const registrations = this.collectRegistrationsForInspection(includeInherited)\n        .map(({key, registration, source}) => ({\n          tokenDescription: this.describeKey(key),\n          lifetime: registration.lifetime,\n          async: isAsyncRegistration(registration),\n          deps: registration.deps?.map((dep) => describeToken(dep)) ?? [],\n          source,\n        }))\n        .sort((a, b) => a.tokenDescription.localeCompare(b.tokenDescription));\n\n    return {\n      hasParent: this.parent !== undefined,\n      childScopeCount: this.children.size,\n      cache: {\n        singleton: this.singletonCache.size,\n        scoped: this.scopedCache.size,\n      },\n      registrations,\n    };\n  }\n\n  /**\n   * Disposes resolved scoped/singleton instances by calling one of:\n   * `Symbol.asyncDispose`, `Symbol.dispose`, `dispose()`, or `close()`.\n   */\n  async dispose(options: DisposeOptions = {}): Promise<void> {\n    const includeChildren = options.includeChildren ?? true;\n    const disposedValues = new Set<unknown>();\n    const errors: unknown[] = [];\n\n    if (includeChildren) {\n      for (const child of this.children) {\n        await child.dispose(options).catch((error: unknown) => {\n          errors.push(error);\n        });\n      }\n    }\n\n    await this.disposeCacheValues(this.scopedCache, disposedValues, errors);\n    await this.disposeCacheValues(this.singletonCache, disposedValues, errors);\n\n    this.scopedCache.clear();\n    this.singletonCache.clear();\n    this.children.clear();\n\n    if (errors.length > 0) {\n      throw new AggregateError(errors, \"Container dispose failed\");\n    }\n  }\n\n  /**\n   * Synchronously resolves a service by its token.\n   * @throws {DependencyNotFoundError} If the token is not registered.\n   * @throws {CircularDependencyError} If a circular dependency is detected.\n   * @throws {InvalidLifetimeDependencyError} If lifetime rules are violated.\n   * @throws {AsyncFactoryInSyncResolveError} If the registration is async.\n   */\n  resolve = <T>(token: Token<T>): T => {\n      return this.resolveWithStack(token, []);\n  };\n\n    private resolveWithStack<T>(token: Token<T>, stack: ResolutionFrame[]): T {\n    const found = this.findRegistration(token.key);\n\n    if (!found) {\n      throw new DependencyNotFoundError(\n          describeToken(token),\n          stack.map((frame) => describeToken(frame.token)),\n      );\n    }\n\n    const { registration, owner } = found;\n\n    if (isAsyncRegistration(registration)) {\n      throw new AsyncFactoryInSyncResolveError(describeToken(token));\n    }\n\n        this.checkCycle(token, stack);\n        this.checkLifetime(token, registration, stack);\n\n        const nextStack = [...stack, {\n      token,\n      lifetime: registration.lifetime,\n        }];\n\n        const resolver = this.createResolverContext(nextStack);\n\n        if (registration.lifetime === \"singleton\") {\n            if (owner.singletonCache.has(token.key)) {\n                return owner.singletonCache.get(token.key) as T;\n            }\n\n            const instance = registration.factory(resolver);\n            owner.singletonCache.set(token.key, instance);\n            return instance as T;\n        }\n\n        if (registration.lifetime === \"scoped\") {\n            if (this.scopedCache.has(token.key)) {\n                return this.scopedCache.get(token.key) as T;\n            }\n\n            const instance = registration.factory(resolver);\n            this.scopedCache.set(token.key, instance);\n            return instance as T;\n        }\n\n        return registration.factory(resolver) as T;\n    }\n\n  /** Like {@link resolve}, but returns `undefined` instead of throwing {@link DependencyNotFoundError}. */\n  tryResolve = <T>(token: Token<T>): T | undefined => {\n    try {\n      return this.resolve(token);\n    } catch (error) {\n      if (error instanceof DependencyNotFoundError) {\n        return undefined;\n      }\n\n      throw error;\n    }\n  };\n\n  /**\n   * Asynchronously resolves a service by its token. Works with both sync\n   * and async registrations. Async singletons and scoped services cache\n   * the `Promise` to prevent double initialization on concurrent calls.\n   */\n  resolveAsync = async <T>(token: Token<T>): Promise<T> => {\n      return await this.resolveAsyncWithStack(token, []);\n  };\n\n    private async resolveAsyncWithStack<T>(\n        token: Token<T>,\n        stack: ResolutionFrame[],\n    ): Promise<T> {\n    const found = this.findRegistration(token.key);\n\n    if (!found) {\n      throw new DependencyNotFoundError(\n          describeToken(token),\n          stack.map((frame) => describeToken(frame.token)),\n      );\n    }\n\n    const { registration, owner } = found;\n\n        this.checkCycle(token, stack);\n        this.checkLifetime(token, registration, stack);\n\n        const nextStack = [...stack, {\n      token,\n      lifetime: registration.lifetime,\n        }];\n\n        const resolver = this.createResolverContext(nextStack);\n\n        if (registration.lifetime === \"singleton\") {\n            if (owner.singletonCache.has(token.key)) {\n                return await owner.singletonCache.get(token.key) as T;\n            }\n\n            if (isAsyncRegistration(registration)) {\n                const promise = registration.factory(resolver).catch((err: unknown) => {\n                    owner.singletonCache.delete(token.key);\n                    throw err;\n                });\n                owner.singletonCache.set(token.key, promise);\n                return await promise as T;\n            }\n\n            const instance = (registration as Registration<unknown>).factory(resolver);\n            owner.singletonCache.set(token.key, instance);\n            return instance as T;\n        }\n\n        if (registration.lifetime === \"scoped\") {\n            if (this.scopedCache.has(token.key)) {\n                return await this.scopedCache.get(token.key) as T;\n            }\n\n            if (isAsyncRegistration(registration)) {\n                const promise = registration.factory(resolver).catch((err: unknown) => {\n                    this.scopedCache.delete(token.key);\n                    throw err;\n                });\n                this.scopedCache.set(token.key, promise);\n                return await promise as T;\n            }\n\n            const instance = (registration as Registration<unknown>).factory(resolver);\n            this.scopedCache.set(token.key, instance);\n            return instance as T;\n        }\n\n        if (isAsyncRegistration(registration)) {\n            return await registration.factory(resolver) as T;\n        }\n\n        return (registration as Registration<unknown>).factory(resolver) as T;\n    }\n\n  /** Like {@link resolveAsync}, but returns `undefined` instead of throwing {@link DependencyNotFoundError}. */\n  tryResolveAsync = async <T>(token: Token<T>): Promise<T | undefined> => {\n    try {\n      return await this.resolveAsync(token);\n    } catch (error) {\n      if (error instanceof DependencyNotFoundError) {\n        return undefined;\n      }\n\n      throw error;\n    }\n  };\n\n  /**\n   * Statically validates the dependency graph without resolving anything.\n   * Checks registrations that declare dependencies via `withDeps` for:\n   * missing dependencies, circular dependencies, lifetime violations,\n   * and sync-depends-on-async errors. Validates child scopes recursively.\n   */\n  validate(options: ValidateOptions = {}): void {\n    this.validateContainer(options);\n\n    for (const child of this.children) {\n      child.validate(options);\n    }\n  }\n\n  private validateContainer(options: ValidateOptions): void {\n    if (options.requireDepsMetadata) {\n      for (const [key, registration] of this.registry) {\n        if (!registration.deps) {\n          throw new MissingDependencyMetadataError(this.describeKey(key));\n        }\n      }\n    }\n\n    for (const [key, registration] of this.registry) {\n      if (!registration.deps) continue;\n\n      const token = this.describeKey(key);\n\n      for (const dep of registration.deps) {\n        const found = this.findRegistration(dep.key);\n\n        if (!found) {\n          throw new DependencyNotFoundError(\n              describeToken(dep),\n              [token],\n          );\n        }\n\n        if (!isAsyncRegistration(registration) && isAsyncRegistration(found.registration)) {\n          throw new AsyncFactoryInSyncResolveError(describeToken(dep));\n        }\n      }\n    }\n\n    this.detectStaticCycles();\n    this.checkStaticLifetimeRules();\n  }\n\n    private checkCycle<T>(token: Token<T>, stack: ResolutionFrame[]): void {\n        const cycleStartIndex = stack.findIndex(\n        (frame) => frame.token.key === token.key,\n    );\n\n    if (cycleStartIndex >= 0) {\n      const cyclePath = [\n          ...stack\n            .slice(cycleStartIndex)\n            .map((frame) => describeToken(frame.token)),\n        describeToken(token),\n      ];\n\n      throw new CircularDependencyError(cyclePath);\n    }\n  }\n\n  private checkLifetime<T>(\n      token: Token<T>,\n      registration: AnyRegistration<unknown>,\n      stack: ResolutionFrame[],\n  ): void {\n    const invalidConsumer = findInvalidLifetimeConsumer(\n        stack,\n        registration.lifetime,\n    );\n\n    if (invalidConsumer) {\n      throw new InvalidLifetimeDependencyError({\n        consumer: describeToken(invalidConsumer.token),\n        consumerLifetime: invalidConsumer.lifetime,\n        dependency: describeToken(token),\n        dependencyLifetime: registration.lifetime,\n        resolutionPath: [\n            ...stack.map((frame) => describeToken(frame.token)),\n          describeToken(token),\n        ],\n      });\n    }\n  }\n\n  private detectStaticCycles(): void {\n    const visited = new Set<Key>();\n    const inStack = new Set<Key>();\n    const path: string[] = [];\n\n    const visit = (key: Key): void => {\n      if (inStack.has(key)) {\n        const description = this.describeKey(key);\n        const cycleStart = path.indexOf(description);\n        const cyclePath = [...path.slice(cycleStart), description];\n        throw new CircularDependencyError(cyclePath);\n      }\n\n      if (visited.has(key)) return;\n\n      const registration = this.findRegistration(key)?.registration;\n      if (!registration?.deps) return;\n\n      visited.add(key);\n      inStack.add(key);\n      path.push(this.describeKey(key));\n\n      for (const dep of registration.deps) {\n        visit(dep.key);\n      }\n\n      path.pop();\n      inStack.delete(key);\n    };\n\n    for (const [key] of this.registry) {\n      visit(key);\n    }\n  }\n\n  private checkStaticLifetimeRules(): void {\n    const visit = (\n        key: Key,\n        ancestors: ResolutionFrame[],\n    ): void => {\n      const found = this.findRegistration(key);\n      if (!found) return;\n\n      const { registration } = found;\n\n      const invalidConsumer = findInvalidLifetimeConsumer(ancestors, registration.lifetime);\n\n      if (invalidConsumer) {\n        throw new InvalidLifetimeDependencyError({\n          consumer: describeToken(invalidConsumer.token),\n          consumerLifetime: invalidConsumer.lifetime,\n          dependency: this.describeKey(key),\n          dependencyLifetime: registration.lifetime,\n          resolutionPath: [\n            ...ancestors.map((f) => describeToken(f.token)),\n            this.describeKey(key),\n          ],\n        });\n      }\n\n      if (!registration.deps) return;\n\n      const token: Token<unknown> = { key, description: this.describeKey(key) };\n      const frame: ResolutionFrame = { token, lifetime: registration.lifetime };\n\n      for (const dep of registration.deps) {\n        visit(dep.key, [...ancestors, frame]);\n      }\n    };\n\n    for (const [key, registration] of this.registry) {\n      if (!registration.deps) continue;\n\n      const token: Token<unknown> = { key, description: this.describeKey(key) };\n      const frame: ResolutionFrame = { token, lifetime: registration.lifetime };\n\n      for (const dep of registration.deps) {\n        visit(dep.key, [frame]);\n      }\n    }\n  }\n\n  private describeKey(key: Key): string {\n    return key.description ?? key.toString();\n  }\n\n  private collectRegistrationsForInspection(\n      includeInherited: boolean,\n  ): Array<{\n    key: Key;\n    registration: AnyRegistration<unknown>;\n    source: \"self\" | \"inherited\";\n  }> {\n    const visible = new Map<Key, {\n      registration: AnyRegistration<unknown>;\n      source: \"self\" | \"inherited\";\n    }>();\n\n    for (const [key, registration] of this.registry) {\n      visible.set(key, {registration, source: \"self\"});\n    }\n\n    if (includeInherited) {\n      let cursor = this.parent;\n      while (cursor) {\n        for (const [key, registration] of cursor.registry) {\n          if (!visible.has(key)) {\n            visible.set(key, {registration, source: \"inherited\"});\n          }\n        }\n        cursor = cursor.parent;\n      }\n    }\n\n    return [...visible.entries()].map(([key, value]) => ({\n      key,\n      registration: value.registration,\n      source: value.source,\n    }));\n  }\n\n  private async disposeCacheValues(\n      cache: Map<Key, unknown>,\n      disposedValues: Set<unknown>,\n      errors: unknown[],\n  ): Promise<void> {\n    for (const value of cache.values()) {\n      try {\n        const resolved = await value;\n        await this.callDisposer(resolved, disposedValues);\n      } catch (error) {\n        errors.push(error);\n      }\n    }\n  }\n\n  private async callDisposer(\n      value: unknown,\n      disposedValues: Set<unknown>,\n  ): Promise<void> {\n    if (value === null || value === undefined) return;\n    if (typeof value !== \"object\" && typeof value !== \"function\") return;\n    if (disposedValues.has(value)) return;\n\n    disposedValues.add(value);\n\n    const asyncDisposeSymbol = Symbol.asyncDispose as symbol | undefined;\n    const syncDisposeSymbol = Symbol.dispose as symbol | undefined;\n    const candidate = value as {\n      [k: symbol]: (() => Promise<void> | void) | undefined;\n      dispose?: () => Promise<void> | void;\n      close?: () => Promise<void> | void;\n    };\n\n    if (asyncDisposeSymbol && typeof candidate[asyncDisposeSymbol] === \"function\") {\n      await candidate[asyncDisposeSymbol]?.();\n      return;\n    }\n\n    if (syncDisposeSymbol && typeof candidate[syncDisposeSymbol] === \"function\") {\n      candidate[syncDisposeSymbol]?.();\n      return;\n    }\n\n    if (typeof candidate.dispose === \"function\") {\n      await candidate.dispose();\n      return;\n    }\n\n    if (typeof candidate.close === \"function\") {\n      await candidate.close();\n    }\n  }\n\n  private findRegistration(\n      key: Key,\n  ): { registration: AnyRegistration<unknown>; owner: Container } | undefined {\n    const registration = this.registry.get(key);\n\n    if (registration) {\n      return { registration, owner: this };\n    }\n\n    return this.parent?.findRegistration(key);\n  }\n\n    private createResolverContext(\n        stack: ResolutionFrame[],\n    ): Resolver & AsyncResolver {\n        return {\n            resolve: <T>(token: Token<T>): T => this.resolveWithStack(token, stack),\n            tryResolve: <T>(token: Token<T>): T | undefined => {\n                try {\n                    return this.resolveWithStack(token, stack);\n                } catch (error) {\n                    if (error instanceof DependencyNotFoundError) {\n                        return undefined;\n                    }\n\n                    throw error;\n                }\n            },\n            resolveAsync: async <T>(token: Token<T>): Promise<T> => {\n                return await this.resolveAsyncWithStack(token, stack);\n            },\n            tryResolveAsync: async <T>(token: Token<T>): Promise<T | undefined> => {\n                try {\n                    return await this.resolveAsyncWithStack(token, stack);\n                } catch (error) {\n                    if (error instanceof DependencyNotFoundError) {\n                        return undefined;\n                    }\n\n                    throw error;\n                }\n            },\n        };\n    }\n}\n\n/** Creates a new root {@link Container}. */\nexport function createContainer(): Container {\n    return Container.createRoot();\n}\n"]}

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@shinigoji/levain-core",
+  "version": "1.0.0-rc.0",
+  "description": "Type-safe dependency injection for TypeScript with explicit lifetimes, scopes, and async resolution.",
+  "license": "MIT",
+  "private": false,
+  "type": "module",
+  "sideEffects": false,
+  "module": "./dist/index.js",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "dependency-injection",
+    "di",
+    "typescript",
+    "ioc",
+    "container"
+  ],
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "docs:api": "bun run build && typedoc --options typedoc.json",
+    "prepack": "bun run build",
+    "dev": "tsup --watch",
+    "test": "bun test",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "release:check": "./scripts/release-check.sh",
+    "clean": "rm -rf dist"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.3.11",
+    "tsup": "^8.5.1",
+    "typedoc": "^0.28.18",
+    "typescript": "^6.0.2"
+  }
+}