velocious 1.0.666 → 1.0.668

package/src/http-server/websocket-event-log-store.js

@@ -11,6 +11,7 @@ import Logger from "../logger.js"
  * @property {Date | string} created_at - Creation time.
  * @property {string} id - Event id.
  * @property {string} payload_json - Serialized payload.
+ * @property {string | null} params_json - Serialized broadcast params, or null when the publish carried none.
  * @property {number | string} sequence - Sequence number.
  */
 /**
@@ -18,6 +19,16 @@ import Logger from "../logger.js"
  * @typedef {object} WebsocketReplayChannelRow
  * @property {string} channel - Channel name.
  */
+/**
+ * Normalized persisted websocket event.
+ * @typedef {object} WebsocketPersistedEvent
+ * @property {string} channel - Channel name.
+ * @property {string} createdAt - ISO creation time.
+ * @property {string} id - Event id.
+ * @property {Record<string, ReturnType<typeof JSON.parse>> | null} params - Persisted broadcast params, or null when the publish carried none.
+ * @property {ReturnType<typeof JSON.parse>} payload - Event payload.
+ * @property {number} sequence - Sequence number.
+ */
 const EVENTS_TABLE = "websocket_channel_events"
 const REPLAY_CHANNELS_TABLE = "websocket_replay_channels"
 const DEFAULT_RETENTION_MS = 10 * 60 * 1000
@@ -100,22 +111,40 @@ export default class VelociousHttpServerWebsocketEventLogStore {
 
   /**
    * Runs schema present.
-   * @returns {Promise<boolean>} - Whether both event-log tables physically exist.
+   * @returns {Promise<boolean>} - Whether both event-log tables exist and the events table carries every required column.
    */
   async _schemaPresent() {
     return await this._withDb(async (db) =>
-      await db.tableExists(EVENTS_TABLE) && await db.tableExists(REPLAY_CHANNELS_TABLE)
+      (await db.tableExists(EVENTS_TABLE) && await db.tableExists(REPLAY_CHANNELS_TABLE))
+      && (await this._columnPresent(db, EVENTS_TABLE, "params_json"))
     )
   }
 
+  /**
+   * Runs column present.
+   * @param {import("../database/drivers/base.js").default} db - Database connection.
+   * @param {string} tableName - Table name.
+   * @param {string} columnName - Column name.
+   * @returns {Promise<boolean>} - Whether the column exists on the table.
+   */
+  async _columnPresent(db, tableName, columnName) {
+    const tables = await db.getTables()
+    const table = tables.find((candidate) => candidate.getName() == tableName)
+
+    if (!table) return false
+
+    return (await table.getColumnByName(columnName)) !== undefined
+  }
+
   /**
    * Runs append event.
    * @param {object} args - Options.
    * @param {string} args.channel - Channel name.
    * @param {ReturnType<typeof JSON.parse>} args.payload - Event payload.
-   * @returns {Promise<{channel: string, createdAt: string, id: string, payload: ReturnType<typeof JSON.parse>}>} - Persisted event row.
+   * @param {Record<string, ReturnType<typeof JSON.parse>> | null} [args.params] - Broadcast params to persist for stream-scoped replay, or null when the publish carried none.
+   * @returns {Promise<WebsocketPersistedEvent>} - Persisted event row.
    */
-  async appendEvent({channel, payload}) {
+  async appendEvent({channel, params = null, payload}) {
     await this.ensureReady()
 
     const id = randomUUID()
@@ -128,10 +157,11 @@ export default class VelociousHttpServerWebsocketEventLogStore {
           channel,
           created_at: createdAt,
           id,
+          params_json: params === null ? null : JSON.stringify(params),
           payload_json: JSON.stringify(payload)
         }
       })
-      return {channel, createdAt: createdAt.toISOString(), id, payload}
+      return {channel, createdAt: createdAt.toISOString(), id, params, payload}
     })
   }
 
@@ -139,8 +169,13 @@ export default class VelociousHttpServerWebsocketEventLogStore {
    * Runs mark channel interested.
    * @param {string} channel - Channel name.
    * @returns {Promise<void>} - Resolves when the channel interest was persisted.
+   * @throws {Error} When the channel is registered live-only, which forbids replay persistence.
    */
   async markChannelInterested(channel) {
+    if (this.configuration.isWebsocketChannelLiveOnly(channel)) {
+      throw new Error(`Websocket channel "${channel}" is registered live-only and cannot be marked interested in replay persistence`)
+    }
+
     await this.ensureReady()
 
     const interestedUntil = new Date(Date.now() + this.retentionMs)
@@ -158,6 +193,12 @@ export default class VelociousHttpServerWebsocketEventLogStore {
    * @returns {Promise<boolean>} - Whether the channel should be persisted for replay.
    */
   async shouldPersistChannel(channel) {
+    // A channel re-registered live-only can still hold cached or durable
+    // interest state from before the re-registration; the live-only
+    // contract must hold at the persistence decision, not only at
+    // interest marking.
+    if (this.configuration.isWebsocketChannelLiveOnly(channel)) return false
+
     if (this._channelInterestCached(channel)) return true
     if (this._interestedChannels.size === 0) return false
 
@@ -197,7 +238,7 @@ export default class VelociousHttpServerWebsocketEventLogStore {
    * @param {object} args - Options.
    * @param {string} args.channel - Channel name.
    * @param {string} args.id - Event id.
-   * @returns {Promise<{channel: string, createdAt: string, id: string, payload: ReturnType<typeof JSON.parse>, sequence: number} | null>} - Event row or null.
+   * @returns {Promise<WebsocketPersistedEvent | null>} - Event row or null.
    */
   async getEventById({channel, id}) {
     await this.ensureReady()
@@ -237,7 +278,7 @@ export default class VelociousHttpServerWebsocketEventLogStore {
    * @param {string} args.channel - Channel name.
    * @param {number} args.sequence - Lower bound sequence.
    * @param {number | null | undefined} [args.upToSequence] - Inclusive ceiling sequence.
-   * @returns {Promise<Array<{channel: string, createdAt: string, id: string, payload: ReturnType<typeof JSON.parse>, sequence: number}>>} - Ordered events.
+   * @returns {Promise<WebsocketPersistedEvent[]>} - Ordered events.
    */
   async getEventsAfter({channel, sequence, upToSequence}) {
     await this.ensureReady()
@@ -312,24 +353,55 @@ export default class VelociousHttpServerWebsocketEventLogStore {
    * @returns {Promise<void>} - Resolves when complete.
    */
   async _ensureEventsTable(db) {
-    this.logger.info("Applying websocket event-log schema")
-
     if (await db.tableExists(EVENTS_TABLE)) {
-      this.logger.info("Websocket event-log table already exists - skipping create")
+      await this._ensureEventsTableColumns(db)
       return
     }
 
+    this.logger.info("Applying websocket event-log schema")
+
     const eventTable = new TableData(EVENTS_TABLE, {ifNotExists: true})
 
     eventTable.integer("sequence", {autoIncrement: true, null: false, primaryKey: true})
     eventTable.string("id", {index: true, null: false})
     eventTable.string("channel", {index: true, null: false})
+    eventTable.text("params_json", {null: true})
     eventTable.text("payload_json", {null: false})
     eventTable.datetime("created_at", {index: true, null: false})
 
     await db.createTable(eventTable)
   }
 
+  /**
+   * Adds columns the current schema requires to an events table created by an
+   * older framework version, so upgrades keep working without a manual ALTER.
+   * @param {import("../database/drivers/base.js").default} db - Database connection.
+   * @returns {Promise<void>} - Resolves when the events table schema is current.
+   */
+  async _ensureEventsTableColumns(db) {
+    if (await this._columnPresent(db, EVENTS_TABLE, "params_json")) return
+
+    this.logger.info("Adding params_json column to websocket event-log table")
+
+    const tableData = new TableData(EVENTS_TABLE)
+
+    tableData.addColumn("params_json", {isNewColumn: true, null: true, type: "text"})
+
+    try {
+      for (const sql of await db.alterTableSQLs(tableData)) {
+        await db.query(sql)
+      }
+    } catch (error) {
+      // A concurrent process can add the column between the presence check
+      // and the ALTER (multi-worker or rolling upgrade); the
+      // duplicate-column failure is then the expected outcome, not a real
+      // error. Anything else re-checks as absent and rethrows.
+      if (await this._columnPresent(db, EVENTS_TABLE, "params_json")) return
+
+      throw error
+    }
+  }
+
   /**
    * Runs ensure replay channels table.
    * @param {import("../database/drivers/base.js").default} db - Database connection.
@@ -352,7 +424,7 @@ export default class VelociousHttpServerWebsocketEventLogStore {
    * @param {string} args.channel - Channel name.
    * @param {import("../database/drivers/base.js").default} args.db - Database connection.
    * @param {string} args.id - Event id.
-   * @returns {Promise<{channel: string, createdAt: string, id: string, payload: ReturnType<typeof JSON.parse>, sequence: number} | null>} - Event row or null.
+   * @returns {Promise<WebsocketPersistedEvent | null>} - Event row or null.
    */
   async _getEventById({channel, db, id}) {
     const rows = /** @type {WebsocketEventRow[]} */ (await db
@@ -370,7 +442,7 @@ export default class VelociousHttpServerWebsocketEventLogStore {
   /**
    * Runs normalize event row.
    * @param {WebsocketEventRow} row - Raw row.
-   * @returns {{channel: string, createdAt: string, id: string, payload: ReturnType<typeof JSON.parse>, sequence: number}} - Normalized row.
+   * @returns {WebsocketPersistedEvent} - Normalized row.
    */
   _normalizeEventRow(row) {
     const createdAtValue = row.created_at
@@ -379,6 +451,7 @@ export default class VelociousHttpServerWebsocketEventLogStore {
       channel: row.channel,
       createdAt: createdAtValue instanceof Date ? createdAtValue.toISOString() : new Date(createdAtValue).toISOString(),
       id: row.id,
+      params: row.params_json === null || row.params_json === undefined ? null : JSON.parse(row.params_json),
       payload: JSON.parse(row.payload_json),
       sequence: Number(row.sequence)
     }

package/src/http-server/websocket-events-host.js

@@ -116,7 +116,7 @@ export class VelociousHttpServerWebsocketEventsHost {
     // Other channels chain onto their own tails and are not delayed.
     this._queuePublish({
       callback: async () => {
-        const persistedEvent = await this._persistV2EventIfNeeded({body, channel, configuration})
+        const persistedEvent = await this._persistV2EventIfNeeded({body, broadcastParams, channel, configuration})
         const dispatchedTargets = new Set()
 
         for (const handler of this.broadcastHandlersByConfiguration.get(configuration) || []) {
@@ -159,7 +159,9 @@ export class VelociousHttpServerWebsocketEventsHost {
 
     if (configuration) {
       queuedPublish = previousTail.then(() => configuration.withoutCurrentTestDatabaseAccessScope(() => {
-        return configuration.withoutCurrentConnectionContexts(callback)
+        return configuration.withoutCurrentConnectionContexts(() => {
+          return configuration.runWithTestSharedConnectionContexts(callback)
+        })
       }))
     } else {
       queuedPublish = previousTail.then(callback)
@@ -191,12 +193,13 @@ export class VelociousHttpServerWebsocketEventsHost {
    * Runs persist v2 event if needed.
    * @param {object} args - Options.
    * @param {ReturnType<typeof JSON.parse>} args.body - Event body.
+   * @param {Record<string, ReturnType<typeof JSON.parse>>} args.broadcastParams - Routing filter params.
    * @param {string} args.channel - Channel name.
    * @param {import("../configuration.js").default} args.configuration - Originating configuration.
    * @returns {Promise<{createdAt: string, id: string} | null>} - Persisted event metadata when storage is enabled.
    */
-  async _persistV2EventIfNeeded({body, channel, configuration}) {
-    return await this._persistChannelEventIfNeeded({channel, payload: body, configuration})
+  async _persistV2EventIfNeeded({body, broadcastParams, channel, configuration}) {
+    return await this._persistChannelEventIfNeeded({broadcastParams, channel, configuration, payload: body})
   }
 
   /**
@@ -211,14 +214,18 @@ export class VelociousHttpServerWebsocketEventsHost {
   }
 
   /**
-   * Runs persist channel event if needed.
+   * Runs persist channel event if needed. Persists the broadcast's routing
+   * params (sanitized through the channel class's
+   * `replayableBroadcastParams`) so replay can re-apply `matches()` per
+   * stream instead of delivering the whole channel's log.
    * @param {object} args - Options object.
+   * @param {Record<string, ReturnType<typeof JSON.parse>> | null} [args.broadcastParams] - Broadcast params to persist for stream-scoped replay.
    * @param {string} args.channel - Channel name.
    * @param {ReturnType<typeof JSON.parse>} args.payload - Payload data.
    * @param {import("../configuration.js").default} [args.configuration] - Configuration owning the event store.
    * @returns {Promise<{createdAt: string, id: string} | null>} - Persisted event metadata.
    */
-  async _persistChannelEventIfNeeded({channel, payload, configuration}) {
+  async _persistChannelEventIfNeeded({broadcastParams = null, channel, configuration, payload}) {
     const handler = this.handlers.values().next().value
     const eventConfiguration = configuration || handler?.configuration
 
@@ -229,7 +236,10 @@ export class VelociousHttpServerWebsocketEventsHost {
 
     if (!shouldPersist) return null
 
-    const persistedEvent = await websocketEventLogStore.appendEvent({channel, payload})
+    const ChannelClass = eventConfiguration.getWebsocketChannelClass(channel)
+    const params = ChannelClass ? ChannelClass.replayableBroadcastParams(broadcastParams) : broadcastParams
+
+    const persistedEvent = await websocketEventLogStore.appendEvent({channel, params, payload})
 
     return {
       createdAt: persistedEvent.createdAt,

package/src/testing/test-files-finder.js

@@ -1,364 +1,53 @@
 // @ts-check
 
-import fs from "fs/promises"
-import path from "path"
+import {
+  discoverTestFiles,
+  lineFiltersFromCandidates
+} from "@velocious/testing/node"
 
-import fileExists from "../utils/file-exists.js"
-import Logger from "../logger.js"
 import restArgsError from "../utils/rest-args-error.js"
 
-// Incredibly complex class to find files in multiple simultanious running promises to do it as fast as possible.
-export default class TestFilesFinder {
-  static IGNORED_NAMES = [".git", "node_modules"]
+const VELOCIOUS_NODE_TEST_PATTERN = /(?<!\.browser)-(?:spec|test)\.(?:m)?js$/u
 
+/** Compatibility facade for Velocious's published test-file finder path. */
+export default class TestFilesFinder {
   /**
-   * Runs constructor.
-   * @param {object} args - Options object.
-   * @param {string} args.directory - Directory path.
-   * @param {string[]} [args.directories] - Directories.
-   * @param {string[]} args.processArgs - Process args.
+   * Creates a Velocious-compatible package discovery adapter.
+   * @param {object} args - Discovery options.
+   * @param {string} args.directory - Discovery base directory.
+   * @param {string[]} [args.directories] - Default directories.
+   * @param {RegExp} [args.filePattern] - Test-file pattern override.
+   * @param {string[]} args.processArgs - Process arguments including the command name.
    */
-  constructor({directory, directories, processArgs, ...restArgs}) {
+  constructor({directory, directories, filePattern, processArgs, ...restArgs}) {
     restArgsError(restArgs)
-
-    this.directory = path.resolve(directory)
-    this.logger = new Logger(this)
-
-    if (directories) {
-      this.directories = directories.map((entry) => path.resolve(entry))
-    } else {
-      this.directories = [
-        `${this.directory}/__tests__`,
-        `${this.directory}/tests`,
-        `${this.directory}/spec`
-      ]
-    }
-
-    this.findingCount = 0
-    this.processArgs = processArgs
-
-    /**
-     * Narrows the runtime value to the documented type.
-     * @type {string[]} */
-    this.foundFiles = []
-
-    /**
-     * Narrows the runtime value to the documented type.
-     * @type {Record<number, Promise<void>>} */
-    this.findingPromises = {}
-
-    /**
-     * Narrows the runtime value to the documented type.
-     * @type {string[]} */
-    this.testArgs = this.processArgs.filter((processArg, index) => index != 0)
-
-    /**
-     * Narrows the runtime value to the documented type.
-     * @type {string[]} */
-    this.directoryArgs = []
-
-    /**
-     * Narrows the runtime value to the documented type.
-     * @type {string[]} */
-    this.directoryFullPaths = []
-
-    /**
-     * Narrows the runtime value to the documented type.
-     * @type {string[]} */
-    this.fileArgs = []
-
-    /**
-     * Narrows the runtime value to the documented type.
-     * @type {string[]} */
-    this.explicitFiles = []
-
-    /**
-     * Narrows the runtime value to the documented type.
-     * @type {Record<string, number[]>} */
-    this.lineFiltersByFile = {}
-
-    this._argsPrepared = false
+    this.directory = directory
+    this.directories = directories
+    this.filePattern = filePattern
+    this.candidates = processArgs.slice(1).filter((argument) => argument !== "--")
+    /** @type {Record<string, number[]>} */
+    this.lineFiltersByFile = lineFiltersFromCandidates({
+      cwd: directory,
+      candidates: this.candidates
+    })
   }
 
   /**
-   * Runs find test files.
-   * @returns {Promise<string[]>} - Resolves with the test files.
+   * Discovers test files through the package implementation.
+   * @returns {Promise<string[]>} - Discovered absolute file paths.
    */
   async findTestFiles() {
-    await this.prepareArgs()
-
-    if (this.explicitFiles.length > 0 && this.directoryArgs.length === 0) {
-      return Array.from(new Set(this.explicitFiles))
-    }
-
-    await this.withFindingCount(async () => {
-      const hasExplicitArgs = this.directoryFullPaths.length > 0 || this.fileArgs.length > 0
-      const directoriesToScan = hasExplicitArgs ? this.directoryFullPaths : this.directories
-
-      for (const directory of directoriesToScan) {
-        if (await fileExists(directory)) {
-          await this.findTestFilesInDir(directory)
-        }
-      }
+    return await discoverTestFiles({
+      cwd: this.directory,
+      candidates: this.candidates,
+      directories: this.directories,
+      filePattern: this.filePattern || VELOCIOUS_NODE_TEST_PATTERN
     })
-
-    await this.waitForFindingPromises()
-
-    if (this.explicitFiles.length > 0) {
-      this.foundFiles.push(...this.explicitFiles)
-    }
-
-    return Array.from(new Set(this.foundFiles))
   }
 
   /**
-   * Runs get line filters by file.
-   * @returns {Record<string, number[]>} - Line filters by file.
+   * Gets candidate-derived line filters.
+   * @returns {Record<string, number[]>} - Line filters keyed by absolute file path.
    */
   getLineFiltersByFile() { return this.lineFiltersByFile }
-
-  /**
-   * Runs finding promises length.
-   * @returns {number} - The ing promises length.
-   */
-  findingPromisesLength() { return Object.keys(this.findingPromises).length }
-
-  async waitForFindingPromises() {
-    while (this.findingPromisesLength() > 0) {
-      await this.waitForFindingPromisesIteration()
-    }
-  }
-
-  /**
-   * Runs wait for finding promises iteration.
-   * @returns {Promise<void>} - Resolves when complete.
-   */
-  async waitForFindingPromisesIteration() {
-    const unfinishedPromises = []
-
-    for (const findingPromiseId in this.findingPromises) {
-      const findingPromise = this.findingPromises[findingPromiseId]
-
-      unfinishedPromises.push(findingPromise)
-    }
-
-    await Promise.all(unfinishedPromises)
-  }
-
-  /**
-   * Runs with finding count.
-   * @param {() => Promise<void>} callback - Callback function.
-   * @returns {Promise<void>} - Resolves when complete.
-   */
-  withFindingCount(callback) {
-    return new Promise((resolve) => {
-      const findingPromise = callback()
-      const findingCount = this.findingCount
-
-      this.findingCount += 1
-      this.findingPromises[findingCount] = findingPromise
-
-      findingPromise.finally(() => {
-        delete this.findingPromises[findingCount]
-
-        resolve(undefined)
-      })
-    })
-  }
-
-  /**
-   * Runs find test files in dir.
-   * @param {string} dir - Dir.
-   * @returns {Promise<void>} - Resolves when complete.
-   */
-  async findTestFilesInDir(dir) {
-    await this.withFindingCount(async () => {
-      const files = await fs.readdir(dir)
-
-      for (const file of files) {
-        if (TestFilesFinder.IGNORED_NAMES.includes(file)) {
-          continue
-        }
-
-        const fullPath = `${dir}/${file}`
-        const localPath = fullPath.replace(`${this.directory}/`, "")
-        const isDir = (await fs.stat(fullPath)).isDirectory()
-
-        if (isDir) {
-          this.findTestFilesInDir(fullPath)
-        } else {
-          if (this.isFileMatchingRequirements(file, localPath)) {
-            this.foundFiles.push(fullPath)
-          }
-        }
-      }
-    })
-  }
-
-  /**
-   * Runs is file matching requirements.
-   * @param {string} file - File.
-   * @param {string} localPath - Local path.
-   * @returns {boolean} - Whether file matching requirements.
-   */
-  isFileMatchingRequirements(file, localPath) {
-    if (this.directoryArgs.length > 0) {
-      for (const directoryArg of this.directoryArgs) {
-        if (localPath.startsWith(directoryArg) && this.looksLikeTestFile(file)) {
-          this.logger.debug("Found test file because matching dir and looks like this file:", file)
-          return true
-        }
-      }
-    }
-
-    if (this.fileArgs.length > 0) {
-      for (const fileArg of this.fileArgs) {
-        if (fileArg == localPath) {
-          this.logger.debug("Found test file because matching file arg:", file)
-          return true
-        }
-      }
-    }
-
-    if (this.fileArgs.length == 0 && this.directoryArgs.length == 0 && this.looksLikeTestFile(file)) {
-      this.logger.debug("Found test file because looks like this file:", file)
-      return true
-    }
-
-    return false
-  }
-
-  /**
-   * Runs looks like test file.
-   * @param {string} file - File.
-   * @returns {boolean} - Whether looks like test file.
-   */
-  looksLikeTestFile(file) {
-    return Boolean(file.match(/-(spec|test)\.(m|)js$/))
-  }
-
-  /**
-   * Runs prepare args.
-   * @returns {Promise<void>} - Resolves when test args are prepared.
-   */
-  async prepareArgs() {
-    if (this._argsPrepared) return
-
-    for (const testArg of this.testArgs) {
-      if (testArg === "--") continue
-
-      const {cleanArg, line} = this.splitLineArg(testArg)
-      const forceDirectory = testArg.endsWith("/") || testArg.endsWith(path.sep)
-      const fullPath = path.isAbsolute(cleanArg) ? cleanArg : path.resolve(this.directory, cleanArg)
-      const baseName = path.basename(this.directory)
-      const hasBasePrefix = cleanArg === baseName || cleanArg.startsWith(`${baseName}/`) || cleanArg.startsWith(`${baseName}${path.sep}`)
-      const basePrefixedFullPath = (!path.isAbsolute(cleanArg) && hasBasePrefix) ? path.resolve(path.dirname(this.directory), cleanArg) : null
-      const fullPathCandidates = basePrefixedFullPath ? [basePrefixedFullPath] : [fullPath]
-
-      if (forceDirectory) {
-        const preferredLocalPath = this.toLocalPath(basePrefixedFullPath || fullPath)
-        this.directoryArgs.push(this.ensureTrailingSlash(preferredLocalPath))
-        this.directoryFullPaths.push(path.resolve(basePrefixedFullPath || fullPath))
-        continue
-      }
-
-      try {
-        let stats
-        let resolvedFullPath
-
-        for (const candidatePath of fullPathCandidates) {
-          try {
-            stats = await fs.stat(candidatePath)
-            resolvedFullPath = candidatePath
-            break
-          } catch {
-            // Keep searching
-          }
-        }
-
-        if (!stats || !resolvedFullPath) throw new Error("Path not found")
-        const localPath = this.toLocalPath(resolvedFullPath)
-
-        if (stats.isDirectory()) {
-          this.directoryArgs.push(this.ensureTrailingSlash(localPath))
-          this.directoryFullPaths.push(resolvedFullPath)
-        } else if (stats.isFile()) {
-          this.fileArgs.push(localPath)
-          this.explicitFiles.push(resolvedFullPath)
-
-          if (line) {
-            this.addLineFilter(resolvedFullPath, line)
-          }
-        }
-      } catch {
-        const fallbackLocalPath = this.toLocalPath(basePrefixedFullPath || fullPath)
-        this.fileArgs.push(fallbackLocalPath)
-
-        if (line) {
-          this.addLineFilter(basePrefixedFullPath || fullPath, line)
-        }
-      }
-    }
-
-    this._argsPrepared = true
-  }
-
-  /**
-   * Runs add line filter.
-   * @param {string} filePath - File path.
-   * @param {number} line - Line number.
-   * @returns {void} - No return value.
-   */
-  addLineFilter(filePath, line) {
-    const fullPath = path.resolve(filePath)
-
-    if (!this.lineFiltersByFile[fullPath]) {
-      this.lineFiltersByFile[fullPath] = []
-    }
-
-    if (!this.lineFiltersByFile[fullPath].includes(line)) {
-      this.lineFiltersByFile[fullPath].push(line)
-    }
-  }
-
-  /**
-   * Runs split line arg.
-   * @param {string} testArg - Test arg.
-   * @returns {{cleanArg: string, line?: number}} - Cleaned arg and line.
-   */
-  splitLineArg(testArg) {
-    const match = testArg.match(/^(.*):(\d+)$/)
-
-    if (!match) {
-      return {cleanArg: testArg}
-    }
-
-    const line = Number(match[2])
-
-    if (!Number.isFinite(line)) {
-      return {cleanArg: testArg}
-    }
-
-    return {cleanArg: match[1], line}
-  }
-
-  /**
-   * Runs ensure trailing slash.
-   * @param {string} localPath - Local path.
-   * @returns {string} - Normalized local path with trailing slash.
-   */
-  ensureTrailingSlash(localPath) {
-    if (localPath === "") return localPath
-    return localPath.endsWith("/") ? localPath : `${localPath}/`
-  }
-
-  /**
-   * Runs to local path.
-   * @param {string} fullPath - Full path.
-   * @returns {string} - Local path relative to the base directory.
-   */
-  toLocalPath(fullPath) {
-    const relativePath = path.relative(this.directory, fullPath)
-    return relativePath.split(path.sep).join("/")
-  }
 }