velocious 1.0.552 → 1.0.555

package/build/src/testing/factory/factory-registry.js

@@ -0,0 +1,438 @@
+// @ts-check
+import { DuplicateDefinitionError, RegistryBusyError, UndefinedSequenceError } from "./errors.js";
+import AttributesForStrategy from "./strategies/attributes-for.js";
+import BuildStrategy from "./strategies/build.js";
+import CreateStrategy from "./strategies/create.js";
+import DefinitionSession from "./definition-builder.js";
+import FactoryEventEmitter from "./events.js";
+import FactoryLinter from "./linter.js";
+import FactoryRunner from "./factory-runner.js";
+import { isPlainObject } from "is-plain-object";
+/**
+ * Normalizes a strategy invocation's variadic tail into ordered trait names plus
+ * a single final overrides object (`strategy(name, ...traits, overrides?)`).
+ * @param {Array<?>} args - Arguments after the factory name (and count for lists).
+ * @returns {{traits: string[], overrides: Record<string, ?>}} - Normalized invocation.
+ */
+function normalizeInvocationArgs(args) {
+    /** @type {string[]} */
+    const traits = [];
+    /** @type {Record<string, ?>} */
+    let overrides = {};
+    let sawOverrides = false;
+    for (const arg of args) {
+        if (typeof arg === "string" && !sawOverrides) {
+            traits.push(arg);
+        }
+        else if (isPlainObject(arg) && !sawOverrides) {
+            overrides = arg;
+            sawOverrides = true;
+        }
+        else if (arg !== undefined) {
+            throw new TypeError(`Invalid factory invocation argument: ${String(arg)}. Expected trait names then a single final overrides object.`);
+        }
+    }
+    return { traits, overrides };
+}
+/**
+ * Owns all factories, traits, sequences, callbacks and construction defaults for
+ * one isolated scope, and exposes the strategy entry points. Registry mutation is
+ * setup-time only and is rejected while evaluations are active.
+ */
+export default class FactoryRegistry {
+    /** Builds an empty registry with the built-in strategies installed. */
+    constructor() {
+        /** @type {Map<string, import("./factory-definition.js").default>} - Factories and aliases. */
+        this._factories = new Map();
+        /** @type {Map<string, import("./trait-definition.js").default>} - Global traits. */
+        this._globalTraits = new Map();
+        /** @type {Map<string, import("./sequence.js").default>} - Global sequences and aliases. */
+        this._sequences = new Map();
+        /** @type {Map<string, Map<string, import("./sequence.js").default>>} - Factory-scoped sequences. */
+        this._factorySequences = new Map();
+        /** @type {import("./declarations.js").Declaration[]} - Registry-level default declarations. */
+        this._globalDeclarations = [];
+        /** @type {number} - In-flight evaluation count (mutation guard). */
+        this._activeEvaluations = 0;
+        /** @type {FactoryRunner} - Plan compiler. */
+        this._runner = new FactoryRunner(this);
+        /** @type {FactoryEventEmitter} - Debug/performance event emitter. */
+        this._events = new FactoryEventEmitter();
+        /** @type {{attributesFor: AttributesForStrategy, build: BuildStrategy, create: CreateStrategy}} - Installed strategies. */
+        this._strategies = {
+            attributesFor: new AttributesForStrategy(),
+            build: new BuildStrategy(),
+            create: new CreateStrategy()
+        };
+    }
+    /**
+     * Registers factories/traits/sequences/callbacks via a builder callback.
+     * @param {(builder: object) => void} callback - The definition callback.
+     * @returns {this} - This registry (for chaining).
+     */
+    define(callback) {
+        this._assertNotEvaluating("define");
+        new DefinitionSession(this).run(callback);
+        return this;
+    }
+    /**
+     * Reopens existing factories to append/override declarations, recompiling each
+     * into a fresh immutable definition. Rejected while evaluations are active.
+     * @param {(builder: object) => void} callback - The modify callback.
+     * @returns {this} - This registry (for chaining).
+     */
+    modify(callback) {
+        this._assertNotEvaluating("modify");
+        new DefinitionSession(this).runModify(callback);
+        return this;
+    }
+    /**
+     * Lints factories/traits, aggregating every failure. Create-strategy cases roll
+     * back their database writes.
+     * @param {object} [options] - Lint options (factories, traits, strategy).
+     * @returns {Promise<void>} - Resolves when all cases pass; rejects with an aggregate otherwise.
+     */
+    async lint(options) {
+        return await new FactoryLinter(this).lint(options);
+    }
+    /**
+     * Subscribes to factory debug events (`start`, `success`, `failure`).
+     * @param {string} event - Event name.
+     * @param {(payload: {invocationId: string, factory: string, strategy: string, traits: string[], durationMs?: number, error?: ?}) => void} handler - Event handler.
+     * @returns {this} - This registry (for chaining).
+     */
+    on(event, handler) {
+        this._events.on(event, handler);
+        return this;
+    }
+    /**
+     * Unsubscribes a previously-registered event handler.
+     * @param {string} event - Event name.
+     * @param {(payload: ?) => void} handler - Event handler to remove.
+     * @returns {this} - This registry (for chaining).
+     */
+    off(event, handler) {
+        this._events.off(event, handler);
+        return this;
+    }
+    /**
+     * Resolves attributes without constructing a model or building associations.
+     * @param {string} factoryName - Factory name.
+     * @param {Array<?>} args - Trait names then an optional overrides object.
+     * @returns {Promise<Record<string, ?>>} - The resolved attributes.
+     */
+    async attributesFor(factoryName, ...args) {
+        const { traits, overrides } = normalizeInvocationArgs(args);
+        return await this._runFactory({ factoryName, traits, overrides, strategy: "attributesFor" });
+    }
+    /**
+     * Builds an unsaved record graph.
+     * @param {string} factoryName - Factory name.
+     * @param {Array<?>} args - Trait names then an optional overrides object.
+     * @returns {Promise<?>} - The built record.
+     */
+    async build(factoryName, ...args) {
+        const { traits, overrides } = normalizeInvocationArgs(args);
+        return await this._runFactory({ factoryName, traits, overrides, strategy: "build" });
+    }
+    /**
+     * Builds and persists a record graph.
+     * @param {string} factoryName - Factory name.
+     * @param {Array<?>} args - Trait names then an optional overrides object.
+     * @returns {Promise<?>} - The persisted record.
+     */
+    async create(factoryName, ...args) {
+        const { traits, overrides } = normalizeInvocationArgs(args);
+        return await this._runFactory({ factoryName, traits, overrides, strategy: "create" });
+    }
+    /**
+     * Resolves attributes for a list of records sequentially.
+     * @param {string} factoryName - Factory name.
+     * @param {number} count - Number of entries.
+     * @param {Array<?>} args - Trait names then an optional overrides object.
+     * @returns {Promise<Array<Record<string, ?>>>} - The resolved attribute objects.
+     */
+    async attributesForList(factoryName, count, ...args) {
+        return await this._runList("attributesFor", factoryName, count, args);
+    }
+    /**
+     * Builds a list of unsaved records sequentially.
+     * @param {string} factoryName - Factory name.
+     * @param {number} count - Number of records.
+     * @param {Array<?>} args - Trait names then an optional overrides object.
+     * @returns {Promise<Array<?>>} - The built records.
+     */
+    async buildList(factoryName, count, ...args) {
+        return await this._runList("build", factoryName, count, args);
+    }
+    /**
+     * Creates a list of persisted records sequentially.
+     * @param {string} factoryName - Factory name.
+     * @param {number} count - Number of records.
+     * @param {Array<?>} args - Trait names then an optional overrides object.
+     * @returns {Promise<Array<?>>} - The persisted records.
+     */
+    async createList(factoryName, count, ...args) {
+        return await this._runList("create", factoryName, count, args);
+    }
+    /**
+     * Resolves attributes for exactly two records.
+     * @param {string} factoryName - Factory name.
+     * @param {Array<?>} args - Trait names then an optional overrides object.
+     * @returns {Promise<Array<Record<string, ?>>>} - The two resolved attribute objects.
+     */
+    async attributesForPair(factoryName, ...args) {
+        return await this._runList("attributesFor", factoryName, 2, args);
+    }
+    /**
+     * Builds exactly two unsaved records.
+     * @param {string} factoryName - Factory name.
+     * @param {Array<?>} args - Trait names then an optional overrides object.
+     * @returns {Promise<Array<?>>} - The two built records.
+     */
+    async buildPair(factoryName, ...args) {
+        return await this._runList("build", factoryName, 2, args);
+    }
+    /**
+     * Creates exactly two persisted records.
+     * @param {string} factoryName - Factory name.
+     * @param {Array<?>} args - Trait names then an optional overrides object.
+     * @returns {Promise<Array<?>>} - The two persisted records.
+     */
+    async createPair(factoryName, ...args) {
+        return await this._runList("create", factoryName, 2, args);
+    }
+    /**
+     * Advances a sequence and returns its formatted value.
+     * @param {string} sequenceName - Sequence name.
+     * @returns {Promise<?>} - The formatted value.
+     */
+    async generate(sequenceName) {
+        return await this._generateScoped(sequenceName, []);
+    }
+    /**
+     * Advances a sequence `count` times and returns the formatted values.
+     * @param {string} sequenceName - Sequence name.
+     * @param {number} count - Number of values.
+     * @returns {Promise<Array<?>>} - The formatted values.
+     */
+    async generateList(sequenceName, count) {
+        /** @type {Array<?>} */
+        const values = [];
+        for (let index = 0; index < count; index++) {
+            values.push(await this._generateScoped(sequenceName, []));
+        }
+        return values;
+    }
+    /**
+     * Returns the next raw value a global sequence would allocate without consuming it.
+     * @param {string} sequenceName - Sequence name.
+     * @returns {number} - The upcoming raw value.
+     */
+    peekSequence(sequenceName) {
+        return this._resolveGlobalSequence(sequenceName).peek();
+    }
+    /**
+     * Sets the next value a global sequence will allocate.
+     * @param {string} sequenceName - Sequence name.
+     * @param {number} value - Next raw value.
+     * @returns {void}
+     */
+    setSequence(sequenceName, value) {
+        this._assertNotEvaluating("setSequence");
+        this._resolveGlobalSequence(sequenceName).set(value);
+    }
+    /**
+     * Rewinds a single global sequence to its initial value.
+     * @param {string} sequenceName - Sequence name.
+     * @returns {void}
+     */
+    rewindSequence(sequenceName) {
+        this._assertNotEvaluating("rewindSequence");
+        this._resolveGlobalSequence(sequenceName).rewind();
+    }
+    /**
+     * Rewinds every global and factory-scoped sequence to its initial value while
+     * leaving all definitions intact.
+     * @returns {void}
+     */
+    rewindSequences() {
+        this._assertNotEvaluating("rewindSequences");
+        for (const sequence of new Set(this._sequences.values()))
+            sequence.rewind();
+        for (const scope of this._factorySequences.values()) {
+            for (const sequence of new Set(scope.values()))
+                sequence.rewind();
+        }
+    }
+    /**
+     * Clears all definitions, traits, sequences and registry defaults, restoring an
+     * empty registry with the built-in strategies.
+     * @returns {void}
+     */
+    reset() {
+        this._assertNotEvaluating("reset");
+        this._factories.clear();
+        this._globalTraits.clear();
+        this._sequences.clear();
+        this._factorySequences.clear();
+        this._globalDeclarations = [];
+        this._events = new FactoryEventEmitter();
+    }
+    /**
+     * Runs `count` sequential strategy invocations.
+     * @param {"attributesFor" | "build" | "create"} strategy - Strategy name.
+     * @param {string} factoryName - Factory name.
+     * @param {number} count - Number of entries.
+     * @param {Array<?>} args - Trait names then an optional overrides object.
+     * @returns {Promise<Array<?>>} - The results.
+     */
+    async _runList(strategy, factoryName, count, args) {
+        const { traits, overrides } = normalizeInvocationArgs(args);
+        /** @type {Array<?>} */
+        const results = [];
+        for (let index = 0; index < count; index++) {
+            results.push(await this._runFactory({ factoryName, traits, overrides, strategy }));
+        }
+        return results;
+    }
+    /**
+     * Compiles and runs a factory invocation under a strategy, tracking active
+     * evaluations for the mutation guard.
+     * @param {object} args - Options.
+     * @param {string} args.factoryName - Factory name.
+     * @param {string[]} args.traits - Ordered traits.
+     * @param {Record<string, ?>} args.overrides - Overrides.
+     * @param {"attributesFor" | "build" | "create"} args.strategy - Strategy name.
+     * @returns {Promise<?>} - The strategy result.
+     */
+    async _runFactory({ factoryName, traits, overrides, strategy }) {
+        this._activeEvaluations += 1;
+        const invocationId = this._events.nextInvocationId();
+        const startedAt = Date.now();
+        try {
+            this._events.emit("start", { invocationId, factory: factoryName, strategy, traits });
+            const plan = this._runner.compile(factoryName, traits, overrides);
+            const result = await this._strategies[strategy].run({ registry: this, plan });
+            this._events.emit("success", { invocationId, factory: factoryName, strategy, traits, durationMs: Date.now() - startedAt });
+            return result;
+        }
+        catch (error) {
+            this._events.emit("failure", { invocationId, factory: factoryName, strategy, traits, durationMs: Date.now() - startedAt, error });
+            throw error;
+        }
+        finally {
+            this._activeEvaluations -= 1;
+        }
+    }
+    /**
+     * Registers an immutable factory definition and its aliases.
+     * @param {import("./factory-definition.js").default} definition - Compiled factory.
+     * @returns {void}
+     */
+    _registerFactoryDefinition(definition) {
+        for (const name of [definition.name, ...definition.aliases]) {
+            if (this._factories.has(name)) {
+                throw new DuplicateDefinitionError(`Factory "${name}" is already registered`);
+            }
+        }
+        for (const name of [definition.name, ...definition.aliases]) {
+            this._factories.set(name, definition);
+        }
+    }
+    /**
+     * Replaces an existing factory definition (and its aliases) with a recompiled
+     * one. Used by `modify`; no duplicate check because it intentionally overwrites.
+     * @param {import("./factory-definition.js").default} definition - Recompiled factory.
+     * @returns {void}
+     */
+    _replaceFactoryDefinition(definition) {
+        for (const name of [definition.name, ...definition.aliases]) {
+            this._factories.set(name, definition);
+        }
+    }
+    /**
+     * Registers a global trait.
+     * @param {import("./trait-definition.js").default} trait - Compiled trait.
+     * @returns {void}
+     */
+    _registerGlobalTrait(trait) {
+        if (this._globalTraits.has(trait.name)) {
+            throw new DuplicateDefinitionError(`Trait "${trait.name}" is already registered`);
+        }
+        this._globalTraits.set(trait.name, trait);
+    }
+    /**
+     * Registers a sequence (and its aliases) either globally or under a factory scope.
+     * @param {import("./sequence.js").default} sequence - Sequence instance.
+     * @param {string | null} factoryScope - Factory name to scope under, or null for global.
+     * @returns {void}
+     */
+    _registerSequence(sequence, factoryScope) {
+        /** @type {Map<string, import("./sequence.js").default>} */
+        let target;
+        if (factoryScope) {
+            if (!this._factorySequences.has(factoryScope))
+                this._factorySequences.set(factoryScope, new Map());
+            target = /** @type {Map<string, import("./sequence.js").default>} */ (this._factorySequences.get(factoryScope));
+        }
+        else {
+            target = this._sequences;
+        }
+        for (const name of [sequence.name, ...sequence.aliases]) {
+            if (target.has(name)) {
+                throw new DuplicateDefinitionError(`Sequence "${name}" is already registered${factoryScope ? ` for factory "${factoryScope}"` : ""}`);
+            }
+        }
+        for (const name of [sequence.name, ...sequence.aliases]) {
+            target.set(name, sequence);
+        }
+    }
+    /**
+     * Appends a registry-level default declaration (callbacks/construction defaults).
+     * @param {import("./declarations.js").Declaration} declaration - Declaration to add.
+     * @returns {void}
+     */
+    _addGlobalDeclaration(declaration) {
+        this._globalDeclarations.push(declaration);
+    }
+    /**
+     * Resolves a sequence name against a factory scope chain (child first) then the
+     * global scope and advances it.
+     * @param {string} sequenceName - Sequence name.
+     * @param {string[]} chainNames - Inheritance chain names (child last).
+     * @returns {Promise<?>} - The formatted value.
+     */
+    async _generateScoped(sequenceName, chainNames) {
+        for (let index = chainNames.length - 1; index >= 0; index--) {
+            const scope = this._factorySequences.get(chainNames[index]);
+            if (scope && scope.has(sequenceName)) {
+                return await /** @type {import("./sequence.js").default} */ (scope.get(sequenceName)).next();
+            }
+        }
+        return await this._resolveGlobalSequence(sequenceName).next();
+    }
+    /**
+     * Resolves a global sequence by name.
+     * @param {string} sequenceName - Sequence name.
+     * @returns {import("./sequence.js").default} - The sequence.
+     */
+    _resolveGlobalSequence(sequenceName) {
+        const sequence = this._sequences.get(sequenceName);
+        if (!sequence) {
+            throw new UndefinedSequenceError(`No sequence registered called "${sequenceName}"`);
+        }
+        return sequence;
+    }
+    /**
+     * Rejects setup-time mutation while evaluations are active.
+     * @param {string} operation - Operation name, for the error message.
+     * @returns {void}
+     */
+    _assertNotEvaluating(operation) {
+        if (this._activeEvaluations > 0) {
+            throw new RegistryBusyError(`Cannot ${operation} while factory evaluations are active. Registry mutation is setup-time only.`);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"factory-registry.js","sourceRoot":"","sources":["../../../../src/testing/factory/factory-registry.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {DuplicateDefinitionError, RegistryBusyError, UndefinedSequenceError} from \"./errors.js\"\nimport AttributesForStrategy from \"./strategies/attributes-for.js\"\nimport BuildStrategy from \"./strategies/build.js\"\nimport CreateStrategy from \"./strategies/create.js\"\nimport DefinitionSession from \"./definition-builder.js\"\nimport FactoryEventEmitter from \"./events.js\"\nimport FactoryLinter from \"./linter.js\"\nimport FactoryRunner from \"./factory-runner.js\"\nimport {isPlainObject} from \"is-plain-object\"\n\n/**\n * Normalizes a strategy invocation's variadic tail into ordered trait names plus\n * a single final overrides object (`strategy(name, ...traits, overrides?)`).\n * @param {Array<?>} args - Arguments after the factory name (and count for lists).\n * @returns {{traits: string[], overrides: Record<string, ?>}} - Normalized invocation.\n */\nfunction normalizeInvocationArgs(args) {\n  /** @type {string[]} */\n  const traits = []\n  /** @type {Record<string, ?>} */\n  let overrides = {}\n  let sawOverrides = false\n\n  for (const arg of args) {\n    if (typeof arg === \"string\" && !sawOverrides) {\n      traits.push(arg)\n    } else if (isPlainObject(arg) && !sawOverrides) {\n      overrides = arg\n      sawOverrides = true\n    } else if (arg !== undefined) {\n      throw new TypeError(`Invalid factory invocation argument: ${String(arg)}. Expected trait names then a single final overrides object.`)\n    }\n  }\n\n  return {traits, overrides}\n}\n\n/**\n * Owns all factories, traits, sequences, callbacks and construction defaults for\n * one isolated scope, and exposes the strategy entry points. Registry mutation is\n * setup-time only and is rejected while evaluations are active.\n */\nexport default class FactoryRegistry {\n  /** Builds an empty registry with the built-in strategies installed. */\n  constructor() {\n    /** @type {Map<string, import(\"./factory-definition.js\").default>} - Factories and aliases. */\n    this._factories = new Map()\n\n    /** @type {Map<string, import(\"./trait-definition.js\").default>} - Global traits. */\n    this._globalTraits = new Map()\n\n    /** @type {Map<string, import(\"./sequence.js\").default>} - Global sequences and aliases. */\n    this._sequences = new Map()\n\n    /** @type {Map<string, Map<string, import(\"./sequence.js\").default>>} - Factory-scoped sequences. */\n    this._factorySequences = new Map()\n\n    /** @type {import(\"./declarations.js\").Declaration[]} - Registry-level default declarations. */\n    this._globalDeclarations = []\n\n    /** @type {number} - In-flight evaluation count (mutation guard). */\n    this._activeEvaluations = 0\n\n    /** @type {FactoryRunner} - Plan compiler. */\n    this._runner = new FactoryRunner(this)\n\n    /** @type {FactoryEventEmitter} - Debug/performance event emitter. */\n    this._events = new FactoryEventEmitter()\n\n    /** @type {{attributesFor: AttributesForStrategy, build: BuildStrategy, create: CreateStrategy}} - Installed strategies. */\n    this._strategies = {\n      attributesFor: new AttributesForStrategy(),\n      build: new BuildStrategy(),\n      create: new CreateStrategy()\n    }\n  }\n\n  /**\n   * Registers factories/traits/sequences/callbacks via a builder callback.\n   * @param {(builder: object) => void} callback - The definition callback.\n   * @returns {this} - This registry (for chaining).\n   */\n  define(callback) {\n    this._assertNotEvaluating(\"define\")\n    new DefinitionSession(this).run(callback)\n\n    return this\n  }\n\n  /**\n   * Reopens existing factories to append/override declarations, recompiling each\n   * into a fresh immutable definition. Rejected while evaluations are active.\n   * @param {(builder: object) => void} callback - The modify callback.\n   * @returns {this} - This registry (for chaining).\n   */\n  modify(callback) {\n    this._assertNotEvaluating(\"modify\")\n    new DefinitionSession(this).runModify(callback)\n\n    return this\n  }\n\n  /**\n   * Lints factories/traits, aggregating every failure. Create-strategy cases roll\n   * back their database writes.\n   * @param {object} [options] - Lint options (factories, traits, strategy).\n   * @returns {Promise<void>} - Resolves when all cases pass; rejects with an aggregate otherwise.\n   */\n  async lint(options) {\n    return await new FactoryLinter(this).lint(options)\n  }\n\n  /**\n   * Subscribes to factory debug events (`start`, `success`, `failure`).\n   * @param {string} event - Event name.\n   * @param {(payload: {invocationId: string, factory: string, strategy: string, traits: string[], durationMs?: number, error?: ?}) => void} handler - Event handler.\n   * @returns {this} - This registry (for chaining).\n   */\n  on(event, handler) {\n    this._events.on(event, handler)\n\n    return this\n  }\n\n  /**\n   * Unsubscribes a previously-registered event handler.\n   * @param {string} event - Event name.\n   * @param {(payload: ?) => void} handler - Event handler to remove.\n   * @returns {this} - This registry (for chaining).\n   */\n  off(event, handler) {\n    this._events.off(event, handler)\n\n    return this\n  }\n\n  /**\n   * Resolves attributes without constructing a model or building associations.\n   * @param {string} factoryName - Factory name.\n   * @param {Array<?>} args - Trait names then an optional overrides object.\n   * @returns {Promise<Record<string, ?>>} - The resolved attributes.\n   */\n  async attributesFor(factoryName, ...args) {\n    const {traits, overrides} = normalizeInvocationArgs(args)\n\n    return await this._runFactory({factoryName, traits, overrides, strategy: \"attributesFor\"})\n  }\n\n  /**\n   * Builds an unsaved record graph.\n   * @param {string} factoryName - Factory name.\n   * @param {Array<?>} args - Trait names then an optional overrides object.\n   * @returns {Promise<?>} - The built record.\n   */\n  async build(factoryName, ...args) {\n    const {traits, overrides} = normalizeInvocationArgs(args)\n\n    return await this._runFactory({factoryName, traits, overrides, strategy: \"build\"})\n  }\n\n  /**\n   * Builds and persists a record graph.\n   * @param {string} factoryName - Factory name.\n   * @param {Array<?>} args - Trait names then an optional overrides object.\n   * @returns {Promise<?>} - The persisted record.\n   */\n  async create(factoryName, ...args) {\n    const {traits, overrides} = normalizeInvocationArgs(args)\n\n    return await this._runFactory({factoryName, traits, overrides, strategy: \"create\"})\n  }\n\n  /**\n   * Resolves attributes for a list of records sequentially.\n   * @param {string} factoryName - Factory name.\n   * @param {number} count - Number of entries.\n   * @param {Array<?>} args - Trait names then an optional overrides object.\n   * @returns {Promise<Array<Record<string, ?>>>} - The resolved attribute objects.\n   */\n  async attributesForList(factoryName, count, ...args) {\n    return await this._runList(\"attributesFor\", factoryName, count, args)\n  }\n\n  /**\n   * Builds a list of unsaved records sequentially.\n   * @param {string} factoryName - Factory name.\n   * @param {number} count - Number of records.\n   * @param {Array<?>} args - Trait names then an optional overrides object.\n   * @returns {Promise<Array<?>>} - The built records.\n   */\n  async buildList(factoryName, count, ...args) {\n    return await this._runList(\"build\", factoryName, count, args)\n  }\n\n  /**\n   * Creates a list of persisted records sequentially.\n   * @param {string} factoryName - Factory name.\n   * @param {number} count - Number of records.\n   * @param {Array<?>} args - Trait names then an optional overrides object.\n   * @returns {Promise<Array<?>>} - The persisted records.\n   */\n  async createList(factoryName, count, ...args) {\n    return await this._runList(\"create\", factoryName, count, args)\n  }\n\n  /**\n   * Resolves attributes for exactly two records.\n   * @param {string} factoryName - Factory name.\n   * @param {Array<?>} args - Trait names then an optional overrides object.\n   * @returns {Promise<Array<Record<string, ?>>>} - The two resolved attribute objects.\n   */\n  async attributesForPair(factoryName, ...args) {\n    return await this._runList(\"attributesFor\", factoryName, 2, args)\n  }\n\n  /**\n   * Builds exactly two unsaved records.\n   * @param {string} factoryName - Factory name.\n   * @param {Array<?>} args - Trait names then an optional overrides object.\n   * @returns {Promise<Array<?>>} - The two built records.\n   */\n  async buildPair(factoryName, ...args) {\n    return await this._runList(\"build\", factoryName, 2, args)\n  }\n\n  /**\n   * Creates exactly two persisted records.\n   * @param {string} factoryName - Factory name.\n   * @param {Array<?>} args - Trait names then an optional overrides object.\n   * @returns {Promise<Array<?>>} - The two persisted records.\n   */\n  async createPair(factoryName, ...args) {\n    return await this._runList(\"create\", factoryName, 2, args)\n  }\n\n  /**\n   * Advances a sequence and returns its formatted value.\n   * @param {string} sequenceName - Sequence name.\n   * @returns {Promise<?>} - The formatted value.\n   */\n  async generate(sequenceName) {\n    return await this._generateScoped(sequenceName, [])\n  }\n\n  /**\n   * Advances a sequence `count` times and returns the formatted values.\n   * @param {string} sequenceName - Sequence name.\n   * @param {number} count - Number of values.\n   * @returns {Promise<Array<?>>} - The formatted values.\n   */\n  async generateList(sequenceName, count) {\n    /** @type {Array<?>} */\n    const values = []\n\n    for (let index = 0; index < count; index++) {\n      values.push(await this._generateScoped(sequenceName, []))\n    }\n\n    return values\n  }\n\n  /**\n   * Returns the next raw value a global sequence would allocate without consuming it.\n   * @param {string} sequenceName - Sequence name.\n   * @returns {number} - The upcoming raw value.\n   */\n  peekSequence(sequenceName) {\n    return this._resolveGlobalSequence(sequenceName).peek()\n  }\n\n  /**\n   * Sets the next value a global sequence will allocate.\n   * @param {string} sequenceName - Sequence name.\n   * @param {number} value - Next raw value.\n   * @returns {void}\n   */\n  setSequence(sequenceName, value) {\n    this._assertNotEvaluating(\"setSequence\")\n    this._resolveGlobalSequence(sequenceName).set(value)\n  }\n\n  /**\n   * Rewinds a single global sequence to its initial value.\n   * @param {string} sequenceName - Sequence name.\n   * @returns {void}\n   */\n  rewindSequence(sequenceName) {\n    this._assertNotEvaluating(\"rewindSequence\")\n    this._resolveGlobalSequence(sequenceName).rewind()\n  }\n\n  /**\n   * Rewinds every global and factory-scoped sequence to its initial value while\n   * leaving all definitions intact.\n   * @returns {void}\n   */\n  rewindSequences() {\n    this._assertNotEvaluating(\"rewindSequences\")\n\n    for (const sequence of new Set(this._sequences.values())) sequence.rewind()\n\n    for (const scope of this._factorySequences.values()) {\n      for (const sequence of new Set(scope.values())) sequence.rewind()\n    }\n  }\n\n  /**\n   * Clears all definitions, traits, sequences and registry defaults, restoring an\n   * empty registry with the built-in strategies.\n   * @returns {void}\n   */\n  reset() {\n    this._assertNotEvaluating(\"reset\")\n    this._factories.clear()\n    this._globalTraits.clear()\n    this._sequences.clear()\n    this._factorySequences.clear()\n    this._globalDeclarations = []\n    this._events = new FactoryEventEmitter()\n  }\n\n  /**\n   * Runs `count` sequential strategy invocations.\n   * @param {\"attributesFor\" | \"build\" | \"create\"} strategy - Strategy name.\n   * @param {string} factoryName - Factory name.\n   * @param {number} count - Number of entries.\n   * @param {Array<?>} args - Trait names then an optional overrides object.\n   * @returns {Promise<Array<?>>} - The results.\n   */\n  async _runList(strategy, factoryName, count, args) {\n    const {traits, overrides} = normalizeInvocationArgs(args)\n    /** @type {Array<?>} */\n    const results = []\n\n    for (let index = 0; index < count; index++) {\n      results.push(await this._runFactory({factoryName, traits, overrides, strategy}))\n    }\n\n    return results\n  }\n\n  /**\n   * Compiles and runs a factory invocation under a strategy, tracking active\n   * evaluations for the mutation guard.\n   * @param {object} args - Options.\n   * @param {string} args.factoryName - Factory name.\n   * @param {string[]} args.traits - Ordered traits.\n   * @param {Record<string, ?>} args.overrides - Overrides.\n   * @param {\"attributesFor\" | \"build\" | \"create\"} args.strategy - Strategy name.\n   * @returns {Promise<?>} - The strategy result.\n   */\n  async _runFactory({factoryName, traits, overrides, strategy}) {\n    this._activeEvaluations += 1\n\n    const invocationId = this._events.nextInvocationId()\n    const startedAt = Date.now()\n\n    try {\n      this._events.emit(\"start\", {invocationId, factory: factoryName, strategy, traits})\n\n      const plan = this._runner.compile(factoryName, traits, overrides)\n      const result = await this._strategies[strategy].run({registry: this, plan})\n\n      this._events.emit(\"success\", {invocationId, factory: factoryName, strategy, traits, durationMs: Date.now() - startedAt})\n\n      return result\n    } catch (error) {\n      this._events.emit(\"failure\", {invocationId, factory: factoryName, strategy, traits, durationMs: Date.now() - startedAt, error})\n\n      throw error\n    } finally {\n      this._activeEvaluations -= 1\n    }\n  }\n\n  /**\n   * Registers an immutable factory definition and its aliases.\n   * @param {import(\"./factory-definition.js\").default} definition - Compiled factory.\n   * @returns {void}\n   */\n  _registerFactoryDefinition(definition) {\n    for (const name of [definition.name, ...definition.aliases]) {\n      if (this._factories.has(name)) {\n        throw new DuplicateDefinitionError(`Factory \"${name}\" is already registered`)\n      }\n    }\n\n    for (const name of [definition.name, ...definition.aliases]) {\n      this._factories.set(name, definition)\n    }\n  }\n\n  /**\n   * Replaces an existing factory definition (and its aliases) with a recompiled\n   * one. Used by `modify`; no duplicate check because it intentionally overwrites.\n   * @param {import(\"./factory-definition.js\").default} definition - Recompiled factory.\n   * @returns {void}\n   */\n  _replaceFactoryDefinition(definition) {\n    for (const name of [definition.name, ...definition.aliases]) {\n      this._factories.set(name, definition)\n    }\n  }\n\n  /**\n   * Registers a global trait.\n   * @param {import(\"./trait-definition.js\").default} trait - Compiled trait.\n   * @returns {void}\n   */\n  _registerGlobalTrait(trait) {\n    if (this._globalTraits.has(trait.name)) {\n      throw new DuplicateDefinitionError(`Trait \"${trait.name}\" is already registered`)\n    }\n\n    this._globalTraits.set(trait.name, trait)\n  }\n\n  /**\n   * Registers a sequence (and its aliases) either globally or under a factory scope.\n   * @param {import(\"./sequence.js\").default} sequence - Sequence instance.\n   * @param {string | null} factoryScope - Factory name to scope under, or null for global.\n   * @returns {void}\n   */\n  _registerSequence(sequence, factoryScope) {\n    /** @type {Map<string, import(\"./sequence.js\").default>} */\n    let target\n\n    if (factoryScope) {\n      if (!this._factorySequences.has(factoryScope)) this._factorySequences.set(factoryScope, new Map())\n      target = /** @type {Map<string, import(\"./sequence.js\").default>} */ (this._factorySequences.get(factoryScope))\n    } else {\n      target = this._sequences\n    }\n\n    for (const name of [sequence.name, ...sequence.aliases]) {\n      if (target.has(name)) {\n        throw new DuplicateDefinitionError(`Sequence \"${name}\" is already registered${factoryScope ? ` for factory \"${factoryScope}\"` : \"\"}`)\n      }\n    }\n\n    for (const name of [sequence.name, ...sequence.aliases]) {\n      target.set(name, sequence)\n    }\n  }\n\n  /**\n   * Appends a registry-level default declaration (callbacks/construction defaults).\n   * @param {import(\"./declarations.js\").Declaration} declaration - Declaration to add.\n   * @returns {void}\n   */\n  _addGlobalDeclaration(declaration) {\n    this._globalDeclarations.push(declaration)\n  }\n\n  /**\n   * Resolves a sequence name against a factory scope chain (child first) then the\n   * global scope and advances it.\n   * @param {string} sequenceName - Sequence name.\n   * @param {string[]} chainNames - Inheritance chain names (child last).\n   * @returns {Promise<?>} - The formatted value.\n   */\n  async _generateScoped(sequenceName, chainNames) {\n    for (let index = chainNames.length - 1; index >= 0; index--) {\n      const scope = this._factorySequences.get(chainNames[index])\n\n      if (scope && scope.has(sequenceName)) {\n        return await /** @type {import(\"./sequence.js\").default} */ (scope.get(sequenceName)).next()\n      }\n    }\n\n    return await this._resolveGlobalSequence(sequenceName).next()\n  }\n\n  /**\n   * Resolves a global sequence by name.\n   * @param {string} sequenceName - Sequence name.\n   * @returns {import(\"./sequence.js\").default} - The sequence.\n   */\n  _resolveGlobalSequence(sequenceName) {\n    const sequence = this._sequences.get(sequenceName)\n\n    if (!sequence) {\n      throw new UndefinedSequenceError(`No sequence registered called \"${sequenceName}\"`)\n    }\n\n    return sequence\n  }\n\n  /**\n   * Rejects setup-time mutation while evaluations are active.\n   * @param {string} operation - Operation name, for the error message.\n   * @returns {void}\n   */\n  _assertNotEvaluating(operation) {\n    if (this._activeEvaluations > 0) {\n      throw new RegistryBusyError(`Cannot ${operation} while factory evaluations are active. Registry mutation is setup-time only.`)\n    }\n  }\n}\n"]}