sliftutils 1.7.122 → 1.7.124

package/package.json

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

package/storage/BulkDatabase2/BulkDatabaseBase.ts

@@ -40,6 +40,10 @@ const ROLLOVER_BYTES = 5 * 1024 * 1024;
 const MEMORY_WATCHDOG_INTERVAL_MS = 60 * 1000;
 const STALE_DELETE_MS = 24 * 60 * 60 * 1000;
 const MAX_INDEX_RELOAD_ATTEMPTS = 3;
+// A bulk file under this is "loose" - still worth rolling up into a bigger one. Half the target file size, because that is exactly where combining stops paying: merging two files that are each over half the target just splits back into two files again, so the file count (and with it the per-file key list every read holds in memory) does not drop. Under half, any two inputs fit in one output, so phase 2 always makes the count go down.
+//
+// NOT the target size itself. runPlannedMerge cuts a chunk BEFORE adding the key that would exceed the target, so every file it writes is under TARGET_FILE_BYTES - testing against the target would classify the entire collection as loose and re-merge all of it, forever.
+const LOOSE_BULK_MAX_BYTES = TARGET_FILE_BYTES / 2;
 const KEY_GROUP_BYTES = 800 * 1024 * 1024;
 const DUP_THRESHOLD = 0.4;
 // Whole-tier dedup short-circuit (start of phase 3): when the combined tier is over this size AND the overall key duplication fraction is over this threshold, fold every combined file in one merge instead of the per-key-group walk (which spaces merges 5 min apart — 16 h for 200 groups).
@@ -363,16 +367,13 @@ export class BulkDatabaseBase<T extends { key: string }> {
         return this.streamBytesOnDisk > bulkDatabase2Timing.streamFoldTriggerBytes;
     }
 
-    // Stream files nobody can still be appending to, split by who owned them:
-    //   retirable - a fold may delete these the moment it has consumed them, instead of waiting out streamSealAgeMs. Includes our own sealed files and merge-carry output.
-    //   ownerGone - nobody is left to fold these (a closed tab's leftovers, or a legacy name with no owner stamp), and until one is folded every reader has to decode all of it just to build the index. Worth folding at any size. Our own files are deliberately NOT in here: every merge pass seals ours, so counting them would fold on every tick; the streamFileMaxBytes rollover and the streamFoldTriggerBytes gate cover ours instead.
+    // Stream files nobody can still be appending to: our own sealed files, merge-carry output, and files whose owner is gone (a closed tab's leftovers, or a legacy name with no owner stamp). A fold may delete these the moment it has consumed them, instead of waiting out streamSealAgeMs.
     //
     // Foreign owners are probed over the sync channel. In Node there is no channel, so we cannot know - every foreign owner is assumed alive and the streamSealAgeMs rule stands.
     //
     // assumeSealed is for planning: a merge pass broadcasts a seal before it starts, so by the time it merges our current file IS final. The planner passes isSyncSupported() to predict that; anything deciding a real deletion passes false and goes by streamFileName as it actually stands.
-    private async findAbandonedStreams(streamFiles: StreamFileInfo[], assumeSealed: boolean): Promise<{ retirable: Set<string>; ownerGone: Set<string> }> {
+    private async findAbandonedStreams(streamFiles: StreamFileInfo[], assumeSealed: boolean): Promise<Set<string>> {
         const retirable = new Set<string>();
-        const ownerGone = new Set<string>();
         const hasForeignOwner = streamFiles.some(f => f.ownerId && f.ownerId !== writerId && f.ownerId !== MERGE_OUTPUT_OWNER);
         const live = hasForeignOwner && await queryLiveWriters(this.name, bulkDatabase2Timing.liveWriterProbeMs) || undefined;
         for (const f of streamFiles) {
@@ -382,12 +383,9 @@ export class BulkDatabaseBase<T extends { key: string }> {
                 if (assumeSealed || f.fileName !== this.streamFileName) retirable.add(f.fileName);
                 continue;
             }
-            if (!f.ownerId || live && !live.has(f.ownerId)) {
-                retirable.add(f.fileName);
-                ownerGone.add(f.fileName);
-            }
+            if (!f.ownerId || live && !live.has(f.ownerId)) retirable.add(f.fileName);
         }
-        return { retirable, ownerGone };
+        return retirable;
     }
 
     private async automaticCompactionAllowed(): Promise<boolean> {
@@ -858,7 +856,7 @@ export class BulkDatabaseBase<T extends { key: string }> {
         const streamReader = ordered.length ? streamReaderFromEntries(ordered, 0).reader : undefined;
 
         // An abandoned stream that yielded no entries (zero bytes, or nothing but torn bytes) holds no data and has no writer left. Retire it here: the merge below never lists it as a used source, so the normal retirement path would skip it and it would re-trigger the abandoned-stream fold on every pass. replacedBy is empty because nothing supersedes it - the marker hides it from reads immediately and processMarkers deletes it once aged.
-        const { retirable: retirableStreams } = await this.findAbandonedStreams(streamFiles, false);
+        const retirableStreams = await this.findAbandonedStreams(streamFiles, false);
         const contributingStreams = new Set(streamData.entries.map(e => e.fileName));
         const emptyAbandoned = streamFiles.filter(f => retirableStreams.has(f.fileName) && !contributingStreams.has(f.fileName)).map(f => f.fileName);
         if (emptyAbandoned.length) await writeDeleteMarker(storage, { deleteFiles: emptyAbandoned, replacedBy: [] });
@@ -966,7 +964,7 @@ export class BulkDatabaseBase<T extends { key: string }> {
         return true;
     }
 
-    // Splits the bulk tier the way the merge writer does. A merge cuts an output file once it reaches TARGET_FILE_BYTES, so only its LAST output can be under that — meaning a sub-target file is either a single stream fold or the tail of an earlier merge, and is still waiting to be rolled up ("loose"). Anything at or over the target is done growing ("combined") and only phase 3 touches it again.
+    // Splits the bulk tier into files still worth rolling up ("loose", under LOOSE_BULK_MAX_BYTES - a single stream fold, or the tail end of an earlier merge) and files that are done growing ("combined", which only phase 3 touches again).
     //
     // A file whose size won't read is reported as combined: phase 2 can't consume one (its reader won't load, so the merge won't retire it), and calling it loose would re-trigger phase 2 on every pass until handleUnreadableFile finally deletes it.
     private async splitBulkTier(bulkFiles: BulkFileInfo[]): Promise<{ loose: BulkFileInfo[]; looseBytes: number; combined: BulkFileInfo[]; sizes: Map<string, number> }> {
@@ -978,7 +976,7 @@ export class BulkDatabaseBase<T extends { key: string }> {
         for (let i = 0; i < bulkFiles.length; i++) {
             const bytes = logicalSizes[i];
             sizes.set(bulkFiles[i].fileName, bytes ?? 0);
-            if (bytes === undefined || bytes >= TARGET_FILE_BYTES) {
+            if (bytes === undefined || bytes >= LOOSE_BULK_MAX_BYTES) {
                 combined.push(bulkFiles[i]);
                 continue;
             }
@@ -1064,28 +1062,26 @@ export class BulkDatabaseBase<T extends { key: string }> {
         });
 
         // A pass seals before it merges, so by then our own current file is final too - predict that rather than reporting it as still-open.
-        const { retirable, ownerGone } = await this.findAbandonedStreams(streamFiles, isSyncSupported());
+        const retirable = await this.findAbandonedStreams(streamFiles, isSyncSupported());
         // Only fold what we can also retire. Folding a stream a live foreign owner may still append to would copy it into bulk without removing it, so the bytes would stay in memory and just get re-folded next pass; that owner rolls its own file over at streamFileMaxBytes instead.
         // Aged past streamSealAgeMs counts as retirable too (canDeleteStream's own first rule): no writer appends past the seal age, and this is the only thing that frees the tier in Node, where liveness cannot be probed at all.
         const foldable = streamFiles.filter(f => f.ownerId !== MERGE_OUTPUT_OWNER
             && (retirable.has(f.fileName) || time - f.timestamp >= bulkDatabase2Timing.streamSealAgeMs));
         // Merge-carry files hold nothing but tombstones and are never a REASON to fold - folding one alone would just rewrite it into another carry file, forever. They ride along whenever something else folds, which collapses however many have piled up into one.
         const carry = streamFiles.filter(f => f.ownerId === MERGE_OUTPUT_OWNER);
-        // A stream whose writer is gone will never grow and nothing else will ever fold it, so fold it at any size - even one row. Zero-byte ones don't count: they hold no data to fold, and mergeFileSetInner retires them directly.
-        const abandoned = foldable.filter(f => ownerGone.has(f.fileName) && streamSizes.get(f.fileName));
+        // Size is the only reason to fold. An abandoned stream is NOT one on its own: it is already retirable, so it is counted here and gets swept up the moment the tier is worth folding, and until then it is bounded by this very threshold. Triggering on one would fold on essentially every pass - a browser leaves a file behind whose writer never answers the liveness probe on every reload - which mints a small bulk file each time and pushes the fragmentation into phase 2.
         const foldTriggers = [
             makeTrigger({ name: "foldableBytes", value: streamBytes(foldable), threshold: bulkDatabase2Timing.streamFoldTriggerBytes, unit: "bytes" }),
-            makeTrigger({ name: "abandonedFiles", value: abandoned.length, threshold: 1, unit: "count" }),
         ];
         steps.push({
-            phase: 1, kind: "streamFold", requires: "any", triggers: foldTriggers,
+            phase: 1, kind: "streamFold", requires: "all", triggers: foldTriggers,
             // Skipped when the hard limit already folds everything this would have.
-            ready: !hardLimit.met && foldTriggers.some(t => t.met),
+            ready: !hardLimit.met && foldTriggers.every(t => t.met),
             bulkFiles: [], streamFiles: [...foldable, ...carry], bytes: streamBytes([...foldable, ...carry]),
         });
 
         // ── Phase 2: loose bulk -> combined bulk ─────────────────────────────────────────────────────
-        // Phase 1 emits one small bulk file per fold. Each is cheap to read (index only) but holds its whole key list in memory and joins into every read, so they have to be rolled up. Merging just the loose ones also dedupes them for free - a rewrite-heavy workload collapses a gigabyte of near-identical folds into almost nothing - and it always terminates, because a merge cuts every output but the last at TARGET_FILE_BYTES, so one pass can leave at most one loose file behind.
+        // Phase 1 emits one small bulk file per fold. Each is cheap to read (index only) but holds its whole key list in memory and joins into every read, so they have to be rolled up. Merging just the loose ones also dedupes them for free - a rewrite-heavy workload collapses a gigabyte of near-identical folds into almost nothing - and it always terminates: a chunk is only cut once the next key would take it past TARGET_FILE_BYTES, so every output but the last is over half the target and lands in the combined tier, leaving at most one loose file behind.
         const { loose, looseBytes, combined, sizes } = await this.splitBulkTier(bulkFiles);
         const looseTriggers = [
             makeTrigger({ name: "looseBytes", value: looseBytes, threshold: bulkDatabase2Timing.looseBulkTriggerBytes, unit: "bytes" }),

package/storage/PrivateFileSystemStorage.ts

@@ -1,17 +1,5 @@
-import { delay } from "socket-function/src/batching";
 import { IStorageRaw } from "./IStorage";
 
-const WRITE_CONFLICT_RETRIES = 5;
-const WRITE_CONFLICT_DELAY = 100;
-
-// Serializes writes to the same file within this process, so two overlapping set calls can never hold a writable on the same file at once. Keyed by full path, as separate instances are commonly created for the same root.
-let writeChains = new Map<string, Promise<unknown>>();
-
-// OPFS rejects a write when the file changed between resolving the handle and finishing the write (another tab, or an overlapping write we don't control). We always write the file in full, so re-resolving the handle and writing again is correct.
-function isStaleHandleError(error: unknown): boolean {
-    return String((error as Error)?.stack || error).includes("InvalidStateError");
-}
-
 export class PrivateFileSystemStorage implements IStorageRaw {
     private rootHandle: FileSystemDirectoryHandle | undefined;
 
@@ -145,37 +133,12 @@ export class PrivateFileSystemStorage implements IStorageRaw {
     }
 
     public async set(key: string, value: Buffer): Promise<void> {
-        const write = async () => {
-            for (let attempt = 1; attempt <= WRITE_CONFLICT_RETRIES; attempt++) {
-                try {
-                    await this.ensureInitialized();
-                    const { dir, name } = await this.resolveKey(key, true);
-                    const fileHandle = await dir.getFileHandle(name, { create: true });
-                    const writable = await fileHandle.createWritable();
-                    await writable.write(value);
-                    await writable.close();
-                    return;
-                } catch (error) {
-                    if (!isStaleHandleError(error) || attempt === WRITE_CONFLICT_RETRIES) {
-                        throw error;
-                    }
-                    console.warn(`Write of ${this.path}/${key} conflicted with another writer, retrying (attempt ${attempt} of ${WRITE_CONFLICT_RETRIES}):`, String((error as Error)?.stack || error));
-                    await delay(WRITE_CONFLICT_DELAY);
-                }
-            }
-        };
-
-        const chainKey = `${this.path}/${key}`;
-        const previous = writeChains.get(chainKey) || Promise.resolve();
-        const current = previous.catch(() => { }).then(write);
-        writeChains.set(chainKey, current);
-        try {
-            await current;
-        } finally {
-            if (writeChains.get(chainKey) === current) {
-                writeChains.delete(chainKey);
-            }
-        }
+        await this.ensureInitialized();
+        const { dir, name } = await this.resolveKey(key, true);
+        const fileHandle = await dir.getFileHandle(name, { create: true });
+        const writable = await fileHandle.createWritable();
+        await writable.write(value);
+        await writable.close();
     }
 
     public async append(key: string, value: Buffer): Promise<void> {

package/storage/dist/PrivateFileSystemStorage.ts.cache

@@ -1,15 +1,6 @@
 "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";
 Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
 //exports.PrivateFileSystemStorage = void 0;
-const batching_1 = require("socket-function/src/batching");
-const WRITE_CONFLICT_RETRIES = 5;
-const WRITE_CONFLICT_DELAY = 100;
-// Serializes writes to the same file within this process, so two overlapping set calls can never hold a writable on the same file at once. Keyed by full path, as separate instances are commonly created for the same root.
-let writeChains = new Map();
-// OPFS rejects a write when the file changed between resolving the handle and finishing the write (another tab, or an overlapping write we don't control). We always write the file in full, so re-resolving the handle and writing again is correct.
-function isStaleHandleError(error) {
-    return String((error === null || error === void 0 ? void 0 : error.stack) || error).includes("InvalidStateError");
-}
 class PrivateFileSystemStorage {
     constructor(path) {
         this.path = path;
@@ -129,38 +120,12 @@ class PrivateFileSystemStorage {
         return Buffer.from(arrayBuffer);
     }
     async set(key, value) {
-        const write = async () => {
-            for (let attempt = 1; attempt <= WRITE_CONFLICT_RETRIES; attempt++) {
-                try {
-                    await this.ensureInitialized();
-                    const { dir, name } = await this.resolveKey(key, true);
-                    const fileHandle = await dir.getFileHandle(name, { create: true });
-                    const writable = await fileHandle.createWritable();
-                    await writable.write(value);
-                    await writable.close();
-                    return;
-                }
-                catch (error) {
-                    if (!isStaleHandleError(error) || attempt === WRITE_CONFLICT_RETRIES) {
-                        throw error;
-                    }
-                    console.warn(`Write of ${this.path}/${key} conflicted with another writer, retrying (attempt ${attempt} of ${WRITE_CONFLICT_RETRIES}):`, String((error === null || error === void 0 ? void 0 : error.stack) || error));
-                    await (0, batching_1.delay)(WRITE_CONFLICT_DELAY);
-                }
-            }
-        };
-        const chainKey = `${this.path}/${key}`;
-        const previous = writeChains.get(chainKey) || Promise.resolve();
-        const current = previous.catch(() => { }).then(write);
-        writeChains.set(chainKey, current);
-        try {
-            await current;
-        }
-        finally {
-            if (writeChains.get(chainKey) === current) {
-                writeChains.delete(chainKey);
-            }
-        }
+        await this.ensureInitialized();
+        const { dir, name } = await this.resolveKey(key, true);
+        const fileHandle = await dir.getFileHandle(name, { create: true });
+        const writable = await fileHandle.createWritable();
+        await writable.write(value);
+        await writable.close();
     }
     async append(key, value) {
         const existingContent = await this.get(key);
@@ -218,5 +183,5 @@ class PrivateFileSystemStorage {
     }
 }
 exports.PrivateFileSystemStorage = PrivateFileSystemStorage;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"PrivateFileSystemStorage.js","sourceRoot":"","sources":["PrivateFileSystemStorage.ts"],"names":[],"mappings":"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","sourcesContent":["import { delay } from \"socket-function/src/batching\";\nimport { IStorageRaw } from \"./IStorage\";\n\nconst WRITE_CONFLICT_RETRIES = 5;\nconst WRITE_CONFLICT_DELAY = 100;\n\n// Serializes writes to the same file within this process, so two overlapping set calls can never hold a writable on the same file at once. Keyed by full path, as separate instances are commonly created for the same root.\nlet writeChains = new Map<string, Promise<unknown>>();\n\n// OPFS rejects a write when the file changed between resolving the handle and finishing the write (another tab, or an overlapping write we don't control). We always write the file in full, so re-resolving the handle and writing again is correct.\nfunction isStaleHandleError(error: unknown): boolean {\n    return String((error as Error)?.stack || error).includes(\"InvalidStateError\");\n}\n\nexport class PrivateFileSystemStorage implements IStorageRaw {\n    private rootHandle: FileSystemDirectoryHandle | undefined;\n\n    constructor(private path: string) { }\n\n    private async ensureInitialized(): Promise<FileSystemDirectoryHandle> {\n        if (!this.rootHandle) {\n            if (!navigator.storage?.getDirectory) {\n                throw new Error(\"Private File System Access API not supported in this browser\");\n            }\n            if (location.protocol === \"file:\") {\n                throw new Error(`Private File System API is disallowed in file:// type locations. Either use the File System API (the use gives you access to their file system), or host on an actual domain`);\n            }\n            this.rootHandle = await navigator.storage.getDirectory();\n        }\n        return this.rootHandle;\n    }\n\n    private async directoryExists(): Promise<boolean> {\n        const root = await this.ensureInitialized();\n        try {\n\n            if (!this.path || this.path === \"\" || this.path === \"/\") {\n                return true; // Root always exists\n            }\n\n            const pathParts = this.path.split(\"/\").filter(part => part.length > 0);\n            let currentHandle = root;\n\n            for (const part of pathParts) {\n                try {\n                    currentHandle = await currentHandle.getDirectoryHandle(part);\n                } catch (error) {\n                    return false;\n                }\n            }\n\n            return true;\n        } catch (error) {\n            return false;\n        }\n    }\n\n    private async getDirectoryHandle(createPath: boolean = true): Promise<FileSystemDirectoryHandle> {\n        const root = await this.ensureInitialized();\n\n        if (!this.path || this.path === \"\" || this.path === \"/\") {\n            return root;\n        }\n\n        const pathParts = this.path.split(\"/\").filter(part => part.length > 0);\n        let currentHandle = root;\n\n        for (const part of pathParts) {\n            try {\n                currentHandle = await currentHandle.getDirectoryHandle(part, { create: createPath });\n            } catch (error) {\n                if (!createPath) {\n                    throw new Error(`Directory not found: ${this.path}`);\n                }\n                throw error;\n            }\n        }\n\n        return currentHandle;\n    }\n\n    // Keys may contain \"/\" (nested paths). OPFS handles reject separators in names, so we\n    // walk/create the intermediate directories and return the leaf directory + file name.\n    private async resolveKey(key: string, create: boolean): Promise<{ dir: FileSystemDirectoryHandle; name: string }> {\n        let dir = await this.getDirectoryHandle(create);\n        const parts = key.split(\"/\").filter(part => part.length > 0);\n        const name = parts.pop();\n        if (!name) {\n            throw new Error(`Invalid empty key: ${JSON.stringify(key)}`);\n        }\n        for (const part of parts) {\n            dir = await dir.getDirectoryHandle(part, { create });\n        }\n        return { dir, name };\n    }\n\n    private async getFileHandle(key: string, create: boolean = false): Promise<FileSystemFileHandle | undefined> {\n        await this.ensureInitialized();\n        if (create) {\n            const { dir, name } = await this.resolveKey(key, true);\n            return await dir.getFileHandle(name, { create: true });\n        }\n        try {\n            const { dir, name } = await this.resolveKey(key, false);\n            return await dir.getFileHandle(name);\n        } catch (error) {\n            return undefined;\n        }\n    }\n\n    private async fileExists(key: string): Promise<boolean> {\n        return !!(await this.getFileHandle(key, false));\n    }\n\n    public async get(key: string): Promise<Buffer | undefined> {\n        // Check if file exists first to avoid unnecessary errors\n        if (!(await this.fileExists(key))) {\n            return undefined;\n        }\n\n        try {\n            const fileHandle = await this.getFileHandle(key, false);\n            if (!fileHandle) {\n                return undefined;\n            }\n\n            const file = await fileHandle.getFile();\n            const arrayBuffer = await file.arrayBuffer();\n            return Buffer.from(arrayBuffer);\n        } catch (error) {\n            console.warn(`Error reading file ${key}:`, error);\n            return undefined;\n        }\n    }\n\n    public async getRange(key: string, config: { start: number; end: number }): Promise<Buffer | undefined> {\n        const fileHandle = await this.getFileHandle(key, false);\n        if (!fileHandle) {\n            return undefined;\n        }\n\n        const file = await fileHandle.getFile();\n        const arrayBuffer = await file.slice(config.start, config.end).arrayBuffer();\n        return Buffer.from(arrayBuffer);\n    }\n\n    public async set(key: string, value: Buffer): Promise<void> {\n        const write = async () => {\n            for (let attempt = 1; attempt <= WRITE_CONFLICT_RETRIES; attempt++) {\n                try {\n                    await this.ensureInitialized();\n                    const { dir, name } = await this.resolveKey(key, true);\n                    const fileHandle = await dir.getFileHandle(name, { create: true });\n                    const writable = await fileHandle.createWritable();\n                    await writable.write(value);\n                    await writable.close();\n                    return;\n                } catch (error) {\n                    if (!isStaleHandleError(error) || attempt === WRITE_CONFLICT_RETRIES) {\n                        throw error;\n                    }\n                    console.warn(`Write of ${this.path}/${key} conflicted with another writer, retrying (attempt ${attempt} of ${WRITE_CONFLICT_RETRIES}):`, String((error as Error)?.stack || error));\n                    await delay(WRITE_CONFLICT_DELAY);\n                }\n            }\n        };\n\n        const chainKey = `${this.path}/${key}`;\n        const previous = writeChains.get(chainKey) || Promise.resolve();\n        const current = previous.catch(() => { }).then(write);\n        writeChains.set(chainKey, current);\n        try {\n            await current;\n        } finally {\n            if (writeChains.get(chainKey) === current) {\n                writeChains.delete(chainKey);\n            }\n        }\n    }\n\n    public async append(key: string, value: Buffer): Promise<void> {\n        const existingContent = await this.get(key);\n        let newContent: Buffer;\n        if (existingContent) {\n            newContent = Buffer.concat([existingContent, value]);\n        } else {\n            newContent = value;\n        }\n        await this.set(key, newContent);\n    }\n\n    public async remove(key: string): Promise<void> {\n        // Check if file exists first to avoid unnecessary errors\n        if (!(await this.fileExists(key))) {\n            return; // File doesn't exist, nothing to remove\n        }\n\n        const { dir, name } = await this.resolveKey(key, false);\n        await dir.removeEntry(name);\n    }\n\n    public async getKeys(): Promise<string[]> {\n        // Check if directory exists first to avoid unnecessary errors\n        if (!(await this.directoryExists())) {\n            return [];\n        }\n\n        const dirHandle = await this.getDirectoryHandle(false);\n        const keys: string[] = [];\n        const walk = async (dir: FileSystemDirectoryHandle, prefix: string) => {\n            // Use the async iterator protocol for FileSystemDirectoryHandle\n            for await (const [name, handle] of (dir as any).entries()) {\n                if (handle.kind === \"file\") {\n                    keys.push(prefix + name);\n                } else if (handle.kind === \"directory\") {\n                    await walk(handle, prefix + name + \"/\");\n                }\n            }\n        };\n        await walk(dirHandle, \"\");\n        return keys.sort();\n    }\n    public async getInfo(key: string): Promise<undefined | {\n        size: number;\n        lastModified: number;\n    }> {\n        let fileHandle = await this.getFileHandle(key, false);\n        if (!fileHandle) {\n            return undefined;\n        }\n        let file = await fileHandle.getFile();\n        return {\n            size: file.size,\n            lastModified: file.lastModified,\n        };\n    }\n    public async reset(): Promise<void> {\n        throw new Error(\"Not implemented\");\n    }\n}"]}
- /* _JS_SOURCE_HASH = "d48d77b8abb9d34713bc4fea1980d744ec120d119496a16a6c55cbc3af0f65fb"; */
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"PrivateFileSystemStorage.js","sourceRoot":"","sources":["PrivateFileSystemStorage.ts"],"names":[],"mappings":"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","sourcesContent":["import { IStorageRaw } from \"./IStorage\";\n\nexport class PrivateFileSystemStorage implements IStorageRaw {\n    private rootHandle: FileSystemDirectoryHandle | undefined;\n\n    constructor(private path: string) { }\n\n    private async ensureInitialized(): Promise<FileSystemDirectoryHandle> {\n        if (!this.rootHandle) {\n            if (!navigator.storage?.getDirectory) {\n                throw new Error(\"Private File System Access API not supported in this browser\");\n            }\n            if (location.protocol === \"file:\") {\n                throw new Error(`Private File System API is disallowed in file:// type locations. Either use the File System API (the use gives you access to their file system), or host on an actual domain`);\n            }\n            this.rootHandle = await navigator.storage.getDirectory();\n        }\n        return this.rootHandle;\n    }\n\n    private async directoryExists(): Promise<boolean> {\n        const root = await this.ensureInitialized();\n        try {\n\n            if (!this.path || this.path === \"\" || this.path === \"/\") {\n                return true; // Root always exists\n            }\n\n            const pathParts = this.path.split(\"/\").filter(part => part.length > 0);\n            let currentHandle = root;\n\n            for (const part of pathParts) {\n                try {\n                    currentHandle = await currentHandle.getDirectoryHandle(part);\n                } catch (error) {\n                    return false;\n                }\n            }\n\n            return true;\n        } catch (error) {\n            return false;\n        }\n    }\n\n    private async getDirectoryHandle(createPath: boolean = true): Promise<FileSystemDirectoryHandle> {\n        const root = await this.ensureInitialized();\n\n        if (!this.path || this.path === \"\" || this.path === \"/\") {\n            return root;\n        }\n\n        const pathParts = this.path.split(\"/\").filter(part => part.length > 0);\n        let currentHandle = root;\n\n        for (const part of pathParts) {\n            try {\n                currentHandle = await currentHandle.getDirectoryHandle(part, { create: createPath });\n            } catch (error) {\n                if (!createPath) {\n                    throw new Error(`Directory not found: ${this.path}`);\n                }\n                throw error;\n            }\n        }\n\n        return currentHandle;\n    }\n\n    // Keys may contain \"/\" (nested paths). OPFS handles reject separators in names, so we\n    // walk/create the intermediate directories and return the leaf directory + file name.\n    private async resolveKey(key: string, create: boolean): Promise<{ dir: FileSystemDirectoryHandle; name: string }> {\n        let dir = await this.getDirectoryHandle(create);\n        const parts = key.split(\"/\").filter(part => part.length > 0);\n        const name = parts.pop();\n        if (!name) {\n            throw new Error(`Invalid empty key: ${JSON.stringify(key)}`);\n        }\n        for (const part of parts) {\n            dir = await dir.getDirectoryHandle(part, { create });\n        }\n        return { dir, name };\n    }\n\n    private async getFileHandle(key: string, create: boolean = false): Promise<FileSystemFileHandle | undefined> {\n        await this.ensureInitialized();\n        if (create) {\n            const { dir, name } = await this.resolveKey(key, true);\n            return await dir.getFileHandle(name, { create: true });\n        }\n        try {\n            const { dir, name } = await this.resolveKey(key, false);\n            return await dir.getFileHandle(name);\n        } catch (error) {\n            return undefined;\n        }\n    }\n\n    private async fileExists(key: string): Promise<boolean> {\n        return !!(await this.getFileHandle(key, false));\n    }\n\n    public async get(key: string): Promise<Buffer | undefined> {\n        // Check if file exists first to avoid unnecessary errors\n        if (!(await this.fileExists(key))) {\n            return undefined;\n        }\n\n        try {\n            const fileHandle = await this.getFileHandle(key, false);\n            if (!fileHandle) {\n                return undefined;\n            }\n\n            const file = await fileHandle.getFile();\n            const arrayBuffer = await file.arrayBuffer();\n            return Buffer.from(arrayBuffer);\n        } catch (error) {\n            console.warn(`Error reading file ${key}:`, error);\n            return undefined;\n        }\n    }\n\n    public async getRange(key: string, config: { start: number; end: number }): Promise<Buffer | undefined> {\n        const fileHandle = await this.getFileHandle(key, false);\n        if (!fileHandle) {\n            return undefined;\n        }\n\n        const file = await fileHandle.getFile();\n        const arrayBuffer = await file.slice(config.start, config.end).arrayBuffer();\n        return Buffer.from(arrayBuffer);\n    }\n\n    public async set(key: string, value: Buffer): Promise<void> {\n        await this.ensureInitialized();\n        const { dir, name } = await this.resolveKey(key, true);\n        const fileHandle = await dir.getFileHandle(name, { create: true });\n        const writable = await fileHandle.createWritable();\n        await writable.write(value);\n        await writable.close();\n    }\n\n    public async append(key: string, value: Buffer): Promise<void> {\n        const existingContent = await this.get(key);\n        let newContent: Buffer;\n        if (existingContent) {\n            newContent = Buffer.concat([existingContent, value]);\n        } else {\n            newContent = value;\n        }\n        await this.set(key, newContent);\n    }\n\n    public async remove(key: string): Promise<void> {\n        // Check if file exists first to avoid unnecessary errors\n        if (!(await this.fileExists(key))) {\n            return; // File doesn't exist, nothing to remove\n        }\n\n        const { dir, name } = await this.resolveKey(key, false);\n        await dir.removeEntry(name);\n    }\n\n    public async getKeys(): Promise<string[]> {\n        // Check if directory exists first to avoid unnecessary errors\n        if (!(await this.directoryExists())) {\n            return [];\n        }\n\n        const dirHandle = await this.getDirectoryHandle(false);\n        const keys: string[] = [];\n        const walk = async (dir: FileSystemDirectoryHandle, prefix: string) => {\n            // Use the async iterator protocol for FileSystemDirectoryHandle\n            for await (const [name, handle] of (dir as any).entries()) {\n                if (handle.kind === \"file\") {\n                    keys.push(prefix + name);\n                } else if (handle.kind === \"directory\") {\n                    await walk(handle, prefix + name + \"/\");\n                }\n            }\n        };\n        await walk(dirHandle, \"\");\n        return keys.sort();\n    }\n    public async getInfo(key: string): Promise<undefined | {\n        size: number;\n        lastModified: number;\n    }> {\n        let fileHandle = await this.getFileHandle(key, false);\n        if (!fileHandle) {\n            return undefined;\n        }\n        let file = await fileHandle.getFile();\n        return {\n            size: file.size,\n            lastModified: file.lastModified,\n        };\n    }\n    public async reset(): Promise<void> {\n        throw new Error(\"Not implemented\");\n    }\n}"]}
+ /* _JS_SOURCE_HASH = "d36140aa01c59609e7b32f01e6afca9fd5be1f57c25820dea2bf3779303d78c0"; */