velocious 1.0.577 → 1.0.579

package/build/src/testing/factory/strategies/attributes-for.js

@@ -12,11 +12,11 @@ export default class AttributesForStrategy extends BaseStrategy {
      * @param {object} args - Options.
      * @param {import("../factory-registry.js").default} args.registry - Owning registry.
      * @param {import("../factory-runner.js").CompiledPlan} args.plan - Compiled plan.
-     * @returns {Promise<Record<string, ?>>} - The resolved attributes.
+     * @returns {Promise<Record<string, ReturnType<typeof JSON.parse>>>} - The resolved attributes.
      */
     async run({ registry, plan }) {
         const context = this._newContext(registry, plan, "attributesFor");
         return await context.resolveAttributes();
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXR0cmlidXRlcy1mb3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvdGVzdGluZy9mYWN0b3J5L3N0cmF0ZWdpZXMvYXR0cmlidXRlcy1mb3IuanMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsWUFBWTtBQUVaLE9BQU8sWUFBWSxNQUFNLFdBQVcsQ0FBQTtBQUVwQzs7Ozs7R0FLRztBQUNILE1BQU0sQ0FBQyxPQUFPLE9BQU8scUJBQXNCLFNBQVEsWUFBWTtJQUM3RDs7Ozs7O09BTUc7SUFDSCxLQUFLLENBQUMsR0FBRyxDQUFDLEVBQUMsUUFBUSxFQUFFLElBQUksRUFBQztRQUN4QixNQUFNLE9BQU8sR0FBRyxJQUFJLENBQUMsV0FBVyxDQUFDLFFBQVEsRUFBRSxJQUFJLEVBQUUsZUFBZSxDQUFDLENBQUE7UUFFakUsT0FBTyxNQUFNLE9BQU8sQ0FBQyxpQkFBaUIsRUFBRSxDQUFBO0lBQzFDLENBQUM7Q0FDRiIsInNvdXJjZXNDb250ZW50IjpbIi8vIEB0cy1jaGVja1xuXG5pbXBvcnQgQmFzZVN0cmF0ZWd5IGZyb20gXCIuL2Jhc2UuanNcIlxuXG4vKipcbiAqIFRoZSBgYXR0cmlidXRlc0ZvcmAgc3RyYXRlZ3kuIEl0IHJlc29sdmVzIHNjYWxhci9sYXp5IGF0dHJpYnV0ZXMgKGFuZCBhbnlcbiAqIHRyYW5zaWVudHMgdGhleSBkZXBlbmQgb24pIGJ1dCBuZXZlciBpbml0aWFsaXplcyB0aGUgbW9kZWwsIHJ1bnMgbGlmZWN5Y2xlXG4gKiBjYWxsYmFja3MsIG9yIGV2YWx1YXRlcy9idWlsZHMgZGVjbGFyZWQgYXNzb2NpYXRpb25zLiBUcmFuc2llbnRzIGFuZFxuICogYXNzb2NpYXRpb25zIGFyZSBvbWl0dGVkIGZyb20gdGhlIHJldHVybmVkIHBsYWluIG9iamVjdC5cbiAqL1xuZXhwb3J0IGRlZmF1bHQgY2xhc3MgQXR0cmlidXRlc0ZvclN0cmF0ZWd5IGV4dGVuZHMgQmFzZVN0cmF0ZWd5IHtcbiAgLyoqXG4gICAqIFJ1bnMgdGhlIHN0cmF0ZWd5LlxuICAgKiBAcGFyYW0ge29iamVjdH0gYXJncyAtIE9wdGlvbnMuXG4gICAqIEBwYXJhbSB7aW1wb3J0KFwiLi4vZmFjdG9yeS1yZWdpc3RyeS5qc1wiKS5kZWZhdWx0fSBhcmdzLnJlZ2lzdHJ5IC0gT3duaW5nIHJlZ2lzdHJ5LlxuICAgKiBAcGFyYW0ge2ltcG9ydChcIi4uL2ZhY3RvcnktcnVubmVyLmpzXCIpLkNvbXBpbGVkUGxhbn0gYXJncy5wbGFuIC0gQ29tcGlsZWQgcGxhbi5cbiAgICogQHJldHVybnMge1Byb21pc2U8UmVjb3JkPHN0cmluZywgPz4+fSAtIFRoZSByZXNvbHZlZCBhdHRyaWJ1dGVzLlxuICAgKi9cbiAgYXN5bmMgcnVuKHtyZWdpc3RyeSwgcGxhbn0pIHtcbiAgICBjb25zdCBjb250ZXh0ID0gdGhpcy5fbmV3Q29udGV4dChyZWdpc3RyeSwgcGxhbiwgXCJhdHRyaWJ1dGVzRm9yXCIpXG5cbiAgICByZXR1cm4gYXdhaXQgY29udGV4dC5yZXNvbHZlQXR0cmlidXRlcygpXG4gIH1cbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXR0cmlidXRlcy1mb3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvdGVzdGluZy9mYWN0b3J5L3N0cmF0ZWdpZXMvYXR0cmlidXRlcy1mb3IuanMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsWUFBWTtBQUVaLE9BQU8sWUFBWSxNQUFNLFdBQVcsQ0FBQTtBQUVwQzs7Ozs7R0FLRztBQUNILE1BQU0sQ0FBQyxPQUFPLE9BQU8scUJBQXNCLFNBQVEsWUFBWTtJQUM3RDs7Ozs7O09BTUc7SUFDSCxLQUFLLENBQUMsR0FBRyxDQUFDLEVBQUMsUUFBUSxFQUFFLElBQUksRUFBQztRQUN4QixNQUFNLE9BQU8sR0FBRyxJQUFJLENBQUMsV0FBVyxDQUFDLFFBQVEsRUFBRSxJQUFJLEVBQUUsZUFBZSxDQUFDLENBQUE7UUFFakUsT0FBTyxNQUFNLE9BQU8sQ0FBQyxpQkFBaUIsRUFBRSxDQUFBO0lBQzFDLENBQUM7Q0FDRiIsInNvdXJjZXNDb250ZW50IjpbIi8vIEB0cy1jaGVja1xuXG5pbXBvcnQgQmFzZVN0cmF0ZWd5IGZyb20gXCIuL2Jhc2UuanNcIlxuXG4vKipcbiAqIFRoZSBgYXR0cmlidXRlc0ZvcmAgc3RyYXRlZ3kuIEl0IHJlc29sdmVzIHNjYWxhci9sYXp5IGF0dHJpYnV0ZXMgKGFuZCBhbnlcbiAqIHRyYW5zaWVudHMgdGhleSBkZXBlbmQgb24pIGJ1dCBuZXZlciBpbml0aWFsaXplcyB0aGUgbW9kZWwsIHJ1bnMgbGlmZWN5Y2xlXG4gKiBjYWxsYmFja3MsIG9yIGV2YWx1YXRlcy9idWlsZHMgZGVjbGFyZWQgYXNzb2NpYXRpb25zLiBUcmFuc2llbnRzIGFuZFxuICogYXNzb2NpYXRpb25zIGFyZSBvbWl0dGVkIGZyb20gdGhlIHJldHVybmVkIHBsYWluIG9iamVjdC5cbiAqL1xuZXhwb3J0IGRlZmF1bHQgY2xhc3MgQXR0cmlidXRlc0ZvclN0cmF0ZWd5IGV4dGVuZHMgQmFzZVN0cmF0ZWd5IHtcbiAgLyoqXG4gICAqIFJ1bnMgdGhlIHN0cmF0ZWd5LlxuICAgKiBAcGFyYW0ge29iamVjdH0gYXJncyAtIE9wdGlvbnMuXG4gICAqIEBwYXJhbSB7aW1wb3J0KFwiLi4vZmFjdG9yeS1yZWdpc3RyeS5qc1wiKS5kZWZhdWx0fSBhcmdzLnJlZ2lzdHJ5IC0gT3duaW5nIHJlZ2lzdHJ5LlxuICAgKiBAcGFyYW0ge2ltcG9ydChcIi4uL2ZhY3RvcnktcnVubmVyLmpzXCIpLkNvbXBpbGVkUGxhbn0gYXJncy5wbGFuIC0gQ29tcGlsZWQgcGxhbi5cbiAgICogQHJldHVybnMge1Byb21pc2U8UmVjb3JkPHN0cmluZywgUmV0dXJuVHlwZTx0eXBlb2YgSlNPTi5wYXJzZT4+Pn0gLSBUaGUgcmVzb2x2ZWQgYXR0cmlidXRlcy5cbiAgICovXG4gIGFzeW5jIHJ1bih7cmVnaXN0cnksIHBsYW59KSB7XG4gICAgY29uc3QgY29udGV4dCA9IHRoaXMuX25ld0NvbnRleHQocmVnaXN0cnksIHBsYW4sIFwiYXR0cmlidXRlc0ZvclwiKVxuXG4gICAgcmV0dXJuIGF3YWl0IGNvbnRleHQucmVzb2x2ZUF0dHJpYnV0ZXMoKVxuICB9XG59XG4iXX0=

package/build/src/testing/factory/strategies/base.d.ts

@@ -1,3 +1,4 @@
+import EvaluationContext from "../evaluation-context.js";
 /**
  * Shared behaviour for the build/create/attributesFor strategies: evaluation
  * context creation, deterministic callback execution, guaranteed `afterAll`
@@ -17,21 +18,21 @@ export default class BaseStrategy {
      * Builds the callback `context` object: evaluated transients exposed as plain
      * properties (no Proxy) plus the named evaluator methods.
      * @param {EvaluationContext} context - Evaluation context.
-     * @param {Record<string, ?>} transients - Evaluated transient values.
-     * @returns {Record<string, ?>} - The callback context.
+     * @param {Record<string, ReturnType<typeof JSON.parse>>} transients - Evaluated transient values.
+     * @returns {Record<string, ReturnType<typeof JSON.parse>>} - The callback context.
      */
-    _callbackContext(context: EvaluationContext, transients: Record<string, unknown>): Record<string, unknown>;
+    _callbackContext(context: EvaluationContext, transients: Record<string, ReturnType<typeof JSON.parse>>): Record<string, ReturnType<typeof JSON.parse>>;
     /**
      * Runs every deduped callback for an event in declaration order.
      * @param {EvaluationContext} context - Evaluation context.
      * @param {import("../factory-runner.js").CompiledPlan} plan - Compiled plan.
      * @param {string} event - Event name (e.g. "afterCreate").
-     * @param {{record: ?, transients: Record<string, ?>, strategy: string}} state - Current record/transients/strategy.
+     * @param {{record: ReturnType<typeof JSON.parse>, transients: Record<string, ReturnType<typeof JSON.parse>>, strategy: string}} state - Current record/transients/strategy.
      * @returns {Promise<void>} - Resolves when all callbacks complete.
      */
     _runCallbacks(context: EvaluationContext, plan: import("../factory-runner.js").CompiledPlan, event: string, state: {
-        record: unknown;
-        transients: Record<string, unknown>;
+        record: ReturnType<typeof JSON.parse>;
+        transients: Record<string, ReturnType<typeof JSON.parse>>;
         strategy: string;
     }): Promise<void>;
     /**
@@ -40,62 +41,61 @@ export default class BaseStrategy {
      * is attached as a detail rather than masking it.
      * @param {EvaluationContext} context - Evaluation context.
      * @param {import("../factory-runner.js").CompiledPlan} plan - Compiled plan.
-     * @param {() => {record: ?, transients: Record<string, ?>, strategy: string}} state - Late-bound state accessor.
-     * @param {() => Promise<?>} body - The strategy body.
-     * @returns {Promise<?>} - The body's result.
+     * @param {() => {record: ReturnType<typeof JSON.parse>, transients: Record<string, ReturnType<typeof JSON.parse>>, strategy: string}} state - Late-bound state accessor.
+     * @param {() => Promise<ReturnType<typeof JSON.parse>>} body - The strategy body.
+     * @returns {Promise<ReturnType<typeof JSON.parse>>} - The body's result.
      */
     _runWithAfterAll(context: EvaluationContext, plan: import("../factory-runner.js").CompiledPlan, state: () => {
-        record: unknown;
-        transients: Record<string, unknown>;
+        record: ReturnType<typeof JSON.parse>;
+        transients: Record<string, ReturnType<typeof JSON.parse>>;
         strategy: string;
-    }, body: () => Promise<unknown>): Promise<unknown>;
+    }, body: () => Promise<ReturnType<typeof JSON.parse>>): Promise<ReturnType<typeof JSON.parse>>;
     /**
      * Attaches an afterAll cleanup failure to the primary error without masking it.
-     * @param {?} primaryError - The original error that will propagate.
-     * @param {?} cleanupError - The afterAll cleanup failure.
+     * @param {ReturnType<typeof JSON.parse>} primaryError - The original error that will propagate.
+     * @param {ReturnType<typeof JSON.parse>} cleanupError - The afterAll cleanup failure.
      * @returns {void}
      */
-    _attachCleanupFailure(primaryError: unknown, cleanupError: unknown): void;
+    _attachCleanupFailure(primaryError: ReturnType<typeof JSON.parse>, cleanupError: ReturnType<typeof JSON.parse>): void;
     /**
      * Constructs a record from evaluated public attributes, honouring a custom
      * `initializeWith` constructor and never assigning constructor-consumed
      * attributes twice.
      * @param {import("../factory-runner.js").CompiledPlan} plan - Compiled plan.
-     * @param {Record<string, ?>} publicAttributes - Evaluated public attributes.
+     * @param {Record<string, ReturnType<typeof JSON.parse>>} publicAttributes - Evaluated public attributes.
      * @param {EvaluationContext} context - Evaluation context.
-     * @param {Record<string, ?>} transients - Evaluated transients.
-     * @returns {Promise<?>} - The constructed record.
+     * @param {Record<string, ReturnType<typeof JSON.parse>>} transients - Evaluated transients.
+     * @returns {Promise<ReturnType<typeof JSON.parse>>} - The constructed record.
      */
-    _constructRecord(plan: import("../factory-runner.js").CompiledPlan, publicAttributes: Record<string, unknown>, context: EvaluationContext, transients: Record<string, unknown>): Promise<unknown>;
+    _constructRecord(plan: import("../factory-runner.js").CompiledPlan, publicAttributes: Record<string, ReturnType<typeof JSON.parse>>, context: EvaluationContext, transients: Record<string, ReturnType<typeof JSON.parse>>): Promise<ReturnType<typeof JSON.parse>>;
     /**
      * Constructs a record via a custom `initializeWith`, tracking which attributes
      * the constructor consumed through its `get(name)` accessor and assigning only
      * the remaining public attributes afterwards.
      * @param {import("../factory-runner.js").CompiledPlan} plan - Compiled plan.
-     * @param {new (attributes?: Record<string, ?>) => import("../../../database/record/index.js").default} ModelClass - Validated declared model class.
-     * @param {Record<string, ?>} publicAttributes - Evaluated public attributes.
+     * @param {new (attributes?: Record<string, ReturnType<typeof JSON.parse>>) => import("../../../database/record/index.js").default} ModelClass - Validated declared model class.
+     * @param {Record<string, ReturnType<typeof JSON.parse>>} publicAttributes - Evaluated public attributes.
      * @param {EvaluationContext} context - Evaluation context.
-     * @param {Record<string, ?>} transients - Evaluated transients.
-     * @returns {Promise<?>} - The constructed record.
+     * @param {Record<string, ReturnType<typeof JSON.parse>>} transients - Evaluated transients.
+     * @returns {Promise<ReturnType<typeof JSON.parse>>} - The constructed record.
      */
-    _constructWithInitializer(plan: import("../factory-runner.js").CompiledPlan, ModelClass: new (attributes?: Record<string, unknown>) => import("../../../database/record/index.js").default, publicAttributes: Record<string, unknown>, context: EvaluationContext, transients: Record<string, unknown>): Promise<unknown>;
+    _constructWithInitializer(plan: import("../factory-runner.js").CompiledPlan, ModelClass: new (attributes?: Record<string, ReturnType<typeof JSON.parse>>) => import("../../../database/record/index.js").default, publicAttributes: Record<string, ReturnType<typeof JSON.parse>>, context: EvaluationContext, transients: Record<string, ReturnType<typeof JSON.parse>>): Promise<ReturnType<typeof JSON.parse>>;
     /**
      * Wires evaluated associations onto a record through public relationship
      * reflection and generated setters (never private caches or guessed keys).
-     * @param {?} record - The owning record.
-     * @param {Array<{name: string, record: ?}>} associations - Evaluated associations.
+     * @param {ReturnType<typeof JSON.parse>} record - The owning record.
+     * @param {Array<{name: string, record: ReturnType<typeof JSON.parse>}>} associations - Evaluated associations.
      * @returns {void}
      */
-    _assignAssociations(record: unknown, associations: Array<{
+    _assignAssociations(record: ReturnType<typeof JSON.parse>, associations: Array<{
         name: string;
-        record: unknown;
+        record: ReturnType<typeof JSON.parse>;
     }>): void;
     /**
      * Normalizes a has-many association value into an array of records.
-     * @param {?} value - Association value (record, array, or null).
-     * @returns {Array<?>} - The normalized record array.
+     * @param {ReturnType<typeof JSON.parse>} value - Association value (record, array, or null).
+     * @returns {Array<ReturnType<typeof JSON.parse>>} - The normalized record array.
      */
-    _toRecordArray(value: unknown): Array<unknown>;
+    _toRecordArray(value: ReturnType<typeof JSON.parse>): Array<ReturnType<typeof JSON.parse>>;
 }
-import EvaluationContext from "../evaluation-context.js";
 //# sourceMappingURL=base.d.ts.map

package/build/src/testing/factory/strategies/base.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../../../../src/testing/factory/strategies/base.js"],"names":[],"mappings":"AAOA;;;;;GAKG;AACH;IACE;;;;;;OAMG;IACH,sBALW,OAAO,wBAAwB,EAAE,OAAO,QACxC,OAAO,sBAAsB,EAAE,YAAY,gBAC3C,eAAe,GAAG,OAAO,GAAG,QAAQ,GAClC,iBAAiB,CAI7B;IAED;;;;;;OAMG;IACH,0BAJW,iBAAiB,cACjB,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,GACf,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,CAI7B;IAED;;;;;;;OAOG;IACH,uBANW,iBAAiB,QACjB,OAAO,sBAAsB,EAAE,YAAY,SAC3C,MAAM,SACN;QAAC,MAAM,EAAE,OAAC,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAC,GAC1D,OAAO,CAAC,IAAI,CAAC,CAYzB;IAED;;;;;;;;;OASG;IACH,0BANW,iBAAiB,QACjB,OAAO,sBAAsB,EAAE,YAAY,SAC3C,MAAM;QAAC,MAAM,EAAE,OAAC,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAC,QAClE,MAAM,OAAO,CAAC,OAAC,CAAC,GACd,OAAO,CAAC,OAAC,CAAC,CAoCtB;IAED;;;;;OAKG;IACH,oCAJW,OAAC,gBACD,OAAC,GACC,IAAI,CAOhB;IAED;;;;;;;;;OASG;IACH,uBANW,OAAO,sBAAsB,EAAE,YAAY,oBAC3C,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,WACjB,iBAAiB,cACjB,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,GACf,OAAO,CAAC,OAAC,CAAC,CAUtB;IAED;;;;;;;;;;OAUG;IACH,gCAPW,OAAO,sBAAsB,EAAE,YAAY,cAC3C,KAAK,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,KAAK,OAAO,mCAAmC,EAAE,OAAO,oBAC3F,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,WACjB,iBAAiB,cACjB,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,GACf,OAAO,CAAC,OAAC,CAAC,CA6BtB;IAED;;;;;;OAMG;IACH,4BAJW,OAAC,gBACD,KAAK,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,OAAC,CAAA;KAAC,CAAC,GAC9B,IAAI,CAehB;IAED;;;;OAIG;IACH,sBAHW,OAAC,GACC,KAAK,CAAC,OAAC,CAAC,CAOpB;CACF;8BA3M6B,0BAA0B"}
+{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../../../../src/testing/factory/strategies/base.js"],"names":[],"mappings":"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"}

package/build/src/testing/factory/strategies/base.js

@@ -24,8 +24,8 @@ export default class BaseStrategy {
      * Builds the callback `context` object: evaluated transients exposed as plain
      * properties (no Proxy) plus the named evaluator methods.
      * @param {EvaluationContext} context - Evaluation context.
-     * @param {Record<string, ?>} transients - Evaluated transient values.
-     * @returns {Record<string, ?>} - The callback context.
+     * @param {Record<string, ReturnType<typeof JSON.parse>>} transients - Evaluated transient values.
+     * @returns {Record<string, ReturnType<typeof JSON.parse>>} - The callback context.
      */
     _callbackContext(context, transients) {
         return Object.assign({}, transients, context.contextFor([]));
@@ -35,7 +35,7 @@ export default class BaseStrategy {
      * @param {EvaluationContext} context - Evaluation context.
      * @param {import("../factory-runner.js").CompiledPlan} plan - Compiled plan.
      * @param {string} event - Event name (e.g. "afterCreate").
-     * @param {{record: ?, transients: Record<string, ?>, strategy: string}} state - Current record/transients/strategy.
+     * @param {{record: ReturnType<typeof JSON.parse>, transients: Record<string, ReturnType<typeof JSON.parse>>, strategy: string}} state - Current record/transients/strategy.
      * @returns {Promise<void>} - Resolves when all callbacks complete.
      */
     async _runCallbacks(context, plan, event, state) {
@@ -53,14 +53,14 @@ export default class BaseStrategy {
      * is attached as a detail rather than masking it.
      * @param {EvaluationContext} context - Evaluation context.
      * @param {import("../factory-runner.js").CompiledPlan} plan - Compiled plan.
-     * @param {() => {record: ?, transients: Record<string, ?>, strategy: string}} state - Late-bound state accessor.
-     * @param {() => Promise<?>} body - The strategy body.
-     * @returns {Promise<?>} - The body's result.
+     * @param {() => {record: ReturnType<typeof JSON.parse>, transients: Record<string, ReturnType<typeof JSON.parse>>, strategy: string}} state - Late-bound state accessor.
+     * @param {() => Promise<ReturnType<typeof JSON.parse>>} body - The strategy body.
+     * @returns {Promise<ReturnType<typeof JSON.parse>>} - The body's result.
      */
     async _runWithAfterAll(context, plan, state, body) {
-        /** @type {?} */
+        /** @type {ReturnType<typeof JSON.parse>} */
         let result;
-        /** @type {?} */
+        /** @type {ReturnType<typeof JSON.parse>} */
         let primaryError;
         let hasPrimaryError = false;
         try {
@@ -70,7 +70,7 @@ export default class BaseStrategy {
             primaryError = error;
             hasPrimaryError = true;
         }
-        /** @type {?} */
+        /** @type {ReturnType<typeof JSON.parse>} */
         let cleanupError;
         let hasCleanupError = false;
         try {
@@ -91,8 +91,8 @@ export default class BaseStrategy {
     }
     /**
      * Attaches an afterAll cleanup failure to the primary error without masking it.
-     * @param {?} primaryError - The original error that will propagate.
-     * @param {?} cleanupError - The afterAll cleanup failure.
+     * @param {ReturnType<typeof JSON.parse>} primaryError - The original error that will propagate.
+     * @param {ReturnType<typeof JSON.parse>} cleanupError - The afterAll cleanup failure.
      * @returns {void}
      */
     _attachCleanupFailure(primaryError, cleanupError) {
@@ -107,10 +107,10 @@ export default class BaseStrategy {
      * `initializeWith` constructor and never assigning constructor-consumed
      * attributes twice.
      * @param {import("../factory-runner.js").CompiledPlan} plan - Compiled plan.
-     * @param {Record<string, ?>} publicAttributes - Evaluated public attributes.
+     * @param {Record<string, ReturnType<typeof JSON.parse>>} publicAttributes - Evaluated public attributes.
      * @param {EvaluationContext} context - Evaluation context.
-     * @param {Record<string, ?>} transients - Evaluated transients.
-     * @returns {Promise<?>} - The constructed record.
+     * @param {Record<string, ReturnType<typeof JSON.parse>>} transients - Evaluated transients.
+     * @returns {Promise<ReturnType<typeof JSON.parse>>} - The constructed record.
      */
     async _constructRecord(plan, publicAttributes, context, transients) {
         const ModelClass = assertModelClass(plan.modelClass, plan.factoryName);
@@ -124,11 +124,11 @@ export default class BaseStrategy {
      * the constructor consumed through its `get(name)` accessor and assigning only
      * the remaining public attributes afterwards.
      * @param {import("../factory-runner.js").CompiledPlan} plan - Compiled plan.
-     * @param {new (attributes?: Record<string, ?>) => import("../../../database/record/index.js").default} ModelClass - Validated declared model class.
-     * @param {Record<string, ?>} publicAttributes - Evaluated public attributes.
+     * @param {new (attributes?: Record<string, ReturnType<typeof JSON.parse>>) => import("../../../database/record/index.js").default} ModelClass - Validated declared model class.
+     * @param {Record<string, ReturnType<typeof JSON.parse>>} publicAttributes - Evaluated public attributes.
      * @param {EvaluationContext} context - Evaluation context.
-     * @param {Record<string, ?>} transients - Evaluated transients.
-     * @returns {Promise<?>} - The constructed record.
+     * @param {Record<string, ReturnType<typeof JSON.parse>>} transients - Evaluated transients.
+     * @returns {Promise<ReturnType<typeof JSON.parse>>} - The constructed record.
      */
     async _constructWithInitializer(plan, ModelClass, publicAttributes, context, transients) {
         /** @type {Set<string>} */
@@ -142,22 +142,22 @@ export default class BaseStrategy {
         if (!(record instanceof ModelClass)) {
             throw new ModelContractError(`Factory "${plan.factoryName}" initializeWith must return an instance of ${ModelClass.name}, got: ${String(record)}`);
         }
-        /** @type {Record<string, ?>} */
+        /** @type {Record<string, ReturnType<typeof JSON.parse>>} */
         const remaining = {};
         for (const key of Object.keys(publicAttributes)) {
             if (!consumed.has(key))
                 remaining[key] = publicAttributes[key];
         }
         if (Object.keys(remaining).length > 0) {
-            /** @type {?} */ (record).assign(remaining);
+            /** @type {ReturnType<typeof JSON.parse>} */ (record).assign(remaining);
         }
         return record;
     }
     /**
      * Wires evaluated associations onto a record through public relationship
      * reflection and generated setters (never private caches or guessed keys).
-     * @param {?} record - The owning record.
-     * @param {Array<{name: string, record: ?}>} associations - Evaluated associations.
+     * @param {ReturnType<typeof JSON.parse>} record - The owning record.
+     * @param {Array<{name: string, record: ReturnType<typeof JSON.parse>}>} associations - Evaluated associations.
      * @returns {void}
      */
     _assignAssociations(record, associations) {
@@ -177,8 +177,8 @@ export default class BaseStrategy {
     }
     /**
      * Normalizes a has-many association value into an array of records.
-     * @param {?} value - Association value (record, array, or null).
-     * @returns {Array<?>} - The normalized record array.
+     * @param {ReturnType<typeof JSON.parse>} value - Association value (record, array, or null).
+     * @returns {Array<ReturnType<typeof JSON.parse>>} - The normalized record array.
      */
     _toRecordArray(value) {
         if (value == null)
@@ -188,4 +188,4 @@ export default class BaseStrategy {
         return [value];
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base.js","sourceRoot":"","sources":["../../../../../src/testing/factory/strategies/base.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport * as inflection from \"inflection\"\nimport {assertModelClass} from \"../model-contract.js\"\nimport {ModelContractError} from \"../errors.js\"\nimport EvaluationContext from \"../evaluation-context.js\"\n\n/**\n * Shared behaviour for the build/create/attributesFor strategies: evaluation\n * context creation, deterministic callback execution, guaranteed `afterAll`\n * cleanup, record construction (default and `initializeWith`), and association\n * wiring through public relationship reflection.\n */\nexport default class BaseStrategy {\n  /**\n   * Creates an evaluation context for a plan.\n   * @param {import(\"../factory-registry.js\").default} registry - Owning registry.\n   * @param {import(\"../factory-runner.js\").CompiledPlan} plan - Compiled plan.\n   * @param {\"attributesFor\" | \"build\" | \"create\"} strategyName - Strategy name.\n   * @returns {EvaluationContext} - The context.\n   */\n  _newContext(registry, plan, strategyName) {\n    return new EvaluationContext({registry, plan, strategy: strategyName})\n  }\n\n  /**\n   * Builds the callback `context` object: evaluated transients exposed as plain\n   * properties (no Proxy) plus the named evaluator methods.\n   * @param {EvaluationContext} context - Evaluation context.\n   * @param {Record<string, ?>} transients - Evaluated transient values.\n   * @returns {Record<string, ?>} - The callback context.\n   */\n  _callbackContext(context, transients) {\n    return Object.assign({}, transients, context.contextFor([]))\n  }\n\n  /**\n   * Runs every deduped callback for an event in declaration order.\n   * @param {EvaluationContext} context - Evaluation context.\n   * @param {import(\"../factory-runner.js\").CompiledPlan} plan - Compiled plan.\n   * @param {string} event - Event name (e.g. \"afterCreate\").\n   * @param {{record: ?, transients: Record<string, ?>, strategy: string}} state - Current record/transients/strategy.\n   * @returns {Promise<void>} - Resolves when all callbacks complete.\n   */\n  async _runCallbacks(context, plan, event, state) {\n    const callbacks = plan.callbacks.get(event)\n\n    if (!callbacks) return\n\n    const callbackContext = this._callbackContext(context, state.transients)\n\n    for (const callback of callbacks) {\n      await callback.fn({record: state.record, context: callbackContext, strategy: state.strategy})\n    }\n  }\n\n  /**\n   * Runs `body`, then guarantees `afterAll` runs in `finally`. When both the body\n   * and cleanup fail, the body's primary error is preserved and the cleanup error\n   * is attached as a detail rather than masking it.\n   * @param {EvaluationContext} context - Evaluation context.\n   * @param {import(\"../factory-runner.js\").CompiledPlan} plan - Compiled plan.\n   * @param {() => {record: ?, transients: Record<string, ?>, strategy: string}} state - Late-bound state accessor.\n   * @param {() => Promise<?>} body - The strategy body.\n   * @returns {Promise<?>} - The body's result.\n   */\n  async _runWithAfterAll(context, plan, state, body) {\n    /** @type {?} */\n    let result\n    /** @type {?} */\n    let primaryError\n    let hasPrimaryError = false\n\n    try {\n      result = await body()\n    } catch (error) {\n      primaryError = error\n      hasPrimaryError = true\n    }\n\n    /** @type {?} */\n    let cleanupError\n    let hasCleanupError = false\n\n    try {\n      await this._runCallbacks(context, plan, \"afterAll\", state())\n    } catch (error) {\n      cleanupError = error\n      hasCleanupError = true\n    }\n\n    if (hasPrimaryError) {\n      if (hasCleanupError) this._attachCleanupFailure(primaryError, cleanupError)\n\n      throw primaryError\n    }\n\n    if (hasCleanupError) throw cleanupError\n\n    return result\n  }\n\n  /**\n   * Attaches an afterAll cleanup failure to the primary error without masking it.\n   * @param {?} primaryError - The original error that will propagate.\n   * @param {?} cleanupError - The afterAll cleanup failure.\n   * @returns {void}\n   */\n  _attachCleanupFailure(primaryError, cleanupError) {\n    if (!primaryError || typeof primaryError !== \"object\" || !Object.isExtensible(primaryError)) return\n\n    if (!Array.isArray(primaryError.factoryCleanupErrors)) primaryError.factoryCleanupErrors = []\n    primaryError.factoryCleanupErrors.push(cleanupError)\n  }\n\n  /**\n   * Constructs a record from evaluated public attributes, honouring a custom\n   * `initializeWith` constructor and never assigning constructor-consumed\n   * attributes twice.\n   * @param {import(\"../factory-runner.js\").CompiledPlan} plan - Compiled plan.\n   * @param {Record<string, ?>} publicAttributes - Evaluated public attributes.\n   * @param {EvaluationContext} context - Evaluation context.\n   * @param {Record<string, ?>} transients - Evaluated transients.\n   * @returns {Promise<?>} - The constructed record.\n   */\n  async _constructRecord(plan, publicAttributes, context, transients) {\n    const ModelClass = assertModelClass(plan.modelClass, plan.factoryName)\n\n    if (plan.initializeWith) {\n      return await this._constructWithInitializer(plan, ModelClass, publicAttributes, context, transients)\n    }\n\n    return new ModelClass(publicAttributes)\n  }\n\n  /**\n   * Constructs a record via a custom `initializeWith`, tracking which attributes\n   * the constructor consumed through its `get(name)` accessor and assigning only\n   * the remaining public attributes afterwards.\n   * @param {import(\"../factory-runner.js\").CompiledPlan} plan - Compiled plan.\n   * @param {new (attributes?: Record<string, ?>) => import(\"../../../database/record/index.js\").default} ModelClass - Validated declared model class.\n   * @param {Record<string, ?>} publicAttributes - Evaluated public attributes.\n   * @param {EvaluationContext} context - Evaluation context.\n   * @param {Record<string, ?>} transients - Evaluated transients.\n   * @returns {Promise<?>} - The constructed record.\n   */\n  async _constructWithInitializer(plan, ModelClass, publicAttributes, context, transients) {\n    /** @type {Set<string>} */\n    const consumed = new Set()\n    const get = (/** @type {string} */ name) => {\n      consumed.add(name)\n\n      return publicAttributes[name]\n    }\n    const initializeWith = /** @type {import(\"../declarations.js\").InitializeWithDeclaration[\"fn\"]} */ (plan.initializeWith)\n    const record = await initializeWith({attributes: {...publicAttributes}, get, context: this._callbackContext(context, transients)})\n\n    if (!(record instanceof ModelClass)) {\n      throw new ModelContractError(`Factory \"${plan.factoryName}\" initializeWith must return an instance of ${ModelClass.name}, got: ${String(record)}`)\n    }\n\n    /** @type {Record<string, ?>} */\n    const remaining = {}\n\n    for (const key of Object.keys(publicAttributes)) {\n      if (!consumed.has(key)) remaining[key] = publicAttributes[key]\n    }\n\n    if (Object.keys(remaining).length > 0) {\n      /** @type {?} */ (record).assign(remaining)\n    }\n\n    return record\n  }\n\n  /**\n   * Wires evaluated associations onto a record through public relationship\n   * reflection and generated setters (never private caches or guessed keys).\n   * @param {?} record - The owning record.\n   * @param {Array<{name: string, record: ?}>} associations - Evaluated associations.\n   * @returns {void}\n   */\n  _assignAssociations(record, associations) {\n    for (const {name, record: associatedRecord} of associations) {\n      const instanceRelationship = record.getRelationshipByName(name)\n      const relationshipType = instanceRelationship.getType()\n\n      if (relationshipType === \"belongsTo\") {\n        record[`set${inflection.camelize(name)}`](associatedRecord || null)\n      } else if (relationshipType === \"hasOne\") {\n        instanceRelationship.setLoaded(associatedRecord || undefined)\n      } else if (relationshipType === \"hasMany\") {\n        instanceRelationship.setLoaded(this._toRecordArray(associatedRecord))\n      }\n    }\n  }\n\n  /**\n   * Normalizes a has-many association value into an array of records.\n   * @param {?} value - Association value (record, array, or null).\n   * @returns {Array<?>} - The normalized record array.\n   */\n  _toRecordArray(value) {\n    if (value == null) return []\n    if (Array.isArray(value)) return value\n\n    return [value]\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base.js","sourceRoot":"","sources":["../../../../../src/testing/factory/strategies/base.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport * as inflection from \"inflection\"\nimport {assertModelClass} from \"../model-contract.js\"\nimport {ModelContractError} from \"../errors.js\"\nimport EvaluationContext from \"../evaluation-context.js\"\n\n/**\n * Shared behaviour for the build/create/attributesFor strategies: evaluation\n * context creation, deterministic callback execution, guaranteed `afterAll`\n * cleanup, record construction (default and `initializeWith`), and association\n * wiring through public relationship reflection.\n */\nexport default class BaseStrategy {\n  /**\n   * Creates an evaluation context for a plan.\n   * @param {import(\"../factory-registry.js\").default} registry - Owning registry.\n   * @param {import(\"../factory-runner.js\").CompiledPlan} plan - Compiled plan.\n   * @param {\"attributesFor\" | \"build\" | \"create\"} strategyName - Strategy name.\n   * @returns {EvaluationContext} - The context.\n   */\n  _newContext(registry, plan, strategyName) {\n    return new EvaluationContext({registry, plan, strategy: strategyName})\n  }\n\n  /**\n   * Builds the callback `context` object: evaluated transients exposed as plain\n   * properties (no Proxy) plus the named evaluator methods.\n   * @param {EvaluationContext} context - Evaluation context.\n   * @param {Record<string, ReturnType<typeof JSON.parse>>} transients - Evaluated transient values.\n   * @returns {Record<string, ReturnType<typeof JSON.parse>>} - The callback context.\n   */\n  _callbackContext(context, transients) {\n    return Object.assign({}, transients, context.contextFor([]))\n  }\n\n  /**\n   * Runs every deduped callback for an event in declaration order.\n   * @param {EvaluationContext} context - Evaluation context.\n   * @param {import(\"../factory-runner.js\").CompiledPlan} plan - Compiled plan.\n   * @param {string} event - Event name (e.g. \"afterCreate\").\n   * @param {{record: ReturnType<typeof JSON.parse>, transients: Record<string, ReturnType<typeof JSON.parse>>, strategy: string}} state - Current record/transients/strategy.\n   * @returns {Promise<void>} - Resolves when all callbacks complete.\n   */\n  async _runCallbacks(context, plan, event, state) {\n    const callbacks = plan.callbacks.get(event)\n\n    if (!callbacks) return\n\n    const callbackContext = this._callbackContext(context, state.transients)\n\n    for (const callback of callbacks) {\n      await callback.fn({record: state.record, context: callbackContext, strategy: state.strategy})\n    }\n  }\n\n  /**\n   * Runs `body`, then guarantees `afterAll` runs in `finally`. When both the body\n   * and cleanup fail, the body's primary error is preserved and the cleanup error\n   * is attached as a detail rather than masking it.\n   * @param {EvaluationContext} context - Evaluation context.\n   * @param {import(\"../factory-runner.js\").CompiledPlan} plan - Compiled plan.\n   * @param {() => {record: ReturnType<typeof JSON.parse>, transients: Record<string, ReturnType<typeof JSON.parse>>, strategy: string}} state - Late-bound state accessor.\n   * @param {() => Promise<ReturnType<typeof JSON.parse>>} body - The strategy body.\n   * @returns {Promise<ReturnType<typeof JSON.parse>>} - The body's result.\n   */\n  async _runWithAfterAll(context, plan, state, body) {\n    /** @type {ReturnType<typeof JSON.parse>} */\n    let result\n    /** @type {ReturnType<typeof JSON.parse>} */\n    let primaryError\n    let hasPrimaryError = false\n\n    try {\n      result = await body()\n    } catch (error) {\n      primaryError = error\n      hasPrimaryError = true\n    }\n\n    /** @type {ReturnType<typeof JSON.parse>} */\n    let cleanupError\n    let hasCleanupError = false\n\n    try {\n      await this._runCallbacks(context, plan, \"afterAll\", state())\n    } catch (error) {\n      cleanupError = error\n      hasCleanupError = true\n    }\n\n    if (hasPrimaryError) {\n      if (hasCleanupError) this._attachCleanupFailure(primaryError, cleanupError)\n\n      throw primaryError\n    }\n\n    if (hasCleanupError) throw cleanupError\n\n    return result\n  }\n\n  /**\n   * Attaches an afterAll cleanup failure to the primary error without masking it.\n   * @param {ReturnType<typeof JSON.parse>} primaryError - The original error that will propagate.\n   * @param {ReturnType<typeof JSON.parse>} cleanupError - The afterAll cleanup failure.\n   * @returns {void}\n   */\n  _attachCleanupFailure(primaryError, cleanupError) {\n    if (!primaryError || typeof primaryError !== \"object\" || !Object.isExtensible(primaryError)) return\n\n    if (!Array.isArray(primaryError.factoryCleanupErrors)) primaryError.factoryCleanupErrors = []\n    primaryError.factoryCleanupErrors.push(cleanupError)\n  }\n\n  /**\n   * Constructs a record from evaluated public attributes, honouring a custom\n   * `initializeWith` constructor and never assigning constructor-consumed\n   * attributes twice.\n   * @param {import(\"../factory-runner.js\").CompiledPlan} plan - Compiled plan.\n   * @param {Record<string, ReturnType<typeof JSON.parse>>} publicAttributes - Evaluated public attributes.\n   * @param {EvaluationContext} context - Evaluation context.\n   * @param {Record<string, ReturnType<typeof JSON.parse>>} transients - Evaluated transients.\n   * @returns {Promise<ReturnType<typeof JSON.parse>>} - The constructed record.\n   */\n  async _constructRecord(plan, publicAttributes, context, transients) {\n    const ModelClass = assertModelClass(plan.modelClass, plan.factoryName)\n\n    if (plan.initializeWith) {\n      return await this._constructWithInitializer(plan, ModelClass, publicAttributes, context, transients)\n    }\n\n    return new ModelClass(publicAttributes)\n  }\n\n  /**\n   * Constructs a record via a custom `initializeWith`, tracking which attributes\n   * the constructor consumed through its `get(name)` accessor and assigning only\n   * the remaining public attributes afterwards.\n   * @param {import(\"../factory-runner.js\").CompiledPlan} plan - Compiled plan.\n   * @param {new (attributes?: Record<string, ReturnType<typeof JSON.parse>>) => import(\"../../../database/record/index.js\").default} ModelClass - Validated declared model class.\n   * @param {Record<string, ReturnType<typeof JSON.parse>>} publicAttributes - Evaluated public attributes.\n   * @param {EvaluationContext} context - Evaluation context.\n   * @param {Record<string, ReturnType<typeof JSON.parse>>} transients - Evaluated transients.\n   * @returns {Promise<ReturnType<typeof JSON.parse>>} - The constructed record.\n   */\n  async _constructWithInitializer(plan, ModelClass, publicAttributes, context, transients) {\n    /** @type {Set<string>} */\n    const consumed = new Set()\n    const get = (/** @type {string} */ name) => {\n      consumed.add(name)\n\n      return publicAttributes[name]\n    }\n    const initializeWith = /** @type {import(\"../declarations.js\").InitializeWithDeclaration[\"fn\"]} */ (plan.initializeWith)\n    const record = await initializeWith({attributes: {...publicAttributes}, get, context: this._callbackContext(context, transients)})\n\n    if (!(record instanceof ModelClass)) {\n      throw new ModelContractError(`Factory \"${plan.factoryName}\" initializeWith must return an instance of ${ModelClass.name}, got: ${String(record)}`)\n    }\n\n    /** @type {Record<string, ReturnType<typeof JSON.parse>>} */\n    const remaining = {}\n\n    for (const key of Object.keys(publicAttributes)) {\n      if (!consumed.has(key)) remaining[key] = publicAttributes[key]\n    }\n\n    if (Object.keys(remaining).length > 0) {\n      /** @type {ReturnType<typeof JSON.parse>} */ (record).assign(remaining)\n    }\n\n    return record\n  }\n\n  /**\n   * Wires evaluated associations onto a record through public relationship\n   * reflection and generated setters (never private caches or guessed keys).\n   * @param {ReturnType<typeof JSON.parse>} record - The owning record.\n   * @param {Array<{name: string, record: ReturnType<typeof JSON.parse>}>} associations - Evaluated associations.\n   * @returns {void}\n   */\n  _assignAssociations(record, associations) {\n    for (const {name, record: associatedRecord} of associations) {\n      const instanceRelationship = record.getRelationshipByName(name)\n      const relationshipType = instanceRelationship.getType()\n\n      if (relationshipType === \"belongsTo\") {\n        record[`set${inflection.camelize(name)}`](associatedRecord || null)\n      } else if (relationshipType === \"hasOne\") {\n        instanceRelationship.setLoaded(associatedRecord || undefined)\n      } else if (relationshipType === \"hasMany\") {\n        instanceRelationship.setLoaded(this._toRecordArray(associatedRecord))\n      }\n    }\n  }\n\n  /**\n   * Normalizes a has-many association value into an array of records.\n   * @param {ReturnType<typeof JSON.parse>} value - Association value (record, array, or null).\n   * @returns {Array<ReturnType<typeof JSON.parse>>} - The normalized record array.\n   */\n  _toRecordArray(value) {\n    if (value == null) return []\n    if (Array.isArray(value)) return value\n\n    return [value]\n  }\n}\n"]}

package/build/src/testing/factory/strategies/build.d.ts

@@ -1,3 +1,4 @@
+import BaseStrategy from "./base.js";
 /**
  * The `build` strategy. It recursively builds associated models (using the parent
  * strategy) and constructs the root record without persisting anything. Runs the
@@ -9,12 +10,11 @@ export default class BuildStrategy extends BaseStrategy {
      * @param {object} args - Options.
      * @param {import("../factory-registry.js").default} args.registry - Owning registry.
      * @param {import("../factory-runner.js").CompiledPlan} args.plan - Compiled plan.
-     * @returns {Promise<?>} - The built (unsaved) record.
+     * @returns {Promise<ReturnType<typeof JSON.parse>>} - The built (unsaved) record.
      */
     run({ registry, plan }: {
         registry: import("../factory-registry.js").default;
         plan: import("../factory-runner.js").CompiledPlan;
-    }): Promise<unknown>;
+    }): Promise<ReturnType<typeof JSON.parse>>;
 }
-import BaseStrategy from "./base.js";
 //# sourceMappingURL=build.d.ts.map

package/build/src/testing/factory/strategies/build.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../../../../../src/testing/factory/strategies/build.js"],"names":[],"mappings":"AAIA;;;;GAIG;AACH;IACE;;;;;;OAMG;IACH,wBAJG;QAAuD,QAAQ,EAAvD,OAAO,wBAAwB,EAAE,OAAO;QACU,IAAI,EAAtD,OAAO,sBAAsB,EAAE,YAAY;KACnD,GAAU,OAAO,CAAC,OAAC,CAAC,CAyBtB;CACF;yBAvCwB,WAAW"}
+{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../../../../../src/testing/factory/strategies/build.js"],"names":[],"mappings":"AAEA,OAAO,YAAY,MAAM,WAAW,CAAA;AAEpC;;;;GAIG;AACH,MAAM,CAAC,OAAO,OAAO,aAAc,SAAQ,YAAY;IACrD;;;;;;OAMG;IACG,GAAG,CAAC,EAAC,QAAQ,EAAE,IAAI,EAAC,EAJvB;QAAuD,QAAQ,EAAvD,OAAO,wBAAwB,EAAE,OAAO,CAChD;QAA0D,IAAI,EAAtD,OAAO,sBAAsB,EAAE,YAAY,CACnD;KAEuB,GAFb,OAAO,CAAC,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,CAyBlD;CACF"}

package/build/src/testing/factory/strategies/build.js

@@ -11,11 +11,11 @@ export default class BuildStrategy extends BaseStrategy {
      * @param {object} args - Options.
      * @param {import("../factory-registry.js").default} args.registry - Owning registry.
      * @param {import("../factory-runner.js").CompiledPlan} args.plan - Compiled plan.
-     * @returns {Promise<?>} - The built (unsaved) record.
+     * @returns {Promise<ReturnType<typeof JSON.parse>>} - The built (unsaved) record.
      */
     async run({ registry, plan }) {
         const context = this._newContext(registry, plan, "build");
-        /** @type {{record: ?, transients: Record<string, ?>}} */
+        /** @type {{record: ReturnType<typeof JSON.parse>, transients: Record<string, ReturnType<typeof JSON.parse>>}} */
         const runState = { record: undefined, transients: {} };
         const state = () => ({ record: runState.record, transients: runState.transients, strategy: "build" });
         return await this._runWithAfterAll(context, plan, state, async () => {
@@ -31,4 +31,4 @@ export default class BuildStrategy extends BaseStrategy {
         });
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/build/src/testing/factory/strategies/create.d.ts

@@ -1,3 +1,4 @@
+import BaseStrategy from "./base.js";
 /**
  * The `create` strategy. It builds the object graph (associations use the parent
  * create strategy by default), runs beforeAll/beforeBuild/afterBuild, persists the
@@ -11,22 +12,21 @@ export default class CreateStrategy extends BaseStrategy {
      * @param {object} args - Options.
      * @param {import("../factory-registry.js").default} args.registry - Owning registry.
      * @param {import("../factory-runner.js").CompiledPlan} args.plan - Compiled plan.
-     * @returns {Promise<?>} - The persisted record.
+     * @returns {Promise<ReturnType<typeof JSON.parse>>} - The persisted record.
      */
     run({ registry, plan }: {
         registry: import("../factory-registry.js").default;
         plan: import("../factory-runner.js").CompiledPlan;
-    }): Promise<unknown>;
+    }): Promise<ReturnType<typeof JSON.parse>>;
     /**
      * Persists the record via a custom `toCreate`, native `save()`, or not at all
      * when `skipCreate` is declared.
      * @param {import("../factory-runner.js").CompiledPlan} plan - Compiled plan.
-     * @param {?} record - The record to persist.
+     * @param {ReturnType<typeof JSON.parse>} record - The record to persist.
      * @param {import("../evaluation-context.js").default} context - Evaluation context.
-     * @param {Record<string, ?>} transients - Evaluated transients.
+     * @param {Record<string, ReturnType<typeof JSON.parse>>} transients - Evaluated transients.
      * @returns {Promise<void>} - Resolves when persistence completes.
      */
-    _persist(plan: import("../factory-runner.js").CompiledPlan, record: unknown, context: import("../evaluation-context.js").default, transients: Record<string, unknown>): Promise<void>;
+    _persist(plan: import("../factory-runner.js").CompiledPlan, record: ReturnType<typeof JSON.parse>, context: import("../evaluation-context.js").default, transients: Record<string, ReturnType<typeof JSON.parse>>): Promise<void>;
 }
-import BaseStrategy from "./base.js";
 //# sourceMappingURL=create.d.ts.map

package/build/src/testing/factory/strategies/create.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"create.d.ts","sourceRoot":"","sources":["../../../../../src/testing/factory/strategies/create.js"],"names":[],"mappings":"AAIA;;;;;;GAMG;AACH;IACE;;;;;;OAMG;IACH,wBAJG;QAAuD,QAAQ,EAAvD,OAAO,wBAAwB,EAAE,OAAO;QACU,IAAI,EAAtD,OAAO,sBAAsB,EAAE,YAAY;KACnD,GAAU,OAAO,CAAC,OAAC,CAAC,CA4BtB;IAED;;;;;;;;OAQG;IACH,eANW,OAAO,sBAAsB,EAAE,YAAY,UAC3C,OAAC,WACD,OAAO,0BAA0B,EAAE,OAAO,cAC1C,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,GACf,OAAO,CAAC,IAAI,CAAC,CAYzB;CACF;yBAjEwB,WAAW"}
+{"version":3,"file":"create.d.ts","sourceRoot":"","sources":["../../../../../src/testing/factory/strategies/create.js"],"names":[],"mappings":"AAEA,OAAO,YAAY,MAAM,WAAW,CAAA;AAEpC;;;;;;GAMG;AACH,MAAM,CAAC,OAAO,OAAO,cAAe,SAAQ,YAAY;IACtD;;;;;;OAMG;IACG,GAAG,CAAC,EAAC,QAAQ,EAAE,IAAI,EAAC,EAJvB;QAAuD,QAAQ,EAAvD,OAAO,wBAAwB,EAAE,OAAO,CAChD;QAA0D,IAAI,EAAtD,OAAO,sBAAsB,EAAE,YAAY,CACnD;KAEuB,GAFb,OAAO,CAAC,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,CA4BlD;IAED;;;;;;;;OAQG;IACG,QAAQ,CAAC,IAAI,EANR,OAAO,sBAAsB,EAAE,YAMvB,EAAE,MAAM,EALhB,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAKZ,EAAE,OAAO,EAJzB,OAAO,0BAA0B,EAAE,OAIV,EAAE,UAAU,EAHrC,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,CAGP,GAFnC,OAAO,CAAC,IAAI,CAAC,CAYzB;CACF"}

package/build/src/testing/factory/strategies/create.js

@@ -13,11 +13,11 @@ export default class CreateStrategy extends BaseStrategy {
      * @param {object} args - Options.
      * @param {import("../factory-registry.js").default} args.registry - Owning registry.
      * @param {import("../factory-runner.js").CompiledPlan} args.plan - Compiled plan.
-     * @returns {Promise<?>} - The persisted record.
+     * @returns {Promise<ReturnType<typeof JSON.parse>>} - The persisted record.
      */
     async run({ registry, plan }) {
         const context = this._newContext(registry, plan, "create");
-        /** @type {{record: ?, transients: Record<string, ?>}} */
+        /** @type {{record: ReturnType<typeof JSON.parse>, transients: Record<string, ReturnType<typeof JSON.parse>>}} */
         const runState = { record: undefined, transients: {} };
         const state = () => ({ record: runState.record, transients: runState.transients, strategy: "create" });
         return await this._runWithAfterAll(context, plan, state, async () => {
@@ -39,9 +39,9 @@ export default class CreateStrategy extends BaseStrategy {
      * Persists the record via a custom `toCreate`, native `save()`, or not at all
      * when `skipCreate` is declared.
      * @param {import("../factory-runner.js").CompiledPlan} plan - Compiled plan.
-     * @param {?} record - The record to persist.
+     * @param {ReturnType<typeof JSON.parse>} record - The record to persist.
      * @param {import("../evaluation-context.js").default} context - Evaluation context.
-     * @param {Record<string, ?>} transients - Evaluated transients.
+     * @param {Record<string, ReturnType<typeof JSON.parse>>} transients - Evaluated transients.
      * @returns {Promise<void>} - Resolves when persistence completes.
      */
     async _persist(plan, record, context, transients) {
@@ -54,4 +54,4 @@ export default class CreateStrategy extends BaseStrategy {
         await record.save();
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/build/src/testing/factory/trait-definition.d.ts

@@ -4,6 +4,10 @@
  * base-trait inclusions) that are mixed into a factory run.
  */
 export default class TraitDefinition {
+    /** @type {string} - Trait name. */
+    name: string;
+    /** @type {Array<import("./declarations.js").Declaration>} - Ordered declarations. */
+    declarations: Array<import("./declarations.js").Declaration>;
     /**
      * Builds a trait definition.
      * @param {object} args - Options.
@@ -14,9 +18,5 @@ export default class TraitDefinition {
         name: string;
         declarations: import("./declarations.js").Declaration[];
     });
-    /** @type {string} - Trait name. */
-    name: string;
-    /** @type {Array<import("./declarations.js").Declaration>} - Ordered declarations. */
-    declarations: Array<import("./declarations.js").Declaration>;
 }
 //# sourceMappingURL=trait-definition.d.ts.map

package/build/src/testing/factory/trait-definition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"trait-definition.d.ts","sourceRoot":"","sources":["../../../../src/testing/factory/trait-definition.js"],"names":[],"mappings":"AAEA;;;;GAIG;AACH;IACE;;;;;OAKG;IACH,oCAHG;QAAqB,IAAI,EAAjB,MAAM;QAC0C,YAAY,EAA5D,OAAO,mBAAmB,EAAE,WAAW,EAAE;KACnD,EASA;IAPC,mCAAmC;IACnC,MADW,MAAM,CACD;IAEhB,qFAAqF;IACrF,cADW,KAAK,CAAC,OAAO,mBAAmB,EAAE,WAAW,CAAC,CAC2D;CAIvH"}
+{"version":3,"file":"trait-definition.d.ts","sourceRoot":"","sources":["../../../../src/testing/factory/trait-definition.js"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,MAAM,CAAC,OAAO,OAAO,eAAe;IAQhC,mCAAmC;IAC9B,IAAI,EADE,MAAM;IAGjB,qFAAqF;IAChF,YAAY,EADN,KAAK,CAAC,OAAO,mBAAmB,EAAE,WAAW,CAAC;IAV3D;;;;;OAKG;IACH,YAAY,EAAC,IAAI,EAAE,YAAY,EAAC,EAH7B;QAAqB,IAAI,EAAjB,MAAM,CACd;QAAwD,YAAY,EAA5D,OAAO,mBAAmB,EAAE,WAAW,EAAE,CACnD;KAC+B,EAQ/B;CACF"}