velocious 1.0.552 → 1.0.555

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

@@ -0,0 +1,106 @@
+// @ts-check
+import { FactoryError } from "./errors.js";
+/** Internal sentinel thrown to force a per-case transaction rollback. */
+class LintRollbackSignal extends Error {
+}
+/**
+ * Aggregated lint failure raised when one or more linted factories/traits error.
+ */
+class FactoryLintError extends FactoryError {
+}
+/**
+ * Executes registered factories (and optionally their traits) to prove they build
+ * and persist, aggregating every failure by case. For the create strategy each
+ * case runs inside the model's ambient transaction and is rolled back, so no rows
+ * remain in the supported single-connection case. External callback side effects
+ * are not reversible and cross-database writes are not globally atomic.
+ */
+export default class FactoryLinter {
+    /**
+     * Builds a linter.
+     * @param {import("./factory-registry.js").default} registry - Registry to lint.
+     */
+    constructor(registry) {
+        /** @type {import("./factory-registry.js").default} - Registry to lint. */
+        this.registry = registry;
+    }
+    /**
+     * Lints selected factories and reports every failure together.
+     * @param {object} [options] - Options.
+     * @param {string[]} [options.factories] - Factory names to lint. Defaults to all.
+     * @param {boolean} [options.traits] - Whether to also lint each factory's local traits.
+     * @param {"attributesFor" | "build" | "create"} [options.strategy] - Strategy to lint with. Defaults to create.
+     * @returns {Promise<void>} - Resolves when every case passed; rejects with an aggregate otherwise.
+     */
+    async lint({ factories, traits = false, strategy = "create" } = {}) {
+        const definitions = this._selectDefinitions(factories);
+        /** @type {Array<{label: string, error: ?}>} */
+        const failures = [];
+        for (const definition of definitions) {
+            await this._lintCase(definition, [], strategy, failures);
+            if (traits) {
+                for (const traitName of definition.localTraits.keys()) {
+                    await this._lintCase(definition, [traitName], strategy, failures);
+                }
+            }
+        }
+        if (failures.length > 0) {
+            const details = failures.map((failure) => `  ${failure.label}: ${failure.error && failure.error.message}`).join("\n");
+            throw new FactoryLintError(`Factory lint found ${failures.length} error(s):\n${details}`);
+        }
+    }
+    /**
+     * Resolves the unique set of factory definitions to lint.
+     * @param {string[] | undefined} factories - Explicit names, or undefined for all.
+     * @returns {import("./factory-definition.js").default[]} - Unique definitions.
+     */
+    _selectDefinitions(factories) {
+        if (factories) {
+            return factories.map((name) => this.registry._runner._resolveFactory(name));
+        }
+        return [...new Set(this.registry._factories.values())];
+    }
+    /**
+     * Lints one factory/trait case, rolling back create-strategy persistence.
+     * @param {import("./factory-definition.js").default} definition - Factory definition.
+     * @param {string[]} traits - Traits to apply for this case.
+     * @param {"attributesFor" | "build" | "create"} strategy - Strategy to run.
+     * @param {Array<{label: string, error: ?}>} failures - Failure sink.
+     * @returns {Promise<void>} - Resolves when the case has been evaluated.
+     */
+    async _lintCase(definition, traits, strategy, failures) {
+        const label = traits.length > 0 ? `${definition.name} + ${traits.join(", ")}` : definition.name;
+        try {
+            if (strategy === "create") {
+                await this._lintCreateCase(definition, traits);
+            }
+            else {
+                await this.registry[strategy](definition.name, ...traits);
+            }
+        }
+        catch (error) {
+            if (error instanceof LintRollbackSignal)
+                return;
+            failures.push({ label, error });
+        }
+    }
+    /**
+     * Runs a create-strategy case inside a transaction and forces a rollback.
+     * @param {import("./factory-definition.js").default} definition - Factory definition.
+     * @param {string[]} traits - Traits to apply.
+     * @returns {Promise<void>} - Resolves (or rejects) once the rollback completes.
+     */
+    async _lintCreateCase(definition, traits) {
+        const chain = this.registry._runner._resolveChain(definition.name);
+        const modelClass = this.registry._runner._resolveModelClass(chain);
+        if (!modelClass) {
+            await this.registry.create(definition.name, ...traits);
+            return;
+        }
+        await /** @type {typeof import("../../database/record/index.js").default} */ (modelClass).transaction(async () => {
+            await this.registry.create(definition.name, ...traits);
+            throw new LintRollbackSignal();
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"linter.js","sourceRoot":"","sources":["../../../../src/testing/factory/linter.js"],"names":[],"mappings":"AAAA,YAAY;AAEZ,OAAO,EAAC,YAAY,EAAC,MAAM,aAAa,CAAA;AAExC,yEAAyE;AACzE,MAAM,kBAAmB,SAAQ,KAAK;CAAG;AAEzC;;GAEG;AACH,MAAM,gBAAiB,SAAQ,YAAY;CAAG;AAE9C;;;;;;GAMG;AACH,MAAM,CAAC,OAAO,OAAO,aAAa;IAChC;;;OAGG;IACH,YAAY,QAAQ;QAClB,0EAA0E;QAC1E,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAA;IAC1B,CAAC;IAED;;;;;;;OAOG;IACH,KAAK,CAAC,IAAI,CAAC,EAAC,SAAS,EAAE,MAAM,GAAG,KAAK,EAAE,QAAQ,GAAG,QAAQ,EAAC,GAAG,EAAE;QAC9D,MAAM,WAAW,GAAG,IAAI,CAAC,kBAAkB,CAAC,SAAS,CAAC,CAAA;QACtD,+CAA+C;QAC/C,MAAM,QAAQ,GAAG,EAAE,CAAA;QAEnB,KAAK,MAAM,UAAU,IAAI,WAAW,EAAE,CAAC;YACrC,MAAM,IAAI,CAAC,SAAS,CAAC,UAAU,EAAE,EAAE,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAA;YAExD,IAAI,MAAM,EAAE,CAAC;gBACX,KAAK,MAAM,SAAS,IAAI,UAAU,CAAC,WAAW,CAAC,IAAI,EAAE,EAAE,CAAC;oBACtD,MAAM,IAAI,CAAC,SAAS,CAAC,UAAU,EAAE,CAAC,SAAS,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAA;gBACnE,CAAC;YACH,CAAC;QACH,CAAC;QAED,IAAI,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACxB,MAAM,OAAO,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,KAAK,OAAO,CAAC,KAAK,KAAK,OAAO,CAAC,KAAK,IAAI,OAAO,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;YAErH,MAAM,IAAI,gBAAgB,CAAC,sBAAsB,QAAQ,CAAC,MAAM,eAAe,OAAO,EAAE,CAAC,CAAA;QAC3F,CAAC;IACH,CAAC;IAED;;;;OAIG;IACH,kBAAkB,CAAC,SAAS;QAC1B,IAAI,SAAS,EAAE,CAAC;YACd,OAAO,SAAS,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC,CAAA;QAC7E,CAAC;QAED,OAAO,CAAC,GAAG,IAAI,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,MAAM,EAAE,CAAC,CAAC,CAAA;IACxD,CAAC;IAED;;;;;;;OAOG;IACH,KAAK,CAAC,SAAS,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ;QACpD,MAAM,KAAK,GAAG,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC,IAAI,MAAM,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,UAAU,CAAC,IAAI,CAAA;QAE/F,IAAI,CAAC;YACH,IAAI,QAAQ,KAAK,QAAQ,EAAE,CAAC;gBAC1B,MAAM,IAAI,CAAC,eAAe,CAAC,UAAU,EAAE,MAAM,CAAC,CAAA;YAChD,CAAC;iBAAM,CAAC;gBACN,MAAM,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,UAAU,CAAC,IAAI,EAAE,GAAG,MAAM,CAAC,CAAA;YAC3D,CAAC;QACH,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,KAAK,YAAY,kBAAkB;gBAAE,OAAM;YAE/C,QAAQ,CAAC,IAAI,CAAC,EAAC,KAAK,EAAE,KAAK,EAAC,CAAC,CAAA;QAC/B,CAAC;IACH,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,eAAe,CAAC,UAAU,EAAE,MAAM;QACtC,MAAM,KAAK,GAAG,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,aAAa,CAAC,UAAU,CAAC,IAAI,CAAC,CAAA;QAClE,MAAM,UAAU,GAAG,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAA;QAElE,IAAI,CAAC,UAAU,EAAE,CAAC;YAChB,MAAM,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,UAAU,CAAC,IAAI,EAAE,GAAG,MAAM,CAAC,CAAA;YAEtD,OAAM;QACR,CAAC;QAED,MAAM,sEAAsE,CAAC,CAAC,UAAU,CAAC,CAAC,WAAW,CAAC,KAAK,IAAI,EAAE;YAC/G,MAAM,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,UAAU,CAAC,IAAI,EAAE,GAAG,MAAM,CAAC,CAAA;YAEtD,MAAM,IAAI,kBAAkB,EAAE,CAAA;QAChC,CAAC,CAAC,CAAA;IACJ,CAAC;CACF","sourcesContent":["// @ts-check\n\nimport {FactoryError} from \"./errors.js\"\n\n/** Internal sentinel thrown to force a per-case transaction rollback. */\nclass LintRollbackSignal extends Error {}\n\n/**\n * Aggregated lint failure raised when one or more linted factories/traits error.\n */\nclass FactoryLintError extends FactoryError {}\n\n/**\n * Executes registered factories (and optionally their traits) to prove they build\n * and persist, aggregating every failure by case. For the create strategy each\n * case runs inside the model's ambient transaction and is rolled back, so no rows\n * remain in the supported single-connection case. External callback side effects\n * are not reversible and cross-database writes are not globally atomic.\n */\nexport default class FactoryLinter {\n  /**\n   * Builds a linter.\n   * @param {import(\"./factory-registry.js\").default} registry - Registry to lint.\n   */\n  constructor(registry) {\n    /** @type {import(\"./factory-registry.js\").default} - Registry to lint. */\n    this.registry = registry\n  }\n\n  /**\n   * Lints selected factories and reports every failure together.\n   * @param {object} [options] - Options.\n   * @param {string[]} [options.factories] - Factory names to lint. Defaults to all.\n   * @param {boolean} [options.traits] - Whether to also lint each factory's local traits.\n   * @param {\"attributesFor\" | \"build\" | \"create\"} [options.strategy] - Strategy to lint with. Defaults to create.\n   * @returns {Promise<void>} - Resolves when every case passed; rejects with an aggregate otherwise.\n   */\n  async lint({factories, traits = false, strategy = \"create\"} = {}) {\n    const definitions = this._selectDefinitions(factories)\n    /** @type {Array<{label: string, error: ?}>} */\n    const failures = []\n\n    for (const definition of definitions) {\n      await this._lintCase(definition, [], strategy, failures)\n\n      if (traits) {\n        for (const traitName of definition.localTraits.keys()) {\n          await this._lintCase(definition, [traitName], strategy, failures)\n        }\n      }\n    }\n\n    if (failures.length > 0) {\n      const details = failures.map((failure) => `  ${failure.label}: ${failure.error && failure.error.message}`).join(\"\\n\")\n\n      throw new FactoryLintError(`Factory lint found ${failures.length} error(s):\\n${details}`)\n    }\n  }\n\n  /**\n   * Resolves the unique set of factory definitions to lint.\n   * @param {string[] | undefined} factories - Explicit names, or undefined for all.\n   * @returns {import(\"./factory-definition.js\").default[]} - Unique definitions.\n   */\n  _selectDefinitions(factories) {\n    if (factories) {\n      return factories.map((name) => this.registry._runner._resolveFactory(name))\n    }\n\n    return [...new Set(this.registry._factories.values())]\n  }\n\n  /**\n   * Lints one factory/trait case, rolling back create-strategy persistence.\n   * @param {import(\"./factory-definition.js\").default} definition - Factory definition.\n   * @param {string[]} traits - Traits to apply for this case.\n   * @param {\"attributesFor\" | \"build\" | \"create\"} strategy - Strategy to run.\n   * @param {Array<{label: string, error: ?}>} failures - Failure sink.\n   * @returns {Promise<void>} - Resolves when the case has been evaluated.\n   */\n  async _lintCase(definition, traits, strategy, failures) {\n    const label = traits.length > 0 ? `${definition.name} + ${traits.join(\", \")}` : definition.name\n\n    try {\n      if (strategy === \"create\") {\n        await this._lintCreateCase(definition, traits)\n      } else {\n        await this.registry[strategy](definition.name, ...traits)\n      }\n    } catch (error) {\n      if (error instanceof LintRollbackSignal) return\n\n      failures.push({label, error})\n    }\n  }\n\n  /**\n   * Runs a create-strategy case inside a transaction and forces a rollback.\n   * @param {import(\"./factory-definition.js\").default} definition - Factory definition.\n   * @param {string[]} traits - Traits to apply.\n   * @returns {Promise<void>} - Resolves (or rejects) once the rollback completes.\n   */\n  async _lintCreateCase(definition, traits) {\n    const chain = this.registry._runner._resolveChain(definition.name)\n    const modelClass = this.registry._runner._resolveModelClass(chain)\n\n    if (!modelClass) {\n      await this.registry.create(definition.name, ...traits)\n\n      return\n    }\n\n    await /** @type {typeof import(\"../../database/record/index.js\").default} */ (modelClass).transaction(async () => {\n      await this.registry.create(definition.name, ...traits)\n\n      throw new LintRollbackSignal()\n    })\n  }\n}\n"]}

package/build/src/testing/factory/model-contract.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Asserts a class satisfies the V1 factory model contract: it must be an
+ * initialized backend Velocious `DatabaseRecord` subclass. Uninitialized backend
+ * classes and non-backend classes (e.g. generated frontend models) are rejected
+ * with a named, actionable error rather than failing deep inside construction.
+ * @param {?} modelClass - The candidate model class.
+ * @param {string} factoryName - Factory name, for the error message.
+ * @returns {new (attributes?: Record<string, ?>) => import("../../database/record/index.js").default} - The validated model class.
+ */
+export function assertModelClass(modelClass: unknown, factoryName: string): new (attributes?: Record<string, unknown>) => import("../../database/record/index.js").default;
+//# sourceMappingURL=model-contract.d.ts.map

package/build/src/testing/factory/model-contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-contract.d.ts","sourceRoot":"","sources":["../../../../src/testing/factory/model-contract.js"],"names":[],"mappings":"AAKA;;;;;;;;GAQG;AACH,6CAJW,OAAC,eACD,MAAM,GACJ,KAAK,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,KAAK,OAAO,gCAAgC,EAAE,OAAO,CAkBpG"}

package/build/src/testing/factory/model-contract.js

@@ -0,0 +1,26 @@
+// @ts-check
+import DatabaseRecord from "../../database/record/index.js";
+import { ModelContractError } from "./errors.js";
+/**
+ * Asserts a class satisfies the V1 factory model contract: it must be an
+ * initialized backend Velocious `DatabaseRecord` subclass. Uninitialized backend
+ * classes and non-backend classes (e.g. generated frontend models) are rejected
+ * with a named, actionable error rather than failing deep inside construction.
+ * @param {?} modelClass - The candidate model class.
+ * @param {string} factoryName - Factory name, for the error message.
+ * @returns {new (attributes?: Record<string, ?>) => import("../../database/record/index.js").default} - The validated model class.
+ */
+export function assertModelClass(modelClass, factoryName) {
+    if (typeof modelClass !== "function") {
+        throw new ModelContractError(`Factory "${factoryName}" has no model class to construct. Declare one with factory("${factoryName}", ModelClass, ...).`);
+    }
+    if (!(modelClass.prototype instanceof DatabaseRecord)) {
+        throw new ModelContractError(`Factory "${factoryName}" model ${modelClass.name || "class"} is not a supported Velocious backend record. build/create require an initialized DatabaseRecord subclass; generated frontend models are not supported in V1.`);
+    }
+    const backendModelClass = /** @type {typeof import("../../database/record/index.js").default} */ (modelClass);
+    if (!backendModelClass.isInitialized()) {
+        throw new ModelContractError(`Factory "${factoryName}" model ${backendModelClass.name} has not been initialized. Ensure the model class is initialized (e.g. via configuration.initialize()/ensureInitialized) before build/create.`);
+    }
+    return /** @type {new (attributes?: Record<string, ?>) => import("../../database/record/index.js").default} */ (modelClass);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/src/testing/factory/node/load-definitions.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Loads Velocious factory definition files (Node only). Each file must
+ * default-export a `(registry) => void` function that defines into the registry.
+ * Files load in deterministic path order. This module is intentionally Node-only
+ * (filesystem + dynamic import) and must never be imported from browser/Metro
+ * bundles; import the browser-safe core from `../index.js` there instead.
+ * @param {import("../factory-registry.js").default} registry - Registry to define into.
+ * @param {string | string[]} target - File path, directory, or list of paths.
+ * @param {{reload?: boolean}} [options] - Options.
+ * @returns {Promise<string[]>} - The loaded file paths, in load order.
+ */
+export function loadDefinitions(registry: import("../factory-registry.js").default, target: string | string[], { reload }?: {
+    reload?: boolean;
+}): Promise<string[]>;
+/**
+ * Fully reloads definitions: resets the registry (dropping every factory, trait,
+ * sequence, callback and default) and re-imports the target files with cache
+ * busting so edited definitions take effect.
+ * @param {import("../factory-registry.js").default} registry - Registry to reload.
+ * @param {string | string[]} target - File path, directory, or list of paths.
+ * @returns {Promise<string[]>} - The reloaded file paths, in load order.
+ */
+export function reloadDefinitions(registry: import("../factory-registry.js").default, target: string | string[]): Promise<string[]>;
+//# sourceMappingURL=load-definitions.d.ts.map

package/build/src/testing/factory/node/load-definitions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load-definitions.d.ts","sourceRoot":"","sources":["../../../../../src/testing/factory/node/load-definitions.js"],"names":[],"mappings":"AAwDA;;;;;;;;;;GAUG;AACH,0CALW,OAAO,wBAAwB,EAAE,OAAO,UACxC,MAAM,GAAG,MAAM,EAAE,eACjB;IAAC,MAAM,CAAC,EAAE,OAAO,CAAA;CAAC,GAChB,OAAO,CAAC,MAAM,EAAE,CAAC,CAuB7B;AAED;;;;;;;GAOG;AACH,4CAJW,OAAO,wBAAwB,EAAE,OAAO,UACxC,MAAM,GAAG,MAAM,EAAE,GACf,OAAO,CAAC,MAAM,EAAE,CAAC,CAM7B"}

package/build/src/testing/factory/node/load-definitions.js

@@ -0,0 +1,87 @@
+// @ts-check
+import { pathToFileURL } from "node:url";
+import { readdir, stat } from "node:fs/promises";
+import path from "node:path";
+/**
+ * Monotonic cache-busting counter shared by reloads. Kept module-local so a reload
+ * imports a fresh module instance rather than the cached one.
+ * @type {number}
+ */
+let reloadCounter = 0;
+/**
+ * Recursively collects `.js` files under a directory in a deterministic
+ * (lexicographically sorted) order.
+ * @param {string} directory - Directory to scan.
+ * @returns {Promise<string[]>} - Sorted absolute file paths.
+ */
+async function collectDirectoryFiles(directory) {
+    const entries = await readdir(directory, { withFileTypes: true });
+    /** @type {string[]} */
+    const files = [];
+    for (const entry of [...entries].sort((left, right) => (left.name < right.name ? -1 : 1))) {
+        const fullPath = path.join(directory, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...await collectDirectoryFiles(fullPath));
+        }
+        else if (entry.name.endsWith(".js")) {
+            files.push(fullPath);
+        }
+    }
+    return files;
+}
+/**
+ * Resolves a load target (a single file, a directory, or an explicit list) into a
+ * deterministic, de-duplicated list of absolute definition file paths.
+ * @param {string | string[]} target - File path, directory, or list of paths.
+ * @returns {Promise<string[]>} - Sorted, de-duplicated absolute file paths.
+ */
+async function resolveFiles(target) {
+    if (Array.isArray(target)) {
+        return [...new Set(target.map((entry) => path.resolve(entry)))].sort();
+    }
+    const resolved = path.resolve(target);
+    const stats = await stat(resolved);
+    if (stats.isDirectory())
+        return await collectDirectoryFiles(resolved);
+    return [resolved];
+}
+/**
+ * Loads Velocious factory definition files (Node only). Each file must
+ * default-export a `(registry) => void` function that defines into the registry.
+ * Files load in deterministic path order. This module is intentionally Node-only
+ * (filesystem + dynamic import) and must never be imported from browser/Metro
+ * bundles; import the browser-safe core from `../index.js` there instead.
+ * @param {import("../factory-registry.js").default} registry - Registry to define into.
+ * @param {string | string[]} target - File path, directory, or list of paths.
+ * @param {{reload?: boolean}} [options] - Options.
+ * @returns {Promise<string[]>} - The loaded file paths, in load order.
+ */
+export async function loadDefinitions(registry, target, { reload = false } = {}) {
+    const files = await resolveFiles(target);
+    for (const file of files) {
+        let href = pathToFileURL(file).href;
+        if (reload) {
+            reloadCounter += 1;
+            href += `?factoryReload=${reloadCounter}`;
+        }
+        const module = await import(href);
+        if (typeof module.default !== "function") {
+            throw new Error(`Factory definition file ${file} must default-export a (registry) => void function`);
+        }
+        module.default(registry);
+    }
+    return files;
+}
+/**
+ * Fully reloads definitions: resets the registry (dropping every factory, trait,
+ * sequence, callback and default) and re-imports the target files with cache
+ * busting so edited definitions take effect.
+ * @param {import("../factory-registry.js").default} registry - Registry to reload.
+ * @param {string | string[]} target - File path, directory, or list of paths.
+ * @returns {Promise<string[]>} - The reloaded file paths, in load order.
+ */
+export async function reloadDefinitions(registry, target) {
+    registry.reset();
+    return await loadDefinitions(registry, target, { reload: true });
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,73 @@
+/**
+ * SequenceFormatter type. Receives the synchronously-allocated numeric value and
+ * returns the formatted value (optionally asynchronously).
+ * @typedef {(args: {value: number}) => (? | Promise<?>)} SequenceFormatter
+ */
+/**
+ * A numeric counter sequence. Values are allocated and consumed synchronously
+ * before the (possibly async) formatter runs, so a rejected formatter still
+ * advances the counter and concurrent `Promise.all` allocation never collides —
+ * matching FactoryBot's failed-value-consumption behaviour.
+ */
+export default class Sequence {
+    /**
+     * Builds a sequence.
+     * @param {object} args - Options.
+     * @param {string} args.name - Primary sequence name.
+     * @param {number} [args.initial] - First value the sequence yields. Defaults to 1.
+     * @param {SequenceFormatter} [args.formatter] - Optional formatter for the value.
+     * @param {string[]} [args.aliases] - Additional names that share this sequence's state.
+     */
+    constructor({ name, initial, formatter, aliases }: {
+        name: string;
+        initial?: number | undefined;
+        formatter?: SequenceFormatter | undefined;
+        aliases?: string[] | undefined;
+    });
+    /** @type {string} - Primary sequence name. */
+    name: string;
+    /** @type {number} - First value the sequence yields. */
+    initial: number;
+    /** @type {SequenceFormatter | undefined} - Optional value formatter. */
+    formatter: SequenceFormatter | undefined;
+    /** @type {string[]} - Names that share this sequence's counter. */
+    aliases: string[];
+    /** @type {number} - Next value to allocate. */
+    _next: number;
+    /**
+     * Allocates and consumes the next numeric value synchronously.
+     * @returns {number} - The allocated raw value.
+     */
+    _allocate(): number;
+    /**
+     * Advances the sequence and returns the formatted value. The numeric value is
+     * consumed synchronously before awaiting the formatter, so a rejected formatter
+     * still advances the counter.
+     * @returns {Promise<?>} - The formatted value.
+     */
+    next(): Promise<unknown>;
+    /**
+     * Returns the value the next `next()` call will allocate without consuming it.
+     * @returns {number} - The upcoming raw value.
+     */
+    peek(): number;
+    /**
+     * Sets the next value the sequence will allocate.
+     * @param {number} value - Next raw value.
+     * @returns {void}
+     */
+    set(value: number): void;
+    /**
+     * Resets the counter back to its initial value.
+     * @returns {void}
+     */
+    rewind(): void;
+}
+/**
+ * SequenceFormatter type. Receives the synchronously-allocated numeric value and
+ * returns the formatted value (optionally asynchronously).
+ */
+export type SequenceFormatter = (args: {
+    value: number;
+}) => (unknown | Promise<unknown>);
+//# sourceMappingURL=sequence.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sequence.d.ts","sourceRoot":"","sources":["../../../../src/testing/factory/sequence.js"],"names":[],"mappings":"AAEA;;;;GAIG;AAEH;;;;;GAKG;AACH;IACE;;;;;;;OAOG;IACH,mDALG;QAAqB,IAAI,EAAjB,MAAM;QACQ,OAAO;QACI,SAAS;QAClB,OAAO;KACjC,EAgBA;IAdC,8CAA8C;IAC9C,MADW,MAAM,CACD;IAEhB,wDAAwD;IACxD,SADW,MAAM,CACK;IAEtB,wEAAwE;IACxE,WADW,iBAAiB,GAAG,SAAS,CACd;IAE1B,mEAAmE;IACnE,SADW,MAAM,EAAE,CACG;IAEtB,+CAA+C;IAC/C,OADW,MAAM,CACG;IAGtB;;;OAGG;IACH,aAFa,MAAM,CAQlB;IAED;;;;;OAKG;IACH,QAFa,OAAO,CAAC,OAAC,CAAC,CAQtB;IAED;;;OAGG;IACH,QAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,WAHW,MAAM,GACJ,IAAI,CAIhB;IAED;;;OAGG;IACH,UAFa,IAAI,CAIhB;CACF;;;;;gCArFY,CAAC,IAAI,EAAE;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC,KAAK,CAAC,OAAC,GAAG,OAAO,CAAC,OAAC,CAAC,CAAC"}

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

@@ -0,0 +1,78 @@
+// @ts-check
+/**
+ * SequenceFormatter type. Receives the synchronously-allocated numeric value and
+ * returns the formatted value (optionally asynchronously).
+ * @typedef {(args: {value: number}) => (? | Promise<?>)} SequenceFormatter
+ */
+/**
+ * A numeric counter sequence. Values are allocated and consumed synchronously
+ * before the (possibly async) formatter runs, so a rejected formatter still
+ * advances the counter and concurrent `Promise.all` allocation never collides —
+ * matching FactoryBot's failed-value-consumption behaviour.
+ */
+export default class Sequence {
+    /**
+     * Builds a sequence.
+     * @param {object} args - Options.
+     * @param {string} args.name - Primary sequence name.
+     * @param {number} [args.initial] - First value the sequence yields. Defaults to 1.
+     * @param {SequenceFormatter} [args.formatter] - Optional formatter for the value.
+     * @param {string[]} [args.aliases] - Additional names that share this sequence's state.
+     */
+    constructor({ name, initial = 1, formatter, aliases = [] }) {
+        /** @type {string} - Primary sequence name. */
+        this.name = name;
+        /** @type {number} - First value the sequence yields. */
+        this.initial = initial;
+        /** @type {SequenceFormatter | undefined} - Optional value formatter. */
+        this.formatter = formatter;
+        /** @type {string[]} - Names that share this sequence's counter. */
+        this.aliases = aliases;
+        /** @type {number} - Next value to allocate. */
+        this._next = initial;
+    }
+    /**
+     * Allocates and consumes the next numeric value synchronously.
+     * @returns {number} - The allocated raw value.
+     */
+    _allocate() {
+        const value = this._next;
+        this._next += 1;
+        return value;
+    }
+    /**
+     * Advances the sequence and returns the formatted value. The numeric value is
+     * consumed synchronously before awaiting the formatter, so a rejected formatter
+     * still advances the counter.
+     * @returns {Promise<?>} - The formatted value.
+     */
+    async next() {
+        const value = this._allocate();
+        if (!this.formatter)
+            return value;
+        return await this.formatter({ value });
+    }
+    /**
+     * Returns the value the next `next()` call will allocate without consuming it.
+     * @returns {number} - The upcoming raw value.
+     */
+    peek() {
+        return this._next;
+    }
+    /**
+     * Sets the next value the sequence will allocate.
+     * @param {number} value - Next raw value.
+     * @returns {void}
+     */
+    set(value) {
+        this._next = value;
+    }
+    /**
+     * Resets the counter back to its initial value.
+     * @returns {void}
+     */
+    rewind() {
+        this._next = this.initial;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/src/testing/factory/strategies/attributes-for.d.ts

@@ -0,0 +1,21 @@
+/**
+ * The `attributesFor` strategy. It resolves scalar/lazy attributes (and any
+ * transients they depend on) but never initializes the model, runs lifecycle
+ * callbacks, or evaluates/builds declared associations. Transients and
+ * associations are omitted from the returned plain object.
+ */
+export default class AttributesForStrategy extends BaseStrategy {
+    /**
+     * Runs the strategy.
+     * @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.
+     */
+    run({ registry, plan }: {
+        registry: import("../factory-registry.js").default;
+        plan: import("../factory-runner.js").CompiledPlan;
+    }): Promise<Record<string, unknown>>;
+}
+import BaseStrategy from "./base.js";
+//# sourceMappingURL=attributes-for.d.ts.map

package/build/src/testing/factory/strategies/attributes-for.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attributes-for.d.ts","sourceRoot":"","sources":["../../../../../src/testing/factory/strategies/attributes-for.js"],"names":[],"mappings":"AAIA;;;;;GAKG;AACH;IACE;;;;;;OAMG;IACH,wBAJG;QAAuD,QAAQ,EAAvD,OAAO,wBAAwB,EAAE,OAAO;QACU,IAAI,EAAtD,OAAO,sBAAsB,EAAE,YAAY;KACnD,GAAU,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,CAAC,CAMtC;CACF;yBArBwB,WAAW"}

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

@@ -0,0 +1,22 @@
+// @ts-check
+import BaseStrategy from "./base.js";
+/**
+ * The `attributesFor` strategy. It resolves scalar/lazy attributes (and any
+ * transients they depend on) but never initializes the model, runs lifecycle
+ * callbacks, or evaluates/builds declared associations. Transients and
+ * associations are omitted from the returned plain object.
+ */
+export default class AttributesForStrategy extends BaseStrategy {
+    /**
+     * Runs the strategy.
+     * @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.
+     */
+    async run({ registry, plan }) {
+        const context = this._newContext(registry, plan, "attributesFor");
+        return await context.resolveAttributes();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXR0cmlidXRlcy1mb3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvdGVzdGluZy9mYWN0b3J5L3N0cmF0ZWdpZXMvYXR0cmlidXRlcy1mb3IuanMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsWUFBWTtBQUVaLE9BQU8sWUFBWSxNQUFNLFdBQVcsQ0FBQTtBQUVwQzs7Ozs7R0FLRztBQUNILE1BQU0sQ0FBQyxPQUFPLE9BQU8scUJBQXNCLFNBQVEsWUFBWTtJQUM3RDs7Ozs7O09BTUc7SUFDSCxLQUFLLENBQUMsR0FBRyxDQUFDLEVBQUMsUUFBUSxFQUFFLElBQUksRUFBQztRQUN4QixNQUFNLE9BQU8sR0FBRyxJQUFJLENBQUMsV0FBVyxDQUFDLFFBQVEsRUFBRSxJQUFJLEVBQUUsZUFBZSxDQUFDLENBQUE7UUFFakUsT0FBTyxNQUFNLE9BQU8sQ0FBQyxpQkFBaUIsRUFBRSxDQUFBO0lBQzFDLENBQUM7Q0FDRiIsInNvdXJjZXNDb250ZW50IjpbIi8vIEB0cy1jaGVja1xuXG5pbXBvcnQgQmFzZVN0cmF0ZWd5IGZyb20gXCIuL2Jhc2UuanNcIlxuXG4vKipcbiAqIFRoZSBgYXR0cmlidXRlc0ZvcmAgc3RyYXRlZ3kuIEl0IHJlc29sdmVzIHNjYWxhci9sYXp5IGF0dHJpYnV0ZXMgKGFuZCBhbnlcbiAqIHRyYW5zaWVudHMgdGhleSBkZXBlbmQgb24pIGJ1dCBuZXZlciBpbml0aWFsaXplcyB0aGUgbW9kZWwsIHJ1bnMgbGlmZWN5Y2xlXG4gKiBjYWxsYmFja3MsIG9yIGV2YWx1YXRlcy9idWlsZHMgZGVjbGFyZWQgYXNzb2NpYXRpb25zLiBUcmFuc2llbnRzIGFuZFxuICogYXNzb2NpYXRpb25zIGFyZSBvbWl0dGVkIGZyb20gdGhlIHJldHVybmVkIHBsYWluIG9iamVjdC5cbiAqL1xuZXhwb3J0IGRlZmF1bHQgY2xhc3MgQXR0cmlidXRlc0ZvclN0cmF0ZWd5IGV4dGVuZHMgQmFzZVN0cmF0ZWd5IHtcbiAgLyoqXG4gICAqIFJ1bnMgdGhlIHN0cmF0ZWd5LlxuICAgKiBAcGFyYW0ge29iamVjdH0gYXJncyAtIE9wdGlvbnMuXG4gICAqIEBwYXJhbSB7aW1wb3J0KFwiLi4vZmFjdG9yeS1yZWdpc3RyeS5qc1wiKS5kZWZhdWx0fSBhcmdzLnJlZ2lzdHJ5IC0gT3duaW5nIHJlZ2lzdHJ5LlxuICAgKiBAcGFyYW0ge2ltcG9ydChcIi4uL2ZhY3RvcnktcnVubmVyLmpzXCIpLkNvbXBpbGVkUGxhbn0gYXJncy5wbGFuIC0gQ29tcGlsZWQgcGxhbi5cbiAgICogQHJldHVybnMge1Byb21pc2U8UmVjb3JkPHN0cmluZywgPz4+fSAtIFRoZSByZXNvbHZlZCBhdHRyaWJ1dGVzLlxuICAgKi9cbiAgYXN5bmMgcnVuKHtyZWdpc3RyeSwgcGxhbn0pIHtcbiAgICBjb25zdCBjb250ZXh0ID0gdGhpcy5fbmV3Q29udGV4dChyZWdpc3RyeSwgcGxhbiwgXCJhdHRyaWJ1dGVzRm9yXCIpXG5cbiAgICByZXR1cm4gYXdhaXQgY29udGV4dC5yZXNvbHZlQXR0cmlidXRlcygpXG4gIH1cbn1cbiJdfQ==

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

@@ -0,0 +1,101 @@
+/**
+ * Shared behaviour for the build/create/attributesFor strategies: evaluation
+ * context creation, deterministic callback execution, guaranteed `afterAll`
+ * cleanup, record construction (default and `initializeWith`), and association
+ * wiring through public relationship reflection.
+ */
+export default class BaseStrategy {
+    /**
+     * Creates an evaluation context for a plan.
+     * @param {import("../factory-registry.js").default} registry - Owning registry.
+     * @param {import("../factory-runner.js").CompiledPlan} plan - Compiled plan.
+     * @param {"attributesFor" | "build" | "create"} strategyName - Strategy name.
+     * @returns {EvaluationContext} - The context.
+     */
+    _newContext(registry: import("../factory-registry.js").default, plan: import("../factory-runner.js").CompiledPlan, strategyName: "attributesFor" | "build" | "create"): EvaluationContext;
+    /**
+     * 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.
+     */
+    _callbackContext(context: EvaluationContext, transients: Record<string, unknown>): Record<string, unknown>;
+    /**
+     * 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.
+     * @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>;
+        strategy: string;
+    }): Promise<void>;
+    /**
+     * Runs `body`, then guarantees `afterAll` runs in `finally`. When both the body
+     * and cleanup fail, the body's primary error is preserved and the cleanup error
+     * 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.
+     */
+    _runWithAfterAll(context: EvaluationContext, plan: import("../factory-runner.js").CompiledPlan, state: () => {
+        record: unknown;
+        transients: Record<string, unknown>;
+        strategy: string;
+    }, body: () => Promise<unknown>): Promise<unknown>;
+    /**
+     * 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.
+     * @returns {void}
+     */
+    _attachCleanupFailure(primaryError: unknown, cleanupError: unknown): 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 {EvaluationContext} context - Evaluation context.
+     * @param {Record<string, ?>} transients - Evaluated transients.
+     * @returns {Promise<?>} - The constructed record.
+     */
+    _constructRecord(plan: import("../factory-runner.js").CompiledPlan, publicAttributes: Record<string, unknown>, context: EvaluationContext, transients: Record<string, unknown>): Promise<unknown>;
+    /**
+     * 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 {EvaluationContext} context - Evaluation context.
+     * @param {Record<string, ?>} transients - Evaluated transients.
+     * @returns {Promise<?>} - 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>;
+    /**
+     * 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.
+     * @returns {void}
+     */
+    _assignAssociations(record: unknown, associations: Array<{
+        name: string;
+        record: unknown;
+    }>): 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.
+     */
+    _toRecordArray(value: unknown): Array<unknown>;
+}
+import EvaluationContext from "../evaluation-context.js";
+//# sourceMappingURL=base.d.ts.map

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

@@ -0,0 +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"}