@remix-run/assets 0.4.4 → 0.6.0

package/dist/lib/hmr.js

@@ -0,0 +1,357 @@
+export function createHmrClientSource(options) {
+    return `
+const contexts = new Map()
+const dataByPath = new Map()
+
+class RemixHmrContext {
+  constructor(path) {
+    this.path = path
+    this.data = dataByPath.get(path) ?? {}
+    this.acceptCallbacks = []
+    this.acceptDependencyCallbacks = []
+    this.disposeCallbacks = []
+    this.customEventCallbacks = new Map()
+    this.invalidated = false
+    this.updating = false
+    dataByPath.set(path, this.data)
+  }
+
+  accept(deps, callback) {
+    if (typeof deps === 'string') {
+      this.acceptDependencyCallbacks.push({
+        deps: [normalizeAcceptedDependency(this.path, deps)],
+        callback: callback ?? (() => {}),
+      })
+      return
+    }
+
+    if (Array.isArray(deps)) {
+      this.acceptDependencyCallbacks.push({
+        deps: deps.map((dep) => normalizeAcceptedDependency(this.path, dep)),
+        callback: callback ?? (() => {}),
+      })
+      return
+    }
+
+    this.acceptCallbacks.push(deps ?? (() => {}))
+  }
+
+  dispose(callback) {
+    this.disposeCallbacks.push(callback)
+  }
+
+  invalidate(message) {
+    this.invalidated = true
+    if (this.updating) {
+      if (message) console.debug(message)
+      return
+    }
+    if (message) console.debug(message)
+    reloadPage()
+  }
+
+  on(event, callback) {
+    let callbacks = this.customEventCallbacks.get(event)
+    if (!callbacks) {
+      callbacks = []
+      this.customEventCallbacks.set(event, callbacks)
+    }
+    callbacks.push(callback)
+  }
+}
+
+export function createHotContext(path) {
+  let context = new RemixHmrContext(path)
+  contexts.set(path, context)
+  return context
+}
+
+let connected = false
+let reconnectPending = false
+let pageReloadTimer
+let failedJavaScriptUpdates = new Map()
+let stylesheetUpdatePromise = Promise.resolve()
+
+let events = new EventSource(${JSON.stringify(options.eventPathname)})
+
+events.onopen = () => {
+  console.debug('[remix] HMR connected')
+  if (reconnectPending) {
+    reconnectPending = false
+    console.log('[remix] HMR reconnected')
+    handleReconnect().catch((error) => {
+      console.error('[remix] HMR reconnect recovery failed', error)
+      reloadPage()
+    })
+  }
+  connected = true
+}
+
+events.onerror = () => {
+  if (!connected) return
+  connected = false
+  reconnectPending = true
+  console.log('[remix] HMR connection lost, retrying...')
+}
+
+events.onmessage = (event) => {
+  let payload = JSON.parse(event.data)
+  handlePayload(payload).catch((error) => {
+    console.error('[remix] HMR update failed', error)
+    if (payload.type !== 'browser:update' || payload.updates.some((update) => update.type !== 'js')) {
+      reloadPage()
+    }
+  })
+}
+
+async function handlePayload(payload) {
+  if (payload.type === 'browser:reload') {
+    reloadPage()
+    return
+  }
+
+  if (payload.type === 'server:update') {
+    await retryFailedJavaScriptUpdates(payload)
+    await dispatchCustomEvent(payload.type, payload)
+    return
+  }
+
+  if (payload.type === 'browser:update') {
+    for (let update of payload.updates) {
+      if (update.type === 'css') {
+        let updated = await queueStylesheetUpdate(update.path, payload.timestamp)
+        if (updated) console.debug('[remix] HMR updated stylesheet', update.path)
+        continue
+      }
+
+      try {
+        let updated = await updateJavaScriptModule(
+          update.path,
+          update.acceptedPath ?? update.path,
+          payload.timestamp,
+        )
+        failedJavaScriptUpdates.delete(update.path)
+        if (updated) console.debug('[remix] HMR accepted update', update.path)
+      } catch (error) {
+        failedJavaScriptUpdates.set(update.path, update.acceptedPath ?? update.path)
+        throw error
+      }
+    }
+  }
+}
+
+async function handleReconnect() {
+  let data = { timestamp: Date.now() }
+  await reloadCurrentStylesheets(data)
+  await retryFailedJavaScriptUpdates(data)
+}
+
+async function retryFailedJavaScriptUpdates(data) {
+  if (failedJavaScriptUpdates.size === 0) return
+
+  let timestamp = getTimestamp(data)
+  for (let [path, acceptedPath] of Array.from(failedJavaScriptUpdates)) {
+    try {
+      let updated = await updateJavaScriptModule(path, acceptedPath, timestamp)
+      failedJavaScriptUpdates.delete(path)
+      if (updated) console.debug('[remix] HMR recovered update', path)
+    } catch (error) {
+      console.error('[remix] HMR recovery update failed', error)
+    }
+  }
+}
+
+async function reloadCurrentStylesheets(data) {
+  let timestamp = getTimestamp(data)
+  let paths = new Set()
+  for (let link of document.querySelectorAll('link[rel="stylesheet"]')) {
+    if (link.dataset.remixHmrStylesheet === 'true') continue
+    let url = new URL(link.href)
+    if (url.origin !== location.origin) continue
+    paths.add(url.pathname)
+  }
+
+  for (let path of paths) {
+    await queueStylesheetUpdate(path, timestamp)
+  }
+}
+
+function getTimestamp(data) {
+  if (data && typeof data === 'object' && typeof data.timestamp === 'number') {
+    return data.timestamp
+  }
+
+  return Date.now()
+}
+
+async function updateJavaScriptModule(path, acceptedPath, timestamp) {
+  let previousContext = contexts.get(path)
+  if (!previousContext) return false
+
+  let isSelfUpdate = path === acceptedPath
+  let dependencyCallbacks = getAcceptDependencyCallbacks(previousContext, acceptedPath)
+
+  if (
+    isSelfUpdate ? previousContext.acceptCallbacks.length === 0 : dependencyCallbacks.length === 0
+  ) {
+    console.log('[remix] HMR no accept handler, reloading page', path)
+    reloadPage()
+    return false
+  }
+
+  if (isSelfUpdate) {
+    for (let callback of previousContext.disposeCallbacks) {
+      await callback(previousContext.data)
+    }
+
+    let updatedModule = await import(withTimestamp(path, timestamp))
+    previousContext.invalidated = false
+    previousContext.updating = true
+    try {
+      for (let callback of previousContext.acceptCallbacks) {
+        await callback(updatedModule)
+      }
+    } finally {
+      previousContext.updating = false
+    }
+    if (previousContext.invalidated) {
+      await propagateInvalidatedJavaScriptModule(path, timestamp)
+    }
+    return true
+  }
+
+  let acceptedContext = contexts.get(acceptedPath)
+  if (acceptedContext) {
+    for (let callback of acceptedContext.disposeCallbacks) {
+      await callback(acceptedContext.data)
+    }
+  }
+
+  let updatedModule = await import(withTimestamp(acceptedPath, timestamp))
+  previousContext.invalidated = false
+  previousContext.updating = true
+  try {
+    for (let { deps, callback } of dependencyCallbacks) {
+      if (deps.length === 1) {
+        await callback(updatedModule)
+      } else {
+        await callback(deps.map((dep) => (dep === acceptedPath ? updatedModule : undefined)))
+      }
+    }
+  } finally {
+    previousContext.updating = false
+  }
+  if (previousContext.invalidated) {
+    await propagateInvalidatedJavaScriptModule(path, timestamp)
+  }
+  return true
+}
+
+async function propagateInvalidatedJavaScriptModule(path, timestamp) {
+  let updated = false
+  for (let [importerPath, importerContext] of contexts) {
+    if (importerPath === path) continue
+    let callbacks = getAcceptDependencyCallbacks(importerContext, path)
+    if (callbacks.length === 0) continue
+
+    for (let callback of importerContext.disposeCallbacks) {
+      await callback(importerContext.data)
+    }
+
+    let updatedModule = await import(withTimestamp(path, timestamp))
+    importerContext.invalidated = false
+    importerContext.updating = true
+    try {
+      for (let { deps, callback } of callbacks) {
+        if (deps.length === 1) {
+          await callback(updatedModule)
+        } else {
+          await callback(deps.map((dep) => (dep === path ? updatedModule : undefined)))
+        }
+      }
+    } finally {
+      importerContext.updating = false
+    }
+    updated = true
+
+    if (importerContext.invalidated) {
+      reloadPage()
+      return
+    }
+  }
+
+  if (!updated) reloadPage()
+}
+
+function getAcceptDependencyCallbacks(context, acceptedPath) {
+  return context.acceptDependencyCallbacks.filter(({ deps }) => deps.includes(acceptedPath))
+}
+
+function normalizeAcceptedDependency(importerPath, dep) {
+  if (dep.startsWith('/')) return dep
+  return new URL(dep, new URL(importerPath, window.location.href)).pathname
+}
+
+async function dispatchCustomEvent(event, data) {
+  for (let context of contexts.values()) {
+    let callbacks = context.customEventCallbacks.get(event) ?? []
+    for (let callback of callbacks) {
+      await callback(data)
+    }
+  }
+}
+
+async function reloadStylesheet(path, timestamp) {
+  let links = document.querySelectorAll('link[rel="stylesheet"]')
+  let updates = []
+  for (let link of links) {
+    let url = new URL(link.href)
+    if (url.pathname !== path) continue
+    if (link.dataset.remixHmrStylesheet === 'true') continue
+
+    updates.push(loadStylesheet(link, path, timestamp))
+  }
+
+  if (updates.length === 0) return false
+  return (await Promise.all(updates)).some(Boolean)
+}
+
+async function queueStylesheetUpdate(path, timestamp) {
+  let update = stylesheetUpdatePromise.then(() => reloadStylesheet(path, timestamp))
+  stylesheetUpdatePromise = update.catch(() => {})
+  return update
+}
+
+function loadStylesheet(link, path, timestamp) {
+  return new Promise((resolve) => {
+    let next = link.cloneNode()
+    next.dataset.remixHmrStylesheet = 'true'
+    next.href = withTimestamp(path, timestamp)
+    next.onload = () => {
+      delete next.dataset.remixHmrStylesheet
+      link.remove()
+      resolve(true)
+    }
+    next.onerror = () => {
+      next.remove()
+      resolve(false)
+    }
+    link.after(next)
+  })
+}
+
+function withTimestamp(path, timestamp) {
+  let url = new URL(path, location.href)
+  url.searchParams.set('t', String(timestamp))
+  return url.pathname + url.search
+}
+
+function reloadPage() {
+  if (pageReloadTimer) clearTimeout(pageReloadTimer)
+  pageReloadTimer = setTimeout(() => {
+    console.debug('[remix] HMR reloading page')
+    window.location.href = window.location.href
+  }, 20)
+}
+`.trimStart();
+}

package/dist/lib/injected-packages.d.ts

@@ -1,8 +1,9 @@
 export declare function isInjectedPackageFilePath(filePath: string): boolean;
-export declare function getInjectedPackageRouteConfigs(): {
-    fileMap: Record<string, string>;
+export declare function getInjectedPackageMountConfigs(): {
+    mounts: Record<string, string>;
     rootDir: string;
 }[];
+export declare function getInjectedPackageRoots(): readonly string[];
 export declare function getInjectedPackageNameForSpecifier(specifier: string): string | null;
 export declare function mayContainInjectedPackageSpecifier(sourceText: string): boolean;
 export declare function maskAuthoredInjectedPackageSpecifier(specifier: string): string | null;

package/dist/lib/injected-packages.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"injected-packages.d.ts","sourceRoot":"","sources":["../../src/lib/injected-packages.ts"],"names":[],"mappings":"AAeA,wBAAgB,yBAAyB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAWnE;AAED,wBAAgB,8BAA8B,IAAI;IAChD,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC/B,OAAO,EAAE,MAAM,CAAA;CAChB,EAAE,CAWF;AAED,wBAAgB,kCAAkC,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAQnF;AAED,wBAAgB,kCAAkC,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAE9E;AAED,wBAAgB,oCAAoC,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAMrF;AAED,wBAAgB,uCAAuC,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAYxF;AAMD,wBAAgB,8BAA8B,IAAI,MAAM,CAEvD"}
+{"version":3,"file":"injected-packages.d.ts","sourceRoot":"","sources":["../../src/lib/injected-packages.ts"],"names":[],"mappings":"AAiBA,wBAAgB,yBAAyB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAWnE;AAED,wBAAgB,8BAA8B,IAAI;IAChD,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC9B,OAAO,EAAE,MAAM,CAAA;CAChB,EAAE,CAYF;AAED,wBAAgB,uBAAuB,IAAI,SAAS,MAAM,EAAE,CAI3D;AAED,wBAAgB,kCAAkC,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAcnF;AAED,wBAAgB,kCAAkC,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAE9E;AAED,wBAAgB,oCAAoC,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CASrF;AAED,wBAAgB,uCAAuC,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAYxF;AAWD,wBAAgB,8BAA8B,IAAI,MAAM,CAEvD"}

package/dist/lib/injected-packages.js

@@ -1,7 +1,9 @@
 import * as fs from 'node:fs';
 import { fileURLToPath } from 'node:url';
-import { getFilePathDirectory, normalizeFilePath } from "./paths.js";
+import { getFilePathDirectory, normalizeFilePath } from './paths.js';
 const injectedPackageNames = ['@oxc-project/runtime'];
+const authoredInjectedPackageNames = ['@oxc-project/runtime'];
+const generatedInjectedPackageSpecifiers = [];
 const injectedPackagesBasePath = '/__@remix/injected';
 const resolvedInjectedPackages = new Map();
 export function isInjectedPackageFilePath(filePath) {
@@ -14,19 +16,28 @@ export function isInjectedPackageFilePath(filePath) {
     }
     return false;
 }
-export function getInjectedPackageRouteConfigs() {
+export function getInjectedPackageMountConfigs() {
     return injectedPackageNames.map((packageName) => {
         let { packageRoot } = getResolvedInjectedPackage(packageName);
+        let { fileRoot, routeRoot } = getInjectedPackageRoute(packageRoot, packageName);
         return {
-            fileMap: {
-                [getInjectedPackageRoutePattern(packageName)]: `${packageName}/*path`,
+            mounts: {
+                [getInjectedPackageMountPath(packageName)]: fileRoot,
             },
-            rootDir: getInjectedPackageRouteRoot(packageRoot, packageName),
+            rootDir: routeRoot,
         };
     });
 }
+export function getInjectedPackageRoots() {
+    return injectedPackageNames.map((packageName) => getResolvedInjectedPackage(packageName).packageRoot);
+}
 export function getInjectedPackageNameForSpecifier(specifier) {
-    for (let packageName of injectedPackageNames) {
+    for (let injectedSpecifier of generatedInjectedPackageSpecifiers) {
+        if (specifier === injectedSpecifier) {
+            return getPackageName(injectedSpecifier);
+        }
+    }
+    for (let packageName of authoredInjectedPackageNames) {
         if (specifier === packageName || specifier.startsWith(`${packageName}/`)) {
             return packageName;
         }
@@ -34,17 +45,19 @@ export function getInjectedPackageNameForSpecifier(specifier) {
     return null;
 }
 export function mayContainInjectedPackageSpecifier(sourceText) {
-    return injectedPackageNames.some((packageName) => sourceText.includes(packageName));
+    return authoredInjectedPackageNames.some((packageName) => sourceText.includes(packageName));
 }
 export function maskAuthoredInjectedPackageSpecifier(specifier) {
-    let packageName = getInjectedPackageNameForSpecifier(specifier);
-    if (!packageName)
-        return null;
-    let maskedPackageName = getMaskedInjectedPackageName(packageName);
-    return `${maskedPackageName}${specifier.slice(packageName.length)}`;
+    for (let packageName of authoredInjectedPackageNames) {
+        if (specifier !== packageName && !specifier.startsWith(`${packageName}/`))
+            continue;
+        let maskedPackageName = getMaskedInjectedPackageName(packageName);
+        return `${maskedPackageName}${specifier.slice(packageName.length)}`;
+    }
+    return null;
 }
 export function restoreAuthoredInjectedPackageSpecifier(specifier) {
-    for (let packageName of injectedPackageNames) {
+    for (let packageName of authoredInjectedPackageNames) {
         let maskedPackageName = getMaskedInjectedPackageName(packageName);
         if (specifier === maskedPackageName) {
             return packageName;
@@ -58,6 +71,10 @@ export function restoreAuthoredInjectedPackageSpecifier(specifier) {
 function getMaskedInjectedPackageName(packageName) {
     return `~${packageName.slice(1)}`;
 }
+function getPackageName(specifier) {
+    let parts = specifier.split('/');
+    return parts[0]?.startsWith('@') ? `${parts[0]}/${parts[1]}` : (parts[0] ?? specifier);
+}
 export function getInjectedPackageImporterPath() {
     return normalizeFilePath(fileURLToPath(import.meta.url));
 }
@@ -74,13 +91,22 @@ function getResolvedInjectedPackage(packageName) {
     resolvedInjectedPackages.set(packageName, resolvedInjectedPackage);
     return resolvedInjectedPackage;
 }
-function getInjectedPackageRoutePattern(packageName) {
-    return `${injectedPackagesBasePath}/${packageName}/*path`;
+function getInjectedPackageMountPath(packageName) {
+    return `${injectedPackagesBasePath}/${packageName}`;
 }
-function getInjectedPackageRouteRoot(packageRoot, packageName) {
+function getInjectedPackageRoute(packageRoot, packageName) {
+    if (!packageRoot.endsWith(`/${packageName}`)) {
+        return {
+            fileRoot: packageRoot.slice(getFilePathDirectory(packageRoot).length + 1),
+            routeRoot: getFilePathDirectory(packageRoot),
+        };
+    }
     let routeRoot = packageRoot;
     for (let _segment of packageName.split('/')) {
         routeRoot = getFilePathDirectory(routeRoot);
     }
-    return routeRoot;
+    return {
+        fileRoot: packageName,
+        routeRoot,
+    };
 }

package/dist/lib/inspection.d.ts

@@ -0,0 +1,39 @@
+import type { AccessPolicy, AssetAccessDetails } from './access.ts';
+import type { CompiledRoutes } from './routes.ts';
+/** 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 declare function createAssetInspector(options: AssetInspectorOptions): AssetInspector;
+export {};
+//# sourceMappingURL=inspection.d.ts.map

package/dist/lib/inspection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inspection.d.ts","sourceRoot":"","sources":["../../src/lib/inspection.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAA;AAInE,OAAO,KAAK,EAAmB,cAAc,EAAE,MAAM,aAAa,CAAA;AAOlE,sDAAsD;AACtD,MAAM,MAAM,SAAS,GAAG,MAAM,GAAG,QAAQ,GAAG,OAAO,GAAG,aAAa,CAAA;AAEnE,0DAA0D;AAC1D,MAAM,MAAM,WAAW,GACnB,QAAQ,GACR,SAAS,GACT,aAAa,GACb,WAAW,GACX,UAAU,GACV,aAAa,CAAA;AAEjB,wEAAwE;AACxE,MAAM,WAAW,YAAY;IAC3B,gEAAgE;IAChE,MAAM,CAAC,EAAE,kBAAkB,CAAA;IAC3B,iCAAiC;IACjC,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,+DAA+D;IAC/D,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,mCAAmC;IACnC,MAAM,EAAE,WAAW,CAAA;IACnB,6CAA6C;IAC7C,IAAI,CAAC,EAAE,SAAS,CAAA;IAChB,gDAAgD;IAChD,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,gDAAgD;IAChD,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB;AAED,UAAU,qBAAqB;IAC7B,YAAY,EAAE,YAAY,CAAA;IAC1B,UAAU,EAAE,SAAS,MAAM,EAAE,CAAA;IAC7B,cAAc,EAAE,SAAS,MAAM,EAAE,CAAA;IACjC,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,EAAE,cAAc,CAAA;CACvB;AAED,MAAM,WAAW,cAAc;IAC7B,oEAAoE;IACpE,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,CAAA;IACrD,kFAAkF;IAClF,SAAS,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC,CAAA;CACrC;AAED,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,qBAAqB,GAAG,cAAc,CA4BnF"}

package/dist/lib/inspection.js

@@ -0,0 +1,160 @@
+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 { parseFingerprintSuffix } from './fingerprint.js';
+import { getInjectedPackageRoots } from './injected-packages.js';
+import { isAbsoluteFilePath, normalizeFilePath, resolveFilePath } from './paths.js';
+import { supportedScriptExtensions } from './scripts/resolve.js';
+import { isStyleFilePath } from './styles/compiler.js';
+const scriptExtensions = new Set(supportedScriptExtensions);
+const globSyntaxPattern = /[*?[\]{}()!+@]/;
+export function createAssetInspector(options) {
+    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 = [];
+            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, options) {
+    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, options, fileExtensions) {
+    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, fileExtensions) {
+    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) {
+    let roots = new Set();
+    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();
+    for (let root of roots) {
+        await collectFiles(root, filePaths);
+    }
+    return [...filePaths];
+}
+function resolveDiscoveryRoot(rootDir, pattern) {
+    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, filePaths) {
+    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) {
+    try {
+        await fsPromises.access(filePath);
+        return true;
+    }
+    catch (error) {
+        if (isPathNotFoundError(error))
+            return false;
+        throw error;
+    }
+}
+function isPathNotFoundError(error) {
+    return (error instanceof Error &&
+        'code' in error &&
+        (error.code === 'ENOENT' || error.code === 'ENOTDIR'));
+}