@codefast/di 0.3.14-canary.1 → 0.3.14

package/dist/scope.d.mts

@@ -1,112 +1,25 @@
-import { Binding, BindingIdentifier } from "./binding.mjs";
+import { BindingIdentifier } from "./types.mjs";
 
 //#region src/scope.d.ts
-/**
- * Caches singleton and scoped instances, deduplicates concurrent async creation, and runs
- * deactivation hooks (`onDeactivation`, `@preDestroy`) on disposal.
- *
- * A root scope manager owns both singleton and scoped caches. A child scope manager (created
- * via {@link createChildScope}) shares the parent's singleton cache but receives a fresh scoped
- * cache — singletons are shared across the hierarchy, scoped instances are isolated per child.
- *
- * Invariant: `ownsSingletonDisposal` is `true` only for the root. When a child disposes, only
- * its scoped bindings are deactivated; singletons remain alive until the root disposes.
- */
 declare class ScopeManager {
-  /**
-   * Cached singleton instances: `bindingId → { binding, instance }`.
-   */
-  private readonly singletonCache;
-  /**
-   * Cached scoped instances for this container level: `bindingId → { binding, instance }`.
-   */
-  private readonly scopedCache;
-  /**
-   * True only for the root scope manager. Controls whether {@link dispose} / {@link disposeAsync}
-   * also drain the shared singleton cache; child scopes leave singleton disposal to the root.
-   */
-  private readonly ownsSingletonDisposal;
-  /**
-   * In-flight async singleton creation promises.
-   * Guards against double-instantiation when multiple `resolveAsync` calls for the same
-   * singleton binding overlap before the first one settles.
-   */
-  private readonly singletonPendingPromises;
-  /**
-   * In-flight async scoped creation promises (same deduplication role as
-   * {@link singletonPendingPromises} but for scoped bindings).
-   */
-  private readonly scopedPendingPromises;
-  /**
-   * Internal constructor for root/child scope managers.
-   * Prefer {@link createRoot} and {@link createChildScope}.
-   */
-  private constructor();
-  /**
-   * Creates a root scope manager that owns both the singleton cache and scoped cache.
-   */
-  static createRoot(): ScopeManager;
-  /**
-   * Shares the parent singleton cache; receives a fresh scoped cache (for child containers).
-   */
-  createChildScope(): ScopeManager;
-  /**
-   * Whether a singleton/scoped binding currently has a cached instance (always false for transient).
-   */
-  isBindingCached(binding: Binding<unknown>): boolean;
-  /**
-   * Returns the cached instance for singleton/scoped bindings, or calls `createInstance` on first access.
-   */
-  getOrCreate(binding: Binding<unknown>, createInstance: () => unknown): unknown;
-  /**
-   * Async variant of {@link getOrCreate}. Deduplicates concurrent creation calls for the same
-   * binding using an in-flight promise map, preventing double-instantiation under parallel resolves.
-   */
-  getOrCreateAsync(binding: Binding<unknown>, createInstance: () => Promise<unknown>): Promise<unknown>;
-  /**
-   * Runs synchronous `onDeactivation` hooks for scoped instances owned by this manager.
-   * Throws if any hook returns a Promise.
-   */
-  dispose(): void;
-  /**
-   * Runs `onDeactivation` hooks for scoped instances; root also disposes shared singletons.
-   */
-  disposeAsync(): Promise<void>;
-  /**
-   * Drops a cached singleton/scoped instance for `bindingId` and runs `onDeactivation` synchronously.
-   */
-  releaseByBindingId(bindingId: BindingIdentifier): void;
-  /**
-   * Drops a cached singleton/scoped instance for `bindingId` and awaits `onDeactivation`.
-   */
-  releaseByBindingIdAsync(bindingId: BindingIdentifier): Promise<void>;
-  /**
-   * Drops a cached singleton/scoped instance for `binding.id` and runs `onDeactivation` synchronously.
-   */
-  releaseBinding(binding: Binding<unknown>): void;
-  /**
-   * Drops a cached singleton/scoped instance for `binding.id` and awaits `onDeactivation`.
-   */
-  releaseBindingAsync(binding: Binding<unknown>): Promise<void>;
-  /**
-   * Removes a single entry from `store`, runs `onDeactivation` synchronously, then calls
-   * `@preDestroy`. Throws {@link InternalError} if the handler returns a Promise.
-   */
-  private releaseFromStore;
-  /**
-   * Async counterpart of {@link releaseFromStore}: awaits `onDeactivation` then `@preDestroy`.
-   */
-  private releaseFromStoreAsync;
-  /**
-   * Iterates all entries in `store`, clears each one, runs `onDeactivation` + `@preDestroy`
-   * synchronously. Throws {@link InternalError} if any handler returns a Promise.
-   */
-  private disposeMap;
-  /**
-   * Async counterpart of {@link disposeMap}: clears the store first, then runs all
-   * deactivation hooks; collects errors and rethrows as `AggregateError` when multiple fail.
-   */
-  private disposeMapAsync;
+  private readonly _singletons;
+  private readonly _inflight;
+  private readonly _scoped;
+  readonly isChild: boolean;
+  constructor(isChild?: boolean);
+  hasSingleton(id: BindingIdentifier): boolean;
+  getSingleton<Value>(id: BindingIdentifier): Value;
+  setSingleton(id: BindingIdentifier, instance: unknown): void;
+  deleteSingleton(id: BindingIdentifier): boolean;
+  getAllSingletons(): ReadonlyMap<BindingIdentifier, unknown>;
+  getInflight(id: BindingIdentifier): Promise<unknown> | undefined;
+  setInflight(id: BindingIdentifier, p: Promise<unknown>): void;
+  clearInflight(id: BindingIdentifier): void;
+  hasScoped(id: BindingIdentifier): boolean;
+  getScoped<Value>(id: BindingIdentifier): Value;
+  setScoped(id: BindingIdentifier, instance: unknown): void;
+  getAllScoped(): ReadonlyMap<BindingIdentifier, unknown>;
+  clearAll(): void;
 }
 //#endregion
 export { ScopeManager };

package/dist/scope.mjs

@@ -1,213 +1,54 @@
-import { InternalError } from "./errors.mjs";
-import { isPromiseLike, runPreDestroy, runPreDestroyAsync } from "./lifecycle.mjs";
+import { MissingScopeContextError } from "./errors.mjs";
 //#region src/scope.ts
-/**
-* Caches singleton and scoped instances, deduplicates concurrent async creation, and runs
-* deactivation hooks (`onDeactivation`, `@preDestroy`) on disposal.
-*
-* A root scope manager owns both singleton and scoped caches. A child scope manager (created
-* via {@link createChildScope}) shares the parent's singleton cache but receives a fresh scoped
-* cache — singletons are shared across the hierarchy, scoped instances are isolated per child.
-*
-* Invariant: `ownsSingletonDisposal` is `true` only for the root. When a child disposes, only
-* its scoped bindings are deactivated; singletons remain alive until the root disposes.
-*/
-var ScopeManager = class ScopeManager {
-	/**
-	* Cached singleton instances: `bindingId → { binding, instance }`.
-	*/
-	singletonCache;
-	/**
-	* Cached scoped instances for this container level: `bindingId → { binding, instance }`.
-	*/
-	scopedCache;
-	/**
-	* True only for the root scope manager. Controls whether {@link dispose} / {@link disposeAsync}
-	* also drain the shared singleton cache; child scopes leave singleton disposal to the root.
-	*/
-	ownsSingletonDisposal;
-	/**
-	* In-flight async singleton creation promises.
-	* Guards against double-instantiation when multiple `resolveAsync` calls for the same
-	* singleton binding overlap before the first one settles.
-	*/
-	singletonPendingPromises;
-	/**
-	* In-flight async scoped creation promises (same deduplication role as
-	* {@link singletonPendingPromises} but for scoped bindings).
-	*/
-	scopedPendingPromises;
-	/**
-	* Internal constructor for root/child scope managers.
-	* Prefer {@link createRoot} and {@link createChildScope}.
-	*/
-	constructor(singletonCache, scopedCache, ownsSingletonDisposal, singletonPendingPromises, scopedPendingPromises) {
-		this.singletonCache = singletonCache;
-		this.scopedCache = scopedCache;
-		this.ownsSingletonDisposal = ownsSingletonDisposal;
-		this.singletonPendingPromises = singletonPendingPromises;
-		this.scopedPendingPromises = scopedPendingPromises;
+var ScopeManager = class {
+	_singletons = /* @__PURE__ */ new Map();
+	_inflight = /* @__PURE__ */ new Map();
+	_scoped = /* @__PURE__ */ new Map();
+	isChild;
+	constructor(isChild = false) {
+		this.isChild = isChild;
 	}
-	/**
-	* Creates a root scope manager that owns both the singleton cache and scoped cache.
-	*/
-	static createRoot() {
-		return new ScopeManager(/* @__PURE__ */ new Map(), /* @__PURE__ */ new Map(), true, /* @__PURE__ */ new Map(), /* @__PURE__ */ new Map());
+	hasSingleton(id) {
+		return this._singletons.has(id);
 	}
-	/**
-	* Shares the parent singleton cache; receives a fresh scoped cache (for child containers).
-	*/
-	createChildScope() {
-		return new ScopeManager(this.singletonCache, /* @__PURE__ */ new Map(), false, this.singletonPendingPromises, /* @__PURE__ */ new Map());
+	getSingleton(id) {
+		return this._singletons.get(id);
 	}
-	/**
-	* Whether a singleton/scoped binding currently has a cached instance (always false for transient).
-	*/
-	isBindingCached(binding) {
-		if (binding.scope === "transient") return false;
-		return (binding.scope === "singleton" ? this.singletonCache : this.scopedCache).has(binding.id);
+	setSingleton(id, instance) {
+		this._singletons.set(id, instance);
 	}
-	/**
-	* Returns the cached instance for singleton/scoped bindings, or calls `createInstance` on first access.
-	*/
-	getOrCreate(binding, createInstance) {
-		if (binding.scope === "transient") return createInstance();
-		const cache = binding.scope === "singleton" ? this.singletonCache : this.scopedCache;
-		const cached = cache.get(binding.id);
-		if (cached !== void 0) return cached.instance;
-		const instance = createInstance();
-		cache.set(binding.id, {
-			binding,
-			instance
-		});
-		return instance;
+	deleteSingleton(id) {
+		return this._singletons.delete(id);
 	}
-	/**
-	* Async variant of {@link getOrCreate}. Deduplicates concurrent creation calls for the same
-	* binding using an in-flight promise map, preventing double-instantiation under parallel resolves.
-	*/
-	async getOrCreateAsync(binding, createInstance) {
-		if (binding.scope === "transient") return createInstance();
-		const cache = binding.scope === "singleton" ? this.singletonCache : this.scopedCache;
-		const pendingCreationMap = binding.scope === "singleton" ? this.singletonPendingPromises : this.scopedPendingPromises;
-		const cached = cache.get(binding.id);
-		if (cached !== void 0) return cached.instance;
-		let pendingCreation = pendingCreationMap.get(binding.id);
-		if (pendingCreation === void 0) {
-			pendingCreation = (async () => {
-				try {
-					const instance = await createInstance();
-					cache.set(binding.id, {
-						binding,
-						instance
-					});
-					return instance;
-				} finally {
-					pendingCreationMap.delete(binding.id);
-				}
-			})();
-			pendingCreationMap.set(binding.id, pendingCreation);
-		}
-		return pendingCreation;
+	getAllSingletons() {
+		return this._singletons;
 	}
-	/**
-	* Runs synchronous `onDeactivation` hooks for scoped instances owned by this manager.
-	* Throws if any hook returns a Promise.
-	*/
-	dispose() {
-		this.disposeMap(this.scopedCache);
-		if (this.ownsSingletonDisposal) this.disposeMap(this.singletonCache);
+	getInflight(id) {
+		return this._inflight.get(id);
 	}
-	/**
-	* Runs `onDeactivation` hooks for scoped instances; root also disposes shared singletons.
-	*/
-	async disposeAsync() {
-		await this.disposeMapAsync(this.scopedCache);
-		if (this.ownsSingletonDisposal) await this.disposeMapAsync(this.singletonCache);
+	setInflight(id, p) {
+		this._inflight.set(id, p);
 	}
-	/**
-	* Drops a cached singleton/scoped instance for `bindingId` and runs `onDeactivation` synchronously.
-	*/
-	releaseByBindingId(bindingId) {
-		this.releaseFromStore(this.singletonCache, bindingId);
-		this.releaseFromStore(this.scopedCache, bindingId);
+	clearInflight(id) {
+		this._inflight.delete(id);
 	}
-	/**
-	* Drops a cached singleton/scoped instance for `bindingId` and awaits `onDeactivation`.
-	*/
-	async releaseByBindingIdAsync(bindingId) {
-		await this.releaseFromStoreAsync(this.singletonCache, bindingId);
-		await this.releaseFromStoreAsync(this.scopedCache, bindingId);
+	hasScoped(id) {
+		return this._scoped.has(id);
 	}
-	/**
-	* Drops a cached singleton/scoped instance for `binding.id` and runs `onDeactivation` synchronously.
-	*/
-	releaseBinding(binding) {
-		this.releaseByBindingId(binding.id);
+	getScoped(id) {
+		return this._scoped.get(id);
 	}
-	/**
-	* Drops a cached singleton/scoped instance for `binding.id` and awaits `onDeactivation`.
-	*/
-	async releaseBindingAsync(binding) {
-		await this.releaseByBindingIdAsync(binding.id);
+	setScoped(id, instance) {
+		if (!this.isChild) throw new MissingScopeContextError("(unknown)");
+		this._scoped.set(id, instance);
 	}
-	/**
-	* Removes a single entry from `store`, runs `onDeactivation` synchronously, then calls
-	* `@preDestroy`. Throws {@link InternalError} if the handler returns a Promise.
-	*/
-	releaseFromStore(store, bindingId) {
-		const entry = store.get(bindingId);
-		if (entry === void 0) return;
-		store.delete(bindingId);
-		const handler = entry.binding.onDeactivation;
-		if (handler !== void 0) {
-			if (isPromiseLike(handler(entry.instance))) throw new InternalError("onDeactivation returned a Promise during synchronous scope release; use releaseBindingAsync() or unloadAsync().");
-		}
-		if (entry.binding.kind === "class") runPreDestroy(entry.binding.implementationClass, entry.instance);
+	getAllScoped() {
+		return this._scoped;
 	}
-	/**
-	* Async counterpart of {@link releaseFromStore}: awaits `onDeactivation` then `@preDestroy`.
-	*/
-	async releaseFromStoreAsync(store, bindingId) {
-		const entry = store.get(bindingId);
-		if (entry === void 0) return;
-		store.delete(bindingId);
-		const handler = entry.binding.onDeactivation;
-		if (handler !== void 0) await handler(entry.instance);
-		if (entry.binding.kind === "class") await runPreDestroyAsync(entry.binding.implementationClass, entry.instance);
-	}
-	/**
-	* Iterates all entries in `store`, clears each one, runs `onDeactivation` + `@preDestroy`
-	* synchronously. Throws {@link InternalError} if any handler returns a Promise.
-	*/
-	disposeMap(store) {
-		const entries = [...store.values()];
-		store.clear();
-		for (const entry of entries) {
-			const handler = entry.binding.onDeactivation;
-			if (handler !== void 0) {
-				if (isPromiseLike(handler(entry.instance))) throw new InternalError("onDeactivation returned a Promise; use disposeAsync() instead of dispose().");
-			}
-			if (entry.binding.kind === "class") runPreDestroy(entry.binding.implementationClass, entry.instance);
-		}
-	}
-	/**
-	* Async counterpart of {@link disposeMap}: clears the store first, then runs all
-	* deactivation hooks; collects errors and rethrows as `AggregateError` when multiple fail.
-	*/
-	async disposeMapAsync(store) {
-		const entries = [...store.values()];
-		store.clear();
-		const errors = [];
-		for (const entry of entries) try {
-			const handler = entry.binding.onDeactivation;
-			if (handler !== void 0) await handler(entry.instance);
-			if (entry.binding.kind === "class") await runPreDestroyAsync(entry.binding.implementationClass, entry.instance);
-		} catch (error) {
-			errors.push(error);
-		}
-		if (errors.length === 1) throw errors[0];
-		if (errors.length > 1) throw new AggregateError(errors, "disposeAsync: multiple deactivation handlers failed");
+	clearAll() {
+		this._singletons.clear();
+		this._inflight.clear();
+		this._scoped.clear();
 	}
 };
 //#endregion

package/dist/token.d.mts

@@ -1,27 +1,13 @@
+import { Constructor } from "./constructor-type.mjs";
+
 //#region src/token.d.ts
 declare const TOKEN_BRAND: unique symbol;
-/**
- * Opaque injection key branded by `Value` so distinct tokens do not unify in the type system.
- * Registry keys rely on **reference equality** — always reuse the same `token()` result as the key.
- */
-type Token<Value> = {
-  readonly [TOKEN_BRAND]: Value;
+interface Token<Value> {
   readonly name: string;
-};
-/**
- * Extracts the value type carried by a {@link Token} or the instance type of a {@link Constructor}.
- * Falls through to `never` for types that are neither a token nor a constructor.
- */
-type TokenValue<Type> = Type extends Token<infer Value> ? Value : Type extends (abstract new (...args: never[]) => infer Value) ? Value : never;
-/**
- * Creates a frozen, type-safe injection token identified by `name`.
- *
- * The returned object is `Object.freeze`-d; `name` is used only for debugging and error
- * messages — binding lookup relies on **reference equality** of the token object.
- * Store the return value in a module-level `const` and import it wherever needed.
- *
- * @param name - Human-readable label (appears in error messages, graph output, and debug snapshots).
- */
+  readonly [TOKEN_BRAND]: Value;
+}
 declare function token<Value>(name: string): Token<Value>;
+declare function tokenName(t: Token<unknown> | Constructor): string;
+declare function isToken(value: unknown): value is Token<unknown>;
 //#endregion
-export { Token, TokenValue, token };
+export { Token, isToken, token, tokenName };

package/dist/token.mjs

@@ -1,15 +1,13 @@
 //#region src/token.ts
-/**
-* Creates a frozen, type-safe injection token identified by `name`.
-*
-* The returned object is `Object.freeze`-d; `name` is used only for debugging and error
-* messages — binding lookup relies on **reference equality** of the token object.
-* Store the return value in a module-level `const` and import it wherever needed.
-*
-* @param name - Human-readable label (appears in error messages, graph output, and debug snapshots).
-*/
 function token(name) {
-	return Object.freeze({ name });
+	return { name };
+}
+function tokenName(t) {
+	if (typeof t === "function") return t.name;
+	return t.name;
+}
+function isToken(value) {
+	return typeof value === "object" && value !== null && "name" in value && typeof value["name"] === "string" && typeof value !== "function";
 }
 //#endregion
-export { token };
+export { isToken, token, tokenName };

package/dist/types.d.mts

@@ -0,0 +1,48 @@
+import { Constructor } from "./constructor-type.mjs";
+import { Token } from "./token.mjs";
+
+//#region src/types.d.ts
+/** Token or class constructor used as a binding / injection / resolve key. */
+type DependencyKey = Token<unknown> | Constructor;
+type BindingScope = "singleton" | "transient" | "scoped";
+declare const BINDING_ID_BRAND: unique symbol;
+type BindingIdentifier = string & {
+  readonly [BINDING_ID_BRAND]: true;
+};
+type BindingKind = "class" | "dynamic" | "dynamic-async" | "resolved" | "resolved-async" | "constant" | "alias";
+type ActivationHandler<Value> = (ctx: ResolutionContext, instance: Value) => Value | Promise<Value>;
+type DeactivationHandler<Value> = (instance: Value) => void | Promise<void>;
+interface ResolveOptions {
+  name?: string;
+  tag?: readonly [tag: string, value: unknown];
+  tags?: ReadonlyArray<readonly [tag: string, value: unknown]>;
+}
+interface MaterializationFrame {
+  readonly tokenName: string;
+  readonly scope: BindingScope;
+  readonly bindingId: BindingIdentifier;
+  readonly kind: BindingKind;
+  readonly slot: {
+    readonly name: string | undefined;
+    readonly tags: ReadonlyArray<readonly [tag: string, value: unknown]>;
+  };
+}
+interface ConstraintContext {
+  readonly resolutionPath: readonly string[];
+  readonly materializationStack: readonly MaterializationFrame[];
+  readonly parent: MaterializationFrame | undefined;
+  readonly ancestors: readonly MaterializationFrame[];
+  readonly currentResolveHint: ResolveOptions | undefined;
+}
+interface ResolutionContext {
+  resolve<const Value>(token: Token<Value> | Constructor<Value>, hint?: ResolveOptions): Value;
+  resolveAsync<const Value>(token: Token<Value> | Constructor<Value>, hint?: ResolveOptions): Promise<Value>;
+  resolveOptional<const Value>(token: Token<Value> | Constructor<Value>, hint?: ResolveOptions): Value | undefined;
+  resolveOptionalAsync<const Value>(token: Token<Value> | Constructor<Value>, hint?: ResolveOptions): Promise<Value | undefined>;
+  resolveAll<const Value>(token: Token<Value> | Constructor<Value>, hint?: ResolveOptions): Value[];
+  resolveAllAsync<const Value>(token: Token<Value> | Constructor<Value>, hint?: ResolveOptions): Promise<Value[]>;
+  readonly graph: ConstraintContext;
+}
+type TokenValue<Type> = Type extends Token<infer Value> ? Value : Type extends Constructor<infer Value> ? Value : never;
+//#endregion
+export { ActivationHandler, BindingIdentifier, BindingKind, BindingScope, ConstraintContext, type Constructor, DeactivationHandler, DependencyKey, MaterializationFrame, ResolutionContext, ResolveOptions, TokenValue };

package/dist/types.mjs

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codefast/di",
-  "version": "0.3.14-canary.1",
+  "version": "0.3.14",
   "description": "Lightweight dependency injection primitives for Codefast",
   "keywords": [
     "codefast",
@@ -28,6 +28,13 @@
   "module": "./dist/index.mjs",
   "types": "./dist/index.d.mts",
   "imports": {
+    "#/tests/*": [
+      "./tests/*",
+      "./tests/*.ts",
+      "./tests/*.tsx",
+      "./tests/*/index.ts",
+      "./tests/*/index.tsx"
+    ],
     "#/*": [
       "./src/*",
       "./src/*.ts",
@@ -45,6 +52,10 @@
       "types": "./dist/binding.d.mts",
       "import": "./dist/binding.mjs"
     },
+    "./binding-scope": {
+      "types": "./dist/binding-scope.d.mts",
+      "import": "./dist/binding-scope.mjs"
+    },
     "./binding-select": {
       "types": "./dist/binding-select.d.mts",
       "import": "./dist/binding-select.mjs"
@@ -53,6 +64,10 @@
       "types": "./dist/constraints.d.mts",
       "import": "./dist/constraints.mjs"
     },
+    "./constructor-type": {
+      "types": "./dist/constructor-type.d.mts",
+      "import": "./dist/constructor-type.mjs"
+    },
     "./container": {
       "types": "./dist/container.d.mts",
       "import": "./dist/container.mjs"
@@ -109,14 +124,14 @@
       "types": "./dist/metadata/metadata-keys.d.mts",
       "import": "./dist/metadata/metadata-keys.mjs"
     },
+    "./metadata/metadata-reader-token": {
+      "types": "./dist/metadata/metadata-reader-token.d.mts",
+      "import": "./dist/metadata/metadata-reader-token.mjs"
+    },
     "./metadata/metadata-types": {
       "types": "./dist/metadata/metadata-types.d.mts",
       "import": "./dist/metadata/metadata-types.mjs"
     },
-    "./metadata/param-registry": {
-      "types": "./dist/metadata/param-registry.d.mts",
-      "import": "./dist/metadata/param-registry.mjs"
-    },
     "./metadata/symbol-metadata-reader": {
       "types": "./dist/metadata/symbol-metadata-reader.d.mts",
       "import": "./dist/metadata/symbol-metadata-reader.mjs"
@@ -129,6 +144,10 @@
       "types": "./dist/registry.d.mts",
       "import": "./dist/registry.mjs"
     },
+    "./resolve-options": {
+      "types": "./dist/resolve-options.d.mts",
+      "import": "./dist/resolve-options.mjs"
+    },
     "./resolver": {
       "types": "./dist/resolver.d.mts",
       "import": "./dist/resolver.mjs"
@@ -137,14 +156,14 @@
       "types": "./dist/scope.d.mts",
       "import": "./dist/scope.mjs"
     },
-    "./scope-validation": {
-      "types": "./dist/scope-validation.d.mts",
-      "import": "./dist/scope-validation.mjs"
-    },
     "./token": {
       "types": "./dist/token.d.mts",
       "import": "./dist/token.mjs"
     },
+    "./types": {
+      "types": "./dist/types.d.mts",
+      "import": "./dist/types.mjs"
+    },
     "./package.json": "./package.json"
   },
   "publishConfig": {
@@ -152,12 +171,13 @@
   },
   "devDependencies": {
     "@types/node": "^25.6.0",
-    "@typescript/native-preview": "7.0.0-dev.20260411.1",
-    "@vitest/coverage-v8": "^4.1.4",
-    "typescript": "^6.0.2",
+    "@typescript/native-preview": "7.0.0-dev.20260422.1",
+    "@vitest/coverage-v8": "^4.1.5",
+    "expect-type": "^1.3.0",
+    "typescript": "^6.0.3",
     "unplugin-swc": "^1.5.9",
-    "vitest": "^4.1.4",
-    "@codefast/typescript-config": "0.3.14-canary.1"
+    "vitest": "^4.1.5",
+    "@codefast/typescript-config": "0.3.14"
   },
   "engines": {
     "node": ">=22.0.0"
@@ -166,6 +186,8 @@
     "build": "tsdown",
     "check-types": "tsgo --noEmit",
     "clean": "rm -rf dist",
+    "examples": "for file in examples/*/*.ts; do echo \"=== Running $file ===\"; tsx \"$file\"; echo \"\n\" || exit 1; done",
+    "bench": "vitest bench --run",
     "test": "vitest run",
     "test:coverage": "vitest run --coverage",
     "test:watch": "vitest"

package/dist/metadata/param-registry.d.mts

@@ -1,16 +0,0 @@
-import { Constructor } from "../binding.mjs";
-import { ParamMetadata } from "./metadata-types.mjs";
-
-//#region src/metadata/param-registry.d.ts
-/**
- * Returns the pending `ParamMetadata` map for `implementationClass`, creating it on first access.
- * Used by legacy parameter decorators that fire before the class decorator runs.
- */
-declare function getOrCreatePendingMap(implementationClass: Constructor<unknown>): Map<number, ParamMetadata>;
-/**
- * Removes and returns the pending map for `implementationClass` (transfer of ownership).
- * Returns `undefined` if no pending entries exist.
- */
-declare function takePendingMap(implementationClass: Constructor<unknown>): Map<number, ParamMetadata> | undefined;
-//#endregion
-export { getOrCreatePendingMap, takePendingMap };

package/dist/metadata/param-registry.mjs

@@ -1,31 +0,0 @@
-//#region src/metadata/param-registry.ts
-/**
-* WeakMap keyed by constructor → pending parameter metadata.
-* Entries are populated by legacy parameter decorators that fire *before* the
-* `@injectable()` class decorator runs, and consumed (via {@link takePendingMap})
-* by the class decorator to merge into the final {@link ConstructorMetadata}.
-*/
-const pendingByConstructor = /* @__PURE__ */ new WeakMap();
-/**
-* Returns the pending `ParamMetadata` map for `implementationClass`, creating it on first access.
-* Used by legacy parameter decorators that fire before the class decorator runs.
-*/
-function getOrCreatePendingMap(implementationClass) {
-	let map = pendingByConstructor.get(implementationClass);
-	if (!map) {
-		map = /* @__PURE__ */ new Map();
-		pendingByConstructor.set(implementationClass, map);
-	}
-	return map;
-}
-/**
-* Removes and returns the pending map for `implementationClass` (transfer of ownership).
-* Returns `undefined` if no pending entries exist.
-*/
-function takePendingMap(implementationClass) {
-	const map = pendingByConstructor.get(implementationClass);
-	if (map) pendingByConstructor.delete(implementationClass);
-	return map;
-}
-//#endregion
-export { getOrCreatePendingMap, takePendingMap };