velocious 1.0.604 → 1.0.606

package/build/src/testing/test-suite-splitter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"test-suite-splitter.d.ts","sourceRoot":"","sources":["../../../src/testing/test-suite-splitter.js"],"names":[],"mappings":"AAOG,YAAkB,iBAAiB,GACnC;;;;IAAmB,QAAQ,EAAhB,MAAM,CACjB;;;;IAAmB,MAAM,EAAd,MAAM,CACnB;CAAA,CAAA;AAIE,YAAkB,WAAW,GAC7B;;;;IAAmB,WAAW,EAAnB,MAAM,CACjB;;;;IAAqB,KAAK,EAAf,MAAM,EAAE,CACrB;CAAA,CAAA;AAmBD;;;GAGG;AACH,MAAM,CAAC,OAAO,OAAO,iBAAiB;IAqB7B,OAAO;IACP,YAAY;IACZ,UAAU;IACV,cAAc;IACd,eAAe;IAxBtB;;;;;;;;OAQG;IACH,YAAY,EAAC,MAAM,EAAE,WAAW,EAAE,SAAS,EAAE,aAAa,EAAE,cAAc,EAAE,GAAG,QAAQ,EAAC,EANrF;QAAqB,MAAM,EAAnB,MAAM,CACd;QAAqB,WAAW,EAAxB,MAAM,CACd;QAAuB,SAAS,EAAxB,MAAM,EAAE,CAChB;QAAsB,aAAa,AAAnC,CACA,EADQ,MAAM,CACd;QAA6C,cAAc,AAA3D,CACF,EADU,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,CACvC;KACuF,EAgBvF;IAED;;;OAGG;IACH,aAAa,IAFA,MAAM,EAAE,CAQpB;IAED;;;OAGG;IACH,oBAAoB,IAFP,iBAAiB,EAAE,CAO/B;IAED;;;;OAIG;IACH,aAAa,CAAC,QAAQ,EAHX,MAGW,GAFT,MAAM,CA+BlB;IAED;;;;OAIG;IACH,uBAAuB,CAAC,cAAc,EAH3B,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAGD,GAFzB,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAiBlC;IAED;;;;OAIG;IACH,qBAAqB,CAAC,QAAQ,EAHnB,MAGmB,GAFjB,MAAM,CAMlB;IAED;;;;OAIG;IACH,sBAAsB,CAAC,KAAK,EAHjB,iBAAiB,EAGA,GAFf,iBAAiB,EAAE,CAU/B;IAED;;;;;OAKG;IACH,kBAAkB,CAAC,WAAW,EAHnB,iBAAiB,EAGE,GAFjB,WAAW,EAAE,CAoBzB;IAED;;;;;OAKG;IACH,kBAAkB,CAAC,OAAO,EAHf,WAAW,EAGI,GAFb,WAAW,CAYvB;CACF"}
+{"version":3,"file":"test-suite-splitter.d.ts","sourceRoot":"","sources":["../../../src/testing/test-suite-splitter.js"],"names":[],"mappings":"AAQG,YAAkB,iBAAiB,GACnC;;;;IAAmB,QAAQ,EAAhB,MAAM,CACjB;;;;IAAmB,MAAM,EAAd,MAAM,CACnB;CAAA,CAAA;AAIE,YAAkB,WAAW,GAC7B;;;;IAAmB,WAAW,EAAnB,MAAM,CACjB;;;;IAAqB,KAAK,EAAf,MAAM,EAAE,CACrB;CAAA,CAAA;AAmBD;;;GAGG;AACH,MAAM,CAAC,OAAO,OAAO,iBAAiB;IAqB7B,OAAO;IACP,YAAY;IACZ,UAAU;IACV,cAAc;IACd,eAAe;IAxBtB;;;;;;;;OAQG;IACH,YAAY,EAAC,MAAM,EAAE,WAAW,EAAE,SAAS,EAAE,aAAa,EAAE,cAAc,EAAE,GAAG,QAAQ,EAAC,EANrF;QAAqB,MAAM,EAAnB,MAAM,CACd;QAAqB,WAAW,EAAxB,MAAM,CACd;QAAuB,SAAS,EAAxB,MAAM,EAAE,CAChB;QAAsB,aAAa,AAAnC,CACA,EADQ,MAAM,CACd;QAA6C,cAAc,AAA3D,CACF,EADU,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,CACvC;KACuF,EAgBvF;IAED;;;OAGG;IACH,aAAa,IAFA,MAAM,EAAE,CAQpB;IAED;;;OAGG;IACH,oBAAoB,IAFP,iBAAiB,EAAE,CAO/B;IAED;;;;OAIG;IACH,aAAa,CAAC,QAAQ,EAHX,MAGW,GAFT,MAAM,CA8BlB;IAED;;;;OAIG;IACH,uBAAuB,CAAC,cAAc,EAH3B,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAGD,GAFzB,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAqBlC;IAED;;;;OAIG;IACH,qBAAqB,CAAC,QAAQ,EAHnB,MAGmB,GAFjB,MAAM,CAIlB;IAED;;;;OAIG;IACH,qBAAqB,CAAC,QAAQ,EAHnB,MAGmB,GAFjB,MAAM,CAMlB;IAED;;;;OAIG;IACH,oBAAoB,CAAC,QAAQ,EAHlB,MAGkB,GAFhB,MAAM,GAAG,SAAS,CAS9B;IAED;;;;OAIG;IACH,sBAAsB,CAAC,QAAQ,EAHpB,MAGoB,GAFlB,MAAM,GAAG,SAAS,CAQ9B;IAED;;;;OAIG;IACH,mBAAmB,CAAC,QAAQ,EAHjB,MAGiB,GAFf,MAAM,EAAE,CAUpB;IAED;;;OAGG;IACH,yBAAyB,IAFZ;QAAC,cAAc,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAA;KAAC,CAyBjF;IAED;;;;OAIG;IACH,sBAAsB,CAAC,KAAK,EAHjB,iBAAiB,EAGA,GAFf,iBAAiB,EAAE,CAU/B;IAED;;;;;OAKG;IACH,kBAAkB,CAAC,WAAW,EAHnB,iBAAiB,EAGE,GAFjB,WAAW,EAAE,CAoBzB;IAED;;;;;OAKG;IACH,kBAAkB,CAAC,OAAO,EAHf,WAAW,EAGI,GAFb,WAAW,CAYvB;CACF"}

package/build/src/testing/test-suite-splitter.js

@@ -1,6 +1,7 @@
 // @ts-check
 import path from "path";
 import restArgsError from "../utils/rest-args-error.js";
+import { canonicalTimingManifestPath, compareTimingManifestPaths } from "./timing-manifest.js";
 /**
  * SplitterFileEntry type.
  * @typedef {object} SplitterFileEntry
@@ -81,12 +82,11 @@ export default class TestSuiteSplitter {
      * @returns {number} - Weight value.
      */
     computeWeight(filePath) {
-        const relativePath = this.normalizeRelativePath(path.relative(this._baseDirectory, filePath));
-        const projectRelativePath = this.normalizeRelativePath(path.join(path.basename(this._baseDirectory), relativePath));
-        const duration = this._timingManifest[relativePath] ?? this._timingManifest[projectRelativePath];
-        if (duration !== undefined) {
+        const duration = this.timingManifestDuration(filePath);
+        if (duration !== undefined && duration > 0) {
             return duration;
         }
+        const relativePath = this.heuristicRelativePath(filePath);
         let weight = DEFAULT_WEIGHT;
         // Extract the type directory from the relative path.
         // Matches both "spec/system/..." (base is project root) and "system/..." (base is spec/ itself).
@@ -115,9 +115,15 @@ export default class TestSuiteSplitter {
             return normalized;
         }
         for (const [filePath, duration] of Object.entries(timingManifest)) {
-            if (typeof duration === "number" && Number.isFinite(duration) && duration > 0) {
+            if (typeof duration !== "number" || !Number.isFinite(duration) || duration < 0)
+                continue;
+            try {
                 normalized[this.normalizeRelativePath(filePath)] = duration;
             }
+            catch (error) {
+                if (!(error instanceof Error))
+                    throw error;
+            }
         }
         return normalized;
     }
@@ -127,10 +133,80 @@ export default class TestSuiteSplitter {
      * @returns {string} - Normalized relative test path.
      */
     normalizeRelativePath(filePath) {
-        return filePath
+        return canonicalTimingManifestPath(filePath);
+    }
+    /**
+     * Returns the permissive relative path used only for heuristic classification.
+     * @param {string} filePath - Absolute test file path.
+     * @returns {string} - Portable relative path which may escape the profiling base.
+     */
+    heuristicRelativePath(filePath) {
+        return path.relative(this._baseDirectory, filePath)
             .replaceAll("\\", "/")
             .replace(/^\.\//, "");
     }
+    /**
+     * Returns a canonical manifest key when the file is representable under the profiling base.
+     * @param {string} filePath - Absolute test file path.
+     * @returns {string | undefined} - Canonical relative path, or undefined for an external file.
+     */
+    manifestRelativePath(filePath) {
+        const relativePath = path.relative(this._baseDirectory, filePath);
+        if (!relativePath || path.isAbsolute(relativePath))
+            return;
+        if (relativePath === ".." || relativePath.startsWith(`..${path.sep}`))
+            return;
+        return this.normalizeRelativePath(relativePath);
+    }
+    /**
+     * Returns the first manifest entry matching a discovered test file.
+     * @param {string} filePath - Absolute test file path.
+     * @returns {number | undefined} - Recorded duration, including zero.
+     */
+    timingManifestDuration(filePath) {
+        for (const manifestPath of this.timingManifestPaths(filePath)) {
+            if (Object.hasOwn(this._timingManifest, manifestPath))
+                return this._timingManifest[manifestPath];
+        }
+        return undefined;
+    }
+    /**
+     * Returns compatible manifest keys for one discovered file.
+     * @param {string} filePath - Absolute test file path.
+     * @returns {string[]} - Canonical keys in matching priority order.
+     */
+    timingManifestPaths(filePath) {
+        const relativePath = this.manifestRelativePath(filePath);
+        if (!relativePath)
+            return [];
+        const projectRelativePath = this.normalizeRelativePath(path.join(path.basename(this._baseDirectory), relativePath));
+        return relativePath === projectRelativePath ? [relativePath] : [relativePath, projectRelativePath];
+    }
+    /**
+     * Summarizes timing-history coverage for the complete discovered suite.
+     * @returns {{heuristicFiles: number, measuredFiles: number, staleEntries: number}} - Compact coverage counts.
+     */
+    getTimingManifestCoverage() {
+        const matchedManifestPaths = new Set();
+        let measuredFiles = 0;
+        for (const filePath of this._testFiles) {
+            let matchedDuration;
+            for (const manifestPath of this.timingManifestPaths(filePath)) {
+                if (!Object.hasOwn(this._timingManifest, manifestPath))
+                    continue;
+                matchedManifestPaths.add(manifestPath);
+                matchedDuration = this._timingManifest[manifestPath];
+                break;
+            }
+            if (matchedDuration !== undefined && matchedDuration > 0)
+                measuredFiles++;
+        }
+        return {
+            heuristicFiles: this._testFiles.length - measuredFiles,
+            measuredFiles,
+            staleEntries: Object.keys(this._timingManifest).length - matchedManifestPaths.size
+        };
+    }
     /**
      * Sorts files by weight descending, then by path for determinism.
      * @param {SplitterFileEntry[]} files - Weighted files.
@@ -141,7 +217,7 @@ export default class TestSuiteSplitter {
             if (b.weight !== a.weight) {
                 return b.weight - a.weight;
             }
-            return a.filePath.localeCompare(b.filePath);
+            return compareTimingManifestPaths(a.filePath, b.filePath);
         });
     }
     /**
@@ -181,4 +257,4 @@ export default class TestSuiteSplitter {
         return lightest;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"test-suite-splitter.js","sourceRoot":"","sources":["../../../src/testing/test-suite-splitter.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport path from \"path\"\nimport restArgsError from \"../utils/rest-args-error.js\"\n\n/**\n * SplitterFileEntry type.\n * @typedef {object} SplitterFileEntry\n * @property {string} filePath - Absolute file path.\n * @property {number} weight - Computed weight for load balancing.\n */\n\n/**\n * GroupBucket type.\n * @typedef {object} GroupBucket\n * @property {number} totalWeight - Accumulated weight.\n * @property {string[]} files - Files assigned to this group.\n */\n\n/** Default weight for a regular test file. */\nconst DEFAULT_WEIGHT = 1\n\n/**\n * Weight multipliers by spec directory name.\n * Heavier test types get higher weights so greedy distribution balances wall-clock time.\n * @type {Record<string, number>}\n */\nconst DIRECTORY_WEIGHTS = {\n  system: 20,\n  \"frontend-models\": 10,\n  controller: 3\n}\n\n/** Extra multiplier applied to browser spec files on top of directory weight. */\nconst BROWSER_SPEC_MULTIPLIER = 2\n\n/**\n * Splits a list of test files into balanced groups using a greedy load-balancing algorithm.\n * Modeled after test_suite_splitter for RSpec.\n */\nexport default class TestSuiteSplitter {\n  /**\n   * Runs constructor.\n   * @param {object} args - Options.\n   * @param {number} args.groups - Total number of groups.\n   * @param {number} args.groupNumber - Which group to return (1-indexed).\n   * @param {string[]} args.testFiles - All discovered test file paths.\n   * @param {string} [args.baseDirectory] - Base directory for relative path computation.\n   * @param {ReturnType<typeof JSON.parse>} [args.timingManifest] - Relative test paths mapped to durations.\n   */\n  constructor({groups, groupNumber, testFiles, baseDirectory, timingManifest, ...restArgs}) {\n    restArgsError(restArgs)\n\n    if (!Number.isInteger(groups) || groups < 1) {\n      throw new Error(`--groups must be a positive integer, got: ${groups}`)\n    }\n\n    if (!Number.isInteger(groupNumber) || groupNumber < 1 || groupNumber > groups) {\n      throw new Error(`--group-number must be between 1 and ${groups}, got: ${groupNumber}`)\n    }\n\n    this._groups = groups\n    this._groupNumber = groupNumber\n    this._testFiles = testFiles\n    this._baseDirectory = baseDirectory || process.cwd()\n    this._timingManifest = this.normalizeTimingManifest(timingManifest)\n  }\n\n  /**\n   * Returns the test files assigned to this group.\n   * @returns {string[]} - File paths for the requested group.\n   */\n  getGroupFiles() {\n    const weighted = this.computeWeightedFiles()\n    const sorted = this.sortByWeightDescending(weighted)\n    const buckets = this.distributeGreedily(sorted)\n\n    return buckets[this._groupNumber - 1].files\n  }\n\n  /**\n   * Computes weight for each test file based on directory type and file suffix.\n   * @returns {SplitterFileEntry[]} - Weighted file entries.\n   */\n  computeWeightedFiles() {\n    return this._testFiles.map((filePath) => ({\n      filePath,\n      weight: this.computeWeight(filePath)\n    }))\n  }\n\n  /**\n   * Computes the weight for a single file.\n   * @param {string} filePath - Absolute file path.\n   * @returns {number} - Weight value.\n   */\n  computeWeight(filePath) {\n    const relativePath = this.normalizeRelativePath(path.relative(this._baseDirectory, filePath))\n    const projectRelativePath = this.normalizeRelativePath(path.join(path.basename(this._baseDirectory), relativePath))\n    const duration = this._timingManifest[relativePath] ?? this._timingManifest[projectRelativePath]\n\n    if (duration !== undefined) {\n      return duration\n    }\n\n    let weight = DEFAULT_WEIGHT\n\n    // Extract the type directory from the relative path.\n    // Matches both \"spec/system/...\" (base is project root) and \"system/...\" (base is spec/ itself).\n    const specDirMatch = relativePath.match(/^(?:(?:spec|__tests__|tests)\\/)?([^/]+)\\//)\n\n    if (specDirMatch) {\n      const dirName = specDirMatch[1]\n\n      if (DIRECTORY_WEIGHTS[dirName] !== undefined) {\n        weight = DIRECTORY_WEIGHTS[dirName]\n      }\n    }\n\n    // Browser spec files are heavier\n    if (filePath.endsWith(\".browser-spec.js\") || filePath.endsWith(\".browser-spec.mjs\")) {\n      weight *= BROWSER_SPEC_MULTIPLIER\n    }\n\n    return weight\n  }\n\n  /**\n   * Keeps only usable positive finite duration entries keyed by normalized relative path.\n   * @param {ReturnType<typeof JSON.parse>} timingManifest - Parsed timing manifest.\n   * @returns {Record<string, number>} - Valid normalized duration weights.\n   */\n  normalizeTimingManifest(timingManifest) {\n    /** @type {Record<string, number>} */\n    const normalized = {}\n\n    if (!timingManifest || typeof timingManifest !== \"object\" || Array.isArray(timingManifest)) {\n      return normalized\n    }\n\n    for (const [filePath, duration] of Object.entries(timingManifest)) {\n      if (typeof duration === \"number\" && Number.isFinite(duration) && duration > 0) {\n        normalized[this.normalizeRelativePath(filePath)] = duration\n      }\n    }\n\n    return normalized\n  }\n\n  /**\n   * Normalizes a relative test path to the manifest's portable slash format.\n   * @param {string} filePath - Relative test path.\n   * @returns {string} - Normalized relative test path.\n   */\n  normalizeRelativePath(filePath) {\n    return filePath\n      .replaceAll(\"\\\\\", \"/\")\n      .replace(/^\\.\\//, \"\")\n  }\n\n  /**\n   * Sorts files by weight descending, then by path for determinism.\n   * @param {SplitterFileEntry[]} files - Weighted files.\n   * @returns {SplitterFileEntry[]} - Sorted files.\n   */\n  sortByWeightDescending(files) {\n    return [...files].sort((a, b) => {\n      if (b.weight !== a.weight) {\n        return b.weight - a.weight\n      }\n\n      return a.filePath.localeCompare(b.filePath)\n    })\n  }\n\n  /**\n   * Distributes files greedily into N balanced groups.\n   * Each file is assigned to the group with the least accumulated weight.\n   * @param {SplitterFileEntry[]} sortedFiles - Files sorted by weight descending.\n   * @returns {GroupBucket[]} - Array of group buckets.\n   */\n  distributeGreedily(sortedFiles) {\n    /**\n     * Buckets.\n     * @type {GroupBucket[]} */\n    const buckets = []\n\n    for (let i = 0; i < this._groups; i++) {\n      buckets.push({totalWeight: 0, files: []})\n    }\n\n    for (const entry of sortedFiles) {\n      const lightest = this.findLightestBucket(buckets)\n\n      lightest.files.push(entry.filePath)\n      lightest.totalWeight += entry.weight\n    }\n\n    return buckets\n  }\n\n  /**\n   * Finds the bucket with the least accumulated weight.\n   * Ties are broken by bucket index (earlier bucket wins) for determinism.\n   * @param {GroupBucket[]} buckets - Group buckets.\n   * @returns {GroupBucket} - The lightest bucket.\n   */\n  findLightestBucket(buckets) {\n    let lightest = buckets[0]\n\n    for (let i = 1; i < buckets.length; i++) {\n      if (buckets[i].totalWeight < lightest.totalWeight) {\n        lightest = buckets[i]\n      }\n    }\n\n    return lightest\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"test-suite-splitter.js","sourceRoot":"","sources":["../../../src/testing/test-suite-splitter.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport path from \"path\"\nimport restArgsError from \"../utils/rest-args-error.js\"\nimport { canonicalTimingManifestPath, compareTimingManifestPaths } from \"./timing-manifest.js\"\n\n/**\n * SplitterFileEntry type.\n * @typedef {object} SplitterFileEntry\n * @property {string} filePath - Absolute file path.\n * @property {number} weight - Computed weight for load balancing.\n */\n\n/**\n * GroupBucket type.\n * @typedef {object} GroupBucket\n * @property {number} totalWeight - Accumulated weight.\n * @property {string[]} files - Files assigned to this group.\n */\n\n/** Default weight for a regular test file. */\nconst DEFAULT_WEIGHT = 1\n\n/**\n * Weight multipliers by spec directory name.\n * Heavier test types get higher weights so greedy distribution balances wall-clock time.\n * @type {Record<string, number>}\n */\nconst DIRECTORY_WEIGHTS = {\n  system: 20,\n  \"frontend-models\": 10,\n  controller: 3\n}\n\n/** Extra multiplier applied to browser spec files on top of directory weight. */\nconst BROWSER_SPEC_MULTIPLIER = 2\n\n/**\n * Splits a list of test files into balanced groups using a greedy load-balancing algorithm.\n * Modeled after test_suite_splitter for RSpec.\n */\nexport default class TestSuiteSplitter {\n  /**\n   * Runs constructor.\n   * @param {object} args - Options.\n   * @param {number} args.groups - Total number of groups.\n   * @param {number} args.groupNumber - Which group to return (1-indexed).\n   * @param {string[]} args.testFiles - All discovered test file paths.\n   * @param {string} [args.baseDirectory] - Base directory for relative path computation.\n   * @param {ReturnType<typeof JSON.parse>} [args.timingManifest] - Relative test paths mapped to durations.\n   */\n  constructor({groups, groupNumber, testFiles, baseDirectory, timingManifest, ...restArgs}) {\n    restArgsError(restArgs)\n\n    if (!Number.isInteger(groups) || groups < 1) {\n      throw new Error(`--groups must be a positive integer, got: ${groups}`)\n    }\n\n    if (!Number.isInteger(groupNumber) || groupNumber < 1 || groupNumber > groups) {\n      throw new Error(`--group-number must be between 1 and ${groups}, got: ${groupNumber}`)\n    }\n\n    this._groups = groups\n    this._groupNumber = groupNumber\n    this._testFiles = testFiles\n    this._baseDirectory = baseDirectory || process.cwd()\n    this._timingManifest = this.normalizeTimingManifest(timingManifest)\n  }\n\n  /**\n   * Returns the test files assigned to this group.\n   * @returns {string[]} - File paths for the requested group.\n   */\n  getGroupFiles() {\n    const weighted = this.computeWeightedFiles()\n    const sorted = this.sortByWeightDescending(weighted)\n    const buckets = this.distributeGreedily(sorted)\n\n    return buckets[this._groupNumber - 1].files\n  }\n\n  /**\n   * Computes weight for each test file based on directory type and file suffix.\n   * @returns {SplitterFileEntry[]} - Weighted file entries.\n   */\n  computeWeightedFiles() {\n    return this._testFiles.map((filePath) => ({\n      filePath,\n      weight: this.computeWeight(filePath)\n    }))\n  }\n\n  /**\n   * Computes the weight for a single file.\n   * @param {string} filePath - Absolute file path.\n   * @returns {number} - Weight value.\n   */\n  computeWeight(filePath) {\n    const duration = this.timingManifestDuration(filePath)\n\n    if (duration !== undefined && duration > 0) {\n      return duration\n    }\n\n    const relativePath = this.heuristicRelativePath(filePath)\n    let weight = DEFAULT_WEIGHT\n\n    // Extract the type directory from the relative path.\n    // Matches both \"spec/system/...\" (base is project root) and \"system/...\" (base is spec/ itself).\n    const specDirMatch = relativePath.match(/^(?:(?:spec|__tests__|tests)\\/)?([^/]+)\\//)\n\n    if (specDirMatch) {\n      const dirName = specDirMatch[1]\n\n      if (DIRECTORY_WEIGHTS[dirName] !== undefined) {\n        weight = DIRECTORY_WEIGHTS[dirName]\n      }\n    }\n\n    // Browser spec files are heavier\n    if (filePath.endsWith(\".browser-spec.js\") || filePath.endsWith(\".browser-spec.mjs\")) {\n      weight *= BROWSER_SPEC_MULTIPLIER\n    }\n\n    return weight\n  }\n\n  /**\n   * Keeps only usable positive finite duration entries keyed by normalized relative path.\n   * @param {ReturnType<typeof JSON.parse>} timingManifest - Parsed timing manifest.\n   * @returns {Record<string, number>} - Valid normalized duration weights.\n   */\n  normalizeTimingManifest(timingManifest) {\n    /** @type {Record<string, number>} */\n    const normalized = {}\n\n    if (!timingManifest || typeof timingManifest !== \"object\" || Array.isArray(timingManifest)) {\n      return normalized\n    }\n\n    for (const [filePath, duration] of Object.entries(timingManifest)) {\n      if (typeof duration !== \"number\" || !Number.isFinite(duration) || duration < 0) continue\n\n      try {\n        normalized[this.normalizeRelativePath(filePath)] = duration\n      } catch (error) {\n        if (!(error instanceof Error)) throw error\n      }\n    }\n\n    return normalized\n  }\n\n  /**\n   * Normalizes a relative test path to the manifest's portable slash format.\n   * @param {string} filePath - Relative test path.\n   * @returns {string} - Normalized relative test path.\n   */\n  normalizeRelativePath(filePath) {\n    return canonicalTimingManifestPath(filePath)\n  }\n\n  /**\n   * Returns the permissive relative path used only for heuristic classification.\n   * @param {string} filePath - Absolute test file path.\n   * @returns {string} - Portable relative path which may escape the profiling base.\n   */\n  heuristicRelativePath(filePath) {\n    return path.relative(this._baseDirectory, filePath)\n      .replaceAll(\"\\\\\", \"/\")\n      .replace(/^\\.\\//, \"\")\n  }\n\n  /**\n   * Returns a canonical manifest key when the file is representable under the profiling base.\n   * @param {string} filePath - Absolute test file path.\n   * @returns {string | undefined} - Canonical relative path, or undefined for an external file.\n   */\n  manifestRelativePath(filePath) {\n    const relativePath = path.relative(this._baseDirectory, filePath)\n\n    if (!relativePath || path.isAbsolute(relativePath)) return\n    if (relativePath === \"..\" || relativePath.startsWith(`..${path.sep}`)) return\n\n    return this.normalizeRelativePath(relativePath)\n  }\n\n  /**\n   * Returns the first manifest entry matching a discovered test file.\n   * @param {string} filePath - Absolute test file path.\n   * @returns {number | undefined} - Recorded duration, including zero.\n   */\n  timingManifestDuration(filePath) {\n    for (const manifestPath of this.timingManifestPaths(filePath)) {\n      if (Object.hasOwn(this._timingManifest, manifestPath)) return this._timingManifest[manifestPath]\n    }\n\n    return undefined\n  }\n\n  /**\n   * Returns compatible manifest keys for one discovered file.\n   * @param {string} filePath - Absolute test file path.\n   * @returns {string[]} - Canonical keys in matching priority order.\n   */\n  timingManifestPaths(filePath) {\n    const relativePath = this.manifestRelativePath(filePath)\n\n    if (!relativePath) return []\n\n    const projectRelativePath = this.normalizeRelativePath(path.join(path.basename(this._baseDirectory), relativePath))\n\n    return relativePath === projectRelativePath ? [relativePath] : [relativePath, projectRelativePath]\n  }\n\n  /**\n   * Summarizes timing-history coverage for the complete discovered suite.\n   * @returns {{heuristicFiles: number, measuredFiles: number, staleEntries: number}} - Compact coverage counts.\n   */\n  getTimingManifestCoverage() {\n    const matchedManifestPaths = new Set()\n    let measuredFiles = 0\n\n    for (const filePath of this._testFiles) {\n      let matchedDuration\n\n      for (const manifestPath of this.timingManifestPaths(filePath)) {\n        if (!Object.hasOwn(this._timingManifest, manifestPath)) continue\n\n        matchedManifestPaths.add(manifestPath)\n        matchedDuration = this._timingManifest[manifestPath]\n        break\n      }\n\n      if (matchedDuration !== undefined && matchedDuration > 0) measuredFiles++\n    }\n\n    return {\n      heuristicFiles: this._testFiles.length - measuredFiles,\n      measuredFiles,\n      staleEntries: Object.keys(this._timingManifest).length - matchedManifestPaths.size\n    }\n  }\n\n  /**\n   * Sorts files by weight descending, then by path for determinism.\n   * @param {SplitterFileEntry[]} files - Weighted files.\n   * @returns {SplitterFileEntry[]} - Sorted files.\n   */\n  sortByWeightDescending(files) {\n    return [...files].sort((a, b) => {\n      if (b.weight !== a.weight) {\n        return b.weight - a.weight\n      }\n\n      return compareTimingManifestPaths(a.filePath, b.filePath)\n    })\n  }\n\n  /**\n   * Distributes files greedily into N balanced groups.\n   * Each file is assigned to the group with the least accumulated weight.\n   * @param {SplitterFileEntry[]} sortedFiles - Files sorted by weight descending.\n   * @returns {GroupBucket[]} - Array of group buckets.\n   */\n  distributeGreedily(sortedFiles) {\n    /**\n     * Buckets.\n     * @type {GroupBucket[]} */\n    const buckets = []\n\n    for (let i = 0; i < this._groups; i++) {\n      buckets.push({totalWeight: 0, files: []})\n    }\n\n    for (const entry of sortedFiles) {\n      const lightest = this.findLightestBucket(buckets)\n\n      lightest.files.push(entry.filePath)\n      lightest.totalWeight += entry.weight\n    }\n\n    return buckets\n  }\n\n  /**\n   * Finds the bucket with the least accumulated weight.\n   * Ties are broken by bucket index (earlier bucket wins) for determinism.\n   * @param {GroupBucket[]} buckets - Group buckets.\n   * @returns {GroupBucket} - The lightest bucket.\n   */\n  findLightestBucket(buckets) {\n    let lightest = buckets[0]\n\n    for (let i = 1; i < buckets.length; i++) {\n      if (buckets[i].totalWeight < lightest.totalWeight) {\n        lightest = buckets[i]\n      }\n    }\n\n    return lightest\n  }\n}\n"]}

package/build/src/testing/timing-manifest.d.ts

@@ -0,0 +1,94 @@
+export type TimingManifest = Record<string, number>;
+export type ValidatedProfileShard = {
+    /**
+     * - Complete pre-shard file count.
+     */
+    discoveredFileCount: number;
+    /**
+     * - Selected post-shard file count.
+     */
+    fileCount: number;
+    /**
+     * - One-indexed shard number.
+     */
+    groupNumber: number;
+    /**
+     * - Complete shard count.
+     */
+    groups: number;
+    /**
+     * - Profiling path-base semantics.
+     */
+    pathBase: string;
+    /**
+     * - Complete canonical file-set identity.
+     */
+    testFileSetHash: string;
+    /**
+     * - Canonical shard timing map.
+     */
+    timingManifest: TimingManifest;
+};
+export type TestProfileTimingManifestInput = {
+    /**
+     * - Parsed rich test profile.
+     */
+    profile: ReturnType<typeof JSON.parse>;
+    /**
+     * - Human-readable input source for validation errors.
+     */
+    source: string;
+};
+/** @typedef {Record<string, number>} TimingManifest */
+/**
+ * ValidatedProfileShard type.
+ * @typedef {object} ValidatedProfileShard
+ * @property {number} discoveredFileCount - Complete pre-shard file count.
+ * @property {number} fileCount - Selected post-shard file count.
+ * @property {number} groupNumber - One-indexed shard number.
+ * @property {number} groups - Complete shard count.
+ * @property {string} pathBase - Profiling path-base semantics.
+ * @property {string} testFileSetHash - Complete canonical file-set identity.
+ * @property {TimingManifest} timingManifest - Canonical shard timing map.
+ */
+/**
+ * TestProfileTimingManifestInput type.
+ * @typedef {object} TestProfileTimingManifestInput
+ * @property {ReturnType<typeof JSON.parse>} profile - Parsed rich test profile.
+ * @property {string} source - Human-readable input source for validation errors.
+ */
+/**
+ * Canonicalizes a timing-manifest path relative to its profiling base.
+ * @param {string} filePath - Candidate relative path.
+ * @returns {string} - Portable canonical path.
+ */
+export declare function canonicalTimingManifestPath(filePath: string): string;
+/**
+ * Compares timing-manifest paths by JavaScript code units without locale rules.
+ * @param {string} filePathA - First path.
+ * @param {string} filePathB - Second path.
+ * @returns {number} - Negative, zero, or positive ordering result.
+ */
+export declare function compareTimingManifestPaths(filePathA: string, filePathB: string): number;
+/**
+ * Validates and sorts a plain timing manifest.
+ * @param {ReturnType<typeof JSON.parse>} timingManifest - Parsed timing manifest.
+ * @param {{source?: string}} [options] - Validation context.
+ * @returns {TimingManifest} - Canonical sorted timing manifest.
+ */
+export declare function validateTimingManifest(timingManifest: ReturnType<typeof JSON.parse>, { source }?: {
+    source?: string;
+}): TimingManifest;
+/**
+ * Returns an opaque deterministic identity for a complete canonical test-file set.
+ * @param {string[]} filePaths - Paths relative to one profiling base.
+ * @returns {string} - SHA-256 file-set identity.
+ */
+export declare function timingManifestFileSetHash(filePaths: string[]): string;
+/**
+ * Merges a complete compatible set of rich Velocious shard profiles.
+ * @param {TestProfileTimingManifestInput[]} inputs - Parsed profile documents and sources.
+ * @returns {TimingManifest} - Complete sorted plain timing manifest.
+ */
+export declare function mergeTestProfileTimingManifests(inputs: TestProfileTimingManifestInput[]): TimingManifest;
+//# sourceMappingURL=timing-manifest.d.ts.map

package/build/src/testing/timing-manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timing-manifest.d.ts","sourceRoot":"","sources":["../../../src/testing/timing-manifest.js"],"names":[],"mappings":"AAII,YAAkC,cAAc,GAAtC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAgB;AAIjD,YAAkB,qBAAqB,GACvC;;;;IAAmB,mBAAmB,EAA3B,MAAM,CACjB;;;;IAAmB,SAAS,EAAjB,MAAM,CACjB;;;;IAAmB,WAAW,EAAnB,MAAM,CACjB;;;;IAAmB,MAAM,EAAd,MAAM,CACjB;;;;IAAmB,QAAQ,EAAhB,MAAM,CACjB;;;;IAAmB,eAAe,EAAvB,MAAM,CACjB;;;;IAA2B,cAAc,EAA9B,cAAc,CAC3B;CAAA,CAAA;AAIE,YAAkB,8BAA8B,GAChD;;;;IAA0C,OAAO,EAAtC,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,CACxC;;;;IAAmB,MAAM,EAAd,MAAM,CACnB;CAAA,CAAA;AAnBD,uDAAuD;AAEvD;;;;;;;;;;GAUG;AAEH;;;;;GAKG;AAEH;;;;GAIG;AACH,wBAAgB,2BAA2B,CAAC,QAAQ,EAHzC,MAGyC,GAFvC,MAAM,CAmClB;AAED;;;;;GAKG;AACH,wBAAgB,0BAA0B,CAAC,SAAS,EAJzC,MAIyC,EAAE,SAAS,EAHpD,MAGoD,GAFlD,MAAM,CAMlB;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,cAAc,EAJ1C,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAIc,EAAE,EAAC,MAA0B,EAAC,AAHhF,CACA,EADQ;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAG6D,GAF3E,cAAc,CA8B1B;AAED;;;;GAIG;AACH,wBAAgB,yBAAyB,CAAC,SAAS,EAHxC,MAAM,EAGkC,GAFtC,MAAM,CAQlB;AAqKD;;;;GAIG;AACH,wBAAgB,+BAA+B,CAAC,MAAM,EAH3C,8BAA8B,EAGa,GAFzC,cAAc,CAqD1B"}