sandly 0.1.0 → 0.3.0

package/dist/index.js

@@ -1,49 +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
-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.
+* 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 TagId = "__tag_id__";
+const ValueTagIdKey = "sandly/ValueTagIdKey";
+const ServiceTagIdKey = "sandly/ServiceTagIdKey";
+/**
+* Internal string used to identify the type of a tagged type within the dependency injection system.
+* This string 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 TagTypeKey = "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;
+			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;
 	}
 };
+/**
+* String used to store the original ValueTag in Inject<T> types.
+* This prevents property name collisions while allowing type-level extraction.
+*/
+const InjectSource = "sandly/InjectSource";
 
 //#endregion
 //#region src/errors.ts
@@ -86,7 +114,7 @@ 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 ContainerError) {
 *     console.error('DI Error:', error.message);
@@ -107,7 +135,7 @@ 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()`
+* 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.
 */
@@ -115,16 +143,16 @@ 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 container = 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);
@@ -140,7 +168,7 @@ var UnknownDependencyError = class extends ContainerError {
 	* @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))}`);
 	}
 };
 /**
@@ -152,19 +180,19 @@ var UnknownDependencyError = class extends ContainerError {
 *
 * @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()
+* const container = Container.empty()
 *   .register(ServiceA, async (ctx) =>
-*     new ServiceA(await ctx.get(ServiceB)) // Depends on B
+*     new ServiceA(await ctx.resolve(ServiceB)) // Depends on B
 *   )
 *   .register(ServiceB, async (ctx) =>
-*     new ServiceB(await ctx.get(ServiceA)) // Depends on A - CIRCULAR!
+*     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);
@@ -183,7 +211,7 @@ var CircularDependencyError = class extends ContainerError {
 	*/
 	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))
 		} });
@@ -197,14 +225,14 @@ var CircularDependencyError = class extends ContainerError {
 *
 * @example Factory throwing error
 * ```typescript
-* class DatabaseService extends Tag.Class('DatabaseService') {}
+* class DatabaseService extends Tag.Service('DatabaseService') {}
 *
-* const c = container().register(DatabaseService, () => {
+* const container = 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);
@@ -222,7 +250,7 @@ var DependencyCreationError = class extends ContainerError {
 	* @param error - The original error thrown by the factory function
 	*/
 	constructor(tag, error) {
-		super(`Error creating instance of ${Tag.id(tag)}`, {
+		super(`Error creating instance of ${String(Tag.id(tag))}`, {
 			cause: error,
 			detail: { tag: Tag.id(tag) }
 		});
@@ -271,6 +299,7 @@ var DependencyFinalizationError = class extends ContainerError {
 * @internal
 */
 const resolutionChain = new AsyncLocalStorage();
+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
@@ -282,26 +311,26 @@ const resolutionChain = new AsyncLocalStorage();
 *
 * @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 '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 container = Container.empty()
 *   .register(DatabaseService, () => new DatabaseService())
 *   .register(UserService, async (ctx) =>
-*     new UserService(await ctx.get(DatabaseService))
+*     new UserService(await ctx.resolve(DatabaseService))
 *   );
 *
-* const userService = await c.get(UserService);
+* const userService = await c.resolve(UserService);
 * ```
 *
 * @example Usage with value tags
@@ -309,22 +338,22 @@ const resolutionChain = new AsyncLocalStorage();
 * const ApiKeyTag = Tag.of('apiKey')<string>();
 * const ConfigTag = Tag.of('config')<{ dbUrl: string }>();
 *
-* const c = container()
+* const container = 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 container = Container.empty().register(
 *   DatabaseConnection,
 *   async () => {
 *     const conn = new DatabaseConnection();
@@ -339,6 +368,8 @@ const resolutionChain = new AsyncLocalStorage();
 * ```
 */
 var Container = class Container {
+	[ContainerTypeId];
+	constructor() {}
 	/**
 	* Cache of instantiated dependencies as promises.
 	* Ensures singleton behavior and supports concurrent access.
@@ -361,11 +392,18 @@ var Container = class Container {
 	*/
 	isDestroyed = false;
 	/**
+	* Creates a new empty container instance.
+	* @returns A new empty Container instance with no registered dependencies.
+	*/
+	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.
@@ -380,11 +418,11 @@ var Container = class Container {
 	*
 	* @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 container = Container.empty().register(
 	*   LoggerService,
 	*   () => new LoggerService()
 	* );
@@ -392,24 +430,24 @@ var Container = class Container {
 	*
 	* @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 container = Container.empty()
 	*   .register(DatabaseService, () => new DatabaseService())
 	*   .register(LoggerService, () => new LoggerService())
 	*   .register(UserService, async (ctx) =>
 	*     new UserService(
-	*       await ctx.get(DatabaseService),
-	*       await ctx.get(LoggerService)
+	*       await ctx.resolve(DatabaseService),
+	*       await ctx.resolve(LoggerService)
 	*     )
 	*   );
 	* ```
 	*
 	* @example Overriding a dependency
 	* ```typescript
-	* const c = container()
+	* const container = Container.empty()
 	*   .register(DatabaseService, () => new DatabaseService())
 	*   .register(DatabaseService, () => new MockDatabaseService()); // Overrides the previous registration
 	* ```
@@ -418,7 +456,7 @@ var Container = class Container {
 	* ```typescript
 	* const ConfigTag = Tag.of('config')<{ apiUrl: string }>();
 	*
-	* const c = container().register(
+	* const container = Container.empty().register(
 	*   ConfigTag,
 	*   () => ({ apiUrl: 'https://api.example.com' })
 	* );
@@ -426,12 +464,12 @@ var Container = class Container {
 	*
 	* @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 container = Container.empty().register(
 	*   DatabaseConnection,
 	*   async () => {
 	*     const conn = new DatabaseConnection();
@@ -444,7 +482,7 @@ var Container = class Container {
 	*/
 	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 (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);
@@ -465,7 +503,7 @@ var Container = class Container {
 	*
 	* @example
 	* ```typescript
-	* const c = container().register(DatabaseService, () => new DatabaseService());
+	* const container = Container.empty().register(DatabaseService, () => new DatabaseService());
 	* console.log(c.has(DatabaseService)); // true
 	* ```
 	*/
@@ -500,10 +538,10 @@ var Container = class Container {
 	*
 	* @example Basic usage
 	* ```typescript
-	* const c = container()
+	* const container = Container.empty()
 	*   .register(DatabaseService, () => new DatabaseService());
 	*
-	* const db = await c.get(DatabaseService);
+	* const db = await c.resolve(DatabaseService);
 	* db.query('SELECT * FROM users');
 	* ```
 	*
@@ -511,9 +549,9 @@ var Container = class Container {
 	* ```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
@@ -521,17 +559,17 @@ var Container = class Container {
 	*
 	* @example Dependency injection in factories
 	* ```typescript
-	* const c = container()
+	* const container = Container.empty()
 	*   .register(DatabaseService, () => new DatabaseService())
 	*   .register(UserService, async (ctx) => {
-	*     const db = await ctx.get(DatabaseService);
+	*     const db = await ctx.resolve(DatabaseService);
 	*     return new UserService(db);
 	*   });
 	*
-	* const userService = await c.get(UserService);
+	* const userService = await c.resolve(UserService);
 	* ```
 	*/
-	async get(tag) {
+	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;
@@ -554,6 +592,52 @@ var Container = class Container {
 		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 container = 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 container = 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 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
@@ -587,10 +671,10 @@ var Container = class Container {
 	*
 	* @example Merging containers
 	* ```typescript
-	* const container1 = container()
+	* const container1 = Container.empty()
 	*   .register(DatabaseService, () => new DatabaseService());
 	*
-	* const container2 = container()
+	* const container2 = Container.empty()
 	*   .register(UserService, () => new UserService());
 	*
 	* const merged = container1.merge(container2);
@@ -625,7 +709,7 @@ var Container = class Container {
 	*
 	* @example Basic cleanup
 	* ```typescript
-	* const c = container()
+	* const container = Container.empty()
 	*   .register(DatabaseConnection,
 	*     async () => {
 	*       const conn = new DatabaseConnection();
@@ -635,12 +719,12 @@ var Container = class Container {
 	*     (conn) => conn.disconnect() // Finalizer
 	*   );
 	*
-	* const db = await c.get(DatabaseConnection);
+	* const db = await c.resolve(DatabaseConnection);
 	* await c.destroy(); // Calls conn.disconnect(), container becomes unusable
 	*
 	* // This will throw an error
 	* try {
-	*   await c.get(DatabaseConnection);
+	*   await c.resolve(DatabaseConnection);
 	* } catch (error) {
 	*   console.log(error.message); // "Cannot resolve dependencies from a destroyed container"
 	* }
@@ -648,9 +732,9 @@ var Container = class Container {
 	*
 	* @example Application shutdown
 	* ```typescript
-	* const appContainer = container()
+	* const appContainer Container.empty
 	*   .register(DatabaseService, () => new DatabaseService())
-	*   .register(HTTPServer, async (ctx) => new HTTPServer(await ctx.get(DatabaseService)));
+	*   .register(HTTPServer, async (ctx) => new HTTPServer(await ctx.resolve(DatabaseService)));
 	*
 	* // During application shutdown
 	* process.on('SIGTERM', async () => {
@@ -691,38 +775,14 @@ var Container = class Container {
 		}
 	}
 };
-/**
-* 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 'sandly';
-*
-* class DatabaseService extends Tag.Class('DatabaseService') {}
-* class UserService extends Tag.Class('UserService') {}
-*
-* const c = container()
-*   .register(DatabaseService, () => new DatabaseService())
-*   .register(UserService, async (ctx) =>
-*     new UserService(await ctx.get(DatabaseService))
-*   );
-*
-* const userService = await c.get(UserService);
-* ```
-*/
-function container() {
-	return new Container();
-}
 
 //#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.
 *
@@ -736,7 +796,7 @@ function container() {
 * ```typescript
 * import { layer, Tag } from 'sandly';
 *
-* class DatabaseService extends Tag.Class('DatabaseService') {
+* class DatabaseService extends Tag.Service('DatabaseService') {
 *   constructor(private url: string = 'sqlite://memory') {}
 *   query() { return 'data'; }
 * }
@@ -761,15 +821,15 @@ function container() {
 * const infraLayer = layer<typeof ConfigTag, typeof DatabaseService | typeof CacheService>(
 *   (container) =>
 *     container
-*       .register(DatabaseService, async (ctx) => new DatabaseService(await ctx.get(ConfigTag)))
-*       .register(CacheService, async (ctx) => new CacheService(await ctx.get(ConfigTag)))
+*       .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.get(DatabaseService), await ctx.get(CacheService))
+*       new UserService(await ctx.resolve(DatabaseService), await ctx.resolve(CacheService))
 *     )
 * );
 *
@@ -779,7 +839,7 @@ function container() {
 */
 function layer(register) {
 	const layerImpl = {
-		register: (container$1) => register(container$1),
+		register: (container) => register(container),
 		provide(dependency) {
 			return createProvidedLayer(dependency, layerImpl);
 		},
@@ -808,8 +868,8 @@ function createProvidedLayer(dependency, target) {
 * @internal
 */
 function createComposedLayer(dependency, target) {
-	return layer((container$1) => {
-		const containerWithDependency = dependency.register(container$1);
+	return layer((container) => {
+		const containerWithDependency = dependency.register(container);
 		return target.register(containerWithDependency);
 	});
 }
@@ -820,8 +880,8 @@ function createComposedLayer(dependency, target) {
 * @internal
 */
 function createMergedLayer(layer1, layer2) {
-	return layer((container$1) => {
-		const container1 = layer1.register(container$1);
+	return layer((container) => {
+		const container1 = layer1.register(container);
 		const container2 = layer2.register(container1);
 		return container2;
 	});
@@ -831,7 +891,7 @@ function createMergedLayer(layer1, layer2) {
 */
 const Layer = {
 	empty() {
-		return layer((container$1) => container$1);
+		return layer((container) => container);
 	},
 	mergeAll(...layers) {
 		return layers.reduce((acc, layer$1) => acc.merge(layer$1));
@@ -853,6 +913,14 @@ var ScopedContainer = class ScopedContainer extends Container {
 		this.scope = scope;
 	}
 	/**
+	* Creates a new empty scoped container instance.
+	* @param scope - The scope identifier for this container
+	* @returns A new empty ScopedContainer instance with no registered dependencies
+	*/
+	static empty(scope) {
+		return new ScopedContainer(null, scope);
+	}
+	/**
 	* Registers a dependency in the scoped container.
 	*
 	* Overrides the base implementation to return ScopedContainer type
@@ -891,9 +959,9 @@ var ScopedContainer = class ScopedContainer extends Container {
 	* 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);
+	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);
 	}
 	/**
@@ -973,7 +1041,7 @@ var ScopedContainer = class ScopedContainer extends Container {
 * ```typescript
 * import { container, scoped } from 'sandly';
 *
-* const appContainer = container()
+* const appContainer = Container.empty()
 *   .register(DatabaseService, () => new DatabaseService())
 *   .register(ConfigService, () => new ConfigService());
 *
@@ -985,10 +1053,10 @@ var ScopedContainer = class ScopedContainer extends Container {
 *
 * @example Copying complex registrations
 * ```typescript
-* const baseContainer = container()
+* const baseContainer = Container.empty()
 *   .register(DatabaseService, () => new DatabaseService())
 *   .register(UserService, {
-*     factory: async (ctx) => new UserService(await ctx.get(DatabaseService)),
+*     factory: async (ctx) => new UserService(await ctx.resolve(DatabaseService)),
 *     finalizer: (service) => service.cleanup()
 *   });
 *
@@ -996,32 +1064,31 @@ var ScopedContainer = class ScopedContainer extends Container {
 * // 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;
+function scoped(container, scope) {
+	const emptyScoped = ScopedContainer.empty(scope);
+	return emptyScoped.merge(container);
 }
 
 //#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)
-* @param serviceClass - The tag (ClassTag or ValueTag)
+* @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); }
 * }
 *
@@ -1030,11 +1097,11 @@ function scoped(container$1, scope) {
 *
 * @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();
 *   }
@@ -1043,15 +1110,131 @@ function scoped(container$1, scope) {
 * }
 *
 * const userService = service(UserService, async (ctx) =>
-*   new UserService(await ctx.get(DatabaseService))
+*   new UserService(await ctx.resolve(DatabaseService))
 * );
 * ```
 */
-function service(serviceClass, spec) {
-	return layer((container$1) => {
-		return container$1.register(serviceClass, spec);
+function service(tag, spec) {
+	return layer((container) => {
+		return container.register(tag, spec);
 	});
 }
+/**
+* Creates a service layer with automatic dependency injection by inferring constructor parameters.
+*
+* This is a convenience function that automatically resolves constructor dependencies and passes
+* both DI-managed dependencies and static values to the service constructor in the correct order.
+* It eliminates the need to manually write factory functions for services with constructor dependencies.
+*
+* @template T - The ServiceTag representing the service class
+* @param tag - The service tag (must be a ServiceTag, not a ValueTag)
+* @param deps - Tuple of constructor parameters in order - mix of dependency tags and static values
+* @param finalizer - Optional cleanup function called when the container is destroyed
+* @returns A service layer that automatically handles dependency injection
+*
+* @example Simple service with dependencies
+* ```typescript
+* class DatabaseService extends Tag.Service('DatabaseService') {
+*   constructor(private url: string) {
+*     super();
+*   }
+*   connect() { return `Connected to ${this.url}`; }
+* }
+*
+* class UserService extends Tag.Service('UserService') {
+*   constructor(private db: DatabaseService, private timeout: number) {
+*     super();
+*   }
+*   getUsers() { return this.db.query('SELECT * FROM users'); }
+* }
+*
+* // Automatically inject DatabaseService and pass static timeout value
+* const userService = autoService(UserService, [DatabaseService, 5000]);
+* ```
+*
+* @example Mixed dependencies and static values
+* ```typescript
+* class NotificationService extends Tag.Service('NotificationService') {
+*   constructor(
+*     private logger: LoggerService,
+*     private apiKey: string,
+*     private retries: number,
+*     private cache: CacheService
+*   ) {
+*     super();
+*   }
+* }
+*
+* // Mix of DI tags and static values in constructor order
+* const notificationService = autoService(NotificationService, [
+*   LoggerService,    // Will be resolved from container
+*   'secret-api-key', // Static string value
+*   3,                // Static number value
+*   CacheService      // Will be resolved from container
+* ]);
+* ```
+*
+* @example Compared to manual service creation
+* ```typescript
+* // Manual approach (more verbose)
+* const userServiceManual = service(UserService, async (ctx) => {
+*   const db = await ctx.resolve(DatabaseService);
+*   return new UserService(db, 5000);
+* });
+*
+* // Auto approach (concise)
+* const userServiceAuto = autoService(UserService, [DatabaseService, 5000]);
+* ```
+*
+* @example With finalizer for cleanup
+* ```typescript
+* class DatabaseService extends Tag.Service('DatabaseService') {
+*   constructor(private connectionString: string) {
+*     super();
+*   }
+*
+*   private connection: Connection | null = null;
+*
+*   async connect() {
+*     this.connection = await createConnection(this.connectionString);
+*   }
+*
+*   async disconnect() {
+*     if (this.connection) {
+*       await this.connection.close();
+*       this.connection = null;
+*     }
+*   }
+* }
+*
+* // Service with automatic cleanup
+* const dbService = autoService(
+*   DatabaseService,
+* 	 {
+* 		dependencies: ['postgresql://localhost:5432/mydb'],
+* 		finalizer: (service) => service.disconnect() // Finalizer for cleanup
+* 	 }
+* );
+* ```
+*/
+function autoService(tag, spec) {
+	if (Array.isArray(spec)) spec = { dependencies: spec };
+	const factory = async (ctx) => {
+		const diDeps = [];
+		for (const dep of spec.dependencies) if (Tag.isTag(dep)) diDeps.push(dep);
+		const resolved = await ctx.resolveAll(...diDeps);
+		const args = [];
+		let resolvedIndex = 0;
+		for (const dep of spec.dependencies) if (Tag.isTag(dep)) args.push(resolved[resolvedIndex++]);
+		else args.push(dep);
+		return new tag(...args);
+	};
+	const finalSpec = spec.finalizer ? {
+		factory,
+		finalizer: spec.finalizer
+	} : factory;
+	return service(tag, finalSpec);
+}
 
 //#endregion
 //#region src/value.ts
@@ -1074,8 +1257,8 @@ function service(serviceClass, spec) {
 * ```
 */
 function value(tag, constantValue) {
-	return layer((container$1) => container$1.register(tag, () => constantValue));
+	return layer((container) => container.register(tag, () => constantValue));
 }
 
 //#endregion
-export { CircularDependencyError, Container, ContainerDestroyedError, ContainerError, DependencyAlreadyInstantiatedError, DependencyCreationError, DependencyFinalizationError, Layer, ScopedContainer, Tag, UnknownDependencyError, container, layer, scoped, service, value };
+export { CircularDependencyError, Container, ContainerDestroyedError, ContainerError, DependencyAlreadyInstantiatedError, DependencyCreationError, DependencyFinalizationError, InjectSource, Layer, ScopedContainer, Tag, UnknownDependencyError, autoService, layer, scoped, service, value };