@ryanatkn/gro 0.143.3 → 0.144.1

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.143.3',
+	version: '0.144.1',
 	description: 'task runner and toolkit extending SvelteKit',
 	motto: 'generate, run, optimize',
 	glyph: '🌰',
@@ -44,11 +44,11 @@ export const package_json = {
 		'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',
@@ -61,21 +61,21 @@ export const package_json = {
 		'@changesets/changelog-git': '^0.2.0',
 		'@changesets/types': '^6.0.0',
 		'@ryanatkn/eslint-config': '^0.5.5',
-		'@ryanatkn/fuz': '^0.130.1',
-		'@ryanatkn/moss': '^0.18.2',
+		'@ryanatkn/fuz': '^0.130.3',
+		'@ryanatkn/moss': '^0.19.0',
 		'@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: {
@@ -157,6 +157,10 @@ export const package_json = {
 			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',
@@ -267,7 +271,7 @@ export const package_json = {
 
 export const src_json = {
 	name: '@ryanatkn/gro',
-	version: '0.143.3',
+	version: '0.144.1',
 	modules: {
 		'.': {
 			path: 'index.ts',
@@ -431,14 +435,14 @@ export const src_json = {
 		'./esbuild_plugin_external_worker.js': {
 			path: 'esbuild_plugin_external_worker.ts',
 			declarations: [
-				{name: 'Options', kind: 'type'},
+				{name: 'Esbuild_Plugin_External_Worker_Options', kind: 'type'},
 				{name: 'esbuild_plugin_external_worker', kind: 'function'},
 			],
 		},
 		'./esbuild_plugin_svelte.js': {
 			path: 'esbuild_plugin_svelte.ts',
 			declarations: [
-				{name: 'Options', kind: 'type'},
+				{name: 'Esbuild_Plugin_Svelte_Options', kind: 'type'},
 				{name: 'esbuild_plugin_svelte', kind: 'function'},
 			],
 		},
@@ -449,21 +453,21 @@ export const src_json = {
 		'./esbuild_plugin_sveltekit_shim_alias.js': {
 			path: 'esbuild_plugin_sveltekit_shim_alias.ts',
 			declarations: [
-				{name: 'Options', kind: 'type'},
+				{name: 'Esbuild_Plugin_Sveltekit_Shim_Alias_Options', kind: 'type'},
 				{name: 'esbuild_plugin_sveltekit_shim_alias', kind: 'function'},
 			],
 		},
 		'./esbuild_plugin_sveltekit_shim_app.js': {
 			path: 'esbuild_plugin_sveltekit_shim_app.ts',
 			declarations: [
-				{name: 'Options', kind: 'type'},
+				{name: 'Esbuild_Plugin_Sveltekit_Shim_App_Options', kind: 'type'},
 				{name: 'esbuild_plugin_sveltekit_shim_app', kind: 'function'},
 			],
 		},
 		'./esbuild_plugin_sveltekit_shim_env.js': {
 			path: 'esbuild_plugin_sveltekit_shim_env.ts',
 			declarations: [
-				{name: 'Options', kind: 'type'},
+				{name: 'Esbuild_Plugin_Sveltekit_Shim_Env_Options', kind: 'type'},
 				{name: 'esbuild_plugin_sveltekit_shim_env', kind: 'function'},
 			],
 		},
@@ -473,7 +477,7 @@ export const src_json = {
 				{name: 'Source_File', kind: 'type'},
 				{name: 'Cleanup_Watch', kind: 'type'},
 				{name: 'On_Filer_Change', kind: 'type'},
-				{name: 'Options', kind: 'type'},
+				{name: 'Filer_Options', kind: 'type'},
 				{name: 'Filer', kind: 'class'},
 			],
 		},
@@ -594,17 +598,28 @@ export const src_json = {
 			path: 'gro_plugin_gen.ts',
 			declarations: [
 				{name: 'Task_Args', kind: 'type'},
-				{name: 'Options', kind: 'type'},
+				{name: 'Gro_Plugin_Gen_Options', kind: 'type'},
 				{name: 'gro_plugin_gen', kind: 'function'},
 				{name: 'filter_dependents', kind: 'function'},
 			],
 		},
+		'./gro_plugin_moss.js': {
+			path: 'gro_plugin_moss.ts',
+			declarations: [
+				{name: 'MOSS_PACKAGE_DEP_NAME', kind: 'variable'},
+				{name: 'has_moss_dep', kind: 'function'},
+				{name: 'generate_classes_css', kind: 'function'},
+				{name: 'Task_Args', kind: 'type'},
+				{name: 'Options', kind: 'type'},
+				{name: 'gro_plugin_moss', kind: 'function'},
+			],
+		},
 		'./gro_plugin_server.js': {
 			path: 'gro_plugin_server.ts',
 			declarations: [
 				{name: 'SERVER_SOURCE_ID', kind: 'variable'},
 				{name: 'has_server', kind: 'function'},
-				{name: 'Options', kind: 'type'},
+				{name: 'Gro_Plugin_Server_Options', kind: 'type'},
 				{name: 'Outpaths', kind: 'type'},
 				{name: 'Create_Outpaths', kind: 'type'},
 				{name: 'gro_plugin_server', kind: 'function'},
@@ -613,7 +628,7 @@ export const src_json = {
 		'./gro_plugin_sveltekit_app.js': {
 			path: 'gro_plugin_sveltekit_app.ts',
 			declarations: [
-				{name: 'Options', kind: 'type'},
+				{name: 'Gro_Plugin_Sveltekit_App_Options', kind: 'type'},
 				{name: 'Host_Target', kind: 'type'},
 				{name: 'Copy_File_Filter', kind: 'type'},
 				{name: 'gro_plugin_sveltekit_app', kind: 'function'},
@@ -622,7 +637,7 @@ export const src_json = {
 		'./gro_plugin_sveltekit_library.js': {
 			path: 'gro_plugin_sveltekit_library.ts',
 			declarations: [
-				{name: 'Options', kind: 'type'},
+				{name: 'Gro_Plugin_Sveltekit_Library_Options', kind: 'type'},
 				{name: 'gro_plugin_sveltekit_library', kind: 'function'},
 			],
 		},
@@ -704,6 +719,7 @@ export const src_json = {
 				{name: 'Package_Json_Repository', kind: 'variable'},
 				{name: 'Package_Json_Author', kind: 'variable'},
 				{name: 'Package_Json_Funding', kind: 'variable'},
+				{name: 'Export_Value', kind: 'variable'},
 				{name: 'Package_Json_Exports', kind: 'variable'},
 				{name: 'Package_Json', kind: 'variable'},
 				{name: 'Map_Package_Json', kind: 'type'},
@@ -1037,7 +1053,7 @@ export const src_json = {
 				{name: 'Watcher_Change', kind: 'type'},
 				{name: 'Watcher_Change_Type', kind: 'type'},
 				{name: 'Watcher_Change_Callback', kind: 'type'},
-				{name: 'Options', kind: 'type'},
+				{name: 'Watch_Dir_Options', kind: 'type'},
 				{name: 'watch_dir', kind: 'function'},
 			],
 		},

package/src/lib/package_json.ts

@@ -63,20 +63,21 @@ export const Package_Json_Funding = z.union([
 ]);
 export type Package_Json_Funding = z.infer<typeof Package_Json_Funding>;
 
-// 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 = (): z.ZodType => {
+	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;
+export type Export_Value = z.infer<typeof Export_Value>;
+
+// 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)]);
 export type Package_Json_Exports = z.infer<typeof Package_Json_Exports>;
 
 /**

package/src/lib/resolve_node_specifier.ts

@@ -1,17 +1,15 @@
-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 type {Resolved_Specifier} from './resolve_specifier.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: string,
@@ -19,8 +17,7 @@ export const resolve_node_specifier = (
 	parent_path?: string,
 	cache?: Record<string, Package_Json>,
 	throw_on_missing_package = true,
-	// TODO this needs to use `--conditions`/`-C` to determine the correct key
-	exports_condition = DEV ? 'development' : 'default',
+	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;
@@ -28,7 +25,6 @@ export const resolve_node_specifier = (
 	// Parse the specifier
 	let idx: number = -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] === '/') count++;
@@ -40,12 +36,17 @@ export const resolve_node_specifier = (
 	} else {
 		idx = mapped_specifier.indexOf('/');
 	}
+
 	const pkg_name = idx === -1 ? mapped_specifier : mapped_specifier.substring(0, idx);
 	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: Package_Json | undefined;
+	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` +
@@ -54,13 +55,31 @@ export const resolve_node_specifier = (
 		} else {
 			return null;
 		}
+	} 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;
+		}
 	}
 
-	const package_json = load_package_json(package_dir, cache, false);
-	const {exported, exports_key} = resolve_subpath(package_json, specifier, subpath);
 	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}` : ''),
@@ -69,18 +88,20 @@ export const resolve_node_specifier = (
 			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` +
+				`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,
@@ -92,47 +113,244 @@ export const resolve_node_specifier = (
 	};
 };
 
-/**
- * Resolves the subpath of a package.json `exports` field based on the `specifier`.
- */
-const resolve_subpath = (
-	package_json: Package_Json,
-	specifier: string,
-	subpath: string,
-): {exported: Package_Json_Exports[string]; exports_key: string} => {
-	const exports_key = specifier.endsWith('.svelte') ? 'svelte' : 'default';
+const replace_wildcards = (pattern: string, wildcards: string[]): string => {
+	if (!pattern.includes('*')) return pattern;
 
-	const exported =
-		subpath === '.' && !package_json.exports
-			? {[exports_key]: package_json.main}
-			: package_json.exports?.[subpath];
+	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;
+	}
 
-	return {exported, exports_key};
+	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: 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;
 };
 
-/**
- * Resolves the exported value based on the exports key and condition.
- */
 const resolve_exported_value = (
-	exported: Exclude<Package_Json_Exports[string], undefined>,
-	exports_key: string,
-	exports_condition: string,
+	exported: Export_Value,
+	conditions: string[],
 ): string | undefined => {
-	let exported_value = typeof exported === 'string' ? exported : exported[exports_key];
+	if (typeof exported === 'string') {
+		return exported;
+	}
+
+	if (typeof exported !== 'object' || exported === null) {
+		return undefined;
+	}
+
+	const exported_obj = exported as Record<string, unknown>;
+
+	// eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
+	let default_value: Export_Value | undefined;
+
+	// 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';
+	}
 
-	// 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;
+	// No extension handling needed if path already has an extension
+	if (extname(path)) {
+		return path;
 	}
 
-	// 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
+	// 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;
+		}
+	}
 
-	return exported_value;
+	// 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/src/lib/sveltekit_helpers.ts

@@ -33,7 +33,6 @@ export const has_sveltekit_library = (
 	package_json?: Package_Json,
 	sveltekit_config: Parsed_Sveltekit_Config = default_sveltekit_config,
 	dep_name = SVELTE_PACKAGE_DEP_NAME,
-	pm_cli = PM_CLI_DEFAULT, // TODO source from config when possible, is just needed for error messages
 ): Result<object, {message: string}> => {
 	const has_sveltekit_app_result = has_sveltekit_app();
 	if (!has_sveltekit_app_result.ok) {
@@ -47,7 +46,7 @@ export const has_sveltekit_library = (
 	if (!has_dep(dep_name, package_json)) {
 		return {
 			ok: false,
-			message: `no dependency found in package.json for ${dep_name}, install it with \`${pm_cli} install -D ${dep_name}\``,
+			message: `no dependency found in package.json for ${dep_name}`,
 		};
 	}
 

package/src/lib/watch_dir.ts

@@ -20,7 +20,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;
@@ -41,7 +41,7 @@ export const watch_dir = ({
 	filter,
 	absolute = true,
 	chokidar,
-}: Options): Watch_Node_Fs => {
+}: Watch_Dir_Options): Watch_Node_Fs => {
 	let watcher: FSWatcher | undefined;
 	let initing: Deferred<void> | undefined;