@psnext/lscg 0.1.3 → 0.1.5

package/dist/src/view/templates/interactive.html

@@ -38,6 +38,18 @@
             </select>
           </label>
         </div>
+        <div class="section">
+          <label>
+            <span class="status">Layout</span>
+            <select id="layout-select">
+              <option value="force">Force-directed</option>
+              <option value="radial">Radial</option>
+              <option value="grid">Grid</option>
+              <option value="kind">By kind</option>
+              <option value="treemap">Treemap</option>
+            </select>
+          </label>
+        </div>
         <div class="section">
           <label>
             <span class="status">View box zoom</span>
@@ -68,12 +80,14 @@
 
       const data = {{DATA}};
       let display = data.display ?? 'shape';
+      let layoutMode = 'force';
       const app = document.getElementById('app');
       const svg = d3.select('#graph');
       const graphPanel = document.querySelector('.graph-panel');
       const tooltip = document.getElementById('tooltip');
       const searchInput = document.getElementById('search');
       const displaySelect = document.getElementById('display-select');
+      const layoutSelect = document.getElementById('layout-select');
       const zoomInput = document.getElementById('zoom');
       const zoomValue = document.getElementById('zoom-value');
       const zoomAllButton = document.getElementById('zoom-all');
@@ -240,31 +254,52 @@
         .force('x', d3.forceX(width / 2).strength(0.05))
         .force('y', d3.forceY(height / 2).strength(0.05));
 
-      const links = linkLayer.selectAll('line')
-        .data(linksData)
-        .join('line')
-        .attr('class', (d) => 'edge edge--' + d.kind)
-        .attr('marker-end', 'url(#arrow)');
-
-      const nodes = nodeLayer.selectAll('g')
-        .data(nodesData)
-        .join('g')
-        .attr('class', (d) => 'node node--' + d.kind)
-        .call(drag(simulation));
+      let links = linkLayer.selectAll('line');
+      let nodes = nodeLayer.selectAll('g');
 
-      nodeLayer.raise();
-
-      nodes.each(function(d) {
-        const group = d3.select(this);
-        appendNodeShape(group, d);
+      function renderNode(group, node) {
+        appendNodeShape(group, node);
+        group.append('title').text(node.label);
         group.append('text')
           .attr('class', 'node-label')
           .attr('text-anchor', 'middle')
-          .attr('dominant-baseline', display === 'shape' && d.kind === 'file' ? 'middle' : 'hanging')
-          .attr('y', display === 'shape' && d.kind === 'file' ? 0 : (d.height / 2) + 14)
-          .text(d.label);
-        group.append('title').text(d.label);
-      });
+          .attr('dominant-baseline', display === 'shape' && node.kind === 'file' ? 'middle' : 'hanging')
+          .attr('y', display === 'shape' && node.kind === 'file' ? 0 : (node.height / 2) + 14)
+          .text(node.label);
+      }
+
+      function renderGraph(visibleNodeIds, visibleEdgeIds) {
+        links = linkLayer.selectAll('line')
+          .data(linksData.filter((edge) => visibleEdgeIds.has(edge.id)), (edge) => edge.id)
+          .join(
+            (enter) => enter.append('line'),
+            (update) => update,
+            (exit) => exit.remove()
+          )
+          .attr('class', (d) => 'edge edge--' + d.kind)
+          .attr('marker-end', 'url(#arrow)');
+
+        nodes = nodeLayer.selectAll('g')
+          .data(nodesData.filter((node) => visibleNodeIds.has(node.id)), (node) => node.id)
+          .join(
+            (enter) => {
+              const selection = enter.append('g')
+                .attr('class', (d) => 'node node--' + d.kind)
+              if (layoutMode === 'force') 
+                selection.call(drag(simulation));
+              
+              selection.each(function(node) {
+                renderNode(d3.select(this), node);
+              });
+              return selection;
+            },
+            (update) => update,
+            (exit) => exit.remove()
+          );
+
+        nodeLayer.raise();
+        bindNodeInteractions();
+      }
 
       function updateDisplay() {
         nodes.each(function(d) {
@@ -273,7 +308,8 @@
           appendNodeShape(group, d);
           group.select('.node-label')
             .attr('dominant-baseline', display === 'shape' && d.kind === 'file' ? 'middle' : 'hanging')
-            .attr('y', display === 'shape' && d.kind === 'file' ? 0 : (d.height / 2) + 14);
+            .attr('y', display === 'shape' && d.kind === 'file' ? 0 : (d.height / 2) + 14)
+            .raise();
         });
       }
 
@@ -361,6 +397,74 @@
         return typeof endpoint === 'string' ? endpoint : endpoint?.id;
       }
 
+      function applyLayout(visibleNodeIds) {
+        if (layoutMode === 'force') {
+          for (const node of nodesData) {
+            node.fx = null;
+            node.fy = null;
+          }
+          simulation.alpha(0.8).restart();
+          return;
+        }
+
+        simulation.stop();
+        const visibleNodes = nodesData.filter((node) => visibleNodeIds.has(node.id));
+        const { width: canvasWidth, height: canvasHeight } = canvasSize();
+        const centerX = canvasWidth / 2;
+        const centerY = canvasHeight / 2;
+        const padding = 80;
+        const radius = Math.max(40, Math.min(canvasWidth, canvasHeight) / 2 - padding);
+        const columns = Math.max(1, Math.ceil(Math.sqrt(visibleNodes.length)));
+        const rows = Math.max(1, Math.ceil(visibleNodes.length / columns));
+
+        const orderedNodes = layoutMode === 'kind'
+          ? [...visibleNodes].sort((left, right) => left.kind.localeCompare(right.kind) || left.label.localeCompare(right.label))
+          : visibleNodes;
+        const treemapRoot = layoutMode === 'treemap'
+          ? d3.treemap().size([canvasWidth - padding * 2, canvasHeight - padding * 2]).paddingInner(12)(
+              d3.hierarchy({ children: visibleNodes }).sum((node) => node.degree ? Math.max(1, node.degree + 1) : 1)
+            )
+          : null;
+
+        orderedNodes.forEach((node, index) => {
+          let x = centerX;
+          let y = centerY;
+          if (layoutMode === 'treemap') {
+            const tile = treemapRoot?.leaves().find((leaf) => leaf.data === node);
+            x = padding + ((tile?.x0 ?? 0) + (tile?.x1 ?? 0)) / 2;
+            y = padding + ((tile?.y0 ?? 0) + (tile?.y1 ?? 0)) / 2;
+          } else if (layoutMode === 'radial') {
+            const angle = (index * Math.PI * 2) / Math.max(visibleNodes.length, 1) - Math.PI / 2;
+            x = centerX + Math.cos(angle) * radius;
+            y = centerY + Math.sin(angle) * radius;
+          } else {
+            const kindIndex = layoutMode === 'kind'
+              ? orderedNodes.slice(0, index).filter((candidate) => candidate.kind === node.kind).length
+              : index;
+            const kindCount = layoutMode === 'kind'
+              ? orderedNodes.filter((candidate) => candidate.kind === node.kind).length
+              : visibleNodes.length;
+            const kindColumn = layoutMode === 'kind'
+              ? [...new Set(orderedNodes.map((candidate) => candidate.kind))].indexOf(node.kind)
+              : 0;
+            const kindColumns = layoutMode === 'kind'
+              ? Math.max(1, new Set(orderedNodes.map((candidate) => candidate.kind)).size)
+              : columns;
+            const localColumns = layoutMode === 'kind' ? Math.max(1, Math.ceil(Math.sqrt(kindCount))) : columns;
+            const localRows = layoutMode === 'kind' ? Math.max(1, Math.ceil(kindCount / localColumns)) : rows;
+            const column = layoutMode === 'kind' ? kindIndex % localColumns : index % columns;
+            const row = layoutMode === 'kind' ? Math.floor(kindIndex / localColumns) : Math.floor(index / columns);
+            x = layoutMode === 'kind'
+              ? ((kindColumn + 0.5) * canvasWidth) / kindColumns
+              : ((column + 1) * canvasWidth) / (columns + 1);
+            y = ((row + 1) * canvasHeight) / (localRows + 1);
+          }
+          node.x = node.fx = x;
+          node.y = node.fy = y;
+        });
+        ticked();
+      }
+
       function updateStatus() {
         if (anchorId && focusVisibleOnly) {
           subtitle.textContent = 'Focus on ' + (nodeById.get(anchorId)?.label ?? anchorId);
@@ -416,16 +520,17 @@
         const visibleEdgeIds = visibleSets.visibleEdgeIds;
         const activeAnchorVisible = Boolean(anchorId && visibleNodeIds.has(anchorId));
 
+        renderGraph(visibleNodeIds, visibleEdgeIds);
+        applyLayout(visibleNodeIds);
+
         nodes
-          .classed('is-hidden', (node) => !visibleNodeIds.has(node.id))
-          .classed('is-dimmed', (node) => !focusVisibleOnly && anchorId ? !visibleNodeIds.has(node.id) : false)
+          .classed('is-dimmed', () => false)
           .classed('is-selected', (node) => anchorId === node.id)
           .classed('is-highlighted', (node) => activeAnchorVisible && visibleNodeIds.has(node.id));
 
         links
-          .classed('is-hidden', (edge) => !visibleEdgeIds.has(edge.id))
-          .classed('is-dimmed', (edge) => !focusVisibleOnly && anchorId ? !visibleEdgeIds.has(edge.id) : false)
-          .classed('is-highlighted', (edge) => visibleEdgeIds.has(edge.id));
+          .classed('is-dimmed', () => false)
+          .classed('is-highlighted', () => true);
 
         updateStatus();
         updateInfo();
@@ -554,25 +659,27 @@
         nodes.attr('transform', (d) => 'translate(' + d.x + ',' + d.y + ')');
       }
 
-      nodes
-        .on('click', (event, node) => {
-          event.stopPropagation();
-          setAnchor(node.id);
-        })
-        .on('mouseenter', function(event, node) {
-          if (!tooltip) return;
-          tooltip.style.display = 'block';
-          tooltip.textContent = node.label + ' · ' + node.kind;
-        })
-        .on('mousemove', function(event) {
-          if (!tooltip) return;
-          tooltip.style.left = event.clientX + 14 + 'px';
-          tooltip.style.top = event.clientY + 14 + 'px';
-        })
-        .on('mouseleave', function() {
-          if (!tooltip) return;
-          tooltip.style.display = 'none';
-        });
+      function bindNodeInteractions() {
+        nodes
+          .on('click', (event, node) => {
+            event.stopPropagation();
+            setAnchor(node.id);
+          })
+          .on('mouseenter', function(event, node) {
+            if (!tooltip) return;
+            tooltip.style.display = 'block';
+            tooltip.textContent = node.label + ' · ' + node.kind;
+          })
+          .on('mousemove', function(event) {
+            if (!tooltip) return;
+            tooltip.style.left = event.clientX + 14 + 'px';
+            tooltip.style.top = event.clientY + 14 + 'px';
+          })
+          .on('mouseleave', function() {
+            if (!tooltip) return;
+            tooltip.style.display = 'none';
+          });
+      }
 
       svg.on('click', (event) => {
         if (event.target === svg.node()) {
@@ -589,6 +696,13 @@
         updateDisplay();
       });
 
+      layoutSelect?.addEventListener('change', (event) => {
+        const value = event.target instanceof HTMLSelectElement ? event.target.value : 'force';
+        if (value !== 'force' && value !== 'radial' && value !== 'grid' && value !== 'kind' && value !== 'treemap') return;
+        layoutMode = value;
+        applyState();
+      });
+
       searchInput.value = filterText;
       searchInput.addEventListener('input', (event) => {
         filterText = event.target.value;

package/dist/src/watch.d.ts

@@ -1,9 +1,10 @@
-import { scanRepository } from './graph/repository.js';
-import type { RepositoryRecord, StorageScope } from './types.js';
+import { drainRepositoryEnrichment, scanRepository } from './graph/repository.js';
+import type { EnrichmentSummary, ProgressReporter, RepositoryRecord, StorageScope } from './types.js';
 export interface WatchCommandOptions {
     root?: string | undefined;
     scope?: StorageScope | 'both' | undefined;
     intervalMs?: number | undefined;
+    debounceMs?: number | undefined;
 }
 export interface WatchSummary {
     filesDiscovered: number;
@@ -11,6 +12,7 @@ export interface WatchSummary {
     nodesWritten: number;
     edgesWritten: number;
     skippedCount: number;
+    enrichment: EnrichmentSummary;
 }
 export interface WatchEvent {
     event: 'watching' | 'scan' | 'waiting' | 'rescan-triggered' | 'stopped';
@@ -22,13 +24,26 @@ export interface WatchEvent {
     summary?: WatchSummary | undefined;
     scans?: number | undefined;
 }
+export type FileSystemWatchEvent = 'change' | 'rename';
+export type FileSystemWatchListener = (event: FileSystemWatchEvent, filename: string | Buffer | null) => void;
+/** Minimal fs.watch surface so watch behavior can be tested without the filesystem. */
+export interface FileSystemWatcher {
+    close(): void;
+    on(event: 'error', listener: (error: Error) => void): this;
+}
+export type FileSystemWatcherFactory = (directory: string, options: {
+    recursive: boolean;
+}, listener: FileSystemWatchListener) => FileSystemWatcher;
 export interface WatchDependencies {
     scanRepository?: typeof scanRepository | undefined;
+    drainEnrichment?: typeof drainRepositoryEnrichment | undefined;
     fingerprint?: ((root: string) => Promise<string> | string) | undefined;
+    watcherFactory?: FileSystemWatcherFactory | undefined;
     emit?: ((event: WatchEvent) => void) | undefined;
     wait?: ((ms: number, signal?: AbortSignal) => Promise<void>) | undefined;
     signal?: AbortSignal | undefined;
     mode?: 'watch' | 'scan --watch' | undefined;
+    progress?: ProgressReporter | undefined;
 }
 export interface WatchRunResult {
     repository: RepositoryRecord;

package/dist/src/watch.js

@@ -1,30 +1,115 @@
+import { readdirSync, watch as watchFileSystem } from 'node:fs';
+import path from 'node:path';
 import { setTimeout as sleep } from 'node:timers/promises';
-import { repositoryForRoot, scanRepository } from './graph/repository.js';
+import { drainRepositoryEnrichment, repositoryForRoot, scanRepository } from './graph/repository.js';
 import { collectRepositoryFingerprint } from './scanner/fingerprint.js';
+import { discoverSourceFiles } from './scanner/discover.js';
+import { isSupportedSourceFile } from './parser/treeSitter.js';
 const DEFAULT_POLL_INTERVAL_MS = 1000;
+const DEFAULT_DEBOUNCE_MS = 100;
+const IGNORED_WATCH_DIRECTORIES = new Set(['.git', 'node_modules', 'dist', 'coverage', '.next', '.turbo', '.cache', '.sling']);
 export async function watchRepository(options = {}, dependencies = {}) {
     const scope = resolveWatchScope(options.scope);
     const repository = repositoryForRoot(options.root);
     const scanFn = dependencies.scanRepository ?? scanRepository;
+    const drainEnrichment = dependencies.drainEnrichment ?? drainRepositoryEnrichment;
     const fingerprintFn = dependencies.fingerprint ?? ((root) => collectRepositoryFingerprint(root));
+    const watcherFactory = dependencies.watcherFactory ?? defaultWatcherFactory;
     const emit = dependencies.emit ?? defaultEmit;
     const wait = dependencies.wait ?? defaultWait;
     const signal = dependencies.signal;
     const mode = dependencies.mode ?? 'watch';
+    const progress = dependencies.progress;
     const intervalMs = options.intervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+    const debounceMs = options.debounceMs ?? DEFAULT_DEBOUNCE_MS;
     let scans = 0;
     let stopped = false;
-    let currentFingerprint = await fingerprintFn(repository.root);
-    emit({
-        event: 'watching',
-        mode,
-        repository,
-        scope
-    });
+    let scanning = false;
+    let polling = false;
+    let currentFingerprint;
+    let followUpQueued = false;
+    let pendingEventPaths = new Set();
+    let failed = false;
+    let wakeWaiting;
+    const watchers = [];
+    const wake = () => {
+        const resolve = wakeWaiting;
+        wakeWaiting = undefined;
+        resolve?.();
+    };
+    const queueReconciliation = () => {
+        if (scanning) {
+            followUpQueued = true;
+        }
+        else {
+            pendingEventPaths.add('');
+        }
+        wake();
+    };
+    const usePollingFallback = () => {
+        if (polling)
+            return;
+        polling = true;
+        currentFingerprint = undefined;
+        closeWatchers(watchers);
+        reportWatchProgress(progress, { event: 'polling-fallback', mode, repository, scope, detail: 'filesystem watcher unavailable; polling fallback enabled' });
+        queueReconciliation();
+    };
+    const handleWatchEvent = (watchedDirectory, event, filename) => {
+        if (event === 'rename' || filename === null) {
+            usePollingFallback();
+            return;
+        }
+        const relativePath = relevantWatchPath(repository.root, watchedDirectory, filename);
+        if (!relativePath)
+            return;
+        pendingEventPaths.add(relativePath);
+        if (scanning)
+            followUpQueued = true;
+        wake();
+    };
+    const addWatcher = (directory, recursive) => {
+        const watcher = watcherFactory(directory, { recursive }, (event, filename) => handleWatchEvent(directory, event, filename));
+        watcher.on('error', () => usePollingFallback());
+        watchers.push(watcher);
+    };
     try {
+        try {
+            addWatcher(repository.root, true);
+        }
+        catch {
+            closeWatchers(watchers);
+            try {
+                for (const directory of watchDirectories(repository.root)) {
+                    addWatcher(directory, false);
+                }
+            }
+            catch {
+                closeWatchers(watchers);
+                polling = true;
+                reportWatchProgress(progress, { event: 'polling-fallback', mode, repository, scope, detail: 'filesystem watcher unavailable; polling fallback enabled' });
+            }
+        }
+        emit({
+            event: 'watching',
+            mode,
+            repository,
+            scope
+        });
+        reportWatchProgress(progress, { event: 'watching', mode, repository, scope, detail: 'watch session started' });
         while (!signal?.aborted) {
-            const scanStartFingerprint = currentFingerprint;
-            const summary = await scanFn({ root: repository.root, scope });
+            scanning = true;
+            const phase = scans === 0 ? 'initial-scan' : 'rescan';
+            reportWatchProgress(progress, { event: phase, mode, repository, scope, detail: scans === 0 ? 'starting initial scan' : 'starting rescan' });
+            const scanStartFingerprint = polling ? await fingerprintFn(repository.root) : undefined;
+            const structuralSummary = await scanFn({ root: repository.root, scope, progress });
+            // A watch owns in-process enrichment. Awaiting it while `scanning` is
+            // true serializes durable work with structural replacement; a filesystem
+            // event during either phase queues exactly one follow-up structural scan.
+            const enrichment = await drainEnrichment({ root: repository.root, scope });
+            reportWatchProgress(progress, { event: 'enrichment', mode, repository, scope, detail: `state=${enrichment.state} pending=${enrichment.pending} complete=${enrichment.complete} failed=${enrichment.failed}` });
+            const summary = { ...structuralSummary, enrichment };
+            scanning = false;
             scans += 1;
             emit({
                 event: 'scan',
@@ -34,44 +119,60 @@ export async function watchRepository(options = {}, dependencies = {}) {
                 scope,
                 summary: summarizeScan(summary)
             });
-            const scanEndFingerprint = await fingerprintFn(repository.root);
-            currentFingerprint = scanEndFingerprint;
+            if (polling) {
+                const scanEndFingerprint = await fingerprintFn(repository.root);
+                const changedDuringScan = scanStartFingerprint !== undefined && scanEndFingerprint !== scanStartFingerprint;
+                currentFingerprint = scanEndFingerprint;
+                if (changedDuringScan)
+                    followUpQueued = true;
+            }
             if (signal?.aborted)
                 break;
-            if (scanEndFingerprint !== scanStartFingerprint) {
-                emit({
-                    event: 'rescan-triggered',
-                    mode,
-                    reason: 'follow-up',
-                    repository,
-                    scope
-                });
+            if (followUpQueued) {
+                followUpQueued = false;
+                pendingEventPaths = new Set();
+                emitRescanTriggered('follow-up', mode, repository, scope, emit, progress);
                 continue;
             }
-            emit({
-                event: 'waiting',
-                mode,
-                repository,
-                scope
-            });
-            while (!signal?.aborted) {
-                await wait(intervalMs, signal);
-                const nextFingerprint = await fingerprintFn(repository.root);
-                if (nextFingerprint !== currentFingerprint) {
+            emit({ event: 'waiting', mode, repository, scope });
+            reportWatchProgress(progress, { event: 'waiting', mode, repository, scope, detail: polling ? 'waiting for polling interval' : 'waiting for file changes' });
+            if (polling) {
+                while (!signal?.aborted) {
+                    await wait(intervalMs, signal);
+                    const nextFingerprint = await fingerprintFn(repository.root);
+                    if (nextFingerprint === currentFingerprint)
+                        continue;
                     currentFingerprint = nextFingerprint;
-                    emit({
-                        event: 'rescan-triggered',
-                        mode,
-                        reason: 'file-change',
-                        repository,
-                        scope
-                    });
+                    emitRescanTriggered('file-change', mode, repository, scope, emit, progress);
                     break;
                 }
+                continue;
+            }
+            if (pendingEventPaths.size === 0) {
+                await waitForWatchEvent(signal, (resolve) => {
+                    wakeWaiting = resolve;
+                });
             }
+            if (signal?.aborted)
+                break;
+            if (polling)
+                continue;
+            if (pendingEventPaths.size === 0)
+                continue;
+            await wait(debounceMs, signal);
+            if (signal?.aborted)
+                break;
+            pendingEventPaths = new Set();
+            emitRescanTriggered('file-change', mode, repository, scope, emit, progress);
         }
     }
+    catch (error) {
+        failed = true;
+        reportWatchProgress(progress, { event: 'failed', mode, repository, scope, detail: error instanceof Error ? error.message : String(error) });
+        throw error;
+    }
     finally {
+        closeWatchers(watchers);
         stopped = true;
         emit({
             event: 'stopped',
@@ -80,28 +181,90 @@ export async function watchRepository(options = {}, dependencies = {}) {
             scope,
             scans
         });
+        if (!failed)
+            reportWatchProgress(progress, { event: 'stopped', mode, repository, scope, detail: `watch session stopped after ${scans} scan(s)` });
     }
-    return {
-        repository,
-        scope,
-        scans,
-        stopped
-    };
+    return { repository, scope, scans, stopped };
 }
 function resolveWatchScope(scope) {
     if (scope === undefined || scope === 'repo')
         return 'repo';
     throw new Error('watch mode supports repo scope only');
 }
+function watchDirectories(root) {
+    const directories = new Set([root]);
+    for (const relativePath of discoverSourceFiles(root)) {
+        directories.add(path.dirname(path.join(root, relativePath)));
+    }
+    // Immediate module directories contain the supported Maven/Gradle manifests
+    // and must also be watched when a module has no source files yet.
+    try {
+        for (const entry of readdirSync(root, { withFileTypes: true })) {
+            if (entry.isDirectory() && !entry.isSymbolicLink() && !IGNORED_WATCH_DIRECTORIES.has(entry.name))
+                directories.add(path.join(root, entry.name));
+        }
+    }
+    catch { /* scan will report traversal degradation */ }
+    return [...directories].sort();
+}
+function relevantWatchPath(root, watchedDirectory, filename) {
+    const filenameText = Buffer.isBuffer(filename) ? filename.toString() : filename;
+    const absolutePath = path.resolve(watchedDirectory, filenameText);
+    const relativePath = path.relative(root, absolutePath);
+    if (!relativePath || path.isAbsolute(relativePath) || relativePath === '..' || relativePath.startsWith(`..${path.sep}`))
+        return undefined;
+    const pathSegments = relativePath.split(path.sep);
+    if (pathSegments.some((segment) => IGNORED_WATCH_DIRECTORIES.has(segment)))
+        return undefined;
+    const basename = path.basename(relativePath);
+    const depth = pathSegments.length;
+    const supportedManifest = depth <= 2 && (basename === 'pom.xml' || basename === 'build.gradle' || basename === 'build.gradle.kts');
+    if (basename !== 'package.json' && !isSupportedSourceFile(absolutePath) && !supportedManifest)
+        return undefined;
+    return relativePath;
+}
+function closeWatchers(watchers) {
+    while (watchers.length > 0) {
+        watchers.pop()?.close();
+    }
+}
+function waitForWatchEvent(signal, setWake) {
+    return new Promise((resolve) => {
+        const done = () => {
+            signal?.removeEventListener('abort', done);
+            resolve();
+        };
+        if (signal?.aborted) {
+            done();
+            return;
+        }
+        setWake(done);
+        signal?.addEventListener('abort', done, { once: true });
+    });
+}
+function emitRescanTriggered(reason, mode, repository, scope, emit, progress) {
+    emit({ event: 'rescan-triggered', mode, reason, repository, scope });
+    reportWatchProgress(progress, { event: reason === 'follow-up' ? 'follow-up' : 'coalesced-change', mode, repository, scope, detail: reason === 'follow-up' ? 'change queued during scan; running follow-up' : 'coalesced file changes; running one rescan' });
+}
 function summarizeScan(summary) {
     return {
         filesDiscovered: summary.filesDiscovered,
         filesScanned: summary.filesScanned,
         nodesWritten: summary.nodesWritten,
         edgesWritten: summary.edgesWritten,
-        skippedCount: summary.skipped.length
+        skippedCount: summary.skipped.length,
+        enrichment: summary.enrichment
     };
 }
+function reportWatchProgress(progress, event) {
+    try {
+        progress?.({ kind: 'watch', ...event });
+    }
+    catch { /* progress is observational */ }
+}
+function defaultWatcherFactory(directory, options, listener) {
+    return watchFileSystem(directory, options, (event, filename) => listener(event, filename));
+}
 function defaultEmit(event) {
     console.log(JSON.stringify(event));
 }
@@ -110,9 +273,8 @@ async function defaultWait(ms, signal) {
         await sleep(ms, undefined, signal ? { signal } : undefined);
     }
     catch (error) {
-        if (!signal?.aborted) {
+        if (!signal?.aborted)
             throw error;
-        }
     }
 }
 //# sourceMappingURL=watch.js.map