@remix-run/assets 0.0.0 → 0.1.0

package/dist/lib/scripts/transform.js

@@ -0,0 +1,362 @@
+import * as fs from 'node:fs';
+import * as fsp from 'node:fs/promises';
+import * as path from 'node:path';
+import { getTsconfig } from 'get-tsconfig';
+import { minify } from 'oxc-minify';
+import { transform as oxcTransform } from 'oxc-transform';
+import { init as esModuleLexerInit, parse as esModuleLexer } from 'es-module-lexer';
+import { isCommonJS, mayContainCommonJSModuleGlobals } from "./cjs-check.js";
+import { createAssetServerCompilationError, isAssetServerCompilationError, } from "../compilation-error.js";
+import { generateFingerprint } from "../fingerprint.js";
+import { normalizeFilePath } from "../paths.js";
+import { composeSourceMaps, rewriteSourceMapSources, stringifySourceMap } from "../source-maps.js";
+const scriptModuleTypes = [
+    { extension: '.js', lang: 'js' },
+    { extension: '.jsx', lang: 'jsx' },
+    { extension: '.mjs', lang: 'js' },
+    { extension: '.mts', lang: 'ts' },
+    { extension: '.ts', lang: 'ts' },
+    { extension: '.tsx', lang: 'tsx' },
+];
+const sourceLanguageByExtension = new Map(scriptModuleTypes.map(({ extension, lang }) => [extension, lang]));
+const supportedTsconfigTransformCompilerOptions = {
+    allowNamespaces: 'allowNamespaces',
+    emitDecoratorMetadata: 'emitDecoratorMetadata',
+    experimentalDecorators: 'experimentalDecorators',
+    jsx: 'jsx',
+    jsxFactory: 'jsxFactory',
+    jsxFragmentFactory: 'jsxFragmentFactory',
+    jsxImportSource: 'jsxImportSource',
+    useDefineForClassFields: 'useDefineForClassFields',
+};
+export function createTsconfigTransformOptionsResolver() {
+    let fileSystemCache = new Map();
+    let transformOptionsByDirectory = new Map();
+    return {
+        clear() {
+            fileSystemCache = new Map();
+            transformOptionsByDirectory.clear();
+        },
+        getTransformOptions(filePath, isWatchIgnored) {
+            let directory = path.dirname(filePath);
+            let cached = transformOptionsByDirectory.get(directory);
+            if (cached)
+                return cached;
+            let tsconfig = getTsconfig(directory, 'tsconfig.json', fileSystemCache);
+            if (!tsconfig) {
+                let transformOptions = { trackedFiles: [] };
+                transformOptionsByDirectory.set(directory, transformOptions);
+                return transformOptions;
+            }
+            let tsconfigPath = findNearestTsconfigPath(directory);
+            let transformOptions = {
+                trackedFiles: tsconfigPath && !isWatchIgnored(tsconfigPath) ? [tsconfigPath] : [],
+                tsconfigRaw: tsconfig.config,
+            };
+            transformOptionsByDirectory.set(directory, transformOptions);
+            return transformOptions;
+        },
+    };
+}
+export async function transformModule(record, args) {
+    let resolvedPath = args.resolveActualPath(record.identityPath);
+    if (!resolvedPath) {
+        return {
+            ok: false,
+            error: createAssetServerCompilationError(`Module not found: ${record.identityPath}`, {
+                code: 'MODULE_NOT_FOUND',
+            }),
+            trackedFiles: args.isWatchIgnored(record.identityPath) ? [] : [record.identityPath],
+        };
+    }
+    let transformOptions = args.tsconfigTransformOptionsResolver.getTransformOptions(resolvedPath, args.isWatchIgnored);
+    let trackedFiles = [
+        ...(args.isWatchIgnored(resolvedPath) ? [] : [resolvedPath]),
+        ...transformOptions.trackedFiles,
+    ];
+    let sourceText;
+    try {
+        sourceText = await fsp.readFile(resolvedPath, 'utf-8');
+    }
+    catch (error) {
+        if (isNoEntityError(error)) {
+            return {
+                ok: false,
+                error: createAssetServerCompilationError(`Module not found: ${resolvedPath}`, {
+                    cause: error,
+                    code: 'MODULE_NOT_FOUND',
+                }),
+                trackedFiles,
+            };
+        }
+        return {
+            ok: false,
+            error: toTransformFailedError(error, resolvedPath),
+            trackedFiles,
+        };
+    }
+    try {
+        let analysis = await analyzeModuleSource(sourceText, resolvedPath, transformOptions, {
+            define: args.define ?? undefined,
+            minify: args.minify,
+            sourceMaps: args.sourceMaps ?? undefined,
+            target: args.target ?? undefined,
+        });
+        analysis.unresolvedImports = analysis.unresolvedImports.filter((unresolved) => !args.externalSet.has(unresolved.specifier));
+        if (mayContainCommonJSModuleGlobals(sourceText) && isCommonJS(analysis.rawCode)) {
+            throw createAssetServerCompilationError(`CommonJS module detected: ${resolvedPath}. ` +
+                `This module uses CommonJS (require/module.exports) which is not supported. ` +
+                `Please use an ESM-compatible module.`, {
+                code: 'MODULE_COMMONJS_NOT_SUPPORTED',
+            });
+        }
+        let stableUrlPathname = args.routes.toUrlPathname(record.identityPath);
+        if (!stableUrlPathname) {
+            throw createAssetServerCompilationError(`Module ${record.identityPath} is outside all configured fileMap entries.`, {
+                code: 'MODULE_OUTSIDE_FILE_MAP',
+            });
+        }
+        let sourceMap = analysis.sourceMap
+            ? rewriteSourceMapSources(analysis.sourceMap, resolvedPath, stableUrlPathname, args.sourceMapSourcePaths)
+            : null;
+        return {
+            ok: true,
+            value: {
+                fingerprint: args.buildId === null
+                    ? null
+                    : await generateFingerprint({
+                        buildId: args.buildId,
+                        content: sourceText,
+                    }),
+                identityPath: record.identityPath,
+                importerDir: path.dirname(resolvedPath),
+                packageSpecifiers: analysis.unresolvedImports
+                    .filter((unresolved) => isPackageImportSpecifier(unresolved.specifier))
+                    .map((unresolved) => unresolved.specifier),
+                rawCode: analysis.rawCode,
+                resolvedPath,
+                sourceMap,
+                stableUrlPathname,
+                trackedFiles,
+                unresolvedImports: analysis.unresolvedImports,
+            },
+        };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            error: toTransformFailedError(error, resolvedPath),
+            trackedFiles,
+        };
+    }
+}
+function findNearestTsconfigPath(directory) {
+    let currentDirectory = directory;
+    while (true) {
+        let tsconfigPath = path.join(currentDirectory, 'tsconfig.json');
+        if (fs.existsSync(tsconfigPath)) {
+            return normalizeFilePath(tsconfigPath);
+        }
+        let parentDirectory = path.dirname(currentDirectory);
+        if (parentDirectory === currentDirectory)
+            return null;
+        currentDirectory = parentDirectory;
+    }
+}
+function isPackageImportSpecifier(specifier) {
+    return !specifier.startsWith('./') && !specifier.startsWith('../') && !specifier.startsWith('/');
+}
+async function analyzeModuleSource(sourceText, resolvedPath, transformOptions, options) {
+    let transformResult;
+    try {
+        transformResult = await oxcTransform(resolvedPath, sourceText, getTransformOptions(resolvedPath, transformOptions, options));
+        assertNoCompilerErrors(transformResult.errors, resolvedPath, 'transform');
+    }
+    catch (error) {
+        if (isAssetServerCompilationError(error))
+            throw error;
+        throw createAssetServerCompilationError(`Failed to transform module ${resolvedPath}. ${formatUnknownError(error)}`, {
+            cause: error,
+            code: 'MODULE_TRANSFORM_FAILED',
+        });
+    }
+    let rawCode = transformResult.code.trimEnd();
+    let sourceMap = stringifySourceMap(transformResult.map);
+    if (options.minify) {
+        let minifyResult = await minifyModule(rawCode, resolvedPath, options.target, options.sourceMaps);
+        rawCode = minifyResult.code.trimEnd();
+        let minifyMap = stringifySourceMap(minifyResult.map);
+        sourceMap =
+            minifyMap == null
+                ? sourceMap
+                : sourceMap == null
+                    ? minifyMap
+                    : composeSourceMaps(minifyMap, sourceMap);
+    }
+    return {
+        rawCode,
+        sourceMap,
+        unresolvedImports: await getUnresolvedImportsFromLexer(rawCode),
+    };
+}
+async function minifyModule(rawCode, resolvedPath, target, sourceMaps) {
+    try {
+        let result = await minify(resolvedPath, rawCode, {
+            compress: target ? { target } : true,
+            mangle: true,
+            module: true,
+            sourcemap: sourceMaps != null,
+        });
+        assertNoCompilerErrors(result.errors, resolvedPath, 'minify');
+        return result;
+    }
+    catch (error) {
+        if (isAssetServerCompilationError(error))
+            throw error;
+        throw createAssetServerCompilationError(`Failed to minify module ${resolvedPath}. ${formatUnknownError(error)}`, {
+            cause: error,
+            code: 'MODULE_TRANSFORM_FAILED',
+        });
+    }
+}
+function getTransformOptions(resolvedPath, transformOptions, options) {
+    let compilerOptions = transformOptions.tsconfigRaw?.compilerOptions;
+    let useDefineForClassFields = getBooleanOption(compilerOptions, supportedTsconfigTransformCompilerOptions.useDefineForClassFields);
+    let jsxFactory = getStringOption(compilerOptions, supportedTsconfigTransformCompilerOptions.jsxFactory);
+    let jsxFragmentFactory = getStringOption(compilerOptions, supportedTsconfigTransformCompilerOptions.jsxFragmentFactory);
+    return {
+        assumptions: useDefineForClassFields === false
+            ? {
+                setPublicClassFields: true,
+            }
+            : undefined,
+        decorator: getDecoratorOptions(compilerOptions),
+        define: options.define,
+        jsx: getJsxOptions(resolvedPath, compilerOptions),
+        lang: getSourceLanguageForPath(resolvedPath),
+        sourceType: 'module',
+        sourcemap: options.sourceMaps != null,
+        target: options.target,
+        typescript: {
+            allowNamespaces: getBooleanOption(compilerOptions, supportedTsconfigTransformCompilerOptions.allowNamespaces),
+            jsxPragma: jsxFactory,
+            jsxPragmaFrag: jsxFragmentFactory,
+            removeClassFieldsWithoutInitializer: useDefineForClassFields === false ? true : undefined,
+        },
+    };
+}
+function getJsxOptions(resolvedPath, compilerOptions) {
+    let language = getSourceLanguageForPath(resolvedPath);
+    if (language !== 'jsx' && language !== 'tsx')
+        return undefined;
+    let jsx = getStringOption(compilerOptions, supportedTsconfigTransformCompilerOptions.jsx);
+    let importSource = getStringOption(compilerOptions, supportedTsconfigTransformCompilerOptions.jsxImportSource);
+    let pragma = getStringOption(compilerOptions, supportedTsconfigTransformCompilerOptions.jsxFactory);
+    let pragmaFrag = getStringOption(compilerOptions, supportedTsconfigTransformCompilerOptions.jsxFragmentFactory);
+    if (jsx === 'preserve' || jsx === 'react-native') {
+        throw createAssetServerCompilationError(`Unsupported tsconfig compilerOptions.jsx = "${jsx}" for ${resolvedPath}. ` +
+            `Asset server must compile JSX to browser-runnable JavaScript.`, {
+            code: 'MODULE_TRANSFORM_FAILED',
+        });
+    }
+    if (jsx === 'react-jsx' || jsx === 'react-jsxdev') {
+        return {
+            development: jsx === 'react-jsxdev',
+            importSource,
+            runtime: 'automatic',
+        };
+    }
+    return {
+        pragma,
+        pragmaFrag,
+        runtime: 'classic',
+    };
+}
+function getDecoratorOptions(compilerOptions) {
+    let legacy = getBooleanOption(compilerOptions, supportedTsconfigTransformCompilerOptions.experimentalDecorators);
+    let emitDecoratorMetadata = getBooleanOption(compilerOptions, supportedTsconfigTransformCompilerOptions.emitDecoratorMetadata);
+    if (legacy !== true && emitDecoratorMetadata !== true)
+        return undefined;
+    return {
+        emitDecoratorMetadata,
+        legacy,
+    };
+}
+function getBooleanOption(compilerOptions, key) {
+    let value = compilerOptions?.[key];
+    return typeof value === 'boolean' ? value : undefined;
+}
+function getStringOption(compilerOptions, key) {
+    let value = compilerOptions?.[key];
+    return typeof value === 'string' ? value : undefined;
+}
+function assertNoCompilerErrors(errors, resolvedPath, operation) {
+    if (!errors || errors.length === 0)
+        return;
+    throw createAssetServerCompilationError(`Failed to ${operation} module ${resolvedPath}. ${errors[0].message ?? 'Unknown error'}`, {
+        code: 'MODULE_TRANSFORM_FAILED',
+    });
+}
+async function getUnresolvedImportsFromLexer(rawCode) {
+    await esModuleLexerInit;
+    let [imports] = esModuleLexer(rawCode);
+    let unresolvedImports = [];
+    for (let imported of imports) {
+        let specifier = getStaticImportSpecifier(rawCode, imported);
+        if (specifier == null || shouldSkipImportSpecifier(specifier))
+            continue;
+        unresolvedImports.push({
+            specifier,
+            start: imported.s,
+            end: imported.e,
+            quote: getImportQuote(rawCode, imported.s),
+        });
+    }
+    return unresolvedImports;
+}
+function getStaticImportSpecifier(source, imported) {
+    if (imported.n != null) {
+        return imported.n;
+    }
+    if (imported.d < 0) {
+        return null;
+    }
+    let rawSpecifier = source.slice(imported.s, imported.e);
+    if (!isStaticTemplateLiteral(rawSpecifier)) {
+        return null;
+    }
+    return rawSpecifier.slice(1, -1);
+}
+function isStaticTemplateLiteral(specifier) {
+    return specifier.startsWith('`') && specifier.endsWith('`') && !specifier.includes('${');
+}
+function shouldSkipImportSpecifier(specifier) {
+    return (specifier.startsWith('data:') ||
+        specifier.startsWith('http://') ||
+        specifier.startsWith('https://'));
+}
+function getImportQuote(source, start) {
+    let firstCharacter = source[start];
+    if (firstCharacter === '"' || firstCharacter === "'" || firstCharacter === '`') {
+        return firstCharacter;
+    }
+    return undefined;
+}
+function getSourceLanguageForPath(resolvedPath) {
+    let extension = path.extname(resolvedPath).toLowerCase();
+    return sourceLanguageByExtension.get(extension) ?? 'js';
+}
+function formatUnknownError(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function toTransformFailedError(error, resolvedPath) {
+    if (isAssetServerCompilationError(error))
+        return error;
+    return createAssetServerCompilationError(`Failed to transform module ${resolvedPath}. ${formatUnknownError(error)}`, {
+        cause: error,
+        code: 'MODULE_TRANSFORM_FAILED',
+    });
+}
+function isNoEntityError(error) {
+    return (error instanceof Error && 'code' in error && error.code === 'ENOENT');
+}

package/dist/lib/source-maps.d.ts

@@ -0,0 +1,4 @@
+export declare function composeSourceMaps(rewriteSourceMap: string, transformSourceMap: string): string;
+export declare function rewriteSourceMapSources(sourceMap: string, resolvedPath: string, stableUrlPathname: string, sourceMapSourcePaths: 'absolute' | 'url'): string;
+export declare function stringifySourceMap(map: unknown): string | null;
+//# sourceMappingURL=source-maps.d.ts.map

package/dist/lib/source-maps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"source-maps.d.ts","sourceRoot":"","sources":["../../src/lib/source-maps.ts"],"names":[],"mappings":"AAIA,wBAAgB,iBAAiB,CAAC,gBAAgB,EAAE,MAAM,EAAE,kBAAkB,EAAE,MAAM,GAAG,MAAM,CA2C9F;AAED,wBAAgB,uBAAuB,CACrC,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,MAAM,EACpB,iBAAiB,EAAE,MAAM,EACzB,oBAAoB,EAAE,UAAU,GAAG,KAAK,GACvC,MAAM,CAMR;AAED,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAK9D"}

package/dist/lib/source-maps.js

@@ -0,0 +1,56 @@
+import { SourceMapConsumer, SourceMapGenerator } from 'source-map-js';
+import { normalizeFilePath } from "./paths.js";
+export function composeSourceMaps(rewriteSourceMap, transformSourceMap) {
+    let rewriteConsumer = new SourceMapConsumer(JSON.parse(rewriteSourceMap));
+    let transformConsumer = new SourceMapConsumer(JSON.parse(transformSourceMap));
+    let generator = new SourceMapGenerator();
+    rewriteConsumer.eachMapping((mapping) => {
+        if (mapping.originalLine == null ||
+            mapping.originalColumn == null ||
+            mapping.generatedLine == null ||
+            mapping.generatedColumn == null) {
+            return;
+        }
+        let original = transformConsumer.originalPositionFor({
+            line: mapping.originalLine,
+            column: mapping.originalColumn,
+        });
+        if (original.line == null || original.column == null || original.source == null)
+            return;
+        generator.addMapping({
+            generated: {
+                line: mapping.generatedLine,
+                column: mapping.generatedColumn,
+            },
+            original: {
+                line: original.line,
+                column: original.column,
+            },
+            source: original.source,
+            name: original.name ?? mapping.name ?? undefined,
+        });
+    });
+    for (let source of transformConsumer.sources) {
+        let sourceContent = transformConsumer.sourceContentFor(source, true);
+        if (sourceContent !== null) {
+            generator.setSourceContent(source, sourceContent);
+        }
+    }
+    return JSON.stringify(generator.toJSON());
+}
+export function rewriteSourceMapSources(sourceMap, resolvedPath, stableUrlPathname, sourceMapSourcePaths) {
+    let json = JSON.parse(sourceMap);
+    json.sources = [
+        sourceMapSourcePaths === 'absolute' ? normalizeFilePath(resolvedPath) : stableUrlPathname,
+    ];
+    return JSON.stringify(json);
+}
+export function stringifySourceMap(map) {
+    if (!map)
+        return null;
+    if (typeof map === 'string')
+        return map;
+    if (typeof map === 'object' && map !== null)
+        return JSON.stringify(map);
+    return String(map);
+}

package/dist/lib/watch.d.ts

@@ -0,0 +1,22 @@
+import chokidar from 'chokidar';
+type AssetServerWatcherOptions = {
+    ignore?: readonly string[];
+    onChokidarWatcherCreated?: (watcher: ChokidarWatcher) => void;
+    poll?: boolean;
+    pollInterval?: number;
+    onFileEvent(filePath: string, event: AssetServerWatchEvent): Promise<void>;
+    rootDir: string;
+};
+type AssetServerWatchEvent = 'add' | 'change' | 'unlink';
+export type ChokidarWatcher = ReturnType<typeof chokidar.watch>;
+export type AssetServerWatcher = {
+    close(): Promise<void>;
+    getWatchedTargets(): readonly string[];
+    updateWatchedDirectories(delta: {
+        add: readonly string[];
+        remove: readonly string[];
+    }): void;
+};
+export declare function createAssetServerWatcher(options: AssetServerWatcherOptions): AssetServerWatcher;
+export {};
+//# sourceMappingURL=watch.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"watch.d.ts","sourceRoot":"","sources":["../../src/lib/watch.ts"],"names":[],"mappings":"AAAA,OAAO,QAAQ,MAAM,UAAU,CAAA;AAI/B,KAAK,yBAAyB,GAAG;IAC/B,MAAM,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IAC1B,wBAAwB,CAAC,EAAE,CAAC,OAAO,EAAE,eAAe,KAAK,IAAI,CAAA;IAC7D,IAAI,CAAC,EAAE,OAAO,CAAA;IACd,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,qBAAqB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAC1E,OAAO,EAAE,MAAM,CAAA;CAChB,CAAA;AAED,KAAK,qBAAqB,GAAG,KAAK,GAAG,QAAQ,GAAG,QAAQ,CAAA;AACxD,MAAM,MAAM,eAAe,GAAG,UAAU,CAAC,OAAO,QAAQ,CAAC,KAAK,CAAC,CAAA;AAE/D,MAAM,MAAM,kBAAkB,GAAG;IAC/B,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;IACtB,iBAAiB,IAAI,SAAS,MAAM,EAAE,CAAA;IACtC,wBAAwB,CAAC,KAAK,EAAE;QAAE,GAAG,EAAE,SAAS,MAAM,EAAE,CAAC;QAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAA;KAAE,GAAG,IAAI,CAAA;CAC7F,CAAA;AAED,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,yBAAyB,GAAG,kBAAkB,CAmD/F"}

package/dist/lib/watch.js

@@ -0,0 +1,96 @@
+import chokidar from 'chokidar';
+import { getFilePathDirectory, normalizeFilePath } from "./paths.js";
+export function createAssetServerWatcher(options) {
+    let watcher = chokidar.watch([], {
+        ignoreInitial: true,
+        ignorePermissionErrors: true,
+        ...resolveChokidarWatchOptions(options),
+    });
+    options.onChokidarWatcherCreated?.(watcher);
+    let watchedDirectories = new Set();
+    let watchedTargets = new Set();
+    for (let event of ['add', 'change', 'unlink']) {
+        watcher.on(event, (filePath) => {
+            options.onFileEvent(filePath, event);
+        });
+    }
+    watcher.on('error', (error) => {
+        console.error('Asset server file system watcher encountered an error.', error);
+    });
+    return {
+        async close() {
+            await watcher.close();
+        },
+        getWatchedTargets() {
+            return [...watchedTargets];
+        },
+        updateWatchedDirectories(delta) {
+            let nextWatchedDirectories = new Set(watchedDirectories);
+            for (let directory of delta.add) {
+                nextWatchedDirectories.add(directory);
+            }
+            for (let directory of delta.remove) {
+                nextWatchedDirectories.delete(directory);
+            }
+            let nextTargets = getWatchTargetsForDirectories(options.rootDir, [...nextWatchedDirectories]);
+            let targetsToAdd = [...nextTargets].filter((target) => !watchedTargets.has(target));
+            let targetsToRemove = [...watchedTargets].filter((target) => !nextTargets.has(target));
+            if (targetsToRemove.length > 0) {
+                watcher.unwatch(targetsToRemove);
+            }
+            if (targetsToAdd.length > 0) {
+                watcher.add(targetsToAdd);
+            }
+            watchedDirectories = nextWatchedDirectories;
+            watchedTargets = nextTargets;
+        },
+    };
+}
+function resolveChokidarWatchOptions(options) {
+    return {
+        awaitWriteFinish: {
+            pollInterval: 10,
+            stabilityThreshold: 10,
+        },
+        depth: 0,
+        ignored: ['**/.git/**', ...(options.ignore ?? [])],
+        interval: options.pollInterval ?? 100,
+        usePolling: options.poll ?? false,
+    };
+}
+function getWatchTargetsForDirectories(rootDir, directories) {
+    let normalizedRootDir = normalizeFilePath(rootDir);
+    let targets = new Set();
+    let configAncestors = new Set();
+    for (let directory of directories) {
+        let normalizedDirectory = normalizeFilePath(directory).replace(/\/+$/, '');
+        targets.add(normalizedDirectory);
+        if (!isSameOrDescendantPath(normalizedDirectory, normalizedRootDir))
+            continue;
+        for (let ancestor of getAncestorPaths(normalizedDirectory, normalizedRootDir)) {
+            configAncestors.add(ancestor);
+        }
+    }
+    for (let ancestor of configAncestors) {
+        targets.add(ancestor);
+    }
+    return targets;
+}
+function getAncestorPaths(directoryPath, rootDir) {
+    let ancestors = [];
+    let currentDirectory = directoryPath;
+    while (isSameOrDescendantPath(currentDirectory, rootDir)) {
+        ancestors.push(currentDirectory);
+        if (currentDirectory === rootDir)
+            break;
+        let parentDirectory = getFilePathDirectory(currentDirectory);
+        if (parentDirectory === currentDirectory)
+            break;
+        currentDirectory = parentDirectory;
+    }
+    return ancestors;
+}
+function isSameOrDescendantPath(filePath, directoryPath) {
+    let normalizedDirectoryPath = directoryPath.replace(/\/+$/, '');
+    return filePath === normalizedDirectoryPath || filePath.startsWith(`${normalizedDirectoryPath}/`);
+}

package/package.json

@@ -1,21 +1,59 @@
 {
   "name": "@remix-run/assets",
-  "version": "0.0.0",
-  "description": "Placeholder package for Remix CI/OIDC setup",
-  "main": "index.js",
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
-  "keywords": [],
-  "author": "",
+  "version": "0.1.0",
+  "description": "Fetch-based server for compiling browser JS/TS assets on demand",
+  "author": "Michael Jackson <mjijackson@gmail.com>",
   "license": "MIT",
-  "type": "commonjs",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/remix-run/remix.git",
     "directory": "packages/assets"
   },
-  "publishConfig": {
-    "access": "public"
+  "homepage": "https://github.com/remix-run/remix/tree/main/packages/assets#readme",
+  "files": [
+    "LICENSE",
+    "README.md",
+    "dist",
+    "src",
+    "!src/**/*.test.ts"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/assets.d.ts",
+      "default": "./dist/assets.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "chokidar": "^5.0.0",
+    "es-module-lexer": "^2.0.0",
+    "get-tsconfig": "^4.13.6",
+    "magic-string": "^0.30.21",
+    "oxc-minify": "^0.121.0",
+    "oxc-parser": "^0.121.0",
+    "oxc-resolver": "^11.19.1",
+    "oxc-transform": "^0.121.0",
+    "source-map-js": "^1.2.1",
+    "@remix-run/headers": "0.19.0",
+    "@remix-run/route-pattern": "0.20.1"
+  },
+  "devDependencies": {
+    "@types/node": "^24.6.0",
+    "@typescript/native-preview": "7.0.0-dev.20251125.1"
+  },
+  "keywords": [
+    "remix",
+    "scripts",
+    "assets",
+    "transform",
+    "server"
+  ],
+  "scripts": {
+    "bench": "pnpm --dir ./bench run bench",
+    "build": "tsgo -p tsconfig.build.json",
+    "clean": "git clean -fdX",
+    "test": "node --disable-warning=ExperimentalWarning --test './src/**/*.test.ts'",
+    "typecheck": "tsgo --noEmit"
   }
-}
+}

package/src/assets.ts

@@ -0,0 +1,2 @@
+export { createAssetServer } from './lib/asset-server.ts'
+export type { AssetServer, AssetServerOptions } from './lib/asset-server.ts'

package/src/lib/access.ts

@@ -0,0 +1,24 @@
+import { createFileMatcher } from './file-matcher.ts'
+
+type AccessPolicy = {
+  isAllowed(filePath: string): boolean
+}
+
+export function createAccessPolicy(options: {
+  allow: readonly string[]
+  deny?: readonly string[]
+  rootDir: string
+}): AccessPolicy {
+  let allowMatchers = options.allow.map((pattern) => createFileMatcher(pattern, options.rootDir))
+  let denyMatchers = (options.deny ?? []).map((pattern) =>
+    createFileMatcher(pattern, options.rootDir),
+  )
+
+  return {
+    isAllowed(filePath) {
+      if (!allowMatchers.some((matcher) => matcher(filePath))) return false
+      if (denyMatchers.length > 0 && denyMatchers.some((matcher) => matcher(filePath))) return false
+      return true
+    },
+  }
+}