velocious 1.0.597 → 1.0.598

package/build/src/testing/factory/node/definition-reload-policy.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Default maximum number of cache-busted factory definition import attempts a
+ * single Node process may perform. Chosen conservatively from the
+ * `factory-esm-reload-retention` benchmark evidence: each cache-busted import
+ * retains roughly 6 KB of heap in Node's ESM module map, so the default bounds
+ * retained definition modules to a few tens of MB before the owning process
+ * must be recycled. This module is intentionally Node-only; browser-safe factory
+ * code must never import it.
+ */
+export declare const DEFAULT_DEFINITION_RELOAD_BUDGET = 4096;
+/**
+ * Rejected when code tries to configure the process-global reload budget more
+ * than once or after any valid cache-busted import reservation was attempted.
+ * Retained ESM modules and their accounting live for the process lifetime, so
+ * changing the budget can never begin a new in-process policy epoch.
+ */
+export declare class DefinitionReloadConfigurationError extends Error {
+    budget: number;
+    configured: boolean;
+    current: number;
+    requestedBudget: number;
+    /**
+     * Creates the error.
+     * @param {object} args - Details.
+     * @param {number} args.current - Cache-busted imports already reserved.
+     * @param {number} args.budget - Active process-global import budget.
+     * @param {number} args.requestedBudget - Rejected replacement budget.
+     * @param {boolean} args.configured - Whether an explicit budget was already configured.
+     */
+    constructor({ budget, configured, current, requestedBudget }: {
+        current: number;
+        budget: number;
+        requestedBudget: number;
+        configured: boolean;
+    });
+}
+/**
+ * Rejected when a reload would push the process over its cache-busted import
+ * budget. The rejection happens synchronously before any registry reset or
+ * import, so the currently loaded registry stays usable. Node never evicts
+ * retained ESM module instances, so only recycling/restarting the owning Node
+ * process reclaims the memory and refreshes edited dependency modules.
+ */
+export declare class DefinitionRecycleRequiredError extends Error {
+    current: number;
+    budget: number;
+    requested: number;
+    /**
+     * Creates the error.
+     * @param {object} args - Details.
+     * @param {number} args.current - Cache-busted import attempts already reserved in this process.
+     * @param {number} args.budget - Process-global import budget.
+     * @param {number} args.requested - Import attempts the rejected reload needed.
+     */
+    constructor({ current, budget, requested }: {
+        current: number;
+        budget: number;
+        requested: number;
+    });
+}
+/**
+ * Returns the process-global cache-busted import budget.
+ * @returns {number} - The budget.
+ */
+export declare function getDefinitionReloadBudget(): number;
+/**
+ * Reads the cache-busted import attempts reserved so far in this process,
+ * across every registry and target. Combined with {@link getDefinitionReloadBudget}
+ * this is the deterministic process-global census for the recycle policy.
+ * @returns {number} - Reserved count.
+ */
+export declare function peekDefinitionReloadBudget(): number;
+/**
+ * Configures the one process-global import budget exactly once and only before
+ * the first valid reservation attempt. There is exactly one budget for the whole
+ * process, so no combination of registries or targets can create independent
+ * budgets that defeat the global limit. Retained-import accounting is never
+ * reset in-process.
+ * @param {number} budget - New budget.
+ * @returns {void}
+ */
+export declare function setDefinitionReloadBudget(budget: number): void;
+/**
+ * Preflights and reserves a whole reload batch synchronously. Malformed counts
+ * are rejected before configuration is sealed or accounting changes. Every valid
+ * request, including zero and a rejected over-budget request, seals configuration
+ * before capacity is evaluated. Throws {@link DefinitionRecycleRequiredError}
+ * when the requested batch would push the process over its budget. The check and
+ * reservation run in one synchronous step, so concurrent reloads cannot race past
+ * the budget. The reservation is deliberately conservative: it covers every
+ * import attempt in the batch, so a mid-batch import failure still counts its
+ * attempts as retained modules.
+ * @param {number} requested - Cache-busted import attempts the reload will perform.
+ * @returns {void}
+ */
+export declare function reserveDefinitionReloadBudget(requested: number): void;
+//# sourceMappingURL=definition-reload-policy.d.ts.map

package/build/src/testing/factory/node/definition-reload-policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition-reload-policy.d.ts","sourceRoot":"","sources":["../../../../../src/testing/factory/node/definition-reload-policy.js"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,eAAO,MAAM,gCAAgC,OAAO,CAAA;AAEpD;;;;;GAKG;AACH,qBAAa,kCAAmC,SAAQ,KAAK;IAgBpD,MAAM;IACN,UAAU;IACV,OAAO;IACP,eAAe;IAlBtB;;;;;;;OAOG;IACH,YAAY,EAAC,MAAM,EAAE,UAAU,EAAE,OAAO,EAAE,eAAe,EAAC,EALvD;QAAqB,OAAO,EAApB,MAAM,CACd;QAAqB,MAAM,EAAnB,MAAM,CACd;QAAqB,eAAe,EAA5B,MAAM,CACd;QAAsB,UAAU,EAAxB,OAAO,CACjB;KACyD,EAWzD;CACF;AAED;;;;;;GAMG;AACH,qBAAa,8BAA+B,SAAQ,KAAK;IAWhD,OAAO;IACP,MAAM;IACN,SAAS;IAZhB;;;;;;OAMG;IACH,YAAY,EAAC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAC,EAJrC;QAAqB,OAAO,EAApB,MAAM,CACd;QAAqB,MAAM,EAAnB,MAAM,CACd;QAAqB,SAAS,EAAtB,MAAM,CAChB;KACuC,EAMvC;CACF;AAcD;;;GAGG;AACH,wBAAgB,yBAAyB,IAF5B,MAAM,CAIlB;AAED;;;;;GAKG;AACH,wBAAgB,0BAA0B,IAF7B,MAAM,CAIlB;AAED;;;;;;;;GAQG;AACH,wBAAgB,yBAAyB,CAAC,MAAM,EAHrC,MAGqC,GAFnC,IAAI,CAkBhB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,6BAA6B,CAAC,SAAS,EAH5C,MAG4C,GAF1C,IAAI,CAchB"}

package/build/src/testing/factory/node/definition-reload-policy.js

@@ -0,0 +1,133 @@
+// @ts-check
+/**
+ * Default maximum number of cache-busted factory definition import attempts a
+ * single Node process may perform. Chosen conservatively from the
+ * `factory-esm-reload-retention` benchmark evidence: each cache-busted import
+ * retains roughly 6 KB of heap in Node's ESM module map, so the default bounds
+ * retained definition modules to a few tens of MB before the owning process
+ * must be recycled. This module is intentionally Node-only; browser-safe factory
+ * code must never import it.
+ */
+export const DEFAULT_DEFINITION_RELOAD_BUDGET = 4096;
+/**
+ * Rejected when code tries to configure the process-global reload budget more
+ * than once or after any valid cache-busted import reservation was attempted.
+ * Retained ESM modules and their accounting live for the process lifetime, so
+ * changing the budget can never begin a new in-process policy epoch.
+ */
+export class DefinitionReloadConfigurationError extends Error {
+    /**
+     * Creates the error.
+     * @param {object} args - Details.
+     * @param {number} args.current - Cache-busted imports already reserved.
+     * @param {number} args.budget - Active process-global import budget.
+     * @param {number} args.requestedBudget - Rejected replacement budget.
+     * @param {boolean} args.configured - Whether an explicit budget was already configured.
+     */
+    constructor({ budget, configured, current, requestedBudget }) {
+        const reason = configured
+            ? "the process-global definition reload budget was already configured"
+            : "a definition reload reservation was already attempted";
+        super(`Cannot configure definition reload budget to ${requestedBudget}: ${reason} (current=${current}, budget=${budget}). Configuration is allowed exactly once before the first reservation; only process exit resets retained-module accounting.`);
+        this.name = "DefinitionReloadConfigurationError";
+        this.budget = budget;
+        this.configured = configured;
+        this.current = current;
+        this.requestedBudget = requestedBudget;
+    }
+}
+/**
+ * Rejected when a reload would push the process over its cache-busted import
+ * budget. The rejection happens synchronously before any registry reset or
+ * import, so the currently loaded registry stays usable. Node never evicts
+ * retained ESM module instances, so only recycling/restarting the owning Node
+ * process reclaims the memory and refreshes edited dependency modules.
+ */
+export class DefinitionRecycleRequiredError extends Error {
+    /**
+     * Creates the error.
+     * @param {object} args - Details.
+     * @param {number} args.current - Cache-busted import attempts already reserved in this process.
+     * @param {number} args.budget - Process-global import budget.
+     * @param {number} args.requested - Import attempts the rejected reload needed.
+     */
+    constructor({ current, budget, requested }) {
+        super(`Factory definition reload import budget exhausted (current=${current}, budget=${budget}, requested=${requested}). Recycle or restart the owning Node process: every reload imports a fresh cache-busted module instance and Node never evicts them, so process recycling is the only reclamation boundary.`);
+        this.name = "DefinitionRecycleRequiredError";
+        this.current = current;
+        this.budget = budget;
+        this.requested = requested;
+    }
+}
+/** @type {number} - The single process-global import budget. */
+let importBudget = DEFAULT_DEFINITION_RELOAD_BUDGET;
+/** @type {number} - Cache-busted import attempts reserved so far across every registry and target. */
+let reservedImports = 0;
+/** @type {boolean} - Whether the process-global budget was explicitly configured. */
+let budgetConfigured = false;
+/** @type {boolean} - Whether any valid complete reload batch reservation was attempted. */
+let reservationStarted = false;
+/**
+ * Returns the process-global cache-busted import budget.
+ * @returns {number} - The budget.
+ */
+export function getDefinitionReloadBudget() {
+    return importBudget;
+}
+/**
+ * Reads the cache-busted import attempts reserved so far in this process,
+ * across every registry and target. Combined with {@link getDefinitionReloadBudget}
+ * this is the deterministic process-global census for the recycle policy.
+ * @returns {number} - Reserved count.
+ */
+export function peekDefinitionReloadBudget() {
+    return reservedImports;
+}
+/**
+ * Configures the one process-global import budget exactly once and only before
+ * the first valid reservation attempt. There is exactly one budget for the whole
+ * process, so no combination of registries or targets can create independent
+ * budgets that defeat the global limit. Retained-import accounting is never
+ * reset in-process.
+ * @param {number} budget - New budget.
+ * @returns {void}
+ */
+export function setDefinitionReloadBudget(budget) {
+    if (!Number.isInteger(budget) || budget < 1) {
+        throw new TypeError(`Definition reload budget must be a positive integer, got ${JSON.stringify(budget)}`);
+    }
+    if (budgetConfigured || reservationStarted) {
+        throw new DefinitionReloadConfigurationError({
+            budget: importBudget,
+            configured: budgetConfigured,
+            current: reservedImports,
+            requestedBudget: budget
+        });
+    }
+    importBudget = budget;
+    budgetConfigured = true;
+}
+/**
+ * Preflights and reserves a whole reload batch synchronously. Malformed counts
+ * are rejected before configuration is sealed or accounting changes. Every valid
+ * request, including zero and a rejected over-budget request, seals configuration
+ * before capacity is evaluated. Throws {@link DefinitionRecycleRequiredError}
+ * when the requested batch would push the process over its budget. The check and
+ * reservation run in one synchronous step, so concurrent reloads cannot race past
+ * the budget. The reservation is deliberately conservative: it covers every
+ * import attempt in the batch, so a mid-batch import failure still counts its
+ * attempts as retained modules.
+ * @param {number} requested - Cache-busted import attempts the reload will perform.
+ * @returns {void}
+ */
+export function reserveDefinitionReloadBudget(requested) {
+    if (!Number.isInteger(requested) || requested < 0) {
+        throw new TypeError(`Definition reload reservation must be a non-negative integer, got ${typeof requested} ${String(requested)}`);
+    }
+    reservationStarted = true;
+    if (reservedImports + requested > importBudget) {
+        throw new DefinitionRecycleRequiredError({ current: reservedImports, budget: importBudget, requested });
+    }
+    reservedImports += requested;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"definition-reload-policy.js","sourceRoot":"","sources":["../../../../../src/testing/factory/node/definition-reload-policy.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\n/**\n * Default maximum number of cache-busted factory definition import attempts a\n * single Node process may perform. Chosen conservatively from the\n * `factory-esm-reload-retention` benchmark evidence: each cache-busted import\n * retains roughly 6 KB of heap in Node's ESM module map, so the default bounds\n * retained definition modules to a few tens of MB before the owning process\n * must be recycled. This module is intentionally Node-only; browser-safe factory\n * code must never import it.\n */\nexport const DEFAULT_DEFINITION_RELOAD_BUDGET = 4096\n\n/**\n * Rejected when code tries to configure the process-global reload budget more\n * than once or after any valid cache-busted import reservation was attempted.\n * Retained ESM modules and their accounting live for the process lifetime, so\n * changing the budget can never begin a new in-process policy epoch.\n */\nexport class DefinitionReloadConfigurationError extends Error {\n  /**\n   * Creates the error.\n   * @param {object} args - Details.\n   * @param {number} args.current - Cache-busted imports already reserved.\n   * @param {number} args.budget - Active process-global import budget.\n   * @param {number} args.requestedBudget - Rejected replacement budget.\n   * @param {boolean} args.configured - Whether an explicit budget was already configured.\n   */\n  constructor({budget, configured, current, requestedBudget}) {\n    const reason = configured\n      ? \"the process-global definition reload budget was already configured\"\n      : \"a definition reload reservation was already attempted\"\n\n    super(`Cannot configure definition reload budget to ${requestedBudget}: ${reason} (current=${current}, budget=${budget}). Configuration is allowed exactly once before the first reservation; only process exit resets retained-module accounting.`)\n    this.name = \"DefinitionReloadConfigurationError\"\n    this.budget = budget\n    this.configured = configured\n    this.current = current\n    this.requestedBudget = requestedBudget\n  }\n}\n\n/**\n * Rejected when a reload would push the process over its cache-busted import\n * budget. The rejection happens synchronously before any registry reset or\n * import, so the currently loaded registry stays usable. Node never evicts\n * retained ESM module instances, so only recycling/restarting the owning Node\n * process reclaims the memory and refreshes edited dependency modules.\n */\nexport class DefinitionRecycleRequiredError extends Error {\n  /**\n   * Creates the error.\n   * @param {object} args - Details.\n   * @param {number} args.current - Cache-busted import attempts already reserved in this process.\n   * @param {number} args.budget - Process-global import budget.\n   * @param {number} args.requested - Import attempts the rejected reload needed.\n   */\n  constructor({current, budget, requested}) {\n    super(`Factory definition reload import budget exhausted (current=${current}, budget=${budget}, requested=${requested}). Recycle or restart the owning Node process: every reload imports a fresh cache-busted module instance and Node never evicts them, so process recycling is the only reclamation boundary.`)\n    this.name = \"DefinitionRecycleRequiredError\"\n    this.current = current\n    this.budget = budget\n    this.requested = requested\n  }\n}\n\n/** @type {number} - The single process-global import budget. */\nlet importBudget = DEFAULT_DEFINITION_RELOAD_BUDGET\n\n/** @type {number} - Cache-busted import attempts reserved so far across every registry and target. */\nlet reservedImports = 0\n\n/** @type {boolean} - Whether the process-global budget was explicitly configured. */\nlet budgetConfigured = false\n\n/** @type {boolean} - Whether any valid complete reload batch reservation was attempted. */\nlet reservationStarted = false\n\n/**\n * Returns the process-global cache-busted import budget.\n * @returns {number} - The budget.\n */\nexport function getDefinitionReloadBudget() {\n  return importBudget\n}\n\n/**\n * Reads the cache-busted import attempts reserved so far in this process,\n * across every registry and target. Combined with {@link getDefinitionReloadBudget}\n * this is the deterministic process-global census for the recycle policy.\n * @returns {number} - Reserved count.\n */\nexport function peekDefinitionReloadBudget() {\n  return reservedImports\n}\n\n/**\n * Configures the one process-global import budget exactly once and only before\n * the first valid reservation attempt. There is exactly one budget for the whole\n * process, so no combination of registries or targets can create independent\n * budgets that defeat the global limit. Retained-import accounting is never\n * reset in-process.\n * @param {number} budget - New budget.\n * @returns {void}\n */\nexport function setDefinitionReloadBudget(budget) {\n  if (!Number.isInteger(budget) || budget < 1) {\n    throw new TypeError(`Definition reload budget must be a positive integer, got ${JSON.stringify(budget)}`)\n  }\n\n  if (budgetConfigured || reservationStarted) {\n    throw new DefinitionReloadConfigurationError({\n      budget: importBudget,\n      configured: budgetConfigured,\n      current: reservedImports,\n      requestedBudget: budget\n    })\n  }\n\n  importBudget = budget\n  budgetConfigured = true\n}\n\n/**\n * Preflights and reserves a whole reload batch synchronously. Malformed counts\n * are rejected before configuration is sealed or accounting changes. Every valid\n * request, including zero and a rejected over-budget request, seals configuration\n * before capacity is evaluated. Throws {@link DefinitionRecycleRequiredError}\n * when the requested batch would push the process over its budget. The check and\n * reservation run in one synchronous step, so concurrent reloads cannot race past\n * the budget. The reservation is deliberately conservative: it covers every\n * import attempt in the batch, so a mid-batch import failure still counts its\n * attempts as retained modules.\n * @param {number} requested - Cache-busted import attempts the reload will perform.\n * @returns {void}\n */\nexport function reserveDefinitionReloadBudget(requested) {\n  if (!Number.isInteger(requested) || requested < 0) {\n    throw new TypeError(`Definition reload reservation must be a non-negative integer, got ${typeof requested} ${String(requested)}`)\n  }\n\n  reservationStarted = true\n\n  if (reservedImports + requested > importBudget) {\n    throw new DefinitionRecycleRequiredError({current: reservedImports, budget: importBudget, requested})\n  }\n\n  reservedImports += requested\n}\n"]}

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

@@ -15,7 +15,10 @@ export declare function loadDefinitions(registry: import("../factory-registry.js
 /**
  * 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.
+ * busting so edited definitions take effect. The resolved batch is preflighted
+ * against the process-global import budget before the reset, and a
+ * `DefinitionRecycleRequiredError` is raised before any mutation when the batch
+ * would exceed the budget.
  * @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.

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

@@ -1 +1 @@
-{"version":3,"file":"load-definitions.d.ts","sourceRoot":"","sources":["../../../../../src/testing/factory/node/load-definitions.js"],"names":[],"mappings":"AAwDA;;;;;;;;;;GAUG;AACH,wBAAsB,eAAe,CAAC,QAAQ,EALnC,OAAO,wBAAwB,EAAE,OAKE,EAAE,MAAM,EAJ3C,MAAM,GAAG,MAAM,EAI4B,EAAE,EAAC,MAAc,EAAC,AAHrE,CACA,EADQ;IAAC,MAAM,CAAC,EAAE,OAAO,CAAA;CAGiD,GAFhE,OAAO,CAAC,MAAM,EAAE,CAAC,CAuB7B;AAED;;;;;;;GAOG;AACH,wBAAsB,iBAAiB,CAAC,QAAQ,EAJrC,OAAO,wBAAwB,EAAE,OAII,EAAE,MAAM,EAH7C,MAAM,GAAG,MAAM,EAG8B,GAF3C,OAAO,CAAC,MAAM,EAAE,CAAC,CAM7B"}
+{"version":3,"file":"load-definitions.d.ts","sourceRoot":"","sources":["../../../../../src/testing/factory/node/load-definitions.js"],"names":[],"mappings":"AAyDA;;;;;;;;;;GAUG;AACH,wBAAsB,eAAe,CAAC,QAAQ,EALnC,OAAO,wBAAwB,EAAE,OAKE,EAAE,MAAM,EAJ3C,MAAM,GAAG,MAAM,EAI4B,EAAE,EAAC,MAAc,EAAC,AAHrE,CACA,EADQ;IAAC,MAAM,CAAC,EAAE,OAAO,CAAA;CAGiD,GAFhE,OAAO,CAAC,MAAM,EAAE,CAAC,CAM7B;AAuCD;;;;;;;;;;GAUG;AACH,wBAAsB,iBAAiB,CAAC,QAAQ,EAJrC,OAAO,wBAAwB,EAAE,OAII,EAAE,MAAM,EAH7C,MAAM,GAAG,MAAM,EAG8B,GAF3C,OAAO,CAAC,MAAM,EAAE,CAAC,CAM7B"}

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

@@ -2,6 +2,7 @@
 import { pathToFileURL } from "node:url";
 import { readdir, stat } from "node:fs/promises";
 import path from "node:path";
+import { reserveDefinitionReloadBudget } from "./definition-reload-policy.js";
 /**
  * Monotonic cache-busting counter shared by reloads. Kept module-local so a reload
  * imports a fresh module instance rather than the cached one.
@@ -58,6 +59,25 @@ async function resolveFiles(target) {
  */
 export async function loadDefinitions(registry, target, { reload = false } = {}) {
     const files = await resolveFiles(target);
+    return await loadResolvedDefinitionFiles({ files, registry, reload });
+}
+/**
+ * Loads definition files that have already been resolved into a deterministic
+ * sorted list. When `reload` is set, the whole batch is preflighted and reserved
+ * against the process-global import budget before any registry reset or import
+ * attempt, so a rejected reload never mutates the registry.
+ * @param {object} args - Options object.
+ * @param {string[]} args.files - Resolved, sorted definition file paths.
+ * @param {import("../factory-registry.js").default} args.registry - Registry to define into.
+ * @param {boolean} args.reload - Whether to cache-bust the imports.
+ * @param {boolean} [args.reset] - Whether to reset the registry first.
+ * @returns {Promise<string[]>} - The loaded file paths, in load order.
+ */
+async function loadResolvedDefinitionFiles({ files, registry, reload, reset = false }) {
+    if (reload)
+        reserveDefinitionReloadBudget(files.length);
+    if (reset)
+        registry.reset();
     for (const file of files) {
         let href = pathToFileURL(file).href;
         if (reload) {
@@ -75,13 +95,16 @@ export async function loadDefinitions(registry, target, { reload = false } = {})
 /**
  * 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.
+ * busting so edited definitions take effect. The resolved batch is preflighted
+ * against the process-global import budget before the reset, and a
+ * `DefinitionRecycleRequiredError` is raised before any mutation when the batch
+ * would exceed the budget.
  * @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 });
+    const files = await resolveFiles(target);
+    return await loadResolvedDefinitionFiles({ files, registry, reload: true, reset: true });
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9hZC1kZWZpbml0aW9ucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy90ZXN0aW5nL2ZhY3Rvcnkvbm9kZS9sb2FkLWRlZmluaXRpb25zLmpzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLFlBQVk7QUFFWixPQUFPLEVBQUMsYUFBYSxFQUFDLE1BQU0sVUFBVSxDQUFBO0FBQ3RDLE9BQU8sRUFBQyxPQUFPLEVBQUUsSUFBSSxFQUFDLE1BQU0sa0JBQWtCLENBQUE7QUFDOUMsT0FBTyxJQUFJLE1BQU0sV0FBVyxDQUFBO0FBRTVCOzs7O0dBSUc7QUFDSCxJQUFJLGFBQWEsR0FBRyxDQUFDLENBQUE7QUFFckI7Ozs7O0dBS0c7QUFDSCxLQUFLLFVBQVUscUJBQXFCLENBQUMsU0FBUztJQUM1QyxNQUFNLE9BQU8sR0FBRyxNQUFNLE9BQU8sQ0FBQyxTQUFTLEVBQUUsRUFBQyxhQUFhLEVBQUUsSUFBSSxFQUFDLENBQUMsQ0FBQTtJQUMvRCx1QkFBdUI7SUFDdkIsTUFBTSxLQUFLLEdBQUcsRUFBRSxDQUFBO0lBRWhCLEtBQUssTUFBTSxLQUFLLElBQUksQ0FBQyxHQUFHLE9BQU8sQ0FBQyxDQUFDLElBQUksQ0FBQyxDQUFDLElBQUksRUFBRSxLQUFLLEVBQUUsRUFBRSxDQUFDLENBQUMsSUFBSSxDQUFDLElBQUksR0FBRyxLQUFLLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDO1FBQzFGLE1BQU0sUUFBUSxHQUFHLElBQUksQ0FBQyxJQUFJLENBQUMsU0FBUyxFQUFFLEtBQUssQ0FBQyxJQUFJLENBQUMsQ0FBQTtRQUVqRCxJQUFJLEtBQUssQ0FBQyxXQUFXLEVBQUUsRUFBRSxDQUFDO1lBQ3hCLEtBQUssQ0FBQyxJQUFJLENBQUMsR0FBRyxNQUFNLHFCQUFxQixDQUFDLFFBQVEsQ0FBQyxDQUFDLENBQUE7UUFDdEQsQ0FBQzthQUFNLElBQUksS0FBSyxDQUFDLElBQUksQ0FBQyxRQUFRLENBQUMsS0FBSyxDQUFDLEVBQUUsQ0FBQztZQUN0QyxLQUFLLENBQUMsSUFBSSxDQUFDLFFBQVEsQ0FBQyxDQUFBO1FBQ3RCLENBQUM7SUFDSCxDQUFDO0lBRUQsT0FBTyxLQUFLLENBQUE7QUFDZCxDQUFDO0FBRUQ7Ozs7O0dBS0c7QUFDSCxLQUFLLFVBQVUsWUFBWSxDQUFDLE1BQU07SUFDaEMsSUFBSSxLQUFLLENBQUMsT0FBTyxDQUFDLE1BQU0sQ0FBQyxFQUFFLENBQUM7UUFDMUIsT0FBTyxDQUFDLEdBQUcsSUFBSSxHQUFHLENBQUMsTUFBTSxDQUFDLEdBQUcsQ0FBQyxDQUFDLEtBQUssRUFBRSxFQUFFLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxJQUFJLEVBQUUsQ0FBQTtJQUN4RSxDQUFDO0lBRUQsTUFBTSxRQUFRLEdBQUcsSUFBSSxDQUFDLE9BQU8sQ0FBQyxNQUFNLENBQUMsQ0FBQTtJQUNyQyxNQUFNLEtBQUssR0FBRyxNQUFNLElBQUksQ0FBQyxRQUFRLENBQUMsQ0FBQTtJQUVsQyxJQUFJLEtBQUssQ0FBQyxXQUFXLEVBQUU7UUFBRSxPQUFPLE1BQU0scUJBQXFCLENBQUMsUUFBUSxDQUFDLENBQUE7SUFFckUsT0FBTyxDQUFDLFFBQVEsQ0FBQyxDQUFBO0FBQ25CLENBQUM7QUFFRDs7Ozs7Ozs7OztHQVVHO0FBQ0gsTUFBTSxDQUFDLEtBQUssVUFBVSxlQUFlLENBQUMsUUFBUSxFQUFFLE1BQU0sRUFBRSxFQUFDLE1BQU0sR0FBRyxLQUFLLEVBQUMsR0FBRyxFQUFFO0lBQzNFLE1BQU0sS0FBSyxHQUFHLE1BQU0sWUFBWSxDQUFDLE1BQU0sQ0FBQyxDQUFBO0lBRXhDLEtBQUssTUFBTSxJQUFJLElBQUksS0FBSyxFQUFFLENBQUM7UUFDekIsSUFBSSxJQUFJLEdBQUcsYUFBYSxDQUFDLElBQUksQ0FBQyxDQUFDLElBQUksQ0FBQTtRQUVuQyxJQUFJLE1BQU0sRUFBRSxDQUFDO1lBQ1gsYUFBYSxJQUFJLENBQUMsQ0FBQTtZQUNsQixJQUFJLElBQUksa0JBQWtCLGFBQWEsRUFBRSxDQUFBO1FBQzNDLENBQUM7UUFFRCxNQUFNLE1BQU0sR0FBRyxNQUFNLE1BQU0sQ0FBQyxJQUFJLENBQUMsQ0FBQTtRQUVqQyxJQUFJLE9BQU8sTUFBTSxDQUFDLE9BQU8sS0FBSyxVQUFVLEVBQUUsQ0FBQztZQUN6QyxNQUFNLElBQUksS0FBSyxDQUFDLDJCQUEyQixJQUFJLG9EQUFvRCxDQUFDLENBQUE7UUFDdEcsQ0FBQztRQUVELE1BQU0sQ0FBQyxPQUFPLENBQUMsUUFBUSxDQUFDLENBQUE7SUFDMUIsQ0FBQztJQUVELE9BQU8sS0FBSyxDQUFBO0FBQ2QsQ0FBQztBQUVEOzs7Ozs7O0dBT0c7QUFDSCxNQUFNLENBQUMsS0FBSyxVQUFVLGlCQUFpQixDQUFDLFFBQVEsRUFBRSxNQUFNO0lBQ3RELFFBQVEsQ0FBQyxLQUFLLEVBQUUsQ0FBQTtJQUVoQixPQUFPLE1BQU0sZUFBZSxDQUFDLFFBQVEsRUFBRSxNQUFNLEVBQUUsRUFBQyxNQUFNLEVBQUUsSUFBSSxFQUFDLENBQUMsQ0FBQTtBQUNoRSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLy8gQHRzLWNoZWNrXG5cbmltcG9ydCB7cGF0aFRvRmlsZVVSTH0gZnJvbSBcIm5vZGU6dXJsXCJcbmltcG9ydCB7cmVhZGRpciwgc3RhdH0gZnJvbSBcIm5vZGU6ZnMvcHJvbWlzZXNcIlxuaW1wb3J0IHBhdGggZnJvbSBcIm5vZGU6cGF0aFwiXG5cbi8qKlxuICogTW9ub3RvbmljIGNhY2hlLWJ1c3RpbmcgY291bnRlciBzaGFyZWQgYnkgcmVsb2Fkcy4gS2VwdCBtb2R1bGUtbG9jYWwgc28gYSByZWxvYWRcbiAqIGltcG9ydHMgYSBmcmVzaCBtb2R1bGUgaW5zdGFuY2UgcmF0aGVyIHRoYW4gdGhlIGNhY2hlZCBvbmUuXG4gKiBAdHlwZSB7bnVtYmVyfVxuICovXG5sZXQgcmVsb2FkQ291bnRlciA9IDBcblxuLyoqXG4gKiBSZWN1cnNpdmVseSBjb2xsZWN0cyBgLmpzYCBmaWxlcyB1bmRlciBhIGRpcmVjdG9yeSBpbiBhIGRldGVybWluaXN0aWNcbiAqIChsZXhpY29ncmFwaGljYWxseSBzb3J0ZWQpIG9yZGVyLlxuICogQHBhcmFtIHtzdHJpbmd9IGRpcmVjdG9yeSAtIERpcmVjdG9yeSB0byBzY2FuLlxuICogQHJldHVybnMge1Byb21pc2U8c3RyaW5nW10+fSAtIFNvcnRlZCBhYnNvbHV0ZSBmaWxlIHBhdGhzLlxuICovXG5hc3luYyBmdW5jdGlvbiBjb2xsZWN0RGlyZWN0b3J5RmlsZXMoZGlyZWN0b3J5KSB7XG4gIGNvbnN0IGVudHJpZXMgPSBhd2FpdCByZWFkZGlyKGRpcmVjdG9yeSwge3dpdGhGaWxlVHlwZXM6IHRydWV9KVxuICAvKiogQHR5cGUge3N0cmluZ1tdfSAqL1xuICBjb25zdCBmaWxlcyA9IFtdXG5cbiAgZm9yIChjb25zdCBlbnRyeSBvZiBbLi4uZW50cmllc10uc29ydCgobGVmdCwgcmlnaHQpID0+IChsZWZ0Lm5hbWUgPCByaWdodC5uYW1lID8gLTEgOiAxKSkpIHtcbiAgICBjb25zdCBmdWxsUGF0aCA9IHBhdGguam9pbihkaXJlY3RvcnksIGVudHJ5Lm5hbWUpXG5cbiAgICBpZiAoZW50cnkuaXNEaXJlY3RvcnkoKSkge1xuICAgICAgZmlsZXMucHVzaCguLi5hd2FpdCBjb2xsZWN0RGlyZWN0b3J5RmlsZXMoZnVsbFBhdGgpKVxuICAgIH0gZWxzZSBpZiAoZW50cnkubmFtZS5lbmRzV2l0aChcIi5qc1wiKSkge1xuICAgICAgZmlsZXMucHVzaChmdWxsUGF0aClcbiAgICB9XG4gIH1cblxuICByZXR1cm4gZmlsZXNcbn1cblxuLyoqXG4gKiBSZXNvbHZlcyBhIGxvYWQgdGFyZ2V0IChhIHNpbmdsZSBmaWxlLCBhIGRpcmVjdG9yeSwgb3IgYW4gZXhwbGljaXQgbGlzdCkgaW50byBhXG4gKiBkZXRlcm1pbmlzdGljLCBkZS1kdXBsaWNhdGVkIGxpc3Qgb2YgYWJzb2x1dGUgZGVmaW5pdGlvbiBmaWxlIHBhdGhzLlxuICogQHBhcmFtIHtzdHJpbmcgfCBzdHJpbmdbXX0gdGFyZ2V0IC0gRmlsZSBwYXRoLCBkaXJlY3RvcnksIG9yIGxpc3Qgb2YgcGF0aHMuXG4gKiBAcmV0dXJucyB7UHJvbWlzZTxzdHJpbmdbXT59IC0gU29ydGVkLCBkZS1kdXBsaWNhdGVkIGFic29sdXRlIGZpbGUgcGF0aHMuXG4gKi9cbmFzeW5jIGZ1bmN0aW9uIHJlc29sdmVGaWxlcyh0YXJnZXQpIHtcbiAgaWYgKEFycmF5LmlzQXJyYXkodGFyZ2V0KSkge1xuICAgIHJldHVybiBbLi4ubmV3IFNldCh0YXJnZXQubWFwKChlbnRyeSkgPT4gcGF0aC5yZXNvbHZlKGVudHJ5KSkpXS5zb3J0KClcbiAgfVxuXG4gIGNvbnN0IHJlc29sdmVkID0gcGF0aC5yZXNvbHZlKHRhcmdldClcbiAgY29uc3Qgc3RhdHMgPSBhd2FpdCBzdGF0KHJlc29sdmVkKVxuXG4gIGlmIChzdGF0cy5pc0RpcmVjdG9yeSgpKSByZXR1cm4gYXdhaXQgY29sbGVjdERpcmVjdG9yeUZpbGVzKHJlc29sdmVkKVxuXG4gIHJldHVybiBbcmVzb2x2ZWRdXG59XG5cbi8qKlxuICogTG9hZHMgVmVsb2Npb3VzIGZhY3RvcnkgZGVmaW5pdGlvbiBmaWxlcyAoTm9kZSBvbmx5KS4gRWFjaCBmaWxlIG11c3RcbiAqIGRlZmF1bHQtZXhwb3J0IGEgYChyZWdpc3RyeSkgPT4gdm9pZGAgZnVuY3Rpb24gdGhhdCBkZWZpbmVzIGludG8gdGhlIHJlZ2lzdHJ5LlxuICogRmlsZXMgbG9hZCBpbiBkZXRlcm1pbmlzdGljIHBhdGggb3JkZXIuIFRoaXMgbW9kdWxlIGlzIGludGVudGlvbmFsbHkgTm9kZS1vbmx5XG4gKiAoZmlsZXN5c3RlbSArIGR5bmFtaWMgaW1wb3J0KSBhbmQgbXVzdCBuZXZlciBiZSBpbXBvcnRlZCBmcm9tIGJyb3dzZXIvTWV0cm9cbiAqIGJ1bmRsZXM7IGltcG9ydCB0aGUgYnJvd3Nlci1zYWZlIGNvcmUgZnJvbSBgLi4vaW5kZXguanNgIHRoZXJlIGluc3RlYWQuXG4gKiBAcGFyYW0ge2ltcG9ydChcIi4uL2ZhY3RvcnktcmVnaXN0cnkuanNcIikuZGVmYXVsdH0gcmVnaXN0cnkgLSBSZWdpc3RyeSB0byBkZWZpbmUgaW50by5cbiAqIEBwYXJhbSB7c3RyaW5nIHwgc3RyaW5nW119IHRhcmdldCAtIEZpbGUgcGF0aCwgZGlyZWN0b3J5LCBvciBsaXN0IG9mIHBhdGhzLlxuICogQHBhcmFtIHt7cmVsb2FkPzogYm9vbGVhbn19IFtvcHRpb25zXSAtIE9wdGlvbnMuXG4gKiBAcmV0dXJucyB7UHJvbWlzZTxzdHJpbmdbXT59IC0gVGhlIGxvYWRlZCBmaWxlIHBhdGhzLCBpbiBsb2FkIG9yZGVyLlxuICovXG5leHBvcnQgYXN5bmMgZnVuY3Rpb24gbG9hZERlZmluaXRpb25zKHJlZ2lzdHJ5LCB0YXJnZXQsIHtyZWxvYWQgPSBmYWxzZX0gPSB7fSkge1xuICBjb25zdCBmaWxlcyA9IGF3YWl0IHJlc29sdmVGaWxlcyh0YXJnZXQpXG5cbiAgZm9yIChjb25zdCBmaWxlIG9mIGZpbGVzKSB7XG4gICAgbGV0IGhyZWYgPSBwYXRoVG9GaWxlVVJMKGZpbGUpLmhyZWZcblxuICAgIGlmIChyZWxvYWQpIHtcbiAgICAgIHJlbG9hZENvdW50ZXIgKz0gMVxuICAgICAgaHJlZiArPSBgP2ZhY3RvcnlSZWxvYWQ9JHtyZWxvYWRDb3VudGVyfWBcbiAgICB9XG5cbiAgICBjb25zdCBtb2R1bGUgPSBhd2FpdCBpbXBvcnQoaHJlZilcblxuICAgIGlmICh0eXBlb2YgbW9kdWxlLmRlZmF1bHQgIT09IFwiZnVuY3Rpb25cIikge1xuICAgICAgdGhyb3cgbmV3IEVycm9yKGBGYWN0b3J5IGRlZmluaXRpb24gZmlsZSAke2ZpbGV9IG11c3QgZGVmYXVsdC1leHBvcnQgYSAocmVnaXN0cnkpID0+IHZvaWQgZnVuY3Rpb25gKVxuICAgIH1cblxuICAgIG1vZHVsZS5kZWZhdWx0KHJlZ2lzdHJ5KVxuICB9XG5cbiAgcmV0dXJuIGZpbGVzXG59XG5cbi8qKlxuICogRnVsbHkgcmVsb2FkcyBkZWZpbml0aW9uczogcmVzZXRzIHRoZSByZWdpc3RyeSAoZHJvcHBpbmcgZXZlcnkgZmFjdG9yeSwgdHJhaXQsXG4gKiBzZXF1ZW5jZSwgY2FsbGJhY2sgYW5kIGRlZmF1bHQpIGFuZCByZS1pbXBvcnRzIHRoZSB0YXJnZXQgZmlsZXMgd2l0aCBjYWNoZVxuICogYnVzdGluZyBzbyBlZGl0ZWQgZGVmaW5pdGlvbnMgdGFrZSBlZmZlY3QuXG4gKiBAcGFyYW0ge2ltcG9ydChcIi4uL2ZhY3RvcnktcmVnaXN0cnkuanNcIikuZGVmYXVsdH0gcmVnaXN0cnkgLSBSZWdpc3RyeSB0byByZWxvYWQuXG4gKiBAcGFyYW0ge3N0cmluZyB8IHN0cmluZ1tdfSB0YXJnZXQgLSBGaWxlIHBhdGgsIGRpcmVjdG9yeSwgb3IgbGlzdCBvZiBwYXRocy5cbiAqIEByZXR1cm5zIHtQcm9taXNlPHN0cmluZ1tdPn0gLSBUaGUgcmVsb2FkZWQgZmlsZSBwYXRocywgaW4gbG9hZCBvcmRlci5cbiAqL1xuZXhwb3J0IGFzeW5jIGZ1bmN0aW9uIHJlbG9hZERlZmluaXRpb25zKHJlZ2lzdHJ5LCB0YXJnZXQpIHtcbiAgcmVnaXN0cnkucmVzZXQoKVxuXG4gIHJldHVybiBhd2FpdCBsb2FkRGVmaW5pdGlvbnMocmVnaXN0cnksIHRhcmdldCwge3JlbG9hZDogdHJ1ZX0pXG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"load-definitions.js","sourceRoot":"","sources":["../../../../../src/testing/factory/node/load-definitions.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport { pathToFileURL } from \"node:url\"\nimport { readdir, stat } from \"node:fs/promises\"\nimport path from \"node:path\"\nimport { reserveDefinitionReloadBudget } from \"./definition-reload-policy.js\"\n\n/**\n * Monotonic cache-busting counter shared by reloads. Kept module-local so a reload\n * imports a fresh module instance rather than the cached one.\n * @type {number}\n */\nlet reloadCounter = 0\n\n/**\n * Recursively collects `.js` files under a directory in a deterministic\n * (lexicographically sorted) order.\n * @param {string} directory - Directory to scan.\n * @returns {Promise<string[]>} - Sorted absolute file paths.\n */\nasync function collectDirectoryFiles(directory) {\n  const entries = await readdir(directory, {withFileTypes: true})\n  /** @type {string[]} */\n  const files = []\n\n  for (const entry of [...entries].sort((left, right) => (left.name < right.name ? -1 : 1))) {\n    const fullPath = path.join(directory, entry.name)\n\n    if (entry.isDirectory()) {\n      files.push(...await collectDirectoryFiles(fullPath))\n    } else if (entry.name.endsWith(\".js\")) {\n      files.push(fullPath)\n    }\n  }\n\n  return files\n}\n\n/**\n * Resolves a load target (a single file, a directory, or an explicit list) into a\n * deterministic, de-duplicated list of absolute definition file paths.\n * @param {string | string[]} target - File path, directory, or list of paths.\n * @returns {Promise<string[]>} - Sorted, de-duplicated absolute file paths.\n */\nasync function resolveFiles(target) {\n  if (Array.isArray(target)) {\n    return [...new Set(target.map((entry) => path.resolve(entry)))].sort()\n  }\n\n  const resolved = path.resolve(target)\n  const stats = await stat(resolved)\n\n  if (stats.isDirectory()) return await collectDirectoryFiles(resolved)\n\n  return [resolved]\n}\n\n/**\n * Loads Velocious factory definition files (Node only). Each file must\n * default-export a `(registry) => void` function that defines into the registry.\n * Files load in deterministic path order. This module is intentionally Node-only\n * (filesystem + dynamic import) and must never be imported from browser/Metro\n * bundles; import the browser-safe core from `../index.js` there instead.\n * @param {import(\"../factory-registry.js\").default} registry - Registry to define into.\n * @param {string | string[]} target - File path, directory, or list of paths.\n * @param {{reload?: boolean}} [options] - Options.\n * @returns {Promise<string[]>} - The loaded file paths, in load order.\n */\nexport async function loadDefinitions(registry, target, {reload = false} = {}) {\n  const files = await resolveFiles(target)\n\n  return await loadResolvedDefinitionFiles({files, registry, reload})\n}\n\n/**\n * Loads definition files that have already been resolved into a deterministic\n * sorted list. When `reload` is set, the whole batch is preflighted and reserved\n * against the process-global import budget before any registry reset or import\n * attempt, so a rejected reload never mutates the registry.\n * @param {object} args - Options object.\n * @param {string[]} args.files - Resolved, sorted definition file paths.\n * @param {import(\"../factory-registry.js\").default} args.registry - Registry to define into.\n * @param {boolean} args.reload - Whether to cache-bust the imports.\n * @param {boolean} [args.reset] - Whether to reset the registry first.\n * @returns {Promise<string[]>} - The loaded file paths, in load order.\n */\nasync function loadResolvedDefinitionFiles({files, registry, reload, reset = false}) {\n  if (reload) reserveDefinitionReloadBudget(files.length)\n\n  if (reset) registry.reset()\n\n  for (const file of files) {\n    let href = pathToFileURL(file).href\n\n    if (reload) {\n      reloadCounter += 1\n      href += `?factoryReload=${reloadCounter}`\n    }\n\n    const module = await import(href)\n\n    if (typeof module.default !== \"function\") {\n      throw new Error(`Factory definition file ${file} must default-export a (registry) => void function`)\n    }\n\n    module.default(registry)\n  }\n\n  return files\n}\n\n/**\n * Fully reloads definitions: resets the registry (dropping every factory, trait,\n * sequence, callback and default) and re-imports the target files with cache\n * busting so edited definitions take effect. The resolved batch is preflighted\n * against the process-global import budget before the reset, and a\n * `DefinitionRecycleRequiredError` is raised before any mutation when the batch\n * would exceed the budget.\n * @param {import(\"../factory-registry.js\").default} registry - Registry to reload.\n * @param {string | string[]} target - File path, directory, or list of paths.\n * @returns {Promise<string[]>} - The reloaded file paths, in load order.\n */\nexport async function reloadDefinitions(registry, target) {\n  const files = await resolveFiles(target)\n\n  return await loadResolvedDefinitionFiles({files, registry, reload: true, reset: true})\n}\n"]}