pi-lens 3.8.73 → 4.0.0

package/dist/clients/bash-file-access.js

@@ -15,10 +15,8 @@
  */
 import * as nodeFs from "node:fs";
 import * as path from "node:path";
+import { isReadableSourceFile } from "./file-kinds.js";
 import { countFileLines } from "./read-guard-tool-lines.js";
-// Source-ish extensions worth registering. Anchored end-check → linear (no
-// catastrophic backtracking).
-const READABLE_EXT_RE = /\.(?:ts|tsx|js|jsx|mjs|cjs|py|sh|rs|go|cs|java|kt|rb|php|c|cpp|cc|h|hpp|json|jsonc|yaml|yml|toml|md|txt|env|cfg|conf|ini|html|css|scss|less|xml|sql|vue|svelte)$/i;
 function stripQuotes(token) {
     if (token.length >= 2) {
         const first = token[0];
@@ -32,14 +30,123 @@ function stripQuotes(token) {
 function stripAnsi(value) {
     return value.replace(/\x1b\[[0-9;?]*[ -/]*[@-~]/g, "");
 }
-function tokenizeSegment(segment) {
-    const matches = segment.match(/'[^']*'|"(?:[^"\\]|\\.)*"|\S+/g);
-    return matches ?? [];
+export function tokenizeShellCommand(command) {
+    const segments = [];
+    let tokens = [];
+    let word = "";
+    let quote;
+    let escaped = false;
+    let unsupported = false;
+    let atTokenStart = true;
+    const flushWord = () => {
+        if (word)
+            tokens.push(word);
+        word = "";
+        atTokenStart = true;
+    };
+    const flushSegment = () => {
+        flushWord();
+        if (tokens.length > 0 || unsupported)
+            segments.push({ tokens, unsupported });
+        tokens = [];
+        unsupported = false;
+        atTokenStart = true;
+    };
+    for (let i = 0; i < command.length; i++) {
+        const ch = command[i];
+        const next = command[i + 1];
+        if (quote === "single") {
+            if (ch === "'")
+                quote = undefined;
+            else
+                word += ch;
+            continue;
+        }
+        if (quote === "double") {
+            if (escaped) {
+                word += ch;
+                escaped = false;
+            }
+            else if (ch === "\\")
+                escaped = true;
+            else if (ch === '"')
+                quote = undefined;
+            else
+                word += ch;
+            continue;
+        }
+        if (escaped) {
+            // A backslash-newline is a shell line continuation, not part of the
+            // command argument. Keeping the newline here makes a continued git command
+            // visible to command guards.
+            if (ch !== "\n")
+                word += ch;
+            escaped = false;
+            atTokenStart = false;
+            continue;
+        }
+        if (ch === "\\") {
+            // Bash uses backslash as a general escape, but command inputs on
+            // Windows routinely contain native paths (C:\\src\\file.ts). Preserve
+            // backslashes before ordinary path characters while still honoring
+            // shell escapes and line continuations.
+            if (next === "\n" || /[\s\\'\";$|&<>]/.test(next ?? "")) {
+                escaped = true;
+            }
+            else {
+                word += ch;
+                atTokenStart = false;
+            }
+            atTokenStart = false;
+            continue;
+        }
+        if (ch === "'") {
+            quote = "single";
+            atTokenStart = false;
+            continue;
+        }
+        if (ch === '"') {
+            quote = "double";
+            atTokenStart = false;
+            continue;
+        }
+        if (ch === "#" && atTokenStart) {
+            while (i + 1 < command.length && command[i + 1] !== "\n")
+                i++;
+            continue;
+        }
+        if (/\s/.test(ch)) {
+            flushWord();
+            continue;
+        }
+        if (ch === ";" || ch === "\n" || ch === "|" || ch === "&") {
+            flushWord();
+            if (ch === "|" && next === "|")
+                i++;
+            else if (ch === "&" && next === "&")
+                i++;
+            else if (ch === "|" || ch === "&")
+                unsupported = true;
+            flushSegment();
+            continue;
+        }
+        if (ch === "<" || ch === ">") {
+            flushWord();
+            unsupported = true;
+            continue;
+        }
+        word += ch;
+        atTokenStart = false;
+    }
+    if (quote || escaped)
+        unsupported = true;
+    flushSegment();
+    return segments;
 }
 /** Resolve a token to an absolute path if it looks like a source file. */
 function resolveCandidate(token, cwd) {
     const cleaned = stripQuotes(token);
-    if (!cleaned || cleaned.startsWith("-") || !READABLE_EXT_RE.test(cleaned)) {
+    if (!cleaned || cleaned.startsWith("-") || !isReadableSourceFile(cleaned)) {
         return null;
     }
     return path.isAbsolute(cleaned) ? cleaned : path.resolve(cwd, cleaned);
@@ -52,8 +159,67 @@ function parseCountFlag(token) {
     const n = Number.parseInt(digits, 10);
     return Number.isFinite(n) && n > 0 ? n : undefined;
 }
-function splitSegments(command) {
-    return command.split(/&&|\|\||[;|\n]/);
+function commandSegments(command) {
+    return tokenizeShellCommand(command).map((segment) => segment.tokens);
+}
+/** Find redirect targets without treating quoted `>` characters as syntax. */
+function extractRedirectTargets(command) {
+    const targets = [];
+    let quote;
+    let escaped = false;
+    for (let i = 0; i < command.length; i += 1) {
+        const ch = command[i];
+        if (quote === "single") {
+            if (ch === "'")
+                quote = undefined;
+            continue;
+        }
+        if (quote === "double") {
+            if (escaped)
+                escaped = false;
+            else if (ch === "\\")
+                escaped = true;
+            else if (ch === '"')
+                quote = undefined;
+            continue;
+        }
+        if (escaped) {
+            escaped = false;
+            continue;
+        }
+        if (ch === "\\") {
+            escaped = true;
+            continue;
+        }
+        if (ch === "'") {
+            quote = "single";
+            continue;
+        }
+        if (ch === '"') {
+            quote = "double";
+            continue;
+        }
+        if (ch !== ">")
+            continue;
+        while (i + 1 < command.length && /\s/.test(command[i + 1]))
+            i += 1;
+        if (command[i + 1] === ">")
+            i += 1;
+        while (i + 1 < command.length && /\s/.test(command[i + 1]))
+            i += 1;
+        let target = "";
+        for (i += 1; i < command.length; i += 1) {
+            const next = command[i];
+            if (/\s/.test(next) || next === ";" || next === "|" || next === "&") {
+                i -= 1;
+                break;
+            }
+            target += next;
+        }
+        if (target)
+            targets.push(target);
+    }
+    return targets;
 }
 /**
  * Extract the line ranges a bash command explicitly showed the agent.
@@ -93,11 +259,9 @@ export function extractReadPathsFromCommand(command, cwd) {
         seen.add(key);
         spans.push({ filePath: file.abs, offset, limit });
     };
-    for (const rawSegment of splitSegments(command)) {
-        const segment = rawSegment.trim();
-        if (!segment)
+    for (const tokens of commandSegments(command)) {
+        if (tokens.length === 0)
             continue;
-        const tokens = segment.split(/\s+/);
         const verb = path.basename(tokens[0] ?? "");
         const args = tokens.slice(1);
         if (["cat", "bat", "less", "more", "nl"].includes(verb)) {
@@ -247,8 +411,7 @@ function parseGrepLineWithoutFile(line, file) {
 function collectGrepCommandFiles(command, cwd) {
     const files = new Set();
     let hasLineNumberGrep = false;
-    for (const rawSegment of splitSegments(command)) {
-        const tokens = tokenizeSegment(rawSegment.trim());
+    for (const tokens of commandSegments(command)) {
         const verb = path.basename(stripQuotes(tokens[0] ?? ""));
         if (verb !== "grep" && verb !== "egrep" && verb !== "fgrep")
             continue;
@@ -311,15 +474,22 @@ export function extractWrittenPathsFromCommand(command, cwd) {
         if (abs)
             out.add(abs);
     };
-    for (const rawSegment of splitSegments(command)) {
-        const segment = rawSegment.trim();
-        if (!segment)
+    for (const tokens of commandSegments(command)) {
+        if (tokens.length === 0)
+            continue;
+        // Redirect targets are collected by a quote-aware scanner. The shared
+        // tokenizer supplies the normalized command arguments; it deliberately
+        // does not expose shell redirection operators as arguments.
+        for (const target of extractRedirectTargets(command))
+            add(target);
+        // A command may contain multiple segments; only the first pass should
+        // attach redirects, otherwise targets would be duplicated harmlessly but
+        // needlessly rescanned.
+        break;
+    }
+    for (const tokens of commandSegments(command)) {
+        if (tokens.length === 0)
             continue;
-        // Redirect targets: the token after `>` / `>>` (optionally prefixed by a
-        // file descriptor like `2>` or `&>`, with or without a space).
-        for (const m of segment.matchAll(/>>?\s*([^\s>|&]+)/g))
-            add(m[1]);
-        const tokens = segment.split(/\s+/);
         const verb = path.basename(tokens[0] ?? "");
         const args = tokens.slice(1);
         if (verb === "tee" || verb === "touch") {

package/dist/clients/biome-client.js

@@ -7,12 +7,15 @@
  * Requires: npm install @biomejs/biome (or npx @biomejs/biome)
  * Docs: https://biomejs.dev/
  */
+import { createSubsystemLogger } from "./extension-log.js";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { isFileKind } from "./file-kinds.js";
 import { getGlobalPiLensDir } from "./file-utils.js";
 import { findGlobalBinary } from "./package-manager.js";
 import { safeSpawnAsync } from "./safe-spawn.js";
+import { biomeConfigArgs } from "./tool-policy.js";
+import { resolveManagedToolClient } from "./dispatch/runners/utils/runner-helpers.js";
 // --- Client ---
 export class BiomeClient {
     biomeAvailable = null;
@@ -29,7 +32,7 @@ export class BiomeClient {
     log;
     constructor(verbose = false) {
         this.log = verbose
-            ? (msg) => console.error(`[biome] ${msg}`)
+            ? createSubsystemLogger("biome")
             : () => { };
     }
     /**
@@ -87,7 +90,7 @@ export class BiomeClient {
     }
     async spawnBiomeAsync(args, timeout = 15000, cwd) {
         const { cmd, args: prefix } = await this.getBiomeBinary(cwd);
-        return safeSpawnAsync(cmd, [...prefix, ...args], { timeout });
+        return safeSpawnAsync(cmd, [...prefix, ...args], { timeout, cwd });
     }
     /**
      * Ensure Biome is available, auto-installing if necessary.
@@ -112,27 +115,22 @@ export class BiomeClient {
         }
     }
     async doEnsureAvailable() {
-        // Check if already available
-        const result = await this.spawnBiomeAsync(["--version"], 10000);
-        if (!result.error && result.status === 0) {
-            this.biomeAvailable = true;
-            return true;
-        }
-        // Auto-install via pi-lens installer
-        this.log("Biome not found, attempting auto-install...");
-        const { ensureTool } = await import("./installer/index.js");
-        const installedPath = await ensureTool("biome");
-        if (installedPath) {
-            this.log(`Biome auto-installed: ${installedPath}`);
-            // Set the installed path as the global fallback so every cwd
-            // reaches it after its own per-package lookup misses.
-            this.autoInstalledBinaryPath = installedPath;
-            this.biomeAvailable = true;
-            return true;
-        }
-        this.log("Biome auto-install failed");
-        this.biomeAvailable = false;
-        return false;
+        const outcome = await resolveManagedToolClient({
+            toolId: "biome",
+            cwd: process.cwd(),
+            probe: async () => {
+                const result = await this.spawnBiomeAsync(["--version"], 10000);
+                return !result.error && result.status === 0
+                    ? { outcome: "success", value: true }
+                    : { outcome: "missing" };
+            },
+            acceptInstalled: (installedPath) => {
+                this.autoInstalledBinaryPath = installedPath;
+                return true;
+            },
+        });
+        this.biomeAvailable = outcome.outcome === "success";
+        return this.biomeAvailable;
     }
     /**
      * Check if a file is supported by Biome
@@ -142,8 +140,10 @@ export class BiomeClient {
     }
     /**
      * Async auto-fix variant for pipeline use (non-blocking spawn).
+     * `cwd` is the dispatch language root (used for config discovery); when
+     * omitted it defaults to the file's directory.
      */
-    async fixFileAsync(filePath) {
+    async fixFileAsync(filePath, cwd) {
         if (!(await this.ensureAvailable())) {
             return {
                 success: false,
@@ -163,7 +163,11 @@ export class BiomeClient {
         }
         try {
             const before = await fs.promises.readFile(absolutePath, "utf-8");
-            const result = await this.spawnBiomeAsync(["lint", "--write", absolutePath], 15000, path.dirname(absolutePath));
+            const configCwd = cwd ?? path.dirname(absolutePath);
+            // Shared config-args seam (#1247): the lint runner consumes the same
+            // builder, so `lint --write` can never drift to biome's default
+            // config when a user config or the package fallback exists.
+            const result = await this.spawnBiomeAsync(["lint", "--write", ...biomeConfigArgs(configCwd), absolutePath], 15000, configCwd);
             if (result.error) {
                 return {
                     success: false,

package/dist/clients/bootstrap.js

@@ -1,3 +1,4 @@
+import { logExtension } from "./extension-log.js";
 let bootstrapPromise = null;
 /**
  * A stand-in for an analysis client whose module failed to load (an unresolved
@@ -28,11 +29,19 @@ export function degradedClient() {
  */
 async function logBootstrapFailures(failures) {
     for (const { name, err } of failures) {
-        console.error(`[pi-lens] analyzer "${name}" disabled (degraded mode): ${err?.message ?? String(err)}`);
+        logExtension({
+            subsystem: "bootstrap",
+            message: `analyzer "${name}" disabled (degraded mode): ${err?.message ?? String(err)}`,
+            metadata: { analyzer: name },
+        });
     }
     try {
         const { collectInstallDiagnostics, formatInstallDiagnostics } = await import("./install-diagnostics.js");
-        console.error(formatInstallDiagnostics(collectInstallDiagnostics(), failures[0]?.err));
+        logExtension({
+            subsystem: "bootstrap",
+            message: formatInstallDiagnostics(collectInstallDiagnostics(), failures[0]?.err),
+            metadata: { kind: "install_diagnostics" },
+        });
     }
     catch {
         // the per-analyzer lines above already named the failures

package/dist/clients/bounded-cache.js

@@ -0,0 +1,34 @@
+/** Small insertion-ordered LRU used for process-lifetime memo tables. */
+export class BoundedLruCache {
+    maxEntries;
+    entries = new Map();
+    constructor(maxEntries) {
+        this.maxEntries = maxEntries;
+    }
+    get(key) {
+        const value = this.entries.get(key);
+        if (value !== undefined) {
+            this.entries.delete(key);
+            this.entries.set(key, value);
+        }
+        return value;
+    }
+    has(key) { return this.entries.has(key); }
+    set(key, value) {
+        this.entries.delete(key);
+        this.entries.set(key, value);
+        while (this.entries.size > this.maxEntries) {
+            const oldest = this.entries.keys().next().value;
+            if (oldest === undefined)
+                break;
+            this.entries.delete(oldest);
+        }
+    }
+    delete(key) { return this.entries.delete(key); }
+    clear() { this.entries.clear(); }
+    get size() { return this.entries.size; }
+    keys() { return this.entries.keys(); }
+    values() { return this.entries.values(); }
+    entriesArray() { return [...this.entries.entries()]; }
+    [Symbol.iterator]() { return this.entries[Symbol.iterator](); }
+}

package/dist/clients/bounded-pid-file-lock.js

@@ -0,0 +1,192 @@
+import { randomUUID } from "node:crypto";
+import * as fs from "node:fs";
+import fsp from "node:fs/promises";
+import path from "node:path";
+const waitArray = new Int32Array(new SharedArrayBuffer(4));
+function ownerPidIsLive(pid) {
+    if (!Number.isSafeInteger(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code === "EPERM";
+    }
+}
+function quarantinePath(lockPath, token) {
+    return `${lockPath}.quarantine-${process.pid}-${token}`;
+}
+async function restoreQuarantinedLock(lockPath, quarantined) {
+    try {
+        await fsp.rename(quarantined, lockPath);
+    }
+    catch {
+        // A replacement owner may already hold the canonical name. Never overwrite it.
+    }
+}
+async function releaseQuarantineLock(lockPath, token) {
+    const quarantined = quarantinePath(lockPath, `release-${token}`);
+    let renamed = false;
+    for (let attempt = 0; attempt < 3; attempt += 1) {
+        try {
+            await fsp.rename(lockPath, quarantined);
+            renamed = true;
+            break;
+        }
+        catch (error) {
+            if (error.code !== "ENOENT" ||
+                attempt === 2)
+                return;
+            await new Promise((resolve) => setImmediate(resolve));
+        }
+    }
+    if (!renamed)
+        return;
+    try {
+        const owner = JSON.parse(await fsp.readFile(path.join(quarantined, "owner.json"), "utf8"));
+        if (owner.token === token) {
+            await fsp.rm(quarantined, { recursive: true, force: true });
+        }
+        else {
+            await restoreQuarantinedLock(lockPath, quarantined);
+        }
+    }
+    catch {
+        await restoreQuarantinedLock(lockPath, quarantined);
+    }
+}
+function quarantineOwnerIsStale(owner, staleMs) {
+    return Number.isInteger(owner.pid) && owner.pid > 0 &&
+        Number.isFinite(owner.createdAt) &&
+        (!ownerPidIsLive(owner.pid) || Date.now() - owner.createdAt > staleMs);
+}
+async function reclaimQuarantineLock(lockPath, staleMs) {
+    const quarantined = quarantinePath(lockPath, `reclaim-${Date.now()}-${randomUUID()}`);
+    try {
+        await fsp.rename(lockPath, quarantined);
+    }
+    catch {
+        return false;
+    }
+    let stale = false;
+    try {
+        const owner = JSON.parse(await fsp.readFile(path.join(quarantined, "owner.json"), "utf8"));
+        stale = quarantineOwnerIsStale(owner, staleMs);
+    }
+    catch {
+        try {
+            stale = Date.now() - (await fsp.stat(quarantined)).mtimeMs > staleMs;
+        }
+        catch {
+            stale = false;
+        }
+    }
+    if (stale) {
+        await fsp.rm(quarantined, { recursive: true, force: true });
+        return true;
+    }
+    await restoreQuarantinedLock(lockPath, quarantined);
+    return false;
+}
+async function tryAcquireQuarantineLock(lockPath, staleMs) {
+    const owner = {
+        pid: process.pid,
+        createdAt: Date.now(),
+        token: `${process.pid}-${Date.now()}-${randomUUID()}`,
+    };
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+        try {
+            await fsp.mkdir(lockPath);
+            try {
+                await fsp.writeFile(path.join(lockPath, "owner.json"), JSON.stringify(owner), "utf8");
+            }
+            catch (error) {
+                await fsp.rm(lockPath, { recursive: true, force: true }).catch(() => { });
+                throw error;
+            }
+            return () => releaseQuarantineLock(lockPath, owner.token);
+        }
+        catch (error) {
+            if (error.code !== "EEXIST")
+                throw error;
+        }
+        let stale;
+        try {
+            const existing = JSON.parse(await fsp.readFile(path.join(lockPath, "owner.json"), "utf8"));
+            stale = quarantineOwnerIsStale(existing, staleMs);
+        }
+        catch {
+            try {
+                stale = Date.now() - (await fsp.stat(lockPath)).mtimeMs > staleMs;
+            }
+            catch {
+                stale = true;
+            }
+        }
+        if (!stale || !(await reclaimQuarantineLock(lockPath, staleMs)))
+            return null;
+    }
+    return null;
+}
+export async function acquireQuarantinePidFileLock(lockPath, options) {
+    const deadline = Date.now() + options.waitMs;
+    for (;;) {
+        const release = await tryAcquireQuarantineLock(lockPath, options.staleMs);
+        if (release)
+            return release;
+        const remaining = deadline - Date.now();
+        if (remaining <= 0) {
+            if (options.onContention === "skip-log") {
+                options.logContention();
+                return null;
+            }
+            throw new Error(options.timeoutMessage);
+        }
+        await new Promise((resolve) => setTimeout(resolve, Math.min(options.retryMs, remaining)));
+    }
+}
+export function acquireBoundedPidFileLock(lockPath, options) {
+    const token = `${process.pid}:${Date.now()}:${randomUUID()}`;
+    const deadline = Date.now() + options.waitMs;
+    for (;;) {
+        try {
+            const fd = fs.openSync(lockPath, "wx");
+            fs.writeFileSync(fd, token, "utf8");
+            fs.closeSync(fd);
+            return () => {
+                try {
+                    if (fs.readFileSync(lockPath, "utf8") === token) {
+                        fs.unlinkSync(lockPath);
+                    }
+                }
+                catch {
+                    // Protected write completed; cleanup is best-effort.
+                }
+            };
+        }
+        catch (error) {
+            if (error.code !== "EEXIST")
+                throw error;
+            try {
+                const [pidText] = fs.readFileSync(lockPath, "utf8").split(":", 1);
+                if (!ownerPidIsLive(Number.parseInt(pidText ?? "", 10))) {
+                    fs.unlinkSync(lockPath);
+                    continue;
+                }
+            }
+            catch (lockError) {
+                if (lockError.code === "ENOENT")
+                    continue;
+            }
+            if (Date.now() >= deadline) {
+                if (options.onContention === "skip-log") {
+                    options.logContention();
+                    return null;
+                }
+                throw new Error(options.timeoutMessage);
+            }
+            Atomics.wait(waitArray, 0, 0, options.retryMs);
+        }
+    }
+}

package/dist/clients/bus-events-logger.js

@@ -36,8 +36,12 @@ import * as path from "node:path";
 import { isTestMode } from "./env-utils.js";
 import { getGlobalPiLensDir } from "./file-utils.js";
 import { createNdjsonLogger } from "./ndjson-logger.js";
+import { getMaxLogSizeMB } from "./log-cleanup.js";
 const BUS_EVENTS_LOG_FILE = path.join(getGlobalPiLensDir(), "bus-events.log");
-const writer = createNdjsonLogger({ filePath: BUS_EVENTS_LOG_FILE });
+const writer = createNdjsonLogger({
+    filePath: BUS_EVENTS_LOG_FILE,
+    maxBytes: getMaxLogSizeMB() * 1024 * 1024,
+});
 export function logBusEvent(entry) {
     if (isTestMode()) {
         return;

package/dist/clients/bus-publish.js

@@ -20,9 +20,10 @@
 import { logBusEvent } from "./bus-events-logger.js";
 import { normalizeFilePath } from "./path-utils.js";
 import { appendRecentTouches } from "./recent-touches.js";
+import { createLiveBusEmitter, recordStaleBusFailure, } from "./live-bus-emitter.js";
 export const BUS_FILES_TOUCHED_EVENT = "pilens:files:touched";
 export const BUS_FILES_TOUCHED_VERSION = 1;
-let busEmit;
+const liveEmitter = createLiveBusEmitter();
 let hasLoggedFailure = false;
 // Log-once-per-process guards for the two structural-no-op outcomes below
 // (see bus-events-logger.ts's module doc for why these aren't logged on
@@ -38,11 +39,14 @@ let hasLoggedDisabled = false;
  * no `pi.events`).
  */
 export function wireBusEmitter(emitFn) {
-    busEmit = emitFn;
+    liveEmitter.wire(emitFn);
+}
+export function wireBusEmitterGetter(getter) {
+    liveEmitter.wireGetter(getter);
 }
 /** Test-only: reset module state between test files. */
 export function _resetForTests() {
-    busEmit = undefined;
+    liveEmitter.reset();
     hasLoggedFailure = false;
     hasLoggedUnwired = false;
     hasLoggedDisabled = false;
@@ -102,6 +106,7 @@ export function publishFilesTouched(args) {
     }).catch((err) => {
         args.dbg?.(`bus-publish: recent-touches append failed: ${err}`);
     });
+    const busEmit = liveEmitter.get();
     if (!busEmit) {
         if (!hasLoggedUnwired) {
             hasLoggedUnwired = true;
@@ -129,6 +134,7 @@ export function publishFilesTouched(args) {
             }));
         }
         busEmit(BUS_FILES_TOUCHED_EVENT, payload);
+        hasLoggedFailure = false;
         logBusEvent({
             event: BUS_FILES_TOUCHED_EVENT,
             outcome: "emitted",
@@ -147,6 +153,7 @@ export function publishFilesTouched(args) {
         });
         if (!hasLoggedFailure) {
             hasLoggedFailure = true;
+            recordStaleBusFailure(BUS_FILES_TOUCHED_EVENT, err);
             args.dbg?.(`bus-publish: pilens:files:touched emit failed (further failures suppressed): ${err}`);
         }
     }