@ryanatkn/gro 0.146.2 → 0.147.0

package/dist/filer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"filer.d.ts","sourceRoot":"../src/lib/","sources":["filer.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,yBAAyB,CAAC;AAGzD,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,WAAW,CAAC;AACvC,OAAO,EACN,SAAS,EAET,KAAK,cAAc,EACnB,KAAK,iBAAiB,EAEtB,MAAM,gBAAgB,CAAC;AAQxB,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,mBAAmB,CAAC;AAIpD,MAAM,WAAW,WAAW;IAC3B,EAAE,EAAE,OAAO,CAAC;IACZ;;;OAGG;IACH,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB;;OAEG;IACH,QAAQ,EAAE,OAAO,CAAC;IAClB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,UAAU,EAAE,GAAG,CAAC,OAAO,EAAE,WAAW,CAAC,CAAC;IACtC,YAAY,EAAE,GAAG,CAAC,OAAO,EAAE,WAAW,CAAC,CAAC;CACxC;AAED,MAAM,MAAM,aAAa,GAAG,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;AAEhD,MAAM,MAAM,eAAe,GAAG,CAAC,MAAM,EAAE,cAAc,EAAE,WAAW,EAAE,WAAW,KAAK,IAAI,CAAC;AAEzF,MAAM,WAAW,aAAa;IAC7B,SAAS,CAAC,EAAE,OAAO,SAAS,CAAC;IAC7B,iBAAiB,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC,iBAAiB,EAAE,WAAW,CAAC,CAAC,CAAC;IACzE,kBAAkB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;CAClD;AAED,qBAAa,KAAK;;IACjB,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAE3B,QAAQ,CAAC,KAAK,EAAE,GAAG,CAAC,OAAO,EAAE,WAAW,CAAC,CAAa;gBAO1C,OAAO,GAAE,aAA4B;IAYjD,SAAS,OAAQ,OAAO,KAAG,WAAW,GAAG,SAAS,CAEhD;IAEF,aAAa,OAAQ,OAAO,KAAG,WAAW,CAkBxC;IAmII,KAAK,CAAC,QAAQ,EAAE,eAAe,GAAG,OAAO,CAAC,aAAa,CAAC;IAKxD,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAa5B"}
+{"version":3,"file":"filer.d.ts","sourceRoot":"../src/lib/","sources":["filer.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,yBAAyB,CAAC;AAMzD,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,WAAW,CAAC;AACvC,OAAO,EACN,SAAS,EAET,KAAK,cAAc,EACnB,KAAK,iBAAiB,EAEtB,MAAM,gBAAgB,CAAC;AAMxB,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,mBAAmB,CAAC;AAIpD,MAAM,WAAW,WAAW;IAC3B,EAAE,EAAE,OAAO,CAAC;IACZ;;;OAGG;IACH,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB;;OAEG;IACH,QAAQ,EAAE,OAAO,CAAC;IAClB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,UAAU,EAAE,GAAG,CAAC,OAAO,EAAE,WAAW,CAAC,CAAC;IACtC,YAAY,EAAE,GAAG,CAAC,OAAO,EAAE,WAAW,CAAC,CAAC;CACxC;AAED,MAAM,MAAM,aAAa,GAAG,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;AAEhD,MAAM,MAAM,eAAe,GAAG,CAAC,MAAM,EAAE,cAAc,EAAE,WAAW,EAAE,WAAW,KAAK,IAAI,CAAC;AAEzF,MAAM,WAAW,aAAa;IAC7B,SAAS,CAAC,EAAE,OAAO,SAAS,CAAC;IAC7B,iBAAiB,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC,iBAAiB,EAAE,WAAW,CAAC,CAAC,CAAC;IACzE,kBAAkB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;CAClD;AAED,qBAAa,KAAK;;IACjB,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAE3B,QAAQ,CAAC,KAAK,EAAE,GAAG,CAAC,OAAO,EAAE,WAAW,CAAC,CAAa;gBAK1C,OAAO,GAAE,aAA4B;IAWjD,SAAS,OAAQ,OAAO,KAAG,WAAW,GAAG,SAAS,CAEhD;IAEF,aAAa,OAAQ,OAAO,KAAG,WAAW,CAkBxC;IA2II,KAAK,CAAC,QAAQ,EAAE,eAAe,GAAG,OAAO,CAAC,aAAa,CAAC;IAKxD,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAa5B"}

package/dist/filer.js

@@ -2,26 +2,25 @@ import { EMPTY_OBJECT } from '@ryanatkn/belt/object.js';
 import { existsSync, readFileSync, statSync } from 'node:fs';
 import { dirname, resolve } from 'node:path';
 import { wait } from '@ryanatkn/belt/async.js';
+import { isBuiltin } from 'node:module';
+import { fileURLToPath } from 'node:url';
+import { Unreachable_Error } from '@ryanatkn/belt/error.js';
 import { watch_dir, } from './watch_dir.js';
 import { paths } from './paths.js';
 import { parse_imports } from './parse_imports.js';
 import { resolve_specifier } from './resolve_specifier.js';
 import { default_sveltekit_config } from './sveltekit_config.js';
 import { map_sveltekit_aliases } from './sveltekit_helpers.js';
-import { Unreachable_Error } from '@ryanatkn/belt/error.js';
-import { resolve_node_specifier } from './resolve_node_specifier.js';
 const aliases = Object.entries(default_sveltekit_config.alias);
 export class Filer {
     root_dir;
     files = new Map();
     #watch_dir;
     #watch_dir_options;
-    #package_json_cache;
     constructor(options = EMPTY_OBJECT) {
         this.#watch_dir = options.watch_dir ?? watch_dir;
         this.#watch_dir_options = options.watch_dir_options ?? EMPTY_OBJECT;
         this.root_dir = resolve(options.watch_dir_options?.dir ?? paths.source);
-        this.#package_json_cache = options.package_json_cache ?? {};
     }
     #watching;
     #listeners = new Set();
@@ -64,15 +63,26 @@ export class Filer {
         const dependencies_removed = new Set(dependencies_before);
         const imported = file.contents ? parse_imports(file.id, file.contents) : [];
         for (const specifier of imported) {
-            // TODO logic is duplicated from loader
             const path = map_sveltekit_aliases(specifier, aliases);
-            // The specifier `path` has now been mapped to its final form, so we can inspect it.
-            const resolved = path[0] === '.' || path[0] === '/'
-                ? resolve_specifier(path, dir)
-                : resolve_node_specifier(path, undefined, file.id, this.#package_json_cache, false);
-            if (!resolved)
-                continue; // ignore any missing imports like Node identifiers
-            const { path_id } = resolved;
+            let path_id;
+            if (path[0] === '.' || path[0] === '/') {
+                const resolved = resolve_specifier(path, dir);
+                path_id = resolved.path_id;
+            }
+            else {
+                if (isBuiltin(path))
+                    continue;
+                try {
+                    path_id = fileURLToPath(import.meta.resolve(path, file.id));
+                }
+                catch (error) {
+                    // If it's imported from an external module, ignore any import errors.
+                    if (error.code === 'ERR_MODULE_NOT_FOUND' && file.external) {
+                        continue;
+                    }
+                    throw error;
+                }
+            }
             dependencies_removed.delete(path_id);
             if (!dependencies_before.has(path_id)) {
                 const d = this.get_or_create(path_id);

package/dist/loader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"loader.d.ts","sourceRoot":"../src/lib/","sources":["loader.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,QAAQ,EAAE,WAAW,EAAC,MAAM,aAAa,CAAC;AAgFvD,eAAO,MAAM,IAAI,EAAE,QAwFlB,CAAC;AAEF,eAAO,MAAM,OAAO,EAAE,WA6DrB,CAAC"}
+{"version":3,"file":"loader.d.ts","sourceRoot":"../src/lib/","sources":["loader.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,QAAQ,EAAE,WAAW,EAAC,MAAM,aAAa,CAAC;AA4EvD,eAAO,MAAM,IAAI,EAAE,QAwFlB,CAAC;AAEF,eAAO,MAAM,OAAO,EAAE,WAoDrB,CAAC"}

package/dist/loader.js

@@ -12,7 +12,6 @@ import { IS_THIS_GRO, paths } from './paths.js';
 import { JSON_MATCHER, NODE_MODULES_DIRNAME, TS_MATCHER } from './constants.js';
 import { to_define_import_meta_env, default_ts_transform_options } from './esbuild_helpers.js';
 import { resolve_specifier } from './resolve_specifier.js';
-import { resolve_node_specifier } from './resolve_node_specifier.js';
 import { map_sveltekit_aliases } from './sveltekit_helpers.js';
 /*
 
@@ -52,7 +51,6 @@ const aliases = Object.entries(alias);
 const RAW_MATCHER = /(%3Fraw|\.css|\.svg)$/; // TODO others? configurable?
 const ENV_MATCHER = /src\/lib\/\$env\/(static|dynamic)\/(public|private)$/;
 const NODE_MODULES_MATCHER = new RegExp(escape_regexp('/' + NODE_MODULES_DIRNAME + '/'), 'u');
-const package_json_cache = {};
 export const load = async (url, context, nextLoad) => {
     if (SVELTEKIT_SHIM_APP_PATHS_MATCHER.test(url)) {
         // SvelteKit `$app/paths` shim
@@ -162,20 +160,9 @@ export const resolve = async (specifier, context, nextResolve) => {
     }
     s = map_sveltekit_aliases(s, aliases);
     // The specifier has now been mapped to its final form, so we can inspect it.
+    // Imports into `node_modules` use the default algorithm, and the rest use use Vite conventions.
     if (s[0] !== '.' && s[0] !== '/') {
-        // Resolve to `node_modules`.
-        if (SVELTE_MATCHER.test(s) || JSON_MATCHER.test(s)) {
-            // Match the behavior of Vite and esbuild for Svelte and JSON imports.
-            const resolved = resolve_node_specifier(s, dir, parent_url, package_json_cache); // `node:` specifiers shouldn't reach this point, so the assertion is safe
-            return {
-                url: pathToFileURL(resolved.path_id_with_querystring).href,
-                format: 'module',
-                shortCircuit: true,
-            };
-        }
-        else {
-            return nextResolve(s, context);
-        }
+        return nextResolve(s, context);
     }
     const resolved = resolve_specifier(s, dirname(fileURLToPath(parent_url)));
     return {

package/dist/package.d.ts

@@ -333,10 +333,6 @@ export declare const package_json: {
             types: string;
             default: string;
         };
-        './resolve_node_specifier.js': {
-            types: string;
-            default: string;
-        };
         './resolve_specifier.js': {
             types: string;
             default: string;
@@ -965,13 +961,6 @@ export declare const src_json: {
                 kind: "variable";
             }[];
         };
-        './resolve_node_specifier.js': {
-            path: string;
-            declarations: {
-                name: string;
-                kind: "function";
-            }[];
-        };
         './resolve_specifier.js': {
             path: string;
             declarations: ({

package/dist/package.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"package.d.ts","sourceRoot":"../src/lib/","sources":["package.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuQD,CAAC;AAEzB,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0wBD,CAAC"}
+{"version":3,"file":"package.d.ts","sourceRoot":"../src/lib/","sources":["package.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmQD,CAAC;AAEzB,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAswBD,CAAC"}

package/dist/package.js

@@ -1,7 +1,7 @@
 // generated by src/lib/package.gen.ts
 export const package_json = {
     name: '@ryanatkn/gro',
-    version: '0.146.2',
+    version: '0.147.0',
     description: 'task runner and toolkit extending SvelteKit',
     motto: 'generate, run, optimize',
     glyph: '🌰',
@@ -196,10 +196,6 @@ export const package_json = {
             default: './dist/reinstall.task.js',
         },
         './release.task.js': { types: './dist/release.task.d.ts', default: './dist/release.task.js' },
-        './resolve_node_specifier.js': {
-            types: './dist/resolve_node_specifier.d.ts',
-            default: './dist/resolve_node_specifier.js',
-        },
         './resolve_specifier.js': {
             types: './dist/resolve_specifier.d.ts',
             default: './dist/resolve_specifier.js',
@@ -264,7 +260,7 @@ export const package_json = {
 };
 export const src_json = {
     name: '@ryanatkn/gro',
-    version: '0.146.2',
+    version: '0.147.0',
     modules: {
         '.': {
             path: 'index.ts',
@@ -810,10 +806,6 @@ export const src_json = {
                 { name: 'task', kind: 'variable' },
             ],
         },
-        './resolve_node_specifier.js': {
-            path: 'resolve_node_specifier.ts',
-            declarations: [{ name: 'resolve_node_specifier', kind: 'function' }],
-        },
         './resolve_specifier.js': {
             path: 'resolve_specifier.ts',
             declarations: [

package/dist/sveltekit_shim_app_forms.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sveltekit_shim_app_forms.d.ts","sourceRoot":"../src/lib/","sources":["sveltekit_shim_app_forms.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACX,WAAW,IAAI,gBAAgB,EAC/B,WAAW,IAAI,gBAAgB,EAC/B,OAAO,IAAI,YAAY,EACvB,MAAM,YAAY,CAAC;AAMpB,eAAO,MAAM,WAAW,EAAE,OAAO,gBAA6B,CAAC;AAC/D,eAAO,MAAM,WAAW,EAAE,OAAO,gBAMhC,CAAC;AACF,eAAO,MAAM,OAAO,EAAE,OAAO,YAAsC,CAAC"}
+{"version":3,"file":"sveltekit_shim_app_forms.d.ts","sourceRoot":"../src/lib/","sources":["sveltekit_shim_app_forms.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACX,WAAW,IAAI,gBAAgB,EAC/B,WAAW,IAAI,gBAAgB,EAC/B,OAAO,IAAI,YAAY,EACvB,MAAM,YAAY,CAAC;AAGpB,eAAO,MAAM,WAAW,EAAE,OAAO,gBAA6B,CAAC;AAC/D,eAAO,MAAM,WAAW,EAAE,OAAO,gBAAoC,CAAC;AACtE,eAAO,MAAM,OAAO,EAAE,OAAO,YAAsC,CAAC"}

package/dist/sveltekit_shim_app_forms.js

@@ -1,15 +1,6 @@
 // shim for $app/forms
 // @see https://github.com/sveltejs/kit/issues/1485
 import { noop, noop_async } from '@ryanatkn/belt/function.js';
-// TODO better way todo this?
-// @ts-expect-error
-import * as devalue from 'devalue';
 export const applyAction = noop_async;
-export const deserialize = (result) => {
-    const parsed = JSON.parse(result);
-    if (parsed.data) {
-        parsed.data = devalue.parse(parsed.data);
-    }
-    return parsed;
-};
+export const deserialize = () => ({});
 export const enhance = () => ({ destroy: noop });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ryanatkn/gro",
-  "version": "0.146.2",
+  "version": "0.147.0",
   "description": "task runner and toolkit extending SvelteKit",
   "motto": "generate, run, optimize",
   "glyph": "🌰",
@@ -354,10 +354,6 @@
       "types": "./dist/release.task.d.ts",
       "default": "./dist/release.task.js"
     },
-    "./resolve_node_specifier.js": {
-      "types": "./dist/resolve_node_specifier.d.ts",
-      "default": "./dist/resolve_node_specifier.js"
-    },
     "./resolve_specifier.js": {
       "types": "./dist/resolve_specifier.d.ts",
       "default": "./dist/resolve_specifier.js"

package/src/lib/filer.ts

@@ -3,6 +3,9 @@ import {existsSync, readFileSync, statSync} from 'node:fs';
 import {dirname, resolve} from 'node:path';
 import type {Omit_Strict} from '@ryanatkn/belt/types.js';
 import {wait} from '@ryanatkn/belt/async.js';
+import {isBuiltin} from 'node:module';
+import {fileURLToPath} from 'node:url';
+import {Unreachable_Error} from '@ryanatkn/belt/error.js';
 
 import type {Path_Id} from './path.js';
 import {
@@ -17,8 +20,6 @@ import {parse_imports} from './parse_imports.js';
 import {resolve_specifier} from './resolve_specifier.js';
 import {default_sveltekit_config} from './sveltekit_config.js';
 import {map_sveltekit_aliases} from './sveltekit_helpers.js';
-import {Unreachable_Error} from '@ryanatkn/belt/error.js';
-import {resolve_node_specifier} from './resolve_node_specifier.js';
 import type {Package_Json} from './package_json.js';
 
 const aliases = Object.entries(default_sveltekit_config.alias);
@@ -58,13 +59,10 @@ export class Filer {
 	#watch_dir: typeof watch_dir;
 	#watch_dir_options: Partial<Watch_Dir_Options>;
 
-	#package_json_cache: Record<string, Package_Json>;
-
 	constructor(options: Filer_Options = EMPTY_OBJECT) {
 		this.#watch_dir = options.watch_dir ?? watch_dir;
 		this.#watch_dir_options = options.watch_dir_options ?? EMPTY_OBJECT;
 		this.root_dir = resolve(options.watch_dir_options?.dir ?? paths.source);
-		this.#package_json_cache = options.package_json_cache ?? {};
 	}
 
 	#watching: Watch_Node_Fs | undefined;
@@ -118,16 +116,24 @@ export class Filer {
 
 		const imported = file.contents ? parse_imports(file.id, file.contents) : [];
 		for (const specifier of imported) {
-			// TODO logic is duplicated from loader
 			const path = map_sveltekit_aliases(specifier, aliases);
 
-			// The specifier `path` has now been mapped to its final form, so we can inspect it.
-			const resolved =
-				path[0] === '.' || path[0] === '/'
-					? resolve_specifier(path, dir)
-					: resolve_node_specifier(path, undefined, file.id, this.#package_json_cache, false);
-			if (!resolved) continue; // ignore any missing imports like Node identifiers
-			const {path_id} = resolved;
+			let path_id;
+			if (path[0] === '.' || path[0] === '/') {
+				const resolved = resolve_specifier(path, dir);
+				path_id = resolved.path_id;
+			} else {
+				if (isBuiltin(path)) continue;
+				try {
+					path_id = fileURLToPath(import.meta.resolve(path, file.id));
+				} catch (error) {
+					// If it's imported from an external module, ignore any import errors.
+					if (error.code === 'ERR_MODULE_NOT_FOUND' && file.external) {
+						continue;
+					}
+					throw error;
+				}
+			}
 			dependencies_removed.delete(path_id);
 			if (!dependencies_before.has(path_id)) {
 				const d = this.get_or_create(path_id);

package/src/lib/loader.ts

@@ -20,8 +20,6 @@ import {IS_THIS_GRO, paths} from './paths.js';
 import {JSON_MATCHER, NODE_MODULES_DIRNAME, TS_MATCHER} from './constants.js';
 import {to_define_import_meta_env, default_ts_transform_options} from './esbuild_helpers.js';
 import {resolve_specifier} from './resolve_specifier.js';
-import {resolve_node_specifier} from './resolve_node_specifier.js';
-import type {Package_Json} from './package_json.js';
 import {map_sveltekit_aliases} from './sveltekit_helpers.js';
 
 /*
@@ -80,8 +78,6 @@ const RAW_MATCHER = /(%3Fraw|\.css|\.svg)$/; // TODO others? configurable?
 const ENV_MATCHER = /src\/lib\/\$env\/(static|dynamic)\/(public|private)$/;
 const NODE_MODULES_MATCHER = new RegExp(escape_regexp('/' + NODE_MODULES_DIRNAME + '/'), 'u');
 
-const package_json_cache: Record<string, Package_Json> = {};
-
 export const load: LoadHook = async (url, context, nextLoad) => {
 	if (SVELTEKIT_SHIM_APP_PATHS_MATCHER.test(url)) {
 		// SvelteKit `$app/paths` shim
@@ -211,19 +207,10 @@ export const resolve: ResolveHook = async (specifier, context, nextResolve) => {
 	s = map_sveltekit_aliases(s, aliases);
 
 	// The specifier has now been mapped to its final form, so we can inspect it.
+
+	// Imports into `node_modules` use the default algorithm, and the rest use use Vite conventions.
 	if (s[0] !== '.' && s[0] !== '/') {
-		// Resolve to `node_modules`.
-		if (SVELTE_MATCHER.test(s) || JSON_MATCHER.test(s)) {
-			// Match the behavior of Vite and esbuild for Svelte and JSON imports.
-			const resolved = resolve_node_specifier(s, dir, parent_url, package_json_cache)!; // `node:` specifiers shouldn't reach this point, so the assertion is safe
-			return {
-				url: pathToFileURL(resolved.path_id_with_querystring).href,
-				format: 'module',
-				shortCircuit: true,
-			};
-		} else {
-			return nextResolve(s, context);
-		}
+		return nextResolve(s, context);
 	}
 
 	const resolved = resolve_specifier(s, dirname(fileURLToPath(parent_url)));

package/src/lib/package.ts

@@ -5,7 +5,7 @@ import type {Src_Json} from './src_json.js';
 
 export const package_json = {
 	name: '@ryanatkn/gro',
-	version: '0.146.2',
+	version: '0.147.0',
 	description: 'task runner and toolkit extending SvelteKit',
 	motto: 'generate, run, optimize',
 	glyph: '🌰',
@@ -201,10 +201,6 @@ export const package_json = {
 			default: './dist/reinstall.task.js',
 		},
 		'./release.task.js': {types: './dist/release.task.d.ts', default: './dist/release.task.js'},
-		'./resolve_node_specifier.js': {
-			types: './dist/resolve_node_specifier.d.ts',
-			default: './dist/resolve_node_specifier.js',
-		},
 		'./resolve_specifier.js': {
 			types: './dist/resolve_specifier.d.ts',
 			default: './dist/resolve_specifier.js',
@@ -270,7 +266,7 @@ export const package_json = {
 
 export const src_json = {
 	name: '@ryanatkn/gro',
-	version: '0.146.2',
+	version: '0.147.0',
 	modules: {
 		'.': {
 			path: 'index.ts',
@@ -816,10 +812,6 @@ export const src_json = {
 				{name: 'task', kind: 'variable'},
 			],
 		},
-		'./resolve_node_specifier.js': {
-			path: 'resolve_node_specifier.ts',
-			declarations: [{name: 'resolve_node_specifier', kind: 'function'}],
-		},
 		'./resolve_specifier.js': {
 			path: 'resolve_specifier.ts',
 			declarations: [

package/src/lib/sveltekit_shim_app_forms.ts

@@ -7,16 +7,7 @@ import type {
 	enhance as base_enhance,
 } from '$app/forms';
 import {noop, noop_async} from '@ryanatkn/belt/function.js';
-// TODO better way todo this?
-// @ts-expect-error
-import * as devalue from 'devalue';
 
 export const applyAction: typeof base_applyAction = noop_async;
-export const deserialize: typeof base_deserialize = (result) => {
-	const parsed = JSON.parse(result);
-	if (parsed.data) {
-		parsed.data = devalue.parse(parsed.data);
-	}
-	return parsed;
-};
+export const deserialize: typeof base_deserialize = () => ({}) as any;
 export const enhance: typeof base_enhance = () => ({destroy: noop});

package/dist/resolve_node_specifier.d.ts

@@ -1,9 +0,0 @@
-import { Package_Json } from './package_json.js';
-import type { Resolved_Specifier } from './resolve_specifier.js';
-/**
- * Ideally Gro would just use `import.meta.resolve`, but it can't be used in custom loaders,
- * which Gro relies on for TypeScript.
- * This likely has differences from Node - they should be fixed on a case-by-case basis.
- */
-export declare const resolve_node_specifier: (specifier: string, dir?: string, parent_path?: string, package_json_cache?: Record<string, Package_Json>, throw_on_missing_package?: boolean, exports_conditions?: string[]) => Resolved_Specifier | null;
-//# sourceMappingURL=resolve_node_specifier.d.ts.map

package/dist/resolve_node_specifier.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"resolve_node_specifier.d.ts","sourceRoot":"../src/lib/","sources":["resolve_node_specifier.ts"],"names":[],"mappings":"AAKA,OAAO,EAAe,YAAY,EAAoB,MAAM,mBAAmB,CAAC;AAGhF,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,wBAAwB,CAAC;AAE/D;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,cACvB,MAAM,8BAEH,MAAM,uBACC,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,wEAG/C,kBAAkB,GAAG,IAsFvB,CAAC"}

package/dist/resolve_node_specifier.js

@@ -1,306 +0,0 @@
-import { join, extname } from 'node:path';
-import { existsSync } from 'node:fs';
-import { DEV } from 'esm-env';
-import { escape_regexp } from '@ryanatkn/belt/regexp.js';
-import { Export_Value, Package_Json, load_package_json } from './package_json.js';
-import { paths } from './paths.js';
-import { NODE_MODULES_DIRNAME } from './constants.js';
-/**
- * Ideally Gro would just use `import.meta.resolve`, but it can't be used in custom loaders,
- * which Gro relies on for TypeScript.
- * This likely has differences from Node - they should be fixed on a case-by-case basis.
- */
-export const resolve_node_specifier = (specifier, dir = paths.root, parent_path, package_json_cache, throw_on_missing_package = true, exports_conditions = DEV ? ['development', 'node', 'import'] : ['production', 'node', 'import']) => {
-    const raw = specifier.endsWith('?raw');
-    const mapped_specifier = raw ? specifier.substring(0, specifier.length - 4) : specifier;
-    const specifier_slash_path_index = get_specifier_slash_path_index(mapped_specifier);
-    const pkg_name = specifier_slash_path_index === -1
-        ? mapped_specifier
-        : mapped_specifier.substring(0, specifier_slash_path_index);
-    const module_path = specifier_slash_path_index === -1
-        ? ''
-        : mapped_specifier.substring(specifier_slash_path_index + 1);
-    const subpath = module_path ? './' + module_path : '.';
-    const package_dir = join(dir, NODE_MODULES_DIRNAME, pkg_name);
-    // Check package_json cache first
-    let package_json;
-    if (package_json_cache?.[pkg_name]) {
-        package_json = package_json_cache[pkg_name];
-    }
-    else if (!existsSync(package_dir)) {
-        if (throw_on_missing_package) {
-            throw Error(`Package not found at ${package_dir} for specifier ${specifier}, you may need to install packages or fix the path` +
-                (parent_path ? ` imported from ${parent_path}` : ''));
-        }
-        else {
-            return null;
-        }
-    }
-    else {
-        package_json = load_package_json(package_dir, package_json_cache, false);
-    }
-    // Handle self-referencing
-    if (parent_path?.startsWith(package_dir)) {
-        if (!package_json.exports) {
-            throw Error(`Self-referencing is only available if package.json has "exports" field: ${specifier}` +
-                (parent_path ? ` imported from ${parent_path}` : ''));
-        }
-    }
-    const exported = resolve_subpath(package_json, subpath);
-    if (typeof exported === 'string') {
-        const validated = validate_export_target(exported, throw_on_missing_package);
-        if (validated === null) {
-            return null;
-        }
-    }
-    if (!exported) {
-        if (throw_on_missing_package) {
-            throw Error(`[ERR_PACKAGE_PATH_NOT_EXPORTED]: Package subpath '${subpath}' is not defined by 'exports' in ${package_dir}/package.json` +
-                (parent_path ? ` imported from ${parent_path}` : ''));
-        }
-        else {
-            return null;
-        }
-    }
-    const exported_value = resolve_exported_value(exported, exports_conditions);
-    if (exported_value === undefined) {
-        if (throw_on_missing_package) {
-            throw Error(`No valid export found for subpath '${subpath}' in ${package_dir}/package.json with the following conditions: ${exports_conditions.join(', ')}` +
-                (parent_path ? ` imported from ${parent_path}` : ''));
-        }
-        else {
-            return null;
-        }
-    }
-    const path_id = normalize_extension(join(package_dir, exported_value));
-    return {
-        path_id,
-        path_id_with_querystring: raw ? path_id + '?raw' : path_id,
-        raw,
-        specifier,
-        mapped_specifier,
-        namespace: undefined,
-    };
-};
-const replace_wildcards = (pattern, wildcards) => {
-    if (!pattern.includes('*'))
-        return pattern;
-    let result = pattern;
-    let wildcard_index = 0;
-    while (result.includes('*') && wildcard_index < wildcards.length) {
-        result = result.replace('*', wildcards[wildcard_index++]);
-    }
-    return result;
-};
-const resolve_subpath = (package_json, subpath) => {
-    // If no exports field exists, fallback to main field for the root subpath
-    if (!package_json.exports) {
-        return subpath === '.' && package_json.main ? package_json.main : null;
-    }
-    const exports = package_json.exports;
-    // Handle exports sugar syntax
-    if (typeof exports === 'string') {
-        return subpath === '.' ? exports : null;
-    }
-    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-    if (typeof exports === 'object' && exports !== null) {
-        // Check for exact match first
-        if (subpath in exports) {
-            return exports[subpath];
-        }
-        // TODO some of this may be wrong, will just need to patch as we go
-        // Sort patterns by specificity
-        const patterns = Object.entries(exports)
-            .filter(([pattern]) => pattern.includes('*'))
-            .map(([pattern, target]) => ({
-            pattern,
-            target,
-            static_prefix: pattern.split('*')[0],
-            segments: pattern.split('/').length,
-            wildcards: (pattern.match(/\*/g) ?? []).length,
-        }))
-            .sort((a, b) => {
-            // Sort by static prefix length first
-            const prefix_diff = b.static_prefix.length - a.static_prefix.length;
-            if (prefix_diff !== 0)
-                return prefix_diff;
-            // Then by number of segments
-            const segment_diff = b.segments - a.segments;
-            if (segment_diff !== 0)
-                return segment_diff;
-            // Then by number of wildcards (fewer is more specific)
-            const wildcard_diff = a.wildcards - b.wildcards;
-            if (wildcard_diff !== 0)
-                return wildcard_diff;
-            // Finally by total pattern length
-            return b.pattern.length - a.pattern.length;
-        });
-        // Track matched wildcards for later use
-        let matched_wildcards = [];
-        // Check patterns in order of specificity
-        for (const { pattern, target } of patterns) {
-            // Convert pattern to regex, handling path segments properly
-            const regex_pattern = pattern.split('*').map(escape_regexp).join('([^/]+)');
-            const regex = new RegExp(`^${regex_pattern}$`);
-            const match = subpath.match(regex);
-            if (match) {
-                // If this is a null pattern and it matches, block access
-                if (target === null)
-                    return null;
-                // Extract captured wildcards and store them
-                matched_wildcards = match.slice(1);
-                if (typeof target === 'string') {
-                    return replace_wildcards(target, matched_wildcards);
-                }
-                if (typeof target === 'object' && target !== null) {
-                    // For conditional exports, return an object with resolved wildcards
-                    return Object.fromEntries(Object.entries(target).map(([key, value]) => {
-                        if (typeof value === 'string') {
-                            return [key, replace_wildcards(value, matched_wildcards)];
-                        }
-                        // Handle nested conditions
-                        if (typeof value === 'object' && value !== null) {
-                            return [
-                                key,
-                                Object.fromEntries(Object.entries(value).map(([nested_key, nested_value]) => [
-                                    nested_key,
-                                    typeof nested_value === 'string'
-                                        ? replace_wildcards(nested_value, matched_wildcards)
-                                        : nested_value,
-                                ])),
-                            ];
-                        }
-                        return [key, value];
-                    }));
-                }
-            }
-        }
-        // Handle catch-all patterns for remaining cases
-        const catch_all_patterns = patterns.filter(({ pattern }) => pattern.endsWith('/*') || pattern === './*');
-        for (const { pattern, target } of catch_all_patterns) {
-            const base_pattern = pattern.slice(0, -1); // Remove trailing '*'
-            if (subpath.startsWith(base_pattern)) {
-                if (target === null)
-                    return null;
-                const remainder = subpath.slice(base_pattern.length);
-                if (typeof target === 'string') {
-                    return target.slice(0, -1) + remainder;
-                }
-            }
-        }
-    }
-    return null;
-};
-const resolve_exported_value = (exported, conditions) => {
-    if (typeof exported === 'string') {
-        return exported;
-    }
-    if (typeof exported !== 'object' || exported === null) {
-        return undefined;
-    }
-    const exported_obj = exported;
-    let default_value; // eslint-disable-line @typescript-eslint/no-redundant-type-constituents
-    // For each key in exported_obj, in order
-    for (const [condition, value] of Object.entries(exported_obj)) {
-        // Skip invalid conditions
-        if (!is_valid_condition(condition)) {
-            continue;
-        }
-        if (condition === 'default') {
-            // Store default value to try last
-            default_value = value;
-        }
-        else if (conditions.includes(condition)) {
-            const resolved = resolve_exported_value(value, conditions);
-            if (resolved !== undefined) {
-                return resolved;
-            }
-        }
-    }
-    // If no conditions matched, try default
-    if (default_value !== undefined) {
-        const resolved = resolve_exported_value(default_value, conditions);
-        if (resolved !== undefined) {
-            return resolved;
-        }
-    }
-    return undefined;
-};
-const is_valid_condition = (condition) => {
-    if (condition.length === 0 ||
-        condition.startsWith('.') ||
-        condition.includes(',') ||
-        /^\d+$/.test(condition)) {
-        return false;
-    }
-    return /^[a-zA-Z0-9:_\-=]+$/.test(condition);
-};
-const normalize_extension = (path) => {
-    if (path.endsWith('.d.ts')) {
-        return path.slice(0, -5) + '.js';
-    }
-    // No extension handling needed if path already has an extension
-    if (extname(path)) {
-        return path;
-    }
-    // If no extension at all, add .js
-    return path + '.js';
-};
-const validate_export_target = (target, throw_on_missing_package) => {
-    // Must start with './'
-    if (!target.startsWith('./') && !target.startsWith('../')) {
-        if (throw_on_missing_package) {
-            throw new Error('ERR_INVALID_PACKAGE_TARGET: Export target must start with "./" or "../"');
-        }
-        else {
-            return null;
-        }
-    }
-    // Can't contain node_modules
-    if (target.includes('node_modules')) {
-        if (throw_on_missing_package) {
-            throw new Error('ERR_INVALID_PACKAGE_TARGET: Export target cannot contain node_modules');
-        }
-        else {
-            return null;
-        }
-    }
-    // Check for package boundary escape
-    const parts = target.split('/');
-    let depth = 0;
-    for (const part of parts) {
-        if (part === '..') {
-            depth--;
-            // If we go above root, it's escaping the package boundary
-            if (depth < 0) {
-                if (throw_on_missing_package) {
-                    throw new Error('ERR_INVALID_PACKAGE_TARGET: Export target cannot escape package boundary');
-                }
-                else {
-                    return null;
-                }
-            }
-        }
-        else if (part !== '.' && part !== '') {
-            depth++;
-        }
-    }
-};
-const get_specifier_slash_path_index = (mapped_specifier) => {
-    let index = -1;
-    if (mapped_specifier[0] === '@') {
-        let count = 0;
-        for (let i = 0; i < mapped_specifier.length; i++) {
-            if (mapped_specifier[i] === '/')
-                count++;
-            if (count === 2) {
-                index = i;
-                break;
-            }
-        }
-    }
-    else {
-        index = mapped_specifier.indexOf('/');
-    }
-    return index;
-};

package/src/lib/resolve_node_specifier.ts

@@ -1,369 +0,0 @@
-import {join, extname} from 'node:path';
-import {existsSync} from 'node:fs';
-import {DEV} from 'esm-env';
-import {escape_regexp} from '@ryanatkn/belt/regexp.js';
-
-import {Export_Value, Package_Json, load_package_json} from './package_json.js';
-import {paths} from './paths.js';
-import {NODE_MODULES_DIRNAME} from './constants.js';
-import type {Resolved_Specifier} from './resolve_specifier.js';
-
-/**
- * Ideally Gro would just use `import.meta.resolve`, but it can't be used in custom loaders,
- * which Gro relies on for TypeScript.
- * This likely has differences from Node - they should be fixed on a case-by-case basis.
- */
-export const resolve_node_specifier = (
-	specifier: string,
-	dir = paths.root,
-	parent_path?: string,
-	package_json_cache?: Record<string, Package_Json>,
-	throw_on_missing_package = true,
-	exports_conditions = DEV ? ['development', 'node', 'import'] : ['production', 'node', 'import'],
-): Resolved_Specifier | null => {
-	const raw = specifier.endsWith('?raw');
-	const mapped_specifier = raw ? specifier.substring(0, specifier.length - 4) : specifier;
-
-	const specifier_slash_path_index = get_specifier_slash_path_index(mapped_specifier);
-
-	const pkg_name =
-		specifier_slash_path_index === -1
-			? mapped_specifier
-			: mapped_specifier.substring(0, specifier_slash_path_index);
-	const module_path =
-		specifier_slash_path_index === -1
-			? ''
-			: mapped_specifier.substring(specifier_slash_path_index + 1);
-	const subpath = module_path ? './' + module_path : '.';
-	const package_dir = join(dir, NODE_MODULES_DIRNAME, pkg_name);
-
-	// Check package_json cache first
-	let package_json: Package_Json | undefined;
-	if (package_json_cache?.[pkg_name]) {
-		package_json = package_json_cache[pkg_name];
-	} else if (!existsSync(package_dir)) {
-		if (throw_on_missing_package) {
-			throw Error(
-				`Package not found at ${package_dir} for specifier ${specifier}, you may need to install packages or fix the path` +
-					(parent_path ? ` imported from ${parent_path}` : ''),
-			);
-		} else {
-			return null;
-		}
-	} else {
-		package_json = load_package_json(package_dir, package_json_cache, false);
-	}
-
-	// Handle self-referencing
-	if (parent_path?.startsWith(package_dir)) {
-		if (!package_json.exports) {
-			throw Error(
-				`Self-referencing is only available if package.json has "exports" field: ${specifier}` +
-					(parent_path ? ` imported from ${parent_path}` : ''),
-			);
-		}
-	}
-
-	const exported = resolve_subpath(package_json, subpath);
-
-	if (typeof exported === 'string') {
-		const validated = validate_export_target(exported, throw_on_missing_package);
-		if (validated === null) {
-			return null;
-		}
-	}
-
-	if (!exported) {
-		if (throw_on_missing_package) {
-			throw Error(
-				`[ERR_PACKAGE_PATH_NOT_EXPORTED]: Package subpath '${subpath}' is not defined by 'exports' in ${package_dir}/package.json` +
-					(parent_path ? ` imported from ${parent_path}` : ''),
-			);
-		} else {
-			return null;
-		}
-	}
-
-	const exported_value = resolve_exported_value(exported, exports_conditions);
-	if (exported_value === undefined) {
-		if (throw_on_missing_package) {
-			throw Error(
-				`No valid export found for subpath '${subpath}' in ${package_dir}/package.json with the following conditions: ${exports_conditions.join(', ')}` +
-					(parent_path ? ` imported from ${parent_path}` : ''),
-			);
-		} else {
-			return null;
-		}
-	}
-
-	const path_id = normalize_extension(join(package_dir, exported_value));
-
-	return {
-		path_id,
-		path_id_with_querystring: raw ? path_id + '?raw' : path_id,
-		raw,
-		specifier,
-		mapped_specifier,
-		namespace: undefined,
-	};
-};
-
-const replace_wildcards = (pattern: string, wildcards: string[]): string => {
-	if (!pattern.includes('*')) return pattern;
-
-	let result = pattern;
-	let wildcard_index = 0;
-	while (result.includes('*') && wildcard_index < wildcards.length) {
-		result = result.replace('*', wildcards[wildcard_index++]);
-	}
-	return result;
-};
-
-const resolve_subpath = (package_json: Package_Json, subpath: string): unknown => {
-	// If no exports field exists, fallback to main field for the root subpath
-	if (!package_json.exports) {
-		return subpath === '.' && package_json.main ? package_json.main : null;
-	}
-
-	const exports = package_json.exports;
-
-	// Handle exports sugar syntax
-	if (typeof exports === 'string') {
-		return subpath === '.' ? exports : null;
-	}
-
-	// eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-	if (typeof exports === 'object' && exports !== null) {
-		// Check for exact match first
-		if (subpath in exports) {
-			return exports[subpath];
-		}
-
-		// TODO some of this may be wrong, will just need to patch as we go
-		// Sort patterns by specificity
-		const patterns = Object.entries(exports)
-			.filter(([pattern]) => pattern.includes('*'))
-			.map(([pattern, target]) => ({
-				pattern,
-				target,
-				static_prefix: pattern.split('*')[0],
-				segments: pattern.split('/').length,
-				wildcards: (pattern.match(/\*/g) ?? []).length,
-			}))
-			.sort((a, b) => {
-				// Sort by static prefix length first
-				const prefix_diff = b.static_prefix.length - a.static_prefix.length;
-				if (prefix_diff !== 0) return prefix_diff;
-
-				// Then by number of segments
-				const segment_diff = b.segments - a.segments;
-				if (segment_diff !== 0) return segment_diff;
-
-				// Then by number of wildcards (fewer is more specific)
-				const wildcard_diff = a.wildcards - b.wildcards;
-				if (wildcard_diff !== 0) return wildcard_diff;
-
-				// Finally by total pattern length
-				return b.pattern.length - a.pattern.length;
-			});
-
-		// Track matched wildcards for later use
-		let matched_wildcards: string[] = [];
-
-		// Check patterns in order of specificity
-		for (const {pattern, target} of patterns) {
-			// Convert pattern to regex, handling path segments properly
-			const regex_pattern = pattern.split('*').map(escape_regexp).join('([^/]+)');
-			const regex = new RegExp(`^${regex_pattern}$`);
-			const match = subpath.match(regex);
-
-			if (match) {
-				// If this is a null pattern and it matches, block access
-				if (target === null) return null;
-
-				// Extract captured wildcards and store them
-				matched_wildcards = match.slice(1);
-
-				if (typeof target === 'string') {
-					return replace_wildcards(target, matched_wildcards);
-				}
-
-				if (typeof target === 'object' && target !== null) {
-					// For conditional exports, return an object with resolved wildcards
-					return Object.fromEntries(
-						Object.entries(target).map(([key, value]) => {
-							if (typeof value === 'string') {
-								return [key, replace_wildcards(value, matched_wildcards)];
-							}
-							// Handle nested conditions
-							if (typeof value === 'object' && value !== null) {
-								return [
-									key,
-									Object.fromEntries(
-										Object.entries(value).map(([nested_key, nested_value]) => [
-											nested_key,
-											typeof nested_value === 'string'
-												? replace_wildcards(nested_value, matched_wildcards)
-												: nested_value,
-										]),
-									),
-								];
-							}
-							return [key, value];
-						}),
-					);
-				}
-			}
-		}
-
-		// Handle catch-all patterns for remaining cases
-		const catch_all_patterns = patterns.filter(
-			({pattern}) => pattern.endsWith('/*') || pattern === './*',
-		);
-
-		for (const {pattern, target} of catch_all_patterns) {
-			const base_pattern = pattern.slice(0, -1); // Remove trailing '*'
-			if (subpath.startsWith(base_pattern)) {
-				if (target === null) return null;
-
-				const remainder = subpath.slice(base_pattern.length);
-				if (typeof target === 'string') {
-					return target.slice(0, -1) + remainder;
-				}
-			}
-		}
-	}
-
-	return null;
-};
-
-const resolve_exported_value = (
-	exported: Export_Value,
-	conditions: string[],
-): string | undefined => {
-	if (typeof exported === 'string') {
-		return exported;
-	}
-
-	if (typeof exported !== 'object' || exported === null) {
-		return undefined;
-	}
-
-	const exported_obj = exported as Record<string, unknown>;
-
-	let default_value: Export_Value | undefined; // eslint-disable-line @typescript-eslint/no-redundant-type-constituents
-
-	// For each key in exported_obj, in order
-	for (const [condition, value] of Object.entries(exported_obj)) {
-		// Skip invalid conditions
-		if (!is_valid_condition(condition)) {
-			continue;
-		}
-
-		if (condition === 'default') {
-			// Store default value to try last
-			default_value = value;
-		} else if (conditions.includes(condition)) {
-			const resolved = resolve_exported_value(value, conditions);
-			if (resolved !== undefined) {
-				return resolved;
-			}
-		}
-	}
-
-	// If no conditions matched, try default
-	if (default_value !== undefined) {
-		const resolved = resolve_exported_value(default_value, conditions);
-		if (resolved !== undefined) {
-			return resolved;
-		}
-	}
-
-	return undefined;
-};
-
-const is_valid_condition = (condition: string): boolean => {
-	if (
-		condition.length === 0 ||
-		condition.startsWith('.') ||
-		condition.includes(',') ||
-		/^\d+$/.test(condition)
-	) {
-		return false;
-	}
-	return /^[a-zA-Z0-9:_\-=]+$/.test(condition);
-};
-
-const normalize_extension = (path: string): string => {
-	if (path.endsWith('.d.ts')) {
-		return path.slice(0, -5) + '.js';
-	}
-
-	// No extension handling needed if path already has an extension
-	if (extname(path)) {
-		return path;
-	}
-
-	// If no extension at all, add .js
-	return path + '.js';
-};
-
-const validate_export_target = (target: string, throw_on_missing_package: boolean): void | null => {
-	// Must start with './'
-	if (!target.startsWith('./') && !target.startsWith('../')) {
-		if (throw_on_missing_package) {
-			throw new Error('ERR_INVALID_PACKAGE_TARGET: Export target must start with "./" or "../"');
-		} else {
-			return null;
-		}
-	}
-
-	// Can't contain node_modules
-	if (target.includes('node_modules')) {
-		if (throw_on_missing_package) {
-			throw new Error('ERR_INVALID_PACKAGE_TARGET: Export target cannot contain node_modules');
-		} else {
-			return null;
-		}
-	}
-
-	// Check for package boundary escape
-	const parts = target.split('/');
-	let depth = 0;
-
-	for (const part of parts) {
-		if (part === '..') {
-			depth--;
-			// If we go above root, it's escaping the package boundary
-			if (depth < 0) {
-				if (throw_on_missing_package) {
-					throw new Error(
-						'ERR_INVALID_PACKAGE_TARGET: Export target cannot escape package boundary',
-					);
-				} else {
-					return null;
-				}
-			}
-		} else if (part !== '.' && part !== '') {
-			depth++;
-		}
-	}
-};
-
-const get_specifier_slash_path_index = (mapped_specifier: string): number => {
-	let index: number = -1;
-	if (mapped_specifier[0] === '@') {
-		let count = 0;
-		for (let i = 0; i < mapped_specifier.length; i++) {
-			if (mapped_specifier[i] === '/') count++;
-			if (count === 2) {
-				index = i;
-				break;
-			}
-		}
-	} else {
-		index = mapped_specifier.indexOf('/');
-	}
-
-	return index;
-};