sliftutils 1.7.67 → 1.7.69

package/dist/test.ts.cache

@@ -76,7 +76,7 @@ function summarize(files, weightBySize) {
                 return summary.totalSize;
             return summary.count;
         },
-        expectedOutputCount: SUMMARY_COUNT,
+        expectedOutputCount: 100,
     });
     let addStart = performance.now();
     for (let file of files) {
@@ -195,5 +195,5 @@ main().catch(e => {
     console.error((_a = e.stack) !== null && _a !== void 0 ? _a : e);
     process.exit(1);
 });
-//# 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"; */
+//# 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: 100,\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 = "90802e23dfaf68469b5c319fa6270629c6b9178410c4c003fd4293ec3f46f4f9"; */

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, GetInfoConfig, SetConfig } from "./IArchives";
+    import { IArchives, ArchiveFileInfo, ArchivesConfig, ChangesAfterConfig, DelConfig, GetConfig, GetInfoConfig, SetConfig } from "./IArchives";
     export declare class ArchivesDisk implements IArchives {
         private folder;
         constructor(folder: string);
@@ -878,7 +878,7 @@ declare module "sliftutils/storage/ArchivesDisk" {
         hasWriteAccess(): Promise<boolean>;
         private filePath;
         set(key: string, data: Buffer, config?: SetConfig): Promise<string>;
-        del(key: string): Promise<void>;
+        del(key: string, config?: DelConfig): Promise<void>;
         get(key: string, config?: GetConfig): Promise<Buffer | undefined>;
         get2(key: string, config?: GetConfig): Promise<{
             data: Buffer;
@@ -2149,6 +2149,14 @@ 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 DelConfig = {
+        /** Stamps the deletion (its tombstone) with this write time instead of now. Synchronization passes the ORIGINAL deletion time, so deletion ordering survives propagation exactly like any other write's ordering. */
+        lastModified?: number;
+        /** See SetConfig.internal. */
+        internal?: boolean;
+        /** See SetConfig.noChecks. */
+        noChecks?: 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;
@@ -2272,9 +2280,14 @@ declare module "sliftutils/storage/IArchives" {
          * VARIABLE_SHARD, where the shard value is materialized into the key (picked by shard latency,
          * see ArchivesChain) and the caller needs the returned key to ever read the value back.
          */
+        /**
+         * THROWS on an empty buffer: an empty file IS a deletion in this system (the tombstone), so a
+         * set-empty would read back as "the file is gone" - which is just asking for problems. If you
+         * want the file deleted, call del; deletions take their own path.
+         */
         set(fileName: string, data: Buffer, config?: SetConfig): Promise<string>;
-        del(fileName: string): Promise<void>;
-        /** Streams a file too large to hold in memory. getNextData returns undefined when done. lastModified stamps the finished file like set's (synchronized copies need it to keep write ordering); backends that stamp their own times (backblaze) accept and ignore it. */
+        del(fileName: string, config?: DelConfig): Promise<void>;
+        /** Streams a file too large to hold in memory. getNextData returns undefined when done. lastModified stamps the finished file like set's (synchronized copies need it to keep write ordering); backends that stamp their own times (backblaze) accept and ignore it. THROWS when the stream produces no data at all - same rule as set: an empty file IS a deletion and would read back as missing. */
         setLargeFile(config: {
             path: string;
             lastModified?: number;
@@ -2576,7 +2589,7 @@ declare module "sliftutils/storage/TransactionStorage" {
 declare module "sliftutils/storage/backblaze" {
     /// <reference types="node" />
     /// <reference types="node" />
-    import { IArchives, ArchivesConfig, ChangesAfterConfig, ArchiveFileInfo, GetConfig, GetInfoConfig, SetConfig } from "./IArchives";
+    import { IArchives, ArchivesConfig, ChangesAfterConfig, ArchiveFileInfo, DelConfig, GetConfig, GetInfoConfig, SetConfig } from "./IArchives";
     export declare class ArchivesBackblaze implements IArchives {
         private config;
         constructor(config: {
@@ -2605,7 +2618,7 @@ declare module "sliftutils/storage/backblaze" {
         getConfig(): Promise<ArchivesConfig>;
         hasWriteAccess(): Promise<boolean>;
         set(fileName: string, data: Buffer, config?: SetConfig): Promise<string>;
-        del(fileName: string): Promise<void>;
+        del(fileName: string, config?: DelConfig): Promise<void>;
         setLargeFile(config: {
             path: string;
             lastModified?: number;
@@ -2880,7 +2893,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, GetInfoConfig, SetConfig } from "../IArchives";
+    import { IArchives, ArchiveFileInfo, ArchivesConfig, ArchivesSyncStatus, ChangesAfterConfig, DelConfig, GetConfig, GetInfoConfig, SetConfig } from "../IArchives";
     export type ArchivesRemoteConfig = {
         url: string;
         waitForAccess?: boolean;
@@ -2926,7 +2939,7 @@ declare module "sliftutils/storage/remoteStorage/ArchivesRemote" {
             size: number;
         } | undefined>;
         set(fileName: string, data: Buffer, config?: SetConfig): Promise<string>;
-        del(fileName: string): Promise<void>;
+        del(fileName: string, config?: DelConfig): Promise<void>;
         getInfo(fileName: string, config?: GetInfoConfig): Promise<{
             writeTime: number;
             size: number;
@@ -3000,6 +3013,35 @@ declare module "sliftutils/storage/remoteStorage/accessPage" {
 
 }
 
+declare module "sliftutils/storage/remoteStorage/accessStats" {
+    import { SummaryEntry } from "../../treeSummary";
+    export type AccessSummaryState = {
+        total: number;
+    };
+    export type AccessTotals = {
+        [operation: string]: {
+            count: number;
+            size: number;
+        };
+    };
+    /** Counts one storage access, in memory only. size is the bytes involved (0 when the target does not exist); omit it entirely for operations that only count calls, which then only get a count tree. */
+    export declare function trackAccess(config: {
+        account: string;
+        operation: string;
+        path: string;
+        size?: number;
+    }): void;
+    export declare function getAccessTotals(account: string): AccessTotals;
+    export declare function readAccessSummaries(config: {
+        account: string;
+        operation: string;
+        maxCount: number;
+        weightBySize?: boolean;
+    }): SummaryEntry<AccessSummaryState>[];
+    export declare function clearAccountAccessStats(account: string): void;
+
+}
+
 declare module "sliftutils/storage/remoteStorage/blobStore" {
     /// <reference types="node" />
     /// <reference types="node" />
@@ -3178,6 +3220,7 @@ declare module "sliftutils/storage/remoteStorage/blobStore" {
         private cacheRead;
         set(key: string, data: Buffer, config?: WriteConfig): Promise<string>;
         del(key: string, config?: WriteConfig): Promise<void>;
+        private setOrDelete;
         private getWritableSources;
         private writeToSources;
         getInfo(key: string, config?: GetInfoConfig): Promise<{
@@ -3211,7 +3254,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, GetInfoConfig, SetConfig } from "../IArchives";
+    import { IArchives, RemoteConfig, RemoteConfigBase, HostedConfig, BackblazeConfig, ArchiveFileInfo, ArchivesConfig, ArchivesSyncStatus, ChangesAfterConfig, DelConfig, 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";
@@ -3307,7 +3350,7 @@ declare module "sliftutils/storage/remoteStorage/createArchives" {
         hasWriteAccess(): Promise<boolean>;
         set(fileName: string, data: Buffer, config?: SetConfig): Promise<string>;
         private setRoutingConfig;
-        del(fileName: string): Promise<void>;
+        del(fileName: string, config?: DelConfig): Promise<void>;
         private getVariableShardTargets;
         /** The key setVariableShard would materialize for this VARIABLE_SHARD key (a value in the preferred shard's route range), without writing anything. */
         getShardKey(key: string): Promise<string>;
@@ -3544,6 +3587,8 @@ declare module "sliftutils/storage/remoteStorage/storageController" {
     /// <reference types="node" />
     import { ArchiveFileInfo, ArchivesConfig, ArchivesSyncStatus, ChangesAfterConfig } from "../IArchives";
     import { ServerBucketInfo, ActiveBucketInfo } from "./storageServerState";
+    import { AccessTotals, AccessSummaryState } from "./accessStats";
+    import type { SummaryEntry } from "../../treeSummary";
     export declare const REMOTE_STORAGE_CLASS_GUID = "RemoteStorageController-b7e42a91";
     export declare const STORAGE_AUTH_PURPOSE = "remoteStorage-auth-1";
     export declare const STORAGE_NOT_AUTHENTICATED = "REMOTE_STORAGE_NOT_AUTHENTICATED_cf2f7b1e";
@@ -3613,7 +3658,7 @@ declare module "sliftutils/storage/remoteStorage/storageController" {
             size: number;
         } | 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>;
+        del: (account: string, bucketName: string, path: string, lastModified?: number, internal?: boolean) => Promise<void>;
         getInfo: (account: string, bucketName: string, path: string, includeTombstones?: boolean) => Promise<{
             writeTime: number;
             size: number;
@@ -3630,6 +3675,12 @@ declare module "sliftutils/storage/remoteStorage/storageController" {
         clearWriteStats: (account: string) => Promise<{
             clearedBuckets: number;
         }>;
+        getAccessStats: (account: string) => Promise<AccessTotals>;
+        getAccessSummaries: (account: string, config: {
+            operation: string;
+            maxCount: number;
+            weightBySize?: boolean;
+        }) => Promise<SummaryEntry<AccessSummaryState>[]>;
         getIndexInfo: (account: string, bucketName: string) => Promise<{
             fileCount: number;
             byteCount: number;
@@ -3699,8 +3750,8 @@ declare module "sliftutils/storage/remoteStorage/storageServerState" {
         flushedWrites: number;
         flushedBytes: number;
     };
-    /** Zeroes the write statistics of every bucket in the account, including counts not yet flushed. */
-    export declare function clearAccountWriteStats(account: string): Promise<number>;
+    /** Zeroes the write statistics of every bucket in the account. */
+    export declare function clearAccountWriteStats(account: string): number;
     export declare function setTrustedMachines(config: {
         account: string;
         machineIds: string[];
@@ -3782,7 +3833,10 @@ declare module "sliftutils/storage/remoteStorage/storageServerState" {
     /** Loads a bucket that exists on this server's disk into memory, which starts its synchronization and window timers, and returns its live state. Nothing is written and no other server is contacted - unlike building an ArchivesChain for it, which would probe every source and could write the routing config. Already-loaded buckets just return their state. */
     export declare function activateBucket(account: string, bucketName: string): Promise<ActiveBucketInfo | string>;
     export declare function listAccountBuckets(account: string): Promise<ServerBucketInfo[]>;
-    export declare function deleteBucketFile(account: string, bucketName: string, filePath: string): Promise<void>;
+    export declare function deleteBucketFile(account: string, bucketName: string, filePath: string, config?: {
+        lastModified?: number;
+        internal?: boolean;
+    }): Promise<void>;
     export declare function getLocalArchives(account: string, bucketName: string): IArchives;
 
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "sliftutils",
-    "version": "1.7.67",
+    "version": "1.7.69",
     "main": "index.js",
     "license": "MIT",
     "files": [

package/storage/ArchivesDisk.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 /// <reference types="node" />
-import { IArchives, ArchiveFileInfo, ArchivesConfig, ChangesAfterConfig, GetConfig, GetInfoConfig, SetConfig } from "./IArchives";
+import { IArchives, ArchiveFileInfo, ArchivesConfig, ChangesAfterConfig, DelConfig, GetConfig, GetInfoConfig, SetConfig } from "./IArchives";
 export declare class ArchivesDisk implements IArchives {
     private folder;
     constructor(folder: string);
@@ -20,7 +20,7 @@ export declare class ArchivesDisk implements IArchives {
     hasWriteAccess(): Promise<boolean>;
     private filePath;
     set(key: string, data: Buffer, config?: SetConfig): Promise<string>;
-    del(key: string): Promise<void>;
+    del(key: string, config?: DelConfig): Promise<void>;
     get(key: string, config?: GetConfig): Promise<Buffer | undefined>;
     get2(key: string, config?: GetConfig): Promise<{
         data: Buffer;

package/storage/ArchivesDisk.ts

@@ -3,7 +3,7 @@ import path from "path";
 import { lazy } from "socket-function/src/caching";
 import { runInfinitePoll } from "socket-function/src/batching";
 import { sort, binarySearchBasic } from "socket-function/src/misc";
-import { IArchives, ArchiveFileInfo, ArchivesConfig, ChangesAfterConfig, GetConfig, GetInfoConfig, SetConfig, assertValidLastModified } from "./IArchives";
+import { IArchives, ArchiveFileInfo, ArchivesConfig, ChangesAfterConfig, DelConfig, GetConfig, GetInfoConfig, SetConfig, assertValidLastModified } from "./IArchives";
 import { filterChanges } from "./remoteStorage/remoteConfig";
 
 // The base file-system IArchives: storage is one-to-one with the file system, every key is exactly one real file under <folder>/files, so the file system itself is the index. File handles are cached and reused, and closed once idle (see FileHandleCache). All operations on a file run in serial, so they can't collide with each other or with handle closing. Used as the disk synchronization source of BlobStore (see remoteStorage/blobStore.ts).
@@ -151,6 +151,9 @@ export class ArchivesDisk implements IArchives {
 
     // forceSetImmutable is accepted and needs no handling: disk sources are never immutable, and the older-write no-op below already gives synchronization its only-take-the-latest semantics
     public async set(key: string, data: Buffer, config?: SetConfig): Promise<string> {
+        if (!data.length) {
+            throw new Error(`set was called with an empty buffer for ${JSON.stringify(key)} on ${this.getDebugName()}: an empty file IS a deletion in this system and would read back as missing - call del instead`);
+        }
         await this.init();
         let lastModified = config?.lastModified;
         if (lastModified) {
@@ -174,7 +177,8 @@ export class ArchivesDisk implements IArchives {
         return key;
     }
 
-    public async del(key: string): Promise<void> {
+    // config is accepted and ignored: a disk deletion is a physical remove (no tombstone to stamp - BlobStore's index carries the tombstone for disk sources)
+    public async del(key: string, config?: DelConfig): Promise<void> {
         await this.init();
         let filePath = this.filePath(key);
         await this.handles.run(filePath, async () => {
@@ -319,8 +323,8 @@ export class ArchivesDisk implements IArchives {
                 await fs.promises.rename(tmpPath, filePath);
             } catch (e: any) {
                 if (e.code !== "ENOENT") throw e;
-                // Nothing was ever appended, so the upload file was never created
-                await fs.promises.writeFile(filePath, Buffer.alloc(0));
+                // Either nothing was ever appended, or the temp file was destroyed under us - both must fail loudly. Materializing an empty file here (the old behavior) silently turned the upload into a DELETION, since an empty file IS a missing file in this system.
+                throw new Error(`Large upload of ${JSON.stringify(key)} has no data: the upload temp file ${tmpPath} does not exist. Either no data was ever appended (empty files are forbidden - they read back as deletions; use del to delete) or the temp file was removed while the upload was running.`);
             }
             // The rename preserves the temp file's mtime, which is just when the last append happened - the logical write time has to be stamped explicitly (it is the metadata scans order everything by)
             if (lastModified) {

package/storage/IArchives.d.ts

@@ -58,6 +58,14 @@ export type GetConfig = {
     /** 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 DelConfig = {
+    /** Stamps the deletion (its tombstone) with this write time instead of now. Synchronization passes the ORIGINAL deletion time, so deletion ordering survives propagation exactly like any other write's ordering. */
+    lastModified?: number;
+    /** See SetConfig.internal. */
+    internal?: boolean;
+    /** See SetConfig.noChecks. */
+    noChecks?: 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;
@@ -181,9 +189,14 @@ export interface IArchives {
      * VARIABLE_SHARD, where the shard value is materialized into the key (picked by shard latency,
      * see ArchivesChain) and the caller needs the returned key to ever read the value back.
      */
+    /**
+     * THROWS on an empty buffer: an empty file IS a deletion in this system (the tombstone), so a
+     * set-empty would read back as "the file is gone" - which is just asking for problems. If you
+     * want the file deleted, call del; deletions take their own path.
+     */
     set(fileName: string, data: Buffer, config?: SetConfig): Promise<string>;
-    del(fileName: string): Promise<void>;
-    /** Streams a file too large to hold in memory. getNextData returns undefined when done. lastModified stamps the finished file like set's (synchronized copies need it to keep write ordering); backends that stamp their own times (backblaze) accept and ignore it. */
+    del(fileName: string, config?: DelConfig): Promise<void>;
+    /** Streams a file too large to hold in memory. getNextData returns undefined when done. lastModified stamps the finished file like set's (synchronized copies need it to keep write ordering); backends that stamp their own times (backblaze) accept and ignore it. THROWS when the stream produces no data at all - same rule as set: an empty file IS a deletion and would read back as missing. */
     setLargeFile(config: {
         path: string;
         lastModified?: number;

package/storage/IArchives.ts

@@ -94,6 +94,15 @@ export type GetConfig = {
     internal?: boolean;
 };
 
+export type DelConfig = {
+    /** Stamps the deletion (its tombstone) with this write time instead of now. Synchronization passes the ORIGINAL deletion time, so deletion ordering survives propagation exactly like any other write's ordering. */
+    lastModified?: number;
+    /** See SetConfig.internal. */
+    internal?: boolean;
+    /** See SetConfig.noChecks. */
+    noChecks?: 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;
@@ -204,7 +213,8 @@ export async function copyArchiveFile(config: {
     }
     if (size <= LARGE_COPY_THRESHOLD) {
         let result = await from.get2(path, { internal: config.internal });
-        if (!result || !result.data) return undefined;
+        // Empty counts as absent, never as content to copy: an empty file IS a deletion, set refuses empty buffers, and deletions travel through their own path (del / scan tombstones)
+        if (!result || !result.data || !result.data.length) return undefined;
         await to.set(path, result.data, { lastModified: result.writeTime, forceSetImmutable: config.forceSetImmutable, noChecks: config.noChecks, internal: config.internal });
         return { writeTime: result.writeTime, size: result.data.length };
     }
@@ -246,6 +256,7 @@ export type ArchivesSyncStatus = {
     sources: ArchivesSyncSourceStatus[];
 };
 
+// NOTE: We don't presently have an append function here because a surprising number of storage systems don't support it (backblaze, file system api). It would also complicate things as now there needs to be really a single source of truth of a file, and if you append to the wrong single source of truth, things just become very complicated. 
 export interface IArchives {
     getDebugName(): string;
     /** Whether writes would be accepted (credentials exist, the account trusts this machine, etc). Checked without writing anything. */
@@ -269,9 +280,14 @@ export interface IArchives {
      * VARIABLE_SHARD, where the shard value is materialized into the key (picked by shard latency,
      * see ArchivesChain) and the caller needs the returned key to ever read the value back.
      */
+    /**
+     * THROWS on an empty buffer: an empty file IS a deletion in this system (the tombstone), so a
+     * set-empty would read back as "the file is gone" - which is just asking for problems. If you
+     * want the file deleted, call del; deletions take their own path.
+     */
     set(fileName: string, data: Buffer, config?: SetConfig): Promise<string>;
-    del(fileName: string): Promise<void>;
-    /** Streams a file too large to hold in memory. getNextData returns undefined when done. lastModified stamps the finished file like set's (synchronized copies need it to keep write ordering); backends that stamp their own times (backblaze) accept and ignore it. */
+    del(fileName: string, config?: DelConfig): Promise<void>;
+    /** Streams a file too large to hold in memory. getNextData returns undefined when done. lastModified stamps the finished file like set's (synchronized copies need it to keep write ordering); backends that stamp their own times (backblaze) accept and ignore it. THROWS when the stream produces no data at all - same rule as set: an empty file IS a deletion and would read back as missing. */
     setLargeFile(config: { path: string; 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. Size-0 entries (tombstones) report undefined unless config.includeTombstones. */
     getInfo(fileName: string, config?: GetInfoConfig): Promise<{ writeTime: number; size: number; url?: string } | undefined>;

package/storage/backblaze.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 /// <reference types="node" />
-import { IArchives, ArchivesConfig, ChangesAfterConfig, ArchiveFileInfo, GetConfig, GetInfoConfig, SetConfig } from "./IArchives";
+import { IArchives, ArchivesConfig, ChangesAfterConfig, ArchiveFileInfo, DelConfig, GetConfig, GetInfoConfig, SetConfig } from "./IArchives";
 export declare class ArchivesBackblaze implements IArchives {
     private config;
     constructor(config: {
@@ -29,7 +29,7 @@ export declare class ArchivesBackblaze implements IArchives {
     getConfig(): Promise<ArchivesConfig>;
     hasWriteAccess(): Promise<boolean>;
     set(fileName: string, data: Buffer, config?: SetConfig): Promise<string>;
-    del(fileName: string): Promise<void>;
+    del(fileName: string, config?: DelConfig): Promise<void>;
     setLargeFile(config: {
         path: string;
         lastModified?: number;

package/storage/backblaze.ts

@@ -9,7 +9,7 @@ import debugbreak from "debugbreak";
 import dns from "dns";
 import { getSecret } from "../misc/getSecret";
 import { httpsRequest, HttpsResponseInfo } from "socket-function/src/https";
-import { IArchives, ArchivesConfig, ChangesAfterConfig, ArchiveFileInfo, GetConfig, GetInfoConfig, SetConfig, assertValidLastModified, IMMUTABLE_CACHE_TIME } from "./IArchives";
+import { IArchives, ArchivesConfig, ChangesAfterConfig, ArchiveFileInfo, DelConfig, GetConfig, GetInfoConfig, SetConfig, assertValidLastModified, IMMUTABLE_CACHE_TIME } from "./IArchives";
 import { filterChanges } from "./remoteStorage/remoteConfig";
 
 type BackblazeCreds = {
@@ -703,6 +703,9 @@ export class ArchivesBackblaze implements IArchives {
         }
     }
     public async set(fileName: string, data: Buffer, config?: SetConfig): Promise<string> {
+        if (!data.length) {
+            throw new Error(`set was called with an empty buffer for ${JSON.stringify(fileName)} on ${this.getDebugName()}: an empty file IS a deletion in this system and would read back as missing - call del instead`);
+        }
         if (config?.forceSetImmutable && !config.lastModified) {
             throw new Error(`forceSetImmutable requires lastModified (synchronization writes are ordered by their write time), writing ${fileName} to ${this.getDebugName()}`);
         }
@@ -737,7 +740,19 @@ export class ArchivesBackblaze implements IArchives {
         }
         return fileName;
     }
-    public async del(fileName: string): Promise<void> {
+    public async del(fileName: string, config?: DelConfig): Promise<void> {
+        if (config?.lastModified) {
+            // A synchronized deletion: b2's hide removes the file from listings entirely, so peers scanning the bucket could never learn of it. Instead the tombstone is stored as a REAL empty file (an empty file IS a missing file), which listings show and scans ingest as a deletion. (b2 stamps its own upload time, so the exact deletion time is not preserved here - same as every b2 write.)
+            if (!config.noChecks) {
+                let existing = await this.getInfo(fileName, { includeTombstones: true });
+                if (existing && config.lastModified < existing.writeTime) return;
+            }
+            this.log(`backblaze tombstone upload ${fileName}`);
+            await this.apiRetryLogic(`del ${fileName}`, async (api) => {
+                await api.uploadFile({ bucketId: this.bucketId, fileName, data: Buffer.alloc(0) });
+            });
+            return;
+        }
         this.log(`backblaze delete ${fileName}`);
         try {
             await this.apiRetryLogic(`hideFile ${fileName}`, async (api) => {
@@ -777,7 +792,9 @@ export class ArchivesBackblaze implements IArchives {
 
             let fileName = path;
             let data = await getNextData();
-            if (!data?.length) return;
+            if (!data?.length) {
+                throw new Error(`setLargeFile produced no data for ${JSON.stringify(config.path)} on ${this.getDebugName()}: an empty file IS a deletion in this system - call del to delete, never write empty files`);
+            }
             // Backblaze disallows overly small files
             if (data.length < MIN_CHUNK_SIZE) {
                 await this.set(fileName, data);