@codefast/di 0.8.0 → 0.8.1

package/src/core/module.ts

@@ -1,117 +0,0 @@
-import type { BindToBuilder } from "#/core/binding";
-import type { Token } from "#/core/token";
-import type { Constructor } from "#/core/types";
-
-// ── Branded types (runtime symbols for branding) ─────────────────────────────────────────────────────────────────────
-
-const SYNC_MODULE_BRAND: unique symbol = Symbol("di:sync-module");
-const ASYNC_MODULE_BRAND: unique symbol = Symbol("di:async-module");
-
-/**
- * Key for the module's setup callback. A symbol (not exported from the package root)
- * keeps the container-only member out of consumer-facing autocomplete entirely.
- *
- * @since 0.5.0-canary.7
- */
-export const MODULE_SETUP: unique symbol = Symbol("di:module-setup");
-
-/**
- * A named, reusable group of bindings a container applies synchronously via `load()`.
- *
- * @since 0.3.16-canary.0
- */
-export interface SyncModule {
-  readonly name: string;
-  readonly [SYNC_MODULE_BRAND]: true;
-  readonly [MODULE_SETUP]: (builder: ModuleBuilder) => void;
-}
-
-/**
- * A named group of bindings whose setup is async, applied via `loadAsync()`.
- *
- * @since 0.3.16-canary.0
- */
-export interface AsyncModule {
-  readonly name: string;
-  readonly [ASYNC_MODULE_BRAND]: true;
-  readonly [MODULE_SETUP]: (builder: AsyncModuleBuilder) => Promise<void>;
-}
-
-// ── Builder interfaces ───────────────────────────────────────────────────────────────────────────────────────────────
-
-/**
- * The binding surface a sync module's setup callback receives.
- *
- * @since 0.3.16-canary.0
- */
-export interface ModuleBuilder {
-  bind<Value>(token: Token<Value> | Constructor<Value>): BindToBuilder<Value>;
-  import(...modules: Array<SyncModule>): void;
-}
-
-/**
- * The binding surface an async module's setup callback receives; its `import` accepts async modules too.
- *
- * @since 0.3.16-canary.0
- */
-export interface AsyncModuleBuilder {
-  bind<Value>(token: Token<Value> | Constructor<Value>): BindToBuilder<Value>;
-  import(...modules: Array<SyncModule | AsyncModule>): void;
-}
-
-// ── Static factories ─────────────────────────────────────────────────────────────────────────────────────────────────
-
-/**
- * The companion factory that creates `SyncModule` values.
- *
- * @since 0.3.16-canary.0
- */
-export const SyncModule = {
-  create(name: string, setup: (builder: ModuleBuilder) => void): SyncModule {
-    return {
-      name,
-      [SYNC_MODULE_BRAND]: true as const,
-      [MODULE_SETUP]: setup,
-    };
-  },
-};
-
-/**
- * The companion factory that creates `AsyncModule` values.
- *
- * @since 0.3.16-canary.0
- */
-export const AsyncModule = {
-  create(name: string, setup: (builder: AsyncModuleBuilder) => Promise<void>): AsyncModule {
-    return {
-      name,
-      [ASYNC_MODULE_BRAND]: true as const,
-      [MODULE_SETUP]: setup,
-    };
-  },
-};
-
-// ── Module — unified API ─────────────────────────────────────────────────────────────────────────────────────────────
-
-/**
- * The unified module factory — `create` for sync modules, `createAsync` for async ones.
- *
- * @since 0.3.16-canary.0
- */
-export const Module = {
-  create(name: string, setup: (builder: ModuleBuilder) => void): SyncModule {
-    return SyncModule.create(name, setup);
-  },
-  createAsync(name: string, setup: (builder: AsyncModuleBuilder) => Promise<void>): AsyncModule {
-    return AsyncModule.create(name, setup);
-  },
-};
-
-/**
- * Narrows a module union to `SyncModule` by checking its brand.
- *
- * @since 0.3.16-canary.0
- */
-export function isSyncModule(module: SyncModule | AsyncModule): module is SyncModule {
-  return (module as Partial<SyncModule>)[SYNC_MODULE_BRAND] === true;
-}

package/src/core/registry.ts

@@ -1,319 +0,0 @@
-import type { Binding } from "#/core/binding";
-import { bindingSlotEquals, bindingSlotToString } from "#/core/binding";
-import { getOrInsert } from "#/core/map-upsert";
-import type { BindingTag } from "#/core/tag";
-import type { Token } from "#/core/token";
-import type { BindingIdentifier, Constructor, DependencyKey } from "#/core/types";
-
-/**
- * One container's binding store, indexed by token, binding id, and slot for fast lookup.
- *
- * @since 0.3.16-canary.0
- */
-export class BindingRegistry {
-  // Monotonic mutation counter — lets resolvers version-stamp lookup caches across a container chain.
-  #version = 0;
-  // Map from token key -> array of bindings (order matters for last-wins)
-  readonly #bindings = new Map<DependencyKey, Array<Binding>>();
-  // Fast lookup by binding ID
-  readonly #byId = new Map<BindingIdentifier, Binding>();
-  // Fast path for one default slot binding with no predicate
-  readonly #fastDefault = new Map<DependencyKey, Binding>();
-  // Fast lookup for a slot carrying exactly one criterion (a lone name folds here too) — keyed by
-  // the interned criterion itself, so the pair is one hash. Unallocated until such a slot lands.
-  #simpleTagged: Map<DependencyKey, Map<BindingTag, Binding>> | undefined;
-  // Slots with two or more criteria, bucketed by their FIRST criterion. A matching slot's every
-  // criterion is in the request, so walking the request's buckets finds each candidate exactly once.
-  #multiTagged: Map<DependencyKey, Map<BindingTag, Array<Binding>>> | undefined;
-
-  // Set on the first constant registered and never cleared. Teardown only needs the negative answer
-  // to be exact, and that is what lets a container holding no constant skip its sweep entirely.
-  #heldConstantBinding = false;
-
-  /** Monotonic version — increments on every mutation. */
-  get version(): number {
-    return this.#version;
-  }
-
-  /** Whether a constant has ever been registered here, and so whether teardown has anything to sweep. */
-  get hasHeldConstantBinding(): boolean {
-    return this.#heldConstantBinding;
-  }
-
-  /**
-   * Registers a mutation the indexes don't care about (a fluent chain refining scope or an
-   * activation hook in place), so version-stamped resolver caches still invalidate.
-   */
-  touch(): void {
-    this.#version += 1;
-  }
-
-  /**
-   * Adds or replaces a binding using slot-aware last-wins. Returns the displaced binding, if any.
-   *
-   * @remarks The binding is stored by reference — it must come from `createBinding`, which is
-   * what guarantees the single hidden class the resolver's hot reads depend on.
-   */
-  add(binding: Binding): Binding | undefined {
-    this.#version += 1;
-    if (binding.kind === "constant") {
-      this.#heldConstantBinding = true;
-    }
-    const key: DependencyKey = binding.token;
-    // Copy-on-write: a selection may be walking the current list inside a `when()` predicate, so
-    // mutation replaces the array and never splices one that has been handed out.
-    const bindingsForToken = this.#bindings.get(key);
-
-    // Only apply last-wins for slot-based bindings (not predicate-only)
-    let displacedBinding: Binding | undefined;
-    let nextBindings: Array<Binding>;
-    if (bindingsForToken === undefined) {
-      nextBindings = [binding];
-    } else {
-      if (!isPurePredicateBinding(binding)) {
-        const existingIndex = bindingsForToken.findIndex(
-          (candidate) => !isPurePredicateBinding(candidate) && bindingSlotEquals(candidate.slot, binding.slot),
-        );
-        if (existingIndex !== -1) {
-          displacedBinding = bindingsForToken[existingIndex]!;
-          this.#byId.delete(displacedBinding.id);
-          this.#deindexSimpleTaggedBinding(key, displacedBinding);
-          this.#deindexMultiTaggedBinding(key, displacedBinding);
-        }
-      }
-      nextBindings =
-        displacedBinding === undefined
-          ? [...bindingsForToken, binding]
-          : [...bindingsForToken.filter((candidate) => candidate !== displacedBinding), binding];
-    }
-
-    this.#bindings.set(key, nextBindings);
-    this.#byId.set(binding.id, binding);
-    this.#indexSimpleTaggedBinding(key, binding);
-    this.#indexMultiTaggedBinding(key, binding);
-    this.#refreshFastDefaultForToken(key);
-    return displacedBinding;
-  }
-
-  /** Remove all bindings for a token. Returns removed bindings. */
-  removeByToken(token: Token<unknown> | Constructor): Array<Binding> {
-    this.#version += 1;
-    const key: DependencyKey = token;
-    const bindingsForToken = this.#bindings.get(key) ?? [];
-    this.#bindings.delete(key);
-    this.#simpleTagged?.delete(key);
-    this.#multiTagged?.delete(key);
-    this.#fastDefault.delete(key);
-    for (const binding of bindingsForToken) {
-      this.#byId.delete(binding.id);
-    }
-    return bindingsForToken;
-  }
-
-  /** Remove a specific binding by ID. Returns the removed binding or undefined. */
-  removeById(id: BindingIdentifier): Binding | undefined {
-    const binding = this.#byId.get(id);
-    if (binding === undefined) {
-      return undefined;
-    }
-    this.#version += 1;
-    this.#byId.delete(id);
-    const key: DependencyKey = binding.token;
-    const bindingsForToken = this.#bindings.get(key);
-    if (bindingsForToken !== undefined) {
-      const bindingIndex = bindingsForToken.findIndex((candidate) => candidate.id === id);
-      // Copy-on-write, like `add`: a walk holding the current array must not lose its place.
-      const remaining = bindingIndex === -1 ? bindingsForToken : bindingsForToken.toSpliced(bindingIndex, 1);
-      this.#deindexSimpleTaggedBinding(key, binding);
-      this.#deindexMultiTaggedBinding(key, binding);
-      if (remaining.length === 0) {
-        this.#bindings.delete(key);
-        this.#simpleTagged?.delete(key);
-        this.#multiTagged?.delete(key);
-        this.#fastDefault.delete(key);
-      } else {
-        this.#bindings.set(key, remaining);
-        this.#refreshFastDefaultForToken(key);
-      }
-    }
-    return binding;
-  }
-
-  /** Get all bindings for a token. */
-  getAll(token: Token<unknown> | Constructor): ReadonlyArray<Binding> {
-    return this.#bindings.get(token) ?? [];
-  }
-
-  /** Get binding by ID. */
-  getById(id: BindingIdentifier): Binding | undefined {
-    return this.#byId.get(id);
-  }
-
-  /** Check if any binding exists for token. */
-  has(token: Token<unknown> | Constructor): boolean {
-    const key: DependencyKey = token;
-    const list = this.#bindings.get(key);
-    return list !== undefined && list.length > 0;
-  }
-
-  /** All bindings in the registry. */
-  allBindings(): ReadonlyArray<Binding> {
-    const allBindings: Array<Binding> = [];
-    for (const bindingsForToken of this.#bindings.values()) {
-      allBindings.push(...bindingsForToken);
-    }
-    return allBindings;
-  }
-
-  /** Remove all bindings. Returns all removed. */
-  clear(): ReadonlyArray<Binding> {
-    this.#version += 1;
-    const all = this.allBindings();
-    this.#bindings.clear();
-    this.#byId.clear();
-    this.#simpleTagged?.clear();
-    this.#multiTagged?.clear();
-    this.#fastDefault.clear();
-    return all;
-  }
-
-  /** Whether a slot-based binding currently occupies `binding`'s slot, so adding it would displace. */
-  hasSlotOccupant(binding: Binding): boolean {
-    if (isPurePredicateBinding(binding)) {
-      return false;
-    }
-    const candidates = this.#bindings.get(binding.token);
-    if (candidates === undefined) {
-      return false;
-    }
-    return candidates.some(
-      (candidate) => !isPurePredicateBinding(candidate) && bindingSlotEquals(candidate.slot, binding.slot),
-    );
-  }
-
-  /**
-   * The binding indexed under one criterion.
-   *
-   * @remarks Exact, with no re-check: criteria are interned, so a `Map` keyed by the pair answers by
-   * identity — where a value-keyed map answered by SameValueZero and parted from `Object.is` on ±0.
-   */
-  getSimpleTagged(token: Token<unknown> | Constructor, criterion: BindingTag): Binding | undefined {
-    return this.#simpleTagged?.get(token)?.get(criterion);
-  }
-
-  /**
-   * The multi-tag bindings whose slot's first criterion is `criterion`.
-   *
-   * @remarks A prefilter, not an answer: a bucket member's remaining tags still have to be matched
-   * against the request — first-criterion bucketing only guarantees each candidate appears once.
-   */
-  getMultiTagged(token: Token<unknown> | Constructor, criterion: BindingTag): ReadonlyArray<Binding> | undefined {
-    return this.#multiTagged?.get(token)?.get(criterion);
-  }
-
-  getFastDefault(token: Token<unknown> | Constructor): Binding | undefined {
-    return this.#fastDefault.get(token);
-  }
-
-  /** Summarize available slot strings for a token (for error messages). */
-  availableSlotStrings(token: Token<unknown> | Constructor): Array<string> {
-    const bindingsForToken = this.#bindings.get(token) ?? [];
-    return bindingsForToken.map((binding) => bindingSlotToString(binding.slot));
-  }
-
-  #indexSimpleTaggedBinding(tokenKey: DependencyKey, binding: Binding): void {
-    const criterion = simpleTagOf(binding);
-    if (criterion === undefined) {
-      return;
-    }
-    this.#simpleTagged ??= new Map();
-    const byCriterion = getOrInsert(this.#simpleTagged, tokenKey, new Map<BindingTag, Binding>());
-    byCriterion.set(criterion, binding);
-  }
-
-  #deindexSimpleTaggedBinding(tokenKey: DependencyKey, binding: Binding): void {
-    const criterion = simpleTagOf(binding);
-    if (criterion === undefined) {
-      return;
-    }
-    const byCriterion = this.#simpleTagged?.get(tokenKey);
-    if (byCriterion === undefined) {
-      return;
-    }
-    if (byCriterion.get(criterion)?.id === binding.id) {
-      byCriterion.delete(criterion);
-      if (byCriterion.size === 0) {
-        this.#simpleTagged!.delete(tokenKey);
-      }
-    }
-  }
-
-  #indexMultiTaggedBinding(tokenKey: DependencyKey, binding: Binding): void {
-    const firstCriterion = multiTagFirstOf(binding);
-    if (firstCriterion === undefined) {
-      return;
-    }
-    this.#multiTagged ??= new Map();
-    const buckets = getOrInsert(this.#multiTagged, tokenKey, new Map<BindingTag, Array<Binding>>());
-    getOrInsert(buckets, firstCriterion, []).push(binding);
-  }
-
-  #deindexMultiTaggedBinding(tokenKey: DependencyKey, binding: Binding): void {
-    const firstCriterion = multiTagFirstOf(binding);
-    if (firstCriterion === undefined) {
-      return;
-    }
-    const bucket = this.#multiTagged?.get(tokenKey)?.get(firstCriterion);
-    if (bucket === undefined) {
-      return;
-    }
-    const bindingIndex = bucket.findIndex((candidate) => candidate.id === binding.id);
-    // Spliced in place: nothing walks a bucket while user code runs — candidates are gathered
-    // into their own array before any predicate is evaluated.
-    if (bindingIndex !== -1) {
-      bucket.splice(bindingIndex, 1);
-    }
-  }
-
-  #refreshFastDefaultForToken(tokenKey: DependencyKey): void {
-    const bindingsForToken = this.#bindings.get(tokenKey);
-    const onlyBinding = bindingsForToken?.length === 1 ? bindingsForToken[0]! : undefined;
-    if (onlyBinding !== undefined && isDefaultSlotBinding(onlyBinding)) {
-      this.#fastDefault.set(tokenKey, onlyBinding);
-      return;
-    }
-    this.#fastDefault.delete(tokenKey);
-  }
-
-  /** Whether the deferred tagged-slot index has had to be built. */
-  get isTaggedIndexBuilt(): boolean {
-    return this.#simpleTagged !== undefined;
-  }
-}
-
-/**
- * The criterion a binding is indexed under, or `undefined` when its slot carries more than one.
- *
- * @remarks Carries predicate-bearing bindings too: every lane that reads this index already
- * re-checks what it finds, so an indexed hit was never unconditional.
- */
-function simpleTagOf(binding: Binding): BindingTag | undefined {
-  const { tags } = binding.slot;
-  return tags.length === 1 ? tags[0] : undefined;
-}
-
-/** The first criterion a multi-criterion slot is bucketed under, or `undefined` for any other shape. */
-function multiTagFirstOf(binding: Binding): BindingTag | undefined {
-  const { tags } = binding.slot;
-  return tags.length >= 2 ? tags[0] : undefined;
-}
-
-/** A binding nothing has to be matched against: the default slot, no predicate. */
-function isDefaultSlotBinding(binding: Binding): boolean {
-  return binding.slot.tags.length === 0 && binding.predicate === undefined;
-}
-
-/** A predicate with no slot constraint: last-wins does not apply to it. */
-function isPurePredicateBinding(binding: Binding): boolean {
-  return binding.predicate !== undefined && binding.slot.tags.length === 0;
-}

package/src/core/tag.ts

@@ -1,212 +0,0 @@
-/** Tag keys and the interned pairs they mint — the one way a slot criterion is built. */
-
-declare const TAG_KEY_BRAND: unique symbol;
-declare const BINDING_TAG_BRAND: unique symbol;
-
-/**
- * How many distinct tag keys one mask bit is shared by.
- *
- * @remarks Ids past this wrap, so two keys can share a bit. The mask is a prefilter only — a shared
- * bit costs a false positive that the identity comparison then rejects, never a false negative.
- */
-const MASK_WIDTH = 32;
-
-/**
- * A slot's or a request's tag key set, as one word.
- *
- * @remarks A slot matches only if the request carries every key the slot declares, which is
- * `(requestMask & slotMask) === slotMask` — the whole subset test, before any value is read. Keys
- * are prefiltered rather than values indexed because a key set fits in a word and a value set does not.
- *
- * @since 0.6.0
- */
-export type TagKeyMask = number & { readonly [TAG_KEY_BRAND]: "mask" };
-
-/**
- * The empty key set: what an untagged slot and an untagged request both carry.
- *
- * @since 0.6.0
- */
-export const NO_TAG_KEYS = 0 as TagKeyMask;
-
-/**
- * One `[key, value]` criterion, interned so equal criteria are the same object.
- *
- * @remarks Only {@link TagKey.of} mints one, which is what makes identity a sound stand-in for the
- * `Object.is` comparison the slot contract requires. Never build one by hand — the matcher and the
- * registry index both read identity, so a hand-built criterion matches nothing.
- *
- * @since 0.6.0
- */
-export interface BindingTag<Value = unknown> {
-  readonly key: TagKey<Value>;
-  readonly value: Value;
-  /** This pair's key mask, copied off the key so the matcher reads one field. */
-  readonly mask: TagKeyMask;
-  readonly [BINDING_TAG_BRAND]: true;
-}
-
-/**
- * A named tag key, and the factory for its criteria.
- *
- * @since 0.6.0
- */
-export interface TagKey<Value = unknown> {
-  readonly name: string;
-  /** Process-monotonic, so a key set is a mask and the registry can index on a number. */
-  readonly id: number;
-  readonly mask: TagKeyMask;
-  /** The criterion for one value, interned: the same value always yields the same object. */
-  of(value: Value): BindingTag<Value>;
-  /**
-   * The interned criterion for a value, or `undefined` when none was ever minted.
-   *
-   * @remarks Reading without minting is what keeps a request-side value from being retained for
-   * the process lifetime: a value no binding ever declared has no criterion, so a lookup can
-   * answer "no match" without inserting one.
-   */
-  peek(value: Value): BindingTag<Value> | undefined;
-}
-
-let tagKeyCounter = -1;
-
-/**
- * Distinguishes `-0` from `+0` in the intern cache.
- *
- * @remarks A `Map` key compares by SameValueZero, which holds `+0` and `-0` equal, while tag values
- * compare by `Object.is`, which does not. Interning them to one object would make the
- * two indistinguishable everywhere downstream, so the negative one is cached under this instead.
- */
-const NEGATIVE_ZERO_KEY: unique symbol = Symbol("di:tag-negative-zero");
-
-function internKeyFor(value: unknown): unknown {
-  return value === 0 && Object.is(value, -0) ? NEGATIVE_ZERO_KEY : value;
-}
-
-/**
- * Declares a tag key, whose `of()` builds the criteria a `whenTagged` and a resolve both take.
- *
- * @remarks The value type is checked at both ends: a key declared `tag<Region>("region")` refuses a
- * value that is not a `Region`, so a bind site and a resolve site cannot drift apart silently.
- *
- * @example
- * ```ts
- * const Region = tag<"eu" | "us">("region");
- * container.bind(Storage).to(S3).whenTagged(Region.of("eu"));
- * container.resolve(Storage, { tag: Region.of("eu") });
- * ```
- *
- * @since 0.6.0
- */
-export function tag<Value = unknown>(name: string): TagKey<Value> {
-  tagKeyCounter += 1;
-  const id = tagKeyCounter;
-  const mask = (1 << (id % MASK_WIDTH)) as TagKeyMask;
-  const interned = new Map<unknown, BindingTag<Value>>();
-  // One-entry cache in front of the intern map: an inline `.of()` at a call site usually repeats
-  // one value, and `Object.is` is the slot contract's own comparison, so a hit is exact — ±0 stay
-  // split and `NaN` hits itself, with no `internKeyFor` detour.
-  let lastValue: Value | undefined;
-  let lastPair: BindingTag<Value> | undefined;
-
-  // The miss paths live outside `of()`/`peek()` so the hot wrappers stay small enough to inline.
-  const internPair = (value: Value): BindingTag<Value> => {
-    const cacheKey = internKeyFor(value);
-    const existing = interned.get(cacheKey);
-
-    if (existing !== undefined) {
-      lastValue = value;
-      lastPair = existing;
-
-      return existing;
-    }
-
-    const pair = { key, value, mask } as BindingTag<Value>;
-
-    interned.set(cacheKey, pair);
-    lastValue = value;
-    lastPair = pair;
-
-    return pair;
-  };
-  const peekInterned = (value: Value): BindingTag<Value> | undefined => interned.get(internKeyFor(value));
-
-  const key: TagKey<Value> = {
-    name,
-    id,
-    mask,
-    of(value: Value): BindingTag<Value> {
-      if (lastPair !== undefined && Object.is(value, lastValue)) {
-        return lastPair;
-      }
-      return internPair(value);
-    },
-    peek(value: Value): BindingTag<Value> | undefined {
-      if (lastPair !== undefined && Object.is(value, lastValue)) {
-        return lastPair;
-      }
-      return peekInterned(value);
-    },
-  };
-
-  return key;
-}
-
-/**
- * The reserved key a slot's name is a criterion of.
- *
- * @remarks `whenNamed(n)` and a request's `name` are sugar for `slotName.of(n)`, so one selection
- * model serves both spellings — a name takes part in key masks, indexes and specificity like any
- * criterion. What reserves the key is its identity; diagnostics render its criteria as `name:<value>`.
- *
- * @since 0.8.0
- */
-export const slotName: TagKey<string> = tag<string>("di:name");
-
-// One-entry front for the reserved key's read: a name's criterion never changes once minted, so a
-// hit is sound forever, and a miss is never cached so a later `whenNamed` bind is still seen.
-let lastPeekedName: string | undefined;
-let lastPeekedCriterion: BindingTag<string> | undefined;
-
-/**
- * The reserved criterion for a name, or `undefined` while no binding has declared it.
- *
- * @remarks Reads without minting, so a request-side name no binding declared is never retained.
- *
- * @since 0.8.0
- */
-export function slotNameCriterionOf(name: string): BindingTag<string> | undefined {
-  if (name === lastPeekedName) {
-    return lastPeekedCriterion;
-  }
-  const criterion = slotName.peek(name);
-  if (criterion !== undefined) {
-    lastPeekedName = name;
-    lastPeekedCriterion = criterion;
-  }
-  return criterion;
-}
-
-/**
- * The key set a list of criteria covers.
- *
- * @since 0.6.0
- */
-export function tagKeyMaskOf(tags: ReadonlyArray<BindingTag>): TagKeyMask {
-  let mask = NO_TAG_KEYS;
-
-  for (let index = 0; index < tags.length; index += 1) {
-    mask = (mask | tags[index]!.mask) as TagKeyMask;
-  }
-
-  return mask;
-}
-
-/**
- * Whether a request carrying `requestMask` covers every key in `slotMask`.
- *
- * @since 0.6.0
- */
-export function coversTagKeys(requestMask: TagKeyMask, slotMask: TagKeyMask): boolean {
-  return (requestMask & slotMask) === slotMask;
-}

package/src/core/token.ts

@@ -1,31 +0,0 @@
-import type { Constructor } from "#/core/constructor-type";
-
-declare const TOKEN_BRAND: unique symbol;
-
-/**
- * A branded identifier carrying the value type its bindings resolve to.
- *
- * @since 0.3.16-canary.0
- */
-export interface Token<out Value> {
-  readonly name: string;
-  readonly [TOKEN_BRAND]: Value;
-}
-
-/**
- * Creates a named `Token` for the given value type.
- *
- * @since 0.3.16-canary.0
- */
-export function token<Value>(name: string): Token<Value> {
-  return { name } as Token<Value>;
-}
-
-/**
- * Returns the display name of a token or class used as a dependency key.
- *
- * @since 0.3.16-canary.0
- */
-export function tokenName(dependency: Token<unknown> | Constructor): string {
-  return dependency.name;
-}