velocious 1.0.577 → 1.0.579

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

@@ -11,13 +11,13 @@ 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.
+ * @param {Array<ReturnType<typeof JSON.parse>>} args - Arguments after the factory name (and count for lists).
+ * @returns {{traits: string[], overrides: Record<string, ReturnType<typeof JSON.parse>>}} - Normalized invocation.
  */
 function normalizeInvocationArgs(args) {
     /** @type {string[]} */
     const traits = [];
-    /** @type {Record<string, ?>} */
+    /** @type {Record<string, ReturnType<typeof JSON.parse>>} */
     let overrides = {};
     let sawOverrides = false;
     for (const arg of args) {
@@ -98,7 +98,7 @@ export default class FactoryRegistry {
     /**
      * 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.
+     * @param {(payload: {invocationId: string, factory: string, strategy: string, traits: string[], durationMs?: number, error?: ReturnType<typeof JSON.parse>}) => void} handler - Event handler.
      * @returns {this} - This registry (for chaining).
      */
     on(event, handler) {
@@ -108,7 +108,7 @@ export default class FactoryRegistry {
     /**
      * Unsubscribes a previously-registered event handler.
      * @param {string} event - Event name.
-     * @param {(payload: ?) => void} handler - Event handler to remove.
+     * @param {(payload: ReturnType<typeof JSON.parse>) => void} handler - Event handler to remove.
      * @returns {this} - This registry (for chaining).
      */
     off(event, handler) {
@@ -118,8 +118,8 @@ export default class FactoryRegistry {
     /**
      * 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.
+     * @param {Array<ReturnType<typeof JSON.parse>>} args - Trait names then an optional overrides object.
+     * @returns {Promise<Record<string, ReturnType<typeof JSON.parse>>>} - The resolved attributes.
      */
     async attributesFor(factoryName, ...args) {
         const { traits, overrides } = normalizeInvocationArgs(args);
@@ -128,8 +128,8 @@ export default class FactoryRegistry {
     /**
      * 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.
+     * @param {Array<ReturnType<typeof JSON.parse>>} args - Trait names then an optional overrides object.
+     * @returns {Promise<ReturnType<typeof JSON.parse>>} - The built record.
      */
     async build(factoryName, ...args) {
         const { traits, overrides } = normalizeInvocationArgs(args);
@@ -138,8 +138,8 @@ export default class FactoryRegistry {
     /**
      * 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.
+     * @param {Array<ReturnType<typeof JSON.parse>>} args - Trait names then an optional overrides object.
+     * @returns {Promise<ReturnType<typeof JSON.parse>>} - The persisted record.
      */
     async create(factoryName, ...args) {
         const { traits, overrides } = normalizeInvocationArgs(args);
@@ -149,8 +149,8 @@ export default class FactoryRegistry {
      * 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.
+     * @param {Array<ReturnType<typeof JSON.parse>>} args - Trait names then an optional overrides object.
+     * @returns {Promise<Array<Record<string, ReturnType<typeof JSON.parse>>>>} - The resolved attribute objects.
      */
     async attributesForList(factoryName, count, ...args) {
         return await this._runList("attributesFor", factoryName, count, args);
@@ -159,8 +159,8 @@ export default class FactoryRegistry {
      * 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.
+     * @param {Array<ReturnType<typeof JSON.parse>>} args - Trait names then an optional overrides object.
+     * @returns {Promise<Array<ReturnType<typeof JSON.parse>>>} - The built records.
      */
     async buildList(factoryName, count, ...args) {
         return await this._runList("build", factoryName, count, args);
@@ -169,8 +169,8 @@ export default class FactoryRegistry {
      * 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.
+     * @param {Array<ReturnType<typeof JSON.parse>>} args - Trait names then an optional overrides object.
+     * @returns {Promise<Array<ReturnType<typeof JSON.parse>>>} - The persisted records.
      */
     async createList(factoryName, count, ...args) {
         return await this._runList("create", factoryName, count, args);
@@ -178,8 +178,8 @@ export default class FactoryRegistry {
     /**
      * 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.
+     * @param {Array<ReturnType<typeof JSON.parse>>} args - Trait names then an optional overrides object.
+     * @returns {Promise<Array<Record<string, ReturnType<typeof JSON.parse>>>>} - The two resolved attribute objects.
      */
     async attributesForPair(factoryName, ...args) {
         return await this._runList("attributesFor", factoryName, 2, args);
@@ -187,8 +187,8 @@ export default class FactoryRegistry {
     /**
      * 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.
+     * @param {Array<ReturnType<typeof JSON.parse>>} args - Trait names then an optional overrides object.
+     * @returns {Promise<Array<ReturnType<typeof JSON.parse>>>} - The two built records.
      */
     async buildPair(factoryName, ...args) {
         return await this._runList("build", factoryName, 2, args);
@@ -196,8 +196,8 @@ export default class FactoryRegistry {
     /**
      * 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.
+     * @param {Array<ReturnType<typeof JSON.parse>>} args - Trait names then an optional overrides object.
+     * @returns {Promise<Array<ReturnType<typeof JSON.parse>>>} - The two persisted records.
      */
     async createPair(factoryName, ...args) {
         return await this._runList("create", factoryName, 2, args);
@@ -205,7 +205,7 @@ export default class FactoryRegistry {
     /**
      * Advances a sequence and returns its formatted value.
      * @param {string} sequenceName - Sequence name.
-     * @returns {Promise<?>} - The formatted value.
+     * @returns {Promise<ReturnType<typeof JSON.parse>>} - The formatted value.
      */
     async generate(sequenceName) {
         return await this._generateScoped(sequenceName, []);
@@ -214,10 +214,10 @@ export default class FactoryRegistry {
      * 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.
+     * @returns {Promise<Array<ReturnType<typeof JSON.parse>>>} - The formatted values.
      */
     async generateList(sequenceName, count) {
-        /** @type {Array<?>} */
+        /** @type {Array<ReturnType<typeof JSON.parse>>} */
         const values = [];
         for (let index = 0; index < count; index++) {
             values.push(await this._generateScoped(sequenceName, []));
@@ -284,12 +284,12 @@ export default class FactoryRegistry {
      * @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.
+     * @param {Array<ReturnType<typeof JSON.parse>>} args - Trait names then an optional overrides object.
+     * @returns {Promise<Array<ReturnType<typeof JSON.parse>>>} - The results.
      */
     async _runList(strategy, factoryName, count, args) {
         const { traits, overrides } = normalizeInvocationArgs(args);
-        /** @type {Array<?>} */
+        /** @type {Array<ReturnType<typeof JSON.parse>>} */
         const results = [];
         /** @type {import("./factory-runner.js").CompiledPlan | undefined} */
         let planTemplate;
@@ -311,9 +311,9 @@ export default class FactoryRegistry {
      * @param {object} args - Options.
      * @param {string} args.factoryName - Factory name.
      * @param {string[]} args.traits - Ordered traits.
-     * @param {Record<string, ?>} args.overrides - Overrides.
+     * @param {Record<string, ReturnType<typeof JSON.parse>>} args.overrides - Overrides.
      * @param {"attributesFor" | "build" | "create"} args.strategy - Strategy name.
-     * @returns {Promise<?>} - The strategy result.
+     * @returns {Promise<ReturnType<typeof JSON.parse>>} - The strategy result.
      */
     async _runFactory(args) {
         return (await this._runFactoryInvocation(args)).result;
@@ -323,10 +323,10 @@ export default class FactoryRegistry {
      * @param {object} args - Options.
      * @param {string} args.factoryName - Factory name.
      * @param {string[]} args.traits - Ordered traits.
-     * @param {Record<string, ?>} args.overrides - Overrides.
+     * @param {Record<string, ReturnType<typeof JSON.parse>>} args.overrides - Overrides.
      * @param {"attributesFor" | "build" | "create"} args.strategy - Strategy name.
      * @param {import("./factory-runner.js").CompiledPlan} [args.planTemplate] - Reusable declaration plan.
-     * @returns {Promise<{result: ?, planTemplate: import("./factory-runner.js").CompiledPlan}>} - Result and declaration plan.
+     * @returns {Promise<{result: ReturnType<typeof JSON.parse>, planTemplate: import("./factory-runner.js").CompiledPlan}>} - Result and declaration plan.
      */
     async _runFactoryInvocation({ factoryName, traits, overrides, strategy, planTemplate }) {
         this._activeEvaluations += 1;
@@ -424,7 +424,7 @@ export default class FactoryRegistry {
      * global scope and advances it.
      * @param {string} sequenceName - Sequence name.
      * @param {string[]} chainNames - Inheritance chain names (child last).
-     * @returns {Promise<?>} - The formatted value.
+     * @returns {Promise<ReturnType<typeof JSON.parse>>} - The formatted value.
      */
     async _generateScoped(sequenceName, chainNames) {
         for (let index = chainNames.length - 1; index >= 0; index--) {
@@ -458,4 +458,4 @@ export default class FactoryRegistry {
         }
     }
 }
-//# 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    /** @type {import(\"./factory-runner.js\").CompiledPlan | undefined} */\n    let planTemplate\n\n    this._activeEvaluations += 1\n\n    try {\n      for (let index = 0; index < count; index++) {\n        const invocation = await this._runFactoryInvocation({factoryName, traits, overrides, strategy, planTemplate})\n\n        planTemplate = invocation.planTemplate\n        results.push(invocation.result)\n      }\n    } finally {\n      this._activeEvaluations -= 1\n    }\n\n    return results\n  }\n\n  /**\n   * Compiles and runs a factory invocation under a strategy.\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(args) {\n    return (await this._runFactoryInvocation(args)).result\n  }\n\n  /**\n   * Runs one event-tracked invocation, optionally reusing declaration planning.\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   * @param {import(\"./factory-runner.js\").CompiledPlan} [args.planTemplate] - Reusable declaration plan.\n   * @returns {Promise<{result: ?, planTemplate: import(\"./factory-runner.js\").CompiledPlan}>} - Result and declaration plan.\n   */\n  async _runFactoryInvocation({factoryName, traits, overrides, strategy, planTemplate}) {\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 compiledPlanTemplate = planTemplate || this._runner.compileTemplate(factoryName, traits)\n      const compiledPlan = this._runner.applyOverrides(compiledPlanTemplate, overrides)\n      const result = await this._strategies[strategy].run({registry: this, plan: compiledPlan})\n\n      this._events.emit(\"success\", {invocationId, factory: factoryName, strategy, traits, durationMs: Date.now() - startedAt})\n\n      return {result, planTemplate: compiledPlanTemplate}\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"]}
+//# 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<ReturnType<typeof JSON.parse>>} args - Arguments after the factory name (and count for lists).\n * @returns {{traits: string[], overrides: Record<string, ReturnType<typeof JSON.parse>>}} - Normalized invocation.\n */\nfunction normalizeInvocationArgs(args) {\n  /** @type {string[]} */\n  const traits = []\n  /** @type {Record<string, ReturnType<typeof JSON.parse>>} */\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?: ReturnType<typeof JSON.parse>}) => 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: ReturnType<typeof JSON.parse>) => 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<ReturnType<typeof JSON.parse>>} args - Trait names then an optional overrides object.\n   * @returns {Promise<Record<string, ReturnType<typeof JSON.parse>>>} - 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<ReturnType<typeof JSON.parse>>} args - Trait names then an optional overrides object.\n   * @returns {Promise<ReturnType<typeof JSON.parse>>} - 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<ReturnType<typeof JSON.parse>>} args - Trait names then an optional overrides object.\n   * @returns {Promise<ReturnType<typeof JSON.parse>>} - 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<ReturnType<typeof JSON.parse>>} args - Trait names then an optional overrides object.\n   * @returns {Promise<Array<Record<string, ReturnType<typeof JSON.parse>>>>} - 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<ReturnType<typeof JSON.parse>>} args - Trait names then an optional overrides object.\n   * @returns {Promise<Array<ReturnType<typeof JSON.parse>>>} - 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<ReturnType<typeof JSON.parse>>} args - Trait names then an optional overrides object.\n   * @returns {Promise<Array<ReturnType<typeof JSON.parse>>>} - 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<ReturnType<typeof JSON.parse>>} args - Trait names then an optional overrides object.\n   * @returns {Promise<Array<Record<string, ReturnType<typeof JSON.parse>>>>} - 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<ReturnType<typeof JSON.parse>>} args - Trait names then an optional overrides object.\n   * @returns {Promise<Array<ReturnType<typeof JSON.parse>>>} - 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<ReturnType<typeof JSON.parse>>} args - Trait names then an optional overrides object.\n   * @returns {Promise<Array<ReturnType<typeof JSON.parse>>>} - 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<ReturnType<typeof JSON.parse>>} - 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<ReturnType<typeof JSON.parse>>>} - The formatted values.\n   */\n  async generateList(sequenceName, count) {\n    /** @type {Array<ReturnType<typeof JSON.parse>>} */\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<ReturnType<typeof JSON.parse>>} args - Trait names then an optional overrides object.\n   * @returns {Promise<Array<ReturnType<typeof JSON.parse>>>} - The results.\n   */\n  async _runList(strategy, factoryName, count, args) {\n    const {traits, overrides} = normalizeInvocationArgs(args)\n    /** @type {Array<ReturnType<typeof JSON.parse>>} */\n    const results = []\n    /** @type {import(\"./factory-runner.js\").CompiledPlan | undefined} */\n    let planTemplate\n\n    this._activeEvaluations += 1\n\n    try {\n      for (let index = 0; index < count; index++) {\n        const invocation = await this._runFactoryInvocation({factoryName, traits, overrides, strategy, planTemplate})\n\n        planTemplate = invocation.planTemplate\n        results.push(invocation.result)\n      }\n    } finally {\n      this._activeEvaluations -= 1\n    }\n\n    return results\n  }\n\n  /**\n   * Compiles and runs a factory invocation under a strategy.\n   * @param {object} args - Options.\n   * @param {string} args.factoryName - Factory name.\n   * @param {string[]} args.traits - Ordered traits.\n   * @param {Record<string, ReturnType<typeof JSON.parse>>} args.overrides - Overrides.\n   * @param {\"attributesFor\" | \"build\" | \"create\"} args.strategy - Strategy name.\n   * @returns {Promise<ReturnType<typeof JSON.parse>>} - The strategy result.\n   */\n  async _runFactory(args) {\n    return (await this._runFactoryInvocation(args)).result\n  }\n\n  /**\n   * Runs one event-tracked invocation, optionally reusing declaration planning.\n   * @param {object} args - Options.\n   * @param {string} args.factoryName - Factory name.\n   * @param {string[]} args.traits - Ordered traits.\n   * @param {Record<string, ReturnType<typeof JSON.parse>>} args.overrides - Overrides.\n   * @param {\"attributesFor\" | \"build\" | \"create\"} args.strategy - Strategy name.\n   * @param {import(\"./factory-runner.js\").CompiledPlan} [args.planTemplate] - Reusable declaration plan.\n   * @returns {Promise<{result: ReturnType<typeof JSON.parse>, planTemplate: import(\"./factory-runner.js\").CompiledPlan}>} - Result and declaration plan.\n   */\n  async _runFactoryInvocation({factoryName, traits, overrides, strategy, planTemplate}) {\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 compiledPlanTemplate = planTemplate || this._runner.compileTemplate(factoryName, traits)\n      const compiledPlan = this._runner.applyOverrides(compiledPlanTemplate, overrides)\n      const result = await this._strategies[strategy].run({registry: this, plan: compiledPlan})\n\n      this._events.emit(\"success\", {invocationId, factory: factoryName, strategy, traits, durationMs: Date.now() - startedAt})\n\n      return {result, planTemplate: compiledPlanTemplate}\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<ReturnType<typeof JSON.parse>>} - 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"]}

package/build/src/testing/factory/factory-runner.d.ts

@@ -1,8 +1,60 @@
+export type Slot = {
+    /**
+     * - Slot nature.
+     */
+    slotKind: "attribute" | "transient" | "association";
+    /**
+     * - Literal/lazy value, override value, or AssociationDeclaration.
+     */
+    value: ReturnType<typeof JSON.parse>;
+    /**
+     * - Whether the value came from a call-site override.
+     */
+    isOverride: boolean;
+};
+export type CompiledPlan = {
+    /**
+     * - Target factory name.
+     */
+    factoryName: string;
+    /**
+     * - Target definition.
+     */
+    factoryDefinition: import("./factory-definition.js").default;
+    /**
+     * - Resolved model class.
+     */
+    modelClass: (new (attributes?: Record<string, ReturnType<typeof JSON.parse>>) => ReturnType<typeof JSON.parse>) | null;
+    /**
+     * - Inheritance chain names (child last) for sequence scope.
+     */
+    chainNames: string[];
+    /**
+     * - Name→slot map (last declaration wins).
+     */
+    resolved: Map<string, Slot>;
+    /**
+     * - Deduped callbacks by event.
+     */
+    callbacks: Map<string, import("./declarations.js").CallbackDeclaration[]>;
+    /**
+     * - Custom constructor, or null.
+     */
+    initializeWith: import("./declarations.js").InitializeWithDeclaration["fn"] | null;
+    /**
+     * - Custom persistence, or null.
+     */
+    toCreate: import("./declarations.js").ToCreateDeclaration["fn"] | null;
+    /**
+     * - Whether persistence is skipped.
+     */
+    skipCreate: boolean;
+};
 /**
  * A resolved attribute/transient/association slot in a compiled plan.
  * @typedef {object} Slot
  * @property {"attribute" | "transient" | "association"} slotKind - Slot nature.
- * @property {?} value - Literal/lazy value, override value, or AssociationDeclaration.
+ * @property {ReturnType<typeof JSON.parse>} value - Literal/lazy value, override value, or AssociationDeclaration.
  * @property {boolean} isOverride - Whether the value came from a call-site override.
  */
 /**
@@ -10,7 +62,7 @@
  * @typedef {object} CompiledPlan
  * @property {string} factoryName - Target factory name.
  * @property {import("./factory-definition.js").default} factoryDefinition - Target definition.
- * @property {(new (attributes?: Record<string, ?>) => ?) | null} modelClass - Resolved model class.
+ * @property {(new (attributes?: Record<string, ReturnType<typeof JSON.parse>>) => ReturnType<typeof JSON.parse>) | null} modelClass - Resolved model class.
  * @property {string[]} chainNames - Inheritance chain names (child last) for sequence scope.
  * @property {Map<string, Slot>} resolved - Name→slot map (last declaration wins).
  * @property {Map<string, import("./declarations.js").CallbackDeclaration[]>} callbacks - Deduped callbacks by event.
@@ -24,21 +76,21 @@
  * name→slot map plus a deduped, ordered callback set.
  */
 export default class FactoryRunner {
+    /** @type {import("./factory-registry.js").default} - Owning registry. */
+    registry: import("./factory-registry.js").default;
     /**
      * Builds a runner.
      * @param {import("./factory-registry.js").default} registry - Owning registry.
      */
     constructor(registry: import("./factory-registry.js").default);
-    /** @type {import("./factory-registry.js").default} - Owning registry. */
-    registry: import("./factory-registry.js").default;
     /**
      * Compiles a factory invocation into a plan.
      * @param {string} factoryName - Factory to run.
      * @param {string[]} requestedTraits - Traits requested at the call site, in order.
-     * @param {Record<string, ?>} overrides - Call-site overrides (highest precedence).
+     * @param {Record<string, ReturnType<typeof JSON.parse>>} overrides - Call-site overrides (highest precedence).
      * @returns {CompiledPlan} - The compiled plan.
      */
-    compile(factoryName: string, requestedTraits: string[], overrides: Record<string, unknown>): CompiledPlan;
+    compile(factoryName: string, requestedTraits: string[], overrides: Record<string, ReturnType<typeof JSON.parse>>): CompiledPlan;
     /**
      * Compiles inheritance, traits and declarations without call-site overrides.
      * @param {string} factoryName - Factory to run.
@@ -49,10 +101,10 @@ export default class FactoryRunner {
     /**
      * Applies the current call-site overrides without mutating the reusable template.
      * @param {CompiledPlan} planTemplate - Reusable declaration plan.
-     * @param {Record<string, ?>} overrides - Current call-site overrides.
+     * @param {Record<string, ReturnType<typeof JSON.parse>>} overrides - Current call-site overrides.
      * @returns {CompiledPlan} - Per-invocation plan.
      */
-    applyOverrides(planTemplate: CompiledPlan, overrides: Record<string, unknown>): CompiledPlan;
+    applyOverrides(planTemplate: CompiledPlan, overrides: Record<string, ReturnType<typeof JSON.parse>>): CompiledPlan;
     /**
      * Resolves the inheritance chain from the root parent down to the target.
      * @param {string} factoryName - Target factory name.
@@ -68,9 +120,9 @@ export default class FactoryRunner {
     /**
      * Picks the nearest declared model class in the chain (child overrides parent).
      * @param {import("./factory-definition.js").default[]} chain - Inheritance chain.
-     * @returns {(new (attributes?: Record<string, ?>) => ?) | null} - The model class, or null.
+     * @returns {(new (attributes?: Record<string, ReturnType<typeof JSON.parse>>) => ReturnType<typeof JSON.parse>) | null} - The model class, or null.
      */
-    _resolveModelClass(chain: import("./factory-definition.js").default[]): (new (attributes?: Record<string, unknown>) => unknown) | null;
+    _resolveModelClass(chain: import("./factory-definition.js").default[]): (new (attributes?: Record<string, ReturnType<typeof JSON.parse>>) => ReturnType<typeof JSON.parse>) | null;
     /**
      * Expands one factory's own declarations, inlining base-trait inclusions.
      * @param {import("./factory-definition.js").default} factoryDefinition - Factory whose declarations are expanded.
@@ -106,7 +158,7 @@ export default class FactoryRunner {
      * Folds flattened declarations into a reusable compiled plan.
      * @param {object} args - Options.
      * @param {Array<{decl: import("./declarations.js").Declaration}>} args.flattened - Flattened declarations.
-     * @param {(new (attributes?: Record<string, ?>) => ?) | null} args.modelClass - Resolved model class.
+     * @param {(new (attributes?: Record<string, ReturnType<typeof JSON.parse>>) => ReturnType<typeof JSON.parse>) | null} args.modelClass - Resolved model class.
      * @param {import("./factory-definition.js").default} args.target - Target factory definition.
      * @param {string[]} args.chainNames - Inheritance chain names.
      * @returns {CompiledPlan} - The compiled plan.
@@ -115,7 +167,7 @@ export default class FactoryRunner {
         flattened: Array<{
             decl: import("./declarations.js").Declaration;
         }>;
-        modelClass: (new (attributes?: Record<string, unknown>) => unknown) | null;
+        modelClass: (new (attributes?: Record<string, ReturnType<typeof JSON.parse>>) => ReturnType<typeof JSON.parse>) | null;
         target: import("./factory-definition.js").default;
         chainNames: string[];
     }): CompiledPlan;
@@ -124,68 +176,10 @@ export default class FactoryRunner {
      * real foreign-key metadata. An explicit association object wins over its key;
      * otherwise an explicit key suppresses the factory-declared association.
      * @param {Map<string, Slot>} resolved - Folded slots.
-     * @param {Record<string, ?>} overrides - Call-site overrides.
-     * @param {(new (attributes?: Record<string, ?>) => ?) | null} modelClass - Resolved model class.
+     * @param {Record<string, ReturnType<typeof JSON.parse>>} overrides - Call-site overrides.
+     * @param {(new (attributes?: Record<string, ReturnType<typeof JSON.parse>>) => ReturnType<typeof JSON.parse>) | null} modelClass - Resolved model class.
      * @returns {void}
      */
-    _arbitrateAssociationOverrides(resolved: Map<string, Slot>, overrides: Record<string, unknown>, modelClass: (new (attributes?: Record<string, unknown>) => unknown) | null): void;
+    _arbitrateAssociationOverrides(resolved: Map<string, Slot>, overrides: Record<string, ReturnType<typeof JSON.parse>>, modelClass: (new (attributes?: Record<string, ReturnType<typeof JSON.parse>>) => ReturnType<typeof JSON.parse>) | null): void;
 }
-/**
- * A resolved attribute/transient/association slot in a compiled plan.
- */
-export type Slot = {
-    /**
-     * - Slot nature.
-     */
-    slotKind: "attribute" | "transient" | "association";
-    /**
-     * - Literal/lazy value, override value, or AssociationDeclaration.
-     */
-    value: unknown;
-    /**
-     * - Whether the value came from a call-site override.
-     */
-    isOverride: boolean;
-};
-/**
- * The immutable result of compiling a factory invocation.
- */
-export type CompiledPlan = {
-    /**
-     * - Target factory name.
-     */
-    factoryName: string;
-    /**
-     * - Target definition.
-     */
-    factoryDefinition: import("./factory-definition.js").default;
-    /**
-     * - Resolved model class.
-     */
-    modelClass: (new (attributes?: Record<string, unknown>) => unknown) | null;
-    /**
-     * - Inheritance chain names (child last) for sequence scope.
-     */
-    chainNames: string[];
-    /**
-     * - Name→slot map (last declaration wins).
-     */
-    resolved: Map<string, Slot>;
-    /**
-     * - Deduped callbacks by event.
-     */
-    callbacks: Map<string, import("./declarations.js").CallbackDeclaration[]>;
-    /**
-     * - Custom constructor, or null.
-     */
-    initializeWith: import("./declarations.js").InitializeWithDeclaration["fn"] | null;
-    /**
-     * - Custom persistence, or null.
-     */
-    toCreate: import("./declarations.js").ToCreateDeclaration["fn"] | null;
-    /**
-     * - Whether persistence is skipped.
-     */
-    skipCreate: boolean;
-};
 //# sourceMappingURL=factory-runner.d.ts.map

package/build/src/testing/factory/factory-runner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"factory-runner.d.ts","sourceRoot":"","sources":["../../../../src/testing/factory/factory-runner.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"factory-runner.d.ts","sourceRoot":"","sources":["../../../../src/testing/factory/factory-runner.js"],"names":[],"mappings":"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"}