querysub 0.459.0 → 0.460.0

package/.claude/settings.local.json

@@ -23,7 +23,8 @@
       "mcp__node-debugger__resume",
       "mcp__node-debugger__listBreakpoints",
       "mcp__node-debugger__removeBreakpoint",
-      "mcp__hottest__runTest"
+      "mcp__hottest__runTest",
+      "Bash(yarn test *)"
     ]
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "querysub",
-  "version": "0.459.0",
+  "version": "0.460.0",
   "main": "index.js",
   "license": "MIT",
   "note1": "note on node-forge fork, see https://github.com/digitalbazaar/forge/issues/744 for details",

package/src/config.ts

@@ -134,6 +134,9 @@ export function isPublic() {
     }
     return !!yargObj.public;
 }
+export function setIsPublic(value: boolean) {
+    yargObj.public = value;
+}
 
 /** @deprecated Use !isPublic() instead */
 export function isLocal() {

package/src/deployManager/setupMachineMain.ts

@@ -164,6 +164,15 @@ async function main() {
     // Test command to verify ssh credentials work
     await runPromise(`ssh ${sshRemote} whoami`);
 
+    // Detect Hetzner rescue system — if we're still in rescue, installimage hasn't been run yet
+    let rescueProbe = await runPromise(`ssh ${sshRemote} "hostname; command -v installimage || true"`, { nothrow: true });
+    if (/(^|\n)rescue(\s|$)/i.test(rescueProbe) || /installimage/.test(rescueProbe)) {
+        console.error(`❌ Remote ${sshRemote} appears to be running the Hetzner rescue system (no OS installed yet).`);
+        console.error(`   Run \`installimage\` on the remote first to provision the OS, reboot into the installed system, then re-run \`yarn setup-machine ${sshRemote}\`.`);
+        console.error(`   Detected:\n${rescueProbe.trim()}`);
+        process.exit(1);
+    }
+
     // Setup swap space if not already configured
     console.log("Checking swap configuration...");
     const swapInfo = await runPromise(`ssh ${sshRemote} "free -m | grep Swap"`);

package/src/diagnostics/logs/IndexedLogs/BufferIndex.ts

@@ -300,9 +300,6 @@ export class BufferIndex {
         dataReader: Reader;
         params: SearchParams;
         keepIterating: () => boolean;
-        // Returns true iff the caller actually retained the value. We use that
-        // to drive the per-file matchCount cap below: see the note at the
-        // `matchesPattern(buffer)` call for why we can't blindly count emits.
         onResult: (match: Buffer) => boolean;
         results: IndexedLogResults;
         allSearchUnits: Unit[][];
@@ -331,7 +328,20 @@ export class BufferIndex {
             }, `BufferIndex|readLocalBlocks`);
         });
 
-        let matchCount = 0;
+        // NOTE: The per-file matchCount cap (commented out below in both the
+        // block loop and the inner buffer loop) is intentionally disabled.
+        // We tested (see test.ts) and confirmed that blocks within a file
+        // aren't time-ordered — the move-to-public pipeline can leave a
+        // late-index block holding earlier-time entries than earlier-index
+        // blocks, and buffers within a single block aren't time-ordered
+        // either. The old `matchCount >= params.limit` short-circuit assumed
+        // ordering and was silently dropping blocks whose entries would have
+        // survived the top-K trim (broad queries lost their earliest
+        // matches). Without the cap we scan every candidate block per file,
+        // but the index pre-filter bounds the work and it isn't measurably
+        // slower in practice. If blocks/buffers ever get written in
+        // guaranteed time order this code can be re-enabled.
+        // let matchCount = 0;
         let blockSearchTimeStart = Date.now();
 
         results.totalBlockCount += indexEntries.length;
@@ -344,7 +354,8 @@ export class BufferIndex {
         const step = iterateForward ? 1 : -1;
 
         for (let i = startIdx; iterateForward ? i < endIdx : i > endIdx; i += step) {
-            if (matchCount >= params.limit || !config.keepIterating()) break;
+            // if (matchCount >= params.limit || !config.keepIterating()) break;
+            if (!config.keepIterating()) break;
             await config.results.limitGroup?.wait();
             const blockIndex = i;
 
@@ -393,38 +404,16 @@ export class BufferIndex {
                 const bufferStep = iterateForward ? 1 : -1;
 
                 for (let bufferIndex = bufferStartIdx; iterateForward ? bufferIndex < bufferEndIdx : bufferIndex > bufferEndIdx; bufferIndex += bufferStep) {
-                    // No `matchCount >= params.limit` cap inside the block.
-                    // Buffer order within a block is not guaranteed to follow
-                    // the search direction (blocks are time-ordered, buffers
-                    // inside them are not), so stopping mid-block on a match
-                    // count would drop earlier-time buffers we haven't reached
-                    // yet. The block-level cap above is the only safe stop;
-                    // here we only honor cross-file `keepIterating` (which
-                    // applies to the whole file at once, so it's safe at any
-                    // granularity).
+                    // See the note above the outer loop for why the
+                    // matchCount-based stop is gone.
+                    // if (matchCount >= params.limit || !config.keepIterating()) break;
                     if (!config.keepIterating()) break;
                     await config.results.limitGroup?.wait();
 
                     let buffer = buffers[bufferIndex];
                     if (matchesPattern(buffer)) {
-                        // Only count matches the caller actually kept. `onResult`
-                        // routes through `FindProgressTracker.addResult`, which
-                        // can reject for reasons we don't see from here — most
-                        // notably time-range filtering (an entry whose time is
-                        // outside the search window matched the text pattern
-                        // but isn't a real hit). Counting rejected emits would
-                        // let a stretch of out-of-window matches at the start
-                        // of a file blow the per-file cap and short-circuit the
-                        // scan before we reach the in-window region.
-                        //
-                        // The cost is that we keep matching and calling onResult
-                        // through those out-of-window blocks (mild inefficiency).
-                        // We can't skip ahead — buffers are scanned linearly and
-                        // we don't know up front which entries the caller will
-                        // reject — so this is the best we can do here.
-                        if (config.onResult(buffer)) {
-                            matchCount++;
-                        }
+                        config.onResult(buffer);
+                        // matchCount++;
                     }
                 }
             } catch (e: any) {
@@ -559,9 +548,7 @@ export class BufferIndex {
         params: SearchParams;
 
         keepIterating: () => boolean;
-        // See the note on `findLocal.onResult` — return value drives the
-        // per-file matchCount cap so out-of-window emits don't short-circuit
-        // the scan.
+        // Return value is unused — see `findLocal.onResult`.
         onResult: (match: Buffer) => boolean;
         results: IndexedLogResults;
     }): Promise<{

package/src/diagnostics/logs/IndexedLogs/BufferUnitIndex.ts

@@ -505,9 +505,6 @@ export class BufferUnitIndex {
         params: SearchParams;
         allSearchUnits: Unit[][];
         keepIterating: () => boolean;
-        // Returns true iff the caller actually retained the value. Drives the
-        // `matchCounts` cap below — see the comment at the `matchesPattern`
-        // call for why we can't blindly count emits.
         onResult: (match: Buffer) => boolean;
         index: Buffer;
         reader: Reader;
@@ -534,26 +531,42 @@ export class BufferUnitIndex {
         // Read blocks and search for matches
         let blockSearchTimeStart = Date.now();
         await measureBlock(async () => {
-            let matchCount = 0;
-            let matchCounts = list(blockCount).fill(0);
+            // NOTE: The matchCount / matchCounts tracking and the
+            // `stopIterating` cap below are commented out, not deleted.
+            // We tested (see test.ts) and confirmed that blocks within a
+            // file aren't actually time-ordered — the move-to-public
+            // pipeline can leave a late-index block holding earlier-time
+            // entries than earlier-index blocks. The old `relevantCount
+            // >= params.limit` short-circuit assumed time-ordered blocks
+            // and was silently skipping blocks whose entries would have
+            // survived the top-K trim (broad queries lost their earliest
+            // matches). The same applied to the inner-buffer cap (buffers
+            // within a block aren't time-ordered either). Removing both
+            // caps means we scan every candidate block per file, but the
+            // index pre-filter bounds the work and it isn't measurably
+            // slower in practice. If blocks ever get written in
+            // guaranteed time order, this code can be re-enabled.
+            // let matchCount = 0;
+            // let matchCounts = list(blockCount).fill(0);
 
             const searchBlock = async (blockIndex: number) => {
                 if (!candidateBlocksSet.has(blockIndex)) return;
-                // Check if we should stop iterating based on match counts and direction
-                let stopIterating = () => {
-                    let relevantCount = 0;
-                    if (params.searchFromStart) {
-                        for (let i = 0; i <= blockIndex; i++) {
-                            relevantCount += matchCounts[i];
-                        }
-                    } else {
-                        for (let i = blockIndex; i < blockCount; i++) {
-                            relevantCount += matchCounts[i];
-                        }
-                    }
-                    return relevantCount >= params.limit || !keepIterating();
-                };
-                if (stopIterating()) return;
+                // // Check if we should stop iterating based on match counts and direction
+                // let stopIterating = () => {
+                //     let relevantCount = 0;
+                //     if (params.searchFromStart) {
+                //         for (let i = 0; i <= blockIndex; i++) {
+                //             relevantCount += matchCounts[i];
+                //         }
+                //     } else {
+                //         for (let i = blockIndex; i < blockCount; i++) {
+                //             relevantCount += matchCounts[i];
+                //         }
+                //     }
+                //     return relevantCount >= params.limit || !keepIterating();
+                // };
+                // if (stopIterating()) return;
+                if (!keepIterating()) return;
 
                 let debugOffsets = {
                     startOffset: 0,
@@ -580,38 +593,17 @@ export class BufferUnitIndex {
                     const step = iterateForward ? 1 : -1;
 
                     for (let i = startIdx; iterateForward ? i < endIdx : i > endIdx; i += step) {
-                        // No matchCount-based cap inside the block. Buffer
-                        // order within a block is not guaranteed to follow the
-                        // search direction (blocks are time-ordered, buffers
-                        // inside them are not), so a mid-block stop on
-                        // `relevantCount >= limit` would drop earlier-time
-                        // buffers we haven't reached yet. Block-level
-                        // `stopIterating` is the safe granularity; here we
-                        // only honor cross-file `keepIterating`, which applies
-                        // to the whole file at once.
+                        // See the note at the top of this function for why
+                        // the matchCount-based stop is gone (commented out).
+                        // if (stopIterating()) break;
                         if (!keepIterating()) break;
                         await results.limitGroup?.wait();
 
                         const buffer = await this.getBufferFromBlock(blockReader, i);
                         if (matchesPattern(buffer)) {
-                            // Only count matches the caller actually kept.
-                            // `onResult` routes through
-                            // `FindProgressTracker.addResult`, which can reject
-                            // for reasons opaque to us — most notably
-                            // time-range filtering. Counting rejected emits
-                            // would let a stretch of out-of-window matches at
-                            // the start of a file blow the per-file cap and
-                            // short-circuit the scan before we reach the
-                            // in-window region. The cost is that we keep
-                            // matching and calling onResult through those
-                            // out-of-window blocks (mild inefficiency); we
-                            // can't skip ahead because buffers are scanned
-                            // linearly and we don't know up front which
-                            // entries the caller will reject.
-                            if (config.onResult(buffer)) {
-                                matchCount++;
-                                matchCounts[blockIndex]++;
-                            }
+                            config.onResult(buffer);
+                            // matchCount++;
+                            // matchCounts[blockIndex]++;
                         }
                     }
                 } catch (e: any) {

package/test.ts

@@ -1,81 +1,198 @@
 import { chdir } from "process";
 chdir("D:/repos/qs-cyoa/");
 
+import { isPublic, setIsPublic } from "./src/config";
+setIsPublic(true);
+
 import "./inject";
-import { SocketFunction } from "socket-function/SocketFunction";
-import { NodeCapabilitiesController, getControllerNodeIdList } from "./src/-g-core-values/NodeCapabilities";
-import { delay } from "socket-function/src/batching";
-import { green, yellow } from "socket-function/src/formatting/logColors";
-import { Querysub, t } from "./src/4-querysub/Querysub";
-import { archives, pathValueArchives } from "./src/0-path-value-core/pathValueArchives";
-import { getAllAuthoritySpec } from "./src/0-path-value-core/PathRouterServerAuthoritySpec";
-import { deploySchema } from "./src/4-deploy/deploySchema";
-import { getDomain } from "./src/config";
-import { getProxyPath } from "./src/2-proxy/pathValueProxy";
-import { ClientWatcher } from "./src/1-path-client/pathValueClientWatcher";
-import { RemoteWatcher } from "./src/1-path-client/RemoteWatcher";
-import { PathRouter } from "./src/0-path-value-core/PathRouter";
-import { shutdown } from "./src/diagnostics/periodic";
-import { getShardPrefixes } from "./src/0-path-value-core/ShardPrefixes";
-import { PathValue, epochTime } from "./src/0-path-value-core/pathValueCore";
-import { pathValueSerializer } from "./src/-h-path-value-serialize/PathValueSerializer";
-import { getAllNodeIds } from "./src/-f-node-discovery/NodeDiscovery";
-import { errorToUndefinedSilent } from "./src/errors";
-import { timeoutToUndefinedSilent } from "socket-function/src/misc";
-
-let tempTestSchema = Querysub.createSchema({
-    value: t.number,
-})({
-    domainName: getDomain(),
-    moduleId: "tempTest",
-    module: module,
-    functions: {},
-});
+import { Querysub } from "./src/4-querysub/Querysub";
+import { getLoggers2Async, LogDatum } from "./src/diagnostics/logs/diskLogger";
+import { IndexedLogs } from "./src/diagnostics/logs/IndexedLogs/IndexedLogs";
+import { SearchParams } from "./src/diagnostics/logs/IndexedLogs/BufferIndexHelpers";
+import { formatDateTimeDetailed, formatNumber, formatTime } from "socket-function/src/formatting/format";
+
+// Pulled verbatim from the URLs the user shared.
+const START_TIME = 1779598800000;
+const END_TIME = 1779604200000;
+const LIMIT = 1600;
+const SEARCH_BROAD = `wvupofthbgq & "__threadId":"1f72e0ea774fcc81"`;
+const SEARCH_NARROW = `wvupofthbgq & "__threadId":"1f72e0ea774fcc81" & new`;
+
+type Emit = {
+    time: number;
+    logger: string;
+    datum: LogDatum;
+};
+
+// Stable identity for cross-query comparison. `time` alone isn't unique (many
+// entries share the same ms), so we fold in threadId + entry text.
+function emitKey(e: Emit): string {
+    return `${e.time}|${e.datum.__threadId ?? ""}|${e.datum.__entry ?? ""}|${e.datum.param0 ?? ""}`;
+}
+
+async function runQuery(label: string, searchText: string, limit: number = LIMIT): Promise<Emit[]> {
+    console.log(`\n=== ${label}: ${JSON.stringify(searchText)} (limit=${limit}) ===`);
+    let loggers = await getLoggers2Async();
+    let allLoggers: { name: string; logger: IndexedLogs<LogDatum> }[] = [
+        { name: "info", logger: loggers.infoLogs },
+    ];
+
+    let params: SearchParams = {
+        startTime: START_TIME,
+        endTime: END_TIME,
+        limit,
+        findBuffer: Buffer.from(searchText, "utf8"),
+        searchFromStart: true,
+        only: "public",
+    };
+
+    let allEmits: Emit[] = [];
+    let queryStart = Date.now();
+
+    await Promise.all(allLoggers.map(async ({ name, logger }) => {
+        let perLoggerEmits: Emit[] = [];
+        let loggerStart = Date.now();
+        let result = await logger.find({
+            params,
+            onResult: (match: LogDatum) => {
+                perLoggerEmits.push({ time: match.time, logger: name, datum: match });
+            },
+        });
+
+        let earliest = perLoggerEmits.length > 0 ? Math.min(...perLoggerEmits.map(e => e.time)) : undefined;
+        let latest = perLoggerEmits.length > 0 ? Math.max(...perLoggerEmits.map(e => e.time)) : undefined;
+        console.log(
+            `  [${name}] emits=${perLoggerEmits.length} ` +
+            `matchCount=${result.matchCount} ` +
+            `blocksChecked=${result.blockCheckedCount}/${result.totalBlockCount} ` +
+            `filesScanned=${result.backblazeFilesSearched}/${result.totalBackblazeFiles} ` +
+            `earliest=${earliest !== undefined ? formatDateTimeDetailed(earliest) : "—"} ` +
+            `latest=${latest !== undefined ? formatDateTimeDetailed(latest) : "—"} ` +
+            `time=${formatTime(Date.now() - loggerStart)}`
+        );
+        allEmits.push(...perLoggerEmits);
+    }));
+
+    console.log(`  total emits=${allEmits.length} in ${formatTime(Date.now() - queryStart)}`);
+
+    // Sort + trim to limit (mirroring the client-side display).
+    allEmits.sort((a, b) => a.time - b.time);
+    if (allEmits.length > limit) allEmits.length = limit;
+
+    console.log(
+        `  kept top-${allEmits.length} ` +
+        `earliest=${allEmits.length > 0 ? formatDateTimeDetailed(allEmits[0].time) : "—"} ` +
+        `latest=${allEmits.length > 0 ? formatDateTimeDetailed(allEmits[allEmits.length - 1].time) : "—"}`
+    );
+    return allEmits;
+}
 
 async function main() {
     await Querysub.hostService("test");
 
-    // let testValues: PathValue[] = [];
-    // let buffers = await pathValueSerializer.serialize(testValues);
-    // let values = await pathValueSerializer.deserialize(buffers);
+    // Dump every info file in range — declared startTime / endTime — so we
+    // can spot files whose declared range disagrees with the entries inside.
+    let loggers = await getLoggers2Async();
+    let paths = await loggers.infoLogs.getPaths({
+        startTime: START_TIME,
+        endTime: END_TIME,
+        only: "public",
+    });
+    paths.sort((a, b) => a.startTime - b.startTime);
+    console.log(`\n=== INFO FILES IN RANGE (${paths.length}) — declared ranges ===`);
+    for (let p of paths) {
+        console.log(`  start=${formatDateTimeDetailed(p.startTime)} end=${formatDateTimeDetailed(p.endTime)} logCount=${p.logCount ?? "?"} ${p.fullPath}`);
+    }
 
-    //let values = await pathValueArchives.loadValues(await getAllAuthoritySpec());
+    let broad = await runQuery("BROAD", SEARCH_BROAD);
+    let narrow = await runQuery("NARROW", SEARCH_NARROW);
+    // Sanity: run broad again with a huge limit. If those 4 entries appear
+    // here but not in the limit=1600 run, the per-file `stopIterating` cap is
+    // skipping the block that contains them. If they're still missing, the
+    // bug is upstream (index pre-filter or block scanner missing them).
+    let broadHuge = await runQuery("BROAD_HUGE", SEARCH_BROAD, 1_000_000);
 
-    let nodes = await getAllNodeIds();
-    let values = await Promise.all(nodes.map(async node => {
-        let metadata = await timeoutToUndefinedSilent(5000, NodeCapabilitiesController.nodes[node].getMetadata());
-        return metadata?.entryPoint;
-    }));
-    console.log({ values });
-
-    // let path = getProxyPath(() => tempTestSchema.data().value);
-    // console.log({ path });
-    // let authorities = PathRouter.getAllAuthorities(path);
-    // for (let authority of authorities) {
-    //     console.log({ authority });
-    // }
-
-    // ClientWatcher.DEBUG_READS = true;
-    // ClientWatcher.DEBUG_WRITES = true;
-    // RemoteWatcher.DEBUG = true;
-
-    // let value = await Querysub.commitAsync(() => tempTestSchema.data().value);
-    // console.log({ value });
-    // await Querysub.commitAsync(() => tempTestSchema.data().value++, { doNotStoreWritesAsPredictions: true });
-    // await delay(3000);
-    // let value2 = await Querysub.commitAsync(() => tempTestSchema.data().value);
-    // console.log({ value2 });
-
-    // await shutdown();
-
-    // let test = await Querysub.commitAsync(() => {
-    //     let live = deploySchema()[getDomain()].deploy.live.hash;
-    //     console.log({ live });
-    //     return String(live);
-    // });
-    // console.log({ test });
+    // The diagnostic: narrow ⊂ broad by definition. So every narrow result
+    // whose time falls inside broad's kept window MUST appear in broad. If any
+    // are missing, the broad scan dropped them — that's the bug.
+    if (broad.length === 0 || narrow.length === 0) {
+        console.log(`\nSkipping comparison: broad=${broad.length} narrow=${narrow.length}`);
+        return;
+    }
+
+    let broadKeys = new Set(broad.map(emitKey));
+    let broadCutoff = broad[broad.length - 1].time;
+    let broadEarliest = broad[0].time;
+
+    console.log(`\n=== COMPARE ===`);
+    console.log(`broad window: [${formatDateTimeDetailed(broadEarliest)}, ${formatDateTimeDetailed(broadCutoff)}]`);
+
+    let narrowInWindow = narrow.filter(n => n.time <= broadCutoff);
+    let missing = narrowInWindow.filter(n => !broadKeys.has(emitKey(n)));
+
+    console.log(`narrow total: ${narrow.length}`);
+    console.log(`narrow within broad window (<= broad cutoff): ${narrowInWindow.length}`);
+    console.log(`narrow missing from broad kept top-K: ${missing.length}`);
+
+    if (missing.length > 0) {
+        console.log(`\nFirst ${Math.min(20, missing.length)} missing entries (these prove broad dropped them):`);
+        for (let m of missing.slice(0, 20)) {
+            console.log(
+                `  time=${formatDateTimeDetailed(m.time)} ` +
+                `logger=${m.logger} ` +
+                `entry=${(m.datum.__entry ?? "").slice(0, 80)} ` +
+                `param0=${String(m.datum.param0 ?? "").slice(0, 80)}`
+            );
+        }
+
+        // Group missing by logger so we can tell which scan dropped them.
+        let byLogger = new Map<string, number>();
+        for (let m of missing) byLogger.set(m.logger, (byLogger.get(m.logger) ?? 0) + 1);
+        console.log(`\nMissing by logger:`);
+        for (let [k, v] of byLogger) console.log(`  ${k}: ${formatNumber(v)}`);
+    } else {
+        console.log(`\nNo missing entries — broad correctly contains all narrow results in its window.`);
+    }
+
+    // For each missing entry, identify the file whose declared range *should*
+    // cover its time, and find the file whose declared range *doesn't* cover
+    // it (the bug indicator).
+    if (missing.length > 0) {
+        let missingTimes = missing.map(m => m.time);
+        let minMissing = Math.min(...missingTimes);
+        let maxMissing = Math.max(...missingTimes);
+        console.log(`\nMissing entry times span: [${formatDateTimeDetailed(minMissing)}, ${formatDateTimeDetailed(maxMissing)}]`);
+        console.log(`Files whose declared range overlaps [${formatDateTimeDetailed(minMissing)}, ${formatDateTimeDetailed(maxMissing)}]:`);
+        for (let p of paths) {
+            if (p.endTime < minMissing || p.startTime > maxMissing) continue;
+            console.log(`  start=${formatDateTimeDetailed(p.startTime)} end=${formatDateTimeDetailed(p.endTime)} ${p.fullPath}`);
+        }
+        // Also: any file whose declared startTime > broad cutoff (and so would
+        // be isSourceRelevant-pruned) — these are candidates for the bug.
+        console.log(`Files whose declared startTime > broad cutoff (${formatDateTimeDetailed(broadCutoff)}) — these would be pruned by isSourceRelevant once broad fills:`);
+        for (let p of paths) {
+            if (p.startTime > broadCutoff) {
+                let overlap = p.startTime <= maxMissing && p.endTime >= minMissing ? "  <- OVERLAPS MISSING" : "";
+                console.log(`  start=${formatDateTimeDetailed(p.startTime)} end=${formatDateTimeDetailed(p.endTime)} ${p.fullPath}${overlap}`);
+            }
+        }
+    }
+
+    // Check whether broad-with-huge-limit catches the missing entries.
+    let broadHugeKeys = new Set(broadHuge.map(emitKey));
+    let stillMissingFromHuge = narrow.filter(n => !broadHugeKeys.has(emitKey(n)));
+    console.log(`\n=== BROAD_HUGE check ===`);
+    console.log(`narrow missing from broad_huge: ${stillMissingFromHuge.length}`);
+    if (stillMissingFromHuge.length > 0) {
+        console.log(`First ${Math.min(20, stillMissingFromHuge.length)} still-missing:`);
+        for (let m of stillMissingFromHuge.slice(0, 20)) {
+            console.log(`  time=${formatDateTimeDetailed(m.time)} param0=${String(m.datum.param0 ?? "").slice(0, 60)}`);
+        }
+        console.log(`-> bug is NOT (only) the per-file cap; the scanner / index pre-filter is dropping entries even without the cap.`);
+    } else {
+        console.log(`-> all narrow entries are in broad_huge; the per-file stopIterating cap is the culprit for the limit=1600 miss.`);
+    }
 }
 
-main().catch(console.error)
-    .finally(() => process.exit(0))
-    ;
+main().catch(e => console.error((e as Error).stack ?? e))
+    .finally(() => process.exit(0));