@remix-run/assets 0.0.0 → 0.2.0

package/dist/lib/asset-server.js

@@ -0,0 +1,338 @@
+import * as path from 'node:path';
+import * as fs from 'node:fs';
+import { createAccessPolicy } from "./access.js";
+import { isAssetServerCompilationError } from "./compilation-error.js";
+import { getFingerprintRequestCacheControl, parseFingerprintSuffix } from "./fingerprint.js";
+import { normalizeFilePath } from "./paths.js";
+import { compileRoutes } from "./routes.js";
+import { createResponseForScript, createScriptCompiler } from "./scripts/compiler.js";
+import { supportedScriptExtensions } from "./scripts/resolve.js";
+import { createResponseForStyle, createStyleCompiler, isStyleFilePath } from "./styles/compiler.js";
+import { resolveScriptTarget, resolveStyleTarget } from "./target.js";
+import { createAssetServerWatcher } from "./watch.js";
+const scriptExtensionSet = new Set(supportedScriptExtensions);
+const chokidarWatcherByAssetServer = new WeakMap();
+const watcherByAssetServer = new WeakMap();
+export function getInternalChokidarWatcher(assetServer) {
+    return chokidarWatcherByAssetServer.get(assetServer);
+}
+export function getInternalWatchTargets(assetServer) {
+    return watcherByAssetServer.get(assetServer)?.getWatchedTargets() ?? [];
+}
+/**
+ * Create an asset server instance
+ *
+ * Compiles TypeScript/JavaScript scripts and CSS styles on demand with optional
+ * source-based URL fingerprinting, caching, and configurable file mapping.
+ *
+ * @param options Server configuration
+ * @returns A {@link AssetServer} with `fetch()`, `getHref()`, and `getPreloads()` methods
+ *
+ * @example
+ * ```ts
+ * let assetServer = createAssetServer({
+ *   fileMap: {
+ *     '/assets/app/*path': 'app/*path',
+ *   },
+ *   allow: ['app/**'],
+ * })
+ *
+ * route('/assets/*path', ({ request }) => assetServer.fetch(request))
+ * ```
+ */
+export function createAssetServer(options) {
+    let resolvedOptions = resolveAssetServerOptions(options);
+    let accessPolicy = createAccessPolicy({
+        allow: resolvedOptions.allow,
+        deny: resolvedOptions.deny,
+        rootDir: resolvedOptions.rootDir,
+    });
+    let watcher = null;
+    let chokidarWatcher = null;
+    let scriptCompiler = createScriptCompiler({
+        buildId: resolvedOptions.buildId,
+        define: resolvedOptions.define,
+        external: resolvedOptions.external,
+        fingerprintAssets: resolvedOptions.fingerprintAssets,
+        isAllowed: accessPolicy.isAllowed,
+        minify: resolvedOptions.minify,
+        onWatchDirectoriesChange: (delta) => {
+            if (!watcher)
+                return;
+            watcher.updateWatchedDirectories(delta);
+        },
+        rootDir: resolvedOptions.rootDir,
+        routes: resolvedOptions.routes,
+        sourceMapSourcePaths: resolvedOptions.sourceMapSourcePaths,
+        sourceMaps: resolvedOptions.sourceMaps,
+        target: resolvedOptions.scriptsTarget,
+        watchIgnore: resolvedOptions.watchOptions?.ignore,
+        watchMode: resolvedOptions.watchOptions !== null,
+    });
+    let styleCompiler = createStyleCompiler({
+        buildId: resolvedOptions.buildId,
+        fingerprintAssets: resolvedOptions.fingerprintAssets,
+        isAllowed: accessPolicy.isAllowed,
+        minify: resolvedOptions.minify,
+        onWatchDirectoriesChange: (delta) => {
+            if (!watcher)
+                return;
+            watcher.updateWatchedDirectories(delta);
+        },
+        rootDir: resolvedOptions.rootDir,
+        routes: resolvedOptions.routes,
+        sourceMapSourcePaths: resolvedOptions.sourceMapSourcePaths,
+        sourceMaps: resolvedOptions.sourceMaps,
+        targets: resolvedOptions.stylesTarget,
+        watchIgnore: resolvedOptions.watchOptions?.ignore,
+    });
+    if (resolvedOptions.watchOptions) {
+        watcher = createAssetServerWatcher({
+            ...resolvedOptions.watchOptions,
+            onChokidarWatcherCreated(createdWatcher) {
+                chokidarWatcher = createdWatcher;
+            },
+            onFileEvent: handleWatchEvent,
+            rootDir: resolvedOptions.rootDir,
+        });
+    }
+    async function responseForError(error) {
+        try {
+            return (await resolvedOptions.onError(error)) ?? internalServerError();
+        }
+        catch (error) {
+            console.error(`There was an error in the asset server error handler: ${error}`);
+            return internalServerError();
+        }
+    }
+    async function handleWatchEvent(filePath, event) {
+        try {
+            let normalizedFilePath = normalizeFilePath(filePath);
+            await scriptCompiler.handleFileEvent(normalizedFilePath, event);
+            await styleCompiler.handleFileEvent(normalizedFilePath, event);
+        }
+        catch (error) {
+            console.error(`There was an error invalidating the asset server cache: ${error}`);
+        }
+    }
+    let assetServer = {
+        async fetch(request) {
+            if (request.method !== 'GET' && request.method !== 'HEAD')
+                return null;
+            let parsedRequestPathname = parseAssetRequestPathname(new URL(request.url).pathname, {
+                fingerprintAssets: resolvedOptions.fingerprintAssets,
+                routes: resolvedOptions.routes,
+            });
+            if (!parsedRequestPathname)
+                return null;
+            try {
+                let ifNoneMatch = request.headers.get('If-None-Match');
+                if (isStyleFilePath(parsedRequestPathname.filePath)) {
+                    let styleResult = await styleCompiler.getStyle(parsedRequestPathname.filePath, {
+                        ifNoneMatch,
+                        isSourceMapRequest: parsedRequestPathname.isSourceMapRequest,
+                        requestedFingerprint: parsedRequestPathname.requestedFingerprint,
+                    });
+                    if (styleResult.type === 'not-modified') {
+                        return new Response(null, {
+                            status: 304,
+                            headers: { ETag: styleResult.etag },
+                        });
+                    }
+                    let compiledStyle = styleResult.style;
+                    if (parsedRequestPathname.requestedFingerprint !== null) {
+                        if (compiledStyle.fingerprint !== parsedRequestPathname.requestedFingerprint)
+                            return null;
+                    }
+                    return createResponseForStyle(compiledStyle, {
+                        cacheControl: parsedRequestPathname.cacheControl,
+                        ifNoneMatch,
+                        isSourceMapRequest: parsedRequestPathname.isSourceMapRequest,
+                        method: request.method,
+                    });
+                }
+                if (!isScriptFilePath(parsedRequestPathname.filePath)) {
+                    return null;
+                }
+                let scriptResult = await scriptCompiler.getScript(parsedRequestPathname.filePath, {
+                    ifNoneMatch,
+                    isSourceMapRequest: parsedRequestPathname.isSourceMapRequest,
+                    requestedFingerprint: parsedRequestPathname.requestedFingerprint,
+                });
+                if (scriptResult.type === 'not-modified') {
+                    return new Response(null, {
+                        status: 304,
+                        headers: { ETag: scriptResult.etag },
+                    });
+                }
+                let compiledScript = scriptResult.script;
+                if (parsedRequestPathname.requestedFingerprint !== null) {
+                    if (compiledScript.fingerprint !== parsedRequestPathname.requestedFingerprint)
+                        return null;
+                }
+                return createResponseForScript(compiledScript, {
+                    cacheControl: parsedRequestPathname.cacheControl,
+                    ifNoneMatch,
+                    isSourceMapRequest: parsedRequestPathname.isSourceMapRequest,
+                    method: request.method,
+                });
+            }
+            catch (error) {
+                // A direct request can race with the filesystem or fail a deeper allow check while
+                // compiling imports. In this fetch context, both cases should fall through as "not
+                // handled here" so the outer router can continue to its own 404 behavior.
+                if (isAssetServerCompilationError(error) &&
+                    (error.code === 'FILE_NOT_FOUND' || error.code === 'FILE_NOT_ALLOWED')) {
+                    return null;
+                }
+                return responseForError(error);
+            }
+        },
+        async getHref(filePath) {
+            if (isStyleFilePath(filePath)) {
+                return styleCompiler.getHref(filePath);
+            }
+            return scriptCompiler.getHref(filePath);
+        },
+        async getPreloads(filePath) {
+            let filePaths = Array.isArray(filePath) ? filePath : [filePath];
+            let styleFiles = [];
+            let scriptFiles = [];
+            for (let nextFilePath of filePaths) {
+                if (isStyleFilePath(nextFilePath)) {
+                    styleFiles.push(nextFilePath);
+                    continue;
+                }
+                scriptFiles.push(nextFilePath);
+            }
+            if (styleFiles.length === 0 && scriptFiles.length === 0) {
+                return [];
+            }
+            if (styleFiles.length === 0) {
+                return flattenPreloadLayers(await scriptCompiler.getPreloadLayers(filePath));
+            }
+            if (scriptFiles.length === 0) {
+                return flattenPreloadLayers(await styleCompiler.getPreloadLayers(filePath));
+            }
+            // Mixed asset type preloads need to be merged, so we merge in order of first asset type seen
+            let scriptPreloadLayersPromise = scriptCompiler.getPreloadLayers(scriptFiles);
+            let stylePreloadLayersPromise = styleCompiler.getPreloadLayers(styleFiles);
+            let preloadLayerGroups = isStyleFilePath(filePaths[0])
+                ? [stylePreloadLayersPromise, scriptPreloadLayersPromise]
+                : [scriptPreloadLayersPromise, stylePreloadLayersPromise];
+            return mergePreloadLayers(await Promise.all(preloadLayerGroups));
+        },
+        async close() {
+            await watcher?.close();
+        },
+    };
+    if (chokidarWatcher) {
+        chokidarWatcherByAssetServer.set(assetServer, chokidarWatcher);
+    }
+    if (watcher) {
+        watcherByAssetServer.set(assetServer, watcher);
+    }
+    return assetServer;
+}
+function internalServerError() {
+    return new Response('Internal Server Error', {
+        status: 500,
+        headers: { 'Content-Type': 'text/plain; charset=utf-8' },
+    });
+}
+function mergePreloadLayers(preloadLayersByRoot) {
+    let urls = [];
+    let seen = new Set();
+    let maxDepth = Math.max(0, ...preloadLayersByRoot.map((layers) => layers.length));
+    for (let depth = 0; depth < maxDepth; depth++) {
+        for (let preloadLayers of preloadLayersByRoot) {
+            for (let url of preloadLayers[depth] ?? []) {
+                if (seen.has(url))
+                    continue;
+                seen.add(url);
+                urls.push(url);
+            }
+        }
+    }
+    return urls;
+}
+function flattenPreloadLayers(preloadLayers) {
+    return preloadLayers.flatMap((layer) => layer);
+}
+function defaultErrorHandler(error) {
+    console.error(error);
+}
+function resolveAssetServerOptions(options) {
+    let rootDir = normalizeFilePath(fs.realpathSync(path.resolve(options.rootDir ?? process.cwd())));
+    let scriptOptions = options.scripts ?? {};
+    let fingerprintOptions = normalizeFingerprintOptions({
+        fingerprint: options.fingerprint,
+        watch: options.watch,
+    });
+    return {
+        allow: options.allow,
+        buildId: fingerprintOptions.buildId,
+        define: scriptOptions.define,
+        deny: options.deny,
+        external: scriptOptions.external ?? [],
+        fingerprintAssets: fingerprintOptions.enabled,
+        minify: options.minify ?? false,
+        onError: options.onError ?? defaultErrorHandler,
+        rootDir,
+        routes: compileRoutes({
+            fileMap: options.fileMap,
+            rootDir,
+        }),
+        sourceMapSourcePaths: options.sourceMapSourcePaths ?? 'url',
+        sourceMaps: options.sourceMaps,
+        scriptsTarget: resolveScriptTarget(options.target),
+        stylesTarget: resolveStyleTarget(options.target),
+        watchOptions: normalizeWatchOptions(options.watch),
+    };
+}
+function normalizeFingerprintOptions(options) {
+    if (!options.fingerprint) {
+        return {
+            enabled: false,
+        };
+    }
+    if (typeof options.fingerprint.buildId !== 'string') {
+        throw new TypeError('fingerprint.buildId must be a string');
+    }
+    if (options.fingerprint.buildId.length === 0) {
+        throw new TypeError('fingerprint.buildId must be a non-empty string');
+    }
+    if (options.watch !== false) {
+        throw new TypeError('fingerprint cannot be used with watch mode');
+    }
+    return {
+        enabled: true,
+        buildId: options.fingerprint.buildId,
+    };
+}
+function normalizeWatchOptions(options) {
+    if (options === false)
+        return null;
+    if (options == null || options === true)
+        return {};
+    return options;
+}
+function parseAssetRequestPathname(pathname, options) {
+    let isSourceMapRequest = pathname.endsWith('.map');
+    let pathWithoutMap = isSourceMapRequest ? pathname.slice(0, -4) : pathname;
+    let fingerprint = parseFingerprintSuffix(pathWithoutMap);
+    let filePath = options.routes.resolveUrlPathname(fingerprint.pathname);
+    if (!filePath)
+        return null;
+    if (options.fingerprintAssets && fingerprint.requestedFingerprint === null)
+        return null;
+    return {
+        cacheControl: getFingerprintRequestCacheControl(fingerprint.requestedFingerprint),
+        filePath,
+        isSourceMapRequest,
+        requestedFingerprint: fingerprint.requestedFingerprint,
+    };
+}
+function isScriptFilePath(filePath) {
+    return scriptExtensionSet.has(path.extname(filePath).toLowerCase());
+}

package/dist/lib/compilation-error.d.ts

@@ -0,0 +1,33 @@
+type AssetServerCompilationErrorCode = 'FILE_NOT_FOUND' | 'FILE_NOT_ALLOWED' | 'FILE_OUTSIDE_FILE_MAP' | 'COMMONJS_NOT_SUPPORTED' | 'TRANSFORM_FAILED' | 'EMIT_FAILED' | 'IMPORT_RESOLUTION_FAILED' | 'IMPORT_NOT_SUPPORTED' | 'IMPORT_NOT_ALLOWED' | 'IMPORT_OUTSIDE_FILE_MAP';
+/**
+ * Internal error used by the request-time asset compilation pipeline.
+ */
+export declare class AssetServerCompilationError extends Error {
+    code: AssetServerCompilationErrorCode;
+    constructor(message: string, options: {
+        cause?: unknown;
+        code: AssetServerCompilationErrorCode;
+    });
+}
+/**
+ * Returns true when a value is an `AssetServerCompilationError`.
+ *
+ * @param error Value thrown by the compilation pipeline.
+ * @returns Whether the value is an `AssetServerCompilationError`.
+ */
+export declare function isAssetServerCompilationError(error: unknown): error is AssetServerCompilationError;
+/**
+ * Creates an `AssetServerCompilationError` with a stable internal code.
+ *
+ * @param message Human-readable error message.
+ * @param options Structured internal error details.
+ * @param options.cause Original error cause, when available.
+ * @param options.code Stable internal compilation error code.
+ * @returns A `AssetServerCompilationError`.
+ */
+export declare function createAssetServerCompilationError(message: string, options: {
+    cause?: unknown;
+    code: AssetServerCompilationErrorCode;
+}): AssetServerCompilationError;
+export {};
+//# sourceMappingURL=compilation-error.d.ts.map

package/dist/lib/compilation-error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compilation-error.d.ts","sourceRoot":"","sources":["../../src/lib/compilation-error.ts"],"names":[],"mappings":"AAAA,KAAK,+BAA+B,GAChC,gBAAgB,GAChB,kBAAkB,GAClB,uBAAuB,GACvB,wBAAwB,GACxB,kBAAkB,GAClB,aAAa,GACb,0BAA0B,GAC1B,sBAAsB,GACtB,oBAAoB,GACpB,yBAAyB,CAAA;AAE7B;;GAEG;AACH,qBAAa,2BAA4B,SAAQ,KAAK;IACpD,IAAI,EAAE,+BAA+B,CAAA;IAErC,YACE,OAAO,EAAE,MAAM,EACf,OAAO,EAAE;QACP,KAAK,CAAC,EAAE,OAAO,CAAA;QACf,IAAI,EAAE,+BAA+B,CAAA;KACtC,EAKF;CACF;AAED;;;;;GAKG;AACH,wBAAgB,6BAA6B,CAC3C,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,2BAA2B,CAEtC;AAED;;;;;;;;GAQG;AACH,wBAAgB,iCAAiC,CAC/C,OAAO,EAAE,MAAM,EACf,OAAO,EAAE;IACP,KAAK,CAAC,EAAE,OAAO,CAAA;IACf,IAAI,EAAE,+BAA+B,CAAA;CACtC,GACA,2BAA2B,CAE7B"}

package/dist/lib/compilation-error.js

@@ -0,0 +1,32 @@
+/**
+ * Internal error used by the request-time asset compilation pipeline.
+ */
+export class AssetServerCompilationError extends Error {
+    code;
+    constructor(message, options) {
+        super(message, options.cause === undefined ? undefined : { cause: options.cause });
+        this.name = 'AssetServerCompilationError';
+        this.code = options.code;
+    }
+}
+/**
+ * Returns true when a value is an `AssetServerCompilationError`.
+ *
+ * @param error Value thrown by the compilation pipeline.
+ * @returns Whether the value is an `AssetServerCompilationError`.
+ */
+export function isAssetServerCompilationError(error) {
+    return error instanceof AssetServerCompilationError;
+}
+/**
+ * Creates an `AssetServerCompilationError` with a stable internal code.
+ *
+ * @param message Human-readable error message.
+ * @param options Structured internal error details.
+ * @param options.cause Original error cause, when available.
+ * @param options.code Stable internal compilation error code.
+ * @returns A `AssetServerCompilationError`.
+ */
+export function createAssetServerCompilationError(message, options) {
+    return new AssetServerCompilationError(message, options);
+}

package/dist/lib/file-matcher.d.ts

@@ -0,0 +1,6 @@
+export type FileMatcher = (filePath: string) => boolean;
+export declare function createFileMatcher(pattern: string, rootDir: string, options?: {
+    allowDirectories?: boolean;
+    allowMissing?: boolean;
+}): FileMatcher;
+//# sourceMappingURL=file-matcher.d.ts.map

package/dist/lib/file-matcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-matcher.d.ts","sourceRoot":"","sources":["../../src/lib/file-matcher.ts"],"names":[],"mappings":"AAKA,MAAM,MAAM,WAAW,GAAG,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAA;AAEvD,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,OAAO,GAAE;IACP,gBAAgB,CAAC,EAAE,OAAO,CAAA;IAC1B,YAAY,CAAC,EAAE,OAAO,CAAA;CAClB,GACL,WAAW,CA2Bb"}

package/dist/lib/file-matcher.js

@@ -0,0 +1,44 @@
+import * as fs from 'node:fs';
+import picomatch from 'picomatch';
+import { normalizeFilePath, resolveFilePath } from "./paths.js";
+export function createFileMatcher(pattern, rootDir, options = {}) {
+    let resolvedPatternPath = resolveFilePath(rootDir, pattern);
+    let allowDirectories = options.allowDirectories ?? true;
+    let allowMissing = options.allowMissing ?? true;
+    if (!containsGlobSyntax(pattern)) {
+        try {
+            resolvedPatternPath = normalizeFilePath(fs.realpathSync(resolvedPatternPath));
+        }
+        catch (error) {
+            if (!allowMissing || !isPathNotFoundError(error))
+                throw error;
+        }
+        if (allowDirectories) {
+            try {
+                if (fs.statSync(resolveFilePath(rootDir, pattern)).isDirectory()) {
+                    return (filePath) => isSameOrDescendantPath(filePath, resolvedPatternPath);
+                }
+            }
+            catch (error) {
+                if (!isPathNotFoundError(error))
+                    throw error;
+            }
+        }
+        return (filePath) => filePath === resolvedPatternPath;
+    }
+    let globMatcher = picomatch(resolvedPatternPath, { dot: true });
+    return (filePath) => globMatcher(filePath);
+}
+function isSameOrDescendantPath(filePath, directoryPath) {
+    let normalizedDirectoryPath = directoryPath.replace(/\/+$/, '');
+    return filePath === normalizedDirectoryPath || filePath.startsWith(`${normalizedDirectoryPath}/`);
+}
+function containsGlobSyntax(pattern) {
+    return /[*?[\]{}()!+@]/.test(pattern);
+}
+function isPathNotFoundError(error) {
+    return (error instanceof Error &&
+        'code' in error &&
+        (error.code === 'ENOENT' ||
+            error.code === 'ENOTDIR'));
+}

package/dist/lib/fingerprint.d.ts

@@ -0,0 +1,12 @@
+export declare function hashContent(content: string): Promise<string>;
+export declare function generateFingerprint(options: {
+    buildId: string;
+    content: string;
+}): Promise<string>;
+export declare function parseFingerprintSuffix(pathname: string): {
+    pathname: string;
+    requestedFingerprint: string | null;
+};
+export declare function formatFingerprintedPathname(pathname: string, fingerprint: string | null): string;
+export declare function getFingerprintRequestCacheControl(requestedFingerprint: string | null): string;
+//# sourceMappingURL=fingerprint.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fingerprint.d.ts","sourceRoot":"","sources":["../../src/lib/fingerprint.ts"],"names":[],"mappings":"AAGA,wBAAsB,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAKlE;AAED,wBAAsB,mBAAmB,CAAC,OAAO,EAAE;IACjD,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,MAAM,CAAA;CAChB,GAAG,OAAO,CAAC,MAAM,CAAC,CAElB;AAED,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,MAAM,GAAG;IACxD,QAAQ,EAAE,MAAM,CAAA;IAChB,oBAAoB,EAAE,MAAM,GAAG,IAAI,CAAA;CACpC,CAyBA;AAED,wBAAgB,2BAA2B,CAAC,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,CAahG;AAED,wBAAgB,iCAAiC,CAAC,oBAAoB,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,CAE7F"}

package/dist/lib/fingerprint.js

@@ -0,0 +1,49 @@
+const fingerprintedExtensionRE = /^(.+)\.@([A-Za-z0-9_-]+)(\.[^./]+)$/;
+const fingerprintedBasenameRE = /^(.+)\.@([A-Za-z0-9_-]+)$/;
+export async function hashContent(content) {
+    let encoder = new TextEncoder();
+    let data = encoder.encode(content);
+    let hashBuffer = await crypto.subtle.digest('SHA-256', data);
+    return Buffer.from(hashBuffer).toString('base64url').slice(0, 6);
+}
+export async function generateFingerprint(options) {
+    return hashContent(JSON.stringify([options.content, options.buildId]));
+}
+export function parseFingerprintSuffix(pathname) {
+    let lastSlashIndex = pathname.lastIndexOf('/');
+    let directory = lastSlashIndex >= 0 ? pathname.slice(0, lastSlashIndex + 1) : '';
+    let basename = lastSlashIndex >= 0 ? pathname.slice(lastSlashIndex + 1) : pathname;
+    let extensionMatch = basename.match(fingerprintedExtensionRE);
+    if (extensionMatch) {
+        return {
+            pathname: `${directory}${extensionMatch[1]}${extensionMatch[3]}`,
+            requestedFingerprint: extensionMatch[2],
+        };
+    }
+    let basenameMatch = basename.match(fingerprintedBasenameRE);
+    if (basenameMatch) {
+        return {
+            pathname: `${directory}${basenameMatch[1]}`,
+            requestedFingerprint: basenameMatch[2],
+        };
+    }
+    return {
+        pathname,
+        requestedFingerprint: null,
+    };
+}
+export function formatFingerprintedPathname(pathname, fingerprint) {
+    if (fingerprint === null)
+        return pathname;
+    let lastSlashIndex = pathname.lastIndexOf('/');
+    let directory = lastSlashIndex >= 0 ? pathname.slice(0, lastSlashIndex + 1) : '';
+    let basename = lastSlashIndex >= 0 ? pathname.slice(lastSlashIndex + 1) : pathname;
+    let lastDotIndex = basename.lastIndexOf('.');
+    if (lastDotIndex <= 0) {
+        return `${pathname}.@${fingerprint}`;
+    }
+    return `${directory}${basename.slice(0, lastDotIndex)}.@${fingerprint}${basename.slice(lastDotIndex)}`;
+}
+export function getFingerprintRequestCacheControl(requestedFingerprint) {
+    return requestedFingerprint === null ? 'no-cache' : 'public, max-age=31536000, immutable';
+}

package/dist/lib/module-store.d.ts

@@ -0,0 +1,41 @@
+export type ModuleTracking = {
+    trackedFiles: readonly string[];
+    trackedDirectories?: readonly string[];
+};
+export type ModuleWatchEvent = 'change' | 'add' | 'unlink';
+export type FileSnapshot = {
+    mtimeNs: bigint;
+    size: bigint;
+};
+export type ModuleSnapshot = ReadonlyMap<string, FileSnapshot>;
+type ModuleRecordState<transformed, resolved, emitted> = {
+    identityPath: string;
+    invalidationVersion: number;
+    transformed?: transformed;
+    resolved?: resolved;
+    emitted?: emitted;
+    emittedSnapshot?: ModuleSnapshot;
+    staleEmitted?: emitted;
+    staleEmittedSnapshot?: ModuleSnapshot;
+    trackedFiles: ReadonlySet<string>;
+    trackedDirectories: ReadonlySet<string>;
+};
+export type ModuleRecord<transformed, resolved, emitted> = Readonly<ModuleRecordState<transformed, resolved, emitted>>;
+export type ModuleStore<transformed, resolved, emitted> = {
+    get(identityPath: string): ModuleRecord<transformed, resolved, emitted>;
+    clearTransformed(identityPath: string, tracking: readonly ModuleTracking[]): void;
+    setTransformed(identityPath: string, transformed: transformed, tracking: readonly ModuleTracking[]): void;
+    setResolved(identityPath: string, resolved: resolved, tracking: readonly ModuleTracking[]): void;
+    clearResolved(identityPath: string, tracking: readonly ModuleTracking[]): void;
+    setEmitted(identityPath: string, emitted: emitted, snapshot: ModuleSnapshot | null): void;
+    invalidateForFileEvent(filePath: string, event: ModuleWatchEvent): void;
+    invalidateAll(): void;
+};
+export declare function createModuleStore<transformed, resolved, emitted>(options?: {
+    onWatchDirectoriesChange?: (delta: {
+        add: string[];
+        remove: string[];
+    }) => void;
+}): ModuleStore<transformed, resolved, emitted>;
+export {};
+//# sourceMappingURL=module-store.d.ts.map

package/dist/lib/module-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module-store.d.ts","sourceRoot":"","sources":["../../src/lib/module-store.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,cAAc,GAAG;IAC3B,YAAY,EAAE,SAAS,MAAM,EAAE,CAAA;IAC/B,kBAAkB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CACvC,CAAA;AAED,MAAM,MAAM,gBAAgB,GAAG,QAAQ,GAAG,KAAK,GAAG,QAAQ,CAAA;AAE1D,MAAM,MAAM,YAAY,GAAG;IACzB,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;CACb,CAAA;AAED,MAAM,MAAM,cAAc,GAAG,WAAW,CAAC,MAAM,EAAE,YAAY,CAAC,CAAA;AAE9D,KAAK,iBAAiB,CAAC,WAAW,EAAE,QAAQ,EAAE,OAAO,IAAI;IACvD,YAAY,EAAE,MAAM,CAAA;IACpB,mBAAmB,EAAE,MAAM,CAAA;IAC3B,WAAW,CAAC,EAAE,WAAW,CAAA;IACzB,QAAQ,CAAC,EAAE,QAAQ,CAAA;IACnB,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,eAAe,CAAC,EAAE,cAAc,CAAA;IAChC,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,oBAAoB,CAAC,EAAE,cAAc,CAAA;IACrC,YAAY,EAAE,WAAW,CAAC,MAAM,CAAC,CAAA;IACjC,kBAAkB,EAAE,WAAW,CAAC,MAAM,CAAC,CAAA;CACxC,CAAA;AAED,MAAM,MAAM,YAAY,CAAC,WAAW,EAAE,QAAQ,EAAE,OAAO,IAAI,QAAQ,CACjE,iBAAiB,CAAC,WAAW,EAAE,QAAQ,EAAE,OAAO,CAAC,CAClD,CAAA;AAeD,MAAM,MAAM,WAAW,CAAC,WAAW,EAAE,QAAQ,EAAE,OAAO,IAAI;IACxD,GAAG,CAAC,YAAY,EAAE,MAAM,GAAG,YAAY,CAAC,WAAW,EAAE,QAAQ,EAAE,OAAO,CAAC,CAAA;IACvE,gBAAgB,CAAC,YAAY,EAAE,MAAM,EAAE,QAAQ,EAAE,SAAS,cAAc,EAAE,GAAG,IAAI,CAAA;IACjF,cAAc,CACZ,YAAY,EAAE,MAAM,EACpB,WAAW,EAAE,WAAW,EACxB,QAAQ,EAAE,SAAS,cAAc,EAAE,GAClC,IAAI,CAAA;IACP,WAAW,CAAC,YAAY,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,SAAS,cAAc,EAAE,GAAG,IAAI,CAAA;IAChG,aAAa,CAAC,YAAY,EAAE,MAAM,EAAE,QAAQ,EAAE,SAAS,cAAc,EAAE,GAAG,IAAI,CAAA;IAC9E,UAAU,CAAC,YAAY,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,cAAc,GAAG,IAAI,GAAG,IAAI,CAAA;IACzF,sBAAsB,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,gBAAgB,GAAG,IAAI,CAAA;IACvE,aAAa,IAAI,IAAI,CAAA;CACtB,CAAA;AAED,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,QAAQ,EAAE,OAAO,EAC9D,OAAO,GAAE;IACP,wBAAwB,CAAC,EAAE,CAAC,KAAK,EAAE;QAAE,GAAG,EAAE,MAAM,EAAE,CAAC;QAAC,MAAM,EAAE,MAAM,EAAE,CAAA;KAAE,KAAK,IAAI,CAAA;CAC3E,GACL,WAAW,CAAC,WAAW,EAAE,QAAQ,EAAE,OAAO,CAAC,CA4M7C"}