@warlock.js/core 4.0.161 → 4.0.163

package/esm/dev-server/export-analyzer.js

@@ -0,0 +1,206 @@
+import ts from'typescript';/**
+ * Export Analyzer
+ * Analyzes TypeScript files to extract export information
+ * Used for transforming re-exports to dynamic imports
+ */
+class ExportAnalyzer {
+    /**
+     * Cache of analyzed exports
+     * Maps relative file path to export info (consistent with rest of codebase)
+     */
+    cache = new Map();
+    /**
+     * Analyze exports from a FileManager
+     * Reuses the already-loaded source code instead of reading the file again
+     * @param fileManager FileManager instance with source code
+     * @returns Export information
+     */
+    analyzeExports(fileManager) {
+        // Use relative path for cache key (consistent with rest of codebase)
+        const cacheKey = fileManager.relativePath;
+        // Check cache first
+        if (this.cache.has(cacheKey)) {
+            return this.cache.get(cacheKey);
+        }
+        // Parse and analyze the file using the already-loaded source
+        const info = this.parseExports(fileManager);
+        // Cache the result
+        this.cache.set(cacheKey, info);
+        return info;
+    }
+    /**
+     * Parse exports from a FileManager's source code
+     * @param fileManager FileManager instance with source code
+     * @returns Export information
+     */
+    parseExports(fileManager) {
+        const info = {
+            namedExports: [],
+            hasDefaultExport: false,
+            reExports: [],
+        };
+        try {
+            // Use the already-loaded source from FileManager
+            const sourceText = fileManager.source;
+            if (!sourceText) {
+                return info;
+            }
+            // Create a source file
+            const sourceFile = ts.createSourceFile(fileManager.absolutePath, sourceText, ts.ScriptTarget.Latest, true);
+            // Visit all nodes to find exports
+            const visit = (node) => {
+                // Handle export declarations
+                if (ts.isExportDeclaration(node)) {
+                    this.handleExportDeclaration(node, info);
+                }
+                // Handle export assignments (export = ...)
+                else if (ts.isExportAssignment(node)) {
+                    if (!node.isExportEquals) {
+                        // export default ...
+                        info.hasDefaultExport = true;
+                    }
+                }
+                // Handle variable statements with export modifier
+                else if (ts.isVariableStatement(node)) {
+                    this.handleVariableStatement(node, info);
+                }
+                // Handle function declarations with export modifier
+                else if (ts.isFunctionDeclaration(node)) {
+                    this.handleFunctionDeclaration(node, info);
+                }
+                // Handle class declarations with export modifier
+                else if (ts.isClassDeclaration(node)) {
+                    this.handleClassDeclaration(node, info);
+                }
+                // Handle enum declarations with export modifier (enums exist at runtime)
+                else if (ts.isEnumDeclaration(node)) {
+                    this.handleEnumDeclaration(node, info);
+                }
+                // Note: Interfaces and type aliases are intentionally skipped
+                // They are type-only and don't exist at runtime
+                // Recursively visit child nodes
+                ts.forEachChild(node, visit);
+            };
+            visit(sourceFile);
+        }
+        catch (error) {
+            // If parsing fails, return empty info
+            console.error(`Failed to parse exports from ${fileManager.relativePath}:`, error);
+        }
+        return info;
+    }
+    /**
+     * Handle export declarations (export { x }, export * from, etc.)
+     */
+    handleExportDeclaration(node, info) {
+        // export * from "./module" or export { x } from "./module"
+        if (node.moduleSpecifier && ts.isStringLiteral(node.moduleSpecifier)) {
+            const modulePath = node.moduleSpecifier.text;
+            // If it's export *, track it as a re-export
+            if (!node.exportClause) {
+                // export * from "./module"
+                info.reExports.push(modulePath);
+            }
+            else if (ts.isNamedExports(node.exportClause)) {
+                // export { x, y } from "./module"
+                // These are also re-exports, but we can extract the names
+                for (const element of node.exportClause.elements) {
+                    const exportName = element.name.text;
+                    info.namedExports.push(exportName);
+                }
+            }
+        }
+        // export { x, y } (without from)
+        else if (node.exportClause && ts.isNamedExports(node.exportClause)) {
+            for (const element of node.exportClause.elements) {
+                const exportName = element.name.text;
+                info.namedExports.push(exportName);
+            }
+        }
+    }
+    /**
+     * Handle variable statements (export const x = ...)
+     */
+    handleVariableStatement(node, info) {
+        if (this.hasExportModifier(node)) {
+            for (const declaration of node.declarationList.declarations) {
+                if (ts.isIdentifier(declaration.name)) {
+                    info.namedExports.push(declaration.name.text);
+                }
+            }
+        }
+    }
+    /**
+     * Handle function declarations (export function x() {})
+     */
+    handleFunctionDeclaration(node, info) {
+        if (this.hasExportModifier(node)) {
+            if (this.hasDefaultModifier(node)) {
+                info.hasDefaultExport = true;
+            }
+            else if (node.name) {
+                info.namedExports.push(node.name.text);
+            }
+        }
+    }
+    /**
+     * Handle class declarations (export class X {})
+     */
+    handleClassDeclaration(node, info) {
+        if (this.hasExportModifier(node)) {
+            if (this.hasDefaultModifier(node)) {
+                info.hasDefaultExport = true;
+            }
+            else if (node.name) {
+                info.namedExports.push(node.name.text);
+            }
+        }
+    }
+    /**
+     * Handle enum declarations (export enum X {})
+     * Enums exist at runtime, so they should be included
+     */
+    handleEnumDeclaration(node, info) {
+        if (this.hasExportModifier(node)) {
+            info.namedExports.push(node.name.text);
+        }
+    }
+    /**
+     * Check if a node has an export modifier
+     */
+    hasExportModifier(node) {
+        return (ts.canHaveModifiers(node) &&
+            ts.getModifiers(node)?.some((mod) => mod.kind === ts.SyntaxKind.ExportKeyword) === true);
+    }
+    /**
+     * Check if a node has a default modifier
+     */
+    hasDefaultModifier(node) {
+        return (ts.canHaveModifiers(node) &&
+            ts.getModifiers(node)?.some((mod) => mod.kind === ts.SyntaxKind.DefaultKeyword) === true);
+    }
+    /**
+     * Clear cache for a specific file
+     * @param relativePath Relative path to the file
+     */
+    clearCache(relativePath) {
+        this.cache.delete(relativePath);
+    }
+    /**
+     * Clear all cached export information
+     */
+    clearAllCache() {
+        this.cache.clear();
+    }
+    /**
+     * Get cache statistics
+     */
+    getCacheStats() {
+        return {
+            size: this.cache.size,
+            files: Array.from(this.cache.keys()),
+        };
+    }
+}
+// Singleton instance
+const exportAnalyzer = new ExportAnalyzer();export{ExportAnalyzer,exportAnalyzer};//# sourceMappingURL=export-analyzer.js.map

package/esm/dev-server/export-analyzer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"export-analyzer.js","sources":["../../src/dev-server/export-analyzer.ts"],"sourcesContent":[null],"names":[],"mappings":"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"}

package/esm/dev-server/file-event-handler.d.ts

@@ -0,0 +1,156 @@
+import type { DependencyGraph } from "./dependency-graph";
+import type { FileManager } from "./file-manager";
+import type { FileOperations } from "./file-operations";
+import type { ManifestManager } from "./manifest-manager";
+/**
+ * FileEventHandler - Handles runtime file system events
+ *
+ * This class receives file system events (add, change, delete) from the
+ * FilesWatcher and processes them in batches for optimal performance.
+ *
+ * ## Batching Strategy
+ *
+ * Events are collected and processed after a debounce period (150ms).
+ * This batching is crucial when:
+ * - Multiple files are created at once (e.g., VSCode extension creating a module)
+ * - A file save triggers multiple filesystem events
+ * - Large refactoring operations affect many files
+ *
+ * ## Processing Order
+ *
+ * 1. **Added files** - Processed first so they're available for imports
+ * 2. **Changed files** - Can reference newly added files
+ * 3. **Deleted files** - Processed last, dependents are notified
+ *
+ * ## Batch Add Strategy
+ *
+ * When multiple files are added (e.g., creating a Warlock module), they're
+ * processed using a two-phase approach with topological sorting:
+ *
+ * 1. **Parse Phase**: All files are parsed to discover dependencies
+ * 2. **Sort Phase**: Files are topologically sorted by dependencies
+ * 3. **Complete Phase**: Files are finalized in dependency order
+ *
+ * This ensures that when file A imports file B, file B is processed first.
+ *
+ * @class FileEventHandler
+ */
+export declare class FileEventHandler {
+    private readonly fileOperations;
+    private readonly manifest;
+    private readonly dependencyGraph;
+    private readonly files;
+    /**
+     * Pending file change events (relative paths)
+     */
+    private pendingChanges;
+    /**
+     * Pending file add events (relative paths)
+     */
+    private pendingAdds;
+    /**
+     * Pending file delete events (relative paths)
+     */
+    private pendingDeletes;
+    /**
+     * Debounced batch processor
+     * Waits 150ms after the last event before processing
+     */
+    private readonly processPendingEvents;
+    /**
+     * Creates a new FileEventHandler
+     *
+     * @param fileOperations - FileOperations instance for file lifecycle management
+     * @param manifest - ManifestManager for persisting file metadata
+     * @param dependencyGraph - DependencyGraph for tracking dependencies
+     * @param files - Map of all tracked FileManager instances
+     */
+    constructor(fileOperations: FileOperations, manifest: ManifestManager, dependencyGraph: DependencyGraph, files: Map<string, FileManager>);
+    /**
+     * Handle a file change event from the file watcher
+     *
+     * The event is queued and will be processed in the next batch.
+     *
+     * @param absolutePath - Absolute path to the changed file
+     */
+    handleFileChange(absolutePath: string): void;
+    /**
+     * Handle a file add event from the file watcher
+     *
+     * The event is queued and will be processed in the next batch.
+     *
+     * @param absolutePath - Absolute path to the new file
+     */
+    handleFileAdd(absolutePath: string): void;
+    /**
+     * Handle a file delete event from the file watcher
+     *
+     * The event is queued and will be processed in the next batch.
+     *
+     * @param absolutePath - Absolute path to the deleted file
+     */
+    handleFileDelete(absolutePath: string): void;
+    /**
+     * Process all pending events in a batch
+     *
+     * Events are processed in order: adds → changes → deletes
+     * After processing, the dependency graph and manifest are updated.
+     *
+     * @internal
+     */
+    private processBatch;
+    /**
+     * Process a batch of changed files
+     *
+     * Each file is updated (reprocessed if content changed).
+     * Processing is done in parallel batches for performance.
+     *
+     * @param relativePaths - Array of relative paths to changed files
+     * @internal
+     */
+    private processBatchChanges;
+    /**
+     * Process a batch of added files using topological sort
+     *
+     * This method uses a two-phase approach:
+     * 1. Parse all files to discover dependencies
+     * 2. Complete files in topological order (dependencies first)
+     *
+     * This ensures that when file A imports file B (both in the batch),
+     * file B is fully processed before file A tries to resolve the import.
+     *
+     * @param relativePaths - Array of relative paths to new files
+     * @internal
+     */
+    private processBatchAdds;
+    /**
+     * Topologically sort files by their dependencies
+     *
+     * Uses Kahn's algorithm to produce an ordering where files with
+     * no batch dependencies come first, and files that depend on other
+     * batch files come after their dependencies.
+     *
+     * @param files - Array of FileManager instances to sort
+     * @param batchSet - Set of relative paths in this batch (for filtering deps)
+     * @returns Files in topological order (dependencies first)
+     *
+     * @example
+     * ```typescript
+     * // If A imports B, and B imports C, result will be: [C, B, A]
+     * const ordered = this.topologicalSort([fileA, fileB, fileC], batchSet);
+     * ```
+     *
+     * @internal
+     */
+    private topologicalSort;
+    /**
+     * Process a batch of deleted files
+     *
+     * Each file is removed from the system and its dependents are notified.
+     *
+     * @param relativePaths - Array of relative paths to deleted files
+     * @internal
+     */
+    private processBatchDeletes;
+}
+//# sourceMappingURL=file-event-handler.d.ts.map

package/esm/dev-server/file-event-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-event-handler.d.ts","sourceRoot":"","sources":["../../src/dev-server/file-event-handler.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAE1D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAClD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAExD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAI1D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,qBAAa,gBAAgB;IAiCzB,OAAO,CAAC,QAAQ,CAAC,cAAc;IAC/B,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,eAAe;IAChC,OAAO,CAAC,QAAQ,CAAC,KAAK;IAnCxB;;OAEG;IACH,OAAO,CAAC,cAAc,CAAqB;IAE3C;;OAEG;IACH,OAAO,CAAC,WAAW,CAAqB;IAExC;;OAEG;IACH,OAAO,CAAC,cAAc,CAAqB;IAE3C;;;OAGG;IACH,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAE7B;IAER;;;;;;;OAOG;gBAEgB,cAAc,EAAE,cAAc,EAC9B,QAAQ,EAAE,eAAe,EACzB,eAAe,EAAE,eAAe,EAChC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC;IAGlD;;;;;;OAMG;IACI,gBAAgB,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI;IAMnD;;;;;;OAMG;IACI,aAAa,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI;IAMhD;;;;;;OAMG;IACI,gBAAgB,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI;IAMnD;;;;;;;OAOG;YACW,YAAY;IAoD1B;;;;;;;;OAQG;YACW,mBAAmB;IAgBjC;;;;;;;;;;;;OAYG;YACW,gBAAgB;IAkC9B;;;;;;;;;;;;;;;;;;OAkBG;IACH,OAAO,CAAC,eAAe;IA8DvB;;;;;;;OAOG;YACW,mBAAmB;CAQlC"}

package/esm/dev-server/file-event-handler.js

@@ -0,0 +1,309 @@
+import events from'@mongez/events';import {debounce}from'@mongez/reinforcements';import {devLogSuccess}from'./dev-logger.js';import {FILE_PROCESSING_BATCH_SIZE}from'./flags.js';import {clearFileExistsCache}from'./parse-imports.js';import {Path}from'./path.js';/**
+ * FileEventHandler - Handles runtime file system events
+ *
+ * This class receives file system events (add, change, delete) from the
+ * FilesWatcher and processes them in batches for optimal performance.
+ *
+ * ## Batching Strategy
+ *
+ * Events are collected and processed after a debounce period (150ms).
+ * This batching is crucial when:
+ * - Multiple files are created at once (e.g., VSCode extension creating a module)
+ * - A file save triggers multiple filesystem events
+ * - Large refactoring operations affect many files
+ *
+ * ## Processing Order
+ *
+ * 1. **Added files** - Processed first so they're available for imports
+ * 2. **Changed files** - Can reference newly added files
+ * 3. **Deleted files** - Processed last, dependents are notified
+ *
+ * ## Batch Add Strategy
+ *
+ * When multiple files are added (e.g., creating a Warlock module), they're
+ * processed using a two-phase approach with topological sorting:
+ *
+ * 1. **Parse Phase**: All files are parsed to discover dependencies
+ * 2. **Sort Phase**: Files are topologically sorted by dependencies
+ * 3. **Complete Phase**: Files are finalized in dependency order
+ *
+ * This ensures that when file A imports file B, file B is processed first.
+ *
+ * @class FileEventHandler
+ */
+class FileEventHandler {
+    fileOperations;
+    manifest;
+    dependencyGraph;
+    files;
+    /**
+     * Pending file change events (relative paths)
+     */
+    pendingChanges = new Set();
+    /**
+     * Pending file add events (relative paths)
+     */
+    pendingAdds = new Set();
+    /**
+     * Pending file delete events (relative paths)
+     */
+    pendingDeletes = new Set();
+    /**
+     * Debounced batch processor
+     * Waits 150ms after the last event before processing
+     */
+    processPendingEvents = debounce(async () => {
+        await this.processBatch();
+    }, 150);
+    /**
+     * Creates a new FileEventHandler
+     *
+     * @param fileOperations - FileOperations instance for file lifecycle management
+     * @param manifest - ManifestManager for persisting file metadata
+     * @param dependencyGraph - DependencyGraph for tracking dependencies
+     * @param files - Map of all tracked FileManager instances
+     */
+    constructor(fileOperations, manifest, dependencyGraph, files) {
+        this.fileOperations = fileOperations;
+        this.manifest = manifest;
+        this.dependencyGraph = dependencyGraph;
+        this.files = files;
+    }
+    /**
+     * Handle a file change event from the file watcher
+     *
+     * The event is queued and will be processed in the next batch.
+     *
+     * @param absolutePath - Absolute path to the changed file
+     */
+    handleFileChange(absolutePath) {
+        const relativePath = Path.toRelative(absolutePath);
+        this.pendingChanges.add(relativePath);
+        this.processPendingEvents();
+    }
+    /**
+     * Handle a file add event from the file watcher
+     *
+     * The event is queued and will be processed in the next batch.
+     *
+     * @param absolutePath - Absolute path to the new file
+     */
+    handleFileAdd(absolutePath) {
+        const relativePath = Path.toRelative(absolutePath);
+        this.pendingAdds.add(relativePath);
+        this.processPendingEvents();
+    }
+    /**
+     * Handle a file delete event from the file watcher
+     *
+     * The event is queued and will be processed in the next batch.
+     *
+     * @param absolutePath - Absolute path to the deleted file
+     */
+    handleFileDelete(absolutePath) {
+        const relativePath = Path.toRelative(absolutePath);
+        this.pendingDeletes.add(relativePath);
+        this.processPendingEvents();
+    }
+    /**
+     * Process all pending events in a batch
+     *
+     * Events are processed in order: adds → changes → deletes
+     * After processing, the dependency graph and manifest are updated.
+     *
+     * @internal
+     */
+    async processBatch() {
+        // Snapshot pending events
+        const changes = Array.from(this.pendingChanges);
+        const adds = Array.from(this.pendingAdds);
+        const deletes = Array.from(this.pendingDeletes);
+        // Clear pending sets
+        this.pendingChanges.clear();
+        this.pendingAdds.clear();
+        this.pendingDeletes.clear();
+        // Skip if nothing to process
+        if (changes.length === 0 && adds.length === 0 && deletes.length === 0) {
+            return;
+        }
+        // Separate .env files from code files
+        // .env files don't need transpilation but still trigger HMR
+        const isEnvFile = (path) => {
+            const basename = path.split("/").pop() || path;
+            return basename === ".env" || basename.startsWith(".env.");
+        };
+        const codeChanges = changes.filter((p) => !isEnvFile(p));
+        const codeAdds = adds.filter((p) => !isEnvFile(p));
+        // For batch operations, add extra delay to let filesystem settle
+        const totalFiles = codeAdds.length + codeChanges.length;
+        if (totalFiles > 1) {
+            await new Promise((resolve) => setTimeout(resolve, 500));
+            clearFileExistsCache();
+        }
+        // Process code files only (env files don't need transpilation)
+        await this.processBatchAdds(codeAdds);
+        await this.processBatchChanges(codeChanges);
+        await this.processBatchDeletes(deletes);
+        // Update dependency graph and manifest once
+        this.fileOperations.updateFileDependents();
+        this.fileOperations.syncFilesToManifest();
+        await this.manifest.save();
+        // Trigger batch completion event (for HMR/reload execution)
+        // Include ALL changes (including .env) so config reload is triggered
+        events.trigger("dev-server:batch-complete", {
+            added: adds,
+            changed: changes,
+            deleted: deletes,
+        });
+    }
+    /**
+     * Process a batch of changed files
+     *
+     * Each file is updated (reprocessed if content changed).
+     * Processing is done in parallel batches for performance.
+     *
+     * @param relativePaths - Array of relative paths to changed files
+     * @internal
+     */
+    async processBatchChanges(relativePaths) {
+        if (relativePaths.length === 0)
+            return;
+        const BATCH_SIZE = FILE_PROCESSING_BATCH_SIZE;
+        for (let i = 0; i < relativePaths.length; i += BATCH_SIZE) {
+            const batch = relativePaths.slice(i, i + BATCH_SIZE);
+            await Promise.all(batch.map(async (relativePath) => {
+                await this.fileOperations.updateFile(relativePath);
+            }));
+        }
+    }
+    /**
+     * Process a batch of added files using topological sort
+     *
+     * This method uses a two-phase approach:
+     * 1. Parse all files to discover dependencies
+     * 2. Complete files in topological order (dependencies first)
+     *
+     * This ensures that when file A imports file B (both in the batch),
+     * file B is fully processed before file A tries to resolve the import.
+     *
+     * @param relativePaths - Array of relative paths to new files
+     * @internal
+     */
+    async processBatchAdds(relativePaths) {
+        if (relativePaths.length === 0)
+            return;
+        const batchSet = new Set(relativePaths);
+        // PHASE 1: Parse all files in parallel to discover dependencies
+        const parsedFiles = await Promise.all(relativePaths.map(async (relativePath) => {
+            try {
+                return await this.fileOperations.parseNewFile(relativePath);
+            }
+            catch (error) {
+                return null;
+            }
+        }));
+        // Filter out nulls (files that couldn't be parsed)
+        const validFiles = parsedFiles.filter((f) => f !== null);
+        // PHASE 2: Topological sort for proper dependency order
+        const orderedFiles = this.topologicalSort(validFiles, batchSet);
+        // PHASE 3: Complete processing in dependency order
+        for (const file of orderedFiles) {
+            try {
+                await this.fileOperations.finalizeNewFile(file);
+                devLogSuccess(`Added file: ${file.relativePath}`);
+            }
+            catch (error) {
+                // File may have issues, but we continue with others
+                console.error(`Failed to add file ${file.relativePath}:`, error);
+            }
+        }
+    }
+    /**
+     * Topologically sort files by their dependencies
+     *
+     * Uses Kahn's algorithm to produce an ordering where files with
+     * no batch dependencies come first, and files that depend on other
+     * batch files come after their dependencies.
+     *
+     * @param files - Array of FileManager instances to sort
+     * @param batchSet - Set of relative paths in this batch (for filtering deps)
+     * @returns Files in topological order (dependencies first)
+     *
+     * @example
+     * ```typescript
+     * // If A imports B, and B imports C, result will be: [C, B, A]
+     * const ordered = this.topologicalSort([fileA, fileB, fileC], batchSet);
+     * ```
+     *
+     * @internal
+     */
+    topologicalSort(files, batchSet) {
+        const fileMap = new Map();
+        const inDegree = new Map();
+        const graph = new Map();
+        // Initialize data structures
+        for (const file of files) {
+            fileMap.set(file.relativePath, file);
+            inDegree.set(file.relativePath, 0);
+            graph.set(file.relativePath, []);
+        }
+        // Build graph: for each file, record which files depend on it
+        for (const file of files) {
+            for (const dep of file.dependencies) {
+                // Only consider dependencies that are in this batch
+                if (batchSet.has(dep) && fileMap.has(dep)) {
+                    // dep → file (file depends on dep)
+                    graph.get(dep).push(file.relativePath);
+                    inDegree.set(file.relativePath, (inDegree.get(file.relativePath) || 0) + 1);
+                }
+            }
+        }
+        // Kahn's algorithm: start with files that have no batch dependencies
+        const queue = [];
+        for (const file of files) {
+            if (inDegree.get(file.relativePath) === 0) {
+                queue.push(file);
+            }
+        }
+        const result = [];
+        while (queue.length > 0) {
+            const file = queue.shift();
+            result.push(file);
+            // For each file that depends on this one, reduce its in-degree
+            for (const dependentPath of graph.get(file.relativePath) || []) {
+                const newDegree = (inDegree.get(dependentPath) || 0) - 1;
+                inDegree.set(dependentPath, newDegree);
+                if (newDegree === 0) {
+                    const dependentFile = fileMap.get(dependentPath);
+                    if (dependentFile) {
+                        queue.push(dependentFile);
+                    }
+                }
+            }
+        }
+        // Handle any remaining files (cycles or isolated)
+        // These are added at the end to ensure all files are processed
+        for (const file of files) {
+            if (!result.includes(file)) {
+                result.push(file);
+            }
+        }
+        return result;
+    }
+    /**
+     * Process a batch of deleted files
+     *
+     * Each file is removed from the system and its dependents are notified.
+     *
+     * @param relativePaths - Array of relative paths to deleted files
+     * @internal
+     */
+    async processBatchDeletes(relativePaths) {
+        if (relativePaths.length === 0)
+            return;
+        for (const relativePath of relativePaths) {
+            await this.fileOperations.deleteFile(relativePath);
+            devLogSuccess(`Deleted file: ${relativePath}`);
+        }
+    }
+}export{FileEventHandler};//# sourceMappingURL=file-event-handler.js.map