nitro-graphql 2.0.0-beta.70 → 2.0.0-beta.73

package/dist/core/utils/index.d.mts

@@ -1,7 +1,8 @@
-import { DirectiveFileRef, DirectiveParser, ParsedDirective, directiveParser, generateDirectiveSchema, generateDirectiveSchemas } from "./directive-parser.mjs";
+import { DirectiveFileRef, ParsedDirective, generateDirectiveSchema, generateDirectiveSchemas, parseDirectivesFromFile } from "./directive-parser.mjs";
 import { MaskErrorOptions, createDefaultMaskError } from "./errors.mjs";
-import { ensureDir, readFileSafe, writeFile, writeFileIfChanged } from "./file-io.mjs";
+import { ensureDir, writeFile, writeFileIfChanged } from "./file-io.mjs";
 import { getImportId, relativeWithDot } from "./imports.mjs";
-import { createLogger, createSilentLogger, defaultLogger } from "./logger.mjs";
+import { createLogger } from "./logger.mjs";
 import { OfetchTemplateOptions, generateOfetchTemplate } from "./ofetch-templates.mjs";
-export { DirectiveFileRef, DirectiveParser, MaskErrorOptions, OfetchTemplateOptions, ParsedDirective, createDefaultMaskError, createLogger, createSilentLogger, defaultLogger, directiveParser, ensureDir, generateDirectiveSchema, generateDirectiveSchemas, generateOfetchTemplate, getImportId, readFileSafe, relativeWithDot, writeFile, writeFileIfChanged };
+import { capitalize } from "./string.mjs";
+export { DirectiveFileRef, MaskErrorOptions, OfetchTemplateOptions, ParsedDirective, capitalize, createDefaultMaskError, createLogger, ensureDir, generateDirectiveSchema, generateDirectiveSchemas, generateOfetchTemplate, getImportId, parseDirectivesFromFile, relativeWithDot, writeFile, writeFileIfChanged };

package/dist/core/utils/index.mjs

@@ -1,8 +1,8 @@
-import { ensureDir, readFileSafe, writeFile, writeFileIfChanged } from "./file-io.mjs";
-import { createLogger, createSilentLogger, defaultLogger } from "./logger.mjs";
-import { DirectiveParser, directiveParser, generateDirectiveSchema, generateDirectiveSchemas } from "./directive-parser.mjs";
-import { createDefaultMaskError } from "./errors.mjs";
+import { ensureDir, writeFile, writeFileIfChanged } from "./file-io.mjs";
+import { capitalize } from "./string.mjs";
+import { createLogger } from "./logger.mjs";
 import { getImportId, relativeWithDot } from "./imports.mjs";
+import { generateDirectiveSchema, generateDirectiveSchemas, parseDirectivesFromFile } from "./directive-parser.mjs";
+import { createDefaultMaskError } from "./errors.mjs";
 import { generateOfetchTemplate } from "./ofetch-templates.mjs";
-
-export { DirectiveParser, createDefaultMaskError, createLogger, createSilentLogger, defaultLogger, directiveParser, ensureDir, generateDirectiveSchema, generateDirectiveSchemas, generateOfetchTemplate, getImportId, readFileSafe, relativeWithDot, writeFile, writeFileIfChanged };
+export { capitalize, createDefaultMaskError, createLogger, ensureDir, generateDirectiveSchema, generateDirectiveSchemas, generateOfetchTemplate, getImportId, parseDirectivesFromFile, relativeWithDot, writeFile, writeFileIfChanged };

package/dist/core/utils/logger.d.mts

@@ -5,14 +5,5 @@ import { CoreLogger } from "../types/config.mjs";
  * Create a logger instance with the nitro-graphql tag
  */
 declare function createLogger(tag?: string): CoreLogger;
-/**
- * Default logger instance
- */
-declare const defaultLogger: CoreLogger;
-/**
- * Create a silent logger (no output)
- * Useful for testing or when logging should be suppressed
- */
-declare function createSilentLogger(): CoreLogger;
 //#endregion
-export { createLogger, createSilentLogger, defaultLogger };
+export { createLogger };

package/dist/core/utils/logger.mjs

@@ -1,6 +1,5 @@
 import { LOG_TAG } from "../constants.mjs";
 import { consola as consola$1 } from "consola";
-
 //#region src/core/utils/logger.ts
 /**
 * Create a logger instance with the nitro-graphql tag
@@ -15,24 +14,5 @@ function createLogger(tag = LOG_TAG) {
 		debug: (message, ...args) => logger.debug(message, ...args)
 	};
 }
-/**
-* Default logger instance
-*/
-const defaultLogger = createLogger();
-/**
-* Create a silent logger (no output)
-* Useful for testing or when logging should be suppressed
-*/
-function createSilentLogger() {
-	const noop = () => {};
-	return {
-		info: noop,
-		warn: noop,
-		error: noop,
-		success: noop,
-		debug: noop
-	};
-}
-
 //#endregion
-export { createLogger, createSilentLogger, defaultLogger };
+export { createLogger };

package/dist/core/utils/ofetch-templates.mjs

@@ -1,10 +1,9 @@
+import { capitalize } from "./string.mjs";
 //#region src/core/utils/ofetch-templates.ts
 /**
-* Capitalize first letter of a string
+* Shared ofetch template generation utilities
+* Used by both main client and external service code generation
 */
-function capitalize(str) {
-	return str.charAt(0).toUpperCase() + str.slice(1);
-}
 /**
 * Generate ofetch client template content
 *
@@ -130,6 +129,5 @@ export function create${capitalizedName}GraphQLClient(endpoint: string = '${endp
 
 export const $${serviceName}Sdk: Sdk = getSdk(create${capitalizedName}GraphQLClient())`;
 }
-
 //#endregion
-export { generateOfetchTemplate };
+export { generateOfetchTemplate };

package/dist/core/utils/runtime.d.mts

@@ -1,5 +1,3 @@
-import { basename, dirname, join, resolve } from "pathe";
-
 //#region src/core/utils/runtime.d.ts
 /**
  * Cross-runtime compatibility layer
@@ -7,34 +5,18 @@ import { basename, dirname, join, resolve } from "pathe";
  * Provides runtime-agnostic file system and process utilities
  * that work across Node.js, Bun, and Deno.
  */
-/**
- * Read file contents asynchronously
- */
-declare function readFile(path: string): Promise<string>;
 /**
  * Read file contents synchronously
  */
 declare function readFileSync_(path: string): string;
-/**
- * Write file contents asynchronously
- */
-declare function writeFile(path: string, content: string): Promise<void>;
 /**
  * Write file contents synchronously
  */
 declare function writeFileSync_(path: string, content: string): void;
-/**
- * Check if file/directory exists asynchronously
- */
-declare function exists(path: string): Promise<boolean>;
 /**
  * Check if file/directory exists synchronously
  */
 declare function existsSync_(path: string): boolean;
-/**
- * Create directory recursively asynchronously
- */
-declare function mkdir(path: string): Promise<void>;
 /**
  * Create directory recursively synchronously
  */
@@ -59,16 +41,5 @@ declare function pathToFileURL(path: string): URL;
  * Works across Node.js, Bun, and Deno
  */
 declare function onSignal(signal: 'SIGINT' | 'SIGTERM', handler: () => void): void;
-/**
- * Read directory contents
- */
-declare function readdir(path: string): Promise<string[]>;
-/**
- * Get file/directory stats
- */
-declare function stat(path: string): Promise<{
-  isDirectory: () => boolean;
-  isFile: () => boolean;
-}>;
 //#endregion
-export { basename, dirname, exists, existsSync_, exit, getCwd, join, mkdir, mkdirSync_, onSignal, pathToFileURL, readFile, readFileSync_, readdir, resolve, stat, writeFile, writeFileSync_ };
+export { existsSync_, exit, getCwd, mkdirSync_, onSignal, pathToFileURL, readFileSync_, writeFileSync_ };

package/dist/core/utils/runtime.mjs

@@ -1,7 +1,5 @@
-import { basename, dirname, join, resolve } from "pathe";
-import { existsSync, mkdirSync, promises, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { pathToFileURL as pathToFileURL$1 } from "node:url";
-
 //#region src/core/utils/runtime.ts
 /**
 * Cross-runtime compatibility layer
@@ -11,53 +9,24 @@ import { pathToFileURL as pathToFileURL$1 } from "node:url";
 */
 const _globalThis = globalThis;
 /**
-* Read file contents asynchronously
-*/
-async function readFile(path) {
-	return promises.readFile(path, "utf-8");
-}
-/**
 * Read file contents synchronously
 */
 function readFileSync_(path) {
 	return readFileSync(path, "utf-8");
 }
 /**
-* Write file contents asynchronously
-*/
-async function writeFile(path, content) {
-	await promises.writeFile(path, content, "utf-8");
-}
-/**
 * Write file contents synchronously
 */
 function writeFileSync_(path, content) {
 	writeFileSync(path, content, "utf-8");
 }
 /**
-* Check if file/directory exists asynchronously
-*/
-async function exists(path) {
-	try {
-		await promises.access(path);
-		return true;
-	} catch {
-		return false;
-	}
-}
-/**
 * Check if file/directory exists synchronously
 */
 function existsSync_(path) {
 	return existsSync(path);
 }
 /**
-* Create directory recursively asynchronously
-*/
-async function mkdir(path) {
-	await promises.mkdir(path, { recursive: true });
-}
-/**
 * Create directory recursively synchronously
 */
 function mkdirSync_(path) {
@@ -94,18 +63,5 @@ function onSignal(signal, handler) {
 	if (_globalThis.Deno) _globalThis.Deno.addSignalListener(signal, handler);
 	else process.on(signal, handler);
 }
-/**
-* Read directory contents
-*/
-async function readdir(path) {
-	return promises.readdir(path);
-}
-/**
-* Get file/directory stats
-*/
-async function stat(path) {
-	return promises.stat(path);
-}
-
 //#endregion
-export { basename, dirname, exists, existsSync_, exit, getCwd, join, mkdir, mkdirSync_, onSignal, pathToFileURL, readFile, readFileSync_, readdir, resolve, stat, writeFile, writeFileSync_ };
+export { existsSync_, exit, getCwd, mkdirSync_, onSignal, pathToFileURL, readFileSync_, writeFileSync_ };

package/dist/core/utils/string.d.mts

@@ -0,0 +1,10 @@
+//#region src/core/utils/string.d.ts
+/**
+ * Shared string utilities
+ */
+/**
+ * Capitalize the first character of a string (PascalCase first letter)
+ */
+declare function capitalize(str: string): string;
+//#endregion
+export { capitalize };

package/dist/core/utils/string.mjs

@@ -0,0 +1,12 @@
+//#region src/core/utils/string.ts
+/**
+* Shared string utilities
+*/
+/**
+* Capitalize the first character of a string (PascalCase first letter)
+*/
+function capitalize(str) {
+	return str.charAt(0).toUpperCase() + str.slice(1);
+}
+//#endregion
+export { capitalize };

package/dist/core/utils/subscribe-templates.mjs

@@ -54,6 +54,5 @@ const config: SubscriptionClientConfig = {
 // Export configured client instance
 export const subscriptionClient = createSubscriptionClient(config)
 `;
-
 //#endregion
-export { subscribeClientTemplate };
+export { subscribeClientTemplate };

package/dist/core/validation/external-services.mjs

@@ -3,6 +3,7 @@
 * External services validation utilities
 * Framework-agnostic validation helpers
 */
+const VALID_IDENTIFIER_RE = /^[a-z]\w*$/i;
 /**
 * Validate external GraphQL service configuration
 */
@@ -24,10 +25,9 @@ function validateExternalServices(services) {
 		} catch {
 			errors.push(`${prefix}.endpoint "${service.endpoint}" must be a valid URL`);
 		}
-		if ("name" in service && typeof service.name === "string" && !/^[a-z]\w*$/i.test(service.name)) errors.push(`${prefix}.name "${service.name}" must be a valid identifier (letters, numbers, underscore, starting with letter)`);
+		if ("name" in service && typeof service.name === "string" && !VALID_IDENTIFIER_RE.test(service.name)) errors.push(`${prefix}.name "${service.name}" must be a valid identifier (letters, numbers, underscore, starting with letter)`);
 	}
 	return errors;
 }
-
 //#endregion
-export { validateExternalServices };
+export { validateExternalServices };

package/dist/core/validation/index.mjs

@@ -1,3 +1,2 @@
 import { validateExternalServices } from "./external-services.mjs";
-
-export { validateExternalServices };
+export { validateExternalServices };

package/dist/core/watcher/create-watcher.d.mts

@@ -0,0 +1,103 @@
+import { FSWatcher } from "chokidar";
+
+//#region src/core/watcher/create-watcher.d.ts
+/**
+ * Configuration for core watcher
+ */
+interface CoreWatcherConfig {
+  /** Directories to watch */
+  watchDirs: string[];
+  /** Server directory path (to classify changes) */
+  serverDir: string;
+  /** Debounce delay in ms (default: 150) */
+  debounceMs?: number;
+  /** Persistent watcher (default: true) */
+  persistent?: boolean;
+  /** Ignore initial scan (default: true) */
+  ignoreInitial?: boolean;
+  /** Use polling mode (default: false, but auto-enabled in CI/test environments) */
+  usePolling?: boolean;
+}
+/**
+ * Callbacks for watcher events
+ */
+interface CoreWatcherCallbacks {
+  /** Called when server files change (schemas, resolvers, directives) */
+  onServerChange: () => Promise<void>;
+  /** Called when client files change (documents only) */
+  onClientChange: () => Promise<void>;
+  /** Called when watcher is ready */
+  onReady?: () => void;
+  /** Called on watcher error */
+  onError?: (error: unknown) => void;
+}
+/**
+ * File type classification
+ */
+type FileType = 'graphql' | 'resolver' | 'directive' | null;
+/**
+ * Change type classification
+ */
+type ChangeType = 'server' | 'client' | null;
+/**
+ * Check if a file is a GraphQL-related file
+ */
+declare function getFileType(path: string): FileType;
+/**
+ * Check if a file should be watched
+ */
+declare function isWatchableFile(path: string): boolean;
+/**
+ * Classify a file change as server or client
+ */
+declare function classifyChange(path: string, serverDir: string): ChangeType;
+declare function createIgnoredFunction(): (path: string) => boolean;
+/**
+ * Check if a path should be skipped (generated files)
+ */
+declare function shouldSkipPath(path: string): boolean;
+/**
+ * Create a core file watcher
+ *
+ * This is the shared watcher used by both Nitro and CLI.
+ * Framework-specific actions are passed as callbacks.
+ *
+ * @example
+ * ```typescript
+ * // In Nitro
+ * const watcher = createCoreWatcher(
+ *   { watchDirs, serverDir: nitro.graphql.serverDir },
+ *   {
+ *     onServerChange: async () => {
+ *       await performGraphQLScan(nitro, { silent: true, isRescan: true })
+ *       await generateServerTypes(nitro, { silent: true })
+ *       await nitro.hooks.callHook('dev:reload')
+ *     },
+ *     onClientChange: async () => {
+ *       await generateClientTypes(nitro, { silent: true })
+ *     },
+ *   }
+ * )
+ *
+ * // In CLI
+ * const watcher = createCoreWatcher(
+ *   { watchDirs, serverDir: ctx.config.serverDir },
+ *   {
+ *     onServerChange: async () => {
+ *       await generateAll(ctx, { silent: true })
+ *       await reloadHandler()
+ *     },
+ *     onClientChange: async () => {
+ *       await generateClient(ctx, { silent: true })
+ *     },
+ *   }
+ * )
+ * ```
+ */
+declare function createCoreWatcher(config: CoreWatcherConfig, callbacks: CoreWatcherCallbacks): FSWatcher;
+/**
+ * Close a watcher safely
+ */
+declare function closeWatcher(watcher: FSWatcher): Promise<void>;
+//#endregion
+export { ChangeType, CoreWatcherCallbacks, CoreWatcherConfig, FileType, classifyChange, closeWatcher, createCoreWatcher, createIgnoredFunction, getFileType, isWatchableFile, shouldSkipPath };

package/dist/core/watcher/create-watcher.mjs

@@ -0,0 +1,143 @@
+import { DEFAULT_IGNORE_PATTERNS, DIRECTIVE_EXTENSIONS, GRAPHQL_EXTENSIONS, RESOLVER_EXTENSIONS } from "../constants.mjs";
+import { watch } from "chokidar";
+import { debounce } from "perfect-debounce";
+//#region src/core/watcher/create-watcher.ts
+const BACKSLASH_RE = /\\/g;
+/**
+* Check if a file is a GraphQL-related file
+*/
+function getFileType(path) {
+	if (GRAPHQL_EXTENSIONS.some((ext) => path.endsWith(ext))) return "graphql";
+	if (RESOLVER_EXTENSIONS.some((ext) => path.endsWith(ext))) return "resolver";
+	if (DIRECTIVE_EXTENSIONS.some((ext) => path.endsWith(ext))) return "directive";
+	return null;
+}
+/**
+* Check if a file should be watched
+*/
+function isWatchableFile(path) {
+	return getFileType(path) !== null;
+}
+/**
+* Classify a file change as server or client
+*/
+function classifyChange(path, serverDir) {
+	const fileType = getFileType(path);
+	if (!fileType) return null;
+	if (fileType === "resolver" || fileType === "directive") return "server";
+	if (fileType === "graphql") {
+		const normalizedPath = path.replace(BACKSLASH_RE, "/");
+		const normalizedServerDir = serverDir.replace(BACKSLASH_RE, "/");
+		if (normalizedPath.includes(normalizedServerDir)) return "server";
+		if (normalizedPath.includes("/server/graphql/") || normalizedPath.includes("\\server\\graphql\\")) return "server";
+		return "client";
+	}
+	return null;
+}
+/**
+* Create the ignored function for chokidar
+* Filters out non-GraphQL files and system directories
+*/
+const GLOB_STAR_RE = /\*\*/g;
+const SINGLE_STAR_RE = /\*/g;
+function createIgnoredFunction() {
+	const ignoredDirs = DEFAULT_IGNORE_PATTERNS.map((p) => p.replace(GLOB_STAR_RE, "").replace(SINGLE_STAR_RE, ""));
+	return (path) => {
+		if (ignoredDirs.some((dir) => path.includes(dir))) return true;
+		if (!(path.split("/").pop() || "").includes(".") || path.endsWith("/")) return false;
+		return !isWatchableFile(path);
+	};
+}
+/**
+* Check if a path should be skipped (generated files)
+*/
+function shouldSkipPath(path) {
+	return path.includes("/sdk.ts") || path.includes("/sdk.js") || path.endsWith("/config.ts");
+}
+/**
+* Create a core file watcher
+*
+* This is the shared watcher used by both Nitro and CLI.
+* Framework-specific actions are passed as callbacks.
+*
+* @example
+* ```typescript
+* // In Nitro
+* const watcher = createCoreWatcher(
+*   { watchDirs, serverDir: nitro.graphql.serverDir },
+*   {
+*     onServerChange: async () => {
+*       await performGraphQLScan(nitro, { silent: true, isRescan: true })
+*       await generateServerTypes(nitro, { silent: true })
+*       await nitro.hooks.callHook('dev:reload')
+*     },
+*     onClientChange: async () => {
+*       await generateClientTypes(nitro, { silent: true })
+*     },
+*   }
+* )
+*
+* // In CLI
+* const watcher = createCoreWatcher(
+*   { watchDirs, serverDir: ctx.config.serverDir },
+*   {
+*     onServerChange: async () => {
+*       await generateAll(ctx, { silent: true })
+*       await reloadHandler()
+*     },
+*     onClientChange: async () => {
+*       await generateClient(ctx, { silent: true })
+*     },
+*   }
+* )
+* ```
+*/
+function createCoreWatcher(config, callbacks) {
+	const { watchDirs, serverDir, debounceMs = 150, persistent = true, ignoreInitial = true, usePolling } = config;
+	const shouldUsePolling = usePolling ?? (process.env.CI === "true" || process.env.VITE_TEST === "true");
+	const watcher = watch(watchDirs, {
+		persistent,
+		ignoreInitial,
+		ignored: createIgnoredFunction(),
+		usePolling: shouldUsePolling,
+		interval: shouldUsePolling ? 100 : void 0,
+		awaitWriteFinish: shouldUsePolling ? {
+			stabilityThreshold: 100,
+			pollInterval: 50
+		} : false
+	});
+	const pending = {
+		server: false,
+		client: false
+	};
+	async function processChanges() {
+		const changes = { ...pending };
+		pending.server = pending.client = false;
+		try {
+			if (changes.server) await callbacks.onServerChange();
+			else if (changes.client) await callbacks.onClientChange();
+		} catch (error) {
+			callbacks.onError?.(error);
+		}
+	}
+	const debouncedProcess = debounce(processChanges, debounceMs);
+	watcher.on("all", (_, path) => {
+		if (shouldSkipPath(path)) return;
+		const changeType = classifyChange(path, serverDir);
+		if (!changeType) return;
+		if (changeType === "server") pending.server = true;
+		else pending.client = true;
+		debouncedProcess();
+	});
+	if (callbacks.onReady) watcher.on("ready", callbacks.onReady);
+	if (callbacks.onError) watcher.on("error", callbacks.onError);
+	return watcher;
+}
+/**
+* Close a watcher safely
+*/
+async function closeWatcher(watcher) {
+	await watcher.close();
+}
+//#endregion
+export { classifyChange, closeWatcher, createCoreWatcher, createIgnoredFunction, getFileType, isWatchableFile, shouldSkipPath };

package/dist/core/watcher/index.d.mts

@@ -1,107 +1,2 @@
-import { FSWatcher } from "chokidar";
-
-//#region src/core/watcher/index.d.ts
-/**
- * Configuration for core watcher
- */
-interface CoreWatcherConfig {
-  /** Directories to watch */
-  watchDirs: string[];
-  /** Server directory path (to classify changes) */
-  serverDir: string;
-  /** Debounce delay in ms (default: 150) */
-  debounceMs?: number;
-  /** Persistent watcher (default: true) */
-  persistent?: boolean;
-  /** Ignore initial scan (default: true) */
-  ignoreInitial?: boolean;
-  /** Use polling mode (default: false, but auto-enabled in CI/test environments) */
-  usePolling?: boolean;
-}
-/**
- * Callbacks for watcher events
- */
-interface CoreWatcherCallbacks {
-  /** Called when server files change (schemas, resolvers, directives) */
-  onServerChange: () => Promise<void>;
-  /** Called when client files change (documents only) */
-  onClientChange: () => Promise<void>;
-  /** Called when watcher is ready */
-  onReady?: () => void;
-  /** Called on watcher error */
-  onError?: (error: unknown) => void;
-}
-/**
- * File type classification
- */
-type FileType = 'graphql' | 'resolver' | 'directive' | null;
-/**
- * Change type classification
- */
-type ChangeType = 'server' | 'client' | null;
-/**
- * Check if a file is a GraphQL-related file
- */
-declare function getFileType(path: string): FileType;
-/**
- * Check if a file should be watched
- */
-declare function isWatchableFile(path: string): boolean;
-/**
- * Classify a file change as server or client
- */
-declare function classifyChange(path: string, serverDir: string): ChangeType;
-/**
- * Create the ignored function for chokidar
- * Filters out non-GraphQL files and system directories
- */
-declare function createIgnoredFunction(): (path: string) => boolean;
-/**
- * Check if a path should be skipped (generated files)
- */
-declare function shouldSkipPath(path: string): boolean;
-/**
- * Create a core file watcher
- *
- * This is the shared watcher used by both Nitro and CLI.
- * Framework-specific actions are passed as callbacks.
- *
- * @example
- * ```typescript
- * // In Nitro
- * const watcher = createCoreWatcher(
- *   { watchDirs, serverDir: nitro.graphql.serverDir },
- *   {
- *     onServerChange: async () => {
- *       await performGraphQLScan(nitro, { silent: true, isRescan: true })
- *       await generateServerTypes(nitro, { silent: true })
- *       await nitro.hooks.callHook('dev:reload')
- *     },
- *     onClientChange: async () => {
- *       await generateClientTypes(nitro, { silent: true })
- *     },
- *   }
- * )
- *
- * // In CLI
- * const watcher = createCoreWatcher(
- *   { watchDirs, serverDir: ctx.config.serverDir },
- *   {
- *     onServerChange: async () => {
- *       await generateAll(ctx, { silent: true })
- *       await reloadHandler()
- *     },
- *     onClientChange: async () => {
- *       await generateClient(ctx, { silent: true })
- *     },
- *   }
- * )
- * ```
- */
-declare function createCoreWatcher(config: CoreWatcherConfig, callbacks: CoreWatcherCallbacks): FSWatcher;
-/**
- * Close a watcher safely
- */
-declare function closeWatcher(watcher: FSWatcher): Promise<void>;
-//#endregion
-export { ChangeType, CoreWatcherCallbacks, CoreWatcherConfig, FileType, classifyChange, closeWatcher, createCoreWatcher, createIgnoredFunction, getFileType, isWatchableFile, shouldSkipPath };
+import { ChangeType, CoreWatcherCallbacks, CoreWatcherConfig, FileType, classifyChange, closeWatcher, createCoreWatcher, createIgnoredFunction, getFileType, isWatchableFile, shouldSkipPath } from "./create-watcher.mjs";
+export { type ChangeType, type CoreWatcherCallbacks, type CoreWatcherConfig, type FileType, classifyChange, closeWatcher, createCoreWatcher, createIgnoredFunction, getFileType, isWatchableFile, shouldSkipPath };