sliftutils 1.7.65 → 1.7.67

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>;
@@ -2146,6 +2146,12 @@ declare module "sliftutils/storage/IArchives" {
         };
         /** Read ONLY from the primary source - the one writes would target - instead of falling back across the redundant sources. Use this when you want your reads and writes to be somewhat atomic: there will still be issues with the round trip, but without it you could talk to a completely different node and get a much older value. Most reads aren't followed by a write though, so for most cases it's better to get a value than to have to wait (or even throw) when the primary node is not available. */
         noFallbacks?: boolean;
+        /** 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;
@@ -2158,6 +2164,8 @@ declare module "sliftutils/storage/IArchives" {
         forceSetImmutable?: boolean;
         /** Skips the target-side safety reads around the write (backblaze: the pre-write getInfo comparison and the post-upload existence poll). For writers whose own bookkeeping already decides what to write and orders it by write time (BlobStore's index-driven writes and synchronization), those reads are pure extra API calls - but the default stays checked, because other users of the raw backends rely on the checks. */
         noChecks?: boolean;
+        /** Store-to-store push: the receiving node writes purely to its own disk and index, with NO downstream fan-out (the pushing store owns propagation - fanning its pushes back out is how write loops between stores form). Window and route ARE still checked: the stamp must fall inside one of the receiver's configured windows and routes, so a confused peer cannot stuff data onto a node that was never meant to hold it. Requires lastModified. */
+        internal?: boolean;
     };
     export type ArchiveFileInfo = {
         path: string;
@@ -2212,6 +2220,7 @@ declare module "sliftutils/storage/IArchives" {
         writeTime?: number;
         forceSetImmutable?: boolean;
         noChecks?: boolean;
+        internal?: boolean;
     }): Promise<{
         writeTime: number;
         size: number;
@@ -2271,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";
@@ -2559,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: {
@@ -2594,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>;
@@ -2863,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;
@@ -2910,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>;
@@ -2938,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);
@@ -2950,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>;
@@ -2986,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 = {
@@ -3001,9 +3018,17 @@ declare module "sliftutils/storage/remoteStorage/blobStore" {
             writeTime: number;
             size: number;
         } | undefined>;
+        getInternal2?(fileName: string, config?: GetConfig): Promise<{
+            data: Buffer;
+            writeTime: number;
+            size: number;
+        } | undefined>;
+        setInternal?(fileName: string, data: Buffer, config: {
+            lastModified: number;
+        }): 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>;
@@ -3140,12 +3165,22 @@ declare module "sliftutils/storage/remoteStorage/blobStore" {
             writeTime: number;
             size: number;
         } | undefined>;
+        /** Internal (store-to-store) read: purely the local disk, completely short-circuiting the index and holder resolution - the caller is another store, and chasing OUR remote holders while answering it is how infinite get loops between stores form. No window or route checks: if the bytes are on our disk, the caller may have them. Note fast writes still sitting in the overlay are invisible here; the caller re-finds them after our flush. */
+        getInternal2(key: string, config?: GetConfig): Promise<{
+            data: Buffer;
+            writeTime: number;
+            size: number;
+        } | undefined>;
+        /** Internal (store-to-store) write: the local disk plus our index, with NO downstream fan-out - the pushing store owns propagation, and fanning its pushes back out is how write loops between stores form. Window/route acceptance is the caller's (writeBucketFile's) job; only-take-latest still applies here. */
+        setInternal(key: string, data: Buffer, config: {
+            lastModified: number;
+        }): Promise<void>;
         private cacheRead;
         set(key: string, data: Buffer, config?: WriteConfig): Promise<string>;
         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>;
@@ -3176,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";
@@ -3251,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;
@@ -3572,14 +3607,14 @@ declare module "sliftutils/storage/remoteStorage/storageController" {
         get2: (account: string, bucketName: string, path: string, range?: {
             start: number;
             end: number;
-        }) => Promise<{
+        }, internal?: boolean) => Promise<{
             data: Buffer;
             writeTime: number;
             size: number;
         } | undefined>;
-        set: (account: string, bucketName: string, path: string, data: Buffer, lastModified?: number, forceSetImmutable?: boolean) => Promise<void>;
+        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>;
@@ -3682,6 +3717,8 @@ declare module "sliftutils/storage/remoteStorage/storageServerState" {
     };
     export declare function addExtraListenPort(port: number): void;
     export declare function removeExtraListenPort(port: number): void;
+    /** Whether address:port is this server process. The ONE self test - findSelfIndexes, createApiArchives, and SourceWrapper all consult it, so "is this me" cannot disagree between the routing plan and connection building: a URL that is us on an extra listen port must never become a network client to ourselves, which is how infinite self-request loops form. */
+    export declare function isOwnAddress(address: string, port: number): boolean;
     /** A cached IArchives for a persisted source identity: a routing URL (hosted/backblaze) or a disk folder path - the form BlobStore's sources list stores. Configuration (valid windows, routes) decides WHEN a source should be used; for reading bytes the index says a source holds, the URL alone is enough - even for sources no longer in any config. */
     export declare function resolveSourceArchives(url: string): IArchives;
     /** Our role in a bucket's routing config, summarized across ALL currently-valid self entries. Stored instead of a single representative HostedConfig, so nothing can accidentally use one entry's route or flags where the union is required - the standard config has the same URL twice: a routed write-shard entry plus an unrouted read-everything entry. */
@@ -3699,6 +3736,7 @@ declare module "sliftutils/storage/remoteStorage/storageServerState" {
     export declare function writeBucketFile(account: string, bucketName: string, filePath: string, data: Buffer, config?: {
         lastModified?: number;
         forceSetImmutable?: boolean;
+        internal?: boolean;
     }): Promise<void>;
     export declare function getBucketConfig(bucket: LoadedBucket): ArchivesConfig;
     /** Which buckets this process currently has loaded - what a deploy successor asks its predecessor for, so it activates exactly the buckets that are actually in use. */

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "sliftutils",
-    "version": "1.7.65",
+    "version": "1.7.67",
     "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, SetConfig } from "./IArchives";
+import { IArchives, ArchiveFileInfo, ArchivesConfig, ChangesAfterConfig, GetConfig, GetInfoConfig, SetConfig } from "./IArchives";
 export declare class ArchivesDisk implements IArchives {
     private folder;
     constructor(folder: string);
@@ -27,7 +27,7 @@ export declare class ArchivesDisk implements IArchives {
         writeTime: number;
         size: number;
     } | undefined>;
-    getInfo(key: string): Promise<{
+    getInfo(key: string, config?: GetInfoConfig): Promise<{
         writeTime: number;
         size: number;
     } | undefined>;

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, SetConfig, assertValidLastModified } from "./IArchives";
+import { IArchives, ArchiveFileInfo, ArchivesConfig, ChangesAfterConfig, 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).
@@ -218,12 +218,13 @@ export class ArchivesDisk implements IArchives {
         });
     }
 
-    public async getInfo(key: string): Promise<{ writeTime: number; size: number } | undefined> {
+    public async getInfo(key: string, config?: GetInfoConfig): Promise<{ writeTime: number; size: number } | undefined> {
         await this.init();
         let filePath = this.filePath(key);
         return await this.handles.run(filePath, async () => {
             let stats = await statOrUndefined(filePath);
             if (!stats || !stats.isFile()) return undefined;
+            if (!stats.size && !config?.includeTombstones) return undefined;
             return { writeTime: stats.mtimeMs, size: stats.size };
         });
     }

package/storage/IArchives.d.ts

@@ -55,6 +55,12 @@ export type GetConfig = {
     };
     /** Read ONLY from the primary source - the one writes would target - instead of falling back across the redundant sources. Use this when you want your reads and writes to be somewhat atomic: there will still be issues with the round trip, but without it you could talk to a completely different node and get a much older value. Most reads aren't followed by a write though, so for most cases it's better to get a value than to have to wait (or even throw) when the primary node is not available. */
     noFallbacks?: boolean;
+    /** 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;
@@ -67,6 +73,8 @@ export type SetConfig = {
     forceSetImmutable?: boolean;
     /** Skips the target-side safety reads around the write (backblaze: the pre-write getInfo comparison and the post-upload existence poll). For writers whose own bookkeeping already decides what to write and orders it by write time (BlobStore's index-driven writes and synchronization), those reads are pure extra API calls - but the default stays checked, because other users of the raw backends rely on the checks. */
     noChecks?: boolean;
+    /** Store-to-store push: the receiving node writes purely to its own disk and index, with NO downstream fan-out (the pushing store owns propagation - fanning its pushes back out is how write loops between stores form). Window and route ARE still checked: the stamp must fall inside one of the receiver's configured windows and routes, so a confused peer cannot stuff data onto a node that was never meant to hold it. Requires lastModified. */
+    internal?: boolean;
 };
 export type ArchiveFileInfo = {
     path: string;
@@ -121,6 +129,7 @@ export declare function copyArchiveFile(config: {
     writeTime?: number;
     forceSetImmutable?: boolean;
     noChecks?: boolean;
+    internal?: boolean;
 }): Promise<{
     writeTime: number;
     size: number;
@@ -180,16 +189,24 @@ export interface 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";

package/storage/IArchives.ts

@@ -90,6 +90,13 @@ export type GetConfig = {
     range?: { start: number; end: number };
     /** Read ONLY from the primary source - the one writes would target - instead of falling back across the redundant sources. Use this when you want your reads and writes to be somewhat atomic: there will still be issues with the round trip, but without it you could talk to a completely different node and get a much older value. Most reads aren't followed by a write though, so for most cases it's better to get a value than to have to wait (or even throw) when the primary node is not available. */
     noFallbacks?: boolean;
+    /** 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 = {
@@ -104,6 +111,8 @@ export type SetConfig = {
     forceSetImmutable?: boolean;
     /** Skips the target-side safety reads around the write (backblaze: the pre-write getInfo comparison and the post-upload existence poll). For writers whose own bookkeeping already decides what to write and orders it by write time (BlobStore's index-driven writes and synchronization), those reads are pure extra API calls - but the default stays checked, because other users of the raw backends rely on the checks. */
     noChecks?: boolean;
+    /** Store-to-store push: the receiving node writes purely to its own disk and index, with NO downstream fan-out (the pushing store owns propagation - fanning its pushes back out is how write loops between stores form). Window and route ARE still checked: the stamp must fall inside one of the receiver's configured windows and routes, so a confused peer cannot stuff data onto a node that was never meant to hold it. Requires lastModified. */
+    internal?: boolean;
 };
 
 // createTime is a misnomer kept for compatibility — it is really the LAST-WRITE time, same as getInfo's writeTime. Neither Backblaze nor our remote storage tracks a distinct creation date: each write stamps a fresh timestamp on the current version, so both fields are just "when the bytes served by get() were most recently written".
@@ -182,6 +191,7 @@ export async function copyArchiveFile(config: {
     writeTime?: number;
     forceSetImmutable?: boolean;
     noChecks?: boolean;
+    internal?: boolean;
 }): Promise<{ writeTime: number; size: number } | undefined> {
     let { from, to, path } = config;
     let size = config.size;
@@ -193,9 +203,9 @@ export async function copyArchiveFile(config: {
         writeTime = info.writeTime;
     }
     if (size <= LARGE_COPY_THRESHOLD) {
-        let result = await from.get2(path);
+        let result = await from.get2(path, { internal: config.internal });
         if (!result || !result.data) return undefined;
-        await to.set(path, result.data, { lastModified: result.writeTime, forceSetImmutable: config.forceSetImmutable, noChecks: config.noChecks });
+        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 };
     }
     // Consts so the closure keeps the narrowed types
@@ -208,7 +218,7 @@ export async function copyArchiveFile(config: {
         getNextData: async () => {
             if (offset >= totalSize) return undefined;
             let end = Math.min(offset + LARGE_COPY_CHUNK, totalSize);
-            let data = await from.get(path, { range: { start: offset, end } });
+            let data = await from.get(path, { range: { start: offset, end }, internal: config.internal });
             if (!data || !data.length) {
                 throw new Error(`Ranged read of ${JSON.stringify(path)} from ${from.getDebugName()} returned ${data && data.length || "nothing"} at ${offset}-${end} (expected ${end - offset} bytes of a ${totalSize} byte file - it changed or vanished mid-copy)`);
             }
@@ -263,9 +273,17 @@ export interface IArchives {
     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. */
     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. */
-    getInfo(fileName: string): Promise<{ writeTime: number; size: number; url?: string } | undefined>;
+    /** 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" }): Promise<ArchiveFileInfo[]>;
     /** Only works for public buckets (private buckets are API-access only). */
     getURL(path: string): Promise<string>;

package/storage/backblaze.d.ts

@@ -1,6 +1,6 @@
 /// <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: {
@@ -35,7 +35,7 @@ export declare class ArchivesBackblaze implements IArchives {
         lastModified?: number;
         getNextData(): Promise<Buffer | undefined>;
     }): Promise<void>;
-    getInfo(fileName: string): Promise<{
+    getInfo(fileName: string, config?: GetInfoConfig): Promise<{
         writeTime: number;
         size: number;
     } | undefined>;

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, SetConfig, assertValidLastModified, IMMUTABLE_CACHE_TIME } from "./IArchives";
+import { IArchives, ArchivesConfig, ChangesAfterConfig, ArchiveFileInfo, GetConfig, GetInfoConfig, SetConfig, assertValidLastModified, IMMUTABLE_CACHE_TIME } from "./IArchives";
 import { filterChanges } from "./remoteStorage/remoteConfig";
 
 type BackblazeCreds = {
@@ -709,7 +709,8 @@ export class ArchivesBackblaze implements IArchives {
         if (config?.lastModified) {
             assertValidLastModified(config.lastModified);
             if (!config.noChecks) {
-                let existing = await this.getInfo(fileName);
+                // includeTombstones: a deletion pushed to b2 is a real size-0 file, and it must still win the older-write comparison - or an older-stamped write would resurrect the deleted file
+                let existing = await this.getInfo(fileName, { includeTombstones: true });
                 // An older write never overwrites a newer one (see IArchives.set). B2 stamps its own upload time, so the exact lastModified is not preserved on the stored file.
                 if (existing && config.lastModified < existing.writeTime) return fileName;
                 // Immutability wins: a synchronization push never overwrites an existing path on an immutable bucket (see SetConfig.forceSetImmutable)
@@ -882,11 +883,11 @@ export class ArchivesBackblaze implements IArchives {
         }
     }
 
-    public async getInfo(fileName: string): Promise<{ writeTime: number; size: number; } | undefined> {
+    public async getInfo(fileName: string, config?: GetInfoConfig): Promise<{ writeTime: number; size: number; } | undefined> {
         return await this.apiRetryLogic(`getInfo ${fileName}`, async (api) => {
             try {
                 let file = await api.headFileByName({ bucketName: this.bucketName, fileName });
-                if (!file) {
+                if (!file || !file.size && !config?.includeTombstones) {
                     this.log(`Backblaze file not exists ${fileName}`);
                     return undefined;
                 }