@remix-run/assets 0.4.4 → 0.6.0

package/src/lib/inspection.ts

@@ -0,0 +1,229 @@
+import * as fs from 'node:fs'
+import * as fsPromises from 'node:fs/promises'
+import * as path from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+import type { AccessPolicy, AssetAccessDetails } from './access.ts'
+import { parseFingerprintSuffix } from './fingerprint.ts'
+import { getInjectedPackageRoots } from './injected-packages.ts'
+import { isAbsoluteFilePath, normalizeFilePath, resolveFilePath } from './paths.ts'
+import type { AssetRouteMatch, CompiledRoutes } from './routes.ts'
+import { supportedScriptExtensions } from './scripts/resolve.ts'
+import { isStyleFilePath } from './styles/compiler.ts'
+
+const scriptExtensions = new Set<string>(supportedScriptExtensions)
+const globSyntaxPattern = /[*?[\]{}()!+@]/
+
+/** How the asset server handles an inspected file. */
+export type AssetKind = 'file' | 'script' | 'style' | 'unsupported'
+
+/** Browser-reachability result for an inspected asset. */
+export type AssetStatus =
+  | 'denied'
+  | 'missing'
+  | 'not-allowed'
+  | 'reachable'
+  | 'unmapped'
+  | 'unsupported'
+
+/** Diagnostic information about a configured asset URL or file path. */
+export interface AssetDetails {
+  /** Access-control decision and the rules responsible for it. */
+  access?: AssetAccessDetails
+  /** Absolute mapped file path. */
+  filePath?: string
+  /** Configured filesystem mount root that matched the asset. */
+  fileRoot?: string
+  /** Browser-reachability result. */
+  status: AssetStatus
+  /** How the asset server handles the file. */
+  type?: AssetKind
+  /** Stable public URL pathname for the asset. */
+  url?: string
+  /** Public mount root that matched the asset. */
+  urlRoot?: string
+}
+
+interface AssetInspectorOptions {
+  accessPolicy: AccessPolicy
+  allowFiles: readonly string[]
+  fileExtensions: readonly string[]
+  rootDir: string
+  routes: CompiledRoutes
+}
+
+export interface AssetInspector {
+  /** Returns diagnostic information for a public URL or file path. */
+  getAssetDetails(input: string): Promise<AssetDetails>
+  /** Returns every file currently reachable through the configured asset server. */
+  getAssets(): Promise<AssetDetails[]>
+}
+
+export function createAssetInspector(options: AssetInspectorOptions): AssetInspector {
+  let fileExtensions = new Set(options.fileExtensions.map((extension) => extension.toLowerCase()))
+
+  return {
+    async getAssetDetails(input) {
+      let routeMatch = await resolveInput(input, options)
+      if (routeMatch === null) return { status: 'unmapped' }
+      return inspectRouteMatch(routeMatch, options, fileExtensions)
+    },
+    async getAssets() {
+      let filePaths = await discoverFilePaths(options)
+      let assets: AssetDetails[] = []
+
+      for (let filePath of filePaths) {
+        let routeMatch = options.routes.matchFilePath(filePath)
+        if (routeMatch === null) continue
+
+        let details = await inspectRouteMatch(routeMatch, options, fileExtensions)
+        if (details.status === 'reachable') assets.push(details)
+      }
+
+      assets.sort((left, right) => {
+        let urlOrder = (left.url ?? '').localeCompare(right.url ?? '')
+        return urlOrder === 0 ? (left.filePath ?? '').localeCompare(right.filePath ?? '') : urlOrder
+      })
+      return assets
+    },
+  }
+}
+
+async function resolveInput(
+  input: string,
+  options: Pick<AssetInspectorOptions, 'rootDir' | 'routes'>,
+): Promise<AssetRouteMatch | null> {
+  if (input.startsWith('file://')) {
+    return options.routes.matchFilePath(fileURLToPath(input))
+  }
+
+  if (/^[A-Za-z][A-Za-z\d+.-]*:\/\//.test(input)) {
+    let pathname = parseFingerprintSuffix(new URL(input).pathname).pathname
+    return options.routes.matchUrlPathname(pathname)
+  }
+
+  let filePath = resolveFilePath(options.rootDir, input)
+  if (!input.startsWith('/') || isAbsoluteFilePath(input)) {
+    if (await pathExists(filePath)) return options.routes.matchFilePath(filePath)
+    if (!input.startsWith('/')) return options.routes.matchFilePath(filePath)
+  }
+
+  let pathname = parseFingerprintSuffix(new URL(input, 'http://remix.run').pathname).pathname
+  return options.routes.matchUrlPathname(pathname)
+}
+
+async function inspectRouteMatch(
+  routeMatch: AssetRouteMatch,
+  options: Pick<AssetInspectorOptions, 'accessPolicy' | 'rootDir'>,
+  fileExtensions: ReadonlySet<string>,
+): Promise<AssetDetails> {
+  let exists = await pathExists(routeMatch.filePath)
+  let identityPath = exists ? fs.realpathSync(routeMatch.filePath) : routeMatch.filePath
+  let normalizedIdentityPath = normalizeFilePath(identityPath)
+  let access = options.accessPolicy.inspect(normalizedIdentityPath)
+
+  let type = getAssetKind(routeMatch.filePath, fileExtensions)
+  let details = {
+    access,
+    filePath: routeMatch.filePath,
+    fileRoot: routeMatch.fileRoot,
+    type,
+    url: routeMatch.urlPathname,
+    urlRoot: routeMatch.urlRoot,
+  }
+
+  if (!exists) return { ...details, status: 'missing' }
+  if (!access.allowed) {
+    return { ...details, status: access.deniedBy === undefined ? 'not-allowed' : 'denied' }
+  }
+  if (type === 'unsupported') return { ...details, status: 'unsupported' }
+  return { ...details, status: 'reachable' }
+}
+
+function getAssetKind(filePath: string, fileExtensions: ReadonlySet<string>): AssetKind {
+  let extension = path.extname(filePath).toLowerCase()
+  if (scriptExtensions.has(extension)) return 'script'
+  if (isStyleFilePath(filePath)) return 'style'
+  if (fileExtensions.has(extension)) return 'file'
+  return 'unsupported'
+}
+
+async function discoverFilePaths(options: AssetInspectorOptions): Promise<string[]> {
+  let roots = new Set<string>()
+
+  for (let pattern of options.allowFiles) {
+    roots.add(resolveDiscoveryRoot(options.rootDir, pattern))
+  }
+  for (let packageRoot of options.accessPolicy.getAllowedPackageRoots()) {
+    roots.add(packageRoot)
+  }
+  for (let packageRoot of getInjectedPackageRoots()) {
+    roots.add(packageRoot)
+  }
+
+  let filePaths = new Set<string>()
+  for (let root of roots) {
+    await collectFiles(root, filePaths)
+  }
+
+  return [...filePaths]
+}
+
+function resolveDiscoveryRoot(rootDir: string, pattern: string): string {
+  let dynamicIndex = pattern.search(globSyntaxPattern)
+  if (dynamicIndex === -1) return resolveFilePath(rootDir, pattern)
+
+  let rawStaticPrefix = pattern.slice(0, dynamicIndex)
+  let staticPrefix = rawStaticPrefix.replace(/[/\\]+$/, '')
+  if (staticPrefix.length === 0) return rootDir
+  return resolveFilePath(
+    rootDir,
+    /[/\\]$/.test(rawStaticPrefix) ? staticPrefix : path.dirname(staticPrefix),
+  )
+}
+
+async function collectFiles(root: string, filePaths: Set<string>): Promise<void> {
+  let stat
+  try {
+    stat = await fsPromises.stat(root)
+  } catch (error) {
+    if (isPathNotFoundError(error)) return
+    throw error
+  }
+
+  if (stat.isFile()) {
+    filePaths.add(normalizeFilePath(root))
+    return
+  }
+  if (!stat.isDirectory()) return
+
+  let entries = await fsPromises.readdir(root, { withFileTypes: true })
+  for (let entry of entries) {
+    let entryPath = path.join(root, entry.name)
+    if (entry.isDirectory()) {
+      await collectFiles(entryPath, filePaths)
+    } else if (entry.isFile()) {
+      filePaths.add(normalizeFilePath(entryPath))
+    }
+  }
+}
+
+async function pathExists(filePath: string): Promise<boolean> {
+  try {
+    await fsPromises.access(filePath)
+    return true
+  } catch (error) {
+    if (isPathNotFoundError(error)) return false
+    throw error
+  }
+}
+
+function isPathNotFoundError(
+  error: unknown,
+): error is NodeJS.ErrnoException & { code: 'ENOENT' | 'ENOTDIR' } {
+  return (
+    error instanceof Error &&
+    'code' in error &&
+    (error.code === 'ENOENT' || error.code === 'ENOTDIR')
+  )
+}

package/src/lib/loaders.ts

@@ -0,0 +1,80 @@
+type ModuleFloat16Array = typeof globalThis extends {
+  Float16Array: { prototype: infer array }
+}
+  ? array
+  : never
+
+type ModuleTypedArray =
+  | Uint8Array
+  | Uint8ClampedArray
+  | Uint16Array
+  | Uint32Array
+  | Int8Array
+  | Int16Array
+  | Int32Array
+  | BigUint64Array
+  | BigInt64Array
+  | ModuleFloat16Array
+  | Float32Array
+  | Float64Array
+
+type ModuleLoadSource = string | ArrayBuffer | ModuleTypedArray
+
+/**
+ * Synchronously loads a module or delegates to the next configured loader.
+ *
+ * Loaders follow Node's synchronous `load` hook signature and chaining contract. The asset server
+ * passes them JavaScript after its TypeScript/JavaScript transform and before HMR analysis and
+ * minification. Each loader must delegate to `nextLoad` or return `shortCircuit: true`.
+ *
+ * @param url Resolved `file:` URL for the module being compiled.
+ * @param context Format, conditions, attributes, and public asset URL for this load.
+ * @param nextLoad Next loader in the chain, ending with the asset server's compiled JavaScript.
+ * @returns A Node-compatible load result containing ES module source.
+ */
+export type ModuleLoader = (
+  url: string,
+  context: ModuleLoadContext,
+  nextLoad: NextModuleLoader,
+) => ModuleLoadResult
+
+/**
+ * Continues loading through the remaining loader chain.
+ *
+ * Omitted context fields retain their current values.
+ *
+ * @param url Current module URL. Loaders cannot change this URL.
+ * @param context Context fields to override for the remainder of this load.
+ * @returns The source produced by the remaining loaders or the asset compiler.
+ */
+export type NextModuleLoader = (
+  url: string,
+  context?: Partial<ModuleLoadContext>,
+) => ModuleLoadResult
+
+/** State passed through a module loader chain. */
+export interface ModuleLoadContext {
+  /** Package export conditions used while compiling this module. */
+  conditions: string[]
+  /** Current module format. Asset-server loaders must ultimately return `'module'`. */
+  format: string | null | undefined
+  /** Import attributes supplied by the previous loader. Authored import attributes are unsupported. */
+  importAttributes: Record<string, string | undefined>
+  /**
+   * Stable public URL path used to request this module from the asset server.
+   *
+   * Unlike Node's standard load context, this field is provided so loaders can use the browser
+   * module identity rather than its private filesystem URL.
+   */
+  moduleUrl?: string
+}
+
+/** Source returned by a module loader. */
+export interface ModuleLoadResult {
+  /** Loaded module format. Must be `'module'` for asset-server scripts. */
+  format: string | null | undefined
+  /** Whether this result intentionally ends the loader chain without calling `nextLoad`. */
+  shortCircuit?: boolean
+  /** Compiled JavaScript source, optionally rewritten by the loader. */
+  source?: ModuleLoadSource
+}

package/src/lib/module-store.ts

@@ -14,11 +14,27 @@ export type FileSnapshot = {
 
 export type ModuleSnapshot = ReadonlyMap<string, FileSnapshot>
 
+type ModuleLinksState = {
+  acceptedDependencies: ReadonlySet<string>
+  dependencies: ReadonlySet<string>
+}
+
+type MutableModuleLinks = {
+  acceptedDependencies: Set<string>
+  dependencies: Set<string>
+}
+
 type ModuleRecordState<transformed, resolved, emitted> = {
+  emittedVersion?: number
+  hmrUpdateTimestamp?: number
   identityPath: string
   invalidationVersion: number
   transformed?: transformed
+  transformedVersion?: number
   resolved?: resolved
+  resolvedVersion?: number
+  lastResolved?: resolved
+  links: ModuleLinksState
   emitted?: emitted
   emittedSnapshot?: ModuleSnapshot
   staleEmitted?: emitted
@@ -32,10 +48,16 @@ export type ModuleRecord<transformed, resolved, emitted> = Readonly<
 >
 
 type MutableModuleRecord<transformed, resolved, emitted> = {
+  emittedVersion?: number
+  hmrUpdateTimestamp?: number
   identityPath: string
   invalidationVersion: number
   transformed?: transformed
+  transformedVersion?: number
   resolved?: resolved
+  resolvedVersion?: number
+  lastResolved?: resolved
+  links: MutableModuleLinks
   emitted?: emitted
   emittedSnapshot?: ModuleSnapshot
   staleEmitted?: emitted
@@ -46,6 +68,14 @@ type MutableModuleRecord<transformed, resolved, emitted> = {
 
 export type ModuleStore<transformed, resolved, emitted> = {
   get(identityPath: string): ModuleRecord<transformed, resolved, emitted>
+  getAcceptedImporters(identityPath: string): ReadonlySet<string>
+  getHmrUpdateTimestamp(identityPath: string): number | undefined
+  getImporters(identityPath: string): ReadonlySet<string>
+  getLastResolved(identityPath: string): resolved | undefined
+  isEmittedFresh(record: ModuleRecord<transformed, resolved, emitted>): boolean
+  isResolvedFresh(record: ModuleRecord<transformed, resolved, emitted>): boolean
+  isTransformedFresh(record: ModuleRecord<transformed, resolved, emitted>): boolean
+  setHmrUpdateTimestamp(identityPath: string, timestamp: number): void
   clearTransformed(identityPath: string, tracking: readonly ModuleTracking[]): void
   setTransformed(
     identityPath: string,
@@ -61,12 +91,19 @@ export type ModuleStore<transformed, resolved, emitted> = {
 
 export function createModuleStore<transformed, resolved, emitted>(
   options: {
+    getAcceptedDependencies?: (resolved: resolved) => readonly string[]
+    getDependencies?: (resolved: resolved) => readonly string[]
     onWatchDirectoriesChange?: (delta: { add: string[]; remove: string[] }) => void
+    onWatchFilesChange?: (delta: { add: string[]; remove: string[] }) => void
   } = {},
 ): ModuleStore<transformed, resolved, emitted> {
   let recordsByIdentityPath = new Map<string, MutableModuleRecord<transformed, resolved, emitted>>()
+  let importersByDepPath = new Map<string, Set<string>>()
+  let acceptedImportersByDepPath = new Map<string, Set<string>>()
   let recordsByTrackedFile = new Map<string, Set<string>>()
   let watchDirectoryRefCountByPath = new Map<string, number>()
+  let watchFileRefCountByPath = new Map<string, number>()
+  let emptyImporters = new Set<string>()
 
   return {
     get(identityPath) {
@@ -76,17 +113,55 @@ export function createModuleStore<transformed, resolved, emitted>(
       let record: MutableModuleRecord<transformed, resolved, emitted> = {
         identityPath,
         invalidationVersion: 0,
+        links: createEmptyLinks(),
         trackedFiles: new Set(),
         trackedDirectories: new Set(),
       }
       recordsByIdentityPath.set(identityPath, record)
       return record
     },
+
+    getAcceptedImporters(identityPath) {
+      return acceptedImportersByDepPath.get(identityPath) ?? emptyImporters
+    },
+
+    getHmrUpdateTimestamp(identityPath) {
+      return recordsByIdentityPath.get(identityPath)?.hmrUpdateTimestamp
+    },
+
+    getImporters(identityPath) {
+      return importersByDepPath.get(identityPath) ?? emptyImporters
+    },
+
+    getLastResolved(identityPath) {
+      return recordsByIdentityPath.get(identityPath)?.lastResolved
+    },
+
+    isEmittedFresh(record) {
+      return record.emittedVersion === record.invalidationVersion
+    },
+
+    isResolvedFresh(record) {
+      return record.resolvedVersion === record.invalidationVersion
+    },
+
+    isTransformedFresh(record) {
+      return record.transformedVersion === record.invalidationVersion
+    },
+
+    setHmrUpdateTimestamp(identityPath, timestamp) {
+      let record = getOrCreateMutableRecord(identityPath)
+      record.hmrUpdateTimestamp = timestamp
+    },
+
     clearTransformed(identityPath, tracking) {
       let record = getOrCreateMutableRecord(identityPath)
       record.transformed = undefined
+      record.transformedVersion = undefined
       record.resolved = undefined
+      record.resolvedVersion = undefined
       record.emitted = undefined
+      record.emittedVersion = undefined
       record.emittedSnapshot = undefined
       record.staleEmitted = undefined
       record.staleEmittedSnapshot = undefined
@@ -96,8 +171,11 @@ export function createModuleStore<transformed, resolved, emitted>(
     setTransformed(identityPath, transformed, tracking) {
       let record = getOrCreateMutableRecord(identityPath)
       record.transformed = transformed
+      record.transformedVersion = record.invalidationVersion
       record.resolved = undefined
+      record.resolvedVersion = undefined
       record.emitted = undefined
+      record.emittedVersion = undefined
       record.emittedSnapshot = undefined
       record.staleEmitted = undefined
       record.staleEmittedSnapshot = undefined
@@ -106,18 +184,26 @@ export function createModuleStore<transformed, resolved, emitted>(
 
     setResolved(identityPath, resolved, tracking) {
       let record = getOrCreateMutableRecord(identityPath)
+      removeResolvedIndexes(record)
       record.resolved = resolved
+      record.resolvedVersion = record.invalidationVersion
+      record.lastResolved = resolved
+      record.links = createLinks(resolved)
       record.emitted = undefined
+      record.emittedVersion = undefined
       record.emittedSnapshot = undefined
       record.staleEmitted = undefined
       record.staleEmittedSnapshot = undefined
       setTracking(record, tracking)
+      addResolvedIndexes(record)
     },
 
     clearResolved(identityPath, tracking) {
       let record = getOrCreateMutableRecord(identityPath)
       record.resolved = undefined
+      record.resolvedVersion = undefined
       record.emitted = undefined
+      record.emittedVersion = undefined
       record.emittedSnapshot = undefined
       record.staleEmitted = undefined
       record.staleEmittedSnapshot = undefined
@@ -127,6 +213,7 @@ export function createModuleStore<transformed, resolved, emitted>(
     setEmitted(identityPath, emitted, snapshot) {
       let record = getOrCreateMutableRecord(identityPath)
       record.emitted = emitted
+      record.emittedVersion = record.invalidationVersion
       record.emittedSnapshot = snapshot ?? undefined
       record.staleEmitted = undefined
       record.staleEmittedSnapshot = undefined
@@ -145,12 +232,21 @@ export function createModuleStore<transformed, resolved, emitted>(
 
       for (let identityPath of affected) {
         let record = recordsByIdentityPath.get(identityPath)
-        if (record) invalidateRecord(record, { retainStale: event === 'change' })
+        if (record) {
+          if (event === 'change') {
+            invalidateContent(record, { retainStale: true })
+          } else {
+            invalidateGraph(record)
+          }
+        }
       }
 
       if (event === 'unlink') {
         let deletedRecord = recordsByIdentityPath.get(filePath)
         if (deletedRecord) {
+          if (!affected.has(filePath)) {
+            invalidateGraph(deletedRecord)
+          }
           clearTracking(deletedRecord)
         }
       }
@@ -158,7 +254,7 @@ export function createModuleStore<transformed, resolved, emitted>(
 
     invalidateAll() {
       for (let record of recordsByIdentityPath.values()) {
-        invalidateRecord(record, { retainStale: false })
+        invalidateGraph(record)
       }
     },
   }
@@ -172,6 +268,7 @@ export function createModuleStore<transformed, resolved, emitted>(
     let record: MutableModuleRecord<transformed, resolved, emitted> = {
       identityPath,
       invalidationVersion: 0,
+      links: createEmptyLinks(),
       trackedFiles: new Set(),
       trackedDirectories: new Set(),
     }
@@ -179,7 +276,7 @@ export function createModuleStore<transformed, resolved, emitted>(
     return record
   }
 
-  function invalidateRecord(
+  function invalidateContent(
     record: MutableModuleRecord<transformed, resolved, emitted>,
     options: { retainStale: boolean },
   ) {
@@ -194,18 +291,51 @@ export function createModuleStore<transformed, resolved, emitted>(
       record.staleEmittedSnapshot = undefined
     }
 
-    record.emitted = undefined
-    record.emittedSnapshot = undefined
-    record.resolved = undefined
-    record.transformed = undefined
     record.invalidationVersion += 1
   }
 
+  function invalidateGraph(record: MutableModuleRecord<transformed, resolved, emitted>) {
+    record.hmrUpdateTimestamp = undefined
+    invalidateContent(record, { retainStale: false })
+  }
+
+  function createLinks(resolved: resolved): MutableModuleLinks {
+    return {
+      acceptedDependencies: new Set(options.getAcceptedDependencies?.(resolved) ?? []),
+      dependencies: new Set(options.getDependencies?.(resolved) ?? []),
+    }
+  }
+
+  function createEmptyLinks(): MutableModuleLinks {
+    return {
+      acceptedDependencies: new Set(),
+      dependencies: new Set(),
+    }
+  }
+
+  function addResolvedIndexes(record: MutableModuleRecord<transformed, resolved, emitted>): void {
+    for (let depPath of record.links.dependencies) {
+      addToIndexedSet(importersByDepPath, depPath, record.identityPath)
+    }
+
+    for (let depPath of record.links.acceptedDependencies) {
+      addToIndexedSet(acceptedImportersByDepPath, depPath, record.identityPath)
+    }
+  }
+
+  function removeResolvedIndexes(
+    record: MutableModuleRecord<transformed, resolved, emitted>,
+  ): void {
+    removeFromIndexedSets(importersByDepPath, record.identityPath)
+    removeFromIndexedSets(acceptedImportersByDepPath, record.identityPath)
+  }
+
   function setTracking(
     record: MutableModuleRecord<transformed, resolved, emitted>,
     tracking: readonly ModuleTracking[],
   ) {
     let previousWatchedDirectories = getWatchedDirectories(record)
+    let previousWatchedFiles = new Set(record.trackedFiles)
     removeIndexes(record)
 
     let normalizedTracking = mergeTracking(tracking)
@@ -217,8 +347,13 @@ export function createModuleStore<transformed, resolved, emitted>(
     }
 
     let nextWatchedDirectories = getWatchedDirectories(record)
-    let delta = updateWatchDirectoryRefCounts(previousWatchedDirectories, nextWatchedDirectories)
-    emitWatchDirectoryDelta(delta)
+    let directoryDelta = updateWatchDirectoryRefCounts(
+      previousWatchedDirectories,
+      nextWatchedDirectories,
+    )
+    let fileDelta = updateWatchFileRefCounts(previousWatchedFiles, record.trackedFiles)
+    emitWatchDirectoryDelta(directoryDelta)
+    emitWatchFileDelta(fileDelta)
   }
 
   function clearTracking(record: MutableModuleRecord<transformed, resolved, emitted>) {
@@ -262,11 +397,48 @@ export function createModuleStore<transformed, resolved, emitted>(
     return { add, remove }
   }
 
+  function updateWatchFileRefCounts(
+    previousWatchedFiles: ReadonlySet<string>,
+    nextWatchedFiles: ReadonlySet<string>,
+  ): { add: string[]; remove: string[] } {
+    let add: string[] = []
+    let remove: string[] = []
+
+    for (let file of previousWatchedFiles) {
+      if (nextWatchedFiles.has(file)) continue
+      let previousCount = watchFileRefCountByPath.get(file)
+      if (!previousCount) continue
+      if (previousCount === 1) {
+        watchFileRefCountByPath.delete(file)
+        remove.push(file)
+      } else {
+        watchFileRefCountByPath.set(file, previousCount - 1)
+      }
+    }
+
+    for (let file of nextWatchedFiles) {
+      if (previousWatchedFiles.has(file)) continue
+      let previousCount = watchFileRefCountByPath.get(file) ?? 0
+      watchFileRefCountByPath.set(file, previousCount + 1)
+      if (previousCount === 0) {
+        add.push(file)
+      }
+    }
+
+    return { add, remove }
+  }
+
   function emitWatchDirectoryDelta(delta: { add: string[]; remove: string[] }): void {
     if (!options.onWatchDirectoriesChange) return
     if (delta.add.length === 0 && delta.remove.length === 0) return
     options.onWatchDirectoriesChange(delta)
   }
+
+  function emitWatchFileDelta(delta: { add: string[]; remove: string[] }): void {
+    if (!options.onWatchFilesChange) return
+    if (delta.add.length === 0 && delta.remove.length === 0) return
+    options.onWatchFilesChange(delta)
+  }
 }
 
 function addToIndexedSet(map: Map<string, Set<string>>, key: string, value: string) {
@@ -284,6 +456,15 @@ function removeFromIndexedSet(map: Map<string, Set<string>>, key: string, value:
   }
 }
 
+function removeFromIndexedSets(map: Map<string, Set<string>>, value: string): void {
+  for (let [key, values] of map) {
+    values.delete(value)
+    if (values.size === 0) {
+      map.delete(key)
+    }
+  }
+}
+
 function matchesTrackedDirectory(
   trackedDirectories: ReadonlySet<string>,
   filePath: string,