sandly 0.1.0 → 0.2.0

package/dist/index.d.ts

@@ -1,50 +1,27 @@
 //#region src/tag.d.ts
 /**
- * Unique symbol used to store the original ValueTag in Inject<T> types.
- * This prevents property name collisions while allowing type-level extraction.
+ * Type representing a tag identifier (string or symbol).
+ * @internal
  */
-declare const InjectSource: unique symbol;
+type TagId = string | symbol;
 /**
- * Helper type for injecting ValueTag dependencies in constructor parameters.
- * This allows clean specification of ValueTag dependencies while preserving
- * the original tag information for dependency inference.
- *
- * The phantom property is optional to allow normal runtime values to be assignable.
+ * 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.
  *
- * @template T - A ValueTag type
- * @returns The value type with optional phantom tag metadata for dependency inference
+ * 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'.
  *
- * @example
- * ```typescript
- * const ApiKeyTag = Tag.of('apiKey')<string>();
- *
- * class UserService extends Tag.Class('UserService') {
- *   constructor(
- *     private db: DatabaseService,        // ClassTag - works automatically
- *     private apiKey: Inject<typeof ApiKeyTag>  // ValueTag - type is string, tag preserved
- *   ) {
- *     super();
- *   }
- * }
- * ```
- */
-type Inject<T extends ValueTag<unknown, string | symbol>> = T extends ValueTag<infer V, string | symbol> ? V & {
-  readonly [InjectSource]?: T;
-} : never;
-/**
- * Helper type to extract the original ValueTag from an Inject<T> type.
- * Since InjectSource is optional, we need to check for both presence and absence.
  * @internal
  */
-type ExtractInjectTag<T> = T extends {
-  readonly [InjectSource]?: infer U;
-} ? U : never;
+declare const ValueTagIdKey = "__sandly/ValueTagIdKey__";
+declare const ServiceTagIdKey = "__sandly/ServiceTagIdKey__";
 /**
- * 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.
+ * 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
  */
-declare const TagId: "__tag_id__";
+declare const TagTypeKey: unique symbol;
 /**
  * Type representing a value-based dependency tag.
  *
@@ -58,31 +35,30 @@ declare const TagId: "__tag_id__";
  * @example
  * ```typescript
  * // Creates a value tag for string configuration
- * const ApiKeyTag: ValueTag<string, 'apiKey'> = Tag.of('apiKey')<string>();
+ * const ApiKeyTag: ValueTag<'apiKey', string> = Tag.of('apiKey')<string>();
  *
  * // Register in container
  * container.register(ApiKeyTag, () => 'my-secret-key');
  * ```
  */
-interface ValueTag<T, Id extends string | symbol> {
-  readonly [TagId]: Id;
-  /** @internal Phantom type to carry T */
-  readonly __type: T;
+interface ValueTag<Id extends TagId, T> {
+  readonly [ValueTagIdKey]: Id;
+  readonly [TagTypeKey]: T;
 }
 /**
  * Type representing a class-based dependency tag.
  *
- * Tagged classes are created by Tag.Class() and serve as both the dependency identifier
+ * Tagged classes are created by Tag.Service() and serve as both the dependency identifier
  * and the constructor for the service. They extend regular classes with tag metadata
  * that the DI system uses for identification and type safety.
  *
- * @template T - The type of instances created by this tagged class
  * @template Id - The unique identifier for this tag (string or symbol)
+ * @template T - The type of instances created by this tagged class
  *
  * @example
  * ```typescript
  * // Creates a tagged class
- * class UserService extends Tag.Class('UserService') {
+ * class UserService extends Tag.Service('UserService') {
  *   getUsers() { return []; }
  * }
  *
@@ -90,13 +66,13 @@ interface ValueTag<T, Id extends string | symbol> {
  * container.register(UserService, () => new UserService());
  * ```
  *
- * @internal - Users should use Tag.Class() instead of working with this type directly
+ * @internal - Users should use Tag.Service() instead of working with this type directly
  */
-interface ClassTag<T, Id extends string | symbol> {
+interface ServiceTag<Id extends TagId, T> {
   new (...args: any[]): T & {
-    readonly [TagId]: Id;
+    readonly [ServiceTagIdKey]: Id;
   };
-  readonly [TagId]: Id;
+  readonly [ServiceTagIdKey]: Id;
 }
 /**
  * Utility type that extracts the service type from any dependency tag.
@@ -105,7 +81,7 @@ interface ClassTag<T, Id extends string | symbol> {
  * the container and layers to automatically determine what type of service
  * a given tag represents without manual type annotations.
  *
- * @template T - Any dependency tag (ValueTag or ClassTag)
+ * @template T - Any dependency tag (ValueTag or ServiceTag)
  * @returns The service type that the tag represents
  *
  * @example With value tags
@@ -117,9 +93,9 @@ interface ClassTag<T, Id extends string | symbol> {
  * type ConfigService = TagType<typeof ConfigTag>; // { apiKey: string }
  * ```
  *
- * @example With class tags
+ * @example With service tags
  * ```typescript
- * class UserService extends Tag.Class('UserService') {
+ * class UserService extends Tag.Service('UserService') {
  *   getUsers() { return []; }
  * }
  *
@@ -132,11 +108,11 @@ interface ClassTag<T, Id extends string | symbol> {
  * container.register(StringTag, () => 'hello'); // Factory must return string
  * container.register(UserService, () => new UserService()); // Factory must return UserService
  *
- * const str: string = await container.get(StringTag); // Automatically typed as string
- * const user: UserService = await container.get(UserService); // Automatically typed as UserService
+ * const str: string = await container.resolve(StringTag); // Automatically typed as string
+ * const user: UserService = await container.resolve(UserService); // Automatically typed as UserService
  * ```
  */
-type TagType<T> = T extends ValueTag<infer V, string | symbol> ? V : T extends ClassTag<infer V, string | symbol> ? V : never;
+type TagType<TTag extends AnyTag> = TTag extends ValueTag<any, infer T> ? T : TTag extends ServiceTag<any, infer T> ? T : never;
 /**
  * Union type representing any valid dependency tag in the system.
  *
@@ -152,15 +128,15 @@ type TagType<T> = T extends ValueTag<infer V, string | symbol> ? V : T extends C
  *
  * @example Class tag
  * ```typescript
- * class DatabaseService extends Tag.Class('DatabaseService') {}
+ * class DatabaseService extends Tag.Service('DatabaseService') {}
  * // DatabaseService satisfies AnyTag
  * ```
  */
-type AnyTag = ValueTag<any, string | symbol> | ClassTag<any, string | symbol>;
+type AnyTag = ValueTag<TagId, any> | ServiceTag<TagId, any>;
 /**
  * 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.
  */
@@ -220,7 +196,7 @@ declare const Tag: {
    * }));
    * ```
    */
-  of: <Id extends string | symbol>(id: Id) => <T>() => ValueTag<T, Id>;
+  of: <Id extends TagId>(id: Id) => <T>() => ValueTag<Id, T>;
   /**
    * Creates an anonymous value tag with a unique symbol identifier.
    *
@@ -254,7 +230,7 @@ declare const Tag: {
    * console.log(ConfigA === ConfigB); // false
    * ```
    */
-  for: <T>() => ValueTag<T, symbol>;
+  for: <T>() => ValueTag<symbol, T>;
   /**
    * Creates a base class that can be extended to create service classes with dependency tags.
    *
@@ -268,7 +244,7 @@ declare const Tag: {
    *
    * @example Basic service class
    * ```typescript
-   * class UserService extends Tag.Class('UserService') {
+   * class UserService extends Tag.Service('UserService') {
    *   getUsers() {
    *     return ['alice', 'bob'];
    *   }
@@ -279,11 +255,11 @@ declare const Tag: {
    *
    * @example Service with dependencies
    * ```typescript
-   * class DatabaseService extends Tag.Class('DatabaseService') {
+   * class DatabaseService extends Tag.Service('DatabaseService') {
    *   query(sql: string) { return []; }
    * }
    *
-   * class UserRepository extends Tag.Class('UserRepository') {
+   * class UserRepository extends Tag.Service('UserRepository') {
    *   constructor(private db: DatabaseService) {
    *     super();
    *   }
@@ -296,22 +272,22 @@ declare const Tag: {
    * container
    *   .register(DatabaseService, () => new DatabaseService())
    *   .register(UserRepository, async (ctx) =>
-   *     new UserRepository(await ctx.get(DatabaseService))
+   *     new UserRepository(await ctx.resolve(DatabaseService))
    *   );
    * ```
    *
    * @example With symbol identifiers
    * ```typescript
-   * const SERVICE_ID = Symbol('InternalService');
+   * const ServiceId = Symbol('InternalService');
    *
-   * class InternalService extends Tag.Class(SERVICE_ID) {
+   * class InternalService extends Tag.Service(ServiceId) {
    *   doInternalWork() { return 'work'; }
    * }
    * ```
    */
-  Class: <Id extends string | symbol>(id: Id) => ClassTag<{
-    readonly __tag_id__: Id;
-  }, Id>;
+  Service: <Id extends TagId>(id: Id) => ServiceTag<Id, {
+    readonly "__sandly/ServiceTagIdKey__": Id;
+  }>;
   /**
    * Extracts the string representation of a tag's identifier.
    *
@@ -319,14 +295,14 @@ declare const Tag: {
    * whether it's a string-based or symbol-based tag. Primarily used internally
    * for error messages and debugging.
    *
-   * @param tag - Any valid dependency tag (value tag or class tag)
+   * @param tag - Any valid dependency tag (value tag or service tag)
    * @returns String representation of the tag's identifier
    *
    * @example
    * ```typescript
    * const StringTag = Tag.of('myString')<string>();
    * const SymbolTag = Tag.for<number>();
-   * class ServiceClass extends Tag.Class('MyService') {}
+   * class ServiceClass extends Tag.Service('MyService') {}
    *
    * console.log(Tag.id(StringTag)); // "myString"
    * console.log(Tag.id(SymbolTag)); // "Symbol()"
@@ -335,11 +311,54 @@ declare const Tag: {
    *
    * @internal - Primarily for internal use in error messages and debugging
    */
-  id: (tag: AnyTag) => string;
+  id: (tag: AnyTag) => TagId;
+  isTag: (tag: unknown) => tag is AnyTag;
 };
+/**
+ * Unique symbol used to store the original ValueTag in Inject<T> types.
+ * This prevents property name collisions while allowing type-level extraction.
+ */
+declare const InjectSource: unique symbol;
+/**
+ * Helper type for injecting ValueTag dependencies in constructor parameters.
+ * This allows clean specification of ValueTag dependencies while preserving
+ * the original tag information for dependency inference.
+ *
+ * The phantom property is optional to allow normal runtime values to be assignable.
+ *
+ * @template T - A ValueTag type
+ * @returns The value type with optional phantom tag metadata for dependency inference
+ *
+ * @example
+ * ```typescript
+ * const ApiKeyTag = Tag.of('apiKey')<string>();
+ *
+ * class UserService extends Tag.Service('UserService') {
+ *   constructor(
+ *     private db: DatabaseService,        // ServiceTag - works automatically
+ *     private apiKey: Inject<typeof ApiKeyTag>  // ValueTag - type is string, tag preserved
+ *   ) {
+ *     super();
+ *   }
+ * }
+ * ```
+ */
+type Inject<T extends ValueTag<TagId, unknown>> = T extends ValueTag<any, infer V> ? V & {
+  readonly [InjectSource]?: T;
+} : never;
+/**
+ * Helper type to extract the original ValueTag from an Inject<T> type.
+ * Since InjectSource is optional, we need to check for both presence and absence.
+ * @internal
+ */
+type ExtractInjectTag<T> = T extends {
+  readonly [InjectSource]?: infer U;
+} ? U : never;
 //#endregion
 //#region src/types.d.ts
 type PromiseOrValue<T> = T | Promise<T>;
+type Contravariant<A> = (_: A) => void;
+type Covariant<A> = (_: never) => A;
 //#endregion
 //#region src/container.d.ts
 /**
@@ -366,8 +385,8 @@ type PromiseOrValue<T> = T | Promise<T>;
  * ```typescript
  * const factory: Factory<UserService, typeof ConfigTag | typeof DatabaseService> = async (ctx) => {
  *   const [config, db] = await Promise.all([
- *     ctx.get(ConfigTag),
- *     ctx.get(DatabaseService)
+ *     ctx.resolve(ConfigTag),
+ *     ctx.resolve(DatabaseService)
  *   ]);
  *   return new UserService(config, db);
  * };
@@ -427,7 +446,7 @@ type Finalizer<T> = (instance: T) => PromiseOrValue<void>;
  *
  * @example Using DependencyLifecycle for registration
  * ```typescript
- * class DatabaseConnection extends Tag.Class('DatabaseConnection') {
+ * class DatabaseConnection extends Tag.Service('DatabaseConnection') {
  *   async connect() { return; }
  *   async disconnect() { return; }
  * }
@@ -443,7 +462,7 @@ type Finalizer<T> = (instance: T) => PromiseOrValue<void>;
  *   }
  * };
  *
- * container().register(DatabaseConnection, lifecycle);
+ * Container.empty().register(DatabaseConnection, lifecycle);
  * ```
  */
 type DependencyLifecycle<T, TReg extends AnyTag> = {
@@ -465,7 +484,7 @@ type DependencyLifecycle<T, TReg extends AnyTag> = {
  * const spec: DependencySpec<typeof UserService, never> =
  *   () => new UserService();
  *
- * container().register(UserService, spec);
+ * Container.empty().register(UserService, spec);
  * ```
  *
  * @example Lifecycle registration
@@ -475,29 +494,34 @@ type DependencyLifecycle<T, TReg extends AnyTag> = {
  *   finalizer: (conn) => conn.close()
  * };
  *
- * container().register(DatabaseConnection, spec);
+ * Container.empty().register(DatabaseConnection, spec);
  * ```
  */
 type DependencySpec<T extends AnyTag, TReg extends AnyTag> = Factory<TagType<T>, TReg> | DependencyLifecycle<TagType<T>, TReg>;
 /**
  * Type representing the context available to factory functions during dependency resolution.
  *
- * This type contains only the `get` method from the container, which is used to retrieve
+ * This type contains only the `resolve` and `resolveAll` methods from the container, which are used to retrieve
  * other dependencies during the creation of a service.
  *
  * @template TReg - Union type of all dependencies available in the container
  */
-type ResolutionContext<TReg extends AnyTag> = Pick<IContainer<TReg>, 'get'>;
+type ResolutionContext<TReg extends AnyTag> = Pick<IContainer<TReg>, 'resolve' | 'resolveAll'>;
+declare const ContainerTypeId: unique symbol;
 /**
  * Interface representing a container that can register and retrieve dependencies.
  *
  * @template TReg - Union type of all dependencies available in the container
  */
-interface IContainer<in TReg extends AnyTag> {
-  register<T extends AnyTag>(tag: T, spec: DependencySpec<T, TReg>): IContainer<TReg | T>;
+interface IContainer<TReg extends AnyTag = never> {
+  readonly [ContainerTypeId]: {
+    readonly _TReg: Contravariant<TReg>;
+  };
+  register: <T extends AnyTag>(tag: T, spec: DependencySpec<T, TReg>) => IContainer<TReg | T>;
   has(tag: AnyTag): boolean;
   exists(tag: AnyTag): boolean;
-  get<T extends TReg>(tag: T): Promise<TagType<T>>;
+  resolve: <T extends TReg>(tag: T) => Promise<TagType<T>>;
+  resolveAll: <const T extends readonly TReg[]>(...tags: T) => Promise<{ [K in keyof T]: TagType<T[K]> }>;
   merge<TTarget extends AnyTag>(other: IContainer<TTarget>): IContainer<TReg | TTarget>;
   destroy(): Promise<void>;
 }
@@ -512,26 +536,26 @@ interface IContainer<in TReg extends AnyTag> {
  *
  * @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 c = 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
@@ -539,22 +563,22 @@ interface IContainer<in TReg extends AnyTag> {
  * 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();
@@ -568,7 +592,10 @@ interface IContainer<in TReg extends AnyTag> {
  * await c.destroy(); // Calls all finalizers
  * ```
  */
-declare class Container<in TReg extends AnyTag = never> implements IContainer<TReg> {
+declare class Container<TReg extends AnyTag> implements IContainer<TReg> {
+  readonly [ContainerTypeId]: {
+    readonly _TReg: Contravariant<TReg>;
+  };
   /**
    * Cache of instantiated dependencies as promises.
    * Ensures singleton behavior and supports concurrent access.
@@ -590,12 +617,13 @@ declare class Container<in TReg extends AnyTag = never> implements IContainer<TR
    * @internal
    */
   protected isDestroyed: boolean;
+  static empty(): Container<never>;
   /**
    * 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.
@@ -610,11 +638,11 @@ declare class Container<in TReg extends AnyTag = never> implements IContainer<TR
    *
    * @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()
    * );
@@ -622,24 +650,24 @@ declare class Container<in TReg extends AnyTag = never> implements IContainer<TR
    *
    * @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 (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 c = Container.empty()
    *   .register(DatabaseService, () => new DatabaseService())
    *   .register(DatabaseService, () => new MockDatabaseService()); // Overrides the previous registration
    * ```
@@ -648,7 +676,7 @@ declare class Container<in TReg extends AnyTag = never> implements IContainer<TR
    * ```typescript
    * const ConfigTag = Tag.of('config')<{ apiUrl: string }>();
    *
-   * const c = container().register(
+   * const c = Container.empty().register(
    *   ConfigTag,
    *   () => ({ apiUrl: 'https://api.example.com' })
    * );
@@ -656,12 +684,12 @@ declare class Container<in TReg extends AnyTag = never> implements IContainer<TR
    *
    * @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();
@@ -684,7 +712,7 @@ declare class Container<in TReg extends AnyTag = never> implements IContainer<TR
    *
    * @example
    * ```typescript
-   * const c = container().register(DatabaseService, () => new DatabaseService());
+   * const c = Container.empty().register(DatabaseService, () => new DatabaseService());
    * console.log(c.has(DatabaseService)); // true
    * ```
    */
@@ -715,10 +743,10 @@ declare class Container<in TReg extends AnyTag = never> implements IContainer<TR
    *
    * @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');
    * ```
    *
@@ -726,9 +754,9 @@ declare class Container<in TReg extends AnyTag = never> implements IContainer<TR
    * ```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
@@ -736,17 +764,58 @@ declare class Container<in TReg extends AnyTag = never> implements IContainer<TR
    *
    * @example Dependency injection in factories
    * ```typescript
-   * const c = container()
+   * const c = 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);
    * ```
    */
-  get<T extends TReg>(tag: T): Promise<TagType<T>>;
+  resolve<T extends TReg>(tag: T): Promise<TagType<T>>;
+  /**
+   * 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
+   * ```
+   */
+  resolveAll<const T extends readonly TReg[]>(...tags: T): Promise<{ [K in keyof T]: TagType<T[K]> }>;
   /**
    * Copies all registrations from this container to a target container.
    *
@@ -771,10 +840,10 @@ declare class Container<in TReg extends AnyTag = never> implements IContainer<TR
    *
    * @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);
@@ -803,7 +872,7 @@ declare class Container<in TReg extends AnyTag = never> implements IContainer<TR
    *
    * @example Basic cleanup
    * ```typescript
-   * const c = container()
+   * const c = Container.empty()
    *   .register(DatabaseConnection,
    *     async () => {
    *       const conn = new DatabaseConnection();
@@ -813,12 +882,12 @@ declare class Container<in TReg extends AnyTag = never> implements IContainer<TR
    *     (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"
    * }
@@ -826,9 +895,9 @@ declare class Container<in TReg extends AnyTag = never> implements IContainer<TR
    *
    * @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 () => {
@@ -855,32 +924,6 @@ declare class Container<in TReg extends AnyTag = never> implements IContainer<TR
    */
   destroy(): Promise<void>;
 }
-/**
- * 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);
- * ```
- */
-declare function container(): Container;
 //#endregion
 //#region src/errors.d.ts
 type ErrorProps = {
@@ -917,7 +960,7 @@ declare 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);
@@ -938,7 +981,7 @@ declare class DependencyAlreadyInstantiatedError 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.
  */
@@ -946,16 +989,16 @@ declare class ContainerDestroyedError 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);
@@ -981,19 +1024,19 @@ declare class UnknownDependencyError 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 c = 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);
@@ -1020,14 +1063,14 @@ declare class CircularDependencyError 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 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);
@@ -1077,18 +1120,13 @@ declare class DependencyFinalizationError extends ContainerError {
 //#endregion
 //#region src/layer.d.ts
 /**
- * The most generic layer type that works with variance - accepts any concrete layer.
- *
- * This type is carefully constructed to work with the Layer interface's variance annotations:
- * - `never` for TRequires (contravariant): Any layer requiring specific dependencies can be
- *   assigned to this since requiring something is more restrictive than requiring nothing
- * - `AnyTag` for TProvides (covariant): Any layer providing specific services can be assigned
- *   to this since the general AnyTag type can represent any specific tag type
- *
- * Used internally for functions like Layer.mergeAll() that need to accept arrays of layers
- * with different requirement/provision types while preserving type safety through variance.
+ * The most generic layer type that accepts any concrete layer.
  */
-type AnyLayer = Layer<never, AnyTag>;
+type AnyLayer = Layer<any, any>;
+/**
+ * The type ID for the Layer interface.
+ */
+declare const LayerTypeId: unique symbol;
 /**
  * A dependency layer represents a reusable, composable unit of dependency registrations.
  * Layers allow you to organize your dependency injection setup into logical groups
@@ -1098,12 +1136,12 @@ type AnyLayer = Layer<never, AnyTag>;
  *
  * The Layer interface uses TypeScript's variance annotations to enable safe substitutability:
  *
- * ### TRequires (contravariant with `in`)
+ * ### TRequires (covariant)
  * A layer requiring fewer dependencies can substitute one requiring more:
  * - `Layer<never, X>` can be used where `Layer<A | B, X>` is expected
  * - Intuition: A service that needs nothing is more flexible than one that needs specific deps
  *
- * ### TProvides (covariant with `out`)
+ * ### TProvides (contravariant)
  * A layer providing more services can substitute one providing fewer:
  * - `Layer<X, A | B>` can be used where `Layer<X, A>` is expected
  * - Intuition: A service that gives you extra things is compatible with expecting fewer things
@@ -1115,7 +1153,7 @@ type AnyLayer = Layer<never, AnyTag>;
  * ```typescript
  * import { layer, Tag, container } from 'sandly';
  *
- * class DatabaseService extends Tag.Class('DatabaseService') {
+ * class DatabaseService extends Tag.Service('DatabaseService') {
  *   query() { return 'data'; }
  * }
  *
@@ -1125,10 +1163,10 @@ type AnyLayer = Layer<never, AnyTag>;
  * );
  *
  * // Apply the layer to a container
- * const c = container();
+ * const c = Container.empty();
  * const finalContainer = databaseLayer.register(c);
  *
- * const db = await finalContainer.get(DatabaseService);
+ * const db = await finalContainer.resolve(DatabaseService);
  * ```
  *
  * @example Layer composition with variance
@@ -1136,18 +1174,19 @@ type AnyLayer = Layer<never, AnyTag>;
  * // Layer that requires DatabaseService and provides UserService
  * const userLayer = layer<typeof DatabaseService, typeof UserService>((container) =>
  *   container.register(UserService, async (ctx) =>
- *     new UserService(await ctx.get(DatabaseService))
+ *     new UserService(await ctx.resolve(DatabaseService))
  *   )
  * );
  *
  * // Compose layers: provide database layer to user layer
  * const appLayer = userLayer.provide(databaseLayer);
- *
- * // Thanks to variance, Layer<never, typeof DatabaseService> automatically works
- * // where Layer<typeof DatabaseService, typeof UserService> requires DatabaseService
  * ```
  */
-interface Layer<in TRequires extends AnyTag = never, out TProvides extends AnyTag = never> {
+interface Layer<TRequires extends AnyTag, TProvides extends AnyTag> {
+  readonly [LayerTypeId]?: {
+    readonly _TRequires: Covariant<TRequires>;
+    readonly _TProvides: Contravariant<TProvides>;
+  };
   /**
    * Applies this layer's registrations to the given container.
    *
@@ -1165,13 +1204,13 @@ interface Layer<in TRequires extends AnyTag = never, out TProvides extends AnyTa
    *
    * @example Basic usage
    * ```typescript
-   * const c = container();
+   * const c = Container.empty();
    * const updatedContainer = myLayer.register(c);
    * ```
    *
    * @example With existing services preserved
    * ```typescript
-   * const baseContainer = container()
+   * const baseContainer = Container.empty()
    *   .register(ExistingService, () => new ExistingService());
    *
    * const enhanced = myLayer.register(baseContainer);
@@ -1286,7 +1325,7 @@ interface Layer<in TRequires extends AnyTag = never, out TProvides extends AnyTa
  * ```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'; }
  * }
@@ -1311,15 +1350,15 @@ interface Layer<in TRequires extends AnyTag = never, out TProvides extends AnyTa
  * 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))
  *     )
  * );
  *
@@ -1338,7 +1377,7 @@ declare function layer<TRequires extends AnyTag = never, TProvides extends AnyTa
  *
  * @internal
  */
-type UnionOfRequires<T extends readonly AnyLayer[]> = { [K in keyof T]: T[K] extends Layer<infer R, AnyTag> ? R : never }[number];
+type UnionOfRequires<T extends readonly AnyLayer[]> = { [K in keyof T]: T[K] extends Layer<infer R, any> ? R : never }[number];
 /**
  * Helper type that extracts the union of all provisions from an array of layers.
  * Used by Layer.mergeAll() to compute the correct provision type for the merged layer.
@@ -1349,7 +1388,7 @@ type UnionOfRequires<T extends readonly AnyLayer[]> = { [K in keyof T]: T[K] ext
  *
  * @internal
  */
-type UnionOfProvides<T extends readonly AnyLayer[]> = { [K in keyof T]: T[K] extends Layer<never, infer P> ? P : never }[number];
+type UnionOfProvides<T extends readonly AnyLayer[]> = { [K in keyof T]: T[K] extends Layer<any, infer P> ? P : never }[number];
 /**
  * Utility object containing helper functions for working with layers.
  */
@@ -1370,7 +1409,7 @@ declare const Layer: {
    *   .merge(serviceLayer);
    * ```
    */
-  empty(): Layer;
+  empty(): Layer<never, never>;
   /**
    * Merges multiple layers at once in a type-safe way.
    * This is equivalent to chaining `.merge()` calls but more convenient for multiple layers.
@@ -1461,11 +1500,12 @@ declare const Layer: {
 //#endregion
 //#region src/scoped-container.d.ts
 type Scope = string | symbol;
-declare class ScopedContainer<in TReg extends AnyTag = never> extends Container<TReg> {
+declare class ScopedContainer<TReg extends AnyTag> extends Container<TReg> {
   readonly scope: Scope;
   private parent;
   private readonly children;
-  constructor(parent: IContainer<TReg> | null, scope: Scope);
+  protected constructor(parent: IContainer<TReg> | null, scope: Scope);
+  static empty(scope: Scope): ScopedContainer<never>;
   /**
    * Registers a dependency in the scoped container.
    *
@@ -1496,7 +1536,7 @@ declare class ScopedContainer<in TReg extends AnyTag = never> extends Container<
    * 3. Otherwise, delegate to parent scope
    * 4. If no parent or parent doesn't have it, throw UnknownDependencyError
    */
-  get<T extends TReg>(tag: T): Promise<TagType<T>>;
+  resolve<T extends TReg>(tag: T): Promise<TagType<T>>;
   /**
    * Destroys this scoped container and its children, preserving the container structure for reuse.
    *
@@ -1548,7 +1588,7 @@ declare class ScopedContainer<in TReg extends AnyTag = never> extends Container<
  * ```typescript
  * import { container, scoped } from 'sandly';
  *
- * const appContainer = container()
+ * const appContainer = Container.empty()
  *   .register(DatabaseService, () => new DatabaseService())
  *   .register(ConfigService, () => new ConfigService());
  *
@@ -1560,10 +1600,10 @@ declare class ScopedContainer<in TReg extends AnyTag = never> 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()
  *   });
  *
@@ -1575,49 +1615,58 @@ declare function scoped<TReg extends AnyTag>(container: Container<TReg>, scope:
 //#endregion
 //#region src/service.d.ts
 /**
- * Extracts constructor parameter types from a ClassTag.
+ * Extracts constructor parameter types from a ServiceTag.
  * Only parameters that extend AnyTag are considered as dependencies.
+ * @internal
+ */
+type ConstructorParams<T extends ServiceTag<TagId, unknown>> = T extends (new (...args: infer A) => unknown) ? A : never;
+/**
+ * Extracts only dependency tags from a constructor parameter list.
+ * Filters out non‑DI parameters.
+ *
+ * Example:
+ *   [DatabaseService, Inject<typeof ConfigTag>, number]
+ *     → typeof DatabaseService | typeof ConfigTag
+ * @internal
  */
-type ConstructorParams<T extends ClassTag<unknown, string | symbol>> = T extends (new (...args: infer A) => unknown) ? A : never;
+type ExtractConstructorDeps<T extends readonly unknown[]> = T extends readonly [] ? never : { [K in keyof T]: T[K] extends {
+  readonly [ServiceTagIdKey]: infer Id;
+} ? Id extends TagId ? ServiceTag<Id, T[K]> : never : ExtractInjectTag<T[K]> extends never ? never : ExtractInjectTag<T[K]> }[number];
 /**
- * Helper to convert a tagged instance type back to its constructor type.
- * This uses the fact that tagged classes have a specific structure with TagId property.
+ * Produces an ordered tuple of constructor parameters
+ * where dependency parameters are replaced with their tag types,
+ * while non‑DI parameters are preserved as‑is.
+ * @internal
  */
-type InstanceToConstructorType<T> = T extends {
-  readonly [TagId]: infer Id;
-} ? Id extends string | symbol ? ClassTag<T, Id> : never : never;
+
 /**
- * Extracts constructor-typed dependencies from constructor parameters.
- * Converts instance types to their corresponding constructor types.
- * Handles both ClassTag dependencies (automatic) and ValueTag dependencies (via Inject helper).
+ * Union of all dependency tags a ServiceTag constructor requires.
+ * Filters out non‑DI parameters.
  */
-type FilterTags<T extends readonly unknown[]> = T extends readonly [] ? never : { [K in keyof T]: T[K] extends {
-  readonly [TagId]: string | symbol;
-} ? InstanceToConstructorType<T[K]> : ExtractInjectTag<T[K]> extends never ? never : ExtractInjectTag<T[K]> }[number];
+type ServiceDependencies<T extends ServiceTag<TagId, unknown>> = ExtractConstructorDeps<ConstructorParams<T>> extends AnyTag ? ExtractConstructorDeps<ConstructorParams<T>> : never;
 /**
- * Extracts only the dependency tags from a constructor's parameters for ClassTag services,
- * or returns never for ValueTag services (which have no constructor dependencies).
- * This is used to determine what dependencies a service requires.
+ * Ordered tuple of dependency tags (and other constructor params)
+ * inferred from a ServiceTag’s constructor.
  */
-type ServiceDependencies<T extends AnyTag> = T extends ClassTag<unknown, string | symbol> ? FilterTags<ConstructorParams<T>> extends AnyTag ? FilterTags<ConstructorParams<T>> : never : never;
+
 /**
- * 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); }
  * }
  *
@@ -1626,11 +1675,11 @@ type ServiceDependencies<T extends AnyTag> = T extends ClassTag<unknown, string
  *
  * @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();
  *   }
@@ -1639,11 +1688,107 @@ type ServiceDependencies<T extends AnyTag> = T extends ClassTag<unknown, string
  * }
  *
  * const userService = service(UserService, async (ctx) =>
- *   new UserService(await ctx.get(DatabaseService))
+ *   new UserService(await ctx.resolve(DatabaseService))
+ * );
+ * ```
+ */
+declare function service<T extends ServiceTag<TagId, unknown>>(tag: T, spec: DependencySpec<T, ServiceDependencies<T>>): Layer<ServiceDependencies<T>, T>;
+/**
+ * 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,
+ *   ['postgresql://localhost:5432/mydb'],
+ *   (service) => service.disconnect() // Finalizer for cleanup
  * );
  * ```
  */
-declare function service<T extends AnyTag>(serviceClass: T, spec: DependencySpec<T, ServiceDependencies<T>>): Layer<ServiceDependencies<T>, T>;
 //#endregion
 //#region src/value.d.ts
 /**
@@ -1664,6 +1809,6 @@ declare function service<T extends AnyTag>(serviceClass: T, spec: DependencySpec
  * const config = Layer.merge(apiKey, dbUrl);
  * ```
  */
-declare function value<T, Id extends string | symbol>(tag: ValueTag<T, Id>, constantValue: T): Layer<never, ValueTag<T, Id>>;
+declare function value<Id extends TagId, T>(tag: ValueTag<Id, T>, constantValue: T): Layer<never, ValueTag<Id, T>>;
 //#endregion
-export { type AnyLayer, type AnyTag, CircularDependencyError, type ClassTag, Container, ContainerDestroyedError, ContainerError, DependencyAlreadyInstantiatedError, DependencyCreationError, DependencyFinalizationError, type DependencyLifecycle, type Factory, type Finalizer, type IContainer, type Inject, Layer, type PromiseOrValue, type ResolutionContext, type Scope, ScopedContainer, Tag, type TagType, UnknownDependencyError, type ValueTag, container, layer, scoped, service, value };
+export { type AnyLayer, type AnyTag, CircularDependencyError, Container, ContainerDestroyedError, ContainerError, DependencyAlreadyInstantiatedError, DependencyCreationError, DependencyFinalizationError, type DependencyLifecycle, type DependencySpec, type Factory, type Finalizer, type IContainer, type Inject, InjectSource, Layer, type PromiseOrValue, type ResolutionContext, type Scope, ScopedContainer, type ServiceTag, Tag, type TagType, UnknownDependencyError, type ValueTag, layer, scoped, service, value };