velocious 1.0.667 → 1.0.668

package/build/testing/timing-manifest.js

@@ -1,346 +1,12 @@
 // @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"})
-}
+/** @typedef {import("@velocious/testing/node").TimingManifest} TimingManifest */
+/** @typedef {import("@velocious/testing/node").TestProfileTimingManifestInput} TestProfileTimingManifestInput */
+
+export {
+  canonicalTimingManifestPath,
+  compareTimingManifestPaths,
+  mergeTestProfileTimingManifests,
+  timingManifestFileSetHash,
+  validateTimingManifest
+} from "@velocious/testing/node"

package/build/testing/velocious-attempt-executor.js

@@ -148,10 +148,16 @@ export default class VelociousAttemptExecutor {
       await testRunner.registerTransactionalTenant(args, transactionalTenantRegistrations)
     }
     const profiler = testRunner._profiler
+    const profileTestData = {
+      ...test,
+      filePath: testData.filePath,
+      line: testData.line,
+      ownerFilePath: testData.ownerFilePath ?? metadata.ownerFilePath
+    }
     const profileAttempt = profiler?.startAttempt({
       descriptions,
       attemptNumber,
-      testData,
+      testData: profileTestData,
       testDescription
     })
 

package/package.json

@@ -3,7 +3,7 @@
     "velocious": "build/bin/velocious.js"
   },
   "name": "velocious",
-  "version": "1.0.667",
+  "version": "1.0.668",
   "main": "build/index.js",
   "types": "build/index.d.ts",
   "files": [
@@ -91,7 +91,7 @@
     "ws": "^8.21.3"
   },
   "peerDependencies": {
-    "@velocious/testing": "^0.0.12",
+    "@velocious/testing": "^0.0.14",
     "react": ">=18",
     "smtp-connection": "^4.0.2",
     "sqlite": "^5.1.1",
@@ -121,7 +121,7 @@
     "@types/react-dom": "^19.2.3",
     "@types/strftime": "^0.9.8",
     "@types/ws": "^8.18.1",
-    "@velocious/testing": "0.0.12",
+    "@velocious/testing": "0.0.14",
     "chokidar-cli": "^3.0.0",
     "cpy-cli": "^7.0.0",
     "esbuild": "^0.28.0",

package/scripts/test-browser.js

@@ -268,7 +268,7 @@ async function resolveConfiguration({testFilesRequireContextCallback} = {}) {
 
 /**
  * @param {string[]} processArgs - Process args.
- * @returns {Promise<{directory: string, testFiles: string[], lineFilters: Record<string, number[]>, includeTags: string[], excludeTags: string[], examplePatterns: RegExp[]}>} - Test data.
+ * @returns {Promise<{directory: string, testFiles: string[], lineFilters: Record<string, number[]>, includeTags: string[], excludeTags: string[], examplePatterns: RegExp[], retries: number | undefined, setupFiles: string[], timeoutMs: number | undefined}>} - Test data.
  */
 async function resolveTests(processArgs) {
   const directory = process.env.VELOCIOUS_TEST_DIR
@@ -278,7 +278,15 @@ async function resolveTests(processArgs) {
     ? [directory]
     : [`${rootDir}/__tests__`, `${rootDir}/tests`, `${rootDir}/spec`]
 
-  const {includeTags, excludeTags, examplePatterns, filteredProcessArgs} = parseFilters(processArgs)
+  const {
+    includeTags,
+    excludeTags,
+    examplePatterns,
+    filteredProcessArgs,
+    retries,
+    setupFiles,
+    timeoutMs
+  } = parseFilters(processArgs)
   const testFilesFinder = new TestFilesFinder({
     directory,
     directories,
@@ -298,7 +306,10 @@ async function resolveTests(processArgs) {
     lineFilters: testFilesFinder.getLineFiltersByFile(),
     includeTags,
     excludeTags,
-    examplePatterns: normalizeExamplePatterns(examplePatterns)
+    examplePatterns: normalizeExamplePatterns(examplePatterns),
+    retries,
+    setupFiles: setupFiles.map((setupFile) => path.resolve(process.cwd(), setupFile)),
+    timeoutMs
   }
 }
 
@@ -372,9 +383,18 @@ async function runBrowserTests() {
 
   await buildBrowserTestApp()
 
-  const {testFiles, lineFilters, includeTags, excludeTags, examplePatterns} = await resolveTests(processArgs)
+  const {
+    testFiles,
+    lineFilters,
+    includeTags,
+    excludeTags,
+    examplePatterns,
+    retries,
+    setupFiles,
+    timeoutMs
+  } = await resolveTests(processArgs)
   const configuration = await resolveConfiguration({
-    testFilesRequireContextCallback: async () => createTestFilesRequireContext(testFiles)
+    testFilesRequireContextCallback: async () => createTestFilesRequireContext([...setupFiles, ...testFiles])
   })
   const testRunner = new TestRunner({
     configuration,
@@ -382,7 +402,10 @@ async function runBrowserTests() {
     includeTags,
     testFiles,
     lineFilters,
-    examplePatterns
+    examplePatterns,
+    retries,
+    setupFiles,
+    timeoutMs
   })
   /** @type {BrowserTestSession | undefined} */
   let browserTestSession

package/scripts/verify-docker-dev-environment.js

@@ -18,6 +18,7 @@ const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), ".."
 
 const APPROVED_BASE_DIGEST = "sha256:3131b4cc82a783df6c9df078f86e01819a13594b865c2cad47bd1bca2b7063bb"
 const PROVIDER_PACKAGES = ["@moonshot-ai/kimi-code", "@openai/codex", "@anthropic-ai/claude-code", "opencode-ai"]
+const QWEN_CODE_SPEC = "@qwen-code/qwen-code@0.23.3"
 const COMPOSE_CREDENTIAL_VALUE_PATTERN = /^\s+[A-Z][A-Z0-9_]*(?:API_KEY|TOKEN|SECRET|PASSWORD|CREDENTIALS?)[A-Z0-9_]*:\s*\S.*$/mu
 
 // The complete universal apt coding/debugging baseline shared with the
@@ -198,7 +199,18 @@ function verifyDockerfile(content) {
     problems.push("Missing --allow-scripts lifecycle-script allowlisting")
   }
 
-  for (const probe of ["kimi --version", "codex --version", "claude --version", "opencode --version"]) {
+  if (!content.includes("@qwen-code/audio-capture")) {
+    problems.push("Missing Qwen audio-capture lifecycle-script allowlisting")
+  }
+
+  if (!content.includes(`"${QWEN_CODE_SPEC}"`)) {
+    problems.push(`Missing owner-pinned Qwen Code install spec: ${QWEN_CODE_SPEC}`)
+  }
+  if (!content.includes('test "$(qwen --version)" = "0.23.3"')) {
+    problems.push("Missing exact Qwen Code 0.23.3 verification")
+  }
+
+  for (const probe of ["kimi --version", "codex --version", "claude --version", "opencode --version", "qwen --version"]) {
     if (!content.includes(probe)) {
       problems.push(`Missing provider CLI command probe: ${probe}`)
     }

package/src/configuration.js

@@ -408,6 +408,13 @@ export default class VelociousConfiguration {
      * @type {Map<string, typeof import("./http-server/websocket-channel.js").default>} */
     this._websocketChannelClasses = new Map()
 
+    /**
+     * Channel types registered with `{liveOnly: true}`: their traffic is
+     * never persisted for replay, and `markChannelInterested` rejects the
+     * name.
+     * @type {Set<string>} */
+    this._liveOnlyWebsocketChannels = new Set()
+
     /**
      * Stores the websocket channel subscriptions value.
      * @type {Map<string, Set<import("./http-server/websocket-channel.js").default>>} - channelType → live subscriptions across all sessions.
@@ -1126,6 +1133,7 @@ export default class VelociousConfiguration {
     }
 
     return {
+      liveOnlyChannels: Array.from(this._liveOnlyWebsocketChannels),
       pausedSessions: this._pausedWebsocketSessions.size,
       registeredChannels: Array.from(this._websocketChannelClasses.keys()),
       registeredConnections: Array.from(this._websocketConnectionClasses.keys()),
@@ -2966,12 +2974,15 @@ export default class VelociousConfiguration {
    * Clients subscribe via `{type: "channel-subscribe", channelType: name, ...}`.
    * @param {string} name - Client-facing channel type name.
    * @param {typeof import("./http-server/websocket-channel.js").default} ChannelClass - Websocket channel class.
+   * @param {{liveOnly?: boolean}} [options] - Registration options.
    * @returns {void}
    */
-  registerWebsocketChannel(name, ChannelClass) {
+  registerWebsocketChannel(name, ChannelClass, {liveOnly = false} = {}) {
     if (!name) throw new Error("Channel name is required")
     if (!ChannelClass) throw new Error("ChannelClass is required")
     this._websocketChannelClasses.set(name, ChannelClass)
+
+    if (liveOnly) this._liveOnlyWebsocketChannels.add(name)
   }
 
   /**
@@ -2983,6 +2994,17 @@ export default class VelociousConfiguration {
     return this._websocketChannelClasses.get(name)
   }
 
+  /**
+   * Whether a channel type was registered with `{liveOnly: true}`.
+   * Live-only channels are never persisted for replay: the event-log
+   * store's `markChannelInterested` throws for their names.
+   * @param {string} name - Channel type name to look up.
+   * @returns {boolean} - Whether the channel is declared live-only.
+   */
+  isWebsocketChannelLiveOnly(name) {
+    return this._liveOnlyWebsocketChannels.has(name)
+  }
+
   /**
    * Tracks a live channel subscription in the global routing registry.
    * Called by the session when `canSubscribe()` resolves truthy; the

package/src/environment-handlers/node/cli/commands/test/timing-manifest/merge.js

@@ -1,8 +1,8 @@
 // @ts-check
 
 import BaseCommand from "../../../../../../cli/base-command.js"
+import { parseTimingManifestMergeArguments as parsePackageTimingManifestMergeArguments } from "@velocious/testing/node"
 import fs from "node:fs/promises"
-import path from "node:path"
 import { writeTimingManifest } from "../../../../../../testing/test-profile-output.js"
 import { mergeTestProfileTimingManifests } from "../../../../../../testing/timing-manifest.js"
 
@@ -51,24 +51,6 @@ export default class TestTimingManifestMerge extends BaseCommand {
   }
 }
 
-/**
- * Recognizes one output option spelling.
- * @param {string} argument - Current argument.
- * @param {string | undefined} nextArgument - Following argument.
- * @returns {{matched: boolean, skipNext: boolean, value: string | undefined}} - Parsed output option.
- */
-function timingManifestOutputArgument(argument, nextArgument) {
-  if (argument === "--output") {
-    return {matched: true, skipNext: true, value: nextArgument}
-  }
-
-  if (argument.startsWith("--output=")) {
-    return {matched: true, skipNext: false, value: argument.slice("--output=".length)}
-  }
-
-  return {matched: false, skipNext: false, value: undefined}
-}
-
 /**
  * Parses strict merge arguments and resolves their paths.
  * @param {string[]} processArgs - Raw CLI arguments, including command name.
@@ -76,33 +58,5 @@ function timingManifestOutputArgument(argument, nextArgument) {
  * @returns {TimingManifestMergeArguments} - Validated resolved paths.
  */
 export function parseTimingManifestMergeArguments(processArgs, cwd) {
-  const commandName = processArgs[0] || "test:timing-manifest:merge"
-  const inputPaths = []
-  let outputPath
-
-  for (let index = 1; index < processArgs.length; index++) {
-    const argument = processArgs[index]
-    const outputArgument = timingManifestOutputArgument(argument, processArgs[index + 1])
-
-    if (outputArgument.matched) {
-      if (!outputArgument.value || outputArgument.value.startsWith("-")) throw new Error("Missing value for --output")
-      if (outputPath) throw new Error("--output may only be provided once")
-      outputPath = path.resolve(cwd, outputArgument.value)
-      if (outputArgument.skipNext) index++
-      continue
-    }
-
-    if (argument.startsWith("-")) throw new Error(`Unknown argument for ${commandName}: ${argument}`)
-    inputPaths.push(path.resolve(cwd, argument))
-  }
-
-  if (!outputPath) throw new Error("--output is required")
-  if (inputPaths.length === 0) throw new Error("At least one rich test profile input is required")
-
-  const uniqueInputPaths = new Set(inputPaths)
-
-  if (uniqueInputPaths.size !== inputPaths.length) throw new Error("Each rich test profile input must be provided once")
-  if (uniqueInputPaths.has(outputPath)) throw new Error("Timing manifest output must not overwrite an input profile")
-
-  return {inputPaths, outputPath}
+  return parsePackageTimingManifestMergeArguments(processArgs.slice(1), {cwd})
 }