@openclaw/signal 2026.11.3 → 2026.11.5-beta.2

package/node_modules/@openclaw/fs-safe/dist/watch-io-worker.js

@@ -0,0 +1,93 @@
+import { checkedWatchStat, checkWatchRoot } from "./watch-io.js";
+import fs from "node:fs";
+import fsp from "node:fs/promises";
+import { parentPort, workerData } from "node:worker_threads";
+import { configureFsSafeNative } from "./native-config.js";
+import { resolvePathInRoot } from "./root-context.js";
+import { assertRootDirectoryObservationGuard, createRootDirectoryObservationGuard, openRootDirectoryListing } from "./root-directory-list.js";
+import { lookupRootDirectoryEntry } from "./root-directory-entry.js";
+import { encodeWatchError as errorWire } from "./watch-io-error.js";
+import { watchObservation } from "./watch-probe.js";
+// This worker owns only filesystem observations. Callbacks and transport policy
+// remain with the subscription; no worker observation grants read authority.
+const counts = {};
+if (workerData.diagnostics)
+    for (const [target, methods, prefix] of [
+        [fs, ["lstatSync", "statSync", "realpathSync", "openSync", "closeSync", "fstatSync", "readlinkSync"], "sync."],
+        [fsp, ["lstat", "stat", "realpath", "opendir", "readdir", "open"], "async."],
+        [fs.Dir.prototype, ["readSync", "read", "closeSync", "close"], "dir."],
+    ])
+        for (const method of methods) {
+            const object = target;
+            const original = object[method];
+            object[method] = function (...args) {
+                counts[prefix + method] = (counts[prefix + method] ?? 0) + 1;
+                return Reflect.apply(original, this, args);
+            };
+            Object.assign(object[method], original);
+        }
+configureFsSafeNative(workerData.native);
+const listings = new Map();
+let nextListing = 0;
+let allowance = 0, consumed = 0;
+let cleanupErrors = [];
+async function run(method, args, root) {
+    switch (method) {
+        case "metrics": return counts;
+        case "root": return checkWatchRoot(root);
+        case "resolve": return resolvePathInRoot(root, args[0], args[1]);
+        case "guard": return createRootDirectoryObservationGuard(root, args[0]);
+        case "assert": return assertRootDirectoryObservationGuard(root, args[0]);
+        case "lookup": {
+            const found = await lookupRootDirectoryEntry(root, args[0], args[1], args[2]);
+            if (found?.observation)
+                found.observation = watchObservation(found.observation);
+            return found;
+        }
+        case "stat": return args[0].map((request) => watchObservation(checkedWatchStat(request)));
+        case "open": {
+            const listing = await openRootDirectoryListing(root, args[0], {
+                ...args[1], onCleanupFailure: (error) => cleanupErrors.push(error),
+                admitEntry: () => { if (consumed >= allowance)
+                    return false; consumed++; return true; },
+            });
+            const id = ++nextListing;
+            listings.set(id, listing);
+            return { id, paths: listing.paths };
+        }
+        case "next": {
+            allowance = args[1];
+            consumed = 0;
+            try {
+                const entry = await listings.get(args[0]).next();
+                if (entry?.kind === "entry" && entry.observation)
+                    entry.observation = watchObservation(entry.observation);
+                return { entry, consumed };
+            }
+            catch (error) {
+                return { entryError: errorWire(error), failed: true, consumed };
+            }
+        }
+        case "current": return listings.get(args[0]).assertCurrent();
+        case "close": {
+            const listing = listings.get(args[0]);
+            listings.delete(args[0]);
+            return listing?.[Symbol.asyncDispose]();
+        }
+        default: throw new Error("unknown watch observation request");
+    }
+}
+// Serial execution also bounds in-flight handles and metadata batches.
+let pending = Promise.resolve();
+parentPort.on("message", ({ id, method, args, root }) => {
+    pending = pending.then(async () => {
+        cleanupErrors = [];
+        try {
+            parentPort.postMessage({ id, value: await run(method, args, root), cleanupErrors: cleanupErrors.map(errorWire) });
+        }
+        catch (error) {
+            const wire = errorWire(error);
+            parentPort.postMessage({ id, error: wire, failed: true, cleanupErrors: cleanupErrors.map(item => item === error ? wire : errorWire(item)) });
+        }
+    });
+});

package/node_modules/@openclaw/fs-safe/dist/watch-io.d.ts

@@ -0,0 +1,47 @@
+import { type BigIntStats } from "node:fs";
+import { resolvePathInRoot, type RootContext } from "./root-context.js";
+import { type RootDirectoryObservationGuard } from "./root-directory-list.js";
+import type { WatchObservation } from "./watch-probe.js";
+import type { RootDirectoryListingOptions, RootDirectoryListing } from "./root-directory-list-types.js";
+/** Internal benchmark support; never enables logging or records pathnames. */
+export declare function enableWatchIoDiagnostics(): void;
+export declare function watchIoMetrics(): Promise<Record<string, number>>;
+export declare class WatchEndpoint {
+    private worker;
+    private next;
+    private failure;
+    private requests;
+    references: number;
+    persistent: number;
+    constructor();
+    updateRef(): void;
+    call<T>(root: RootContext | undefined, cleanup: ((error: unknown) => void) | undefined, method: string, ...args: unknown[]): Promise<T>;
+    close(): Promise<void>;
+}
+export declare function createWatchIo(root: RootContext, persistent: boolean, cleanup?: (error: unknown) => void): () => Promise<void>;
+export declare function watchRootCurrent(root: RootContext): Promise<void>;
+/** An unchanged inode alone cannot detect a relocated ancestor above the Root. */
+export declare function checkWatchRoot(root: RootContext): Promise<void>;
+export declare function watchResolve(root: RootContext, name: string, options: Parameters<typeof resolvePathInRoot>[2]): Promise<{
+    rootReal: string;
+    rootWithSep: string;
+    resolved: string;
+}>;
+export declare function watchGuard(root: RootContext, name: string): Promise<RootDirectoryObservationGuard>;
+export declare function watchAssert(root: RootContext, guard: RootDirectoryObservationGuard): Promise<void>;
+export declare function watchLookup(root: RootContext, guard: RootDirectoryObservationGuard, name: string, exact?: boolean): Promise<{
+    entry: import("./types.js").DirEntry;
+    identity: import("./stat-observation.js").ExactStatIdentity;
+    observation?: import("./root-directory-list-types.js").RootEntryObservation;
+} | undefined>;
+export type WatchStatRequest = {
+    path: string;
+    dev: bigint;
+    ino: bigint;
+    directory: boolean;
+};
+export declare function checkedWatchStat(request: WatchStatRequest): BigIntStats;
+export declare function watchStats(root: RootContext, requests: WatchStatRequest[]): Promise<WatchObservation[]>;
+export declare function watchListing(root: RootContext, name: string, options: RootDirectoryListingOptions, remaining: () => number): Promise<RootDirectoryListing>;
+/** Bound pure JS loops and the source/alternate-runtime observation fallback. */
+export declare function watchYield(): () => Promise<void>;

package/node_modules/@openclaw/fs-safe/dist/watch-io.js

@@ -0,0 +1,236 @@
+import { decodeWatchError as decodeError } from "./watch-io-error.js";
+import path from "node:path";
+import fs, {} from "node:fs";
+import { Worker } from "node:worker_threads";
+import { setImmediate as yieldToEventLoop } from "node:timers/promises";
+import { FsSafeError } from "./errors.js";
+import { getFsSafeNativeConfig } from "./native-config.js";
+import { getFsSafeTestHooks } from "./test-hooks.js";
+import { createRootObservationGuard, resolvePathInRoot } from "./root-context.js";
+import { assertRootDirectoryObservationGuard, createRootDirectoryObservationGuard, openRootDirectoryListing } from "./root-directory-list.js";
+import { lookupRootDirectoryEntry } from "./root-directory-entry.js";
+const owners = new WeakMap();
+const diagnostics = new Set();
+const endpoints = new Map();
+let measureIo = false;
+/** Internal benchmark support; never enables logging or records pathnames. */
+export function enableWatchIoDiagnostics() { measureIo = true; }
+export async function watchIoMetrics() {
+    const total = {};
+    for (const owner of diagnostics)
+        for (const [name, count] of Object.entries(await owner.call(undefined, undefined, "metrics")))
+            total[name] = (total[name] ?? 0) + count;
+    return total;
+}
+function statMethods(stat) {
+    const kind = stat.mode & 61440n;
+    return Object.assign(stat, { isDirectory: () => kind === 16384n,
+        isSymbolicLink: () => kind === 40960n, isFile: () => kind === 32768n });
+}
+export class WatchEndpoint {
+    worker;
+    next = 0;
+    failure;
+    requests = new Map();
+    references = 0;
+    persistent = 0;
+    constructor() {
+        const module = new URL("./watch-io-worker.js", import.meta.url);
+        // Default inheritance handles V8/process flags correctly. A data-URL entry
+        // also lets eval/STDIN callers retain --input-type without applying it to a file.
+        const entry = process.execArgv.some(arg => arg === "--input-type" || arg.startsWith("--input-type="))
+            ? new URL(`data:text/javascript,${encodeURIComponent(`import ${JSON.stringify(module.href)};`)}`) : module;
+        this.worker = new Worker(entry, {
+            // Replies are short-lived; bound nursery growth without capping retained listings.
+            resourceLimits: { maxYoungGenerationSizeMb: 4 },
+            workerData: { native: getFsSafeNativeConfig(), diagnostics: measureIo },
+        });
+        this.worker.on("message", ({ id, value, error, failed, cleanupErrors }) => {
+            const request = this.requests.get(id);
+            this.requests.delete(id);
+            const failure = failed ? decodeError(error) : undefined;
+            for (const item of cleanupErrors ?? [])
+                request?.cleanup?.(item === error ? failure : decodeError(item));
+            if (failed)
+                request?.reject(failure);
+            else
+                request?.resolve(value);
+            this.updateRef();
+        });
+        const fail = (cause) => {
+            this.failure = new FsSafeError("helper-failed", "watch observation worker stopped", { cause });
+            for (const request of this.requests.values())
+                request.reject(this.failure);
+            this.requests.clear();
+        };
+        this.worker.on("error", fail);
+        this.worker.on("exit", code => fail(new Error(`watch observation worker exited (${code})`)));
+        this.updateRef();
+    }
+    updateRef() { if (this.persistent || this.requests.size)
+        this.worker.ref();
+    else
+        this.worker.unref(); }
+    call(root, cleanup, method, ...args) {
+        if (this.failure)
+            return Promise.reject(this.failure);
+        return new Promise((resolve, reject) => {
+            const id = ++this.next;
+            this.requests.set(id, { resolve, reject, cleanup });
+            this.worker.ref();
+            try {
+                this.worker.postMessage({ id, method, args, root });
+            }
+            catch (error) {
+                this.requests.delete(id);
+                reject(error);
+            }
+        });
+    }
+    async close() { await this.worker.terminate(); }
+}
+class WatchIo {
+    endpoint;
+    cleanup;
+    root;
+    constructor(endpoint, root, cleanup) {
+        this.endpoint = endpoint;
+        this.cleanup = cleanup;
+        this.root = { rootDir: root.rootDir, rootReal: root.rootReal, rootWithSep: root.rootWithSep, rootIdentity: root.rootIdentity };
+    }
+    call(method, ...args) { return this.endpoint.call(this.root, this.cleanup, method, ...args); }
+}
+export function createWatchIo(root, persistent, cleanup) {
+    // Source loaders and alternate runtimes need not implement Node worker module
+    // loading. Their fallback uses the same guarded helpers with bounded yields.
+    if (!import.meta.url.endsWith(".js") || process.versions.bun || process.versions.deno || getFsSafeTestHooks())
+        return async () => { };
+    const key = `${getFsSafeNativeConfig().mode}:${measureIo}`;
+    let endpoint = endpoints.get(key);
+    if (!endpoint) {
+        endpoint = new WatchEndpoint();
+        endpoints.set(key, endpoint);
+        if (measureIo)
+            diagnostics.add(endpoint);
+    }
+    endpoint.references++;
+    if (persistent)
+        endpoint.persistent++;
+    endpoint.updateRef();
+    owners.set(root, new WatchIo(endpoint, root, cleanup));
+    return async () => {
+        owners.delete(root);
+        endpoint.references--;
+        if (persistent)
+            endpoint.persistent--;
+        endpoint.updateRef();
+        if (!endpoint.references) {
+            endpoints.delete(key);
+            diagnostics.delete(endpoint);
+            await endpoint.close();
+        }
+    };
+}
+export async function watchRootCurrent(root) {
+    const owner = owners.get(root);
+    if (owner)
+        await owner.call("root");
+    else
+        await checkWatchRoot(root);
+}
+/** An unchanged inode alone cannot detect a relocated ancestor above the Root. */
+export async function checkWatchRoot(root) {
+    const guard = await createRootObservationGuard(root);
+    await assertRootDirectoryObservationGuard(root, guard);
+}
+export async function watchResolve(root, name, options) {
+    const owner = owners.get(root);
+    if (owner)
+        return owner.call("resolve", name, options);
+    await yieldToEventLoop();
+    return resolvePathInRoot(root, name, options);
+}
+export async function watchGuard(root, name) {
+    const owner = owners.get(root);
+    if (!owner) {
+        await yieldToEventLoop();
+        return createRootDirectoryObservationGuard(root, name);
+    }
+    const guard = await owner.call("guard", name);
+    statMethods(guard.stat);
+    return guard;
+}
+export async function watchAssert(root, guard) {
+    const owner = owners.get(root);
+    if (owner)
+        await owner.call("assert", { ...guard, stat: { ...guard.stat, isDirectory: undefined, isSymbolicLink: undefined, isFile: undefined } });
+    else {
+        await yieldToEventLoop();
+        await assertRootDirectoryObservationGuard(root, guard);
+    }
+}
+export async function watchLookup(root, guard, name, exact = false) {
+    const owner = owners.get(root);
+    return owner ? owner.call("lookup", { ...guard, stat: { ...guard.stat, isDirectory: undefined, isSymbolicLink: undefined, isFile: undefined } }, name, exact) : lookupRootDirectoryEntry(root, guard, name, exact);
+}
+export function checkedWatchStat(request) {
+    const current = fs.lstatSync(request.path, { bigint: true });
+    if (current.dev !== request.dev || current.ino !== request.ino ||
+        (request.directory && (!current.isDirectory() || current.isSymbolicLink()))) {
+        throw new FsSafeError("path-mismatch", "watch metadata identity changed");
+    }
+    return current;
+}
+export async function watchStats(root, requests) {
+    const owner = owners.get(root);
+    if (owner)
+        return owner.call("stat", requests);
+    const result = [];
+    for (const request of requests) {
+        await yieldToEventLoop();
+        result.push(checkedWatchStat(request));
+    }
+    return result;
+}
+export async function watchListing(root, name, options, remaining) {
+    const owner = owners.get(root);
+    if (!owner) {
+        const listing = await openRootDirectoryListing(root, name, options);
+        return { ...listing, async next() { await yieldToEventLoop(); return listing.next(); } };
+    }
+    const { admitEntry, signal, onCleanupFailure, previousPaths: _hostPaths, ...wire } = options;
+    const opened = await owner.call("open", name, wire);
+    return {
+        paths: opened.paths,
+        assertCurrent: () => owner.call("current", opened.id),
+        async next() {
+            signal?.throwIfAborted();
+            const { entry, consumed, entryError, failed } = await owner.call("next", opened.id, remaining());
+            for (let n = 0; n < consumed; n++) {
+                admitEntry();
+                if (n % 32 === 31) {
+                    await yieldToEventLoop();
+                    signal?.throwIfAborted();
+                }
+            }
+            if (failed)
+                throw decodeError(entryError);
+            if (entry?.kind === "entry")
+                opened.paths.names.set(entry.entry.name, path.join(name, entry.entry.name));
+            return entry;
+        },
+        async [Symbol.asyncDispose]() { try {
+            await owner.call("close", opened.id);
+        }
+        catch (error) {
+            onCleanupFailure?.(error);
+            throw error;
+        } },
+    };
+}
+/** Bound pure JS loops and the source/alternate-runtime observation fallback. */
+export function watchYield() {
+    let count = 0;
+    return async () => { if (++count % 32 === 0)
+        await yieldToEventLoop(); };
+}

package/node_modules/@openclaw/fs-safe/dist/watch-native.d.ts

@@ -50,6 +50,6 @@ export declare class NativeWatchBackend {
     add(name: string, identity: DirectoryIdentity): void;
     testEvent(path: string, flags: number): void;
     entries(snapshot: WatchSnapshot): boolean;
-    configure(snapshot: WatchSnapshot, scopes: readonly WatchScope[]): boolean;
+    configure(snapshot: WatchSnapshot, scopes: readonly WatchScope[]): Promise<boolean>;
     close(): void;
 }

package/node_modules/@openclaw/fs-safe/dist/watch-native.js

@@ -1,7 +1,7 @@
 import { FsSafeError } from "./errors.js";
 import { getNativeBinding } from "./native.js";
 import { getFsSafeNativeConfig } from "./native-config.js";
-import { watchStreamPaths } from "./watch-stream.js";
+import { watchStreamPathsAsync } from "./watch-stream.js";
 export function watchBinding(mode) {
     if (mode === "poll")
         return;
@@ -62,10 +62,10 @@ export class NativeWatchBackend {
             throw watchError(cause);
         }
     }
-    configure(snapshot, scopes) {
+    async configure(snapshot, scopes) {
         if (process.platform !== "darwin")
             return false;
-        const paths = watchStreamPaths(snapshot, scopes);
+        const paths = await watchStreamPathsAsync(snapshot, scopes);
         const key = JSON.stringify(paths);
         if (this.streamPaths === key)
             return false;

package/node_modules/@openclaw/fs-safe/dist/watch-probe.d.ts

@@ -0,0 +1,16 @@
+import type { RootEntryObservation } from "./root-directory-list-types.js";
+import { type RootContext } from "./root-context.js";
+import type { WatchSnapshot } from "./watch-scan.js";
+import type { WatchOptions } from "./watch-types.js";
+export type WatchObservation = RootEntryObservation;
+/** Do not retain or clone unused Stats fields for every cached entry. */
+export declare function watchObservation(stat: WatchObservation): WatchObservation;
+export declare const sameWatchObservation: (a: WatchObservation, b: WatchObservation) => boolean;
+/** Advisory only: these stats can suppress unchanged work, never admit new names or authority. */
+export type WatchProbe = {
+    reuse: Set<string>;
+    stable: boolean;
+};
+export declare function probeWatchSnapshot(root: RootContext, snapshot: WatchSnapshot, signal: AbortSignal, exclude?: WatchOptions["exclude"]): Promise<WatchProbe | undefined>;
+/** Fence reused directory observations after traversal, including ancestors swapped during leaf probes. */
+export declare function verifyWatchReuse(root: RootContext, snapshot: WatchSnapshot, reused: Set<string>, signal: AbortSignal): Promise<boolean>;

package/node_modules/@openclaw/fs-safe/dist/watch-probe.js

@@ -0,0 +1,135 @@
+import path from "node:path";
+import {} from "./root-context.js";
+import { watchRootCurrent as assertRootIdentityCurrent, watchStats, watchYield } from "./watch-io.js";
+import { assertSynchronousCallbackResult } from "./mutation-authority.js";
+import { FsSafeError } from "./errors.js";
+/** Do not retain or clone unused Stats fields for every cached entry. */
+export function watchObservation(stat) {
+    const { dev, ino, mode, nlink, size, mtimeNs, ctimeNs } = stat;
+    return { dev, ino, mode, nlink, size, mtimeNs, ctimeNs };
+}
+export const sameWatchObservation = (a, b) => a.dev === b.dev && a.ino === b.ino && a.mode === b.mode && a.nlink === b.nlink &&
+    a.size === b.size && a.mtimeNs === b.mtimeNs && a.ctimeNs === b.ctimeNs;
+const parent = (name) => path.dirname(name) === "." ? "" : path.dirname(name);
+const preciseTimestamp = (stat) => stat.mtimeNs % 1000000n !== 0n || stat.ctimeNs % 1000000n !== 0n;
+export async function probeWatchSnapshot(root, snapshot, signal, exclude) {
+    if (!snapshot.observations || snapshot.structural?.size || snapshot.overflow)
+        return;
+    await assertRootIdentityCurrent(root);
+    const checkpoint = watchYield();
+    const unchanged = new Set();
+    for (const name of snapshot.listed?.keys() ?? []) {
+        unchanged.add(name);
+        await checkpoint();
+    }
+    // Timestamp storage precision does not prove clock update frequency (notably
+    // on NTFS). Re-list recent observations until their update quantum has passed.
+    let stable = !snapshot.unsettled?.size;
+    for (const name of snapshot.unsettled ?? []) {
+        unchanged.delete(name);
+        await checkpoint();
+    }
+    const settledBefore = BigInt(Date.now() - 1000) * 1000000n;
+    const recent = (value) => value.mtimeNs > settledBefore || value.ctimeNs > settledBefore;
+    // A single valid timestamp may happen to be millisecond-aligned (common on
+    // NTFS). Classify resolution per device, using only prior guarded observations.
+    const preciseDevices = new Set();
+    for (const observed of snapshot.observations.values()) {
+        if (preciseTimestamp(observed))
+            preciseDevices.add(observed.dev);
+        await checkpoint();
+    }
+    try {
+        // Parents first, including inside each worker batch. A persistent redirect
+        // aborts before probing descendants; all returned metadata stays advisory.
+        for await (const [name, previous, current] of observations(root, snapshot, true, signal)) {
+            if (!preciseDevices.has(previous.dev) || current.mtimeNs < previous.mtimeNs || current.ctimeNs < previous.ctimeNs)
+                return;
+            if (recent(previous) || !sameWatchObservation(previous, current)) {
+                stable = false;
+                unchanged.delete(name);
+                unchanged.delete(parent(name));
+            }
+        }
+        for await (const [name, previous, current] of observations(root, snapshot, false, signal)) {
+            if (!preciseDevices.has(previous.dev) || current.mtimeNs < previous.mtimeNs || current.ctimeNs < previous.ctimeNs)
+                return;
+            if (recent(previous) || !sameWatchObservation(previous, current)) {
+                stable = false;
+                unchanged.delete(parent(name));
+            }
+        }
+    }
+    catch (error) {
+        signal.throwIfAborted();
+        await assertRootIdentityCurrent(root);
+        return;
+    }
+    if (exclude)
+        for (const [name, previous] of snapshot.observations) {
+            await checkpoint();
+            if (!snapshot.entries.has(name) && !snapshot.excluded?.has(name) || !name)
+                continue;
+            // Preserve dynamic exclusion callbacks even when no filesystem entry changed.
+            const kind = (previous.mode & 61440n) === 16384n ? "directory" :
+                (previous.mode & 61440n) === 32768n ? "file" : (previous.mode & 61440n) === 40960n ? "symlink" : "other";
+            let excluded;
+            try {
+                excluded = exclude({ path: name, kind });
+                assertSynchronousCallbackResult(excluded, "watch exclude");
+            }
+            catch (cause) {
+                throw new FsSafeError("helper-failed", "watch exclusion callback failed", { cause, details: { operation: "callback" } });
+            }
+            signal.throwIfAborted();
+            if (Boolean(excluded) !== snapshot.excluded?.has(name))
+                return;
+        }
+    await assertRootIdentityCurrent(root);
+    return { reuse: unchanged, stable };
+}
+/** Fence reused directory observations after traversal, including ancestors swapped during leaf probes. */
+export async function verifyWatchReuse(root, snapshot, reused, signal) {
+    try {
+        for await (const [name, previous, current] of observations(root, snapshot, true, signal)) {
+            if (!sameWatchObservation(previous, current) && reused.has(name))
+                return false;
+        }
+    }
+    catch {
+        signal.throwIfAborted();
+        await assertRootIdentityCurrent(root);
+        return false;
+    }
+    await assertRootIdentityCurrent(root);
+    return true;
+}
+async function* observations(root, snapshot, directories, signal) {
+    let batch = [];
+    const read = async function* () {
+        signal.throwIfAborted();
+        const stats = await watchStats(root, batch.map(([name, previous]) => ({
+            path: directories ? snapshot.directoryPaths.get(name) : path.join(root.rootReal, name),
+            dev: previous.dev, ino: previous.ino, directory: directories,
+        })));
+        for (let n = 0; n < batch.length; n++)
+            yield [batch[n][0], batch[n][1], stats[n]];
+    };
+    const checkpoint = watchYield();
+    const names = directories ? snapshot.directories.keys() : snapshot.observations.keys();
+    for (const name of names) {
+        await checkpoint();
+        if (!directories && snapshot.directories.has(name))
+            continue;
+        const previous = snapshot.observations.get(name);
+        if (!previous)
+            throw new Error("missing guarded watch observation");
+        batch.push([name, previous]);
+        if (batch.length === 32) {
+            yield* read();
+            batch = [];
+        }
+    }
+    if (batch.length)
+        yield* read();
+}

package/node_modules/@openclaw/fs-safe/dist/watch-rescan.d.ts

@@ -3,4 +3,4 @@ import type { WatchSnapshot } from "./watch-scan.js";
 /** Only previously enumerated directories can be reconciled without discovering topology. */
 export declare function watchRescanScopes(scopes: readonly WatchScope[], snapshot: WatchSnapshot, changes: readonly WatchChange[]): readonly WatchScope[] | undefined;
 /** Merge only freshly observed slices. Any topology/anchor ambiguity requires a full pass. */
-export declare function mergeWatchRescan(scopes: readonly WatchScope[], before: WatchSnapshot, slice: WatchSnapshot, requested: readonly WatchScope[]): WatchSnapshot | undefined;
+export declare function mergeWatchRescan(scopes: readonly WatchScope[], before: WatchSnapshot, slice: WatchSnapshot, requested: readonly WatchScope[]): Promise<WatchSnapshot | undefined>;