sliftutils 1.7.66 → 1.7.67

package/dist/treeSummary.ts.cache

@@ -0,0 +1,359 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+//exports.TreeSummary = void 0;
+const misc_1 = require("socket-function/src/misc");
+const DEFAULT_OUTPUT_COUNT = 100;
+const TRACKED_NODES_PER_OUTPUT = 100;
+const MIN_TRACKED_NODES = 1000;
+const MAX_TRACKED_NODES = 10000;
+const PRUNE_TARGET_DIVISOR = 2;
+const PRUNE_SEARCH_ITERATIONS = 20;
+class TreeSummary {
+    constructor(config) {
+        this.config = config;
+        this.nodeCount = 1;
+        this.root = { label: "", children: new Map(), summary: config.createSummary() };
+        let outputCount = config.expectedOutputCount || DEFAULT_OUTPUT_COUNT;
+        this.maxTrackedNodes = Math.min(Math.max(outputCount * TRACKED_NODES_PER_OUTPUT, MIN_TRACKED_NODES), MAX_TRACKED_NODES);
+    }
+    add(value) {
+        let path = this.config.getPath(value);
+        let node = this.root;
+        this.config.addToSummary(value, node.summary);
+        let pos = 0;
+        while (pos < path.length) {
+            let child = node.children.get(path[pos]);
+            if (!child) {
+                child = { label: path.slice(pos), children: new Map(), summary: this.config.createSummary() };
+                node.children.set(path[pos], child);
+                this.nodeCount++;
+                this.config.addToSummary(value, child.summary);
+                node = child;
+                break;
+            }
+            let label = child.label;
+            let limit = Math.min(label.length, path.length - pos);
+            let common = 1;
+            while (common < limit && label.charCodeAt(common) === path.charCodeAt(pos + common)) {
+                common++;
+            }
+            if (common < label.length) {
+                this.splitNode(child, common);
+            }
+            this.config.addToSummary(value, child.summary);
+            node = child;
+            pos += common;
+        }
+        let selfSummary = node.selfSummary;
+        if (!selfSummary) {
+            selfSummary = this.config.createSummary();
+            node.selfSummary = selfSummary;
+        }
+        this.config.addToSummary(value, selfSummary);
+        if (this.nodeCount > this.maxTrackedNodes) {
+            this.prune();
+        }
+    }
+    // Splits a node's edge label at labelPos, inserting a new parent covering the prefix. The prefix node's summary is a merge-clone of the original aggregate, since it covers the exact same set of values.
+    splitNode(node, labelPos) {
+        let suffix = {
+            label: node.label.slice(labelPos),
+            children: node.children,
+            summary: node.summary,
+            selfSummary: node.selfSummary,
+            truncatedSummary: node.truncatedSummary,
+        };
+        let prefixSummary = this.config.createSummary();
+        this.config.mergeSummaries(prefixSummary, suffix.summary);
+        node.label = node.label.slice(0, labelPos);
+        node.summary = prefixSummary;
+        node.selfSummary = undefined;
+        node.truncatedSummary = undefined;
+        node.children = new Map([[suffix.label[0], suffix]]);
+        this.nodeCount++;
+    }
+    getTrackedNodeCount() {
+        return this.nodeCount;
+    }
+    // Starts fully collapsed (one entry for the whole tree) and repeatedly refines the heaviest entry, one split at a time. A split pulls the heaviest branch out as its own entry and leaves the remaining siblings combined in a group entry, so entries are never wasted on light branches. This recomputes from the live per-node summaries, so it always reflects everything added so far.
+    getSummaries(maxCount) {
+        if (maxCount <= 0) {
+            throw new Error(`maxCount must be positive, was ${maxCount}`);
+        }
+        if (!this.root.selfSummary && !this.root.truncatedSummary && this.root.children.size === 0) {
+            return [];
+        }
+        let entries = [this.subtreeEntry(this.root, "")];
+        while (entries.length < maxCount) {
+            let bestIndex = -1;
+            for (let i = 0; i < entries.length; i++) {
+                if (!this.isRefinable(entries[i]))
+                    continue;
+                if (bestIndex === -1 || entries[i].weight > entries[bestIndex].weight) {
+                    bestIndex = i;
+                }
+            }
+            if (bestIndex === -1)
+                break;
+            let refined = this.refine(entries[bestIndex]);
+            entries.splice(bestIndex, 1, ...refined);
+        }
+        let output = entries.map(entry => {
+            let path = entry.path;
+            if (entry.kind !== "self") {
+                path += "*";
+            }
+            return {
+                path,
+                kind: entry.kind,
+                summary: this.buildOutputSummary(entry),
+                weight: entry.weight,
+            };
+        });
+        (0, misc_1.sort)(output, entry => entry.path);
+        return output;
+    }
+    isRefinable(entry) {
+        if (entry.kind === "self" || entry.kind === "truncated")
+            return false;
+        if (entry.kind === "group") {
+            let members = entry.members;
+            if (!members || members.size === 0)
+                return false;
+            return members.size + (entry.extras && entry.extras.length || 0) >= 2;
+        }
+        let node = entry.node;
+        if (!node)
+            return false;
+        if (entry.extras && entry.extras.length > 0)
+            return true;
+        let parts = node.children.size + (node.selfSummary && 1 || 0) + (node.truncatedSummary && 1 || 0);
+        return parts >= 2;
+    }
+    // Replaces one entry with exactly two, so each refinement costs exactly one output slot.
+    refine(entry) {
+        if (entry.kind === "group") {
+            let members = entry.members;
+            if (!members) {
+                throw new Error(`Group entry missing members at ${entry.path}`);
+            }
+            return this.splitParts(members, entry.extras || [], entry.path);
+        }
+        let node = entry.node;
+        if (entry.kind !== "subtree" || !node) {
+            throw new Error(`Entry is not refinable at ${entry.path}`);
+        }
+        let extras = entry.extras;
+        if (extras && extras.length > 0) {
+            // Split off the chain residues as one combined entry, so a long chain of pruning leftovers costs a single slot instead of one per character.
+            let weight = 0;
+            for (let extra of extras) {
+                weight += this.config.getWeight(extra);
+            }
+            return [
+                { kind: "group", path: entry.path, extras, weight },
+                this.subtreeEntry(node, entry.nodePath || entry.path),
+            ];
+        }
+        // Children live below the node, so their paths must extend nodePath, never the (possibly shorter) display path.
+        let nodePath = entry.nodePath || entry.path;
+        let truncatedList = [];
+        if (node.truncatedSummary) {
+            truncatedList.push(node.truncatedSummary);
+        }
+        let selfSummary = node.selfSummary;
+        if (selfSummary) {
+            return [
+                { kind: "self", path: nodePath, node, weight: this.config.getWeight(selfSummary) },
+                this.entryForParts(node.children, truncatedList, nodePath),
+            ];
+        }
+        return this.splitParts(node.children, truncatedList, nodePath);
+    }
+    splitParts(children, extras, path) {
+        let heaviestChar = "";
+        let heaviest;
+        for (let [char, child] of children) {
+            if (!heaviest || this.config.getWeight(child.summary) > this.config.getWeight(heaviest.summary)) {
+                heaviestChar = char;
+                heaviest = child;
+            }
+        }
+        if (!heaviest) {
+            throw new Error(`Cannot split empty child set at ${path}`);
+        }
+        let rest = new Map(children);
+        rest.delete(heaviestChar);
+        return [
+            this.subtreeEntry(heaviest, path + heaviest.label),
+            this.entryForParts(rest, extras, path),
+        ];
+    }
+    entryForParts(children, extras, path) {
+        if (children.size === 0) {
+            if (extras.length === 0) {
+                throw new Error(`No parts to make an entry from at ${path}`);
+            }
+            let weight = 0;
+            for (let extra of extras) {
+                weight += this.config.getWeight(extra);
+            }
+            return { kind: "truncated", path, extras, weight };
+        }
+        if (children.size === 1 && extras.length === 0) {
+            for (let child of children.values()) {
+                return this.subtreeEntry(child, path + child.label);
+            }
+        }
+        let weight = 0;
+        for (let extra of extras) {
+            weight += this.config.getWeight(extra);
+        }
+        for (let child of children.values()) {
+            weight += this.config.getWeight(child.summary);
+        }
+        return { kind: "group", path, members: children, extras, weight };
+    }
+    subtreeEntry(node, path) {
+        // Follow single-child chains so paths are maximal shared prefixes instead of single characters. Self/truncated summaries found along the chain are carried on the entry instead of stopping the descent, so pruning leftovers scattered along a chain end up combined instead of each forcing an entry.
+        let carried = [];
+        let carriedWeight = 0;
+        let nodePath = path;
+        while (node.children.size === 1) {
+            let selfSummary = node.selfSummary;
+            if (selfSummary) {
+                carried.push(selfSummary);
+                carriedWeight += this.config.getWeight(selfSummary);
+            }
+            let truncated = node.truncatedSummary;
+            if (truncated) {
+                carried.push(truncated);
+                carriedWeight += this.config.getWeight(truncated);
+            }
+            for (let child of node.children.values()) {
+                nodePath += child.label;
+                node = child;
+            }
+        }
+        // With nothing carried the entry is just the deep node, so display the full descended prefix.
+        if (carried.length === 0) {
+            path = nodePath;
+        }
+        return {
+            kind: "subtree",
+            path,
+            node,
+            nodePath,
+            extras: carried,
+            weight: this.config.getWeight(node.summary) + carriedWeight,
+        };
+    }
+    buildOutputSummary(entry) {
+        let result = this.config.createSummary();
+        if (entry.kind === "group" || entry.kind === "truncated") {
+            for (let extra of entry.extras || []) {
+                this.config.mergeSummaries(result, extra);
+            }
+            if (entry.members) {
+                for (let member of entry.members.values()) {
+                    this.config.mergeSummaries(result, member.summary);
+                }
+            }
+            return result;
+        }
+        let node = entry.node;
+        if (!node) {
+            throw new Error(`Entry missing node at ${entry.path}`);
+        }
+        if (entry.kind === "self") {
+            let selfSummary = node.selfSummary;
+            if (!selfSummary) {
+                throw new Error(`Self entry missing selfSummary at ${entry.path}`);
+            }
+            this.config.mergeSummaries(result, selfSummary);
+            return result;
+        }
+        for (let extra of entry.extras || []) {
+            this.config.mergeSummaries(result, extra);
+        }
+        this.config.mergeSummaries(result, node.summary);
+        return result;
+    }
+    // Collapses the lightest subtrees until the node count is back under the target. Collapsing a node merges everything below it into its truncatedSummary, keeping the data but dropping the path detail. If those prefixes get heavy again later, new adds rebuild branches there and the next prune takes out whatever stayed light instead.
+    prune() {
+        let target = Math.floor(this.maxTrackedNodes / PRUNE_TARGET_DIVISOR);
+        let need = this.nodeCount - target;
+        if (need <= 0)
+            return;
+        let stats = new Map();
+        let measure = (node) => {
+            let size = 1;
+            for (let child of node.children.values()) {
+                size += measure(child).size;
+            }
+            let result = { size, weight: this.config.getWeight(node.summary) };
+            stats.set(node, result);
+            return result;
+        };
+        let rootStats = measure(this.root);
+        let getStats = (node) => {
+            let stat = stats.get(node);
+            if (!stat) {
+                throw new Error(`Missing node stats during prune`);
+            }
+            return stat;
+        };
+        // Collapsing every maximal subtree whose weight is under a limit frees a monotonically increasing number of nodes, so binary search for the smallest limit that frees enough.
+        let freedAt = (limit) => {
+            let freed = 0;
+            let visit = (node) => {
+                if (node.children.size === 0)
+                    return;
+                if (getStats(node).weight <= limit) {
+                    freed += getStats(node).size - 1;
+                    return;
+                }
+                for (let child of node.children.values()) {
+                    visit(child);
+                }
+            };
+            visit(this.root);
+            return freed;
+        };
+        let low = 0;
+        let high = rootStats.weight;
+        for (let i = 0; i < PRUNE_SEARCH_ITERATIONS; i++) {
+            let mid = (low + high) / 2;
+            if (freedAt(mid) >= need) {
+                high = mid;
+            }
+            else {
+                low = mid;
+            }
+        }
+        let collapseVisit = (node) => {
+            if (node.children.size === 0)
+                return;
+            if (getStats(node).weight <= high) {
+                let truncated = node.truncatedSummary;
+                if (!truncated) {
+                    truncated = this.config.createSummary();
+                    node.truncatedSummary = truncated;
+                }
+                for (let child of node.children.values()) {
+                    this.config.mergeSummaries(truncated, child.summary);
+                }
+                this.nodeCount -= getStats(node).size - 1;
+                node.children.clear();
+                return;
+            }
+            for (let child of node.children.values()) {
+                collapseVisit(child);
+            }
+        };
+        collapseVisit(this.root);
+    }
+}
+exports.TreeSummary = TreeSummary;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"treeSummary.js","sourceRoot":"","sources":["treeSummary.ts"],"names":[],"mappings":"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","sourcesContent":["import { sort } from \"socket-function/src/misc\";\n\nconst DEFAULT_OUTPUT_COUNT = 100;\nconst TRACKED_NODES_PER_OUTPUT = 100;\nconst MIN_TRACKED_NODES = 1_000;\nconst MAX_TRACKED_NODES = 10_000;\nconst PRUNE_TARGET_DIVISOR = 2;\nconst PRUNE_SEARCH_ITERATIONS = 20;\n\ntype TreeNode<S> = {\n    // The path fragment this node covers, i.e. the edge from its parent. Children are keyed by the first character of their label.\n    label: string;\n    children: Map<string, TreeNode<S>>;\n    // Aggregate of every value whose path passes through (or ends at) this node.\n    summary: S;\n    // Aggregate of only the values whose path ends exactly at this node.\n    selfSummary?: S;\n    // Aggregate of values that were below this node before pruning collapsed their branches. Their path detail is gone, but their data is preserved.\n    truncatedSummary?: S;\n};\n\nexport type SummaryEntry<S> = {\n    // Ends with \"*\" unless the entry is a single exact path that was heavy enough to stand on its own.\n    path: string;\n    // \"self\" = values whose path is exactly path. \"subtree\" = every value whose path starts with path. \"group\" = values under path kept combined (light sibling branches, chain leftovers, or both) because none was heavy enough to deserve its own entry. \"truncated\" = values under path whose detail was pruned away.\n    kind: \"self\" | \"subtree\" | \"group\" | \"truncated\";\n    summary: S;\n    weight: number;\n};\n\ntype PendingEntry<S> = {\n    kind: \"self\" | \"subtree\" | \"group\" | \"truncated\";\n    path: string;\n    node?: TreeNode<S>;\n    // Where node actually sits when path compression descended a single-child chain past carried residues; equals path when no residues were carried.\n    nodePath?: string;\n    members?: Map<string, TreeNode<S>>;\n    // Self/truncated summaries that sit between path and node (for \"subtree\"), or the loose summaries of a combined entry (for \"group\"/\"truncated\").\n    extras?: S[];\n    weight: number;\n};\n\ntype NodeStats = {\n    size: number;\n    weight: number;\n};\n\nexport class TreeSummary<T, S> {\n    private root: TreeNode<S>;\n    private nodeCount = 1;\n    private maxTrackedNodes: number;\n\n    constructor(private config: {\n        getPath: (value: T) => string;\n        createSummary: () => S;\n        addToSummary: (value: T, summary: S) => void;\n        mergeSummaries: (target: S, source: S) => void;\n        getWeight: (summary: S) => number;\n        // Sizes the internal tree, which keeps roughly TRACKED_NODES_PER_OUTPUT times this many nodes so output granularity decisions have detail to work with.\n        expectedOutputCount?: number;\n    }) {\n        this.root = { label: \"\", children: new Map(), summary: config.createSummary() };\n        let outputCount = config.expectedOutputCount || DEFAULT_OUTPUT_COUNT;\n        this.maxTrackedNodes = Math.min(Math.max(outputCount * TRACKED_NODES_PER_OUTPUT, MIN_TRACKED_NODES), MAX_TRACKED_NODES);\n    }\n\n    public add(value: T) {\n        let path = this.config.getPath(value);\n        let node = this.root;\n        this.config.addToSummary(value, node.summary);\n        let pos = 0;\n        while (pos < path.length) {\n            let child = node.children.get(path[pos]);\n            if (!child) {\n                child = { label: path.slice(pos), children: new Map(), summary: this.config.createSummary() };\n                node.children.set(path[pos], child);\n                this.nodeCount++;\n                this.config.addToSummary(value, child.summary);\n                node = child;\n                break;\n            }\n            let label = child.label;\n            let limit = Math.min(label.length, path.length - pos);\n            let common = 1;\n            while (common < limit && label.charCodeAt(common) === path.charCodeAt(pos + common)) {\n                common++;\n            }\n            if (common < label.length) {\n                this.splitNode(child, common);\n            }\n            this.config.addToSummary(value, child.summary);\n            node = child;\n            pos += common;\n        }\n        let selfSummary = node.selfSummary;\n        if (!selfSummary) {\n            selfSummary = this.config.createSummary();\n            node.selfSummary = selfSummary;\n        }\n        this.config.addToSummary(value, selfSummary);\n        if (this.nodeCount > this.maxTrackedNodes) {\n            this.prune();\n        }\n    }\n\n    // Splits a node's edge label at labelPos, inserting a new parent covering the prefix. The prefix node's summary is a merge-clone of the original aggregate, since it covers the exact same set of values.\n    private splitNode(node: TreeNode<S>, labelPos: number) {\n        let suffix: TreeNode<S> = {\n            label: node.label.slice(labelPos),\n            children: node.children,\n            summary: node.summary,\n            selfSummary: node.selfSummary,\n            truncatedSummary: node.truncatedSummary,\n        };\n        let prefixSummary = this.config.createSummary();\n        this.config.mergeSummaries(prefixSummary, suffix.summary);\n        node.label = node.label.slice(0, labelPos);\n        node.summary = prefixSummary;\n        node.selfSummary = undefined;\n        node.truncatedSummary = undefined;\n        node.children = new Map([[suffix.label[0], suffix]]);\n        this.nodeCount++;\n    }\n\n    public getTrackedNodeCount(): number {\n        return this.nodeCount;\n    }\n\n    // Starts fully collapsed (one entry for the whole tree) and repeatedly refines the heaviest entry, one split at a time. A split pulls the heaviest branch out as its own entry and leaves the remaining siblings combined in a group entry, so entries are never wasted on light branches. This recomputes from the live per-node summaries, so it always reflects everything added so far.\n    public getSummaries(maxCount: number): SummaryEntry<S>[] {\n        if (maxCount <= 0) {\n            throw new Error(`maxCount must be positive, was ${maxCount}`);\n        }\n        if (!this.root.selfSummary && !this.root.truncatedSummary && this.root.children.size === 0) {\n            return [];\n        }\n        let entries: PendingEntry<S>[] = [this.subtreeEntry(this.root, \"\")];\n        while (entries.length < maxCount) {\n            let bestIndex = -1;\n            for (let i = 0; i < entries.length; i++) {\n                if (!this.isRefinable(entries[i])) continue;\n                if (bestIndex === -1 || entries[i].weight > entries[bestIndex].weight) {\n                    bestIndex = i;\n                }\n            }\n            if (bestIndex === -1) break;\n            let refined = this.refine(entries[bestIndex]);\n            entries.splice(bestIndex, 1, ...refined);\n        }\n        let output = entries.map(entry => {\n            let path = entry.path;\n            if (entry.kind !== \"self\") {\n                path += \"*\";\n            }\n            return {\n                path,\n                kind: entry.kind,\n                summary: this.buildOutputSummary(entry),\n                weight: entry.weight,\n            };\n        });\n        sort(output, entry => entry.path);\n        return output;\n    }\n\n    private isRefinable(entry: PendingEntry<S>): boolean {\n        if (entry.kind === \"self\" || entry.kind === \"truncated\") return false;\n        if (entry.kind === \"group\") {\n            let members = entry.members;\n            if (!members || members.size === 0) return false;\n            return members.size + (entry.extras && entry.extras.length || 0) >= 2;\n        }\n        let node = entry.node;\n        if (!node) return false;\n        if (entry.extras && entry.extras.length > 0) return true;\n        let parts = node.children.size + (node.selfSummary && 1 || 0) + (node.truncatedSummary && 1 || 0);\n        return parts >= 2;\n    }\n\n    // Replaces one entry with exactly two, so each refinement costs exactly one output slot.\n    private refine(entry: PendingEntry<S>): PendingEntry<S>[] {\n        if (entry.kind === \"group\") {\n            let members = entry.members;\n            if (!members) {\n                throw new Error(`Group entry missing members at ${entry.path}`);\n            }\n            return this.splitParts(members, entry.extras || [], entry.path);\n        }\n        let node = entry.node;\n        if (entry.kind !== \"subtree\" || !node) {\n            throw new Error(`Entry is not refinable at ${entry.path}`);\n        }\n        let extras = entry.extras;\n        if (extras && extras.length > 0) {\n            // Split off the chain residues as one combined entry, so a long chain of pruning leftovers costs a single slot instead of one per character.\n            let weight = 0;\n            for (let extra of extras) {\n                weight += this.config.getWeight(extra);\n            }\n            return [\n                { kind: \"group\", path: entry.path, extras, weight },\n                this.subtreeEntry(node, entry.nodePath || entry.path),\n            ];\n        }\n        // Children live below the node, so their paths must extend nodePath, never the (possibly shorter) display path.\n        let nodePath = entry.nodePath || entry.path;\n        let truncatedList: S[] = [];\n        if (node.truncatedSummary) {\n            truncatedList.push(node.truncatedSummary);\n        }\n        let selfSummary = node.selfSummary;\n        if (selfSummary) {\n            return [\n                { kind: \"self\", path: nodePath, node, weight: this.config.getWeight(selfSummary) },\n                this.entryForParts(node.children, truncatedList, nodePath),\n            ];\n        }\n        return this.splitParts(node.children, truncatedList, nodePath);\n    }\n\n    private splitParts(children: Map<string, TreeNode<S>>, extras: S[], path: string): PendingEntry<S>[] {\n        let heaviestChar = \"\";\n        let heaviest: TreeNode<S> | undefined;\n        for (let [char, child] of children) {\n            if (!heaviest || this.config.getWeight(child.summary) > this.config.getWeight(heaviest.summary)) {\n                heaviestChar = char;\n                heaviest = child;\n            }\n        }\n        if (!heaviest) {\n            throw new Error(`Cannot split empty child set at ${path}`);\n        }\n        let rest = new Map(children);\n        rest.delete(heaviestChar);\n        return [\n            this.subtreeEntry(heaviest, path + heaviest.label),\n            this.entryForParts(rest, extras, path),\n        ];\n    }\n\n    private entryForParts(children: Map<string, TreeNode<S>>, extras: S[], path: string): PendingEntry<S> {\n        if (children.size === 0) {\n            if (extras.length === 0) {\n                throw new Error(`No parts to make an entry from at ${path}`);\n            }\n            let weight = 0;\n            for (let extra of extras) {\n                weight += this.config.getWeight(extra);\n            }\n            return { kind: \"truncated\", path, extras, weight };\n        }\n        if (children.size === 1 && extras.length === 0) {\n            for (let child of children.values()) {\n                return this.subtreeEntry(child, path + child.label);\n            }\n        }\n        let weight = 0;\n        for (let extra of extras) {\n            weight += this.config.getWeight(extra);\n        }\n        for (let child of children.values()) {\n            weight += this.config.getWeight(child.summary);\n        }\n        return { kind: \"group\", path, members: children, extras, weight };\n    }\n\n    private subtreeEntry(node: TreeNode<S>, path: string): PendingEntry<S> {\n        // Follow single-child chains so paths are maximal shared prefixes instead of single characters. Self/truncated summaries found along the chain are carried on the entry instead of stopping the descent, so pruning leftovers scattered along a chain end up combined instead of each forcing an entry.\n        let carried: S[] = [];\n        let carriedWeight = 0;\n        let nodePath = path;\n        while (node.children.size === 1) {\n            let selfSummary = node.selfSummary;\n            if (selfSummary) {\n                carried.push(selfSummary);\n                carriedWeight += this.config.getWeight(selfSummary);\n            }\n            let truncated = node.truncatedSummary;\n            if (truncated) {\n                carried.push(truncated);\n                carriedWeight += this.config.getWeight(truncated);\n            }\n            for (let child of node.children.values()) {\n                nodePath += child.label;\n                node = child;\n            }\n        }\n        // With nothing carried the entry is just the deep node, so display the full descended prefix.\n        if (carried.length === 0) {\n            path = nodePath;\n        }\n        return {\n            kind: \"subtree\",\n            path,\n            node,\n            nodePath,\n            extras: carried,\n            weight: this.config.getWeight(node.summary) + carriedWeight,\n        };\n    }\n\n    private buildOutputSummary(entry: PendingEntry<S>): S {\n        let result = this.config.createSummary();\n        if (entry.kind === \"group\" || entry.kind === \"truncated\") {\n            for (let extra of entry.extras || []) {\n                this.config.mergeSummaries(result, extra);\n            }\n            if (entry.members) {\n                for (let member of entry.members.values()) {\n                    this.config.mergeSummaries(result, member.summary);\n                }\n            }\n            return result;\n        }\n        let node = entry.node;\n        if (!node) {\n            throw new Error(`Entry missing node at ${entry.path}`);\n        }\n        if (entry.kind === \"self\") {\n            let selfSummary = node.selfSummary;\n            if (!selfSummary) {\n                throw new Error(`Self entry missing selfSummary at ${entry.path}`);\n            }\n            this.config.mergeSummaries(result, selfSummary);\n            return result;\n        }\n        for (let extra of entry.extras || []) {\n            this.config.mergeSummaries(result, extra);\n        }\n        this.config.mergeSummaries(result, node.summary);\n        return result;\n    }\n\n    // Collapses the lightest subtrees until the node count is back under the target. Collapsing a node merges everything below it into its truncatedSummary, keeping the data but dropping the path detail. If those prefixes get heavy again later, new adds rebuild branches there and the next prune takes out whatever stayed light instead.\n    private prune() {\n        let target = Math.floor(this.maxTrackedNodes / PRUNE_TARGET_DIVISOR);\n        let need = this.nodeCount - target;\n        if (need <= 0) return;\n        let stats = new Map<TreeNode<S>, NodeStats>();\n        let measure = (node: TreeNode<S>): NodeStats => {\n            let size = 1;\n            for (let child of node.children.values()) {\n                size += measure(child).size;\n            }\n            let result = { size, weight: this.config.getWeight(node.summary) };\n            stats.set(node, result);\n            return result;\n        };\n        let rootStats = measure(this.root);\n        let getStats = (node: TreeNode<S>): NodeStats => {\n            let stat = stats.get(node);\n            if (!stat) {\n                throw new Error(`Missing node stats during prune`);\n            }\n            return stat;\n        };\n        // Collapsing every maximal subtree whose weight is under a limit frees a monotonically increasing number of nodes, so binary search for the smallest limit that frees enough.\n        let freedAt = (limit: number): number => {\n            let freed = 0;\n            let visit = (node: TreeNode<S>) => {\n                if (node.children.size === 0) return;\n                if (getStats(node).weight <= limit) {\n                    freed += getStats(node).size - 1;\n                    return;\n                }\n                for (let child of node.children.values()) {\n                    visit(child);\n                }\n            };\n            visit(this.root);\n            return freed;\n        };\n        let low = 0;\n        let high = rootStats.weight;\n        for (let i = 0; i < PRUNE_SEARCH_ITERATIONS; i++) {\n            let mid = (low + high) / 2;\n            if (freedAt(mid) >= need) {\n                high = mid;\n            } else {\n                low = mid;\n            }\n        }\n        let collapseVisit = (node: TreeNode<S>) => {\n            if (node.children.size === 0) return;\n            if (getStats(node).weight <= high) {\n                let truncated = node.truncatedSummary;\n                if (!truncated) {\n                    truncated = this.config.createSummary();\n                    node.truncatedSummary = truncated;\n                }\n                for (let child of node.children.values()) {\n                    this.config.mergeSummaries(truncated, child.summary);\n                }\n                this.nodeCount -= getStats(node).size - 1;\n                node.children.clear();\n                return;\n            }\n            for (let child of node.children.values()) {\n                collapseVisit(child);\n            }\n        };\n        collapseVisit(this.root);\n    }\n}\n"]}
+ /* _JS_SOURCE_HASH = "6cc23520550b8de75feb37a36bb0d33aeab003facda37ae7fc99887839e09cab"; */

package/index.d.ts

@@ -858,7 +858,7 @@ declare module "sliftutils/render-utils/observer" {
 declare module "sliftutils/storage/ArchivesDisk" {
     /// <reference types="node" />
     /// <reference types="node" />
-    import { IArchives, ArchiveFileInfo, ArchivesConfig, ChangesAfterConfig, GetConfig, SetConfig } from "./IArchives";
+    import { IArchives, ArchiveFileInfo, ArchivesConfig, ChangesAfterConfig, GetConfig, GetInfoConfig, SetConfig } from "./IArchives";
     export declare class ArchivesDisk implements IArchives {
         private folder;
         constructor(folder: string);
@@ -885,7 +885,7 @@ declare module "sliftutils/storage/ArchivesDisk" {
             writeTime: number;
             size: number;
         } | undefined>;
-        getInfo(key: string): Promise<{
+        getInfo(key: string, config?: GetInfoConfig): Promise<{
             writeTime: number;
             size: number;
         } | undefined>;
@@ -2149,6 +2149,10 @@ declare module "sliftutils/storage/IArchives" {
         /** Store-to-store call: the serving node answers purely from its own disk, completely short-circuiting its index holders - chasing its own remote holders while answering another store is how infinite get loops between stores form (A asks B, B's index points back at A, ...). No window or route checks on reads: if the bytes are on its disk, the caller may have them. */
         internal?: boolean;
     };
+    export type GetInfoConfig = {
+        /** Also report size-0 entries (tombstones - an empty file IS a missing file). Off by default, so a deleted key reports undefined, matching get. Synchronization-style callers pass this when they need a deletion's write time (e.g. to compare it against a write they are about to make). */
+        includeTombstones?: boolean;
+    };
     export type ChangesAfterConfig = {
         time: number;
         /** Only keys routing into one of these [start, end) ranges. Only scanning passes this - it lets a store syncing a partial shard ask for just its slice. */
@@ -2276,16 +2280,24 @@ declare module "sliftutils/storage/IArchives" {
             lastModified?: number;
             getNextData(): Promise<Buffer | undefined>;
         }): Promise<void>;
-        /** writeTime is the last-write time — see ArchiveFileInfo.createTime, which is the same value. url as in get2. */
-        getInfo(fileName: string): Promise<{
+        /** writeTime is the last-write time — see ArchiveFileInfo.createTime, which is the same value. url as in get2. Size-0 entries (tombstones) report undefined unless config.includeTombstones. */
+        getInfo(fileName: string, config?: GetInfoConfig): Promise<{
             writeTime: number;
             size: number;
             url?: string;
         } | undefined>;
+        /**
+         * Empty (size-0) files are NEVER returned by index-backed stores (BlobStore, and therefore the
+         * chain): an empty file IS a missing file - the tombstone of a deletion. If you want a marker
+         * file that shows up in listings, add some content to it. Raw sources (disk, backblaze) DO list
+         * their empty files - that is how scans learn of deletions - but nothing built on the index
+         * ever surfaces them.
+         */
         find(prefix: string, config?: {
             shallow?: boolean;
             type: "files" | "folders";
         }): Promise<string[]>;
+        /** See find for the empty-file (tombstone) rule. */
         findInfo(prefix: string, config?: {
             shallow?: boolean;
             type: "files" | "folders";
@@ -2564,7 +2576,7 @@ declare module "sliftutils/storage/TransactionStorage" {
 declare module "sliftutils/storage/backblaze" {
     /// <reference types="node" />
     /// <reference types="node" />
-    import { IArchives, ArchivesConfig, ChangesAfterConfig, ArchiveFileInfo, GetConfig, SetConfig } from "./IArchives";
+    import { IArchives, ArchivesConfig, ChangesAfterConfig, ArchiveFileInfo, GetConfig, GetInfoConfig, SetConfig } from "./IArchives";
     export declare class ArchivesBackblaze implements IArchives {
         private config;
         constructor(config: {
@@ -2599,7 +2611,7 @@ declare module "sliftutils/storage/backblaze" {
             lastModified?: number;
             getNextData(): Promise<Buffer | undefined>;
         }): Promise<void>;
-        getInfo(fileName: string): Promise<{
+        getInfo(fileName: string, config?: GetInfoConfig): Promise<{
             writeTime: number;
             size: number;
         } | undefined>;
@@ -2868,7 +2880,7 @@ declare module "sliftutils/storage/remoteFileStorage" {
 declare module "sliftutils/storage/remoteStorage/ArchivesRemote" {
     /// <reference types="node" />
     /// <reference types="node" />
-    import { IArchives, ArchiveFileInfo, ArchivesConfig, ArchivesSyncStatus, ChangesAfterConfig, GetConfig, SetConfig } from "../IArchives";
+    import { IArchives, ArchiveFileInfo, ArchivesConfig, ArchivesSyncStatus, ChangesAfterConfig, GetConfig, GetInfoConfig, SetConfig } from "../IArchives";
     export type ArchivesRemoteConfig = {
         url: string;
         waitForAccess?: boolean;
@@ -2915,7 +2927,7 @@ declare module "sliftutils/storage/remoteStorage/ArchivesRemote" {
         } | undefined>;
         set(fileName: string, data: Buffer, config?: SetConfig): Promise<string>;
         del(fileName: string): Promise<void>;
-        getInfo(fileName: string): Promise<{
+        getInfo(fileName: string, config?: GetInfoConfig): Promise<{
             writeTime: number;
             size: number;
         } | undefined>;
@@ -2943,7 +2955,7 @@ declare module "sliftutils/storage/remoteStorage/ArchivesRemote" {
 declare module "sliftutils/storage/remoteStorage/ArchivesUrl" {
     /// <reference types="node" />
     /// <reference types="node" />
-    import { IArchives, ArchiveFileInfo, ArchivesConfig, ChangesAfterConfig, GetConfig } from "../IArchives";
+    import { IArchives, ArchiveFileInfo, ArchivesConfig, ChangesAfterConfig, GetConfig, GetInfoConfig } from "../IArchives";
     export declare class ArchivesUrl implements IArchives {
         private base;
         constructor(base: string);
@@ -2955,7 +2967,7 @@ declare module "sliftutils/storage/remoteStorage/ArchivesUrl" {
             writeTime: number;
             size: number;
         } | undefined>;
-        getInfo(fileName: string): Promise<{
+        getInfo(fileName: string, config?: GetInfoConfig): Promise<{
             writeTime: number;
             size: number;
         } | undefined>;
@@ -2991,7 +3003,7 @@ declare module "sliftutils/storage/remoteStorage/accessPage" {
 declare module "sliftutils/storage/remoteStorage/blobStore" {
     /// <reference types="node" />
     /// <reference types="node" />
-    import { IArchives, ArchiveFileInfo, ArchivesSource, ArchivesSyncStatus, ChangesAfterConfig, GetConfig, SyncActivity } from "../IArchives";
+    import { IArchives, ArchiveFileInfo, ArchivesSource, ArchivesSyncStatus, ChangesAfterConfig, GetConfig, GetInfoConfig, SyncActivity } from "../IArchives";
     export declare const DEFAULT_FAST_WRITE_DELAY: number;
     export declare const WINDOW_END_FLUSH_MARGIN: number;
     export type WriteConfig = {
@@ -3016,7 +3028,7 @@ declare module "sliftutils/storage/remoteStorage/blobStore" {
         }): Promise<void>;
         set(fileName: string, data: Buffer, config?: WriteConfig): Promise<string>;
         del(fileName: string, config?: WriteConfig): Promise<void>;
-        getInfo(fileName: string): Promise<{
+        getInfo(fileName: string, config?: GetInfoConfig): Promise<{
             writeTime: number;
             size: number;
         } | undefined>;
@@ -3168,7 +3180,7 @@ declare module "sliftutils/storage/remoteStorage/blobStore" {
         del(key: string, config?: WriteConfig): Promise<void>;
         private getWritableSources;
         private writeToSources;
-        getInfo(key: string): Promise<{
+        getInfo(key: string, config?: GetInfoConfig): Promise<{
             writeTime: number;
             size: number;
         } | undefined>;
@@ -3199,7 +3211,7 @@ declare module "sliftutils/storage/remoteStorage/cliArgs" {
 declare module "sliftutils/storage/remoteStorage/createArchives" {
     /// <reference types="node" />
     /// <reference types="node" />
-    import { IArchives, RemoteConfig, RemoteConfigBase, HostedConfig, BackblazeConfig, ArchiveFileInfo, ArchivesConfig, ArchivesSyncStatus, ChangesAfterConfig, GetConfig, SetConfig } from "../IArchives";
+    import { IArchives, RemoteConfig, RemoteConfigBase, HostedConfig, BackblazeConfig, ArchiveFileInfo, ArchivesConfig, ArchivesSyncStatus, ChangesAfterConfig, GetConfig, GetInfoConfig, SetConfig } from "../IArchives";
     import { ServerBucketInfo, ActiveBucketInfo } from "./storageServerState";
     /** The address, port, account, and bucket name a bucket routing URL addresses. Throws when the URL isn't a hosted bucket routing URL (https://host:port/file/<account>/<bucketName>/storage/storagerouting.json). */
     export { parseHostedUrl, parseBackblazeUrl, getBucketBaseUrl } from "./remoteConfig";
@@ -3274,7 +3286,7 @@ declare module "sliftutils/storage/remoteStorage/createArchives" {
             size?: undefined;
             url: string;
         }>;
-        getInfo(fileName: string): Promise<{
+        getInfo(fileName: string, config?: GetInfoConfig): Promise<{
             writeTime: number;
             size: number;
             url: string;
@@ -3602,7 +3614,7 @@ declare module "sliftutils/storage/remoteStorage/storageController" {
         } | undefined>;
         set: (account: string, bucketName: string, path: string, data: Buffer, lastModified?: number, forceSetImmutable?: boolean, internal?: boolean) => Promise<void>;
         del: (account: string, bucketName: string, path: string) => Promise<void>;
-        getInfo: (account: string, bucketName: string, path: string) => Promise<{
+        getInfo: (account: string, bucketName: string, path: string, includeTombstones?: boolean) => Promise<{
             writeTime: number;
             size: number;
         } | undefined>;

package/misc/dist/environment.ts.cache

@@ -1,4 +1,4 @@
-"use strict"; var console = (function shimConsole() {             let baseConsole = globalThis.console;             if (typeof window !== "undefined")                 return baseConsole;             let name = __filename.replaceAll("\\", "/").split("/").pop();             let dirName = __dirname.replaceAll("\\", "/").split("/").pop();             let context = {                 __FILE__: __filename,                 __DIR__: __dirname,                 __NAME__: name,                 __DIRNAME__: dirName             };             let newConsole = {                 ...baseConsole             };             for (let shim of ["log", "info", "warn", "error"]) {                 newConsole[shim] = (...args) => {                     args.push(context);                     baseConsole[shim](...args);                 };             }             newConsole.__context = context;             return newConsole;         })(); "use strict";
+"use strict";
 Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
 //exports.isInBrowser = exports.isInBuild = exports.triggerIsInBuild = exports.isInElectron = exports.isInChromeExtensionContentScript = exports.isInChromeExtensionBackground = exports.isInChromeExtension = void 0;
 /// <reference types="@types/chrome/index.d.ts" />
@@ -47,4 +47,4 @@ function isInBrowser() {
 }
 exports.isInBrowser = isInBrowser;
 //# sourceMappingURL=data:application/json;base64,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
- /* _JS_SOURCE_HASH = "de8507c9fce2fb9b79361d996ea125431343dc38988e6c870ee82c7049032ba0"; */
+ /* _JS_SOURCE_HASH = "c7ee18b0b3ad11aeba561c3dc6daba53159677e35bde1c50775ffdf74982b40f"; */