sandly 0.0.2 → 0.2.0

package/dist/index.js

@@ -1,50 +1,77 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 
+//#region src/utils/object.ts
+function hasKey(obj, key) {
+	return obj !== void 0 && obj !== null && (typeof obj === "object" || typeof obj === "function") && key in obj;
+}
+function getKey(obj, ...keys) {
+	let current = obj;
+	for (const key of keys) {
+		if (!hasKey(current, key)) return void 0;
+		current = current[key];
+	}
+	return current;
+}
+
+//#endregion
 //#region src/tag.ts
 /**
-* 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.
+* 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 service tags.
+*
+* Note: We can't use a symbol here becuase it produced the following TS error:
+*  error TS4020: 'extends' clause of exported class 'NotificationService' has or is using private name 'TagIdKey'.
+*
+* @internal
+*/
+const ValueTagIdKey = "__sandly/ValueTagIdKey__";
+const ServiceTagIdKey = "__sandly/ServiceTagIdKey__";
+/**
+* Internal symbol used to identify the type of a tagged type within the dependency injection system.
+* This symbol is used as a property key to attach metadata to both value tags and service tags.
+* It is used to carry the type of the tagged type and should not be used directly.
 * @internal
 */
-const TagId = "__tag_id__";
+const TagTypeKey = Symbol.for("sandly/TagTypeKey");
 /**
 * Utility object containing factory functions for creating dependency tags.
 *
-* The Tag object provides the primary API for creating both value tags and class tags
+* The Tag object provides the primary API for creating both value tags and service tags
 * used throughout the dependency injection system. It's the main entry point for
 * defining dependencies in a type-safe way.
 */
 const Tag = {
 	of: (id) => {
 		return () => ({
-			[TagId]: id,
-			__type: void 0
+			[ValueTagIdKey]: id,
+			[TagTypeKey]: void 0
 		});
 	},
 	for: () => {
 		return {
-			[TagId]: Symbol(),
-			__type: void 0
+			[ValueTagIdKey]: Symbol(),
+			[TagTypeKey]: void 0
 		};
 	},
-	Class: (id) => {
+	Service: (id) => {
 		class Tagged {
-			static [TagId] = id;
-			[TagId] = id;
-			/** @internal */
-			__type;
+			static [ServiceTagIdKey] = id;
+			[ServiceTagIdKey] = id;
 		}
 		return Tagged;
 	},
 	id: (tag) => {
-		if (typeof tag === "function") {
-			const id$1 = tag[TagId];
-			return typeof id$1 === "symbol" ? id$1.toString() : String(id$1);
-		}
-		const id = tag[TagId];
-		return typeof id === "symbol" ? id.toString() : String(id);
+		return typeof tag === "function" ? tag[ServiceTagIdKey] : tag[ValueTagIdKey];
+	},
+	isTag: (tag) => {
+		return typeof tag === "function" ? getKey(tag, ServiceTagIdKey) !== void 0 : getKey(tag, ValueTagIdKey) !== void 0;
 	}
 };
+/**
+* Unique symbol used to store the original ValueTag in Inject<T> types.
+* This prevents property name collisions while allowing type-level extraction.
+*/
+const InjectSource = Symbol("InjectSource");
 
 //#endregion
 //#region src/errors.ts
@@ -87,29 +114,45 @@ var BaseError = class BaseError extends Error {
 * @example Catching DI errors
 * ```typescript
 * try {
-*   await container.get(SomeService);
+*   await container.resolve(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.resolve()`, `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.
 *
-* This error occurs when calling `container.get(Tag)` for a tag that was never
+* This error occurs when calling `container.resolve(Tag)` for a tag that was never
 * registered via `container.register()`. It indicates a programming error where
 * the dependency setup is incomplete.
 *
 * @example
 * ```typescript
-* const c = container(); // Empty container
+* const c = Container.empty(); // Empty container
 *
 * try {
-*   await c.get(UnregisteredService); // This will throw
+*   await c.resolve(UnregisteredService); // This will throw
 * } catch (error) {
 *   if (error instanceof UnknownDependencyError) {
 *     console.error('Missing dependency:', error.message);
@@ -117,7 +160,7 @@ var DependencyContainerError = class extends BaseError {};
 * }
 * ```
 */
-var UnknownDependencyError = class extends DependencyContainerError {
+var UnknownDependencyError = class extends ContainerError {
 	/**
 	* @internal
 	* Creates an UnknownDependencyError for the given tag.
@@ -125,7 +168,7 @@ var UnknownDependencyError = class extends DependencyContainerError {
 	* @param tag - The dependency tag that wasn't found
 	*/
 	constructor(tag) {
-		super(`No factory registered for dependency ${Tag.id(tag)}`);
+		super(`No factory registered for dependency ${String(Tag.id(tag))}`);
 	}
 };
 /**
@@ -137,19 +180,19 @@ var UnknownDependencyError = class extends DependencyContainerError {
 *
 * @example Circular dependency scenario
 * ```typescript
-* class ServiceA extends Tag.Class('ServiceA') {}
-* class ServiceB extends Tag.Class('ServiceB') {}
+* class ServiceA extends Tag.Service('ServiceA') {}
+* class ServiceB extends Tag.Service('ServiceB') {}
 *
-* const c = container()
-*   .register(ServiceA, async (container) =>
-*     new ServiceA(await container.get(ServiceB)) // Depends on B
+* const c = Container.empty()
+*   .register(ServiceA, async (ctx) =>
+*     new ServiceA(await ctx.resolve(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.resolve(ServiceA)) // Depends on A - CIRCULAR!
 *   );
 *
 * try {
-*   await c.get(ServiceA);
+*   await c.resolve(ServiceA);
 * } catch (error) {
 *   if (error instanceof CircularDependencyError) {
 *     console.error('Circular dependency:', error.message);
@@ -158,7 +201,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.
@@ -168,7 +211,7 @@ var CircularDependencyError = class extends DependencyContainerError {
 	*/
 	constructor(tag, dependencyChain) {
 		const chain = dependencyChain.map((t) => Tag.id(t)).join(" -> ");
-		super(`Circular dependency detected for ${Tag.id(tag)}: ${chain} -> ${Tag.id(tag)}`, { detail: {
+		super(`Circular dependency detected for ${String(Tag.id(tag))}: ${chain} -> ${String(Tag.id(tag))}`, { detail: {
 			tag: Tag.id(tag),
 			dependencyChain: dependencyChain.map((t) => Tag.id(t))
 		} });
@@ -182,14 +225,14 @@ var CircularDependencyError = class extends DependencyContainerError {
 *
 * @example Factory throwing error
 * ```typescript
-* class DatabaseService extends Tag.Class('DatabaseService') {}
+* class DatabaseService extends Tag.Service('DatabaseService') {}
 *
-* const c = container().register(DatabaseService, () => {
+* const c = Container.empty().register(DatabaseService, () => {
 *   throw new Error('Database connection failed');
 * });
 *
 * try {
-*   await c.get(DatabaseService);
+*   await c.resolve(DatabaseService);
 * } catch (error) {
 *   if (error instanceof DependencyCreationError) {
 *     console.error('Failed to create:', error.message);
@@ -198,7 +241,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 +250,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 ${String(Tag.id(tag))}`, {
 			cause: error,
 			detail: { tag: Tag.id(tag) }
 		});
@@ -225,17 +268,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
 	*/
@@ -256,46 +299,7 @@ var DependencyContainerFinalizationError = class extends DependencyContainerErro
 * @internal
 */
 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));
-}
+const ContainerTypeId = Symbol.for("sandly/Container");
 /**
 * A type-safe dependency injection container that manages service instantiation,
 * caching, and lifecycle management with support for async dependencies and
@@ -307,26 +311,26 @@ async function runFinalizers(finalizers, cache) {
 *
 * @template TReg - Union type of all registered dependency tags in this container
 *
-* @example Basic usage with class tags
+* @example Basic usage with service tags
 * ```typescript
-* import { container, Tag } from 'sandl';
+* import { container, Tag } from 'sandly';
 *
-* class DatabaseService extends Tag.Class('DatabaseService') {
+* class DatabaseService extends Tag.Service('DatabaseService') {
 *   query() { return 'data'; }
 * }
 *
-* class UserService extends Tag.Class('UserService') {
+* class UserService extends Tag.Service('UserService') {
 *   constructor(private db: DatabaseService) {}
 *   getUser() { return this.db.query(); }
 * }
 *
-* const c = container()
+* const c = Container.empty()
 *   .register(DatabaseService, () => new DatabaseService())
-*   .register(UserService, async (container) =>
-*     new UserService(await container.get(DatabaseService))
+*   .register(UserService, async (ctx) =>
+*     new UserService(await ctx.resolve(DatabaseService))
 *   );
 *
-* const userService = await c.get(UserService);
+* const userService = await c.resolve(UserService);
 * ```
 *
 * @example Usage with value tags
@@ -334,22 +338,22 @@ async function runFinalizers(finalizers, cache) {
 * const ApiKeyTag = Tag.of('apiKey')<string>();
 * const ConfigTag = Tag.of('config')<{ dbUrl: string }>();
 *
-* const c = container()
+* const c = Container.empty()
 *   .register(ApiKeyTag, () => process.env.API_KEY!)
 *   .register(ConfigTag, () => ({ dbUrl: 'postgresql://localhost:5432' }));
 *
-* const apiKey = await c.get(ApiKeyTag);
-* const config = await c.get(ConfigTag);
+* const apiKey = await c.resolve(ApiKeyTag);
+* const config = await c.resolve(ConfigTag);
 * ```
 *
 * @example With finalizers for cleanup
 * ```typescript
-* class DatabaseConnection extends Tag.Class('DatabaseConnection') {
+* class DatabaseConnection extends Tag.Service('DatabaseConnection') {
 *   async connect() { return; }
 *   async disconnect() { return; }
 * }
 *
-* const c = container().register(
+* const c = Container.empty().register(
 *   DatabaseConnection,
 *   async () => {
 *     const conn = new DatabaseConnection();
@@ -363,7 +367,8 @@ async function runFinalizers(finalizers, cache) {
 * await c.destroy(); // Calls all finalizers
 * ```
 */
-var Container = class {
+var Container = class Container {
+	[ContainerTypeId];
 	/**
 	* Cache of instantiated dependencies as promises.
 	* Ensures singleton behavior and supports concurrent access.
@@ -381,26 +386,38 @@ var Container = class {
 	*/
 	finalizers = /* @__PURE__ */ new Map();
 	/**
+	* Flag indicating whether this container has been destroyed.
+	* @internal
+	*/
+	isDestroyed = false;
+	static empty() {
+		return new Container();
+	}
+	/**
 	* 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.
+	* the type level, ensuring type safety for subsequent `.resolve()` 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
-	* class LoggerService extends Tag.Class('LoggerService') {
+	* class LoggerService extends Tag.Service('LoggerService') {
 	*   log(message: string) { console.log(message); }
 	* }
 	*
-	* const c = container().register(
+	* const c = Container.empty().register(
 	*   LoggerService,
 	*   () => new LoggerService()
 	* );
@@ -408,26 +425,33 @@ var Container = class {
 	*
 	* @example Registering with dependencies
 	* ```typescript
-	* class UserService extends Tag.Class('UserService') {
+	* class UserService extends Tag.Service('UserService') {
 	*   constructor(private db: DatabaseService, private logger: LoggerService) {}
 	* }
 	*
-	* const c = container()
+	* const c = Container.empty()
 	*   .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.resolve(DatabaseService),
+	*       await ctx.resolve(LoggerService)
 	*     )
 	*   );
 	* ```
 	*
+	* @example Overriding a dependency
+	* ```typescript
+	* const c = Container.empty()
+	*   .register(DatabaseService, () => new DatabaseService())
+	*   .register(DatabaseService, () => new MockDatabaseService()); // Overrides the previous registration
+	* ```
+	*
 	* @example Using value tags
 	* ```typescript
 	* const ConfigTag = Tag.of('config')<{ apiUrl: string }>();
 	*
-	* const c = container().register(
+	* const c = Container.empty().register(
 	*   ConfigTag,
 	*   () => ({ apiUrl: 'https://api.example.com' })
 	* );
@@ -435,12 +459,12 @@ var Container = class {
 	*
 	* @example With finalizer for cleanup
 	* ```typescript
-	* class DatabaseConnection extends Tag.Class('DatabaseConnection') {
+	* class DatabaseConnection extends Tag.Service('DatabaseConnection') {
 	*   async connect() { return; }
 	*   async close() { return; }
 	* }
 	*
-	* const c = container().register(
+	* const c = Container.empty().register(
 	*   DatabaseConnection,
 	*   async () => {
 	*     const conn = new DatabaseConnection();
@@ -451,35 +475,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 ${String(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
+	* const c = Container.empty().register(DatabaseService, () => new DatabaseService());
+	* 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);
 	}
 	/**
@@ -501,10 +533,10 @@ var Container = class {
 	*
 	* @example Basic usage
 	* ```typescript
-	* const c = container()
+	* const c = Container.empty()
 	*   .register(DatabaseService, () => new DatabaseService());
 	*
-	* const db = await c.get(DatabaseService);
+	* const db = await c.resolve(DatabaseService);
 	* db.query('SELECT * FROM users');
 	* ```
 	*
@@ -512,9 +544,9 @@ var Container = class {
 	* ```typescript
 	* // All three calls will receive the same instance
 	* const [db1, db2, db3] = await Promise.all([
-	*   c.get(DatabaseService),
-	*   c.get(DatabaseService),
-	*   c.get(DatabaseService)
+	*   c.resolve(DatabaseService),
+	*   c.resolve(DatabaseService),
+	*   c.resolve(DatabaseService)
 	* ]);
 	*
 	* console.log(db1 === db2 === db3); // true
@@ -522,25 +554,141 @@ var Container = class {
 	*
 	* @example Dependency injection in factories
 	* ```typescript
-	* const c = container()
+	* const c = Container.empty()
 	*   .register(DatabaseService, () => new DatabaseService())
-	*   .register(UserService, async (container) => {
-	*     const db = await container.get(DatabaseService);
+	*   .register(UserService, async (ctx) => {
+	*     const db = await ctx.resolve(DatabaseService);
 	*     return new UserService(db);
 	*   });
 	*
-	* const userService = await c.get(UserService);
+	* const userService = await c.resolve(UserService);
+	* ```
+	*/
+	async resolve(tag) {
+		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;
+	}
+	/**
+	* Resolves multiple dependencies concurrently using Promise.all.
+	*
+	* This method takes a variable number of dependency tags and resolves all of them concurrently,
+	* returning a tuple with the resolved instances in the same order as the input tags.
+	* The method maintains all the same guarantees as the individual resolve method:
+	* singleton behavior, circular dependency detection, and proper error handling.
+	*
+	* @template T - The tuple type of dependency tags to resolve
+	* @param tags - Variable number of dependency tags to resolve
+	* @returns Promise resolving to a tuple of service instances in the same order
+	* @throws {ContainerDestroyedError} If the container has been destroyed
+	* @throws {UnknownDependencyError} If any dependency is not registered
+	* @throws {CircularDependencyError} If a circular dependency is detected
+	* @throws {DependencyCreationError} If any factory function throws an error
+	*
+	* @example Basic usage
+	* ```typescript
+	* const c = Container.empty()
+	*   .register(DatabaseService, () => new DatabaseService())
+	*   .register(LoggerService, () => new LoggerService());
+	*
+	* const [db, logger] = await c.resolveAll(DatabaseService, LoggerService);
+	* ```
+	*
+	* @example Mixed tag types
+	* ```typescript
+	* const ApiKeyTag = Tag.of('apiKey')<string>();
+	* const c = Container.empty()
+	*   .register(ApiKeyTag, () => 'secret-key')
+	*   .register(UserService, () => new UserService());
+	*
+	* const [apiKey, userService] = await c.resolveAll(ApiKeyTag, UserService);
+	* ```
+	*
+	* @example Empty array
+	* ```typescript
+	* const results = await c.resolveAll(); // Returns empty array
 	* ```
 	*/
-	async get(tag) {
-		return resolveDependency(tag, this.cache, this.factories, this);
+	async resolveAll(...tags) {
+		if (this.isDestroyed) throw new ContainerDestroyedError("Cannot resolve dependencies from a destroyed container");
+		const promises = tags.map((tag) => this.resolve(tag));
+		const results = await Promise.all(promises);
+		return results;
+	}
+	/**
+	* 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.
+	*
+	* 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.
 	*
-	* **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.
+	* @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.empty()
+	*   .register(DatabaseService, () => new DatabaseService());
+	*
+	* const container2 = Container.empty()
+	*   .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,11 +700,11 @@ 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()
+	* const c = Container.empty()
 	*   .register(DatabaseConnection,
 	*     async () => {
 	*       const conn = new DatabaseConnection();
@@ -566,24 +714,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.resolve(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.resolve(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.empty
+	*   .register(DatabaseService, () => new DatabaseService())
+	*   .register(HTTPServer, async (ctx) => new HTTPServer(await ctx.resolve(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,92 +751,196 @@ 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 {
+
+//#endregion
+//#region src/layer.ts
+/**
+* The type ID for the Layer interface.
+*/
+const LayerTypeId = Symbol.for("sandly/Layer");
+/**
+* Creates a new dependency layer that encapsulates a set of dependency registrations.
+* Layers are the primary building blocks for organizing and composing dependency injection setups.
+*
+* @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
+*
+* @param register - Function that performs the dependency registrations. Receives a container.
+* @returns The layer instance.
+*
+* @example Simple layer
+* ```typescript
+* import { layer, Tag } from 'sandly';
+*
+* class DatabaseService extends Tag.Service('DatabaseService') {
+*   constructor(private url: string = 'sqlite://memory') {}
+*   query() { return 'data'; }
+* }
+*
+* // Layer that provides DatabaseService, requires nothing
+* const databaseLayer = layer<never, typeof DatabaseService>((container) =>
+*   container.register(DatabaseService, () => new DatabaseService())
+* );
+*
+* // Usage
+* const dbLayerInstance = databaseLayer;
+* ```
+*
+* @example Complex application layer structure
+* ```typescript
+* // Configuration layer
+* const configLayer = layer<never, typeof ConfigTag>((container) =>
+*   container.register(ConfigTag, () => loadConfig())
+* );
+*
+* // Infrastructure layer (requires config)
+* const infraLayer = layer<typeof ConfigTag, typeof DatabaseService | typeof CacheService>(
+*   (container) =>
+*     container
+*       .register(DatabaseService, async (ctx) => new DatabaseService(await ctx.resolve(ConfigTag)))
+*       .register(CacheService, async (ctx) => new CacheService(await ctx.resolve(ConfigTag)))
+* );
+*
+* // Service layer (requires infrastructure)
+* const serviceLayer = layer<typeof DatabaseService | typeof CacheService, typeof UserService>(
+*   (container) =>
+*     container.register(UserService, async (ctx) =>
+*       new UserService(await ctx.resolve(DatabaseService), await ctx.resolve(CacheService))
+*     )
+* );
+*
+* // Compose the complete application
+* const appLayer = serviceLayer.provide(infraLayer).provide(configLayer);
+* ```
+*/
+function layer(register) {
+	const layerImpl = {
+		register: (container) => register(container),
+		provide(dependency) {
+			return createProvidedLayer(dependency, layerImpl);
+		},
+		provideMerge(dependency) {
+			return createComposedLayer(dependency, layerImpl);
+		},
+		merge(other) {
+			return createMergedLayer(layerImpl, other);
+		}
+	};
+	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 `.provideMerge()` method logic - exposes both layers' provisions.
+*
+* @internal
+*/
+function createComposedLayer(dependency, target) {
+	return layer((container) => {
+		const containerWithDependency = dependency.register(container);
+		return target.register(containerWithDependency);
+	});
+}
+/**
+* Internal function to create a merged layer from two layers.
+* This implements the `.merge()` method logic.
+*
+* @internal
+*/
+function createMergedLayer(layer1, layer2) {
+	return layer((container) => {
+		const container1 = layer1.register(container);
+		const container2 = layer2.register(container1);
+		return container2;
+	});
+}
+/**
+* Utility object containing helper functions for working with layers.
+*/
+const Layer = {
+	empty() {
+		return layer((container) => container);
+	},
+	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 = [];
-	/**
-	* 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) {
+		super();
 		this.parent = parent;
 		this.scope = scope;
 	}
+	static empty(scope) {
+		return new ScopedContainer(null, 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());
+	* Registers a dependency in the scoped container.
 	*
-	* // Register in runtime scope from request container - delegates to parent
-	* request.register(DatabaseService, () => new DatabaseService(), undefined, 'runtime');
-	* ```
+	* Overrides the base implementation to return ScopedContainer type
+	* for proper method chaining support.
 	*/
-	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);
+	register(tag, spec) {
+		super.register(tag, spec);
 		return this;
 	}
 	/**
-	* Checks if a dependency has been instantiated in this scope or any parent scope.
+	* 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 only if the dependency has been created and cached somewhere in the scope hierarchy.
+	* Returns true if the dependency has been registered somewhere in the scope hierarchy.
 	*/
 	has(tag) {
-		if (this.cache.has(tag)) return true;
+		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:
@@ -689,9 +949,9 @@ var ScopedContainer = class ScopedContainer {
 	* 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);
+	async resolve(tag) {
+		if (this.factories.has(tag)) return super.resolve(tag);
+		if (this.parent !== null) return this.parent.resolve(tag);
 		throw new UnknownDependencyError(tag);
 	}
 	/**
@@ -706,19 +966,38 @@ var ScopedContainer = class ScopedContainer {
 	* 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 {
-			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);
+			await super.destroy();
 		} catch (error) {
 			allFailures.push(error);
 		} finally {
-			this.cache.clear();
+			this.parent = null;
 		}
-		if (allFailures.length > 0) throw new DependencyContainerFinalizationError(allFailures);
+		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.
@@ -727,203 +1006,79 @@ var ScopedContainer = class ScopedContainer {
 	* 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(child);
+		this.children.push(new WeakRef(child));
 		return child;
 	}
 };
 /**
-* Creates a new empty dependency injection container.
-*
-* This is a convenience factory function that creates a new DependencyContainer instance.
-* The returned container starts with no registered dependencies and the type parameter
-* defaults to `never`, indicating no dependencies are available for retrieval yet.
-*
-* @returns A new empty DependencyContainer instance
-*
-* @example
-* ```typescript
-* import { container, Tag } from 'sandl';
-*
-* 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))
-*   );
-*
-* const userService = await c.get(UserService);
-* ```
-*/
-function container() {
-	return new Container();
-}
-function scopedContainer(scope) {
-	return new ScopedContainer(null, scope);
-}
-
-//#endregion
-//#region src/layer.ts
-/**
-* Creates a new dependency layer that encapsulates a set of dependency registrations.
-* Layers are the primary building blocks for organizing and composing dependency injection setups.
-*
-* @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
+* Converts a regular container into a scoped container, copying all registrations.
 *
-* @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.
+* 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.
 *
-* @example Simple layer without parameters
-* ```typescript
-* import { layer, Tag } from '@/di/layer.js';
-*
-* class DatabaseService extends Tag.Class('DatabaseService') {
-*   constructor(private url: string = 'sqlite://memory') {}
-*   query() { return 'data'; }
-* }
-*
-* // Layer that provides DatabaseService, requires nothing
-* const databaseLayer = layer<never, typeof DatabaseService>((container) =>
-*   container.register(DatabaseService, () => new DatabaseService())
-* );
+* **Important**: Only the registrations are copied, not any cached instances.
+* The new scoped container starts with an empty instance cache.
 *
-* // Usage
-* const dbLayerInstance = databaseLayer(); // No parameters needed
-* ```
+* @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 Layer with dependencies
+* @example Converting a regular container to scoped
 * ```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);
-*   })
-* );
-* ```
+* import { container, scoped } from 'sandly';
 *
-* @example Parameterized layer
-* ```typescript
-* interface DatabaseConfig {
-*   host: string;
-*   port: number;
-* }
+* const appContainer = Container.empty()
+*   .register(DatabaseService, () => new DatabaseService())
+*   .register(ConfigService, () => new ConfigService());
 *
-* // Layer that takes configuration parameters
-* const databaseLayer = layer<never, typeof DatabaseService, DatabaseConfig>(
-*   (container, config) =>
-*     container.register(DatabaseService, () => new DatabaseService(config))
-* );
+* const scopedAppContainer = scoped(appContainer, 'app');
 *
-* // Usage with parameters
-* const dbLayerInstance = databaseLayer({ host: 'localhost', port: 5432 });
+* // Create child scopes
+* const requestContainer = scopedAppContainer.child('request');
 * ```
 *
-* @example Complex application layer structure
+* @example Copying complex registrations
 * ```typescript
-* // Configuration layer
-* const configLayer = layer<never, typeof ConfigTag>((container) =>
-*   container.register(ConfigTag, () => loadConfig())
-* );
-*
-* // Infrastructure layer (requires config)
-* 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)))
-* );
-*
-* // 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))
-*     )
-* );
+* const baseContainer = Container.empty()
+*   .register(DatabaseService, () => new DatabaseService())
+*   .register(UserService, {
+*     factory: async (ctx) => new UserService(await ctx.resolve(DatabaseService)),
+*     finalizer: (service) => service.cleanup()
+*   });
 *
-* // Compose the complete application
-* const appLayer = configLayer().to(infraLayer()).to(serviceLayer());
+* const scopedContainer = scoped(baseContainer, 'app');
+* // scopedContainer now has all the same registrations with finalizers preserved
 * ```
 */
-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;
-	};
-	return factory;
-}
-/**
-* Internal function to create a composed layer from two layers.
-* This implements the `.to()` method logic.
-*
-* @internal
-*/
-function createComposedLayer(source, target) {
-	return layer((container$1) => {
-		const containerWithSource = source.register(container$1);
-		return target.register(containerWithSource);
-	})();
-}
-/**
-* Internal function to create a merged layer from two layers.
-* This implements the `.and()` method logic.
-*
-* @internal
-*/
-function createMergedLayer(layer1, layer2) {
-	return layer((container$1) => {
-		const container1 = layer1.register(container$1);
-		return layer2.register(container1);
-	})();
+function scoped(container, scope) {
+	const emptyScoped = ScopedContainer.empty(scope);
+	return emptyScoped.merge(container);
 }
-/**
-* Utility object containing helper functions for working with layers.
-*/
-const Layer = {
-	empty() {
-		return layer((container$1) => container$1)();
-	},
-	merge(...layers) {
-		return layers.reduce((acc, layer$1) => acc.and(layer$1));
-	}
-};
 
 //#endregion
 //#region src/service.ts
 /**
-* Creates a service layer from any tag type (ClassTag or ValueTag) with optional parameters.
+* Creates a service layer from any tag type (ServiceTag or ValueTag) with optional parameters.
 *
-* For ClassTag services:
+* For ServiceTag services:
 * - Dependencies are automatically inferred from constructor parameters
 * - The factory function must handle dependency injection by resolving dependencies from the container
 *
 * For ValueTag services:
 * - 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
+* @template T - The tag representing the service (ServiceTag or ValueTag)
+* @param tag - The tag (ServiceTag or ValueTag)
+* @param factory - Factory function for service instantiation with container
+* @returns The service layer
 *
 * @example Simple service without dependencies
 * ```typescript
-* class LoggerService extends Tag.Class('LoggerService') {
+* class LoggerService extends Tag.Service('LoggerService') {
 *   log(message: string) { console.log(message); }
 * }
 *
@@ -932,11 +1087,11 @@ const Layer = {
 *
 * @example Service with dependencies
 * ```typescript
-* class DatabaseService extends Tag.Class('DatabaseService') {
+* class DatabaseService extends Tag.Service('DatabaseService') {
 *   query() { return []; }
 * }
 *
-* class UserService extends Tag.Class('UserService') {
+* class UserService extends Tag.Service('UserService') {
 *   constructor(private db: DatabaseService) {
 *     super();
 *   }
@@ -944,40 +1099,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.resolve(DatabaseService))
 * );
 * ```
+*/
+function service(tag, spec) {
+	return layer((container) => {
+		return container.register(tag, 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) => container.register(tag, () => constantValue));
 }
 
 //#endregion
-export { Layer, Tag, container, layer, scopedContainer, service };
+export { CircularDependencyError, Container, ContainerDestroyedError, ContainerError, DependencyAlreadyInstantiatedError, DependencyCreationError, DependencyFinalizationError, InjectSource, Layer, ScopedContainer, Tag, UnknownDependencyError, layer, scoped, service, value };