@minionry/minion 0.7.36 → 0.7.39

package/dist/server/services/sdk/files-watch.js

@@ -0,0 +1,721 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { lstatSync, watch } from 'node:fs';
+import { lstat, readdir } from 'node:fs/promises';
+import { basename, join, sep } from 'node:path';
+import { notifyFileChangedAbsolute, setFileChangeObserver } from './file-change-notify.js';
+import { guardWorkspacePath } from './files-workspace.js';
+export const WATCH_DEBOUNCE_MS = 150;
+export const MAX_WATCHED_ROOTS_PER_APP = 8;
+export const MAX_WATCH_ENTRIES = 50_000;
+export const MAX_CHANGES_PER_WINDOW = 1_000;
+const RESYNC_COOLDOWN_MS = 5_000;
+const NOTIFIED_CHANGE_TTL_MS = 10_000;
+const STAT_BATCH = 64;
+const WATCH_BATCH = 1_000;
+const IGNORED_SEGMENTS = new Set(['.git', 'node_modules', '.minionry']);
+function toEntry(stats) {
+    return { ino: stats.ino, mtimeMs: stats.mtimeMs, size: stats.size, dir: stats.isDirectory() };
+}
+const defaultDeps = {
+    nativeRecursive: process.platform === 'darwin' || process.platform === 'win32',
+    watch: (absDir, recursive, listener) => {
+        const options = {
+            persistent: false,
+            recursive,
+            ...(recursive ? { ignore: isIgnoredPath } : {}),
+        };
+        return watch(absDir, options, listener);
+    },
+    lstat: (absPath) => lstat(absPath).then(toEntry, () => undefined),
+    lstatSync: (absPath) => {
+        try {
+            return toEntry(lstatSync(absPath));
+        }
+        catch {
+            return undefined;
+        }
+    },
+    readDir: (absDir) => readdir(absDir),
+    now: () => Date.now(),
+    setTimeout: (callback, ms) => setTimeout(callback, ms),
+    clearTimeout: (handle) => clearTimeout(handle),
+};
+let deps = defaultDeps;
+export function isIgnoredPath(rel) {
+    return rel.split(sep).some((segment) => IGNORED_SEGMENTS.has(segment.toLowerCase()));
+}
+export function sameEntry(a, b) {
+    return a.ino === b.ino && a.dir === b.dir && (a.dir || (a.mtimeMs === b.mtimeMs && a.size === b.size));
+}
+function sameState(a, b) {
+    return a === undefined || b === undefined ? a === b : sameEntry(a, b);
+}
+function isBelow(path, dir) {
+    return path.startsWith(dir + sep);
+}
+function parentOf(path) {
+    const cut = path.lastIndexOf(sep);
+    return cut < 0 ? '' : path.slice(0, cut);
+}
+function hasAncestorIn(path, set) {
+    for (let cut = path.lastIndexOf(sep); cut > 0; cut = path.lastIndexOf(sep, cut - 1)) {
+        if (set.has(path.slice(0, cut)))
+            return true;
+    }
+    return false;
+}
+function shallowestFirst(paths) {
+    const depthOf = (path) => {
+        let depth = 0;
+        for (let at = path.indexOf(sep); at >= 0; at = path.indexOf(sep, at + 1))
+            depth++;
+        return depth;
+    };
+    return [...paths]
+        .map((path) => ({ path, depth: depthOf(path) }))
+        .sort((a, b) => a.depth - b.depth || (a.path < b.path ? -1 : a.path > b.path ? 1 : 0))
+        .map(({ path }) => path);
+}
+export class PathTree {
+    byPath = new Map();
+    children = new Map();
+    constructor(entries = []) {
+        for (const [path, value] of entries)
+            this.set(path, value);
+    }
+    get size() {
+        return this.byPath.size;
+    }
+    get(path) {
+        return this.byPath.get(path);
+    }
+    has(path) {
+        return this.byPath.has(path);
+    }
+    keys() {
+        return this.byPath.keys();
+    }
+    [Symbol.iterator]() {
+        return this.byPath.entries();
+    }
+    set(path, value) {
+        this.byPath.set(path, value);
+        for (let child = path; child !== ''; child = parentOf(child)) {
+            const siblings = this.children.get(parentOf(child));
+            if (siblings?.has(child))
+                return;
+            if (siblings)
+                siblings.add(child);
+            else
+                this.children.set(parentOf(child), new Set([child]));
+        }
+    }
+    delete(path) {
+        this.byPath.delete(path);
+        this.unlink(path);
+    }
+    deleteTree(path) {
+        const dropped = [];
+        const stack = [path];
+        for (let node = stack.pop(); node !== undefined; node = stack.pop()) {
+            if (this.byPath.has(node)) {
+                dropped.push([node, this.byPath.get(node)]);
+                this.byPath.delete(node);
+            }
+            const below = this.children.get(node);
+            if (!below)
+                continue;
+            this.children.delete(node);
+            for (const child of below)
+                stack.push(child);
+        }
+        this.unlink(path);
+        return dropped;
+    }
+    move(from, to) {
+        const moved = this.deleteTree(from);
+        this.deleteTree(to);
+        for (const [path, value] of moved)
+            this.set(to + path.slice(from.length), value);
+    }
+    clear() {
+        this.byPath.clear();
+        this.children.clear();
+    }
+    unlink(path) {
+        for (let node = path; node !== '' && !this.byPath.has(node) && !this.children.has(node); node = parentOf(node)) {
+            const siblings = this.children.get(parentOf(node));
+            siblings?.delete(node);
+            if (siblings !== undefined && siblings.size > 0)
+                return;
+            this.children.delete(parentOf(node));
+        }
+    }
+}
+function pairMoves(known, observed, paths) {
+    const candidates = new Map();
+    for (const path of paths) {
+        const after = observed.get(path);
+        const before = known.get(path);
+        if (after && after.ino !== 0 && (!before || before.ino !== after.ino || before.dir !== after.dir)) {
+            const sharing = candidates.get(after.ino);
+            if (sharing)
+                sharing.push(path);
+            else
+                candidates.set(after.ino, [path]);
+        }
+    }
+    const moves = new Map();
+    const targets = new Set();
+    for (const source of paths) {
+        const before = known.get(source);
+        if (!before || observed.get(source) !== undefined || hasAncestorIn(source, moves))
+            continue;
+        const target = candidates
+            .get(before.ino)
+            ?.find((path) => !targets.has(path) && !hasAncestorIn(path, targets) && sameEntry(before, observed.get(path)));
+        if (target === undefined)
+            continue;
+        moves.set(source, target);
+        targets.add(target);
+    }
+    return moves;
+}
+function applyObservation(known, path, after) {
+    const before = known.get(path);
+    if (!after) {
+        if (!before)
+            return [];
+        known.deleteTree(path);
+        return [{ kind: 'deleted', path, dir: before.dir }];
+    }
+    if (!before) {
+        known.set(path, after);
+        return [{ kind: 'created', path, dir: after.dir }];
+    }
+    if (before.dir !== after.dir || (after.dir && before.ino !== after.ino)) {
+        known.deleteTree(path);
+        known.set(path, after);
+        return [
+            { kind: 'deleted', path, dir: before.dir },
+            { kind: 'created', path, dir: after.dir },
+        ];
+    }
+    known.set(path, after);
+    return after.dir || sameEntry(before, after) ? [] : [{ kind: 'changed', path, dir: false }];
+}
+export function classifyWindow(known, observed) {
+    const paths = shallowestFirst([...observed.keys()].filter((path) => path !== ''));
+    const moves = pairMoves(known, observed, paths);
+    const changes = [];
+    for (const [source, target] of moves) {
+        const entry = observed.get(target);
+        known.move(source, target);
+        known.set(target, entry);
+        changes.push({ kind: 'renamed', path: source, newPath: target, dir: entry.dir });
+    }
+    const targets = new Set(moves.values());
+    for (const path of paths) {
+        if (moves.has(path) || targets.has(path))
+            continue;
+        changes.push(...applyObservation(known, path, observed.get(path)));
+    }
+    return changes;
+}
+const ONLY_DIRECT = 'only changes made through the Files view or the SDK are reported for this subscription; list the directory to catch up';
+function errorCode(error) {
+    const code = error?.code;
+    return typeof code === 'string' ? code : 'unknown';
+}
+function thrownGap(error) {
+    const code = errorCode(error);
+    return code === 'ERR_FEATURE_UNAVAILABLE_ON_PLATFORM' || code === 'ENOSYS' || code === 'unknown'
+        ? { reason: 'watchUnsupported', message: `This host cannot watch directories (${code}) — ${ONLY_DIRECT}` }
+        : { reason: 'watchError', message: `Watching stopped (${code}) — ${ONLY_DIRECT}` };
+}
+const ROOT_GONE = {
+    reason: 'watchError',
+    message: `The watched directory was removed or replaced — ${ONLY_DIRECT}`,
+};
+const TOO_MANY_ENTRIES = {
+    reason: 'watchLimit',
+    message: `The directory holds more than ${MAX_WATCH_ENTRIES} entries — ${ONLY_DIRECT}`,
+};
+const TOO_MANY_ROOTS = {
+    reason: 'watchLimit',
+    message: `This app already watches ${MAX_WATCHED_ROOTS_PER_APP} workspace directories in this Space — ${ONLY_DIRECT}`,
+};
+const OVERFLOW = {
+    reason: 'watchOverflow',
+    message: 'Too many changes to report one by one — list the directory to catch up',
+};
+const SKIPPABLE_DIR_ERRORS = new Set(['ENOENT', 'ENOTDIR', 'EACCES', 'EPERM']);
+const watches = new Map();
+let emittingWatch;
+class RootWatch {
+    key;
+    spaceKey;
+    realRoot;
+    workingDir;
+    state = 'priming';
+    generation = 0;
+    refs = new Map();
+    known = new PathTree();
+    handles = new PathTree();
+    pending = new Map();
+    recheck = new Set();
+    notified = new Map();
+    rootIno = 0;
+    timer;
+    flushing = false;
+    resyncTimer;
+    lastResyncAt = Number.NEGATIVE_INFINITY;
+    constructor(key, spaceKey, realRoot, workingDir) {
+        this.key = key;
+        this.spaceKey = spaceKey;
+        this.realRoot = realRoot;
+        this.workingDir = workingDir;
+    }
+    describe() {
+        return { state: this.state, entries: this.known.size, handles: this.handles.size };
+    }
+    holds(appId) {
+        return [...this.refs.values()].some((ref) => ref.appId === appId);
+    }
+    addRef(subscriber) {
+        const token = Symbol('filesWatchRef');
+        this.refs.set(token, subscriber);
+        return () => {
+            if (this.refs.delete(token) && this.refs.size === 0)
+                this.close();
+        };
+    }
+    close() {
+        if (this.state !== 'stopped')
+            this.state = 'closed';
+        this.teardown();
+    }
+    relativeOf(absPath) {
+        if (absPath === this.realRoot)
+            return '';
+        return isBelow(absPath, this.realRoot) ? absPath.slice(this.realRoot.length + 1) : undefined;
+    }
+    recordNotified(rel, state) {
+        if (this.state === 'stopped' || this.state === 'closed')
+            return;
+        const now = deps.now();
+        for (const [path, record] of this.notified) {
+            if (now - record.at <= NOTIFIED_CHANGE_TTL_MS)
+                break;
+            this.notified.delete(path);
+        }
+        this.notified.delete(rel);
+        this.notified.set(rel, { state, at: now });
+    }
+    async start() {
+        if (await this.prime())
+            this.becomeLive();
+    }
+    async prime() {
+        const generation = ++this.generation;
+        this.state = 'priming';
+        this.known.clear();
+        const root = await deps.lstat(this.realRoot);
+        if (generation !== this.generation)
+            return false;
+        if (!root?.dir)
+            return this.stop(ROOT_GONE);
+        this.rootIno = root.ino;
+        if (!(await this.walk('', generation, { watchAsWeGo: false })))
+            return false;
+        if (deps.nativeRecursive)
+            return this.watchDir('');
+        const dirs = ['', ...[...this.known].filter(([, entry]) => entry.dir).map(([path]) => path)];
+        for (let index = 0; index < dirs.length; index++) {
+            if (index > 0 && index % WATCH_BATCH === 0) {
+                await new Promise((resolve) => setImmediate(resolve));
+                if (generation !== this.generation)
+                    return false;
+            }
+            if (!this.watchDir(dirs[index]))
+                return false;
+        }
+        return true;
+    }
+    becomeLive() {
+        this.state = 'live';
+        if (this.pending.size > 0)
+            this.schedule();
+    }
+    async walk(from, generation, opts) {
+        const queue = [from];
+        for (let next = 0; next < queue.length; next++) {
+            const dirRel = queue[next];
+            if (opts.watchAsWeGo && !deps.nativeRecursive && !this.watchDir(dirRel))
+                return false;
+            const children = await this.readChildren(dirRel, generation);
+            if (children === false)
+                return false;
+            for (const [rel, entry] of children) {
+                if (!this.remember(rel, entry, opts.discovered))
+                    return false;
+                if (entry.dir)
+                    queue.push(rel);
+            }
+        }
+        return true;
+    }
+    async readChildren(dirRel, generation) {
+        let names;
+        try {
+            names = await deps.readDir(join(this.realRoot, dirRel));
+        }
+        catch (error) {
+            if (generation !== this.generation)
+                return false;
+            if (dirRel !== '' && SKIPPABLE_DIR_ERRORS.has(errorCode(error)))
+                return [];
+            return this.stop(dirRel === '' ? ROOT_GONE : thrownGap(error));
+        }
+        if (generation !== this.generation)
+            return false;
+        const rels = names.filter((name) => !IGNORED_SEGMENTS.has(name.toLowerCase())).map((name) => join(dirRel, name));
+        const stats = await this.statAll(rels, generation);
+        if (stats === false)
+            return false;
+        return rels.flatMap((rel, position) => {
+            const entry = stats[position];
+            return entry ? [[rel, entry]] : [];
+        });
+    }
+    async statAll(rels, generation) {
+        const stats = [];
+        for (let index = 0; index < rels.length; index += STAT_BATCH) {
+            const batch = rels.slice(index, index + STAT_BATCH);
+            stats.push(...(await Promise.all(batch.map((rel) => deps.lstat(join(this.realRoot, rel))))));
+            if (generation !== this.generation)
+                return false;
+        }
+        return stats;
+    }
+    remember(rel, entry, discovered) {
+        if (this.known.has(rel))
+            return true;
+        this.known.set(rel, entry);
+        discovered?.push({ kind: 'created', path: rel, dir: entry.dir });
+        return this.known.size <= MAX_WATCH_ENTRIES || this.stop(TOO_MANY_ENTRIES);
+    }
+    watchDir(rel) {
+        if (this.handles.has(rel))
+            return true;
+        let handle;
+        try {
+            handle = deps.watch(join(this.realRoot, rel), deps.nativeRecursive, (_eventType, filename) => this.onEvent(rel, filename));
+        }
+        catch (error) {
+            if (rel !== '' && SKIPPABLE_DIR_ERRORS.has(errorCode(error)))
+                return true;
+            return this.stop(thrownGap(error));
+        }
+        handle.on('error', (error) => {
+            this.stop({ reason: 'watchError', message: `Watching stopped (${errorCode(error)}) — ${ONLY_DIRECT}` });
+        });
+        this.handles.set(rel, handle);
+        return true;
+    }
+    unwatchTree(rel) {
+        if (rel === '')
+            return;
+        for (const [, handle] of this.handles.deleteTree(rel))
+            handle.close();
+    }
+    onEvent(dirRel, filename) {
+        if (this.state !== 'live' && this.state !== 'priming')
+            return;
+        if (filename === null) {
+            this.requestResync();
+            return;
+        }
+        const joined = join(dirRel, filename);
+        const rel = joined === '.' ? '' : joined;
+        if (isIgnoredPath(rel))
+            return;
+        if (!deps.nativeRecursive && filename === basename(join(this.realRoot, dirRel))) {
+            this.recheck.add(dirRel);
+            this.pending.set(dirRel, deps.now() + WATCH_DEBOUNCE_MS);
+        }
+        this.pending.set(rel, deps.now() + WATCH_DEBOUNCE_MS);
+        if (this.pending.size > MAX_WATCH_ENTRIES) {
+            this.requestResync();
+            return;
+        }
+        if (this.state === 'live')
+            this.schedule();
+    }
+    schedule() {
+        if (this.timer !== undefined || this.flushing)
+            return;
+        let earliest = Number.POSITIVE_INFINITY;
+        for (const due of this.pending.values())
+            earliest = Math.min(earliest, due);
+        this.timer = deps.setTimeout(() => void this.flush(), Math.max(0, earliest - deps.now()));
+    }
+    async flush() {
+        this.timer = undefined;
+        if (this.state !== 'live' || this.pending.size === 0)
+            return;
+        const now = deps.now();
+        let earliest = Number.POSITIVE_INFINITY;
+        for (const due of this.pending.values())
+            earliest = Math.min(earliest, due);
+        if (earliest > now) {
+            this.schedule();
+            return;
+        }
+        const paths = [...this.pending.keys()];
+        this.pending.clear();
+        const generation = this.generation;
+        this.flushing = true;
+        try {
+            await this.processWindow(paths, generation);
+        }
+        catch (error) {
+            console.error('[files-watch] window failed:', error);
+            this.stop({ reason: 'watchError', message: `Watching stopped (internal error) — ${ONLY_DIRECT}` });
+        }
+        finally {
+            this.flushing = false;
+            if (this.state === 'live' && this.pending.size > 0)
+                this.schedule();
+        }
+    }
+    async processWindow(paths, generation) {
+        const root = await deps.lstat(this.realRoot);
+        if (generation !== this.generation)
+            return;
+        if (!root?.dir || root.ino !== this.rootIno) {
+            this.reportRootGone(root);
+            return;
+        }
+        const stats = await this.statAll(paths, generation);
+        if (stats === false)
+            return;
+        const changes = classifyWindow(this.known, new Map(paths.map((rel, position) => [rel, stats[position]])));
+        const discovered = [];
+        if (!(await this.followDirectories(changes, generation, discovered)))
+            return;
+        if (!(await this.reopenRechecked(generation, discovered)))
+            return;
+        this.report([...changes, ...discovered]);
+    }
+    async followDirectories(changes, generation, discovered) {
+        for (const change of changes) {
+            if (!change.dir)
+                continue;
+            if (change.kind === 'deleted' || change.kind === 'renamed')
+                this.unwatchTree(change.path);
+            const arrived = change.kind === 'renamed' ? change.newPath : change.kind === 'created' ? change.path : undefined;
+            if (arrived !== undefined && !(await this.walk(arrived, generation, { watchAsWeGo: true, discovered })))
+                return false;
+        }
+        return true;
+    }
+    async reopenRechecked(generation, discovered) {
+        for (const rel of [...this.recheck]) {
+            this.recheck.delete(rel);
+            if (rel !== '' && !this.known.get(rel)?.dir)
+                continue;
+            this.handles.get(rel)?.close();
+            this.handles.delete(rel);
+            if (!(await this.walk(rel, generation, { watchAsWeGo: true, discovered })))
+                return false;
+        }
+        return true;
+    }
+    report(changes) {
+        if (this.known.size > MAX_WATCH_ENTRIES) {
+            this.stop(TOO_MANY_ENTRIES);
+            return;
+        }
+        const reportable = [];
+        for (const change of changes) {
+            reportable.push(...this.reportable(change));
+            if (reportable.length > MAX_CHANGES_PER_WINDOW) {
+                this.gapAll(OVERFLOW);
+                return;
+            }
+        }
+        for (const change of reportable)
+            this.notify(change);
+    }
+    reportRootGone(root) {
+        if (this.isNews('', root))
+            this.notify({ kind: 'deleted', path: '', dir: true });
+        this.stop(ROOT_GONE);
+    }
+    takeNotified(rel) {
+        const record = this.notified.get(rel);
+        if (!record)
+            return undefined;
+        this.notified.delete(rel);
+        return deps.now() - record.at > NOTIFIED_CHANGE_TTL_MS ? undefined : record;
+    }
+    isNews(rel, current) {
+        const record = this.takeNotified(rel);
+        return !record || !sameState(record.state, current);
+    }
+    isVisible(rel) {
+        try {
+            guardWorkspacePath(this.workingDir, join(this.realRoot, rel), { quiet: true });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    reportable(change) {
+        const news = (rel) => this.isNews(rel, this.known.get(rel)) && this.isVisible(rel);
+        if (change.kind !== 'renamed')
+            return news(change.path) ? [change] : [];
+        const source = news(change.path);
+        const target = news(change.newPath);
+        if (source && target)
+            return [change];
+        if (source)
+            return [{ kind: 'deleted', path: change.path, dir: change.dir }];
+        if (target)
+            return [{ kind: 'created', path: change.newPath, dir: change.dir }];
+        return [];
+    }
+    notify(change) {
+        const absolute = join(this.realRoot, change.path);
+        emittingWatch = this;
+        try {
+            if (change.kind === 'renamed') {
+                notifyFileChangedAbsolute(this.spaceKey, absolute, 'renamed', {
+                    newPath: join(this.realRoot, change.newPath),
+                    dir: change.dir,
+                });
+            }
+            else {
+                notifyFileChangedAbsolute(this.spaceKey, absolute, change.kind, { dir: change.dir });
+            }
+        }
+        finally {
+            emittingWatch = undefined;
+        }
+    }
+    gapAll(gap) {
+        for (const ref of this.refs.values())
+            ref.onGap(gap);
+    }
+    requestResync() {
+        if (this.resyncTimer !== undefined)
+            return;
+        this.state = 'resyncing';
+        this.pending.clear();
+        const wait = Math.max(0, this.lastResyncAt + RESYNC_COOLDOWN_MS - deps.now());
+        this.resyncTimer = deps.setTimeout(() => {
+            this.resyncTimer = undefined;
+            void this.resync();
+        }, wait);
+    }
+    async resync() {
+        if (this.state !== 'resyncing')
+            return;
+        this.lastResyncAt = deps.now();
+        this.closeHandles();
+        if (!(await this.prime()))
+            return;
+        this.gapAll(OVERFLOW);
+        this.becomeLive();
+    }
+    stop(gap) {
+        if (this.state === 'stopped' || this.state === 'closed')
+            return false;
+        this.state = 'stopped';
+        this.teardown();
+        this.gapAll(gap);
+        return false;
+    }
+    closeHandles() {
+        for (const [, handle] of this.handles)
+            handle.close();
+        this.handles.clear();
+    }
+    teardown() {
+        this.generation++;
+        this.closeHandles();
+        if (this.timer !== undefined)
+            deps.clearTimeout(this.timer);
+        if (this.resyncTimer !== undefined)
+            deps.clearTimeout(this.resyncTimer);
+        this.timer = undefined;
+        this.resyncTimer = undefined;
+        this.pending.clear();
+        this.recheck.clear();
+        this.known.clear();
+        this.notified.clear();
+        if (watches.get(this.key) === this)
+            watches.delete(this.key);
+    }
+}
+function observeNotifiedChange(spaceKey, source, target) {
+    if (watches.size === 0)
+        return;
+    recordInCoveringWatches(spaceKey, source);
+    if (target !== undefined)
+        recordInCoveringWatches(spaceKey, target);
+}
+function recordInCoveringWatches(spaceKey, absolute) {
+    let state = null;
+    for (const rootWatch of watches.values()) {
+        if (rootWatch.spaceKey !== spaceKey || rootWatch === emittingWatch)
+            continue;
+        const rel = rootWatch.relativeOf(absolute);
+        if (rel === undefined)
+            continue;
+        if (state === null)
+            state = deps.lstatSync(absolute);
+        rootWatch.recordNotified(rel, state);
+    }
+}
+export function acquireRootWatch(request) {
+    setFileChangeObserver(observeNotifiedChange);
+    const key = `${request.spaceKey}\0${request.realRoot}`;
+    let rootWatch = watches.get(key);
+    if (!rootWatch?.holds(request.appId)) {
+        const held = [...watches.values()].filter((candidate) => candidate.spaceKey === request.spaceKey && candidate.holds(request.appId)).length;
+        if (held >= MAX_WATCHED_ROOTS_PER_APP) {
+            request.onGap(TOO_MANY_ROOTS);
+            return () => { };
+        }
+    }
+    const fresh = rootWatch === undefined;
+    if (rootWatch === undefined) {
+        rootWatch = new RootWatch(key, request.spaceKey, request.realRoot, request.workingDir);
+        watches.set(key, rootWatch);
+    }
+    const release = rootWatch.addRef({ appId: request.appId, onGap: request.onGap });
+    if (fresh)
+        void rootWatch.start();
+    let released = false;
+    return () => {
+        if (released)
+            return;
+        released = true;
+        release();
+    };
+}
+export function describeRootWatch(spaceKey, realRoot) {
+    return watches.get(`${spaceKey}\0${realRoot}`)?.describe();
+}
+export function setFilesWatchDeps(overrides) {
+    deps = { ...defaultDeps, ...overrides };
+}
+export function resetFilesWatch() {
+    for (const rootWatch of [...watches.values()])
+        rootWatch.close();
+    deps = defaultDeps;
+}