velocious 1.0.604 → 1.0.606

package/build/src/testing/timing-manifest.js

@@ -0,0 +1,284 @@
+// @ts-check
+import sha256Hex from "../utils/sha256-hex.js";
+/** @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 function canonicalTimingManifestPath(filePath) {
+    if (typeof filePath !== "string" || filePath.length === 0) {
+        throw new Error("Timing manifest keys must be non-empty relative paths");
+    }
+    const portablePath = filePath.replaceAll("\\", "/");
+    if (portablePath.startsWith("/") || /^[A-Za-z]:/.test(portablePath)) {
+        throw new Error(`Timing manifest key must be a relative path: ${filePath}`);
+    }
+    const segments = [];
+    for (const segment of portablePath.split("/")) {
+        if (!segment || segment === ".")
+            continue;
+        if (segment === "..") {
+            if (segments.length === 0) {
+                throw new Error(`Timing manifest key must be a non-escaping relative path: ${filePath}`);
+            }
+            segments.pop();
+            continue;
+        }
+        segments.push(segment);
+    }
+    if (segments.length === 0) {
+        throw new Error(`Timing manifest key must be a non-empty relative path: ${filePath}`);
+    }
+    return segments.join("/");
+}
+/**
+ * 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 function compareTimingManifestPaths(filePathA, filePathB) {
+    if (filePathA === filePathB)
+        return 0;
+    return filePathA < filePathB ? -1 : 1;
+}
+/**
+ * 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 function validateTimingManifest(timingManifest, { source = "timing manifest" } = {}) {
+    if (!timingManifest || typeof timingManifest !== "object" || Array.isArray(timingManifest)) {
+        throw new Error(`${source} must be a plain JSON object mapping relative paths to durations`);
+    }
+    /** @type {Map<string, {duration: number, originalPath: string}>} */
+    const entries = new Map();
+    for (const [originalPath, duration] of Object.entries(timingManifest)) {
+        if (typeof duration !== "number" || !Number.isFinite(duration) || duration < 0) {
+            throw new Error(`${source} has an invalid duration for ${originalPath}`);
+        }
+        const canonicalPath = canonicalTimingManifestPath(originalPath);
+        const existing = entries.get(canonicalPath);
+        if (existing) {
+            throw new Error(`${source} has a normalized path collision between ${existing.originalPath} and ${originalPath}`);
+        }
+        entries.set(canonicalPath, { duration, originalPath });
+    }
+    return Object.fromEntries([...entries.entries()]
+        .sort(([filePathA], [filePathB]) => compareTimingManifestPaths(filePathA, filePathB))
+        .map(([filePath, entry]) => [filePath, entry.duration]));
+}
+/**
+ * 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 function timingManifestFileSetHash(filePaths) {
+    const pathManifest = Object.fromEntries(filePaths.map((filePath) => [filePath, 0]));
+    const canonicalPaths = Object.keys(validateTimingManifest(pathManifest, { source: "test file set" }));
+    const identity = `velocious.test-file-set.v1\0${canonicalPaths.join("\0")}`;
+    return `sha256:${sha256Hex(identity)}`;
+}
+/**
+ * Validates that a parsed JSON value is a non-array object.
+ * @param {ReturnType<typeof JSON.parse>} value - Candidate object.
+ * @param {string} message - Validation error message.
+ * @returns {void}
+ */
+function assertJsonObject(value, message) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error(message);
+}
+/**
+ * Requires unfiltered, non-focused profile selection metadata.
+ * @param {ReturnType<typeof JSON.parse>} selection - Rich profile selection.
+ * @param {string} source - Input source.
+ * @returns {void}
+ */
+function assertCompleteSelection(selection, source) {
+    if (selection.focused !== false)
+        throw new Error(`${source} must not be a focused test profile`);
+    const selectionFilters = [
+        [selection.includeTagCount, 0],
+        [selection.excludeTagCount, 0],
+        [selection.hasExampleFilters, false],
+        [selection.hasLineFilters, false]
+    ];
+    if (selectionFilters.some(([value, expected]) => value !== expected)) {
+        throw new Error(`${source} must not be a filtered test profile`);
+    }
+}
+/**
+ * Validates shard numbering metadata.
+ * @param {ReturnType<typeof JSON.parse>} shard - Candidate shard selection.
+ * @param {string} source - Input source.
+ * @returns {{groupNumber: number, groups: number}} - Validated shard numbers.
+ */
+function validatedShardNumbers(shard, source) {
+    assertJsonObject(shard, `${source} is missing shard metadata`);
+    if (!Number.isInteger(shard.groups) || shard.groups < 1) {
+        throw new Error(`${source} has an invalid shard group count`);
+    }
+    if (!Number.isInteger(shard.groupNumber) || shard.groupNumber < 1 || shard.groupNumber > shard.groups) {
+        throw new Error(`${source} has an invalid shard number`);
+    }
+    return { groupNumber: shard.groupNumber, groups: shard.groups };
+}
+/**
+ * Validates a non-negative integer selection count.
+ * @param {ReturnType<typeof JSON.parse>} value - Candidate count.
+ * @param {string} message - Validation error message.
+ * @returns {number} - Validated count.
+ */
+function validatedSelectionCount(value, message) {
+    if (!Number.isInteger(value) || value < 0)
+        throw new Error(message);
+    return value;
+}
+/**
+ * Validates the selection identity used across shard profiles.
+ * @param {ReturnType<typeof JSON.parse>} selection - Rich profile selection.
+ * @param {string} source - Input source.
+ * @returns {{pathBase: string, testFileSetHash: string}} - Validated identity.
+ */
+function validatedSelectionIdentity(selection, source) {
+    if (!["configuration-directory", "test-directory"].includes(selection.pathBase)) {
+        throw new Error(`${source} has an invalid timing manifest path base`);
+    }
+    if (typeof selection.testFileSetHash !== "string" || !/^sha256:[a-f0-9]{64}$/.test(selection.testFileSetHash)) {
+        throw new Error(`${source} has an invalid test file set identity`);
+    }
+    return { pathBase: selection.pathBase, testFileSetHash: selection.testFileSetHash };
+}
+/**
+ * Validates one rich profile and returns its aggregation contract.
+ * @param {TestProfileTimingManifestInput} input - Profile input.
+ * @returns {ValidatedProfileShard} - Validated shard contract.
+ */
+function validatedProfileShard(input) {
+    const { profile, source } = input;
+    assertJsonObject(profile, `${source} must be a rich Velocious test profile`);
+    if (profile.schema !== "velocious.test-profile" || profile.schemaVersion !== 1) {
+        throw new Error(`${source} has an incompatible Velocious test profile schema`);
+    }
+    if (profile.status !== "passed")
+        throw new Error(`${source} must have passed status for timing aggregation`);
+    const selection = profile.selection;
+    assertJsonObject(selection, `${source} is missing test profile selection metadata`);
+    assertCompleteSelection(selection, source);
+    const { groupNumber, groups } = validatedShardNumbers(selection.shard, source);
+    const discoveredFileCount = validatedSelectionCount(selection.discoveredFileCount, `${source} has an invalid pre-shard discovered file count`);
+    const fileCount = validatedSelectionCount(selection.fileCount, `${source} has an invalid post-shard file count`);
+    const { pathBase, testFileSetHash } = validatedSelectionIdentity(selection, source);
+    const timingManifest = validateTimingManifest(profile.timingManifest, { source: `${source} timing manifest` });
+    if (Object.keys(timingManifest).length !== fileCount) {
+        throw new Error(`${source} timing manifest does not match its post-shard file count`);
+    }
+    return {
+        discoveredFileCount,
+        fileCount,
+        groupNumber,
+        groups,
+        pathBase,
+        testFileSetHash,
+        timingManifest
+    };
+}
+/**
+ * Requires one shard to describe the same complete selection as the first.
+ * @param {ValidatedProfileShard} shard - Candidate shard.
+ * @param {ValidatedProfileShard} expected - First shard contract.
+ * @param {string} source - Candidate source.
+ * @returns {void}
+ */
+function assertCompatibleShard(shard, expected, source) {
+    if (shard.groups !== expected.groups)
+        throw new Error(`${source} has a different shard group count`);
+    if (shard.pathBase !== expected.pathBase)
+        throw new Error(`${source} has a different timing manifest path base`);
+    if (shard.discoveredFileCount !== expected.discoveredFileCount)
+        throw new Error(`${source} has a different discovered file count`);
+    if (shard.testFileSetHash !== expected.testFileSetHash)
+        throw new Error(`${source} has a different test file set identity`);
+}
+/**
+ * Adds one validated shard timing map without allowing duplicate canonical keys.
+ * @param {object} args - Merge state.
+ * @param {Map<string, {duration: number, source: string}>} args.mergedEntries - Destination timing entries.
+ * @param {ValidatedProfileShard} args.shard - Candidate shard.
+ * @param {string} args.source - Candidate source.
+ * @returns {void}
+ */
+function mergeShardTimingManifest({ mergedEntries, shard, source }) {
+    for (const [filePath, duration] of Object.entries(shard.timingManifest)) {
+        const existingEntry = mergedEntries.get(filePath);
+        if (existingEntry) {
+            throw new Error(`Duplicate timing path ${filePath} in ${existingEntry.source} and ${source}`);
+        }
+        mergedEntries.set(filePath, { duration, source });
+    }
+}
+/**
+ * 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 function mergeTestProfileTimingManifests(inputs) {
+    if (inputs.length === 0)
+        throw new Error("At least one rich test profile is required");
+    const shards = inputs.map((input) => validatedProfileShard(input));
+    const expected = shards[0];
+    /** @type {Map<number, string>} */
+    const shardSources = new Map();
+    /** @type {Map<string, {duration: number, source: string}>} */
+    const mergedEntries = new Map();
+    let selectedFileCount = 0;
+    for (let index = 0; index < shards.length; index++) {
+        const shard = shards[index];
+        const source = inputs[index].source;
+        assertCompatibleShard(shard, expected, source);
+        const existingShardSource = shardSources.get(shard.groupNumber);
+        if (existingShardSource) {
+            throw new Error(`Duplicate shard ${shard.groupNumber} in ${existingShardSource} and ${source}`);
+        }
+        shardSources.set(shard.groupNumber, source);
+        selectedFileCount += shard.fileCount;
+        mergeShardTimingManifest({ mergedEntries, shard, source });
+    }
+    const missingShardNumbers = [];
+    for (let groupNumber = 1; groupNumber <= expected.groups; groupNumber++) {
+        if (!shardSources.has(groupNumber))
+            missingShardNumbers.push(groupNumber);
+    }
+    if (missingShardNumbers.length > 0) {
+        throw new Error(`Missing shard profiles: ${missingShardNumbers.join(", ")}`);
+    }
+    if (selectedFileCount !== expected.discoveredFileCount || mergedEntries.size !== expected.discoveredFileCount) {
+        throw new Error("Merged timing manifest does not cover the complete file universe");
+    }
+    const merged = Object.fromEntries([...mergedEntries].map(([filePath, entry]) => [filePath, entry.duration]));
+    if (timingManifestFileSetHash(Object.keys(merged)) !== expected.testFileSetHash) {
+        throw new Error("Merged timing manifest does not match the complete file universe");
+    }
+    return validateTimingManifest(merged, { source: "merged timing manifest" });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"timing-manifest.js","sourceRoot":"","sources":["../../../src/testing/timing-manifest.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport sha256Hex from \"../utils/sha256-hex.js\"\n\n/** @typedef {Record<string, number>} TimingManifest */\n\n/**\n * ValidatedProfileShard type.\n * @typedef {object} ValidatedProfileShard\n * @property {number} discoveredFileCount - Complete pre-shard file count.\n * @property {number} fileCount - Selected post-shard file count.\n * @property {number} groupNumber - One-indexed shard number.\n * @property {number} groups - Complete shard count.\n * @property {string} pathBase - Profiling path-base semantics.\n * @property {string} testFileSetHash - Complete canonical file-set identity.\n * @property {TimingManifest} timingManifest - Canonical shard timing map.\n */\n\n/**\n * TestProfileTimingManifestInput type.\n * @typedef {object} TestProfileTimingManifestInput\n * @property {ReturnType<typeof JSON.parse>} profile - Parsed rich test profile.\n * @property {string} source - Human-readable input source for validation errors.\n */\n\n/**\n * Canonicalizes a timing-manifest path relative to its profiling base.\n * @param {string} filePath - Candidate relative path.\n * @returns {string} - Portable canonical path.\n */\nexport function canonicalTimingManifestPath(filePath) {\n  if (typeof filePath !== \"string\" || filePath.length === 0) {\n    throw new Error(\"Timing manifest keys must be non-empty relative paths\")\n  }\n\n  const portablePath = filePath.replaceAll(\"\\\\\", \"/\")\n\n  if (portablePath.startsWith(\"/\") || /^[A-Za-z]:/.test(portablePath)) {\n    throw new Error(`Timing manifest key must be a relative path: ${filePath}`)\n  }\n\n  const segments = []\n\n  for (const segment of portablePath.split(\"/\")) {\n    if (!segment || segment === \".\") continue\n\n    if (segment === \"..\") {\n      if (segments.length === 0) {\n        throw new Error(`Timing manifest key must be a non-escaping relative path: ${filePath}`)\n      }\n\n      segments.pop()\n      continue\n    }\n\n    segments.push(segment)\n  }\n\n  if (segments.length === 0) {\n    throw new Error(`Timing manifest key must be a non-empty relative path: ${filePath}`)\n  }\n\n  return segments.join(\"/\")\n}\n\n/**\n * Compares timing-manifest paths by JavaScript code units without locale rules.\n * @param {string} filePathA - First path.\n * @param {string} filePathB - Second path.\n * @returns {number} - Negative, zero, or positive ordering result.\n */\nexport function compareTimingManifestPaths(filePathA, filePathB) {\n  if (filePathA === filePathB) return 0\n\n  return filePathA < filePathB ? -1 : 1\n}\n\n/**\n * Validates and sorts a plain timing manifest.\n * @param {ReturnType<typeof JSON.parse>} timingManifest - Parsed timing manifest.\n * @param {{source?: string}} [options] - Validation context.\n * @returns {TimingManifest} - Canonical sorted timing manifest.\n */\nexport function validateTimingManifest(timingManifest, {source = \"timing manifest\"} = {}) {\n  if (!timingManifest || typeof timingManifest !== \"object\" || Array.isArray(timingManifest)) {\n    throw new Error(`${source} must be a plain JSON object mapping relative paths to durations`)\n  }\n\n  /** @type {Map<string, {duration: number, originalPath: string}>} */\n  const entries = new Map()\n\n  for (const [originalPath, duration] of Object.entries(timingManifest)) {\n    if (typeof duration !== \"number\" || !Number.isFinite(duration) || duration < 0) {\n      throw new Error(`${source} has an invalid duration for ${originalPath}`)\n    }\n\n    const canonicalPath = canonicalTimingManifestPath(originalPath)\n    const existing = entries.get(canonicalPath)\n\n    if (existing) {\n      throw new Error(`${source} has a normalized path collision between ${existing.originalPath} and ${originalPath}`)\n    }\n\n    entries.set(canonicalPath, {duration, originalPath})\n  }\n\n  return Object.fromEntries(\n    [...entries.entries()]\n      .sort(([filePathA], [filePathB]) => compareTimingManifestPaths(filePathA, filePathB))\n      .map(([filePath, entry]) => [filePath, entry.duration])\n  )\n}\n\n/**\n * Returns an opaque deterministic identity for a complete canonical test-file set.\n * @param {string[]} filePaths - Paths relative to one profiling base.\n * @returns {string} - SHA-256 file-set identity.\n */\nexport function timingManifestFileSetHash(filePaths) {\n  const pathManifest = Object.fromEntries(filePaths.map((filePath) => [filePath, 0]))\n  const canonicalPaths = Object.keys(validateTimingManifest(pathManifest, {source: \"test file set\"}))\n  const identity = `velocious.test-file-set.v1\\0${canonicalPaths.join(\"\\0\")}`\n\n  return `sha256:${sha256Hex(identity)}`\n}\n\n/**\n * Validates that a parsed JSON value is a non-array object.\n * @param {ReturnType<typeof JSON.parse>} value - Candidate object.\n * @param {string} message - Validation error message.\n * @returns {void}\n */\nfunction assertJsonObject(value, message) {\n  if (!value || typeof value !== \"object\" || Array.isArray(value)) throw new Error(message)\n}\n\n/**\n * Requires unfiltered, non-focused profile selection metadata.\n * @param {ReturnType<typeof JSON.parse>} selection - Rich profile selection.\n * @param {string} source - Input source.\n * @returns {void}\n */\nfunction assertCompleteSelection(selection, source) {\n  if (selection.focused !== false) throw new Error(`${source} must not be a focused test profile`)\n\n  const selectionFilters = [\n    [selection.includeTagCount, 0],\n    [selection.excludeTagCount, 0],\n    [selection.hasExampleFilters, false],\n    [selection.hasLineFilters, false]\n  ]\n\n  if (selectionFilters.some(([value, expected]) => value !== expected)) {\n    throw new Error(`${source} must not be a filtered test profile`)\n  }\n}\n\n/**\n * Validates shard numbering metadata.\n * @param {ReturnType<typeof JSON.parse>} shard - Candidate shard selection.\n * @param {string} source - Input source.\n * @returns {{groupNumber: number, groups: number}} - Validated shard numbers.\n */\nfunction validatedShardNumbers(shard, source) {\n  assertJsonObject(shard, `${source} is missing shard metadata`)\n\n  if (!Number.isInteger(shard.groups) || shard.groups < 1) {\n    throw new Error(`${source} has an invalid shard group count`)\n  }\n\n  if (!Number.isInteger(shard.groupNumber) || shard.groupNumber < 1 || shard.groupNumber > shard.groups) {\n    throw new Error(`${source} has an invalid shard number`)\n  }\n\n  return {groupNumber: shard.groupNumber, groups: shard.groups}\n}\n\n/**\n * Validates a non-negative integer selection count.\n * @param {ReturnType<typeof JSON.parse>} value - Candidate count.\n * @param {string} message - Validation error message.\n * @returns {number} - Validated count.\n */\nfunction validatedSelectionCount(value, message) {\n  if (!Number.isInteger(value) || value < 0) throw new Error(message)\n\n  return value\n}\n\n/**\n * Validates the selection identity used across shard profiles.\n * @param {ReturnType<typeof JSON.parse>} selection - Rich profile selection.\n * @param {string} source - Input source.\n * @returns {{pathBase: string, testFileSetHash: string}} - Validated identity.\n */\nfunction validatedSelectionIdentity(selection, source) {\n  if (![\"configuration-directory\", \"test-directory\"].includes(selection.pathBase)) {\n    throw new Error(`${source} has an invalid timing manifest path base`)\n  }\n\n  if (typeof selection.testFileSetHash !== \"string\" || !/^sha256:[a-f0-9]{64}$/.test(selection.testFileSetHash)) {\n    throw new Error(`${source} has an invalid test file set identity`)\n  }\n\n  return {pathBase: selection.pathBase, testFileSetHash: selection.testFileSetHash}\n}\n\n/**\n * Validates one rich profile and returns its aggregation contract.\n * @param {TestProfileTimingManifestInput} input - Profile input.\n * @returns {ValidatedProfileShard} - Validated shard contract.\n */\nfunction validatedProfileShard(input) {\n  const {profile, source} = input\n\n  assertJsonObject(profile, `${source} must be a rich Velocious test profile`)\n\n  if (profile.schema !== \"velocious.test-profile\" || profile.schemaVersion !== 1) {\n    throw new Error(`${source} has an incompatible Velocious test profile schema`)\n  }\n\n  if (profile.status !== \"passed\") throw new Error(`${source} must have passed status for timing aggregation`)\n\n  const selection = profile.selection\n\n  assertJsonObject(selection, `${source} is missing test profile selection metadata`)\n  assertCompleteSelection(selection, source)\n  const {groupNumber, groups} = validatedShardNumbers(selection.shard, source)\n  const discoveredFileCount = validatedSelectionCount(\n    selection.discoveredFileCount,\n    `${source} has an invalid pre-shard discovered file count`\n  )\n  const fileCount = validatedSelectionCount(\n    selection.fileCount,\n    `${source} has an invalid post-shard file count`\n  )\n  const {pathBase, testFileSetHash} = validatedSelectionIdentity(selection, source)\n\n  const timingManifest = validateTimingManifest(profile.timingManifest, {source: `${source} timing manifest`})\n\n  if (Object.keys(timingManifest).length !== fileCount) {\n    throw new Error(`${source} timing manifest does not match its post-shard file count`)\n  }\n\n  return {\n    discoveredFileCount,\n    fileCount,\n    groupNumber,\n    groups,\n    pathBase,\n    testFileSetHash,\n    timingManifest\n  }\n}\n\n/**\n * Requires one shard to describe the same complete selection as the first.\n * @param {ValidatedProfileShard} shard - Candidate shard.\n * @param {ValidatedProfileShard} expected - First shard contract.\n * @param {string} source - Candidate source.\n * @returns {void}\n */\nfunction assertCompatibleShard(shard, expected, source) {\n  if (shard.groups !== expected.groups) throw new Error(`${source} has a different shard group count`)\n  if (shard.pathBase !== expected.pathBase) throw new Error(`${source} has a different timing manifest path base`)\n  if (shard.discoveredFileCount !== expected.discoveredFileCount) throw new Error(`${source} has a different discovered file count`)\n  if (shard.testFileSetHash !== expected.testFileSetHash) throw new Error(`${source} has a different test file set identity`)\n}\n\n/**\n * Adds one validated shard timing map without allowing duplicate canonical keys.\n * @param {object} args - Merge state.\n * @param {Map<string, {duration: number, source: string}>} args.mergedEntries - Destination timing entries.\n * @param {ValidatedProfileShard} args.shard - Candidate shard.\n * @param {string} args.source - Candidate source.\n * @returns {void}\n */\nfunction mergeShardTimingManifest({mergedEntries, shard, source}) {\n  for (const [filePath, duration] of Object.entries(shard.timingManifest)) {\n    const existingEntry = mergedEntries.get(filePath)\n\n    if (existingEntry) {\n      throw new Error(`Duplicate timing path ${filePath} in ${existingEntry.source} and ${source}`)\n    }\n\n    mergedEntries.set(filePath, {duration, source})\n  }\n}\n\n/**\n * Merges a complete compatible set of rich Velocious shard profiles.\n * @param {TestProfileTimingManifestInput[]} inputs - Parsed profile documents and sources.\n * @returns {TimingManifest} - Complete sorted plain timing manifest.\n */\nexport function mergeTestProfileTimingManifests(inputs) {\n  if (inputs.length === 0) throw new Error(\"At least one rich test profile is required\")\n\n  const shards = inputs.map((input) => validatedProfileShard(input))\n  const expected = shards[0]\n  /** @type {Map<number, string>} */\n  const shardSources = new Map()\n  /** @type {Map<string, {duration: number, source: string}>} */\n  const mergedEntries = new Map()\n  let selectedFileCount = 0\n\n  for (let index = 0; index < shards.length; index++) {\n    const shard = shards[index]\n    const source = inputs[index].source\n\n    assertCompatibleShard(shard, expected, source)\n\n    const existingShardSource = shardSources.get(shard.groupNumber)\n\n    if (existingShardSource) {\n      throw new Error(`Duplicate shard ${shard.groupNumber} in ${existingShardSource} and ${source}`)\n    }\n\n    shardSources.set(shard.groupNumber, source)\n    selectedFileCount += shard.fileCount\n    mergeShardTimingManifest({mergedEntries, shard, source})\n  }\n\n  const missingShardNumbers = []\n\n  for (let groupNumber = 1; groupNumber <= expected.groups; groupNumber++) {\n    if (!shardSources.has(groupNumber)) missingShardNumbers.push(groupNumber)\n  }\n\n  if (missingShardNumbers.length > 0) {\n    throw new Error(`Missing shard profiles: ${missingShardNumbers.join(\", \")}`)\n  }\n\n  if (selectedFileCount !== expected.discoveredFileCount || mergedEntries.size !== expected.discoveredFileCount) {\n    throw new Error(\"Merged timing manifest does not cover the complete file universe\")\n  }\n\n  const merged = Object.fromEntries(\n    [...mergedEntries].map(([filePath, entry]) => [filePath, entry.duration])\n  )\n\n  if (timingManifestFileSetHash(Object.keys(merged)) !== expected.testFileSetHash) {\n    throw new Error(\"Merged timing manifest does not match the complete file universe\")\n  }\n\n  return validateTimingManifest(merged, {source: \"merged timing manifest\"})\n}\n"]}

package/build/testing/test-profile-output.js

@@ -3,6 +3,7 @@
 import fs from "node:fs/promises"
 import path from "node:path"
 import { roundProfileDuration } from "./test-profiler.js"
+import { validateTimingManifest } from "./timing-manifest.js"
 
 const FORBIDDEN_PROFILE_FIELDS = new Set([
   "bind",
@@ -156,20 +157,34 @@ async function atomicWrite(outputPath, content) {
 export function timingManifestFromProfile(profile) {
   /** @type {Record<string, number>} */
   const manifest = {}
+  const validatedManifest = validateTimingManifest(profile.timingManifest || {}, {source: "Test profile timing manifest"})
 
-  for (const filePath of Object.keys(profile.timingManifest || {}).sort()) {
-    const durationMs = profile.timingManifest[filePath]
-
-    if (typeof durationMs !== "number" || !Number.isFinite(durationMs) || durationMs < 0) {
-      throw new Error(`Invalid timing manifest duration for ${filePath}`)
-    }
-
+  for (const [filePath, durationMs] of Object.entries(validatedManifest)) {
     manifest[filePath] = roundProfileDuration(durationMs)
   }
 
   return manifest
 }
 
+/**
+ * Atomically writes a canonical splitter-compatible timing manifest.
+ * @param {object} args - Output arguments.
+ * @param {string} args.outputPath - Final output path.
+ * @param {Record<string, number>} args.timingManifest - Validated or candidate timing manifest.
+ * @returns {Promise<void>} - Resolves after atomic replacement.
+ */
+export async function writeTimingManifest({outputPath, timingManifest}) {
+  const normalized = validateTimingManifest(timingManifest)
+  /** @type {Record<string, number>} */
+  const rounded = {}
+
+  for (const [filePath, durationMs] of Object.entries(normalized)) {
+    rounded[filePath] = roundProfileDuration(durationMs)
+  }
+
+  await atomicWrite(outputPath, `${JSON.stringify(rounded, null, 2)}\n`)
+}
+
 /**
  * Atomically writes requested test profile outputs.
  * @param {object} args - Output options.
@@ -189,7 +204,7 @@ export async function writeTestProfileOutputs({profile, profileJsonPath, timingM
   }
 
   if (timingManifestOutputPath) {
-    await atomicWrite(timingManifestOutputPath, `${JSON.stringify(timingManifest, null, 2)}\n`)
+    await writeTimingManifest({outputPath: timingManifestOutputPath, timingManifest})
   }
 }
 

package/build/testing/test-profiler.js

@@ -4,6 +4,7 @@ import { createHash } from "node:crypto"
 import path from "node:path"
 import { registerTestProfileContextReader } from "./test-profile-context.js"
 import { validateTestActivityName } from "./test-profile-activity.js"
+import { compareTimingManifestPaths } from "./timing-manifest.js"
 
 /** @typedef {"passed" | "failed" | "interrupted" | "timed-out"} TestProfileAttemptStatus */
 /** @typedef {{user: number, system: number}} ProcessCpuUsage */
@@ -625,7 +626,7 @@ export default class TestProfiler {
         attemptsMs: roundProfileDuration(file.attemptsMs),
         totalMs: roundProfileDuration(file.totalMs)
       }))
-      .sort((fileA, fileB) => fileA.path.localeCompare(fileB.path))
+      .sort((fileA, fileB) => compareTimingManifestPaths(fileA.path, fileB.path))
     const timingManifest = Object.fromEntries(files.map((file) => [file.path, file.totalMs]))
     const attempts = this._tests.reduce((sum, test) => sum + test.attempts.length, 0)
 

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

@@ -2,6 +2,7 @@
 
 import path from "path"
 import restArgsError from "../utils/rest-args-error.js"
+import { canonicalTimingManifestPath, compareTimingManifestPaths } from "./timing-manifest.js"
 
 /**
  * SplitterFileEntry type.
@@ -95,14 +96,13 @@ 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]
+    const duration = this.timingManifestDuration(filePath)
 
-    if (duration !== undefined) {
+    if (duration !== undefined && duration > 0) {
       return duration
     }
 
+    const relativePath = this.heuristicRelativePath(filePath)
     let weight = DEFAULT_WEIGHT
 
     // Extract the type directory from the relative path.
@@ -139,8 +139,12 @@ export default class TestSuiteSplitter {
     }
 
     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
       }
     }
 
@@ -153,11 +157,91 @@ 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.
@@ -169,7 +253,7 @@ export default class TestSuiteSplitter {
         return b.weight - a.weight
       }
 
-      return a.filePath.localeCompare(b.filePath)
+      return compareTimingManifestPaths(a.filePath, b.filePath)
     })
   }