sandly 0.0.2 → 0.1.0

package/dist/index.js

@@ -1,6 +1,7 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 
 //#region src/tag.ts
+Symbol("InjectSource");
 /**
 * Internal symbol used to identify tagged types within the dependency injection system.
 * This symbol is used as a property key to attach metadata to both value tags and class tags.
@@ -31,8 +32,6 @@ const Tag = {
 		class Tagged {
 			static [TagId] = id;
 			[TagId] = id;
-			/** @internal */
-			__type;
 		}
 		return Tagged;
 	},
@@ -89,14 +88,30 @@ var BaseError = class BaseError extends Error {
 * try {
 *   await container.get(SomeService);
 * } catch (error) {
-*   if (error instanceof DependencyContainerError) {
+*   if (error instanceof ContainerError) {
 *     console.error('DI Error:', error.message);
 *     console.error('Details:', error.detail);
 *   }
 * }
 * ```
 */
-var DependencyContainerError = class extends BaseError {};
+var ContainerError = class extends BaseError {};
+/**
+* Error thrown when attempting to register a dependency that has already been instantiated.
+*
+* This error occurs when calling `container.register()` for a tag that has already been instantiated.
+* Registration must happen before any instantiation occurs, as cached instances would still be used
+* by existing dependencies.
+*/
+var DependencyAlreadyInstantiatedError = class extends ContainerError {};
+/**
+* Error thrown when attempting to use a container that has been destroyed.
+*
+* This error occurs when calling `container.get()`, `container.register()`, or `container.destroy()`
+* on a container that has already been destroyed. It indicates a programming error where the container
+* is being used after it has been destroyed.
+*/
+var ContainerDestroyedError = class extends ContainerError {};
 /**
 * Error thrown when attempting to retrieve a dependency that hasn't been registered.
 *
@@ -117,7 +132,7 @@ var DependencyContainerError = class extends BaseError {};
 * }
 * ```
 */
-var UnknownDependencyError = class extends DependencyContainerError {
+var UnknownDependencyError = class extends ContainerError {
 	/**
 	* @internal
 	* Creates an UnknownDependencyError for the given tag.
@@ -141,11 +156,11 @@ var UnknownDependencyError = class extends DependencyContainerError {
 * class ServiceB extends Tag.Class('ServiceB') {}
 *
 * const c = container()
-*   .register(ServiceA, async (container) =>
-*     new ServiceA(await container.get(ServiceB)) // Depends on B
+*   .register(ServiceA, async (ctx) =>
+*     new ServiceA(await ctx.get(ServiceB)) // Depends on B
 *   )
-*   .register(ServiceB, async (container) =>
-*     new ServiceB(await container.get(ServiceA)) // Depends on A - CIRCULAR!
+*   .register(ServiceB, async (ctx) =>
+*     new ServiceB(await ctx.get(ServiceA)) // Depends on A - CIRCULAR!
 *   );
 *
 * try {
@@ -158,7 +173,7 @@ var UnknownDependencyError = class extends DependencyContainerError {
 * }
 * ```
 */
-var CircularDependencyError = class extends DependencyContainerError {
+var CircularDependencyError = class extends ContainerError {
 	/**
 	* @internal
 	* Creates a CircularDependencyError with the dependency chain information.
@@ -198,7 +213,7 @@ var CircularDependencyError = class extends DependencyContainerError {
 * }
 * ```
 */
-var DependencyCreationError = class extends DependencyContainerError {
+var DependencyCreationError = class extends ContainerError {
 	/**
 	* @internal
 	* Creates a DependencyCreationError wrapping the original factory error.
@@ -207,7 +222,7 @@ var DependencyCreationError = class extends DependencyContainerError {
 	* @param error - The original error thrown by the factory function
 	*/
 	constructor(tag, error) {
-		super(`Error creating instance of ${Tag.id(tag)}: ${error}`, {
+		super(`Error creating instance of ${Tag.id(tag)}`, {
 			cause: error,
 			detail: { tag: Tag.id(tag) }
 		});
@@ -225,17 +240,17 @@ var DependencyCreationError = class extends DependencyContainerError {
 * try {
 *   await container.destroy();
 * } catch (error) {
-*   if (error instanceof DependencyContainerFinalizationError) {
+*   if (error instanceof DependencyFinalizationError) {
 *     console.error('Some finalizers failed');
 *     console.error('Error details:', error.detail.errors);
 *   }
 * }
 * ```
 */
-var DependencyContainerFinalizationError = class extends DependencyContainerError {
+var DependencyFinalizationError = class extends ContainerError {
 	/**
 	* @internal
-	* Creates a DependencyContainerFinalizationError aggregating multiple finalizer failures.
+	* Creates a DependencyFinalizationError aggregating multiple finalizer failures.
 	*
 	* @param errors - Array of errors thrown by individual finalizers
 	*/
@@ -257,46 +272,6 @@ var DependencyContainerFinalizationError = class extends DependencyContainerErro
 */
 const resolutionChain = new AsyncLocalStorage();
 /**
-* Shared logic for dependency resolution that handles caching, circular dependency detection,
-* and error handling. Used by both BasicDependencyContainer and ScopedDependencyContainer.
-* @internal
-*/
-async function resolveDependency(tag, cache, factories, container$1) {
-	const cached = cache.get(tag);
-	if (cached !== void 0) return cached;
-	const currentChain = resolutionChain.getStore() ?? [];
-	if (currentChain.includes(tag)) throw new CircularDependencyError(tag, currentChain);
-	const factory = factories.get(tag);
-	if (factory === void 0) return Promise.reject(new UnknownDependencyError(tag));
-	const instancePromise = resolutionChain.run([...currentChain, tag], async () => {
-		try {
-			const instance = await factory(container$1);
-			return instance;
-		} catch (error) {
-			if (error instanceof CircularDependencyError) throw error;
-			throw new DependencyCreationError(tag, error);
-		}
-	}).catch((error) => {
-		cache.delete(tag);
-		throw error;
-	});
-	cache.set(tag, instancePromise);
-	return instancePromise;
-}
-/**
-* Shared logic for running finalizers and handling cleanup errors.
-* @internal
-*/
-async function runFinalizers(finalizers, cache) {
-	const promises = Array.from(finalizers.entries()).filter(([tag]) => cache.has(tag)).map(async ([tag, finalizer]) => {
-		const dep = await cache.get(tag);
-		return finalizer(dep);
-	});
-	const results = await Promise.allSettled(promises);
-	const failures = results.filter((result) => result.status === "rejected");
-	if (failures.length > 0) throw new DependencyContainerFinalizationError(failures.map((result) => result.reason));
-}
-/**
 * A type-safe dependency injection container that manages service instantiation,
 * caching, and lifecycle management with support for async dependencies and
 * circular dependency detection.
@@ -309,7 +284,7 @@ async function runFinalizers(finalizers, cache) {
 *
 * @example Basic usage with class tags
 * ```typescript
-* import { container, Tag } from 'sandl';
+* import { container, Tag } from 'sandly';
 *
 * class DatabaseService extends Tag.Class('DatabaseService') {
 *   query() { return 'data'; }
@@ -322,8 +297,8 @@ async function runFinalizers(finalizers, cache) {
 *
 * const c = container()
 *   .register(DatabaseService, () => new DatabaseService())
-*   .register(UserService, async (container) =>
-*     new UserService(await container.get(DatabaseService))
+*   .register(UserService, async (ctx) =>
+*     new UserService(await ctx.get(DatabaseService))
 *   );
 *
 * const userService = await c.get(UserService);
@@ -363,7 +338,7 @@ async function runFinalizers(finalizers, cache) {
 * await c.destroy(); // Calls all finalizers
 * ```
 */
-var Container = class {
+var Container = class Container {
 	/**
 	* Cache of instantiated dependencies as promises.
 	* Ensures singleton behavior and supports concurrent access.
@@ -381,18 +356,27 @@ var Container = class {
 	*/
 	finalizers = /* @__PURE__ */ new Map();
 	/**
+	* Flag indicating whether this container has been destroyed.
+	* @internal
+	*/
+	isDestroyed = false;
+	/**
 	* Registers a dependency in the container with a factory function and optional finalizer.
 	*
 	* The factory function receives the current container instance and must return the
 	* service instance (or a Promise of it). The container tracks the registration at
 	* the type level, ensuring type safety for subsequent `.get()` calls.
 	*
+	* If a dependency is already registered, this method will override it unless the
+	* dependency has already been instantiated, in which case it will throw an error.
+	*
 	* @template T - The dependency tag being registered
 	* @param tag - The dependency tag (class or value tag)
 	* @param factory - Function that creates the service instance, receives container for dependency injection
 	* @param finalizer - Optional cleanup function called when container is destroyed
 	* @returns A new container instance with the dependency registered
-	* @throws {DependencyContainerError} If the dependency is already registered
+	* @throws {ContainerDestroyedError} If the container has been destroyed
+	* @throws {Error} If the dependency has already been instantiated
 	*
 	* @example Registering a simple service
 	* ```typescript
@@ -415,14 +399,21 @@ var Container = class {
 	* const c = container()
 	*   .register(DatabaseService, () => new DatabaseService())
 	*   .register(LoggerService, () => new LoggerService())
-	*   .register(UserService, async (container) =>
+	*   .register(UserService, async (ctx) =>
 	*     new UserService(
-	*       await container.get(DatabaseService),
-	*       await container.get(LoggerService)
+	*       await ctx.get(DatabaseService),
+	*       await ctx.get(LoggerService)
 	*     )
 	*   );
 	* ```
 	*
+	* @example Overriding a dependency
+	* ```typescript
+	* const c = container()
+	*   .register(DatabaseService, () => new DatabaseService())
+	*   .register(DatabaseService, () => new MockDatabaseService()); // Overrides the previous registration
+	* ```
+	*
 	* @example Using value tags
 	* ```typescript
 	* const ConfigTag = Tag.of('config')<{ apiUrl: string }>();
@@ -451,35 +442,43 @@ var Container = class {
 	* );
 	* ```
 	*/
-	register(tag, factoryOrLifecycle) {
-		if (this.factories.has(tag)) throw new DependencyContainerError(`Dependency ${Tag.id(tag)} already registered`);
-		if (typeof factoryOrLifecycle === "function") this.factories.set(tag, factoryOrLifecycle);
-		else {
-			this.factories.set(tag, factoryOrLifecycle.factory);
-			this.finalizers.set(tag, factoryOrLifecycle.finalizer);
+	register(tag, spec) {
+		if (this.isDestroyed) throw new ContainerDestroyedError("Cannot register dependencies on a destroyed container");
+		if (this.has(tag) && this.exists(tag)) throw new DependencyAlreadyInstantiatedError(`Cannot register dependency ${Tag.id(tag)} - it has already been instantiated. Registration must happen before any instantiation occurs, as cached instances would still be used by existing dependencies.`);
+		if (typeof spec === "function") {
+			this.factories.set(tag, spec);
+			this.finalizers.delete(tag);
+		} else {
+			this.factories.set(tag, spec.factory);
+			this.finalizers.set(tag, spec.finalizer);
 		}
 		return this;
 	}
 	/**
-	* Checks if a dependency has been instantiated (cached) in the container.
+	* Checks if a dependency has been registered in the container.
 	*
-	* Note: This returns `true` only after the dependency has been created via `.get()`.
-	* A registered but not-yet-instantiated dependency will return `false`.
+	* This returns `true` if the dependency has been registered via `.register()`,
+	* regardless of whether it has been instantiated yet.
 	*
 	* @param tag - The dependency tag to check
-	* @returns `true` if the dependency has been instantiated and cached, `false` otherwise
+	* @returns `true` if the dependency has been registered, `false` otherwise
 	*
 	* @example
 	* ```typescript
 	* const c = container().register(DatabaseService, () => new DatabaseService());
-	*
-	* console.log(c.has(DatabaseService)); // false - not instantiated yet
-	*
-	* await c.get(DatabaseService);
-	* console.log(c.has(DatabaseService)); // true - now instantiated and cached
+	* console.log(c.has(DatabaseService)); // true
 	* ```
 	*/
 	has(tag) {
+		return this.factories.has(tag);
+	}
+	/**
+	* Checks if a dependency has been instantiated (cached) in the container.
+	*
+	* @param tag - The dependency tag to check
+	* @returns true if the dependency has been instantiated, false otherwise
+	*/
+	exists(tag) {
 		return this.cache.has(tag);
 	}
 	/**
@@ -524,8 +523,8 @@ var Container = class {
 	* ```typescript
 	* const c = container()
 	*   .register(DatabaseService, () => new DatabaseService())
-	*   .register(UserService, async (container) => {
-	*     const db = await container.get(DatabaseService);
+	*   .register(UserService, async (ctx) => {
+	*     const db = await ctx.get(DatabaseService);
 	*     return new UserService(db);
 	*   });
 	*
@@ -533,14 +532,84 @@ var Container = class {
 	* ```
 	*/
 	async get(tag) {
-		return resolveDependency(tag, this.cache, this.factories, this);
+		if (this.isDestroyed) throw new ContainerDestroyedError("Cannot resolve dependencies from a destroyed container");
+		const cached = this.cache.get(tag);
+		if (cached !== void 0) return cached;
+		const currentChain = resolutionChain.getStore() ?? [];
+		if (currentChain.includes(tag)) throw new CircularDependencyError(tag, currentChain);
+		const factory = this.factories.get(tag);
+		if (factory === void 0) throw new UnknownDependencyError(tag);
+		const instancePromise = resolutionChain.run([...currentChain, tag], async () => {
+			try {
+				const instance = await factory(this);
+				return instance;
+			} catch (error) {
+				throw new DependencyCreationError(tag, error);
+			}
+		}).catch((error) => {
+			this.cache.delete(tag);
+			throw error;
+		});
+		this.cache.set(tag, instancePromise);
+		return instancePromise;
+	}
+	/**
+	* Copies all registrations from this container to a target container.
+	*
+	* @internal
+	* @param target - The container to copy registrations to
+	* @throws {ContainerDestroyedError} If this container has been destroyed
+	*/
+	copyTo(target) {
+		if (this.isDestroyed) throw new ContainerDestroyedError("Cannot copy registrations from a destroyed container");
+		for (const [tag, factory] of this.factories) {
+			const finalizer = this.finalizers.get(tag);
+			if (finalizer) target.register(tag, {
+				factory,
+				finalizer
+			});
+			else target.register(tag, factory);
+		}
 	}
 	/**
-	* Destroys all instantiated dependencies by calling their finalizers, then clears the instance cache.
+	* Creates a new container by merging this container's registrations with another container.
 	*
-	* **Important: This method preserves the container structure (factories and finalizers) for reuse.**
-	* The container can be used again after destruction to create fresh instances following the same
-	* dependency patterns.
+	* This method creates a new container that contains all registrations from both containers.
+	* If there are conflicts (same dependency registered in both containers), this
+	* container's registration will take precedence.
+	*
+	* **Important**: Only the registrations are copied, not any cached instances.
+	* The new container starts with an empty instance cache.
+	*
+	* @param other - The container to merge with
+	* @returns A new container with combined registrations
+	* @throws {ContainerDestroyedError} If this container has been destroyed
+	*
+	* @example Merging containers
+	* ```typescript
+	* const container1 = container()
+	*   .register(DatabaseService, () => new DatabaseService());
+	*
+	* const container2 = container()
+	*   .register(UserService, () => new UserService());
+	*
+	* const merged = container1.merge(container2);
+	* // merged has both DatabaseService and UserService
+	* ```
+	*/
+	merge(other) {
+		if (this.isDestroyed) throw new ContainerDestroyedError("Cannot merge from a destroyed container");
+		const merged = new Container();
+		other.copyTo(merged);
+		this.copyTo(merged);
+		return merged;
+	}
+	/**
+	* Destroys all instantiated dependencies by calling their finalizers and makes the container unusable.
+	*
+	* **Important: After calling destroy(), the container becomes permanently unusable.**
+	* Any subsequent calls to register(), get(), or destroy() will throw a ContainerError.
+	* This ensures proper cleanup and prevents runtime errors from accessing destroyed resources.
 	*
 	* All finalizers for instantiated dependencies are called concurrently using Promise.allSettled()
 	* for maximum cleanup performance.
@@ -552,9 +621,9 @@ var Container = class {
 	* dependencies are cleaned up.
 	*
 	* @returns Promise that resolves when all cleanup is complete
-	* @throws {DependencyContainerFinalizationError} If any finalizers fail during cleanup
+	* @throws {DependencyFinalizationError} If any finalizers fail during cleanup
 	*
-	* @example Basic cleanup and reuse
+	* @example Basic cleanup
 	* ```typescript
 	* const c = container()
 	*   .register(DatabaseConnection,
@@ -566,24 +635,32 @@ var Container = class {
 	*     (conn) => conn.disconnect() // Finalizer
 	*   );
 	*
-	* // First use cycle
-	* const db1 = await c.get(DatabaseConnection);
-	* await c.destroy(); // Calls conn.disconnect(), clears cache
+	* const db = await c.get(DatabaseConnection);
+	* await c.destroy(); // Calls conn.disconnect(), container becomes unusable
 	*
-	* // Container can be reused - creates fresh instances
-	* const db2 = await c.get(DatabaseConnection); // New connection
-	* expect(db2).not.toBe(db1); // Different instances
+	* // This will throw an error
+	* try {
+	*   await c.get(DatabaseConnection);
+	* } catch (error) {
+	*   console.log(error.message); // "Cannot resolve dependencies from a destroyed container"
+	* }
 	* ```
 	*
-	* @example Multiple destroy/reuse cycles
+	* @example Application shutdown
 	* ```typescript
-	* const c = container().register(UserService, () => new UserService());
+	* const appContainer = container()
+	*   .register(DatabaseService, () => new DatabaseService())
+	*   .register(HTTPServer, async (ctx) => new HTTPServer(await ctx.get(DatabaseService)));
 	*
-	* for (let i = 0; i < 5; i++) {
-	*   const user = await c.get(UserService);
-	*   // ... use service ...
-	*   await c.destroy(); // Clean up, ready for next cycle
-	* }
+	* // During application shutdown
+	* process.on('SIGTERM', async () => {
+	*   try {
+	*     await appContainer.destroy(); // Clean shutdown of all services
+	*   } catch (error) {
+	*     console.error('Error during shutdown:', error);
+	*   }
+	*   process.exit(0);
+	* });
 	* ```
 	*
 	* @example Handling cleanup errors
@@ -595,143 +672,25 @@ var Container = class {
 	*     console.error('Some dependencies failed to clean up:', error.detail.errors);
 	*   }
 	* }
-	* // Container is still reusable even after finalizer errors
+	* // Container is destroyed regardless of finalizer errors
 	* ```
 	*/
 	async destroy() {
+		if (this.isDestroyed) return;
 		try {
-			await runFinalizers(this.finalizers, this.cache);
+			const promises = Array.from(this.finalizers.entries()).filter(([tag]) => this.cache.has(tag)).map(async ([tag, finalizer]) => {
+				const dep = await this.cache.get(tag);
+				return finalizer(dep);
+			});
+			const results = await Promise.allSettled(promises);
+			const failures = results.filter((result) => result.status === "rejected");
+			if (failures.length > 0) throw new DependencyFinalizationError(failures.map((result) => result.reason));
 		} finally {
+			this.isDestroyed = true;
 			this.cache.clear();
 		}
 	}
 };
-var ScopedContainer = class ScopedContainer {
-	scope;
-	parent;
-	children = [];
-	/**
-	* Cache of instantiated dependencies as promises for this scope.
-	* @internal
-	*/
-	cache = /* @__PURE__ */ new Map();
-	/**
-	* Factory functions for creating dependency instances in this scope.
-	* @internal
-	*/
-	factories = /* @__PURE__ */ new Map();
-	/**
-	* Finalizer functions for cleaning up dependencies when this scope is destroyed.
-	* @internal
-	*/
-	finalizers = /* @__PURE__ */ new Map();
-	constructor(parent, scope) {
-		this.parent = parent;
-		this.scope = scope;
-	}
-	/**
-	* Registers a dependency in the specified scope within this container's scope chain.
-	*
-	* If no scope is specified, registers in the current (leaf) scope. If a scope is specified,
-	* delegates to the parent container if the target scope doesn't match the current scope.
-	*
-	* This allows registering dependencies at different scope levels from any container
-	* in the scope chain, providing flexibility for dependency organization.
-	*
-	* @param tag - The dependency tag to register
-	* @param factory - Factory function to create the dependency
-	* @param finalizer - Optional cleanup function
-	* @param scope - Target scope for registration (defaults to current scope)
-	* @returns This container with updated type information
-	*
-	* @example Registering in different scopes
-	* ```typescript
-	* const runtime = scopedContainer('runtime');
-	* const request = runtime.child('request');
-	*
-	* // Register in current (request) scope
-	* request.register(RequestService, () => new RequestService());
-	*
-	* // Register in runtime scope from request container - delegates to parent
-	* request.register(DatabaseService, () => new DatabaseService(), undefined, 'runtime');
-	* ```
-	*/
-	register(tag, factoryOrLifecycle, scope) {
-		if (scope === void 0 || scope === this.scope) {
-			if (this.factories.has(tag)) throw new DependencyContainerError(`Dependency ${Tag.id(tag)} already registered in scope '${String(this.scope)}'`);
-			if (typeof factoryOrLifecycle === "function") this.factories.set(tag, factoryOrLifecycle);
-			else {
-				this.factories.set(tag, factoryOrLifecycle.factory);
-				this.finalizers.set(tag, factoryOrLifecycle.finalizer);
-			}
-			return this;
-		}
-		if (this.parent === null) throw new DependencyContainerError(`Scope '${String(scope)}' not found in container chain`);
-		this.parent.register(tag, factoryOrLifecycle, scope);
-		return this;
-	}
-	/**
-	* Checks if a dependency has been instantiated in this scope or any parent scope.
-	*
-	* This method checks the current scope first, then walks up the parent chain.
-	* Returns true only if the dependency has been created and cached somewhere in the scope hierarchy.
-	*/
-	has(tag) {
-		if (this.cache.has(tag)) return true;
-		return this.parent?.has(tag) ?? false;
-	}
-	/**
-	* Retrieves a dependency instance, resolving from the current scope or parent scopes.
-	*
-	* Resolution strategy:
-	* 1. Check cache in current scope
-	* 2. Check if factory exists in current scope - if so, create instance here
-	* 3. Otherwise, delegate to parent scope
-	* 4. If no parent or parent doesn't have it, throw UnknownDependencyError
-	*/
-	async get(tag) {
-		if (this.factories.has(tag)) return resolveDependency(tag, this.cache, this.factories, this);
-		if (this.parent !== null) return this.parent.get(tag);
-		throw new UnknownDependencyError(tag);
-	}
-	/**
-	* Destroys this scoped container and its children, preserving the container structure for reuse.
-	*
-	* This method ensures proper cleanup order while maintaining reusability:
-	* 1. Destroys all child scopes first (they may depend on parent scope dependencies)
-	* 2. Then calls finalizers for dependencies created in this scope
-	* 3. Clears only instance caches - preserves factories, finalizers, and child structure
-	*
-	* Child destruction happens first to ensure dependencies don't get cleaned up
-	* before their dependents.
-	*/
-	async destroy() {
-		const allFailures = [];
-		try {
-			const childDestroyPromises = this.children.map((child) => child.destroy());
-			const childResults = await Promise.allSettled(childDestroyPromises);
-			const childFailures = childResults.filter((result) => result.status === "rejected").map((result) => result.reason);
-			allFailures.push(...childFailures);
-			await runFinalizers(this.finalizers, this.cache);
-		} catch (error) {
-			allFailures.push(error);
-		} finally {
-			this.cache.clear();
-		}
-		if (allFailures.length > 0) throw new DependencyContainerFinalizationError(allFailures);
-	}
-	/**
-	* Creates a child scoped container.
-	*
-	* Child containers inherit access to parent dependencies but maintain
-	* their own scope for new registrations and instance caching.
-	*/
-	child(scope) {
-		const child = new ScopedContainer(this, scope);
-		this.children.push(child);
-		return child;
-	}
-};
 /**
 * Creates a new empty dependency injection container.
 *
@@ -743,15 +702,15 @@ var ScopedContainer = class ScopedContainer {
 *
 * @example
 * ```typescript
-* import { container, Tag } from 'sandl';
+* import { container, Tag } from 'sandly';
 *
 * class DatabaseService extends Tag.Class('DatabaseService') {}
 * class UserService extends Tag.Class('UserService') {}
 *
 * const c = container()
 *   .register(DatabaseService, () => new DatabaseService())
-*   .register(UserService, async (container) =>
-*     new UserService(await container.get(DatabaseService))
+*   .register(UserService, async (ctx) =>
+*     new UserService(await ctx.get(DatabaseService))
 *   );
 *
 * const userService = await c.get(UserService);
@@ -760,9 +719,6 @@ var ScopedContainer = class ScopedContainer {
 function container() {
 	return new Container();
 }
-function scopedContainer(scope) {
-	return new ScopedContainer(null, scope);
-}
 
 //#endregion
 //#region src/layer.ts
@@ -772,14 +728,13 @@ function scopedContainer(scope) {
 *
 * @template TRequires - The union of dependency tags this layer requires from other layers or external setup
 * @template TProvides - The union of dependency tags this layer registers/provides
-* @template TParams - Optional parameters that can be passed to configure the layer
 *
-* @param register - Function that performs the dependency registrations. Receives a container and optional params.
-* @returns A layer factory function. If TParams is undefined, returns a parameterless function. Otherwise returns a function that takes TParams.
+* @param register - Function that performs the dependency registrations. Receives a container.
+* @returns The layer instance.
 *
-* @example Simple layer without parameters
+* @example Simple layer
 * ```typescript
-* import { layer, Tag } from '@/di/layer.js';
+* import { layer, Tag } from 'sandly';
 *
 * class DatabaseService extends Tag.Class('DatabaseService') {
 *   constructor(private url: string = 'sqlite://memory') {}
@@ -792,37 +747,7 @@ function scopedContainer(scope) {
 * );
 *
 * // Usage
-* const dbLayerInstance = databaseLayer(); // No parameters needed
-* ```
-*
-* @example Layer with dependencies
-* ```typescript
-* const ConfigTag = Tag.of('config')<{ dbUrl: string }>();
-*
-* // Layer that requires ConfigTag and provides DatabaseService
-* const databaseLayer = layer<typeof ConfigTag, typeof DatabaseService>((container) =>
-*   container.register(DatabaseService, async (c) => {
-*     const config = await c.get(ConfigTag);
-*     return new DatabaseService(config.dbUrl);
-*   })
-* );
-* ```
-*
-* @example Parameterized layer
-* ```typescript
-* interface DatabaseConfig {
-*   host: string;
-*   port: number;
-* }
-*
-* // Layer that takes configuration parameters
-* const databaseLayer = layer<never, typeof DatabaseService, DatabaseConfig>(
-*   (container, config) =>
-*     container.register(DatabaseService, () => new DatabaseService(config))
-* );
-*
-* // Usage with parameters
-* const dbLayerInstance = databaseLayer({ host: 'localhost', port: 5432 });
+* const dbLayerInstance = databaseLayer;
 * ```
 *
 * @example Complex application layer structure
@@ -836,73 +761,247 @@ function scopedContainer(scope) {
 * const infraLayer = layer<typeof ConfigTag, typeof DatabaseService | typeof CacheService>(
 *   (container) =>
 *     container
-*       .register(DatabaseService, async (c) => new DatabaseService(await c.get(ConfigTag)))
-*       .register(CacheService, async (c) => new CacheService(await c.get(ConfigTag)))
+*       .register(DatabaseService, async (ctx) => new DatabaseService(await ctx.get(ConfigTag)))
+*       .register(CacheService, async (ctx) => new CacheService(await ctx.get(ConfigTag)))
 * );
 *
 * // Service layer (requires infrastructure)
 * const serviceLayer = layer<typeof DatabaseService | typeof CacheService, typeof UserService>(
 *   (container) =>
-*     container.register(UserService, async (c) =>
-*       new UserService(await c.get(DatabaseService), await c.get(CacheService))
+*     container.register(UserService, async (ctx) =>
+*       new UserService(await ctx.get(DatabaseService), await ctx.get(CacheService))
 *     )
 * );
 *
 * // Compose the complete application
-* const appLayer = configLayer().to(infraLayer()).to(serviceLayer());
+* const appLayer = serviceLayer.provide(infraLayer).provide(configLayer);
 * ```
 */
 function layer(register) {
-	const factory = (params) => {
-		const layerImpl = {
-			register: (container$1) => register(container$1, params),
-			to(target) {
-				return createComposedLayer(layerImpl, target);
-			},
-			and(other) {
-				return createMergedLayer(layerImpl, other);
-			}
-		};
-		return layerImpl;
+	const layerImpl = {
+		register: (container$1) => register(container$1),
+		provide(dependency) {
+			return createProvidedLayer(dependency, layerImpl);
+		},
+		provideMerge(dependency) {
+			return createComposedLayer(dependency, layerImpl);
+		},
+		merge(other) {
+			return createMergedLayer(layerImpl, other);
+		}
 	};
-	return factory;
+	return layerImpl;
+}
+/**
+* Internal function to create a provided layer from two layers.
+* This implements the `.provide()` method logic - only exposes target layer's provisions.
+*
+* @internal
+*/
+function createProvidedLayer(dependency, target) {
+	return createComposedLayer(dependency, target);
 }
 /**
 * Internal function to create a composed layer from two layers.
-* This implements the `.to()` method logic.
+* This implements the `.provideMerge()` method logic - exposes both layers' provisions.
 *
 * @internal
 */
-function createComposedLayer(source, target) {
+function createComposedLayer(dependency, target) {
 	return layer((container$1) => {
-		const containerWithSource = source.register(container$1);
-		return target.register(containerWithSource);
-	})();
+		const containerWithDependency = dependency.register(container$1);
+		return target.register(containerWithDependency);
+	});
 }
 /**
 * Internal function to create a merged layer from two layers.
-* This implements the `.and()` method logic.
+* This implements the `.merge()` method logic.
 *
 * @internal
 */
 function createMergedLayer(layer1, layer2) {
 	return layer((container$1) => {
 		const container1 = layer1.register(container$1);
-		return layer2.register(container1);
-	})();
+		const container2 = layer2.register(container1);
+		return container2;
+	});
 }
 /**
 * Utility object containing helper functions for working with layers.
 */
 const Layer = {
 	empty() {
-		return layer((container$1) => container$1)();
+		return layer((container$1) => container$1);
 	},
-	merge(...layers) {
-		return layers.reduce((acc, layer$1) => acc.and(layer$1));
+	mergeAll(...layers) {
+		return layers.reduce((acc, layer$1) => acc.merge(layer$1));
+	},
+	merge(layer1, layer2) {
+		return layer1.merge(layer2);
 	}
 };
 
+//#endregion
+//#region src/scoped-container.ts
+var ScopedContainer = class ScopedContainer extends Container {
+	scope;
+	parent;
+	children = [];
+	constructor(parent, scope) {
+		super();
+		this.parent = parent;
+		this.scope = scope;
+	}
+	/**
+	* Registers a dependency in the scoped container.
+	*
+	* Overrides the base implementation to return ScopedContainer type
+	* for proper method chaining support.
+	*/
+	register(tag, spec) {
+		super.register(tag, spec);
+		return this;
+	}
+	/**
+	* Checks if a dependency has been registered in this scope or any parent scope.
+	*
+	* This method checks the current scope first, then walks up the parent chain.
+	* Returns true if the dependency has been registered somewhere in the scope hierarchy.
+	*/
+	has(tag) {
+		if (super.has(tag)) return true;
+		return this.parent?.has(tag) ?? false;
+	}
+	/**
+	* Checks if a dependency has been instantiated in this scope or any parent scope.
+	*
+	* This method checks the current scope first, then walks up the parent chain.
+	* Returns true if the dependency has been instantiated somewhere in the scope hierarchy.
+	*/
+	exists(tag) {
+		if (super.exists(tag)) return true;
+		return this.parent?.exists(tag) ?? false;
+	}
+	/**
+	* Retrieves a dependency instance, resolving from the current scope or parent scopes.
+	*
+	* Resolution strategy:
+	* 1. Check cache in current scope
+	* 2. Check if factory exists in current scope - if so, create instance here
+	* 3. Otherwise, delegate to parent scope
+	* 4. If no parent or parent doesn't have it, throw UnknownDependencyError
+	*/
+	async get(tag) {
+		if (this.factories.has(tag)) return super.get(tag);
+		if (this.parent !== null) return this.parent.get(tag);
+		throw new UnknownDependencyError(tag);
+	}
+	/**
+	* Destroys this scoped container and its children, preserving the container structure for reuse.
+	*
+	* This method ensures proper cleanup order while maintaining reusability:
+	* 1. Destroys all child scopes first (they may depend on parent scope dependencies)
+	* 2. Then calls finalizers for dependencies created in this scope
+	* 3. Clears only instance caches - preserves factories, finalizers, and child structure
+	*
+	* Child destruction happens first to ensure dependencies don't get cleaned up
+	* before their dependents.
+	*/
+	async destroy() {
+		if (this.isDestroyed) return;
+		const allFailures = [];
+		const childDestroyPromises = this.children.map((weakRef) => weakRef.deref()).filter((child) => child !== void 0).map((child) => child.destroy());
+		const childResults = await Promise.allSettled(childDestroyPromises);
+		const childFailures = childResults.filter((result) => result.status === "rejected").map((result) => result.reason);
+		allFailures.push(...childFailures);
+		try {
+			await super.destroy();
+		} catch (error) {
+			allFailures.push(error);
+		} finally {
+			this.parent = null;
+		}
+		if (allFailures.length > 0) throw new DependencyFinalizationError(allFailures);
+	}
+	/**
+	* Creates a new scoped container by merging this container's registrations with another container.
+	*
+	* This method overrides the base Container.merge to return a ScopedContainer instead of a regular Container.
+	* The resulting scoped container contains all registrations from both containers and becomes a root scope
+	* (no parent) with the scope name from this container.
+	*
+	* @param other - The container to merge with
+	* @returns A new ScopedContainer with combined registrations
+	* @throws {ContainerDestroyedError} If this container has been destroyed
+	*/
+	merge(other) {
+		if (this.isDestroyed) throw new ContainerDestroyedError("Cannot merge from a destroyed container");
+		const merged = new ScopedContainer(null, this.scope);
+		other.copyTo(merged);
+		this.copyTo(merged);
+		return merged;
+	}
+	/**
+	* Creates a child scoped container.
+	*
+	* Child containers inherit access to parent dependencies but maintain
+	* their own scope for new registrations and instance caching.
+	*/
+	child(scope) {
+		if (this.isDestroyed) throw new ContainerDestroyedError("Cannot create child containers from a destroyed container");
+		const child = new ScopedContainer(this, scope);
+		this.children.push(new WeakRef(child));
+		return child;
+	}
+};
+/**
+* Converts a regular container into a scoped container, copying all registrations.
+*
+* This function creates a new ScopedContainer instance and copies all factory functions
+* and finalizers from the source container. The resulting scoped container becomes a root
+* scope (no parent) with all the same dependency registrations.
+*
+* **Important**: Only the registrations are copied, not any cached instances.
+* The new scoped container starts with an empty instance cache.
+*
+* @param container - The container to convert to a scoped container
+* @param scope - A string or symbol identifier for this scope (used for debugging)
+* @returns A new ScopedContainer instance with all registrations copied from the source container
+* @throws {ContainerDestroyedError} If the source container has been destroyed
+*
+* @example Converting a regular container to scoped
+* ```typescript
+* import { container, scoped } from 'sandly';
+*
+* const appContainer = container()
+*   .register(DatabaseService, () => new DatabaseService())
+*   .register(ConfigService, () => new ConfigService());
+*
+* const scopedAppContainer = scoped(appContainer, 'app');
+*
+* // Create child scopes
+* const requestContainer = scopedAppContainer.child('request');
+* ```
+*
+* @example Copying complex registrations
+* ```typescript
+* const baseContainer = container()
+*   .register(DatabaseService, () => new DatabaseService())
+*   .register(UserService, {
+*     factory: async (ctx) => new UserService(await ctx.get(DatabaseService)),
+*     finalizer: (service) => service.cleanup()
+*   });
+*
+* const scopedContainer = scoped(baseContainer, 'app');
+* // scopedContainer now has all the same registrations with finalizers preserved
+* ```
+*/
+function scoped(container$1, scope) {
+	const emptyScoped = new ScopedContainer(null, scope);
+	const result = emptyScoped.merge(container$1);
+	return result;
+}
+
 //#endregion
 //#region src/service.ts
 /**
@@ -916,10 +1015,9 @@ const Layer = {
 * - No constructor dependencies are needed since they don't have constructors
 *
 * @template T - The tag representing the service (ClassTag or ValueTag)
-* @template TParams - Optional parameters for service configuration
 * @param serviceClass - The tag (ClassTag or ValueTag)
-* @param factory - Factory function for service instantiation with container and optional params
-* @returns A factory function that creates a service layer
+* @param factory - Factory function for service instantiation with container
+* @returns The service layer
 *
 * @example Simple service without dependencies
 * ```typescript
@@ -944,40 +1042,40 @@ const Layer = {
 *   getUsers() { return this.db.query(); }
 * }
 *
-* const userService = service(UserService, async (container) =>
-*   new UserService(await container.get(DatabaseService))
+* const userService = service(UserService, async (ctx) =>
+*   new UserService(await ctx.get(DatabaseService))
 * );
 * ```
+*/
+function service(serviceClass, spec) {
+	return layer((container$1) => {
+		return container$1.register(serviceClass, spec);
+	});
+}
+
+//#endregion
+//#region src/value.ts
+/**
+* Creates a layer that provides a constant value for a given tag.
 *
-* @example Service with configuration parameters
+* @param tag - The value tag to provide
+* @param constantValue - The constant value to provide
+* @returns A layer with no dependencies that provides the constant value
+*
+* @example
 * ```typescript
-* class DatabaseService extends Tag.Class('DatabaseService') {
-*   constructor(private config: { dbUrl: string }) {
-*     super();
-*   }
-* }
+* const ApiKey = Tag.of('ApiKey')<string>();
+* const DatabaseUrl = Tag.of('DatabaseUrl')<string>();
 *
-* const dbService = service(
-*   DatabaseService,
-*   (container, params: { dbUrl: string }) => new DatabaseService(params)
-* );
+* const apiKey = value(ApiKey, 'my-secret-key');
+* const dbUrl = value(DatabaseUrl, 'postgresql://localhost:5432/myapp');
+*
+* const config = Layer.merge(apiKey, dbUrl);
 * ```
 */
-function service(serviceClass, factory) {
-	const serviceFactory = (params) => {
-		const serviceLayer = layer((container$1) => {
-			return container$1.register(serviceClass, (c) => factory(c, params));
-		})();
-		const serviceImpl = {
-			serviceClass,
-			register: serviceLayer.register,
-			to: serviceLayer.to,
-			and: serviceLayer.and
-		};
-		return serviceImpl;
-	};
-	return serviceFactory;
+function value(tag, constantValue) {
+	return layer((container$1) => container$1.register(tag, () => constantValue));
 }
 
 //#endregion
-export { Layer, Tag, container, layer, scopedContainer, service };
+export { CircularDependencyError, Container, ContainerDestroyedError, ContainerError, DependencyAlreadyInstantiatedError, DependencyCreationError, DependencyFinalizationError, Layer, ScopedContainer, Tag, UnknownDependencyError, container, layer, scoped, service, value };