@fgv/ts-web-extras 5.0.2 → 5.1.0-1

package/dist/test/unit/localStorageTreeAccessors.test.js

@@ -0,0 +1,812 @@
+/*
+ * Copyright (c) 2026 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+import '@fgv/ts-utils-jest';
+import { FileTree } from '@fgv/ts-json-base';
+import { LocalStorageTreeAccessors, FileApiTreeAccessors } from '../../packlets/file-tree';
+/**
+ * Mock Storage implementation for testing
+ */
+class MockStorage {
+    constructor() {
+        this._data = new Map();
+    }
+    get length() {
+        return this._data.size;
+    }
+    clear() {
+        this._data.clear();
+    }
+    getItem(key) {
+        var _a;
+        return (_a = this._data.get(key)) !== null && _a !== void 0 ? _a : null;
+    }
+    key(index) {
+        var _a;
+        const keys = Array.from(this._data.keys());
+        return (_a = keys[index]) !== null && _a !== void 0 ? _a : null;
+    }
+    removeItem(key) {
+        this._data.delete(key);
+    }
+    setItem(key, value) {
+        this._data.set(key, value);
+    }
+}
+describe('LocalStorageTreeAccessors', () => {
+    let mockStorage;
+    beforeEach(() => {
+        mockStorage = new MockStorage();
+    });
+    describe('fromStorage', () => {
+        test('creates accessors from empty storage', () => {
+            const result = LocalStorageTreeAccessors.fromStorage({
+                pathToKeyMap: {
+                    '/data/ingredients': 'test:ingredients:v1'
+                },
+                storage: mockStorage
+            });
+            expect(result).toSucceedAndSatisfy((accessors) => {
+                expect(accessors).toBeInstanceOf(LocalStorageTreeAccessors);
+                expect(accessors.isDirty()).toBe(false);
+            });
+        });
+        test('loads collections from storage', () => {
+            mockStorage.setItem('test:ingredients:v1', JSON.stringify({
+                collection1: { items: { item1: {} } },
+                collection2: { items: { item2: {} } }
+            }));
+            const result = LocalStorageTreeAccessors.fromStorage({
+                pathToKeyMap: {
+                    '/data/ingredients': 'test:ingredients:v1'
+                },
+                storage: mockStorage
+            });
+            expect(result).toSucceedAndSatisfy((accessors) => {
+                expect(accessors.getFileContents('/data/ingredients/collection1.json')).toSucceed();
+                expect(accessors.getFileContents('/data/ingredients/collection2.json')).toSucceed();
+            });
+        });
+        test('loads from multiple storage keys', () => {
+            mockStorage.setItem('test:ingredients:v1', JSON.stringify({ ing1: { items: {} } }));
+            mockStorage.setItem('test:fillings:v1', JSON.stringify({ fill1: { items: {} } }));
+            const result = LocalStorageTreeAccessors.fromStorage({
+                pathToKeyMap: {
+                    '/data/ingredients': 'test:ingredients:v1',
+                    '/data/fillings': 'test:fillings:v1'
+                },
+                storage: mockStorage
+            });
+            expect(result).toSucceedAndSatisfy((accessors) => {
+                expect(accessors.getFileContents('/data/ingredients/ing1.json')).toSucceed();
+                expect(accessors.getFileContents('/data/fillings/fill1.json')).toSucceed();
+            });
+        });
+        test('skips corrupted JSON data', () => {
+            mockStorage.setItem('test:ingredients:v1', 'not valid json');
+            const result = LocalStorageTreeAccessors.fromStorage({
+                pathToKeyMap: {
+                    '/data/ingredients': 'test:ingredients:v1'
+                },
+                storage: mockStorage
+            });
+            expect(result).toSucceedAndSatisfy((accessors) => {
+                expect(accessors).toBeInstanceOf(LocalStorageTreeAccessors);
+            });
+        });
+        test('skips non-object JSON', () => {
+            mockStorage.setItem('test:ingredients:v1', '"string value"');
+            const result = LocalStorageTreeAccessors.fromStorage({
+                pathToKeyMap: {
+                    '/data/ingredients': 'test:ingredients:v1'
+                },
+                storage: mockStorage
+            });
+            expect(result).toSucceedAndSatisfy((accessors) => {
+                expect(accessors).toBeInstanceOf(LocalStorageTreeAccessors);
+            });
+        });
+        test('loads string values (new format) with inferred extension', () => {
+            mockStorage.setItem('test:ingredients:v1', JSON.stringify({
+                jsonCollection: '{"items":{}}',
+                yamlCollection: 'metadata:\n  name: test\nitems: {}'
+            }));
+            const result = LocalStorageTreeAccessors.fromStorage({
+                pathToKeyMap: {
+                    '/data/ingredients': 'test:ingredients:v1'
+                },
+                storage: mockStorage
+            });
+            expect(result).toSucceedAndSatisfy((accessors) => {
+                expect(accessors.getFileContents('/data/ingredients/jsonCollection.json')).toSucceedWith('{"items":{}}');
+                expect(accessors.getFileContents('/data/ingredients/yamlCollection.yaml')).toSucceedWith('metadata:\n  name: test\nitems: {}');
+            });
+        });
+        test('skips non-object non-string collection values', () => {
+            mockStorage.setItem('test:ingredients:v1', JSON.stringify({
+                good: { items: {} },
+                bad: 42
+            }));
+            const result = LocalStorageTreeAccessors.fromStorage({
+                pathToKeyMap: {
+                    '/data/ingredients': 'test:ingredients:v1'
+                },
+                storage: mockStorage
+            });
+            expect(result).toSucceedAndSatisfy((accessors) => {
+                expect(accessors.getFileContents('/data/ingredients/good.json')).toSucceed();
+            });
+        });
+        test('applies prefix parameter', () => {
+            mockStorage.setItem('test:ingredients:v1', JSON.stringify({ collection1: { items: {} } }));
+            const result = LocalStorageTreeAccessors.fromStorage({
+                pathToKeyMap: {
+                    '/data/ingredients': 'test:ingredients:v1'
+                },
+                storage: mockStorage,
+                prefix: '/myapp'
+            });
+            expect(result).toSucceedAndSatisfy((accessors) => {
+                expect(accessors.getFileContents('/myapp/data/ingredients/collection1.json')).toSucceed();
+            });
+        });
+        test('succeeds with empty storage when no data present', () => {
+            const result = LocalStorageTreeAccessors.fromStorage({
+                pathToKeyMap: {
+                    '/data/ingredients': 'test:ingredients:v1'
+                },
+                storage: mockStorage
+            });
+            expect(result).toSucceedAndSatisfy((accessors) => {
+                expect(accessors).toBeInstanceOf(LocalStorageTreeAccessors);
+            });
+        });
+    });
+    describe('dirty tracking', () => {
+        test('starts with no dirty files', () => {
+            mockStorage.setItem('test:ingredients:v1', JSON.stringify({ collection1: { items: {} } }));
+            const accessors = LocalStorageTreeAccessors.fromStorage({
+                pathToKeyMap: {
+                    '/data/ingredients': 'test:ingredients:v1'
+                },
+                storage: mockStorage,
+                mutable: true
+            }).orThrow();
+            expect(accessors.isDirty()).toBe(false);
+            expect(accessors.getDirtyPaths()).toEqual([]);
+        });
+        test('marks files as dirty after modification', () => {
+            mockStorage.setItem('test:ingredients:v1', JSON.stringify({ collection1: { items: {} } }));
+            const accessors = LocalStorageTreeAccessors.fromStorage({
+                pathToKeyMap: {
+                    '/data/ingredients': 'test:ingredients:v1'
+                },
+                storage: mockStorage,
+                mutable: true
+            }).orThrow();
+            const newContent = JSON.stringify({ items: { modified: true } });
+            accessors.saveFileContents('/data/ingredients/collection1.json', newContent).orThrow();
+            expect(accessors.isDirty()).toBe(true);
+            expect(accessors.getDirtyPaths()).toContain('/data/ingredients/collection1.json');
+        });
+        test('tracks multiple dirty files', () => {
+            mockStorage.setItem('test:ingredients:v1', JSON.stringify({
+                collection1: { items: {} },
+                collection2: { items: {} }
+            }));
+            const accessors = LocalStorageTreeAccessors.fromStorage({
+                pathToKeyMap: {
+                    '/data/ingredients': 'test:ingredients:v1'
+                },
+                storage: mockStorage,
+                mutable: true
+            }).orThrow();
+            accessors
+                .saveFileContents('/data/ingredients/collection1.json', JSON.stringify({ items: { a: 1 } }))
+                .orThrow();
+            accessors
+                .saveFileContents('/data/ingredients/collection2.json', JSON.stringify({ items: { b: 2 } }))
+                .orThrow();
+            expect(accessors.isDirty()).toBe(true);
+            expect(accessors.getDirtyPaths()).toHaveLength(2);
+        });
+    });
+    describe('syncToDisk', () => {
+        test('syncs modified files to storage', async () => {
+            mockStorage.setItem('test:ingredients:v1', JSON.stringify({ collection1: { items: { original: true } } }));
+            const accessors = LocalStorageTreeAccessors.fromStorage({
+                pathToKeyMap: {
+                    '/data/ingredients': 'test:ingredients:v1'
+                },
+                storage: mockStorage,
+                mutable: true
+            }).orThrow();
+            const newContent = JSON.stringify({ items: { modified: true } });
+            accessors.saveFileContents('/data/ingredients/collection1.json', newContent).orThrow();
+            const syncResult = await accessors.syncToDisk();
+            expect(syncResult).toSucceed();
+            const stored = mockStorage.getItem('test:ingredients:v1');
+            expect(stored).toBeTruthy();
+            const parsed = JSON.parse(stored);
+            // New format: values are raw content strings
+            expect(parsed.collection1).toBe(newContent);
+        });
+        test('clears dirty state after successful sync', async () => {
+            mockStorage.setItem('test:ingredients:v1', JSON.stringify({ collection1: { items: {} } }));
+            const accessors = LocalStorageTreeAccessors.fromStorage({
+                pathToKeyMap: {
+                    '/data/ingredients': 'test:ingredients:v1'
+                },
+                storage: mockStorage,
+                mutable: true
+            }).orThrow();
+            accessors
+                .saveFileContents('/data/ingredients/collection1.json', JSON.stringify({ items: { a: 1 } }))
+                .orThrow();
+            expect(accessors.isDirty()).toBe(true);
+            await accessors.syncToDisk();
+            expect(accessors.isDirty()).toBe(false);
+            expect(accessors.getDirtyPaths()).toEqual([]);
+        });
+        test('syncs multiple files to same storage key', async () => {
+            mockStorage.setItem('test:ingredients:v1', JSON.stringify({
+                collection1: { items: {} },
+                collection2: { items: {} }
+            }));
+            const accessors = LocalStorageTreeAccessors.fromStorage({
+                pathToKeyMap: {
+                    '/data/ingredients': 'test:ingredients:v1'
+                },
+                storage: mockStorage,
+                mutable: true
+            }).orThrow();
+            const content1 = JSON.stringify({ items: { a: 1 } });
+            const content2 = JSON.stringify({ items: { b: 2 } });
+            accessors.saveFileContents('/data/ingredients/collection1.json', content1).orThrow();
+            accessors.saveFileContents('/data/ingredients/collection2.json', content2).orThrow();
+            await accessors.syncToDisk();
+            const stored = mockStorage.getItem('test:ingredients:v1');
+            const parsed = JSON.parse(stored);
+            // New format: values are raw content strings
+            expect(parsed.collection1).toBe(content1);
+            expect(parsed.collection2).toBe(content2);
+        });
+        test('syncs files to different storage keys', async () => {
+            mockStorage.setItem('test:ingredients:v1', JSON.stringify({ ing1: { items: {} } }));
+            mockStorage.setItem('test:fillings:v1', JSON.stringify({ fill1: { items: {} } }));
+            const accessors = LocalStorageTreeAccessors.fromStorage({
+                pathToKeyMap: {
+                    '/data/ingredients': 'test:ingredients:v1',
+                    '/data/fillings': 'test:fillings:v1'
+                },
+                storage: mockStorage,
+                mutable: true
+            }).orThrow();
+            accessors
+                .saveFileContents('/data/ingredients/ing1.json', JSON.stringify({ items: { a: 1 } }))
+                .orThrow();
+            accessors.saveFileContents('/data/fillings/fill1.json', JSON.stringify({ items: { b: 2 } })).orThrow();
+            await accessors.syncToDisk();
+            const ingContent = JSON.stringify({ items: { a: 1 } });
+            const fillContent = JSON.stringify({ items: { b: 2 } });
+            const ingStored = JSON.parse(mockStorage.getItem('test:ingredients:v1'));
+            const fillStored = JSON.parse(mockStorage.getItem('test:fillings:v1'));
+            // New format: values are raw content strings
+            expect(ingStored.ing1).toBe(ingContent);
+            expect(fillStored.fill1).toBe(fillContent);
+        });
+        test('succeeds with no dirty files', async () => {
+            const accessors = LocalStorageTreeAccessors.fromStorage({
+                pathToKeyMap: {
+                    '/data/ingredients': 'test:ingredients:v1'
+                },
+                storage: mockStorage
+            }).orThrow();
+            const result = await accessors.syncToDisk();
+            expect(result).toSucceed();
+        });
+        test('preserves existing collections when syncing', async () => {
+            mockStorage.setItem('test:ingredients:v1', JSON.stringify({
+                existing: { items: { keep: true } },
+                toModify: { items: { original: true } }
+            }));
+            const accessors = LocalStorageTreeAccessors.fromStorage({
+                pathToKeyMap: {
+                    '/data/ingredients': 'test:ingredients:v1'
+                },
+                storage: mockStorage,
+                mutable: true
+            }).orThrow();
+            const modifiedContent = JSON.stringify({ items: { modified: true } });
+            accessors.saveFileContents('/data/ingredients/toModify.json', modifiedContent).orThrow();
+            await accessors.syncToDisk();
+            const stored = JSON.parse(mockStorage.getItem('test:ingredients:v1'));
+            // existing was loaded from legacy format and not modified, so it stays as legacy object
+            // toModify was saved with new content, so it's now a raw string
+            expect(stored.toModify).toBe(modifiedContent);
+        });
+    });
+    describe('autoSync mode', () => {
+        test('automatically syncs on save when enabled', () => {
+            mockStorage.setItem('test:ingredients:v1', JSON.stringify({ collection1: { items: {} } }));
+            const accessors = LocalStorageTreeAccessors.fromStorage({
+                pathToKeyMap: {
+                    '/data/ingredients': 'test:ingredients:v1'
+                },
+                storage: mockStorage,
+                mutable: true,
+                autoSync: true
+            }).orThrow();
+            accessors
+                .saveFileContents('/data/ingredients/collection1.json', JSON.stringify({ items: { auto: true } }))
+                .orThrow();
+            expect(accessors.isDirty()).toBe(false);
+            const autoContent = JSON.stringify({ items: { auto: true } });
+            const stored = JSON.parse(mockStorage.getItem('test:ingredients:v1'));
+            // New format: values are raw content strings
+            expect(stored.collection1).toBe(autoContent);
+        });
+        test('does not auto-sync when disabled', () => {
+            mockStorage.setItem('test:ingredients:v1', JSON.stringify({ collection1: { items: {} } }));
+            const accessors = LocalStorageTreeAccessors.fromStorage({
+                pathToKeyMap: {
+                    '/data/ingredients': 'test:ingredients:v1'
+                },
+                storage: mockStorage,
+                mutable: true,
+                autoSync: false
+            }).orThrow();
+            accessors
+                .saveFileContents('/data/ingredients/collection1.json', JSON.stringify({ items: { manual: true } }))
+                .orThrow();
+            expect(accessors.isDirty()).toBe(true);
+            // Storage should still have the original legacy format (not yet synced)
+            const stored = JSON.parse(mockStorage.getItem('test:ingredients:v1'));
+            expect(stored.collection1).toEqual({ items: {} });
+        });
+    });
+    describe('fileIsMutable', () => {
+        test('returns persistent detail when mutable', () => {
+            mockStorage.setItem('test:ingredients:v1', JSON.stringify({ collection1: { items: {} } }));
+            const accessors = LocalStorageTreeAccessors.fromStorage({
+                pathToKeyMap: {
+                    '/data/ingredients': 'test:ingredients:v1'
+                },
+                storage: mockStorage,
+                mutable: true
+            }).orThrow();
+            expect(accessors.fileIsMutable('/data/ingredients/collection1.json')).toSucceedWithDetail(true, 'persistent');
+        });
+        test('returns not-mutable when not mutable', () => {
+            mockStorage.setItem('test:ingredients:v1', JSON.stringify({ collection1: { items: {} } }));
+            const accessors = LocalStorageTreeAccessors.fromStorage({
+                pathToKeyMap: {
+                    '/data/ingredients': 'test:ingredients:v1'
+                },
+                storage: mockStorage,
+                mutable: false
+            }).orThrow();
+            const result = accessors.fileIsMutable('/data/ingredients/collection1.json');
+            expect(result.isFailure()).toBe(true);
+            if (result.isFailure()) {
+                expect(result.detail).toBe('not-mutable');
+            }
+        });
+    });
+    describe('integration with FileApiTreeAccessors', () => {
+        test('createFromLocalStorage creates FileTree with persistent accessors', () => {
+            mockStorage.setItem('test:ingredients:v1', JSON.stringify({ collection1: { items: {} } }));
+            const result = FileApiTreeAccessors.createFromLocalStorage({
+                pathToKeyMap: {
+                    '/data/ingredients': 'test:ingredients:v1'
+                },
+                storage: mockStorage,
+                mutable: true
+            });
+            expect(result).toSucceed();
+            const tree = result.orThrow();
+            expect(tree).toBeInstanceOf(FileTree.FileTree);
+            expect(FileTree.isPersistentAccessors(tree.hal)).toBe(true);
+            const file = tree.getFile('/data/ingredients/collection1.json').orThrow();
+            expect(FileTree.isMutableFileItem(file)).toBe(true);
+            if (FileTree.isMutableFileItem(file)) {
+                expect(file.getIsMutable()).toSucceedWithDetail(true, 'persistent');
+            }
+        });
+        test('createFromLocalStorage with multiple paths', () => {
+            mockStorage.setItem('test:ingredients:v1', JSON.stringify({ ing1: { items: {} } }));
+            mockStorage.setItem('test:fillings:v1', JSON.stringify({ fill1: { items: {} } }));
+            const result = FileApiTreeAccessors.createFromLocalStorage({
+                pathToKeyMap: {
+                    '/data/ingredients': 'test:ingredients:v1',
+                    '/data/fillings': 'test:fillings:v1'
+                },
+                storage: mockStorage,
+                mutable: true
+            });
+            expect(result).toSucceedAndSatisfy((tree) => {
+                expect(tree.getFile('/data/ingredients/ing1.json')).toSucceed();
+                expect(tree.getFile('/data/fillings/fill1.json')).toSucceed();
+            });
+        });
+        test('createFromLocalStorage with empty storage', () => {
+            const result = FileApiTreeAccessors.createFromLocalStorage({
+                pathToKeyMap: {
+                    '/data/ingredients': 'test:ingredients:v1'
+                },
+                storage: mockStorage
+            });
+            expect(result).toSucceedAndSatisfy((tree) => {
+                expect(tree).toBeInstanceOf(FileTree.FileTree);
+            });
+        });
+        test('createFromLocalStorage fails when localStorage is not available', () => {
+            // Remove the global window object to ensure no fallback
+            const originalWindow = global.window;
+            delete global.window;
+            const result = FileApiTreeAccessors.createFromLocalStorage({
+                pathToKeyMap: {
+                    '/data/ingredients': 'test:ingredients:v1'
+                },
+                storage: undefined
+            });
+            // Restore window
+            global.window = originalWindow;
+            expect(result).toFailWith(/localStorage is not available/i);
+        });
+    });
+    describe('path matching and error handling', () => {
+        test('handles files outside configured paths', async () => {
+            mockStorage.setItem('test:ingredients:v1', JSON.stringify({ collection1: { items: {} } }));
+            const accessors = LocalStorageTreeAccessors.fromStorage({
+                pathToKeyMap: {
+                    '/data/ingredients': 'test:ingredients:v1'
+                },
+                storage: mockStorage,
+                mutable: true
+            }).orThrow();
+            // Try to save a file outside the configured path
+            const saveResult = accessors.saveFileContents('/other/path/file.json', JSON.stringify({ test: 1 }));
+            expect(saveResult).toSucceed();
+            // But syncing should fail because no storage key is configured
+            const syncResult = await accessors.syncToDisk();
+            expect(syncResult).toFailWith(/No storage key configured for path/i);
+        });
+        test('handles files inside configured paths', async () => {
+            mockStorage.setItem('test:ingredients:v1', JSON.stringify({ collection1: { items: {} } }));
+            const accessors = LocalStorageTreeAccessors.fromStorage({
+                pathToKeyMap: {
+                    '/data/ingredients': 'test:ingredients:v1'
+                },
+                storage: mockStorage,
+                mutable: true
+            }).orThrow();
+            // Save a file inside the configured path
+            accessors.saveFileContents('/data/ingredients/newfile.json', JSON.stringify({ test: 1 })).orThrow();
+            // Syncing should succeed
+            const syncResult = await accessors.syncToDisk();
+            expect(syncResult).toSucceed();
+        });
+        test('handles failed content retrieval during sync', async () => {
+            mockStorage.setItem('test:ingredients:v1', JSON.stringify({ collection1: { items: {} } }));
+            const accessors = LocalStorageTreeAccessors.fromStorage({
+                pathToKeyMap: {
+                    '/data/ingredients': 'test:ingredients:v1'
+                },
+                storage: mockStorage,
+                mutable: true
+            }).orThrow();
+            // Modify a file
+            accessors.saveFileContents('/data/ingredients/collection1.json', JSON.stringify({ test: 1 })).orThrow();
+            // Override getFileContents to fail
+            const originalGetFileContents = accessors.getFileContents.bind(accessors);
+            accessors.getFileContents = jest.fn((path) => {
+                if (path === '/data/ingredients/collection1.json') {
+                    return { isSuccess: () => false, isFailure: () => true, message: 'File not found' };
+                }
+                return originalGetFileContents(path);
+            });
+            const syncResult = await accessors.syncToDisk();
+            expect(syncResult).toFailWith(/Failed to get file contents.*File not found/i);
+        });
+        test('handles corrupted JSON in localStorage during sync', async () => {
+            mockStorage.setItem('test:ingredients:v1', JSON.stringify({ collection1: { items: {} } }));
+            const accessors = LocalStorageTreeAccessors.fromStorage({
+                pathToKeyMap: {
+                    '/data/ingredients': 'test:ingredients:v1'
+                },
+                storage: mockStorage,
+                mutable: true
+            }).orThrow();
+            // Modify a file
+            accessors.saveFileContents('/data/ingredients/collection1.json', JSON.stringify({ test: 1 })).orThrow();
+            // Corrupt the existing storage data
+            mockStorage.setItem('test:ingredients:v1', 'not valid json');
+            // Sync should still succeed by starting fresh
+            const syncResult = await accessors.syncToDisk();
+            expect(syncResult).toSucceed();
+            // Verify the data was written correctly despite corrupted previous data
+            const stored = mockStorage.getItem('test:ingredients:v1');
+            const parsed = JSON.parse(stored);
+            // New format: values are raw content strings
+            expect(parsed.collection1).toBe(JSON.stringify({ test: 1 }));
+        });
+        test('syncs non-JSON content (YAML) without error', async () => {
+            const accessors = LocalStorageTreeAccessors.fromStorage({
+                pathToKeyMap: {
+                    '/data/ingredients': 'test:ingredients:v1'
+                },
+                storage: mockStorage,
+                mutable: true
+            }).orThrow();
+            // Create and save a YAML file
+            const yamlContent = 'metadata:\n  name: test\nitems: {}';
+            accessors.saveFileContents('/data/ingredients/my-collection.yaml', yamlContent).orThrow();
+            const syncResult = await accessors.syncToDisk();
+            expect(syncResult).toSucceed();
+            const stored = JSON.parse(mockStorage.getItem('test:ingredients:v1'));
+            expect(stored['my-collection']).toBe(yamlContent);
+        });
+        test('handles multiple sync failures with aggregated errors', async () => {
+            const accessors = LocalStorageTreeAccessors.fromStorage({
+                pathToKeyMap: {
+                    '/data/ingredients': 'test:ingredients:v1'
+                },
+                storage: mockStorage,
+                mutable: true
+            }).orThrow();
+            // Add files outside configured paths
+            accessors.saveFileContents('/other1/file1.json', JSON.stringify({ test: 1 })).orThrow();
+            accessors.saveFileContents('/other2/file2.json', JSON.stringify({ test: 2 })).orThrow();
+            const syncResult = await accessors.syncToDisk();
+            expect(syncResult).toFailWith(/Failed to sync 2 file\(s\)/i);
+        });
+        test('handles auto-sync failure', () => {
+            mockStorage.setItem('test:ingredients:v1', JSON.stringify({ collection1: { items: {} } }));
+            const accessors = LocalStorageTreeAccessors.fromStorage({
+                pathToKeyMap: {
+                    '/data/ingredients': 'test:ingredients:v1'
+                },
+                storage: mockStorage,
+                mutable: true,
+                autoSync: true
+            }).orThrow();
+            // Try to save a file outside configured path with autoSync enabled
+            const saveResult = accessors.saveFileContents('/other/path/file.json', JSON.stringify({ test: 1 }));
+            expect(saveResult).toFailWith(/No storage key configured for path/i);
+        });
+    });
+    describe('deleteFile', () => {
+        test('deletes a file from in-memory storage and from localStorage', () => {
+            mockStorage.setItem('test:ingredients:v1', JSON.stringify({
+                collection1: '{"items":{}}',
+                collection2: '{"items":{}}'
+            }));
+            const accessors = LocalStorageTreeAccessors.fromStorage({
+                pathToKeyMap: {
+                    '/data/ingredients': 'test:ingredients:v1'
+                },
+                storage: mockStorage,
+                mutable: true
+            }).orThrow();
+            const result = accessors.deleteFile('/data/ingredients/collection1.json');
+            expect(result).toSucceedWith(true);
+            // File should no longer be accessible in-memory
+            expect(accessors.getFileContents('/data/ingredients/collection1.json')).toFail();
+            // The deleted collection should be removed from localStorage; collection2 remains
+            const stored = mockStorage.getItem('test:ingredients:v1');
+            expect(stored).toBeTruthy();
+            const parsed = JSON.parse(stored);
+            expect(parsed).not.toHaveProperty('collection1');
+            expect(parsed).toHaveProperty('collection2');
+        });
+        test('removes the storage key entirely when last entry is deleted', () => {
+            mockStorage.setItem('test:ingredients:v1', JSON.stringify({ onlyCollection: '{"items":{}}' }));
+            const accessors = LocalStorageTreeAccessors.fromStorage({
+                pathToKeyMap: {
+                    '/data/ingredients': 'test:ingredients:v1'
+                },
+                storage: mockStorage,
+                mutable: true
+            }).orThrow();
+            const result = accessors.deleteFile('/data/ingredients/onlyCollection.json');
+            expect(result).toSucceedWith(true);
+            // Storage key should be removed entirely since no more entries remain
+            expect(mockStorage.getItem('test:ingredients:v1')).toBeNull();
+        });
+        test('removes path from dirty set when deleting a dirty file', () => {
+            mockStorage.setItem('test:ingredients:v1', JSON.stringify({ collection1: '{"items":{}}' }));
+            const accessors = LocalStorageTreeAccessors.fromStorage({
+                pathToKeyMap: {
+                    '/data/ingredients': 'test:ingredients:v1'
+                },
+                storage: mockStorage,
+                mutable: true
+            }).orThrow();
+            // Mark file as dirty first
+            accessors
+                .saveFileContents('/data/ingredients/collection1.json', JSON.stringify({ items: { modified: true } }))
+                .orThrow();
+            expect(accessors.isDirty()).toBe(true);
+            // Deleting the file should clean it from the dirty set
+            const result = accessors.deleteFile('/data/ingredients/collection1.json');
+            expect(result).toSucceedWith(true);
+            expect(accessors.isDirty()).toBe(false);
+            expect(accessors.getDirtyPaths()).not.toContain('/data/ingredients/collection1.json');
+        });
+        test('fails when deleting a non-existent file', () => {
+            const accessors = LocalStorageTreeAccessors.fromStorage({
+                pathToKeyMap: {
+                    '/data/ingredients': 'test:ingredients:v1'
+                },
+                storage: mockStorage,
+                mutable: true
+            }).orThrow();
+            const result = accessors.deleteFile('/data/ingredients/nonexistent.json');
+            expect(result).toFail();
+        });
+        test('does not modify storage when file has no matching storage key', () => {
+            // Create accessors with one path, but a file that will be stored outside that path
+            const accessors = LocalStorageTreeAccessors.fromStorage({
+                pathToKeyMap: {
+                    '/data/ingredients': 'test:ingredients:v1'
+                },
+                storage: mockStorage,
+                mutable: true
+            }).orThrow();
+            // Add and delete a file inside the configured path but with no existing storage entry
+            accessors.saveFileContents('/data/ingredients/newfile.json', '{"items":{}}').orThrow();
+            // Sync so it exists in storage
+            mockStorage.setItem('test:ingredients:v1', JSON.stringify({ newfile: '{"items":{}}' }));
+            // Now re-load and delete — the file should be removed from storage
+            const accessors2 = LocalStorageTreeAccessors.fromStorage({
+                pathToKeyMap: {
+                    '/data/ingredients': 'test:ingredients:v1'
+                },
+                storage: mockStorage,
+                mutable: true
+            }).orThrow();
+            const result = accessors2.deleteFile('/data/ingredients/newfile.json');
+            expect(result).toSucceedWith(true);
+            expect(mockStorage.getItem('test:ingredients:v1')).toBeNull();
+        });
+        test('handles deletion when localStorage key has no entry for the file', () => {
+            // Storage key exists but does not contain an entry for the file being deleted
+            mockStorage.setItem('test:ingredients:v1', JSON.stringify({ other: '{"items":{}}' }));
+            // Manually add a file to in-memory without it being in the storage JSON
+            const accessors = LocalStorageTreeAccessors.fromStorage({
+                pathToKeyMap: {
+                    '/data/ingredients': 'test:ingredients:v1'
+                },
+                storage: mockStorage,
+                mutable: true
+            }).orThrow();
+            // Save a new file (marks dirty but does not update storage yet)
+            accessors.saveFileContents('/data/ingredients/newfile.json', '{"items":{}}').orThrow();
+            // Clear the dirty flag by directly removing from storage (simulate storage mismatch)
+            // Then delete the file — _deleteFileFromStorage gets the existing JSON which lacks 'newfile'
+            // This exercises the path where the collection is not in the existing JSON
+            mockStorage.setItem('test:ingredients:v1', JSON.stringify({ other: '{"items":{}}' }));
+            const result = accessors.deleteFile('/data/ingredients/newfile.json');
+            expect(result).toSucceedWith(true);
+            // 'other' should still remain in storage since only 'newfile' was deleted (which wasn't there)
+            const stored = mockStorage.getItem('test:ingredients:v1');
+            expect(stored).toBeTruthy();
+            const parsed = JSON.parse(stored);
+            expect(parsed).toHaveProperty('other');
+        });
+        test('handles deletion when storage entry for key is missing entirely', () => {
+            // No storage key at all — _deleteFileFromStorage should return early
+            const accessors = LocalStorageTreeAccessors.fromStorage({
+                pathToKeyMap: {
+                    '/data/ingredients': 'test:ingredients:v1'
+                },
+                storage: mockStorage,
+                mutable: true
+            }).orThrow();
+            // Manually put a file in memory by saving it
+            accessors.saveFileContents('/data/ingredients/newfile.json', '{"items":{}}').orThrow();
+            // Delete the storage key so getItem returns null
+            mockStorage.removeItem('test:ingredients:v1');
+            // deleteFile should still succeed (in-memory deletion succeeds; storage cleanup is a no-op)
+            const result = accessors.deleteFile('/data/ingredients/newfile.json');
+            expect(result).toSucceedWith(true);
+        });
+        test('handles deletion when storage contains corrupted JSON', () => {
+            mockStorage.setItem('test:ingredients:v1', JSON.stringify({ collection1: '{"items":{}}' }));
+            const accessors = LocalStorageTreeAccessors.fromStorage({
+                pathToKeyMap: {
+                    '/data/ingredients': 'test:ingredients:v1'
+                },
+                storage: mockStorage,
+                mutable: true
+            }).orThrow();
+            // Corrupt the storage so JSON.parse fails in _deleteFileFromStorage
+            mockStorage.setItem('test:ingredients:v1', 'not valid json {{{');
+            // deleteFile should still succeed — corrupted JSON is silently ignored
+            const result = accessors.deleteFile('/data/ingredients/collection1.json');
+            expect(result).toSucceedWith(true);
+        });
+        test('deletes a file at a path outside all configured storage keys', () => {
+            // A file can be saved in-memory at a path that has no matching storage key.
+            // When deleted, _deleteFileFromStorage should return early without touching storage.
+            const accessors = LocalStorageTreeAccessors.fromStorage({
+                pathToKeyMap: {
+                    '/data/ingredients': 'test:ingredients:v1'
+                },
+                storage: mockStorage,
+                mutable: true
+            }).orThrow();
+            // Save a file outside the configured path (succeeds in-memory, marks dirty)
+            accessors.saveFileContents('/untracked/file.json', '{"items":{}}').orThrow();
+            // Delete it — should succeed even though there is no storage key for this path
+            const result = accessors.deleteFile('/untracked/file.json');
+            expect(result).toSucceedWith(true);
+            // Storage should be untouched
+            expect(mockStorage.getItem('test:ingredients:v1')).toBeNull();
+        });
+    });
+    describe('inferContentType callback in _loadFromStorage', () => {
+        test('calls inferContentType when loading files from storage', () => {
+            // Covers lines 163-164: the params.inferContentType branch in _loadFromStorage
+            mockStorage.setItem('test:ingredients:v1', JSON.stringify({
+                myCollection: '{"items":{}}'
+            }));
+            const inferContentType = jest.fn((filePath, _provided) => {
+                const { succeed: s } = require('@fgv/ts-utils');
+                return s('application/json');
+            });
+            const result = LocalStorageTreeAccessors.fromStorage({
+                pathToKeyMap: {
+                    '/data/ingredients': 'test:ingredients:v1'
+                },
+                storage: mockStorage,
+                inferContentType
+            });
+            expect(result).toSucceed();
+            expect(inferContentType).toHaveBeenCalledWith('/data/ingredients/myCollection.json', undefined);
+        });
+    });
+    describe('extension-less file path handling', () => {
+        test('syncs a file whose path has no extension (collection ID has no dot)', async () => {
+            // Covers line 249: dotIndex <= 0 case in _getCollectionIdFromPath, returning cleanPath as-is
+            // We save a file at a path with no file extension; the collection ID extracted
+            // will be the entire basename (no dot to strip).
+            const accessors = LocalStorageTreeAccessors.fromStorage({
+                pathToKeyMap: {
+                    '/data/ingredients': 'test:ingredients:v1'
+                },
+                storage: mockStorage,
+                mutable: true
+            }).orThrow();
+            // Save a file at a path with no extension
+            accessors.saveFileContents('/data/ingredients/nodot', '{"items":{}}').orThrow();
+            const syncResult = await accessors.syncToDisk();
+            expect(syncResult).toSucceed();
+            // The collection ID stored in localStorage should be 'nodot' (no extension stripped)
+            const stored = mockStorage.getItem('test:ingredients:v1');
+            expect(stored).toBeTruthy();
+            const parsed = JSON.parse(stored);
+            expect(parsed.nodot).toBe('{"items":{}}');
+        });
+    });
+});
+//# sourceMappingURL=localStorageTreeAccessors.test.js.map