@decohere/crucible 0.0.1-dev.20 → 0.0.1-dev.20261105.103

package/LICENSE

@@ -0,0 +1,15 @@
+ISC License
+
+Copyright (c) 2025-2026 Typesmiths
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/README.md

@@ -0,0 +1,354 @@
+# @decohere/crucible
+
+Lightweight dependency injection for Decohere. Register classes (or tokens) on a `ServiceContainerBuilder`, `build()` a container, then `resolve()` graphs of constructor-injected services.
+
+Higher layers (for example `@decohere/http`'s `Builder.withServices`) register on a `ServiceContainerBuilder`. You can also build and resolve from a container yourself.
+
+## When to use
+
+| Use `@decohere/crucible` | Do not use it |
+|---|---|
+| Constructor-injected services and controllers | Replacing the HTTP, config or data packages — those compose *on top of* the container |
+| Tokens for interfaces, config objects, and “many of this kind” | Auto-scanning folders or Nest-style modules (not in this package) |
+| Request / singleton / transient lifetimes and `using` disposal | Compile-time graph checking (the graph is checked when a service is first resolved) |
+
+## Install
+
+```bash
+npm i @decohere/crucible
+```
+
+```ts
+import { ServiceContainerBuilder, LifetimeScopeToken, Scopes } from "@decohere/crucible";
+import { inject, injectable } from "@decohere/crucible/decorators";
+```
+
+Decorator metadata is required. Enable it in `tsconfig.json` (the Decohere scaffold and this repo already do):
+
+```json
+{
+  "compilerOptions": {
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true
+  }
+}
+```
+
+`@decohere/core/reflection` loads `reflect-metadata`. Import `@decohere/crucible` (or `@decohere/core`) before constructing decorated classes.
+
+---
+
+## Constructor injection — `@inject` is usually unnecessary
+
+If the constructor parameter is a **concrete class**, the container reads `design:paramtypes` and resolves that class. Mark the *consumer* `@injectable()` so TypeScript/SWC emit that metadata. Do **not** add `@inject` for that parameter.
+
+```ts
+import { injectable } from "@decohere/crucible/decorators";
+import { SampleService } from "./sample.service.js";
+
+@injectable()
+export class HelloController {
+  public constructor(private readonly sample: SampleService) {}
+}
+```
+
+```ts
+import { ServiceContainerBuilder } from "@decohere/crucible";
+
+const builder = new ServiceContainerBuilder();
+builder.registerSingleton(SampleService);
+builder.registerRequestScoped(HelloController);
+const container = builder.build();
+
+using scope = container.beginScope("req");
+const hello = scope.resolve(HelloController);
+```
+
+`@injectable()` is an empty class decorator. Its job is to force `design:paramtypes` onto the constructor. Any other class decorator (`@Controller()`, `@Trace`, …) also does that; `@injectable()` is the one to use when there is nothing else.
+
+### Do not `import type` injected classes
+
+`import type` is erased at compile time. `emitDecoratorMetadata` then records `Object` (or nothing) instead of the constructor. The container cannot tell what to inject and **throws `ResolveError`** when the consumer is resolved, naming the parameter and telling you to add `@inject`.
+
+```ts
+// Wrong — SampleService does not exist at runtime, paramtypes collapse to Object
+import type { SampleService } from "./sample.service.js";
+
+// Right — value import keeps the constructor for reflect-metadata
+import { SampleService } from "./sample.service.js";
+```
+
+`import type` is correct for **interfaces** and type-only helpers. Those have no runtime constructor; pair them with `@inject(token)` (see below).
+
+Linters that prefer type-only imports (`import type` / `import { type X }`) will flag a class that appears unused except as a constructor type. Keep the value import and suppress that rule locally — for example with oxlint (or Biome, or ESLint):
+
+```ts
+// oxlint-disable-next-line typescript/consistent-type-imports -- constructor injection needs the class at runtime
+import { Workspace } from "@decohere/workspace";
+```
+
+That pattern is used throughout Forge (`Build`, `Clean`, …). Same idea applies to ESLint `consistent-type-imports` or equivalent.
+
+---
+
+## When you *do* need `@inject`
+
+`@inject(key)` overrides the paramtypes lookup with an explicit key: a class constructor, string, or symbol. Use it when there is no useful constructor in `design:paramtypes`.
+
+| Situation | Why `@inject` |
+|---|---|
+| Interface or type alias (`ISampleStore`) | No runtime class; paramtypes is `Object` |
+| String / symbol token | The service is registered under the token, not the class |
+| Array of implementations (`Transformer[]`) | Paramtypes is `Array`, which says nothing about the element type |
+| Paramtypes collapsed to `Object` (the class's import was dropped) | `@inject(TheClass)` uses the class as a value, so its import is kept |
+
+```ts
+import { inject, injectable } from "@decohere/crucible/decorators";
+
+export const SampleStoreToken = Symbol("SampleStore");
+
+export interface ISampleStore {
+  get(id: string): Promise<unknown>;
+}
+
+@injectable()
+export class SampleService {
+  public constructor(
+    @inject(SampleStoreToken) private readonly store: ISampleStore,
+  ) {}
+}
+```
+
+Keep tokens in a `const.ts` (or next to the interface). Register against the same token:
+
+```ts
+builder.registerSingleton(SampleStoreToken, PostgresSampleStore);
+// or an already-built instance:
+builder.registerSingleton(SampleStoreToken, store);
+```
+
+`@inject` takes `string | symbol | Constructable`. To inject a class, pass the class: `@inject("SampleService")` does **not** find `SampleService` (see [Keys](#registration-and-lifetimes)). Arrays use `resolveMany` automatically when the reflected type is `Array`. For a dependency that may be absent, add `@optional()` (see [Optional / missing](#optional--missing-dependencies)).
+
+---
+
+## Registration and lifetimes
+
+Keys match by **identity** ([ADR 0013](../../docs/adr/0013-container-keys-and-lifetimes.md)): a class matches only itself, a symbol only itself, a string only an equal string. So `resolve("SampleService")` does not find `registerSingleton(SampleService)`, `Symbol("TokenService")` does not collide with a class `TokenService`, two classes with the same name in different modules stay apart, and minified class names still work.
+
+Registering the same class (or the same type on a token) twice **throws** `RegistrationError` — silent last-wins hides accidental double-registers. Replace it explicitly:
+
+```ts
+builder.override.registerSingleton(SampleService);
+builder.override.registerTransient(SampleService);
+```
+
+`builder.override` is a registrar with replace already bound — the builder itself is not mutated. Two different types on one token is still multi-bind: `resolve` throws `ResolveError`, `resolveMany` returns both.
+
+| Lifetime | Cached |
+|---|---|
+| Singleton | On the root container — shared with every nested scope |
+| Request | On the current scope — new instance per `beginScope` |
+| Transient | Never — new instance every `resolve` |
+
+A singleton may not depend on a request-scoped service, directly or through transients: it would keep the first request's instance forever (a "captive dependency", e.g. one database connection for the life of the process). Resolving one throws `ResolveError` naming the chain. Make the consumer request-scoped, or inject `LifetimeScopeToken` and resolve the request-scoped service per request. `LifetimeScopeToken` itself is allowed: a singleton gets the root container.
+
+A dependency cycle (`A → B → A`) throws `ResolveError` listing the cycle.
+
+```ts
+builder.registerSingleton(SampleService);
+builder.registerSingleton(Token, SampleService);
+builder.registerSingleton(Token, existingInstance);
+
+builder.registerRequestScoped(HelloController);
+builder.registerRequestScoped(Token, HelloController);
+builder.registerRequestScoped(Token, () => createConnection());
+
+builder.registerTransient(Helper);
+builder.registerTransient(Token, Helper);
+```
+
+`registerType(type, scope?)` and `registerTypes(...)` are the same registrations without the lifetime in the method name (default **transient**). `Scopes.singleton` is the string `"single-instance"`.
+
+HTTP (`@decohere/http`): controllers are **request-scoped** (one per request). Services are usually **singletons**.
+
+`registerSingleton(Class, instance)` binds an existing object under the class. The CLI does this for the workspace:
+
+```ts
+builder.registerSingleton(workspace.constructor, workspace);
+```
+
+---
+
+## Recipes
+
+### Many implementations of one token
+
+Register several types under the same token. Inject them as an array with `@inject(Token)`.
+
+```ts
+export const TransformerKey = Symbol("TransformerKey");
+
+builder.registerSingleton(TransformerKey, SwcTranspiler);
+builder.registerSingleton(TransformerKey, TypeEmitter);
+```
+
+```ts
+@injectable()
+export class Build {
+  public constructor(
+    @inject(TransformerKey) private readonly transformers: Transformer[],
+  ) {}
+}
+```
+
+`resolve(TransformerKey)` **throws** `ResolveError` when more than one registration exists. Use `resolveMany(TransformerKey)` or constructor injection of an array.
+
+### Request scopes and disposal
+
+```ts
+builder.registerRequestScoped(UnitOfWork);
+builder.registerSingleton(Clock);
+const container = builder.build();
+
+{
+  using scope = container.beginScope("req-1");
+  const uow = scope.resolve(UnitOfWork); // per-scope
+  const clock = scope.resolve(Clock); // same singleton as the root
+} // scope[Symbol.dispose]() — request-scoped instances are disposed
+
+await using scope = container.beginScope("req-2");
+// async teardown via Symbol.asyncDispose if the instance implements it
+```
+
+- Child scopes look registrations up in their parent (nothing is copied, so `beginScope` costs the same however many services are registered); they do not share the request-instance cache.
+- Nested `beginScope` is allowed; each level has its own request instances.
+- Named scopes: a live duplicate name throws `DuplicateScopeError`. After dispose, the name can be reused. Unnamed scopes do not collide.
+- Disposing a parent does **not** dispose child scopes. Dispose the scope you created.
+- Singletons are cached on the root container and shared with nested scopes. Resolving a singleton after the root is disposed throws.
+
+`App.dispose` (`@decohere/http`) (Flux HMR / SIGINT) disposes the **root** container, then Scribe. Implement `Symbol.asyncDispose` (or `Symbol.dispose`) on long-lived services — sockets, pools, timers. Only **constructed** instances are disposed (resolve them at boot; transients are not cached). `export default app` is the composition-root contract; do not wrap it for extra teardown.
+
+The current scope is always registered as `LifetimeScopeToken`:
+
+```ts
+import { type LifetimeScope, LifetimeScopeToken } from "@decohere/crucible";
+import { inject, injectable } from "@decohere/crucible/decorators";
+
+@injectable()
+export class ExceptionFilterHost {
+  public constructor(
+    @inject(LifetimeScopeToken) private readonly scope: LifetimeScope,
+  ) {}
+}
+```
+
+### Factories
+
+```ts
+builder.registerRequestScoped("connection", () => createConnection());
+const connection = container.resolve("connection");
+```
+
+Arrow factories are called as functions (not `new`). Use them when construction needs arguments the container should not know about.
+
+### Optional / missing dependencies
+
+A missing registration **throws** `ResolveError`, naming the chain that needed it (`App → Router → Symbol(AuthorizationService)`). `resolveMany` returns `[]` instead. A `?` on the parameter type does not make it optional to the container; add `@optional()`, and the container passes `undefined` (so a default value applies):
+
+```ts
+import { inject, injectable, optional } from "@decohere/crucible/decorators";
+
+@injectable()
+export class App {
+  public constructor(
+    @inject(HttpProviderToken) @optional() private readonly http?: HttpProvider,
+  ) {}
+}
+```
+
+### HTTP apps
+
+```ts
+import { Builder } from "@decohere/http";
+import { FastifyProvider } from "@decohere/http/providers";
+import { SampleService } from "./services/sample.service.js";
+import { HelloController } from "./controllers/hello.controller.js";
+
+await Builder.create()
+  .withHttp(FastifyProvider)
+  .withControllers(HelloController)
+  .withServices((cb) => {
+    cb.registerSingleton(SampleService);
+  })
+  .buildAndStart();
+```
+
+`withHttp` / `withControllers` already register the HTTP stack (router, controllers as request-scoped, …). Application services go in `withServices`.
+
+### Tests
+
+Prefer constructing the subject with explicit fakes when you do not need the container. Use `ServiceContainerBuilder` when the test *is* the wiring (scopes, tokens, many-implementations).
+
+```ts
+const builder = new ServiceContainerBuilder();
+builder.registerSingleton(SampleService, fakeSample);
+builder.registerRequestScoped(HelloController);
+const container = builder.build();
+using scope = container.beginScope("test");
+const hello = scope.resolve(HelloController);
+```
+
+To assert constructor arguments under DI, use `spyOnConstructor` from `@decohere/testing` — a bare `vi.spyOn` / `vi.fn` constructor drops `design:paramtypes`. See [Asserting DI constructor arguments](../../docs/testing/how-tos/vitest-constructor-spy-with-di.md).
+
+---
+
+## Public API
+
+### `@decohere/crucible`
+
+| Export | Role |
+|---|---|
+| `ServiceContainerBuilder` | Fluent registration; `build()` → `Container` |
+| `Container` | The container: `resolve`, `resolveMany`, `beginScope`, `Symbol.dispose` / `Symbol.asyncDispose` |
+| `IContainer` / `LifetimeScope` / `ContainerBuilder` / `ServiceProvider` | Composition interfaces |
+| `Scopes` | `{ request, singleton: "single-instance", transient }` |
+| `LifetimeScopeToken` | Symbol for the current scope |
+| `ResolveError` | Nothing registered, several registrations for `resolve`, a cycle, a captive dependency, or a parameter with no usable type |
+| `DuplicateScopeError` | `beginScope` with a live duplicate name |
+| `RegistrationError` | Same type registered twice without `builder.override` |
+
+### `@decohere/crucible/decorators`
+
+| Export | Role |
+|---|---|
+| `injectable()` | Empty class decorator; emit `design:paramtypes` |
+| `inject(key)` | Parameter decorator; resolve this key instead of the reflected type |
+| `optional()` | Parameter decorator; pass `undefined` when nothing is registered instead of throwing |
+
+---
+
+## Pitfalls
+
+1. **`import type` on an injected class** — paramtypes become `Object` → `ResolveError` asking for `@inject`. Use a value import, or `@inject(TheClass)`.
+2. **Missing `@injectable()` (or any decorator) on the consumer** — no paramtypes, constructor is called with zero arguments.
+3. **`resolve` of a multi-bound token** — throws; use `resolveMany` or inject `T[]` with `@inject(token)`.
+4. **Same type registered twice** — throws `RegistrationError`. Use `builder.override.registerSingleton(...)` (tests, plugin replacements).
+5. **A string key for a class** — `@inject("SampleService")` does not find `SampleService`. Pass the class.
+6. **Two copies of a package** — the class from one copy is not the class from the other, so a service registered with one is not found with the other. Install each package once.
+7. **A singleton depending on a request-scoped service** — throws; see [lifetimes](#registration-and-lifetimes).
+
+---
+
+## Non-goals
+
+- Folder scanning / “declare a module and everything is registered”
+- Property or setter injection (constructors only)
+- Compile-time graph checking
+
+## Dependencies
+
+| Package | Role |
+|---|---|
+| [`@decohere/core`](../core) | Reflection helpers for `design:paramtypes` (`getMeta`, `isConstructable`, …) |
+
+Layering: [architecture](../../docs/architecture/).

package/es6/src/const.js

@@ -1,12 +1,10 @@
-const Crucible = "Crucible";
+const Container = "Container";
 export const LifetimeScopeToken = Symbol("LifetimeScope");
-export const CrucibleMeta = {
-    injecttoken: `${Crucible}:injecttoken`
+export const ContainerMeta = {
+    injecttoken: `${Container}:injecttoken`
 };
 export const Scopes = {
     request: "request",
     singleton: "single-instance",
     transient: "transient"
 };
-
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL2NydWNpYmxlL3NyYy9jb25zdC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7IFNjb3BlIH0gZnJvbSBcIi4vdHlwZXMvdHlwZXMuanNcIjtcblxuY29uc3QgQ3J1Y2libGUgPSBcIkNydWNpYmxlXCI7XG50eXBlIENydWNpYmxlTWV0YSA9IFwiaW5qZWN0dG9rZW5cIjtcblxuZXhwb3J0IGNvbnN0IExpZmV0aW1lU2NvcGVUb2tlbiA9IFN5bWJvbChcIkxpZmV0aW1lU2NvcGVcIik7XG5cbmV4cG9ydCBjb25zdCBDcnVjaWJsZU1ldGEgPSB7XG5cdGluamVjdHRva2VuOiBgJHtDcnVjaWJsZX06aW5qZWN0dG9rZW5gLFxufSBzYXRpc2ZpZXMgUmVjb3JkPENydWNpYmxlTWV0YSwgc3RyaW5nPjtcblxuZXhwb3J0IGNvbnN0IFNjb3BlcyA9IHtcblx0cmVxdWVzdDogXCJyZXF1ZXN0XCIsXG5cdHNpbmdsZXRvbjogXCJzaW5nbGUtaW5zdGFuY2VcIixcblx0dHJhbnNpZW50OiBcInRyYW5zaWVudFwiLFxufSBzYXRpc2ZpZXMgUmVjb3JkPHN0cmluZywgU2NvcGU+O1xuIl0sIm5hbWVzIjpbIkNydWNpYmxlIiwiTGlmZXRpbWVTY29wZVRva2VuIiwiU3ltYm9sIiwiQ3J1Y2libGVNZXRhIiwiaW5qZWN0dG9rZW4iLCJTY29wZXMiLCJyZXF1ZXN0Iiwic2luZ2xldG9uIiwidHJhbnNpZW50Il0sIm1hcHBpbmdzIjoiQUFFQSxNQUFNQSxXQUFXO0FBR2pCLE9BQU8sTUFBTUMscUJBQXFCQyxPQUFPLGlCQUFpQjtBQUUxRCxPQUFPLE1BQU1DLGVBQWU7SUFDM0JDLGFBQWEsR0FBR0osU0FBUyxZQUFZLENBQUM7QUFDdkMsRUFBeUM7QUFFekMsT0FBTyxNQUFNSyxTQUFTO0lBQ3JCQyxTQUFTO0lBQ1RDLFdBQVc7SUFDWEMsV0FBVztBQUNaLEVBQWtDIn0=

package/es6/src/decorators/index.js

@@ -1,4 +1,2 @@
 export * from "./inject.decorator.js";
 export * from "./injectable.dectorator.js";
-
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL2NydWNpYmxlL3NyYy9kZWNvcmF0b3JzL2luZGV4LnRzIl0sInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gXCIuL2luamVjdC5kZWNvcmF0b3IuanNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2luamVjdGFibGUuZGVjdG9yYXRvci5qc1wiO1xuIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsd0JBQXdCO0FBQ3RDLGNBQWMsNkJBQTZCIn0=

package/es6/src/decorators/inject.decorator.js

@@ -1,17 +1,30 @@
-import { defineMeta, getMeta } from "@decohere/nexus/reflection";
-import { CrucibleMeta } from "../const.js";
-export function inject(key) {
-    return (target, _propertyKey, idx)=>{
-        const metadata = getExistingMeta(target);
-        metadata.set(idx, {
+import { defineMeta, getMeta } from "@decohere/core/reflection";
+import { ContainerMeta } from "../const.js";
+/**
+ * Bind a constructor parameter to a registration key. Keys match by identity: a class matches only
+ * itself (not a string of its name), and a symbol only itself. Prefer the class; use a symbol for an
+ * interface or several implementations. `@inject(SomeClass)` also keeps SomeClass's import, which
+ * a parameter used only as a type can lose (its run-time type then collapses to `Object`).
+ */ export function inject(key) {
+    return updateToken((token)=>({
+            ...token,
             key
-        });
-        defineMeta(CrucibleMeta.injecttoken, metadata, target);
-    };
+        }));
+}
+/**
+ * Mark a constructor parameter as optional: when nothing is registered for it, the container
+ * passes `undefined` (so a default value applies) instead of throwing.
+ */ export function optional() {
+    return updateToken((token)=>({
+            ...token,
+            optional: true
+        }));
 }
-function getExistingMeta(target) {
-    const meta = getMeta(CrucibleMeta.injecttoken, target) ?? new Map();
-    return meta;
+function updateToken(update) {
+    return (target, _propertyKey, idx)=>{
+        // Copy: the metadata can be inherited from a base class, which must not change.
+        const metadata = new Map(getMeta(ContainerMeta.injecttoken, target));
+        metadata.set(idx, update(metadata.get(idx)));
+        defineMeta(ContainerMeta.injecttoken, metadata, target);
+    };
 }
-
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL2NydWNpYmxlL3NyYy9kZWNvcmF0b3JzL2luamVjdC5kZWNvcmF0b3IudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgZGVmaW5lTWV0YSwgZ2V0TWV0YSB9IGZyb20gXCJAZGVjb2hlcmUvbmV4dXMvcmVmbGVjdGlvblwiO1xuaW1wb3J0IHsgQ3J1Y2libGVNZXRhIH0gZnJvbSBcIi4uL2NvbnN0LmpzXCI7XG5cbmV4cG9ydCB0eXBlIEluamVjdGlvbk1ldGFkYXRhID0gTWFwPG51bWJlciwgSW5qZWN0aW9uVG9rZW4+O1xuXG5leHBvcnQgdHlwZSBJbmplY3Rpb25Ub2tlbiA9IHtcblx0a2V5OiBzdHJpbmcgfCBzeW1ib2w7XG59O1xuXG5leHBvcnQgZnVuY3Rpb24gaW5qZWN0KGtleTogc3RyaW5nIHwgc3ltYm9sKSB7XG5cdHJldHVybiAodGFyZ2V0OiBvYmplY3QsIF9wcm9wZXJ0eUtleTogc3RyaW5nIHwgc3ltYm9sIHwgdW5kZWZpbmVkLCBpZHg6IG51bWJlcikgPT4ge1xuXHRcdGNvbnN0IG1ldGFkYXRhID0gZ2V0RXhpc3RpbmdNZXRhKHRhcmdldCk7XG5cdFx0bWV0YWRhdGEuc2V0KGlkeCwgeyBrZXkgfSk7XG5cdFx0ZGVmaW5lTWV0YShDcnVjaWJsZU1ldGEuaW5qZWN0dG9rZW4sIG1ldGFkYXRhLCB0YXJnZXQpO1xuXHR9O1xufVxuXG5mdW5jdGlvbiBnZXRFeGlzdGluZ01ldGEodGFyZ2V0OiBvYmplY3QpIHtcblx0Y29uc3QgbWV0YSA9XG5cdFx0Z2V0TWV0YTxNYXA8bnVtYmVyLCBJbmplY3Rpb25Ub2tlbj4+KENydWNpYmxlTWV0YS5pbmplY3R0b2tlbiwgdGFyZ2V0KSA/P1xuXHRcdG5ldyBNYXA8bnVtYmVyLCBJbmplY3Rpb25Ub2tlbj4oKTtcblx0cmV0dXJuIG1ldGE7XG59XG4iXSwibmFtZXMiOlsiZGVmaW5lTWV0YSIsImdldE1ldGEiLCJDcnVjaWJsZU1ldGEiLCJpbmplY3QiLCJrZXkiLCJ0YXJnZXQiLCJfcHJvcGVydHlLZXkiLCJpZHgiLCJtZXRhZGF0YSIsImdldEV4aXN0aW5nTWV0YSIsInNldCIsImluamVjdHRva2VuIiwibWV0YSIsIk1hcCJdLCJtYXBwaW5ncyI6IkFBQUEsU0FBU0EsVUFBVSxFQUFFQyxPQUFPLFFBQVEsNkJBQTZCO0FBQ2pFLFNBQVNDLFlBQVksUUFBUSxjQUFjO0FBUTNDLE9BQU8sU0FBU0MsT0FBT0MsR0FBb0I7SUFDMUMsT0FBTyxDQUFDQyxRQUFnQkMsY0FBMkNDO1FBQ2xFLE1BQU1DLFdBQVdDLGdCQUFnQko7UUFDakNHLFNBQVNFLEdBQUcsQ0FBQ0gsS0FBSztZQUFFSDtRQUFJO1FBQ3hCSixXQUFXRSxhQUFhUyxXQUFXLEVBQUVILFVBQVVIO0lBQ2hEO0FBQ0Q7QUFFQSxTQUFTSSxnQkFBZ0JKLE1BQWM7SUFDdEMsTUFBTU8sT0FDTFgsUUFBcUNDLGFBQWFTLFdBQVcsRUFBRU4sV0FDL0QsSUFBSVE7SUFDTCxPQUFPRDtBQUNSIn0=

package/es6/src/decorators/injectable.dectorator.js

@@ -2,5 +2,3 @@ export function injectable() {
     // no implementation for now. Just used to ensure reflect metadata is generated
     return ()=>{};
 }
-
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL2NydWNpYmxlL3NyYy9kZWNvcmF0b3JzL2luamVjdGFibGUuZGVjdG9yYXRvci50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgZnVuY3Rpb24gaW5qZWN0YWJsZSgpOiBDbGFzc0RlY29yYXRvciB7XG5cdC8vIG5vIGltcGxlbWVudGF0aW9uIGZvciBub3cuIEp1c3QgdXNlZCB0byBlbnN1cmUgcmVmbGVjdCBtZXRhZGF0YSBpcyBnZW5lcmF0ZWRcblx0cmV0dXJuICgpID0+IHt9O1xufVxuIl0sIm5hbWVzIjpbImluamVjdGFibGUiXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sU0FBU0E7SUFDZiwrRUFBK0U7SUFDL0UsT0FBTyxLQUFPO0FBQ2YifQ==

package/es6/src/index.js

@@ -1,5 +1,3 @@
 export * from "./const.js";
 export * from "./services/index.js";
 export * from "./types/index.js";
-
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL2NydWNpYmxlL3NyYy9pbmRleC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tIFwiLi9jb25zdC5qc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vc2VydmljZXMvaW5kZXguanNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3R5cGVzL2luZGV4LmpzXCI7XG4iXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxhQUFhO0FBQzNCLGNBQWMsc0JBQXNCO0FBQ3BDLGNBQWMsbUJBQW1CIn0=

package/es6/src/models/service-key.js

@@ -0,0 +1,10 @@
+/** A readable name for a key, for error messages. */ export function describeKey(key) {
+    switch(typeof key){
+        case "string":
+            return `"${key}"`;
+        case "symbol":
+            return key.toString();
+        default:
+            return key.name || "(anonymous factory)";
+    }
+}

package/es6/src/models/service-registration.model.js

@@ -9,12 +9,7 @@ export class ServiceRegistration {
         this.scope = scope;
         this.isInstance = isInstance;
     }
-    isEqual(other) {
-        if (other.isInstance) {
-            return false;
-        }
+    /** Same class, or the same instance object. */ isEqual(other) {
         return this.type === other.type;
     }
 }
-
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL2NydWNpYmxlL3NyYy9tb2RlbHMvc2VydmljZS1yZWdpc3RyYXRpb24ubW9kZWwudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBDb25zdHJ1Y3RhYmxlLCBGdW5jdGlvblR5cGUgfSBmcm9tIFwiQGRlY29oZXJlL25leHVzL3JlZmxlY3Rpb25cIjtcbmltcG9ydCB0eXBlIHsgU2NvcGUgfSBmcm9tIFwiLi4vdHlwZXMvdHlwZXMuanNcIjtcbmltcG9ydCB0eXBlIHsgUmVnaXN0cmF0aW9uS2V5IH0gZnJvbSBcIi4vcmVnaXN0cmF0aW9uLWtleS5tb2RlbC5qc1wiO1xuXG5leHBvcnQgY2xhc3MgU2VydmljZVJlZ2lzdHJhdGlvbiB7XG5cdHB1YmxpYyBrZXk6IFJlZ2lzdHJhdGlvbktleTtcblx0cHVibGljIHNjb3BlOiBTY29wZTtcblx0cHVibGljIHR5cGU6IENvbnN0cnVjdGFibGUgfCBGdW5jdGlvblR5cGUgfCBvYmplY3Q7XG5cdHB1YmxpYyBpc0luc3RhbmNlOiBib29sZWFuO1xuXG5cdHB1YmxpYyBjb25zdHJ1Y3Rvcihcblx0XHRrZXk6IFJlZ2lzdHJhdGlvbktleSxcblx0XHR0eXBlOiBDb25zdHJ1Y3RhYmxlIHwgRnVuY3Rpb25UeXBlIHwgb2JqZWN0LFxuXHRcdHNjb3BlOiBTY29wZSxcblx0XHRpc0luc3RhbmNlOiBib29sZWFuLFxuXHQpIHtcblx0XHR0aGlzLmtleSA9IGtleTtcblx0XHR0aGlzLnR5cGUgPSB0eXBlO1xuXHRcdHRoaXMuc2NvcGUgPSBzY29wZTtcblx0XHR0aGlzLmlzSW5zdGFuY2UgPSBpc0luc3RhbmNlO1xuXHR9XG5cblx0cHVibGljIGlzRXF1YWwob3RoZXI6IFNlcnZpY2VSZWdpc3RyYXRpb24pIHtcblx0XHRpZiAob3RoZXIuaXNJbnN0YW5jZSkge1xuXHRcdFx0cmV0dXJuIGZhbHNlO1xuXHRcdH1cblxuXHRcdHJldHVybiB0aGlzLnR5cGUgPT09IG90aGVyLnR5cGU7XG5cdH1cbn1cbiJdLCJuYW1lcyI6WyJTZXJ2aWNlUmVnaXN0cmF0aW9uIiwia2V5Iiwic2NvcGUiLCJ0eXBlIiwiaXNJbnN0YW5jZSIsImlzRXF1YWwiLCJvdGhlciJdLCJtYXBwaW5ncyI6IkFBSUEsT0FBTyxNQUFNQTtJQUNMQyxJQUFxQjtJQUNyQkMsTUFBYTtJQUNiQyxLQUE0QztJQUM1Q0MsV0FBb0I7SUFFM0IsWUFDQ0gsR0FBb0IsRUFDcEJFLElBQTJDLEVBQzNDRCxLQUFZLEVBQ1pFLFVBQW1CLENBQ2xCO1FBQ0QsSUFBSSxDQUFDSCxHQUFHLEdBQUdBO1FBQ1gsSUFBSSxDQUFDRSxJQUFJLEdBQUdBO1FBQ1osSUFBSSxDQUFDRCxLQUFLLEdBQUdBO1FBQ2IsSUFBSSxDQUFDRSxVQUFVLEdBQUdBO0lBQ25CO0lBRU9DLFFBQVFDLEtBQTBCLEVBQUU7UUFDMUMsSUFBSUEsTUFBTUYsVUFBVSxFQUFFO1lBQ3JCLE9BQU87UUFDUjtRQUVBLE9BQU8sSUFBSSxDQUFDRCxJQUFJLEtBQUtHLE1BQU1ILElBQUk7SUFDaEM7QUFDRCJ9