sliftutils 1.7.65 → 1.7.67

package/CLAUDE.md

@@ -45,6 +45,7 @@ from `.cursor/rules/*.mdc` so Claude reads them automatically.
 - Avoid callback hell with `import { PromiseObj } from "socket-function/src/misc";` — wrap event callbacks in a `PromiseObj` and await it.
 - `import { keyBy, keyByArray } from "socket-function/src/misc";` for building lookups.
 - Never use `alert`. Throw instead.
+- Always use the helper functions for potentially large numbers (> 1000), and time spans. For time spans, it takes the time in terms of milliseconds. For example, 5,000 would be formatted as 5 seconds. `import { formatNumber, formatTime } from "socket-function/src/formatting/format";`
 
 ## MobX state
 

package/dist/test.ts.cache

@@ -1,48 +1,199 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule && mod.default) ? mod : { "default": mod };
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
-const net_1 = __importDefault(require("net"));
-const forwardPort_1 = require("socket-function/src/forwardPort");
-const TEST_PORT = 5299;
-const EXTERNAL_IP = "99.250.124.91";
-function testConnect(host, port) {
-    return new Promise(resolve => {
-        let socket = net_1.default.connect({ host, port, timeout: 8000 });
-        socket.on("connect", () => {
-            socket.destroy();
-            resolve("CONNECTED");
-        });
-        socket.on("timeout", () => {
-            socket.destroy();
-            resolve("TIMEOUT");
-        });
-        socket.on("error", e => resolve(e.code || String(e)));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const format_1 = require("socket-function/src/formatting/format");
+const misc_1 = require("socket-function/src/misc");
+const treeSummary_1 = require("./treeSummary");
+const SUMMARY_COUNT = 30;
+const TIMING_RUNS = 20;
+const SCAN_DIRS = [
+    "D:/repos/qs-cyoa",
+    "D:/repos/querysub",
+    "D:/repos/socket-function",
+    "D:/repos/sliftutils",
+    "D:/repos/inference-weights",
+];
+// Matches the gitignored "test*.json" pattern, so the cache never gets tracked.
+const CACHE_FILE = "D:/repos/sliftutils/test-files-cache.json";
+async function collectFiles(dirs, output) {
+    for (let dir of dirs) {
+        let basePath = dir.endsWith("/") && dir || dir + "/";
+        await collectDir(dir, basePath, output);
+    }
+}
+async function collectDir(dir, basePath, output) {
+    let entries = await fs.promises.readdir(dir, { withFileTypes: true });
+    for (let entry of entries) {
+        let fullPath = path.join(dir, entry.name);
+        let entryPath = basePath + entry.name;
+        if (entry.isDirectory()) {
+            await collectDir(fullPath, entryPath + "/", output);
+        }
+        else if (entry.isFile()) {
+            let stats = await fs.promises.stat(fullPath);
+            output.push({ path: entryPath, size: stats.size });
+        }
+    }
+}
+function summarize(files, weightBySize) {
+    let tree = new treeSummary_1.TreeSummary({
+        getPath: file => file.path,
+        createSummary: () => ({ count: 0, totalSize: 0 }),
+        addToSummary: (file, summary) => {
+            summary.count++;
+            summary.totalSize += file.size;
+        },
+        mergeSummaries: (target, source) => {
+            target.count += source.count;
+            target.totalSize += source.totalSize;
+        },
+        getWeight: summary => {
+            if (weightBySize)
+                return summary.totalSize;
+            return summary.count;
+        },
+        expectedOutputCount: SUMMARY_COUNT,
     });
+    let addStart = performance.now();
+    for (let file of files) {
+        tree.add(file);
+    }
+    let addTime = performance.now() - addStart;
+    let queryStart = performance.now();
+    let summaries = tree.getSummaries(SUMMARY_COUNT);
+    for (let i = 1; i < TIMING_RUNS; i++) {
+        summaries = tree.getSummaries(SUMMARY_COUNT);
+    }
+    let queryTime = (performance.now() - queryStart) / TIMING_RUNS;
+    let label = weightBySize && "size" || "count";
+    console.log(`\n=== weighted by ${label}, ${SUMMARY_COUNT} entries ===`);
+    console.log(`add: ${(0, format_1.formatTime)(addTime)} total for ${(0, format_1.formatNumber)(files.length)} files, tracking ${(0, format_1.formatNumber)(tree.getTrackedNodeCount())} nodes, getSummaries: ${(0, format_1.formatTime)(queryTime)} avg over ${TIMING_RUNS} runs`);
+    let totalWeight = 0;
+    for (let entry of summaries) {
+        totalWeight += entry.weight;
+    }
+    (0, misc_1.sort)(summaries, entry => -entry.weight);
+    // Verify each entry against the raw file list: assign every file to its most specific displayed entry (exact paths beat prefixes, longer prefixes beat shorter), which is the partition the entries claim to represent.
+    let actuals = summaries.map(() => ({ count: 0, totalSize: 0 }));
+    let unmatchedCount = 0;
+    let unmatchedSize = 0;
+    for (let file of files) {
+        let bestIndex = -1;
+        let bestLen = -1;
+        for (let i = 0; i < summaries.length; i++) {
+            let entryPath = summaries[i].path;
+            if (entryPath.endsWith("*")) {
+                let prefix = entryPath.slice(0, -1);
+                if (prefix.length > bestLen && file.path.startsWith(prefix)) {
+                    bestIndex = i;
+                    bestLen = prefix.length;
+                }
+            }
+            else if (file.path === entryPath && entryPath.length + 1 > bestLen) {
+                bestIndex = i;
+                bestLen = entryPath.length + 1;
+            }
+        }
+        if (bestIndex === -1) {
+            unmatchedCount++;
+            unmatchedSize += file.size;
+            continue;
+        }
+        actuals[bestIndex].count++;
+        actuals[bestIndex].totalSize += file.size;
+    }
+    let shownPercent = 0;
+    let specificPercent = 0;
+    for (let i = 0; i < summaries.length; i++) {
+        let entry = summaries[i];
+        let percent = entry.weight / totalWeight * 100;
+        shownPercent += percent;
+        if (entry.kind === "self" || entry.kind === "subtree") {
+            specificPercent += percent;
+        }
+        let actual = actuals[i];
+        let diff = "";
+        if (actual.count !== entry.summary.count || actual.totalSize !== entry.summary.totalSize) {
+            diff = `  DIFF actual files=${(0, format_1.formatNumber)(actual.count)} size=${(0, format_1.formatNumber)(actual.totalSize)}B`;
+        }
+        console.log(`${percent.toFixed(1).padStart(5)}% ${entry.path.padEnd(60)} files=${(0, format_1.formatNumber)(entry.summary.count).padStart(6)} size=${((0, format_1.formatNumber)(entry.summary.totalSize) + "B").padStart(8)}${diff}`);
+    }
+    if (unmatchedCount > 0) {
+        console.log(`UNMATCHED: ${(0, format_1.formatNumber)(unmatchedCount)} files (${(0, format_1.formatNumber)(unmatchedSize)}B) matched no displayed entry`);
+    }
+    console.log(`top ${summaries.length} entries cover ${shownPercent.toFixed(1)}% (specific paths ${specificPercent.toFixed(1)}%, combined leftovers ${(shownPercent - specificPercent).toFixed(1)}%)`);
+    // Entries are a strict partition (each file in exactly one entry), so these must match the real totals exactly.
+    let entryCount = 0;
+    let entrySize = 0;
+    for (let entry of summaries) {
+        entryCount += entry.summary.count;
+        entrySize += entry.summary.totalSize;
+    }
+    let actualSize = 0;
+    for (let file of files) {
+        actualSize += file.size;
+    }
+    console.log(`entry totals: files=${(0, format_1.formatNumber)(entryCount)} (actual ${(0, format_1.formatNumber)(files.length)}), size=${(0, format_1.formatNumber)(entrySize)}B (actual ${(0, format_1.formatNumber)(actualSize)}B)`);
+}
+async function getFiles() {
+    var _a;
+    try {
+        let cached = JSON.parse(await fs.promises.readFile(CACHE_FILE, "utf8"));
+        if (JSON.stringify(cached.dirs) === JSON.stringify(SCAN_DIRS)) {
+            console.log(`loaded ${(0, format_1.formatNumber)(cached.files.length)} files from cache ${CACHE_FILE}`);
+            return cached.files;
+        }
+        console.log(`cache dirs changed (cached ${JSON.stringify(cached.dirs)}, now ${JSON.stringify(SCAN_DIRS)}), rescanning`);
+    }
+    catch (err) {
+        if (err.code === "ENOENT") {
+            console.log(`no cache file at ${CACHE_FILE}, scanning`);
+        }
+        else {
+            console.log(`cache read failed, rescanning:`, (_a = err.stack) !== null && _a !== void 0 ? _a : err);
+        }
+    }
+    let files = [];
+    let scanStart = performance.now();
+    await collectFiles(SCAN_DIRS, files);
+    await fs.promises.writeFile(CACHE_FILE, JSON.stringify({ dirs: SCAN_DIRS, files }));
+    console.log(`scanned ${(0, format_1.formatNumber)(files.length)} files in ${(0, format_1.formatTime)(performance.now() - scanStart)}, cached to ${CACHE_FILE}`);
+    return files;
 }
 async function main() {
-    let lanIP = await (0, forwardPort_1.getLocalInternalIP)();
-    console.log("our LAN IP:", lanIP);
-    let listener = net_1.default.createServer(socket => {
-        socket.on("error", () => socket.destroy());
-        socket.end("hello");
-    });
-    await new Promise(resolve => listener.listen(TEST_PORT, "0.0.0.0", () => resolve()));
-    console.log(`listening on 0.0.0.0:${TEST_PORT}`);
-    await (0, forwardPort_1.forwardPort)({ externalPort: TEST_PORT, internalPort: TEST_PORT });
-    let mappings = await (0, forwardPort_1.listPortMappings)();
-    let ours = mappings.find(x => x.externalPort === TEST_PORT);
-    console.log(`mapping for ${TEST_PORT} after create:`, JSON.stringify(ours) || "MISSING");
-    console.log(`LAN direct (${lanIP}:${TEST_PORT}):`, await testConnect(lanIP || "127.0.0.1", TEST_PORT));
-    console.log(`hairpin (${EXTERNAL_IP}:${TEST_PORT}):`, await testConnect(EXTERNAL_IP, TEST_PORT));
-    listener.close();
-    process.exit(0);
+    let files = await getFiles();
+    console.log(`collected ${(0, format_1.formatNumber)(files.length)} files from ${SCAN_DIRS.join(", ")}`);
+    summarize(files, true);
+    summarize(files, false);
 }
 main().catch(e => {
     var _a;
     console.error((_a = e.stack) !== null && _a !== void 0 ? _a : e);
     process.exit(1);
 });
-//# sourceMappingURL=data:application/json;base64,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
- /* _JS_SOURCE_HASH = "ff635e41519c7464cb3b055e6fe334893caa4fa66ebb080597c5fd80309af3da"; */
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"test.js","sourceRoot":"","sources":["test.ts"],"names":[],"mappings":"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","sourcesContent":["import * as fs from \"fs\";\nimport * as path from \"path\";\nimport { formatNumber, formatTime } from \"socket-function/src/formatting/format\";\nimport { sort } from \"socket-function/src/misc\";\nimport { TreeSummary } from \"./treeSummary\";\n\nconst SUMMARY_COUNT = 30;\nconst TIMING_RUNS = 20;\nconst SCAN_DIRS = [\n    \"D:/repos/qs-cyoa\",\n    \"D:/repos/querysub\",\n    \"D:/repos/socket-function\",\n    \"D:/repos/sliftutils\",\n    \"D:/repos/inference-weights\",\n];\n\n// Matches the gitignored \"test*.json\" pattern, so the cache never gets tracked.\nconst CACHE_FILE = \"D:/repos/sliftutils/test-files-cache.json\";\n\ntype FileInfo = { path: string; size: number };\ntype FileSummary = { count: number; totalSize: number };\n\nasync function collectFiles(dirs: string[], output: FileInfo[]) {\n    for (let dir of dirs) {\n        let basePath = dir.endsWith(\"/\") && dir || dir + \"/\";\n        await collectDir(dir, basePath, output);\n    }\n}\n\nasync function collectDir(dir: string, basePath: string, output: FileInfo[]) {\n    let entries = await fs.promises.readdir(dir, { withFileTypes: true });\n    for (let entry of entries) {\n        let fullPath = path.join(dir, entry.name);\n        let entryPath = basePath + entry.name;\n        if (entry.isDirectory()) {\n            await collectDir(fullPath, entryPath + \"/\", output);\n        } else if (entry.isFile()) {\n            let stats = await fs.promises.stat(fullPath);\n            output.push({ path: entryPath, size: stats.size });\n        }\n    }\n}\n\nfunction summarize(files: FileInfo[], weightBySize: boolean) {\n    let tree = new TreeSummary<FileInfo, FileSummary>({\n        getPath: file => file.path,\n        createSummary: () => ({ count: 0, totalSize: 0 }),\n        addToSummary: (file, summary) => {\n            summary.count++;\n            summary.totalSize += file.size;\n        },\n        mergeSummaries: (target, source) => {\n            target.count += source.count;\n            target.totalSize += source.totalSize;\n        },\n        getWeight: summary => {\n            if (weightBySize) return summary.totalSize;\n            return summary.count;\n        },\n        expectedOutputCount: SUMMARY_COUNT,\n    });\n    let addStart = performance.now();\n    for (let file of files) {\n        tree.add(file);\n    }\n    let addTime = performance.now() - addStart;\n    let queryStart = performance.now();\n    let summaries = tree.getSummaries(SUMMARY_COUNT);\n    for (let i = 1; i < TIMING_RUNS; i++) {\n        summaries = tree.getSummaries(SUMMARY_COUNT);\n    }\n    let queryTime = (performance.now() - queryStart) / TIMING_RUNS;\n    let label = weightBySize && \"size\" || \"count\";\n    console.log(`\\n=== weighted by ${label}, ${SUMMARY_COUNT} entries ===`);\n    console.log(`add: ${formatTime(addTime)} total for ${formatNumber(files.length)} files, tracking ${formatNumber(tree.getTrackedNodeCount())} nodes, getSummaries: ${formatTime(queryTime)} avg over ${TIMING_RUNS} runs`);\n    let totalWeight = 0;\n    for (let entry of summaries) {\n        totalWeight += entry.weight;\n    }\n    sort(summaries, entry => -entry.weight);\n    // Verify each entry against the raw file list: assign every file to its most specific displayed entry (exact paths beat prefixes, longer prefixes beat shorter), which is the partition the entries claim to represent.\n    let actuals = summaries.map(() => ({ count: 0, totalSize: 0 }));\n    let unmatchedCount = 0;\n    let unmatchedSize = 0;\n    for (let file of files) {\n        let bestIndex = -1;\n        let bestLen = -1;\n        for (let i = 0; i < summaries.length; i++) {\n            let entryPath = summaries[i].path;\n            if (entryPath.endsWith(\"*\")) {\n                let prefix = entryPath.slice(0, -1);\n                if (prefix.length > bestLen && file.path.startsWith(prefix)) {\n                    bestIndex = i;\n                    bestLen = prefix.length;\n                }\n            } else if (file.path === entryPath && entryPath.length + 1 > bestLen) {\n                bestIndex = i;\n                bestLen = entryPath.length + 1;\n            }\n        }\n        if (bestIndex === -1) {\n            unmatchedCount++;\n            unmatchedSize += file.size;\n            continue;\n        }\n        actuals[bestIndex].count++;\n        actuals[bestIndex].totalSize += file.size;\n    }\n    let shownPercent = 0;\n    let specificPercent = 0;\n    for (let i = 0; i < summaries.length; i++) {\n        let entry = summaries[i];\n        let percent = entry.weight / totalWeight * 100;\n        shownPercent += percent;\n        if (entry.kind === \"self\" || entry.kind === \"subtree\") {\n            specificPercent += percent;\n        }\n        let actual = actuals[i];\n        let diff = \"\";\n        if (actual.count !== entry.summary.count || actual.totalSize !== entry.summary.totalSize) {\n            diff = `  DIFF actual files=${formatNumber(actual.count)} size=${formatNumber(actual.totalSize)}B`;\n        }\n        console.log(`${percent.toFixed(1).padStart(5)}% ${entry.path.padEnd(60)} files=${formatNumber(entry.summary.count).padStart(6)} size=${(formatNumber(entry.summary.totalSize) + \"B\").padStart(8)}${diff}`);\n    }\n    if (unmatchedCount > 0) {\n        console.log(`UNMATCHED: ${formatNumber(unmatchedCount)} files (${formatNumber(unmatchedSize)}B) matched no displayed entry`);\n    }\n    console.log(`top ${summaries.length} entries cover ${shownPercent.toFixed(1)}% (specific paths ${specificPercent.toFixed(1)}%, combined leftovers ${(shownPercent - specificPercent).toFixed(1)}%)`);\n    // Entries are a strict partition (each file in exactly one entry), so these must match the real totals exactly.\n    let entryCount = 0;\n    let entrySize = 0;\n    for (let entry of summaries) {\n        entryCount += entry.summary.count;\n        entrySize += entry.summary.totalSize;\n    }\n    let actualSize = 0;\n    for (let file of files) {\n        actualSize += file.size;\n    }\n    console.log(`entry totals: files=${formatNumber(entryCount)} (actual ${formatNumber(files.length)}), size=${formatNumber(entrySize)}B (actual ${formatNumber(actualSize)}B)`);\n}\n\nasync function getFiles(): Promise<FileInfo[]> {\n    try {\n        let cached = JSON.parse(await fs.promises.readFile(CACHE_FILE, \"utf8\")) as { dirs: string[]; files: FileInfo[] };\n        if (JSON.stringify(cached.dirs) === JSON.stringify(SCAN_DIRS)) {\n            console.log(`loaded ${formatNumber(cached.files.length)} files from cache ${CACHE_FILE}`);\n            return cached.files;\n        }\n        console.log(`cache dirs changed (cached ${JSON.stringify(cached.dirs)}, now ${JSON.stringify(SCAN_DIRS)}), rescanning`);\n    } catch (err) {\n        if ((err as { code?: string }).code === \"ENOENT\") {\n            console.log(`no cache file at ${CACHE_FILE}, scanning`);\n        } else {\n            console.log(`cache read failed, rescanning:`, (err as Error).stack ?? err);\n        }\n    }\n    let files: FileInfo[] = [];\n    let scanStart = performance.now();\n    await collectFiles(SCAN_DIRS, files);\n    await fs.promises.writeFile(CACHE_FILE, JSON.stringify({ dirs: SCAN_DIRS, files }));\n    console.log(`scanned ${formatNumber(files.length)} files in ${formatTime(performance.now() - scanStart)}, cached to ${CACHE_FILE}`);\n    return files;\n}\n\nasync function main() {\n    let files = await getFiles();\n    console.log(`collected ${formatNumber(files.length)} files from ${SCAN_DIRS.join(\", \")}`);\n    summarize(files, true);\n    summarize(files, false);\n}\n\nmain().catch(e => {\n    console.error((e as Error).stack ?? e);\n    process.exit(1);\n});\n"]}
+ /* _JS_SOURCE_HASH = "656b9eea92595d2b1164fb0d91cdd090fdb580dd665e47749657855c28eb87f8"; */