velocious 1.0.581 → 1.0.583

package/build/src/testing/test-filter-parser.d.ts

@@ -7,6 +7,7 @@
  * @property {string[]} filteredProcessArgs - Remaining process args with filter flags removed.
  * @property {number | undefined} groups - Total number of groups for test splitting.
  * @property {number | undefined} groupNumber - Which group to run (1-indexed).
+ * @property {string | undefined} timingManifestPath - JSON timing manifest path.
  */
 export type ParseFiltersResult = {
     /**
@@ -33,6 +34,10 @@ export type ParseFiltersResult = {
      * - Which group to run (1-indexed).
      */
     groupNumber: number | undefined;
+    /**
+     * - JSON timing manifest path.
+     */
+    timingManifestPath: string | undefined;
 };
 /**
  * Runs the normalizeExamplePatterns helper.

package/build/src/testing/test-filter-parser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"test-filter-parser.d.ts","sourceRoot":"","sources":["../../../src/testing/test-filter-parser.js"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAPA,YAAkB,kBAAkB,GACpC;;;;IAAqB,WAAW,EAArB,MAAM,EAAE,CACnB;;;;IAAqB,WAAW,EAArB,MAAM,EAAE,CACnB;;;;IAAqB,eAAe,EAAzB,MAAM,EAAE,CACnB;;;;IAAqB,mBAAmB,EAA7B,MAAM,EAAE,CACnB;;;;IAA+B,MAAM,EAA1B,MAAM,GAAG,SAAS,CAC7B;;;;IAA+B,WAAW,EAA/B,MAAM,GAAG,SAAS,CAC/B;CAAA,CAAA;AAgCD;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,QAAQ,EAHtC,MAAM,EAGgC,GAFpC,MAAM,EAAE,CAgBpB;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,WAAW,EAH7B,MAAM,EAGuB,GAF3B,kBAAkB,CAmI9B"}
+{"version":3,"file":"test-filter-parser.d.ts","sourceRoot":"","sources":["../../../src/testing/test-filter-parser.js"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AARA,YAAkB,kBAAkB,GACpC;;;;IAAqB,WAAW,EAArB,MAAM,EAAE,CACnB;;;;IAAqB,WAAW,EAArB,MAAM,EAAE,CACnB;;;;IAAqB,eAAe,EAAzB,MAAM,EAAE,CACnB;;;;IAAqB,mBAAmB,EAA7B,MAAM,EAAE,CACnB;;;;IAA+B,MAAM,EAA1B,MAAM,GAAG,SAAS,CAC7B;;;;IAA+B,WAAW,EAA/B,MAAM,GAAG,SAAS,CAC7B;;;;IAA+B,kBAAkB,EAAtC,MAAM,GAAG,SAAS,CAC/B;CAAA,CAAA;AAiCD;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,QAAQ,EAHtC,MAAM,EAGgC,GAFpC,MAAM,EAAE,CAgBpB;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,WAAW,EAH7B,MAAM,EAGuB,GAF3B,kBAAkB,CAqJ9B"}

package/build/src/testing/test-filter-parser.js

@@ -7,6 +7,7 @@
  * @property {string[]} filteredProcessArgs - Remaining process args with filter flags removed.
  * @property {number | undefined} groups - Total number of groups for test splitting.
  * @property {number | undefined} groupNumber - Which group to run (1-indexed).
+ * @property {string | undefined} timingManifestPath - JSON timing manifest path.
  */
 // @ts-check
 const INCLUDE_TAG_FLAGS = new Set(["--tag", "--include-tag", "-t"]);
@@ -14,6 +15,7 @@ const EXCLUDE_TAG_FLAGS = new Set(["--exclude-tag", "--skip-tag", "-x"]);
 const EXAMPLE_FLAGS = new Set(["--example", "--name", "-e"]);
 const GROUPS_FLAGS = new Set(["--groups"]);
 const GROUP_NUMBER_FLAGS = new Set(["--group-number"]);
+const TIMING_MANIFEST_FLAGS = new Set(["--timing-manifest"]);
 /**
  * Runs split tags.
  * @param {string | undefined} value - Tag argument value.
@@ -71,6 +73,8 @@ export function parseFilters(processArgs) {
      * Defines groupNumber.
      * @type {number | undefined} */
     let groupNumber;
+    /** @type {string | undefined} */
+    let timingManifestPath;
     let inRestArgs = false;
     for (let i = 1; i < processArgs.length; i++) {
         const arg = processArgs[i];
@@ -152,6 +156,18 @@ export function parseFilters(processArgs) {
                 groupNumber = parseInt(arg.slice("--group-number=".length), 10);
                 continue;
             }
+            if (TIMING_MANIFEST_FLAGS.has(arg)) {
+                const nextValue = processArgs[i + 1];
+                if (nextValue && !nextValue.startsWith("-")) {
+                    timingManifestPath = nextValue;
+                    i++;
+                }
+                continue;
+            }
+            if (arg.startsWith("--timing-manifest=")) {
+                timingManifestPath = arg.slice("--timing-manifest=".length);
+                continue;
+            }
         }
         filteredProcessArgs.push(arg);
     }
@@ -161,7 +177,8 @@ export function parseFilters(processArgs) {
         examplePatterns,
         filteredProcessArgs,
         groups,
-        groupNumber
+        groupNumber,
+        timingManifestPath
     };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"test-filter-parser.js","sourceRoot":"","sources":["../../../src/testing/test-filter-parser.js"],"names":[],"mappings":"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","sourcesContent":["/**\n * ParseFiltersResult type.\n * @typedef {object} ParseFiltersResult\n * @property {string[]} includeTags - Tags to include.\n * @property {string[]} excludeTags - Tags to exclude.\n * @property {string[]} examplePatterns - Example name patterns.\n * @property {string[]} filteredProcessArgs - Remaining process args with filter flags removed.\n * @property {number | undefined} groups - Total number of groups for test splitting.\n * @property {number | undefined} groupNumber - Which group to run (1-indexed).\n */\n// @ts-check\n\nconst INCLUDE_TAG_FLAGS = new Set([\"--tag\", \"--include-tag\", \"-t\"])\nconst EXCLUDE_TAG_FLAGS = new Set([\"--exclude-tag\", \"--skip-tag\", \"-x\"])\nconst EXAMPLE_FLAGS = new Set([\"--example\", \"--name\", \"-e\"])\nconst GROUPS_FLAGS = new Set([\"--groups\"])\nconst GROUP_NUMBER_FLAGS = new Set([\"--group-number\"])\n\n/**\n * Runs split tags.\n * @param {string | undefined} value - Tag argument value.\n * @returns {string[]} - Tags list.\n */\nfunction splitTags(value) {\n  if (!value) return []\n\n  return value\n    .split(\",\")\n    .map((tag) => tag.trim())\n    .filter(Boolean)\n}\n\n/**\n * Runs escape reg exp.\n * @param {string} value - Value.\n * @returns {string} - Escaped value for regex.\n */\nfunction escapeRegExp(value) {\n  return value.replace(/[.*+?^${}()|[\\]\\\\]/g, \"\\\\$&\")\n}\n\n/**\n * Runs the normalizeExamplePatterns helper.\n * @param {string[]} patterns - Patterns.\n * @returns {RegExp[]} - Normalized patterns.\n */\nexport function normalizeExamplePatterns(patterns) {\n  const normalized = []\n\n  for (const pattern of patterns) {\n    const regexMatch = pattern.match(/^\\/(.+)\\/([gimsuy]*)$/)\n\n    if (regexMatch) {\n      normalized.push(new RegExp(regexMatch[1], regexMatch[2]))\n    } else {\n      normalized.push(new RegExp(escapeRegExp(pattern)))\n    }\n  }\n\n  return normalized\n}\n\n/**\n * Runs the parseFilters helper.\n * @param {string[]} processArgs - Process args.\n * @returns {ParseFiltersResult} - Parsed tags, group options, and process args.\n */\nexport function parseFilters(processArgs) {\n  const includeTags = []\n  const excludeTags = []\n  const filteredProcessArgs = processArgs.length > 0 ? [processArgs[0]] : []\n  const examplePatterns = []\n\n  /**\n   * Defines groups.\n   * @type {number | undefined} */\n  let groups\n  /**\n   * Defines groupNumber.\n   * @type {number | undefined} */\n  let groupNumber\n\n  let inRestArgs = false\n\n  for (let i = 1; i < processArgs.length; i++) {\n    const arg = processArgs[i]\n\n    if (arg === \"--\") {\n      inRestArgs = true\n      filteredProcessArgs.push(arg)\n      continue\n    }\n\n    if (!inRestArgs) {\n      if (INCLUDE_TAG_FLAGS.has(arg)) {\n        const nextValue = processArgs[i + 1]\n\n        if (nextValue && !nextValue.startsWith(\"-\")) {\n          includeTags.push(...splitTags(nextValue))\n          i++\n        }\n        continue\n      }\n\n      if (EXCLUDE_TAG_FLAGS.has(arg)) {\n        const nextValue = processArgs[i + 1]\n\n        if (nextValue && !nextValue.startsWith(\"-\")) {\n          excludeTags.push(...splitTags(nextValue))\n          i++\n        }\n        continue\n      }\n\n      if (arg.startsWith(\"--tag=\")) {\n        includeTags.push(...splitTags(arg.slice(\"--tag=\".length)))\n        continue\n      }\n\n      if (arg.startsWith(\"--include-tag=\")) {\n        includeTags.push(...splitTags(arg.slice(\"--include-tag=\".length)))\n        continue\n      }\n\n      if (arg.startsWith(\"--exclude-tag=\")) {\n        excludeTags.push(...splitTags(arg.slice(\"--exclude-tag=\".length)))\n        continue\n      }\n\n      if (arg.startsWith(\"--skip-tag=\")) {\n        excludeTags.push(...splitTags(arg.slice(\"--skip-tag=\".length)))\n        continue\n      }\n\n      if (EXAMPLE_FLAGS.has(arg)) {\n        const nextValue = processArgs[i + 1]\n\n        if (nextValue && !nextValue.startsWith(\"-\")) {\n          examplePatterns.push(nextValue)\n          i++\n        }\n        continue\n      }\n\n      if (arg.startsWith(\"--example=\")) {\n        examplePatterns.push(arg.slice(\"--example=\".length))\n        continue\n      }\n\n      if (arg.startsWith(\"--name=\")) {\n        examplePatterns.push(arg.slice(\"--name=\".length))\n        continue\n      }\n\n      if (GROUPS_FLAGS.has(arg)) {\n        const nextValue = processArgs[i + 1]\n\n        if (nextValue && !nextValue.startsWith(\"-\")) {\n          groups = parseInt(nextValue, 10)\n          i++\n        }\n        continue\n      }\n\n      if (arg.startsWith(\"--groups=\")) {\n        groups = parseInt(arg.slice(\"--groups=\".length), 10)\n        continue\n      }\n\n      if (GROUP_NUMBER_FLAGS.has(arg)) {\n        const nextValue = processArgs[i + 1]\n\n        if (nextValue && !nextValue.startsWith(\"-\")) {\n          groupNumber = parseInt(nextValue, 10)\n          i++\n        }\n        continue\n      }\n\n      if (arg.startsWith(\"--group-number=\")) {\n        groupNumber = parseInt(arg.slice(\"--group-number=\".length), 10)\n        continue\n      }\n    }\n\n    filteredProcessArgs.push(arg)\n  }\n\n  return {\n    includeTags: Array.from(new Set(includeTags)),\n    excludeTags: Array.from(new Set(excludeTags)),\n    examplePatterns,\n    filteredProcessArgs,\n    groups,\n    groupNumber\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"test-filter-parser.js","sourceRoot":"","sources":["../../../src/testing/test-filter-parser.js"],"names":[],"mappings":"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","sourcesContent":["/**\n * ParseFiltersResult type.\n * @typedef {object} ParseFiltersResult\n * @property {string[]} includeTags - Tags to include.\n * @property {string[]} excludeTags - Tags to exclude.\n * @property {string[]} examplePatterns - Example name patterns.\n * @property {string[]} filteredProcessArgs - Remaining process args with filter flags removed.\n * @property {number | undefined} groups - Total number of groups for test splitting.\n * @property {number | undefined} groupNumber - Which group to run (1-indexed).\n * @property {string | undefined} timingManifestPath - JSON timing manifest path.\n */\n// @ts-check\n\nconst INCLUDE_TAG_FLAGS = new Set([\"--tag\", \"--include-tag\", \"-t\"])\nconst EXCLUDE_TAG_FLAGS = new Set([\"--exclude-tag\", \"--skip-tag\", \"-x\"])\nconst EXAMPLE_FLAGS = new Set([\"--example\", \"--name\", \"-e\"])\nconst GROUPS_FLAGS = new Set([\"--groups\"])\nconst GROUP_NUMBER_FLAGS = new Set([\"--group-number\"])\nconst TIMING_MANIFEST_FLAGS = new Set([\"--timing-manifest\"])\n\n/**\n * Runs split tags.\n * @param {string | undefined} value - Tag argument value.\n * @returns {string[]} - Tags list.\n */\nfunction splitTags(value) {\n  if (!value) return []\n\n  return value\n    .split(\",\")\n    .map((tag) => tag.trim())\n    .filter(Boolean)\n}\n\n/**\n * Runs escape reg exp.\n * @param {string} value - Value.\n * @returns {string} - Escaped value for regex.\n */\nfunction escapeRegExp(value) {\n  return value.replace(/[.*+?^${}()|[\\]\\\\]/g, \"\\\\$&\")\n}\n\n/**\n * Runs the normalizeExamplePatterns helper.\n * @param {string[]} patterns - Patterns.\n * @returns {RegExp[]} - Normalized patterns.\n */\nexport function normalizeExamplePatterns(patterns) {\n  const normalized = []\n\n  for (const pattern of patterns) {\n    const regexMatch = pattern.match(/^\\/(.+)\\/([gimsuy]*)$/)\n\n    if (regexMatch) {\n      normalized.push(new RegExp(regexMatch[1], regexMatch[2]))\n    } else {\n      normalized.push(new RegExp(escapeRegExp(pattern)))\n    }\n  }\n\n  return normalized\n}\n\n/**\n * Runs the parseFilters helper.\n * @param {string[]} processArgs - Process args.\n * @returns {ParseFiltersResult} - Parsed tags, group options, and process args.\n */\nexport function parseFilters(processArgs) {\n  const includeTags = []\n  const excludeTags = []\n  const filteredProcessArgs = processArgs.length > 0 ? [processArgs[0]] : []\n  const examplePatterns = []\n\n  /**\n   * Defines groups.\n   * @type {number | undefined} */\n  let groups\n  /**\n   * Defines groupNumber.\n   * @type {number | undefined} */\n  let groupNumber\n  /** @type {string | undefined} */\n  let timingManifestPath\n\n  let inRestArgs = false\n\n  for (let i = 1; i < processArgs.length; i++) {\n    const arg = processArgs[i]\n\n    if (arg === \"--\") {\n      inRestArgs = true\n      filteredProcessArgs.push(arg)\n      continue\n    }\n\n    if (!inRestArgs) {\n      if (INCLUDE_TAG_FLAGS.has(arg)) {\n        const nextValue = processArgs[i + 1]\n\n        if (nextValue && !nextValue.startsWith(\"-\")) {\n          includeTags.push(...splitTags(nextValue))\n          i++\n        }\n        continue\n      }\n\n      if (EXCLUDE_TAG_FLAGS.has(arg)) {\n        const nextValue = processArgs[i + 1]\n\n        if (nextValue && !nextValue.startsWith(\"-\")) {\n          excludeTags.push(...splitTags(nextValue))\n          i++\n        }\n        continue\n      }\n\n      if (arg.startsWith(\"--tag=\")) {\n        includeTags.push(...splitTags(arg.slice(\"--tag=\".length)))\n        continue\n      }\n\n      if (arg.startsWith(\"--include-tag=\")) {\n        includeTags.push(...splitTags(arg.slice(\"--include-tag=\".length)))\n        continue\n      }\n\n      if (arg.startsWith(\"--exclude-tag=\")) {\n        excludeTags.push(...splitTags(arg.slice(\"--exclude-tag=\".length)))\n        continue\n      }\n\n      if (arg.startsWith(\"--skip-tag=\")) {\n        excludeTags.push(...splitTags(arg.slice(\"--skip-tag=\".length)))\n        continue\n      }\n\n      if (EXAMPLE_FLAGS.has(arg)) {\n        const nextValue = processArgs[i + 1]\n\n        if (nextValue && !nextValue.startsWith(\"-\")) {\n          examplePatterns.push(nextValue)\n          i++\n        }\n        continue\n      }\n\n      if (arg.startsWith(\"--example=\")) {\n        examplePatterns.push(arg.slice(\"--example=\".length))\n        continue\n      }\n\n      if (arg.startsWith(\"--name=\")) {\n        examplePatterns.push(arg.slice(\"--name=\".length))\n        continue\n      }\n\n      if (GROUPS_FLAGS.has(arg)) {\n        const nextValue = processArgs[i + 1]\n\n        if (nextValue && !nextValue.startsWith(\"-\")) {\n          groups = parseInt(nextValue, 10)\n          i++\n        }\n        continue\n      }\n\n      if (arg.startsWith(\"--groups=\")) {\n        groups = parseInt(arg.slice(\"--groups=\".length), 10)\n        continue\n      }\n\n      if (GROUP_NUMBER_FLAGS.has(arg)) {\n        const nextValue = processArgs[i + 1]\n\n        if (nextValue && !nextValue.startsWith(\"-\")) {\n          groupNumber = parseInt(nextValue, 10)\n          i++\n        }\n        continue\n      }\n\n      if (arg.startsWith(\"--group-number=\")) {\n        groupNumber = parseInt(arg.slice(\"--group-number=\".length), 10)\n        continue\n      }\n\n      if (TIMING_MANIFEST_FLAGS.has(arg)) {\n        const nextValue = processArgs[i + 1]\n\n        if (nextValue && !nextValue.startsWith(\"-\")) {\n          timingManifestPath = nextValue\n          i++\n        }\n        continue\n      }\n\n      if (arg.startsWith(\"--timing-manifest=\")) {\n        timingManifestPath = arg.slice(\"--timing-manifest=\".length)\n        continue\n      }\n    }\n\n    filteredProcessArgs.push(arg)\n  }\n\n  return {\n    includeTags: Array.from(new Set(includeTags)),\n    excludeTags: Array.from(new Set(excludeTags)),\n    examplePatterns,\n    filteredProcessArgs,\n    groups,\n    groupNumber,\n    timingManifestPath\n  }\n}\n"]}

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

@@ -27,6 +27,7 @@ export default class TestSuiteSplitter {
     _groupNumber: number;
     _testFiles: string[];
     _baseDirectory: string;
+    _timingManifest: Record<string, number>;
     /**
      * Runs constructor.
      * @param {object} args - Options.
@@ -34,12 +35,14 @@ export default class TestSuiteSplitter {
      * @param {number} args.groupNumber - Which group to return (1-indexed).
      * @param {string[]} args.testFiles - All discovered test file paths.
      * @param {string} [args.baseDirectory] - Base directory for relative path computation.
+     * @param {ReturnType<typeof JSON.parse>} [args.timingManifest] - Relative test paths mapped to durations.
      */
-    constructor({ groups, groupNumber, testFiles, baseDirectory, ...restArgs }: {
+    constructor({ groups, groupNumber, testFiles, baseDirectory, timingManifest, ...restArgs }: {
         groups: number;
         groupNumber: number;
         testFiles: string[];
         baseDirectory?: string;
+        timingManifest?: ReturnType<typeof JSON.parse>;
     });
     /**
      * Returns the test files assigned to this group.
@@ -57,6 +60,18 @@ export default class TestSuiteSplitter {
      * @returns {number} - Weight value.
      */
     computeWeight(filePath: string): number;
+    /**
+     * Keeps only usable positive finite duration entries keyed by normalized relative path.
+     * @param {ReturnType<typeof JSON.parse>} timingManifest - Parsed timing manifest.
+     * @returns {Record<string, number>} - Valid normalized duration weights.
+     */
+    normalizeTimingManifest(timingManifest: ReturnType<typeof JSON.parse>): Record<string, number>;
+    /**
+     * Normalizes a relative test path to the manifest's portable slash format.
+     * @param {string} filePath - Relative test path.
+     * @returns {string} - Normalized relative test path.
+     */
+    normalizeRelativePath(filePath: string): string;
     /**
      * Sorts files by weight descending, then by path for determinism.
      * @param {SplitterFileEntry[]} files - Weighted files.

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;IAoB7B,OAAO;IACP,YAAY;IACZ,UAAU;IACV,cAAc;IAtBrB;;;;;;;OAOG;IACH,YAAY,EAAC,MAAM,EAAE,WAAW,EAAE,SAAS,EAAE,aAAa,EAAE,GAAG,QAAQ,EAAC,EALrE;QAAqB,MAAM,EAAnB,MAAM,CACd;QAAqB,WAAW,EAAxB,MAAM,CACd;QAAuB,SAAS,EAAxB,MAAM,EAAE,CAChB;QAAsB,aAAa,AAAnC,CACF,EADU,MAAM,CAChB;KACuE,EAevE;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,CAwBlB;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":"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"}

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

@@ -39,8 +39,9 @@ export default class TestSuiteSplitter {
      * @param {number} args.groupNumber - Which group to return (1-indexed).
      * @param {string[]} args.testFiles - All discovered test file paths.
      * @param {string} [args.baseDirectory] - Base directory for relative path computation.
+     * @param {ReturnType<typeof JSON.parse>} [args.timingManifest] - Relative test paths mapped to durations.
      */
-    constructor({ groups, groupNumber, testFiles, baseDirectory, ...restArgs }) {
+    constructor({ groups, groupNumber, testFiles, baseDirectory, timingManifest, ...restArgs }) {
         restArgsError(restArgs);
         if (!Number.isInteger(groups) || groups < 1) {
             throw new Error(`--groups must be a positive integer, got: ${groups}`);
@@ -52,6 +53,7 @@ export default class TestSuiteSplitter {
         this._groupNumber = groupNumber;
         this._testFiles = testFiles;
         this._baseDirectory = baseDirectory || process.cwd();
+        this._timingManifest = this.normalizeTimingManifest(timingManifest);
     }
     /**
      * Returns the test files assigned to this group.
@@ -79,7 +81,12 @@ export default class TestSuiteSplitter {
      * @returns {number} - Weight value.
      */
     computeWeight(filePath) {
-        const relativePath = path.relative(this._baseDirectory, filePath).split(path.sep).join("/");
+        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) {
+            return duration;
+        }
         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).
@@ -96,6 +103,34 @@ export default class TestSuiteSplitter {
         }
         return weight;
     }
+    /**
+     * Keeps only usable positive finite duration entries keyed by normalized relative path.
+     * @param {ReturnType<typeof JSON.parse>} timingManifest - Parsed timing manifest.
+     * @returns {Record<string, number>} - Valid normalized duration weights.
+     */
+    normalizeTimingManifest(timingManifest) {
+        /** @type {Record<string, number>} */
+        const normalized = {};
+        if (!timingManifest || typeof timingManifest !== "object" || Array.isArray(timingManifest)) {
+            return normalized;
+        }
+        for (const [filePath, duration] of Object.entries(timingManifest)) {
+            if (typeof duration === "number" && Number.isFinite(duration) && duration > 0) {
+                normalized[this.normalizeRelativePath(filePath)] = duration;
+            }
+        }
+        return normalized;
+    }
+    /**
+     * Normalizes a relative test path to the manifest's portable slash format.
+     * @param {string} filePath - Relative test path.
+     * @returns {string} - Normalized relative test path.
+     */
+    normalizeRelativePath(filePath) {
+        return filePath
+            .replaceAll("\\", "/")
+            .replace(/^\.\//, "");
+    }
     /**
      * Sorts files by weight descending, then by path for determinism.
      * @param {SplitterFileEntry[]} files - Weighted files.
@@ -146,4 +181,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   */\n  constructor({groups, groupNumber, testFiles, baseDirectory, ...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  }\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 = path.relative(this._baseDirectory, filePath).split(path.sep).join(\"/\")\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   * 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\"\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"]}

package/build/testing/test-filter-parser.js

@@ -7,6 +7,7 @@
  * @property {string[]} filteredProcessArgs - Remaining process args with filter flags removed.
  * @property {number | undefined} groups - Total number of groups for test splitting.
  * @property {number | undefined} groupNumber - Which group to run (1-indexed).
+ * @property {string | undefined} timingManifestPath - JSON timing manifest path.
  */
 // @ts-check
 
@@ -15,6 +16,7 @@ const EXCLUDE_TAG_FLAGS = new Set(["--exclude-tag", "--skip-tag", "-x"])
 const EXAMPLE_FLAGS = new Set(["--example", "--name", "-e"])
 const GROUPS_FLAGS = new Set(["--groups"])
 const GROUP_NUMBER_FLAGS = new Set(["--group-number"])
+const TIMING_MANIFEST_FLAGS = new Set(["--timing-manifest"])
 
 /**
  * Runs split tags.
@@ -79,6 +81,8 @@ export function parseFilters(processArgs) {
    * Defines groupNumber.
    * @type {number | undefined} */
   let groupNumber
+  /** @type {string | undefined} */
+  let timingManifestPath
 
   let inRestArgs = false
 
@@ -181,6 +185,21 @@ export function parseFilters(processArgs) {
         groupNumber = parseInt(arg.slice("--group-number=".length), 10)
         continue
       }
+
+      if (TIMING_MANIFEST_FLAGS.has(arg)) {
+        const nextValue = processArgs[i + 1]
+
+        if (nextValue && !nextValue.startsWith("-")) {
+          timingManifestPath = nextValue
+          i++
+        }
+        continue
+      }
+
+      if (arg.startsWith("--timing-manifest=")) {
+        timingManifestPath = arg.slice("--timing-manifest=".length)
+        continue
+      }
     }
 
     filteredProcessArgs.push(arg)
@@ -192,6 +211,7 @@ export function parseFilters(processArgs) {
     examplePatterns,
     filteredProcessArgs,
     groups,
-    groupNumber
+    groupNumber,
+    timingManifestPath
   }
 }

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

@@ -46,8 +46,9 @@ export default class TestSuiteSplitter {
    * @param {number} args.groupNumber - Which group to return (1-indexed).
    * @param {string[]} args.testFiles - All discovered test file paths.
    * @param {string} [args.baseDirectory] - Base directory for relative path computation.
+   * @param {ReturnType<typeof JSON.parse>} [args.timingManifest] - Relative test paths mapped to durations.
    */
-  constructor({groups, groupNumber, testFiles, baseDirectory, ...restArgs}) {
+  constructor({groups, groupNumber, testFiles, baseDirectory, timingManifest, ...restArgs}) {
     restArgsError(restArgs)
 
     if (!Number.isInteger(groups) || groups < 1) {
@@ -62,6 +63,7 @@ export default class TestSuiteSplitter {
     this._groupNumber = groupNumber
     this._testFiles = testFiles
     this._baseDirectory = baseDirectory || process.cwd()
+    this._timingManifest = this.normalizeTimingManifest(timingManifest)
   }
 
   /**
@@ -93,7 +95,14 @@ export default class TestSuiteSplitter {
    * @returns {number} - Weight value.
    */
   computeWeight(filePath) {
-    const relativePath = path.relative(this._baseDirectory, filePath).split(path.sep).join("/")
+    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) {
+      return duration
+    }
+
     let weight = DEFAULT_WEIGHT
 
     // Extract the type directory from the relative path.
@@ -116,6 +125,39 @@ export default class TestSuiteSplitter {
     return weight
   }
 
+  /**
+   * Keeps only usable positive finite duration entries keyed by normalized relative path.
+   * @param {ReturnType<typeof JSON.parse>} timingManifest - Parsed timing manifest.
+   * @returns {Record<string, number>} - Valid normalized duration weights.
+   */
+  normalizeTimingManifest(timingManifest) {
+    /** @type {Record<string, number>} */
+    const normalized = {}
+
+    if (!timingManifest || typeof timingManifest !== "object" || Array.isArray(timingManifest)) {
+      return normalized
+    }
+
+    for (const [filePath, duration] of Object.entries(timingManifest)) {
+      if (typeof duration === "number" && Number.isFinite(duration) && duration > 0) {
+        normalized[this.normalizeRelativePath(filePath)] = duration
+      }
+    }
+
+    return normalized
+  }
+
+  /**
+   * Normalizes a relative test path to the manifest's portable slash format.
+   * @param {string} filePath - Relative test path.
+   * @returns {string} - Normalized relative test path.
+   */
+  normalizeRelativePath(filePath) {
+    return filePath
+      .replaceAll("\\", "/")
+      .replace(/^\.\//, "")
+  }
+
   /**
    * Sorts files by weight descending, then by path for determinism.
    * @param {SplitterFileEntry[]} files - Weighted files.

package/package.json

@@ -3,7 +3,7 @@
     "velocious": "build/bin/velocious.js"
   },
   "name": "velocious",
-  "version": "1.0.581",
+  "version": "1.0.583",
   "main": "build/index.js",
   "types": "build/index.d.ts",
   "files": [
@@ -17,12 +17,15 @@
   "scripts": {
     "all-checks": "npm run lint && npm run test",
     "benchmark:factory-plan-reuse": "node benchmark/factory-plan-reuse.js",
+    "benchmark:insert-multiple-chunking": "node benchmark/insert-multiple-chunking.js",
     "benchmark:preloader-id-dedup": "node benchmark/preloader-id-dedup.js",
     "benchmark:mysql-result-row-materialization": "node benchmark/mysql-result-row-materialization.js",
     "benchmark:query-roundtrip-batching": "node benchmark/query-roundtrip-batching.js",
     "benchmark:websocket-outbound-queue": "node benchmark/websocket-outbound-queue.js",
     "benchmark:websocket-frame-buffering": "node benchmark/websocket-frame-buffering.js",
     "benchmark:http-client-content-length-byte-length": "node benchmark/http-client-content-length-byte-length.js",
+    "benchmark:frontend-model-serialization-resource-metadata": "node benchmark/frontend-model-serialization-resource-metadata.js",
+    "benchmark:sql-diagnostic-scans": "node --expose-gc benchmark/sql-diagnostic-scans.js",
     "build": "node scripts/clean-build.js && npm run compile",
     "compile": "tsc -b && npm run copy:js && npm run copy:ejs && npm run copy:templates && node scripts/ensure-bin-executable.js",
     "copy:js": "cpy \"index.js\" build && cpy \"bin/**/*.js\" build/bin && cpy \"src/**/*.js\" build --parents",

package/src/configuration-types.js

@@ -75,6 +75,8 @@
  * @property {boolean} [multipleStatements] - (MySQL) Opt in to multi-statement queries so a whole structure SQL dump loads in one round-trip via `StructureSqlLoader`. Off by default; ordinary queries otherwise reject stacked statements.
  * @property {number} [maxRowsPerInsert] - Maximum rows per `INSERT ... VALUES (...), (...), ...` statement generated by `Record.insertMultiple`. Defaults to 500.
  * @property {number} [maxInsertSqlBytes] - Maximum serialized SQL size, in bytes, for a single `INSERT ... VALUES (...), (...), ...` statement. Defaults to 1 MiB (1048576).
+ * @property {number} [maxInClauseValues] - Maximum values in a single `IN (...)` cohort used by preloads, association counts, and queryData aggregates. Defaults to 999.
+ * @property {number} [maxQuerySqlBytes] - Maximum serialized SQL size, in bytes, for a single cohort query used by preloads, association counts, and queryData aggregates. Defaults to 1 MiB (1048576).
  * @property {string} [password] - Password for the database user.
  * @property {number} [port] - Database port.
  * @property {string} [primaryKeyType] - Default type for implicit migration primary keys and references. Defaults to `uuid`.