@codefast/di 0.11.0 → 0.12.0

package/dist/core/binding.d.ts

@@ -1,7 +1,7 @@
 import type { BindingTag, TagKeyMask } from "#core/tag";
 import type { Token } from "#core/token";
-import type { ActivationHandler, BindingIdentifier, BindingScope, Constructor, DeactivationHandler, ResolutionContext, ResolutionFrame, BindingConstraint } from "#core/types";
-import type { InjectableDependency, InjectionDescriptor, ResolvedDependencyValue } from "#injection/descriptor";
+import type { BindingConstraint, BindingIdentifier, BindingScope, Constructor, ResolutionContext, ResolutionFrame } from "#core/types";
+import type { InjectionDescriptor } from "#injection/descriptor";
 /**
  * The criterion set a binding registers under and a request matches against.
  *
@@ -106,13 +106,6 @@ interface BindingBase<Value> {
      * container resolving each binding once would build and never read again.
      */
     activationStamp: number;
-    /**
-     * Where the binding stands in registration order, or {@link UNREGISTERED_ORDER} before its first add.
-     *
-     * @remarks Registry-owned: stamped by the first `add` and kept through every re-slot and restore, so a
-     * binding taken out and put back returns to its place rather than behind later registrations.
-     */
-    registrationOrder: number;
     /**
      * Cached singleton instance, or {@link NO_INSTANCE}.
      *
@@ -120,6 +113,13 @@ interface BindingBase<Value> {
      * a field read replaces a keyed lookup on the hottest resolve shape there is.
      */
     instance: unknown;
+    /**
+     * The key every container's scoped cache files this binding's instance under.
+     *
+     * @remarks Chain-owned. It starts as the binding's id, and a scope verb that changes the scope mints a new one, so
+     * a scoped instance any child cached under an earlier scope is never found again. The id itself stays stable.
+     */
+    scopedCacheKey: BindingIdentifier;
     readonly token: Token<Value> | Constructor<Value>;
     readonly slot: BindingSlot;
     readonly predicate?: BindingConstraint | undefined;
@@ -228,40 +228,21 @@ export interface AliasBinding<Value> extends BindingBase<Value> {
  */
 export type Binding<Value = unknown> = ClassBinding<Value> | DynamicBinding<Value> | DynamicAsyncBinding<Value> | ResolvedBinding<Value> | ResolvedAsyncBinding<Value> | ConstantBinding<Value> | AliasBinding<Value>;
 /**
- * Returns a process-unique identifier for a new binding.
+ * The scope a binding resolves under.
  *
- * @since 0.3.16-canary.0
- */
-export declare function generateBindingId(): BindingIdentifier;
-/**
- * Writable view of the one selection field a chain may refine without re-registering: nothing
- * indexes on the predicate, so the registry rewrites it in place and re-homes the binding itself.
- *
- * @since 0.10.0
- */
-export interface PredicateField {
-    predicate: BindingConstraint | undefined;
-}
-/**
- * Narrows a registered binding to its predicate for the registry to rewrite.
+ * @remarks Every kind declares one — an alias declares `transient`, since it defers scoping to the
+ * binding it points at — so this is a field read, kept as a named function because it is the
+ * vocabulary validation and introspection speak.
  *
- * @since 0.10.0
+ * @since 0.3.16-canary.0
  */
-export declare function writablePredicate(binding: Binding): PredicateField;
+export declare function effectiveBindingScope(binding: Binding): BindingScope;
 /**
- * Writable view of collection membership, which the registry sets because it decides the binding's map.
- *
- * @since 0.10.0
- */
-export interface MembershipField {
-    isMany: boolean;
-}
-/**
- * Narrows a registered binding to its membership flag for the registry to set.
+ * Returns a process-unique identifier for a new binding.
  *
- * @since 0.10.0
+ * @since 0.3.16-canary.0
  */
-export declare function writableMembership(binding: Binding): MembershipField;
+export declare function generateBindingId(): BindingIdentifier;
 /**
  * The stamp of a binding whose activation need has not been computed under the current versions.
  *
@@ -269,121 +250,12 @@ export declare function writableMembership(binding: Binding): MembershipField;
  */
 export declare const NO_ACTIVATION_STAMP = -1;
 /**
- * The registration order of a binding no registry has added yet.
+ * Drops the memoized resolution frame, for a scope change that alters what the frame reports.
  *
- * @since 0.11.0
- */
-export declare const UNREGISTERED_ORDER = -1;
-/**
- * Drops the memoized resolution frame, for a refinement that changes what the frame reports.
- *
- * @remarks The frame derives from `scope` and `slot`, both of which a chain now writes in place on
- * the registered object, so every such refinement clears it.
+ * @remarks The frame derives from `scope` and `slot`; the slot is final once the binding registers, so
+ * only a scope written in place on the registered object clears it.
  *
  * @since 0.5.0-canary.9
  */
 export declare function clearBindingFrame<Value>(binding: Binding<Value>): void;
-/**
- * Common slot-constraint + id methods shared by all concrete binding builders.
- *
- * @since 0.3.16-canary.0
- */
-export interface SlotConstrainedBuilder<Names extends string = string> {
-    /** Narrows the binding to requests the predicate accepts, evaluated on every resolve. */
-    when(predicate: BindingConstraint): this;
-    /** Declares the binding's slot name, one of the names the token declares. */
-    whenNamed(name: Names): this;
-    /** Declares one criterion of the binding's slot, replacing any earlier criterion of the same key. */
-    whenTagged(criterion: BindingTag): this;
-    /** Keeps the binding on the default slot, the one an unconstrained request selects. */
-    whenDefault(): this;
-    /**
-     * Makes the binding a collection member: one of several the token's `resolveAll` returns, never
-     * what a single `resolve` selects, and outside slot last-wins. It keeps the default slot.
-     */
-    many(): this;
-    /** The identifier this binding is registered under. */
-    id(): BindingIdentifier;
-}
-/**
- * The `to*` step of the fluent chain, choosing what a token resolves to.
- *
- * @since 0.3.16-canary.0
- */
-export interface BindToBuilder<Value, Names extends string = string> {
-    to(type: Constructor<Value>): BindingBuilder<Value, Names>;
-    toSelf(): BindingBuilder<Value, Names>;
-    toConstantValue(value: Value): ConstantBindingBuilder<Value, Names>;
-    toDynamic(factory: (ctx: ResolutionContext) => Value): BindingBuilder<Value, Names>;
-    toDynamicAsync(factory: (ctx: ResolutionContext) => Promise<Value>): BindingBuilder<Value, Names>;
-    toResolved<const Deps extends ReadonlyArray<InjectableDependency>>(factory: (...args: {
-        [K in keyof Deps]: ResolvedDependencyValue<NoInfer<Deps>[K]>;
-    }) => Value, deps: Deps): BindingBuilder<Value, Names>;
-    toResolvedAsync<const Deps extends ReadonlyArray<InjectableDependency>>(factory: (...args: {
-        [K in keyof Deps]: ResolvedDependencyValue<NoInfer<Deps>[K]>;
-    }) => Promise<Value>, deps: Deps): BindingBuilder<Value, Names>;
-    toAlias(target: Token<Value> | Constructor<Value>): AliasBindingBuilder<Names>;
-}
-/**
- * The scope-selection step of the fluent chain.
- *
- * @since 0.3.16-canary.0
- */
-export interface BindingBuilder<Value, Names extends string = string> extends SlotConstrainedBuilder<Names> {
-    singleton(): SingletonBindingBuilder<Value>;
-    transient(): TransientBindingBuilder<Value>;
-    scoped(): ScopedBindingBuilder<Value>;
-}
-/**
- * The fluent chain for a constant — lifecycle hooks only, since the scope is fixed.
- *
- * @since 0.3.16-canary.0
- */
-export interface ConstantBindingBuilder<Value, Names extends string = string> extends SlotConstrainedBuilder<Names> {
-    onActivation(fn: ActivationHandler<Value>): SingletonLifecycleBuilder<Value>;
-    onDeactivation(fn: DeactivationHandler<Value>): SingletonLifecycleBuilder<Value>;
-}
-/**
- * The fluent chain for an alias — slot constraints only, since scoping belongs to the target.
- *
- * @since 0.3.16-canary.0
- */
-export interface AliasBindingBuilder<Names extends string = string> extends SlotConstrainedBuilder<Names> {
-}
-/**
- * The fluent chain after `singleton()`, where both lifecycle hooks stay available.
- *
- * @since 0.3.16-canary.0
- */
-export interface SingletonBindingBuilder<Value> {
-    onActivation(fn: ActivationHandler<Value>): this;
-    onDeactivation(fn: DeactivationHandler<Value>): this;
-    id(): BindingIdentifier;
-}
-/**
- * The fluent chain after `transient()`, where activation is the one lifecycle hook offered.
- *
- * @since 0.3.16-canary.0
- */
-export interface TransientBindingBuilder<Value> {
-    onActivation(fn: ActivationHandler<Value>): this;
-    id(): BindingIdentifier;
-}
-/**
- * The fluent chain after `scoped()`, sharing the `transient()` surface.
- *
- * @since 0.3.16-canary.0
- */
-export interface ScopedBindingBuilder<Value> extends TransientBindingBuilder<Value> {
-}
-/**
- * The fluent chain a constant enters once a lifecycle hook is added.
- *
- * @since 0.3.16-canary.0
- */
-export interface SingletonLifecycleBuilder<Value> {
-    onActivation(fn: ActivationHandler<Value>): this;
-    onDeactivation(fn: DeactivationHandler<Value>): this;
-    id(): BindingIdentifier;
-}
 export {};

package/dist/core/binding.js

@@ -108,6 +108,18 @@ export function bindingSlotToString(slot) {
     }
     return parts.join(",");
 }
+/**
+ * The scope a binding resolves under.
+ *
+ * @remarks Every kind declares one — an alias declares `transient`, since it defers scoping to the
+ * binding it points at — so this is a field read, kept as a named function because it is the
+ * vocabulary validation and introspection speak.
+ *
+ * @since 0.3.16-canary.0
+ */
+export function effectiveBindingScope(binding) {
+    return binding.scope;
+}
 // ── ID generation ────────────────────────────────────────────────────────────────────────────────────────────────────
 let bindingIdCounter = 0;
 /**
@@ -119,22 +131,6 @@ export function generateBindingId() {
     bindingIdCounter += 1;
     return bindingIdCounter;
 }
-/**
- * Narrows a registered binding to its predicate for the registry to rewrite.
- *
- * @since 0.10.0
- */
-export function writablePredicate(binding) {
-    return binding;
-}
-/**
- * Narrows a registered binding to its membership flag for the registry to set.
- *
- * @since 0.10.0
- */
-export function writableMembership(binding) {
-    return binding;
-}
 /**
  * The stamp of a binding whose activation need has not been computed under the current versions.
  *
@@ -142,16 +138,10 @@ export function writableMembership(binding) {
  */
 export const NO_ACTIVATION_STAMP = -1;
 /**
- * The registration order of a binding no registry has added yet.
- *
- * @since 0.11.0
- */
-export const UNREGISTERED_ORDER = -1;
-/**
- * Drops the memoized resolution frame, for a refinement that changes what the frame reports.
+ * Drops the memoized resolution frame, for a scope change that alters what the frame reports.
  *
- * @remarks The frame derives from `scope` and `slot`, both of which a chain now writes in place on
- * the registered object, so every such refinement clears it.
+ * @remarks The frame derives from `scope` and `slot`; the slot is final once the binding registers, so
+ * only a scope written in place on the registered object clears it.
  *
  * @since 0.5.0-canary.9
  */

package/dist/core/module.d.ts

@@ -1,4 +1,4 @@
-import type { BindToBuilder } from "#core/binding";
+import type { BindToBuilder } from "#core/binding-builders";
 import type { BindingDeclaration, DeclaredBinding } from "#core/binding-declaration";
 import type { Token } from "#core/token";
 import type { Constructor } from "#core/types";

package/dist/core/registry.d.ts

@@ -1,7 +1,7 @@
 import type { Binding } from "#core/binding";
 import type { BindingTag } from "#core/tag";
 import type { Token } from "#core/token";
-import type { BindingConstraint, BindingIdentifier, Constructor } from "#core/types";
+import type { BindingIdentifier, Constructor } from "#core/types";
 /**
  * @since 0.11.0
  */
@@ -11,6 +11,8 @@ export declare class BindingRegistry {
     get version(): number;
     /** Whether a constant has ever been registered here, and so whether teardown has anything to sweep. */
     get hasHeldConstantBinding(): boolean;
+    /** Whether an alias has ever been registered here, and so whether a candidate list can hold one. */
+    get hasHeldAlias(): boolean;
     /** Whether the deferred tagged-slot index has had to be built. */
     get isTaggedIndexBuilt(): boolean;
     /** Whether an id-keyed operation has had to build the id index. */
@@ -55,8 +57,6 @@ export declare class BindingRegistry {
     allBindings(): ReadonlyArray<Binding>;
     /** Remove all bindings. Returns all removed. */
     clear(): ReadonlyArray<Binding>;
-    /** Whether a slot-based binding currently occupies `binding`'s slot, so adding it would displace. */
-    hasSlotOccupant(binding: Binding): boolean;
     /**
      * The binding indexed under one criterion.
      *
@@ -83,28 +83,13 @@ export declare class BindingRegistry {
     hasPredicateCandidate(token: Token<unknown> | Constructor): boolean;
     /** The binding holding a token's default slot — lone or recorded — or `undefined` when none does. */
     getDefaultSlotBinding(token: Token<unknown> | Constructor): Binding | undefined;
-    /** A token's lone default-slot binding — the first read of every synchronous resolve. */
-    getFastDefault(token: Token<unknown> | Constructor): Binding | undefined;
     /**
-     * Takes a live binding out of every index, lets `rewrite` change its slot or predicate, and reports
-     * whether it was live; the caller registers it again with `add`.
+     * The token's default-slot alias, which forwards a request's criteria to its target, or `undefined`.
      *
-     * @remarks The binding keeps its object and its id, so the id index needs no touch and nothing
-     * that holds the object has to be told. `false` means the binding was unbound or displaced since
-     * it registered, and a refinement must not resurrect it.
+     * @remarks A registry that never held an alias answers without probing, so a request missing every slot of a
+     * token pays for forwarding only where forwarding can happen.
      */
-    reslot(binding: Binding, rewrite: () => void): boolean;
-    /**
-     * Marks a live binding as a collection member in place, moving it out of the lone map: a member is
-     * never the token's lone default answer, and nothing else indexes on membership.
-     */
-    setMany(binding: Binding): void;
-    /**
-     * Adds a predicate to a live binding in place.
-     *
-     * @remarks Only ever narrows — `when()` composes with any existing predicate — so the argument is
-     * never absent. Nothing indexes on the predicate, so the binding object and its id stay; a lone
-     * binding moves to a record because the lone map holds default-slot bindings with no predicate.
-     */
-    setPredicate(binding: Binding, predicate: BindingConstraint): void;
+    defaultSlotAlias(token: Token<unknown> | Constructor): Binding | undefined;
+    /** A token's lone default-slot binding — the first read of every synchronous resolve. */
+    getFastDefault(token: Token<unknown> | Constructor): Binding | undefined;
 }

package/dist/core/registry.js

@@ -1,4 +1,4 @@
-import { bindingSlotEquals, UNREGISTERED_ORDER, writableMembership, writablePredicate } from "#core/binding";
+import { bindingSlotEquals } from "#core/binding";
 import { getOrInsert } from "#core/map-upsert";
 import { advanceStateEpoch } from "#core/state-epoch";
 const NO_BINDINGS = Object.freeze([]);
@@ -21,8 +21,8 @@ function createTokenRecord(bindings) {
  * that only ever resolves through its parent — every per-request child — allocates no map.
  */
 const EMPTY_LONE = new Map();
-// Process-wide, so registration order compares across every registry a binding could be restored into.
-let registrationCounter = 0;
+const HELD_CONSTANT = 1;
+const HELD_ALIAS = 2;
 /**
  * @since 0.11.0
  */
@@ -35,18 +35,14 @@ export class BindingRegistry {
     // Every other token — several bindings, a tagged slot, a predicate — has a record here, and a
     // token is in exactly one of the two maps. Allocated by the first token that needs a record.
     #records;
-    // The binding the last `add` placed and where it landed: the fluent chain refines what it just
-    // registered, so a refinement that follows its own add re-slots without a map probe.
-    #lastAdded;
-    #lastAddedRecord;
     // Built on the first id-keyed read and maintained from then on: a bind-and-resolve container
     // never asks by id, so it never pays for the second map.
     #byId;
     // Set when the first tagged slot lands and never cleared, like the tagged maps it stands for.
     #taggedIndexBuilt = false;
-    // 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;
+    // Kinds registered here at least once, never cleared: only the negative answers must be exact, so a
+    // container holding no constant skips its teardown sweep and one holding no alias skips its forwarding probe.
+    #heldKinds = 0;
     /** Monotonic version — increments on every mutation. */
     get version() {
         return this.#version;
@@ -59,7 +55,11 @@ export class BindingRegistry {
     }
     /** Whether a constant has ever been registered here, and so whether teardown has anything to sweep. */
     get hasHeldConstantBinding() {
-        return this.#heldConstantBinding;
+        return (this.#heldKinds & HELD_CONSTANT) !== 0;
+    }
+    /** Whether an alias has ever been registered here, and so whether a candidate list can hold one. */
+    get hasHeldAlias() {
+        return (this.#heldKinds & HELD_ALIAS) !== 0;
     }
     /** Whether the deferred tagged-slot index has had to be built. */
     get isTaggedIndexBuilt() {
@@ -88,25 +88,21 @@ export class BindingRegistry {
      */
     add(binding) {
         this.#bump();
-        if (binding.registrationOrder === UNREGISTERED_ORDER) {
-            registrationCounter += 1;
-            binding.registrationOrder = registrationCounter;
-        }
         if (binding.kind === "constant") {
-            this.#heldConstantBinding = true;
+            this.#heldKinds |= HELD_CONSTANT;
+        }
+        else if (binding.kind === "alias") {
+            this.#heldKinds |= HELD_ALIAS;
         }
         const key = binding.token;
         const records = this.#records;
         if (records !== undefined) {
             const record = records.get(key);
             if (record !== undefined) {
-                this.#lastAdded = binding;
-                this.#lastAddedRecord = record;
                 return this.#addToRecord(key, record, binding);
             }
         }
         const occupant = this.#lone.get(key);
-        this.#lastAdded = binding;
         if (occupant === undefined) {
             // The common bind: a fresh token taking the lone seat, one probe and one write.
             if (this.#byId !== undefined) {
@@ -114,33 +110,30 @@ export class BindingRegistry {
             }
             if (isDefaultSlotBinding(binding)) {
                 this.#setLone(key, binding);
-                this.#lastAddedRecord = undefined;
             }
             else {
-                this.#lastAddedRecord = this.#createRecord(key, [binding]);
+                this.#createRecord(key, [binding]);
             }
             return undefined;
         }
         // Same slot, last wins: the newcomer takes the lone seat and nothing else moves.
         if (isDefaultSlotBinding(binding)) {
             this.#setLone(key, binding);
-            this.#lastAddedRecord = undefined;
             if (this.#byId !== undefined) {
                 this.#byId.delete(occupant.identifier);
                 this.#byId.set(binding.identifier, binding);
             }
             return occupant;
         }
-        // A second shape joins the token, which is what a record is for.
+        // A second shape joins the token, which is what a record is for; every add is the newest, so it goes last.
         this.#deleteLone(key);
         this.#byId?.set(binding.identifier, binding);
-        this.#lastAddedRecord = this.#createRecord(key, occupant.registrationOrder < binding.registrationOrder ? [occupant, binding] : [binding, occupant]);
+        this.#createRecord(key, [occupant, binding]);
         return undefined;
     }
     /** Remove all bindings for a token. Returns removed bindings. */
     removeByToken(token) {
         this.#bump();
-        this.#lastAdded = undefined;
         const lone = this.#lone.get(token);
         if (lone !== undefined) {
             this.#deleteLone(token);
@@ -168,7 +161,6 @@ export class BindingRegistry {
             return undefined;
         }
         this.#bump();
-        this.#lastAdded = undefined;
         byId.delete(id);
         const key = binding.token;
         if (this.#lone.get(key)?.identifier === id) {
@@ -236,28 +228,12 @@ export class BindingRegistry {
     /** Remove all bindings. Returns all removed. */
     clear() {
         this.#bump();
-        this.#lastAdded = undefined;
         const all = this.allBindings();
         this.#clearLone();
         this.#records?.clear();
         this.#byId?.clear();
         return all;
     }
-    /** Whether a slot-based binding currently occupies `binding`'s slot, so adding it would displace. */
-    hasSlotOccupant(binding) {
-        if (isPurePredicateBinding(binding)) {
-            return false;
-        }
-        if (this.#lone.has(binding.token)) {
-            // The lone seat is the default slot, so only a default-slot newcomer collides with it.
-            return binding.slot.tags.length === 0;
-        }
-        const record = this.#records?.get(binding.token);
-        if (record === undefined) {
-            return false;
-        }
-        return this.#slotOccupant(record, binding.slot) !== undefined;
-    }
     /**
      * The binding indexed under one criterion.
      *
@@ -304,109 +280,22 @@ export class BindingRegistry {
     getDefaultSlotBinding(token) {
         return this.#lone.get(token) ?? this.#records?.get(token)?.defaultOccupant;
     }
-    /** A token's lone default-slot binding — the first read of every synchronous resolve. */
-    getFastDefault(token) {
-        return this.#lone.get(token);
-    }
-    /**
-     * Takes a live binding out of every index, lets `rewrite` change its slot or predicate, and reports
-     * whether it was live; the caller registers it again with `add`.
-     *
-     * @remarks The binding keeps its object and its id, so the id index needs no touch and nothing
-     * that holds the object has to be told. `false` means the binding was unbound or displaced since
-     * it registered, and a refinement must not resurrect it.
-     */
-    reslot(binding, rewrite) {
-        const key = binding.token;
-        if (this.#lone.get(key) === binding) {
-            this.#bump();
-            this.#lastAdded = undefined;
-            this.#deleteLone(key);
-        }
-        else {
-            const record = this.#records?.get(key);
-            const index = record === undefined ? -1 : record.bindings.indexOf(binding);
-            if (record === undefined || index === -1) {
-                return false;
-            }
-            this.#bump();
-            this.#lastAdded = undefined;
-            // Replaced, never spliced: a walk holding the current array must not lose its place.
-            record.bindings = record.bindings.toSpliced(index, 1);
-            this.#deindexSlot(record, binding);
-            this.#settle(key, record);
-        }
-        rewrite();
-        return true;
-    }
-    /**
-     * Marks a live binding as a collection member in place, moving it out of the lone map: a member is
-     * never the token's lone default answer, and nothing else indexes on membership.
-     */
-    setMany(binding) {
-        this.#bump();
-        // Set before any (re)indexing so `#indexSlot` sees a member and leaves it out of every slot.
-        writableMembership(binding).isMany = true;
-        if (binding === this.#lastAdded) {
-            // The chain refining what it just added: where the binding sits is known without a probe.
-            const record = this.#lastAddedRecord;
-            if (record === undefined) {
-                this.#deleteLone(binding.token);
-                this.#lastAddedRecord = this.#createRecord(binding.token, [binding]);
-            }
-            else if (record.defaultOccupant === binding) {
-                record.defaultOccupant = undefined;
-            }
-            return;
-        }
-        if (this.#promoteLoneToRecord(binding.token, binding)) {
-            return;
-        }
-        // A default occupant that becomes a member frees its slot, so drop the stale index entry. A
-        // member cannot collapse a record back to lone, so this path does not settle.
-        this.#clearDefaultOccupant(binding.token, binding);
-    }
     /**
-     * Adds a predicate to a live binding in place.
+     * The token's default-slot alias, which forwards a request's criteria to its target, or `undefined`.
      *
-     * @remarks Only ever narrows — `when()` composes with any existing predicate — so the argument is
-     * never absent. Nothing indexes on the predicate, so the binding object and its id stay; a lone
-     * binding moves to a record because the lone map holds default-slot bindings with no predicate.
+     * @remarks A registry that never held an alias answers without probing, so a request missing every slot of a
+     * token pays for forwarding only where forwarding can happen.
      */
-    setPredicate(binding, predicate) {
-        this.#bump();
-        // Set before any (re)indexing: a predicate-only binding holds no default slot.
-        writablePredicate(binding).predicate = predicate;
-        if (this.#promoteLoneToRecord(binding.token, binding)) {
-            return;
-        }
-        // The binding may have vacated the default slot, and a narrowed record can collapse back to lone.
-        const record = this.#clearDefaultOccupant(binding.token, binding);
-        if (record !== undefined) {
-            this.#settle(binding.token, record);
-        }
-    }
-    /**
-     * Moves a binding still holding the lone seat into a fresh one-binding record, returning whether it did.
-     *
-     * @remarks Its field (`isMany` or `predicate`) is written before this call, so the founding
-     * `#indexSlot` files it under the slot it now holds.
-     */
-    #promoteLoneToRecord(key, binding) {
-        if (this.#lone.get(key) !== binding) {
-            return false;
+    defaultSlotAlias(token) {
+        if ((this.#heldKinds & HELD_ALIAS) === 0) {
+            return undefined;
         }
-        this.#deleteLone(key);
-        this.#createRecord(key, [binding]);
-        return true;
+        const occupant = this.getDefaultSlotBinding(token);
+        return occupant !== undefined && occupant.kind === "alias" ? occupant : undefined;
     }
-    /** Clears the default-slot index entry a binding has vacated, returning its record if one exists. */
-    #clearDefaultOccupant(key, binding) {
-        const record = this.#records?.get(key);
-        if (record?.defaultOccupant === binding) {
-            record.defaultOccupant = undefined;
-        }
-        return record;
+    /** A token's lone default-slot binding — the first read of every synchronous resolve. */
+    getFastDefault(token) {
+        return this.#lone.get(token);
     }
     #createRecord(key, bindings) {
         const record = createTokenRecord(bindings);
@@ -445,7 +334,7 @@ export class BindingRegistry {
         if (displacedBinding !== undefined) {
             record.bindings = record.bindings.filter((candidate) => candidate !== displacedBinding);
         }
-        insertInRegistrationOrder(record, binding);
+        record.bindings.push(binding);
         this.#byId?.set(binding.identifier, binding);
         this.#indexSlot(record, binding);
         this.#settle(key, record);
@@ -544,20 +433,6 @@ export class BindingRegistry {
  * Places a binding in its record by registration order: a fresh registration appends, and a binding a
  * chain took out and put back returns to its place.
  */
-function insertInRegistrationOrder(record, binding) {
-    const { bindings } = record;
-    const order = binding.registrationOrder;
-    if (bindings.length === 0 || bindings.at(-1).registrationOrder < order) {
-        bindings.push(binding);
-        return;
-    }
-    let index = bindings.length - 1;
-    while (index > 0 && bindings[index - 1].registrationOrder > order) {
-        index -= 1;
-    }
-    // Replaced, never spliced: a walk holding the current array must not lose its place.
-    record.bindings = bindings.toSpliced(index, 0, binding);
-}
 /** A binding nothing has to be matched against: the default slot, no predicate, not a collection member. */
 function isDefaultSlotBinding(binding) {
     return binding.slot.tags.length === 0 && binding.predicate === undefined && !binding.isMany;

package/dist/core/tag.js

@@ -1,6 +1,6 @@
 /** Tag keys and the interned pairs they mint — the one way a slot criterion is built. */
 /**
- * The bits a tag-key mask holds: the width of a 32-bit integer, a constant of the machine.
+ * The bits a tag-key mask holds: the width of a 32-bit integer.
  *
  * @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.