@ryanatkn/gro 0.143.3 → 0.144.0

package/dist/package_json.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"package_json.d.ts","sourceRoot":"../src/lib/","sources":["package_json.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"package_json.d.ts","sourceRoot":"../src/lib/","sources":["package_json.ts"],"names":[],"mappings":"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"}

package/dist/package_json.js

@@ -48,18 +48,18 @@ export const Package_Json_Funding = z.union([
     })
         .passthrough(),
 ]);
-// exports: {
-// 	'./': './index.js',
-// 	'./record': {default: './record.js'},
-//  './export_condition': {default: {development: './ec1', default: './ec2.js'}},
-// }
-export const Package_Json_Exports = z.record(z
-    .union([
-    z.string(),
-    z.record(z.string().optional()),
-    z.record(z.record(z.string().optional()).optional()),
-])
-    .optional());
+// Helper to create a recursive type that represents export conditions and values
+const create_export_value_schema = () => {
+    return z.lazy(() => z.union([z.string(), z.null(), z.record(z.lazy(() => export_value_schema))]));
+};
+// The base export value schema that can be a string, null, or nested conditions
+const export_value_schema = create_export_value_schema();
+export const Export_Value = export_value_schema;
+// Package exports can be:
+// 1. A string (shorthand for main export)
+// 2. null (to block exports)
+// 3. A record of export conditions/paths
+export const Package_Json_Exports = z.union([z.string(), z.null(), z.record(export_value_schema)]);
 /**
  * @see https://docs.npmjs.com/cli/v10/configuring-npm/package-json
  */

package/dist/resolve_node_specifier.d.ts

@@ -1,10 +1,7 @@
 import { Package_Json } from './package_json.js';
 import type { Resolved_Specifier } from './resolve_specifier.js';
 /**
- * Like `resolve_specifier` but for Node specifiers,
- * typically those that aren't relative or absolute.
- * Optionally return `null` instead of throwing by setting
- * `throw_on_missing_package` to `false`.
+ * 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, cache?: Record<string, Package_Json>, throw_on_missing_package?: boolean, exports_condition?: string) => Resolved_Specifier | null;
+export declare const resolve_node_specifier: (specifier: string, dir?: string, parent_path?: string, 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 +1 @@
-{"version":3,"file":"resolve_node_specifier.d.ts","sourceRoot":"../src/lib/","sources":["resolve_node_specifier.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,YAAY,EAA0C,MAAM,mBAAmB,CAAC;AAGxF,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,wBAAwB,CAAC;AAE/D;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB,cACvB,MAAM,8BAEH,MAAM,UACZ,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,qEAIlC,kBAAkB,GAAG,IAqEvB,CAAC"}
+{"version":3,"file":"resolve_node_specifier.d.ts","sourceRoot":"../src/lib/","sources":["resolve_node_specifier.ts"],"names":[],"mappings":"AAIA,OAAO,EAAe,YAAY,EAAoB,MAAM,mBAAmB,CAAC;AAGhF,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,wBAAwB,CAAC;AAG/D;;GAEG;AACH,eAAO,MAAM,sBAAsB,cACvB,MAAM,8BAEH,MAAM,UACZ,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,wEAGlC,kBAAkB,GAAG,IA6FvB,CAAC"}

package/dist/resolve_node_specifier.js

@@ -1,24 +1,19 @@
-import { join } from 'node:path';
+import { join, extname } from 'node:path';
 import { existsSync } from 'node:fs';
 import { DEV } from 'esm-env';
-import { Package_Json, Package_Json_Exports, load_package_json } from './package_json.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 { escape_regexp } from '@ryanatkn/belt/regexp.js';
 /**
- * Like `resolve_specifier` but for Node specifiers,
- * typically those that aren't relative or absolute.
- * Optionally return `null` instead of throwing by setting
- * `throw_on_missing_package` to `false`.
+ * 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, cache, throw_on_missing_package = true, 
-// TODO this needs to use `--conditions`/`-C` to determine the correct key
-exports_condition = DEV ? 'development' : 'default') => {
+export const resolve_node_specifier = (specifier, dir = paths.root, parent_path, 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;
     // Parse the specifier
     let idx = -1;
     if (mapped_specifier[0] === '@') {
-        // get the index of the second `/`
         let count = 0;
         for (let i = 0; i < mapped_specifier.length; i++) {
             if (mapped_specifier[i] === '/')
@@ -36,7 +31,12 @@ exports_condition = DEV ? 'development' : 'default') => {
     const module_path = idx === -1 ? '' : mapped_specifier.substring(idx + 1);
     const subpath = module_path ? './' + module_path : '.';
     const package_dir = join(dir, NODE_MODULES_DIRNAME, pkg_name);
-    if (!existsSync(package_dir)) {
+    // Check cache first
+    let package_json;
+    if (cache?.[pkg_name]) {
+        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}` : ''));
@@ -45,11 +45,25 @@ exports_condition = DEV ? 'development' : 'default') => {
             return null;
         }
     }
-    const package_json = load_package_json(package_dir, cache, false);
-    const { exported, exports_key } = resolve_subpath(package_json, specifier, subpath);
+    else {
+        package_json = load_package_json(package_dir, 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) {
-            // same error message as Node
             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}` : ''));
         }
@@ -57,17 +71,17 @@ exports_condition = DEV ? 'development' : 'default') => {
             return null;
         }
     }
-    const exported_value = resolve_exported_value(exported, exports_key, exports_condition);
+    const exported_value = resolve_exported_value(exported, exports_conditions);
     if (exported_value === undefined) {
         if (throw_on_missing_package) {
-            throw Error(`Package subpath '${subpath}' does not define the key '${exports_key}' in 'exports' in ${package_dir}/package.json` +
+            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 = join(package_dir, exported_value);
+    const path_id = normalize_extension(join(package_dir, exported_value));
     return {
         path_id,
         path_id_with_querystring: raw ? path_id + '?raw' : path_id,
@@ -77,32 +91,207 @@ exports_condition = DEV ? 'development' : 'default') => {
         namespace: undefined,
     };
 };
-/**
- * Resolves the subpath of a package.json `exports` field based on the `specifier`.
- */
-const resolve_subpath = (package_json, specifier, subpath) => {
-    const exports_key = specifier.endsWith('.svelte') ? 'svelte' : 'default';
-    const exported = subpath === '.' && !package_json.exports
-        ? { [exports_key]: package_json.main }
-        : package_json.exports?.[subpath];
-    return { exported, exports_key };
+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;
 };
-/**
- * Resolves the exported value based on the exports key and condition.
- */
-const resolve_exported_value = (exported, exports_key, exports_condition) => {
-    let exported_value = typeof exported === 'string' ? exported : exported[exports_key];
-    // TODO best effort fallback, support `default` but fall back to `import` or `node` as the exports key.
-    if (exported_value === undefined && typeof exported !== 'string' && exports_key === 'default') {
-        exported_value = exported.import ?? exported.node;
-    }
-    // Possibly resolve to conditional exports.
-    exported_value =
-        exported_value === undefined || typeof exported_value === 'string'
-            ? exported_value
-            : (exported_value[exports_condition] ??
-                exported_value.default ??
-                exported_value.import ??
-                exported_value.node); // TODO this fallback has corner case bugs for off-spec exports
-    return exported_value;
+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];
+        }
+        // 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;
+    // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
+    let default_value;
+    // 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++;
+        }
+    }
 };

package/dist/watch_dir.d.ts

@@ -11,7 +11,7 @@ export interface Watcher_Change {
 }
 export type Watcher_Change_Type = 'add' | 'update' | 'delete';
 export type Watcher_Change_Callback = (change: Watcher_Change) => void;
-export interface Options {
+export interface Watch_Dir_Options {
     dir: string;
     on_change: Watcher_Change_Callback;
     filter?: Path_Filter | null | undefined;
@@ -25,5 +25,5 @@ export interface Options {
 /**
  * Watch for changes on the filesystem using chokidar.
  */
-export declare const watch_dir: ({ dir, on_change, filter, absolute, chokidar, }: Options) => Watch_Node_Fs;
+export declare const watch_dir: ({ dir, on_change, filter, absolute, chokidar, }: Watch_Dir_Options) => Watch_Node_Fs;
 //# sourceMappingURL=watch_dir.d.ts.map

package/dist/watch_dir.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"watch_dir.d.ts","sourceRoot":"../src/lib/","sources":["watch_dir.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,KAAK,eAAe,EAAiB,MAAM,UAAU,CAAC;AAKrE,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,WAAW,CAAC;AAI3C,MAAM,WAAW,aAAa;IAC7B,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1B,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC3B;AAED,MAAM,WAAW,cAAc;IAC9B,IAAI,EAAE,mBAAmB,CAAC;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,OAAO,CAAC;CACtB;AACD,MAAM,MAAM,mBAAmB,GAAG,KAAK,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAC9D,MAAM,MAAM,uBAAuB,GAAG,CAAC,MAAM,EAAE,cAAc,KAAK,IAAI,CAAC;AAEvE,MAAM,WAAW,OAAO;IACvB,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,EAAE,uBAAuB,CAAC;IACnC,MAAM,CAAC,EAAE,WAAW,GAAG,IAAI,GAAG,SAAS,CAAC;IACxC,QAAQ,CAAC,EAAE,eAAe,CAAC;IAC3B;;;OAGG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;CACnB;AAED;;GAEG;AACH,eAAO,MAAM,SAAS,oDAMnB,OAAO,KAAG,aA6CZ,CAAC"}
+{"version":3,"file":"watch_dir.d.ts","sourceRoot":"../src/lib/","sources":["watch_dir.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,KAAK,eAAe,EAAiB,MAAM,UAAU,CAAC;AAKrE,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,WAAW,CAAC;AAI3C,MAAM,WAAW,aAAa;IAC7B,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1B,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC3B;AAED,MAAM,WAAW,cAAc;IAC9B,IAAI,EAAE,mBAAmB,CAAC;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,OAAO,CAAC;CACtB;AACD,MAAM,MAAM,mBAAmB,GAAG,KAAK,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAC9D,MAAM,MAAM,uBAAuB,GAAG,CAAC,MAAM,EAAE,cAAc,KAAK,IAAI,CAAC;AAEvE,MAAM,WAAW,iBAAiB;IACjC,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,EAAE,uBAAuB,CAAC;IACnC,MAAM,CAAC,EAAE,WAAW,GAAG,IAAI,GAAG,SAAS,CAAC;IACxC,QAAQ,CAAC,EAAE,eAAe,CAAC;IAC3B;;;OAGG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;CACnB;AAED;;GAEG;AACH,eAAO,MAAM,SAAS,oDAMnB,iBAAiB,KAAG,aA6CtB,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ryanatkn/gro",
-  "version": "0.143.3",
+  "version": "0.144.0",
   "description": "task runner and toolkit extending SvelteKit",
   "motto": "generate, run, optimize",
   "glyph": "🌰",
@@ -49,11 +49,11 @@
     "typescript"
   ],
   "dependencies": {
-    "@ryanatkn/belt": "^0.25.3",
+    "@ryanatkn/belt": "^0.26.0",
     "chokidar": "^4.0.1",
     "dotenv": "^16.4.5",
     "es-module-lexer": "^1.5.4",
-    "esm-env": "^1.0.0",
+    "esm-env": "^1.1.4",
     "mri": "^1.2.0",
     "prettier": "^3.3.3",
     "prettier-plugin-svelte": "^3.2.7",
@@ -69,21 +69,21 @@
     "@changesets/changelog-git": "^0.2.0",
     "@changesets/types": "^6.0.0",
     "@ryanatkn/eslint-config": "^0.5.5",
-    "@ryanatkn/fuz": "^0.130.1",
+    "@ryanatkn/fuz": "^0.130.3",
     "@ryanatkn/moss": "^0.18.2",
     "@sveltejs/adapter-static": "^3.0.6",
     "@sveltejs/kit": "^2.7.3",
     "@sveltejs/package": "^2.3.7",
     "@sveltejs/vite-plugin-svelte": "^4.0.0",
     "@types/fs-extra": "^11.0.4",
-    "@types/node": "^22.8.1",
+    "@types/node": "^22.8.4",
     "esbuild": "^0.21.5",
     "eslint": "^9.13.0",
     "eslint-plugin-svelte": "^2.46.0",
-    "svelte": "^5.1.3",
+    "svelte": "^5.1.5",
     "svelte-check": "^4.0.5",
     "typescript": "^5.6.3",
-    "typescript-eslint": "^8.11.0",
+    "typescript-eslint": "^8.12.1",
     "uvu": "^0.5.6"
   },
   "prettier": {
@@ -250,6 +250,10 @@
       "types": "./dist/gro_plugin_gen.d.ts",
       "default": "./dist/gro_plugin_gen.js"
     },
+    "./gro_plugin_moss.js": {
+      "types": "./dist/gro_plugin_moss.d.ts",
+      "default": "./dist/gro_plugin_moss.js"
+    },
     "./gro_plugin_server.js": {
       "types": "./dist/gro_plugin_server.d.ts",
       "default": "./dist/gro_plugin_server.js"

package/src/lib/esbuild_plugin_external_worker.ts

@@ -13,7 +13,7 @@ import {esbuild_plugin_svelte} from './esbuild_plugin_svelte.js';
 import type {Parsed_Sveltekit_Config} from './sveltekit_config.js';
 import type {Path_Id} from './path.js';
 
-export interface Options {
+export interface Esbuild_Plugin_External_Worker_Options {
 	dev: boolean;
 	build_options: esbuild.BuildOptions;
 	dir?: string;
@@ -47,7 +47,7 @@ export const esbuild_plugin_external_worker = ({
 	env_files,
 	ambient_env,
 	log,
-}: Options): esbuild.Plugin => ({
+}: Esbuild_Plugin_External_Worker_Options): esbuild.Plugin => ({
 	name: 'external_worker',
 	setup: (build) => {
 		const builds: Map<string, Promise<esbuild.BuildResult>> = new Map();

package/src/lib/esbuild_plugin_svelte.ts

@@ -19,7 +19,7 @@ import {
 } from './sveltekit_config.js';
 import {TS_MATCHER} from './constants.js';
 
-export interface Options {
+export interface Esbuild_Plugin_Svelte_Options {
 	dev: boolean;
 	base_url: Parsed_Sveltekit_Config['base_url'];
 	dir?: string;
@@ -30,7 +30,7 @@ export interface Options {
 	is_ts?: (filename: string) => boolean;
 }
 
-export const esbuild_plugin_svelte = (options: Options): esbuild.Plugin => {
+export const esbuild_plugin_svelte = (options: Esbuild_Plugin_Svelte_Options): esbuild.Plugin => {
 	const {
 		dev,
 		base_url,

package/src/lib/esbuild_plugin_sveltekit_shim_alias.ts

@@ -2,7 +2,7 @@ import type * as esbuild from 'esbuild';
 import {escape_regexp} from '@ryanatkn/belt/regexp.js';
 import {join} from 'node:path';
 
-export interface Options {
+export interface Esbuild_Plugin_Sveltekit_Shim_Alias_Options {
 	dir?: string;
 	alias?: Record<string, string>;
 }
@@ -10,7 +10,7 @@ export interface Options {
 export const esbuild_plugin_sveltekit_shim_alias = ({
 	dir = process.cwd(),
 	alias,
-}: Options): esbuild.Plugin => ({
+}: Esbuild_Plugin_Sveltekit_Shim_Alias_Options): esbuild.Plugin => ({
 	name: 'sveltekit_shim_alias',
 	setup: (build) => {
 		const aliases: Record<string, string> = {$lib: 'src/lib', ...alias};

package/src/lib/esbuild_plugin_sveltekit_shim_app.ts

@@ -8,7 +8,7 @@ import {
 import type {Parsed_Sveltekit_Config} from './sveltekit_config.js';
 import {EVERYTHING_MATCHER} from './constants.js';
 
-export interface Options {
+export interface Esbuild_Plugin_Sveltekit_Shim_App_Options {
 	dev: boolean;
 	base_url: Parsed_Sveltekit_Config['base_url'];
 	assets_url: Parsed_Sveltekit_Config['assets_url'];
@@ -18,7 +18,7 @@ export const esbuild_plugin_sveltekit_shim_app = ({
 	dev,
 	base_url,
 	assets_url,
-}: Options): esbuild.Plugin => ({
+}: Esbuild_Plugin_Sveltekit_Shim_App_Options): esbuild.Plugin => ({
 	name: 'sveltekit_shim_app',
 	setup: (build) => {
 		build.onResolve({filter: /^\$app\/(forms|navigation|stores)$/}, ({path, ...rest}) =>

package/src/lib/esbuild_plugin_sveltekit_shim_env.ts

@@ -4,7 +4,7 @@ import {render_env_shim_module} from './sveltekit_shim_env.js';
 import {EVERYTHING_MATCHER} from './constants.js';
 import {SVELTEKIT_ENV_MATCHER} from './sveltekit_helpers.js';
 
-export interface Options {
+export interface Esbuild_Plugin_Sveltekit_Shim_Env_Options {
 	dev: boolean;
 	public_prefix?: string;
 	private_prefix?: string;
@@ -22,7 +22,7 @@ export const esbuild_plugin_sveltekit_shim_env = ({
 	env_dir,
 	env_files,
 	ambient_env,
-}: Options): esbuild.Plugin => ({
+}: Esbuild_Plugin_Sveltekit_Shim_Env_Options): esbuild.Plugin => ({
 	name: 'sveltekit_shim_env',
 	setup: (build) => {
 		build.onResolve({filter: SVELTEKIT_ENV_MATCHER}, ({path}) => ({path, namespace}));

package/src/lib/filer.ts

@@ -9,7 +9,7 @@ import {
 	watch_dir,
 	type Watch_Node_Fs,
 	type Watcher_Change,
-	type Options as Watch_Dir_Options,
+	type Watch_Dir_Options,
 	type Watcher_Change_Callback,
 } from './watch_dir.js';
 import {paths} from './paths.js';
@@ -20,14 +20,11 @@ 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';
-// TODO see below
-// import {resolve_node_specifier} from './resolve_node_specifier.js';
 
 const aliases = Object.entries(default_sveltekit_config.alias);
 
 export interface Source_File {
 	id: Path_Id;
-	// TODO add // mtime: number;
 	/**
 	 * `null` contents means it doesn't exist.
 	 * We create the file in memory to track its dependents regardless of its existence on disk.
@@ -47,7 +44,7 @@ export type Cleanup_Watch = () => Promise<void>;
 
 export type On_Filer_Change = (change: Watcher_Change, source_file: Source_File) => void;
 
-export interface Options {
+export interface Filer_Options {
 	watch_dir?: typeof watch_dir;
 	watch_dir_options?: Partial<Omit_Strict<Watch_Dir_Options, 'on_change'>>;
 	package_json_cache?: Record<string, Package_Json>;
@@ -63,7 +60,7 @@ export class Filer {
 
 	#package_json_cache: Record<string, Package_Json>;
 
-	constructor(options: Options = EMPTY_OBJECT) {
+	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);

package/src/lib/gro_plugin_gen.ts

@@ -16,7 +16,7 @@ export interface Task_Args extends Args {
 	watch?: boolean;
 }
 
-export interface Options {
+export interface Gro_Plugin_Gen_Options {
 	input_paths?: string[];
 	root_dirs?: string[];
 	flush_debounce_delay?: number;
@@ -26,7 +26,7 @@ export const gro_plugin_gen = ({
 	input_paths = [paths.source],
 	root_dirs = [paths.source],
 	flush_debounce_delay = FLUSH_DEBOUNCE_DELAY,
-}: Options = EMPTY_OBJECT): Plugin => {
+}: Gro_Plugin_Gen_Options = EMPTY_OBJECT): Plugin => {
 	let flushing_timeout: NodeJS.Timeout | undefined;
 	const queued_files: Set<string> = new Set();
 	const queue_gen = (gen_file_id: string) => {