@fgv/ts-web-extras 5.1.0-2 → 5.1.0-21

package/lib/test/unit/fileApiTreeAccessors.test.js

@@ -1,1190 +0,0 @@
-"use strict";
-/*
- * Copyright (c) 2025 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.
- */
-var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
-var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var g = generator.apply(thisArg, _arguments || []), i, q = [];
-    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
-    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
-    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
-    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
-    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
-    function fulfill(value) { resume("next", value); }
-    function reject(value) { resume("throw", value); }
-    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-require("@fgv/ts-utils-jest");
-const file_tree_1 = require("../../packlets/file-tree");
-const ts_json_base_1 = require("@fgv/ts-json-base");
-const helpers_1 = require("../../packlets/helpers");
-const testHelpers_1 = require("../utils/testHelpers");
-function makeMockHttpResponse(options) {
-    const { ok, status = ok ? 200 : 400, jsonValue, textValue, throwOnJson } = options;
-    return {
-        ok,
-        status,
-        json: throwOnJson
-            ? () => Promise.reject(new Error('JSON parse error'))
-            : () => Promise.resolve(jsonValue),
-        text: () => Promise.resolve(textValue !== null && textValue !== void 0 ? textValue : `HTTP ${status}`)
-    };
-}
-function makeMockHttpFetch(responses) {
-    let callIndex = 0;
-    return (url, _init) => {
-        const response = responses[callIndex++];
-        if (response === undefined) {
-            return Promise.reject(new Error(`Unexpected fetch call to ${url.toString()}`));
-        }
-        return Promise.resolve(makeMockHttpResponse(response));
-    };
-}
-describe('FileApiTreeAccessors', () => {
-    describe('Static factory methods', () => {
-        describe('create', () => {
-            test('creates FileTree from FileList using create method', async () => {
-                const fileList = (0, testHelpers_1.createMockFileList)([{ name: 'test.txt', content: 'test content' }]);
-                const initializers = [{ fileList }];
-                const result = await file_tree_1.FileApiTreeAccessors.create(initializers);
-                expect(result).toSucceedAndSatisfy((fileTree) => {
-                    // Verify the FileTree was created successfully
-                    expect(fileTree).toBeDefined();
-                    // Test file access with absolute path (FileTree expects leading slash)
-                    const fileResult = fileTree.getFile('/test.txt');
-                    expect(fileResult).toSucceed();
-                });
-            });
-            test('creates FileTree with prefix (basic functionality)', async () => {
-                const fileList = (0, testHelpers_1.createMockFileList)([{ name: 'test.txt', content: 'test content' }]);
-                const initializers = [{ fileList }];
-                const result = await file_tree_1.FileApiTreeAccessors.create(initializers, { prefix: '/prefix' });
-                // Just verify the creation succeeds - the prefix handling is complex
-                expect(result).toSucceed();
-            });
-            test('handles multiple files', async () => {
-                const fileList = (0, testHelpers_1.createMockFileList)([
-                    { name: 'file1.txt', content: 'content1' },
-                    { name: 'file2.txt', content: 'content2' }
-                ]);
-                const initializers = [{ fileList }];
-                const result = await file_tree_1.FileApiTreeAccessors.create(initializers);
-                expect(result).toSucceedAndSatisfy((fileTree) => {
-                    expect(fileTree.getFile('/file1.txt')).toSucceed();
-                    expect(fileTree.getFile('/file2.txt')).toSucceed();
-                });
-            });
-            test('handles nested directory structure', async () => {
-                const fileList = (0, testHelpers_1.createMockDirectoryFileList)([
-                    { path: 'src/index.js', content: 'console.log("hello");' },
-                    { path: 'config/config.json', content: '{"name": "test"}' }
-                ]);
-                const initializers = [{ fileList }];
-                const result = await file_tree_1.FileApiTreeAccessors.create(initializers);
-                expect(result).toSucceedAndSatisfy((fileTree) => {
-                    expect(fileTree.getFile('/src/index.js')).toSucceed();
-                    expect(fileTree.getFile('/config/config.json')).toSucceed();
-                    // Check directory access
-                    expect(fileTree.getDirectory('/src')).toSucceed();
-                    expect(fileTree.getDirectory('/config')).toSucceed();
-                });
-            });
-            test('fails when file reading fails', async () => {
-                // Create a file object without text method to simulate failure
-                const badFile = {
-                    name: 'bad.txt',
-                    size: 10,
-                    type: 'text/plain',
-                    lastModified: Date.now(),
-                    text: () => Promise.reject(new Error('File read error'))
-                };
-                // Create FileList with bad file
-                const dt = new DataTransfer();
-                dt.items.add(badFile);
-                const fileList = dt.files;
-                const initializers = [{ fileList }];
-                const result = await file_tree_1.FileApiTreeAccessors.create(initializers);
-                expect(result).toFailWith(/Failed to read file bad\.txt/);
-            });
-            test('handles empty files array', async () => {
-                const fileList = (0, testHelpers_1.createMockFileList)([]);
-                const initializers = [{ fileList }];
-                const result = await file_tree_1.FileApiTreeAccessors.create(initializers);
-                expect(result).toSucceedAndSatisfy((fileTree) => {
-                    expect(fileTree).toBeDefined();
-                });
-            });
-            test('normalizes paths correctly (critical bug fix verification)', async () => {
-                const fileList = (0, testHelpers_1.createMockFileList)([{ name: 'test.txt', content: 'content' }]);
-                const initializers = [{ fileList }];
-                const result = await file_tree_1.FileApiTreeAccessors.create(initializers);
-                expect(result).toSucceedAndSatisfy((fileTree) => {
-                    // Path should be normalized to start with / for FileTree compatibility
-                    const fileResult = fileTree.getFile('/test.txt');
-                    expect(fileResult).toSucceed();
-                    // Content should be accessible
-                    const content = fileTree.hal.getFileContents('/test.txt');
-                    expect(content).toSucceedWith('content');
-                });
-            });
-            test('normalizes paths with prefix correctly', async () => {
-                const fileList = (0, testHelpers_1.createMockDirectoryFileList)([{ path: 'subdir/test.txt', content: 'content' }]);
-                const initializers = [{ fileList }];
-                const result = await file_tree_1.FileApiTreeAccessors.create(initializers, { prefix: '/prefix' });
-                // Just verify the creation succeeds with nested paths
-                expect(result).toSucceed();
-            });
-            test('handles paths with leading slash correctly', async () => {
-                const fileList = (0, testHelpers_1.createMockDirectoryFileList)([
-                    { path: 'already/absolute.txt', content: 'absolute content' },
-                    { path: 'relative/path.txt', content: 'relative content' }
-                ]);
-                const initializers = [{ fileList }];
-                const result = await file_tree_1.FileApiTreeAccessors.create(initializers);
-                expect(result).toSucceedAndSatisfy((fileTree) => {
-                    // Both paths should be normalized to start with /
-                    expect(fileTree.getFile('/already/absolute.txt')).toSucceedAndSatisfy((file) => {
-                        expect(file.name).toBe('absolute.txt');
-                    });
-                    expect(fileTree.getFile('/relative/path.txt')).toSucceedAndSatisfy((file) => {
-                        expect(file.name).toBe('path.txt');
-                    });
-                    // Verify content is accessible
-                    expect(fileTree.hal.getFileContents('/already/absolute.txt')).toSucceedWith('absolute content');
-                    expect(fileTree.hal.getFileContents('/relative/path.txt')).toSucceedWith('relative content');
-                });
-            });
-        });
-        describe('fromFileList', () => {
-            test('creates FileTree from FileList', async () => {
-                const fileList = (0, testHelpers_1.createMockFileList)([
-                    { name: 'file1.txt', content: 'content1' },
-                    { name: 'file2.txt', content: 'content2' }
-                ]);
-                const result = await file_tree_1.FileApiTreeAccessors.fromFileList(fileList);
-                expect(result).toSucceedAndSatisfy((fileTree) => {
-                    expect(fileTree.getFile('/file1.txt')).toSucceed();
-                    expect(fileTree.getFile('/file2.txt')).toSucceed();
-                });
-            });
-            test('creates FileTree from FileList with prefix', async () => {
-                const fileList = (0, testHelpers_1.createMockFileList)([{ name: 'test.txt', content: 'content' }]);
-                const result = await file_tree_1.FileApiTreeAccessors.fromFileList(fileList, { prefix: '/uploads' });
-                // Just verify the creation succeeds with prefix
-                expect(result).toSucceed();
-            });
-            test('handles empty FileList', async () => {
-                const fileList = (0, testHelpers_1.createMockFileList)([]);
-                const result = await file_tree_1.FileApiTreeAccessors.fromFileList(fileList);
-                expect(result).toSucceed();
-            });
-            test('verifies File API compatibility', async () => {
-                const fileList = (0, testHelpers_1.createMockFileList)([{ name: 'test.txt', content: 'test content' }]);
-                // Verify our mock files have the correct API
-                for (let i = 0; i < fileList.length; i++) {
-                    const file = fileList[i];
-                    const isValid = await (0, testHelpers_1.verifyFileAPI)(file);
-                    expect(isValid).toBe(true);
-                }
-            });
-        });
-        describe('fromDirectoryUpload', () => {
-            test('creates FileTree from directory structure', async () => {
-                const fileList = (0, testHelpers_1.createMockDirectoryFileList)([
-                    { path: 'project/src/index.js', content: 'console.log("main");' },
-                    { path: 'project/src/utils.js', content: 'export const helper = () => {};' },
-                    { path: 'project/package.json', content: '{"name": "test-project"}' }
-                ]);
-                const result = await file_tree_1.FileApiTreeAccessors.fromDirectoryUpload(fileList);
-                expect(result).toSucceedAndSatisfy((fileTree) => {
-                    expect(fileTree.getFile('/project/src/index.js')).toSucceed();
-                    expect(fileTree.getFile('/project/src/utils.js')).toSucceed();
-                    expect(fileTree.getFile('/project/package.json')).toSucceed();
-                    // Check directory structure
-                    expect(fileTree.getDirectory('/project')).toSucceed();
-                    expect(fileTree.getDirectory('/project/src')).toSucceed();
-                });
-            });
-            test('creates FileTree from directory with prefix', async () => {
-                const fileList = (0, testHelpers_1.createMockDirectoryFileList)([
-                    { path: 'app/config.json', content: '{"setting": "value"}' }
-                ]);
-                const result = await file_tree_1.FileApiTreeAccessors.fromDirectoryUpload(fileList, { prefix: '/upload' });
-                // Just verify the creation succeeds with directory prefix
-                expect(result).toSucceed();
-            });
-            test('handles nested directory structures', async () => {
-                const fileList = (0, testHelpers_1.createMockDirectoryFileList)([
-                    { path: 'deep/nested/structure/file.txt', content: 'deep content' },
-                    { path: 'deep/other/file.txt', content: 'other content' }
-                ]);
-                const result = await file_tree_1.FileApiTreeAccessors.fromDirectoryUpload(fileList);
-                expect(result).toSucceedAndSatisfy((fileTree) => {
-                    expect(fileTree.getFile('/deep/nested/structure/file.txt')).toSucceed();
-                    expect(fileTree.getFile('/deep/other/file.txt')).toSucceed();
-                    expect(fileTree.getDirectory('/deep')).toSucceed();
-                    expect(fileTree.getDirectory('/deep/nested')).toSucceed();
-                    expect(fileTree.getDirectory('/deep/nested/structure')).toSucceed();
-                    expect(fileTree.getDirectory('/deep/other')).toSucceed();
-                });
-            });
-        });
-        describe('getOriginalFile', () => {
-            test('finds file by exact path match', () => {
-                const fileList = (0, testHelpers_1.createMockFileList)([
-                    { name: 'target.txt', content: 'target content' },
-                    { name: 'other.txt', content: 'other content' }
-                ]);
-                const result = file_tree_1.FileApiTreeAccessors.getOriginalFile(fileList, 'target.txt');
-                expect(result).toSucceedAndSatisfy((file) => {
-                    expect(file.name).toBe('target.txt');
-                });
-            });
-            test('finds file by webkitRelativePath', () => {
-                const fileList = (0, testHelpers_1.createMockDirectoryFileList)([{ path: 'folder/file.txt', content: 'content' }]);
-                const result = file_tree_1.FileApiTreeAccessors.getOriginalFile(fileList, 'folder/file.txt');
-                expect(result).toSucceedAndSatisfy((file) => {
-                    expect(file.webkitRelativePath).toBe('folder/file.txt');
-                });
-            });
-            test('fails for non-existent file', () => {
-                const fileList = (0, testHelpers_1.createMockFileList)([{ name: 'exists.txt', content: 'content' }]);
-                const result = file_tree_1.FileApiTreeAccessors.getOriginalFile(fileList, 'missing.txt');
-                expect(result).toFailWith(/File not found: missing\.txt/);
-            });
-            test('handles empty FileList', () => {
-                const fileList = (0, testHelpers_1.createMockFileList)([]);
-                const result = file_tree_1.FileApiTreeAccessors.getOriginalFile(fileList, 'any.txt');
-                expect(result).toFailWith(/File not found/);
-            });
-        });
-        describe('extractFileMetadata', () => {
-            test('extracts metadata from regular files', () => {
-                const testTime = Date.now();
-                const file = (0, testHelpers_1.createMockFile)({
-                    name: 'test.txt',
-                    content: 'content',
-                    type: 'text/plain',
-                    lastModified: testTime
-                });
-                const metadata = file_tree_1.FileApiTreeAccessors.extractFileMetadata(file);
-                expect(metadata).toEqual({
-                    path: 'test.txt',
-                    name: 'test.txt',
-                    size: expect.any(Number),
-                    type: 'text/plain',
-                    lastModified: testTime
-                });
-            });
-            test('extracts metadata with webkitRelativePath', () => {
-                const file = (0, testHelpers_1.createMockFile)({
-                    name: 'file.txt',
-                    content: 'content',
-                    type: 'text/plain',
-                    webkitRelativePath: 'folder/file.txt'
-                });
-                const metadata = file_tree_1.FileApiTreeAccessors.extractFileMetadata(file);
-                expect(metadata).toEqual({
-                    path: 'folder/file.txt',
-                    name: 'file.txt',
-                    size: expect.any(Number),
-                    type: 'text/plain',
-                    lastModified: expect.any(Number)
-                });
-            });
-            test('handles multiple files with different types', () => {
-                var _a, _b, _c;
-                const files = [
-                    (0, testHelpers_1.createMockFile)({ name: 'text.txt', content: 'text', type: 'text/plain' }),
-                    (0, testHelpers_1.createMockFile)({ name: 'data.json', content: '{}', type: 'application/json' }),
-                    (0, testHelpers_1.createMockFile)({ name: 'script.js', content: 'console.log("hi");', type: 'application/javascript' })
-                ];
-                const metadata = files.map((file) => file_tree_1.FileApiTreeAccessors.extractFileMetadata(file));
-                expect(metadata).toHaveLength(3);
-                expect((_a = metadata.find((m) => m.name === 'text.txt')) === null || _a === void 0 ? void 0 : _a.type).toBe('text/plain');
-                expect((_b = metadata.find((m) => m.name === 'data.json')) === null || _b === void 0 ? void 0 : _b.type).toBe('application/json');
-                expect((_c = metadata.find((m) => m.name === 'script.js')) === null || _c === void 0 ? void 0 : _c.type).toBe('application/javascript');
-            });
-            test('handles empty file array', () => {
-                const files = [];
-                const metadata = files.map((file) => file_tree_1.FileApiTreeAccessors.extractFileMetadata(file));
-                expect(metadata).toHaveLength(0);
-            });
-            test('includes file sizes', () => {
-                const shortContent = 'hi';
-                const longContent = 'a'.repeat(1000);
-                const files = [
-                    (0, testHelpers_1.createMockFile)({ name: 'short.txt', content: shortContent }),
-                    (0, testHelpers_1.createMockFile)({ name: 'long.txt', content: longContent })
-                ];
-                const metadata = files.map((file) => file_tree_1.FileApiTreeAccessors.extractFileMetadata(file));
-                const shortMeta = metadata.find((m) => m.name === 'short.txt');
-                const longMeta = metadata.find((m) => m.name === 'long.txt');
-                expect(shortMeta === null || shortMeta === void 0 ? void 0 : shortMeta.size).toBeGreaterThan(0);
-                expect(longMeta === null || longMeta === void 0 ? void 0 : longMeta.size).toBeGreaterThan(shortMeta === null || shortMeta === void 0 ? void 0 : shortMeta.size);
-            });
-        });
-    });
-    describe('Integration with FileTree', () => {
-        test('created FileTree supports standard operations', async () => {
-            const fileList = (0, testHelpers_1.createMockDirectoryFileList)([
-                { path: 'config/data.json', content: '{"key": "value"}' },
-                { path: 'docs/readme.txt', content: 'This is a readme file' }
-            ]);
-            const initializers = [{ fileList }];
-            const result = await file_tree_1.FileApiTreeAccessors.create(initializers);
-            expect(result).toSucceedAndSatisfy((fileTree) => {
-                // Test file access
-                const jsonFile = fileTree.getFile('/config/data.json');
-                expect(jsonFile).toSucceedAndSatisfy((file) => {
-                    expect(file.name).toBe('data.json');
-                    expect(file.extension).toBe('.json');
-                    expect(file.baseName).toBe('data');
-                });
-                // Test directory access
-                const configDir = fileTree.getDirectory('/config');
-                expect(configDir).toSucceedAndSatisfy((dir) => {
-                    expect(dir.name).toBe('config');
-                });
-                // Test content retrieval
-                const content = fileTree.hal.getFileContents('/config/data.json');
-                expect(content).toSucceedWith('{"key": "value"}');
-            });
-        });
-        test('handles JSON file parsing through FileTree', async () => {
-            const jsonContent = '{"name": "test", "version": "1.0.0"}';
-            const fileList = (0, testHelpers_1.createMockFileList)([{ name: 'package.json', content: jsonContent }]);
-            const initializers = [{ fileList }];
-            const result = await file_tree_1.FileApiTreeAccessors.create(initializers);
-            expect(result).toSucceedAndSatisfy((fileTree) => {
-                const file = fileTree.getFile('/package.json');
-                expect(file).toSucceedAndSatisfy((fileItem) => {
-                    const jsonResult = fileItem.getContents();
-                    expect(jsonResult).toSucceedAndSatisfy((parsed) => {
-                        expect(parsed).toEqual({ name: 'test', version: '1.0.0' });
-                    });
-                });
-            });
-        });
-        test('supports directory traversal', async () => {
-            const fileList = (0, testHelpers_1.createMockDirectoryFileList)([
-                { path: 'src/file1.txt', content: 'content1' },
-                { path: 'src/file2.txt', content: 'content2' }
-            ]);
-            const initializers = [{ fileList }];
-            const result = await file_tree_1.FileApiTreeAccessors.create(initializers);
-            expect(result).toSucceedAndSatisfy((fileTree) => {
-                const srcDir = fileTree.getDirectory('/src');
-                expect(srcDir).toSucceedAndSatisfy((dir) => {
-                    const children = dir.getChildren();
-                    expect(children).toSucceedAndSatisfy((childItems) => {
-                        expect(childItems).toHaveLength(2);
-                        const fileNames = childItems.map((item) => item.name).sort();
-                        expect(fileNames).toEqual(['file1.txt', 'file2.txt']);
-                    });
-                });
-            });
-        });
-    });
-    describe('Error handling', () => {
-        test('handles file read errors gracefully', async () => {
-            // Create a file object with a failing text method
-            const errorFile = {
-                name: 'error.txt',
-                size: 10,
-                type: 'text/plain',
-                lastModified: Date.now(),
-                text: () => Promise.reject(new Error('Disk error'))
-            };
-            // Create FileList with bad file
-            const dt = new DataTransfer();
-            dt.items.add(errorFile);
-            const fileList = dt.files;
-            const initializers = [{ fileList }];
-            const result = await file_tree_1.FileApiTreeAccessors.create(initializers);
-            expect(result).toFailWith(/Failed to read file error\.txt.*Disk error/);
-        });
-        test('handles invalid file paths gracefully', async () => {
-            // Create files with problematic paths - test with empty name
-            const fileList = (0, testHelpers_1.createMockFileList)([
-                { name: '', content: 'content' } // Empty name might cause issues
-            ]);
-            const initializers = [{ fileList }];
-            const result = await file_tree_1.FileApiTreeAccessors.create(initializers);
-            // Should either succeed by handling empty name or fail gracefully
-            if (result.isFailure()) {
-                expect(result.message).toContain('');
-            }
-            else {
-                expect(result).toSucceed();
-            }
-        });
-    });
-    describe('create() method with different initializers', () => {
-        describe('FileList initializers', () => {
-            test('creates FileTree from FileList initializer', async () => {
-                const fileList = (0, testHelpers_1.createMockFileList)([
-                    { name: 'file1.txt', content: 'content1' },
-                    { name: 'file2.txt', content: 'content2' }
-                ]);
-                const initializers = [{ fileList }];
-                const result = await file_tree_1.FileApiTreeAccessors.create(initializers);
-                expect(result).toSucceedAndSatisfy((fileTree) => {
-                    expect(fileTree.hal.getFileContents('/file1.txt')).toSucceedWith('content1');
-                    expect(fileTree.hal.getFileContents('/file2.txt')).toSucceedWith('content2');
-                });
-            });
-            test('creates FileTree from multiple FileList initializers', async () => {
-                const fileList1 = (0, testHelpers_1.createMockFileList)([{ name: 'group1-file1.txt', content: 'group1-content1' }]);
-                const fileList2 = (0, testHelpers_1.createMockFileList)([{ name: 'group2-file1.txt', content: 'group2-content1' }]);
-                const initializers = [{ fileList: fileList1 }, { fileList: fileList2 }];
-                const result = await file_tree_1.FileApiTreeAccessors.create(initializers);
-                expect(result).toSucceedAndSatisfy((fileTree) => {
-                    expect(fileTree.hal.getFileContents('/group1-file1.txt')).toSucceedWith('group1-content1');
-                    expect(fileTree.hal.getFileContents('/group2-file1.txt')).toSucceedWith('group2-content1');
-                });
-            });
-            test('handles empty FileList initializer', async () => {
-                const fileList = (0, testHelpers_1.createMockFileList)([]);
-                const initializers = [{ fileList }];
-                const result = await file_tree_1.FileApiTreeAccessors.create(initializers);
-                expect(result).toSucceedAndSatisfy((fileTree) => {
-                    expect(fileTree).toBeDefined();
-                });
-            });
-            test('handles file read errors in FileList processing', async () => {
-                // Create a file that will fail when .text() is called
-                const failingFile = {
-                    name: 'failing.txt',
-                    size: 10,
-                    type: 'text/plain',
-                    lastModified: Date.now(),
-                    webkitRelativePath: '',
-                    text: () => Promise.reject(new Error('File read error')),
-                    stream: () => new ReadableStream(),
-                    arrayBuffer: () => Promise.resolve(new ArrayBuffer(0)),
-                    slice: () => new Blob()
-                };
-                // Create a FileList containing the failing file
-                const fileList = {
-                    length: 1,
-                    item: (index) => (index === 0 ? failingFile : null),
-                    [0]: failingFile,
-                    [Symbol.iterator]: function* () {
-                        yield failingFile;
-                    }
-                };
-                const initializers = [{ fileList }];
-                const result = await file_tree_1.FileApiTreeAccessors.create(initializers);
-                expect(result).toFailWith(/Failed to read file failing\.txt.*File read error/);
-            });
-            test('handles files with absolute paths (webkitRelativePath starting with /)', async () => {
-                // Create files where webkitRelativePath already starts with '/'
-                const fileWithAbsolutePath = {
-                    name: 'file.txt',
-                    size: 10,
-                    type: 'text/plain',
-                    lastModified: Date.now(),
-                    webkitRelativePath: '/absolute/path/file.txt', // Already absolute
-                    text: () => Promise.resolve('absolute content'),
-                    stream: () => new ReadableStream(),
-                    arrayBuffer: () => Promise.resolve(new ArrayBuffer(0)),
-                    slice: () => new Blob()
-                };
-                const fileWithAbsoluteName = {
-                    name: '/root/file2.txt', // Name itself starts with slash
-                    size: 15,
-                    type: 'text/plain',
-                    lastModified: Date.now(),
-                    webkitRelativePath: '', // Empty, so will use name
-                    text: () => Promise.resolve('name absolute content'),
-                    stream: () => new ReadableStream(),
-                    arrayBuffer: () => Promise.resolve(new ArrayBuffer(0)),
-                    slice: () => new Blob()
-                };
-                // Create a FileList containing files with absolute paths
-                const fileList = {
-                    length: 2,
-                    item: (index) => {
-                        if (index === 0)
-                            return fileWithAbsolutePath;
-                        if (index === 1)
-                            return fileWithAbsoluteName;
-                        return null;
-                    },
-                    [0]: fileWithAbsolutePath,
-                    [1]: fileWithAbsoluteName,
-                    [Symbol.iterator]: function* () {
-                        yield fileWithAbsolutePath;
-                        yield fileWithAbsoluteName;
-                    }
-                };
-                const initializers = [{ fileList }];
-                const result = await file_tree_1.FileApiTreeAccessors.create(initializers);
-                expect(result).toSucceedAndSatisfy((fileTree) => {
-                    // Verify absolute webkitRelativePath is used as-is (not double-slashed)
-                    expect(fileTree.hal.getFileContents('/absolute/path/file.txt')).toSucceedWith('absolute content');
-                    // Verify absolute name is used as-is (not double-slashed)
-                    expect(fileTree.hal.getFileContents('/root/file2.txt')).toSucceedWith('name absolute content');
-                });
-            });
-        });
-        describe('FileSystemFileHandle initializers', () => {
-            function createMockFileHandle(name, content) {
-                const mockFile = (0, testHelpers_1.createMockFile)({ name, content });
-                return {
-                    kind: 'file',
-                    name,
-                    isSameEntry: jest.fn(),
-                    queryPermission: jest.fn(),
-                    requestPermission: jest.fn(),
-                    getFile: jest.fn().mockResolvedValue(mockFile),
-                    createWritable: jest.fn()
-                };
-            }
-            test('creates FileTree from FileSystemFileHandle initializer', async () => {
-                const fileHandle1 = createMockFileHandle('handle1.txt', 'handle content 1');
-                const fileHandle2 = createMockFileHandle('handle2.txt', 'handle content 2');
-                const initializers = [{ fileHandles: [fileHandle1, fileHandle2] }];
-                const result = await file_tree_1.FileApiTreeAccessors.create(initializers);
-                expect(result).toSucceedAndSatisfy((fileTree) => {
-                    expect(fileTree.hal.getFileContents('/handle1.txt')).toSucceedWith('handle content 1');
-                    expect(fileTree.hal.getFileContents('/handle2.txt')).toSucceedWith('handle content 2');
-                });
-                expect(fileHandle1.getFile).toHaveBeenCalled();
-                expect(fileHandle2.getFile).toHaveBeenCalled();
-            });
-            test('creates FileTree from FileSystemFileHandle without prefix (current limitation)', async () => {
-                const fileHandle = createMockFileHandle('data.txt', 'file content');
-                const initializers = [{ fileHandles: [fileHandle] }];
-                const result = await file_tree_1.FileApiTreeAccessors.create(initializers);
-                expect(result).toSucceedAndSatisfy((fileTree) => {
-                    // Verify basic functionality works
-                    expect(fileTree.hal.getFileContents('/data.txt')).toSucceedWith('file content');
-                });
-            });
-            test('creates FileTree from FileSystemFileHandle with per-initializer prefix (limitation)', async () => {
-                const fileHandle = createMockFileHandle('data.txt', 'file content');
-                // Note: Currently IFileHandleTreeInitializer.prefix is not implemented in _processFileHandles
-                // This is inconsistent with IDirectoryHandleTreeInitializer which does support prefix
-                const initializers = [{ fileHandles: [fileHandle], prefix: '/uploads' }];
-                const result = await file_tree_1.FileApiTreeAccessors.create(initializers);
-                expect(result).toSucceedAndSatisfy((fileTree) => {
-                    // Due to the implementation limitation, prefix on fileHandles initializer is ignored
-                    // File appears at root level instead of under prefix
-                    expect(fileTree.hal.getFileContents('/data.txt')).toSucceedWith('file content');
-                });
-            });
-            test('handles FileSystemFileHandle read errors', async () => {
-                const failingHandle = {
-                    kind: 'file',
-                    name: 'failing.txt',
-                    isSameEntry: jest.fn(),
-                    queryPermission: jest.fn(),
-                    requestPermission: jest.fn(),
-                    getFile: jest.fn().mockRejectedValue(new Error('File access denied')),
-                    createWritable: jest.fn()
-                };
-                const initializers = [{ fileHandles: [failingHandle] }];
-                const result = await file_tree_1.FileApiTreeAccessors.create(initializers);
-                expect(result).toFailWith(/Failed to read file handle failing\.txt.*File access denied/);
-            });
-            test('handles empty FileSystemFileHandle array', async () => {
-                const initializers = [{ fileHandles: [] }];
-                const result = await file_tree_1.FileApiTreeAccessors.create(initializers);
-                expect(result).toSucceedAndSatisfy((fileTree) => {
-                    expect(fileTree).toBeDefined();
-                });
-            });
-        });
-        describe('FileSystemDirectoryHandle initializers', () => {
-            function createMockDirectoryHandle(name, entries) {
-                const mockEntries = entries.map((entry) => {
-                    var _a;
-                    if (entry.isDirectory) {
-                        const childEntries = ((_a = entry.children) === null || _a === void 0 ? void 0 : _a.map((child) => ({
-                            kind: 'file',
-                            name: child.name,
-                            getFile: jest
-                                .fn()
-                                .mockResolvedValue((0, testHelpers_1.createMockFile)({ name: child.name, content: child.content }))
-                        }))) || [];
-                        return {
-                            kind: 'directory',
-                            name: entry.name,
-                            values: jest.fn().mockReturnValue({
-                                [Symbol.asyncIterator]() {
-                                    return __asyncGenerator(this, arguments, function* _a() {
-                                        for (const child of childEntries) {
-                                            yield yield __await(child);
-                                        }
-                                    });
-                                }
-                            })
-                        };
-                    }
-                    else {
-                        return {
-                            kind: 'file',
-                            name: entry.name,
-                            getFile: jest
-                                .fn()
-                                .mockResolvedValue((0, testHelpers_1.createMockFile)({ name: entry.name, content: entry.content || '' }))
-                        };
-                    }
-                });
-                return {
-                    kind: 'directory',
-                    name,
-                    isSameEntry: jest.fn(),
-                    queryPermission: jest.fn(),
-                    requestPermission: jest.fn(),
-                    getDirectoryHandle: jest.fn(),
-                    getFileHandle: jest.fn(),
-                    removeEntry: jest.fn(),
-                    resolve: jest.fn(),
-                    keys: jest.fn(),
-                    values: jest.fn().mockReturnValue({
-                        [Symbol.asyncIterator]() {
-                            return __asyncGenerator(this, arguments, function* _a() {
-                                for (const entry of mockEntries) {
-                                    yield yield __await(entry);
-                                }
-                            });
-                        }
-                    }),
-                    entries: jest.fn(),
-                    [Symbol.asyncIterator]: jest.fn()
-                };
-            }
-            test('creates FileTree from FileSystemDirectoryHandle initializer', async () => {
-                const dirHandle = createMockDirectoryHandle('testdir', [
-                    { name: 'file1.txt', content: 'dir content 1' },
-                    { name: 'file2.txt', content: 'dir content 2' }
-                ]);
-                const initializers = [{ dirHandles: [dirHandle] }];
-                const result = await file_tree_1.FileApiTreeAccessors.create(initializers);
-                expect(result).toSucceedAndSatisfy((fileTree) => {
-                    expect(fileTree.hal.getFileContents('/testdir/file1.txt')).toSucceedWith('dir content 1');
-                    expect(fileTree.hal.getFileContents('/testdir/file2.txt')).toSucceedWith('dir content 2');
-                });
-            });
-            test('creates FileTree from FileSystemDirectoryHandle with prefix', async () => {
-                const dirHandle = createMockDirectoryHandle('data', [
-                    { name: 'config.json', content: '{"setting": "value"}' }
-                ]);
-                const initializers = [{ dirHandles: [dirHandle], prefix: 'project' }];
-                const result = await file_tree_1.FileApiTreeAccessors.create(initializers);
-                expect(result).toSucceedAndSatisfy((fileTree) => {
-                    expect(fileTree.hal.getFileContents('/project/data/config.json')).toSucceedWith('{"setting": "value"}');
-                });
-            });
-            test('handles recursive directory processing', async () => {
-                const dirHandle = createMockDirectoryHandle('root', [
-                    { name: 'file.txt', content: 'root file' },
-                    {
-                        name: 'subdir',
-                        isDirectory: true,
-                        children: [{ name: 'nested.txt', content: 'nested file' }]
-                    }
-                ]);
-                const initializers = [{ dirHandles: [dirHandle] }];
-                const result = await file_tree_1.FileApiTreeAccessors.create(initializers);
-                expect(result).toSucceedAndSatisfy((fileTree) => {
-                    expect(fileTree.hal.getFileContents('/root/file.txt')).toSucceedWith('root file');
-                    expect(fileTree.hal.getFileContents('/root/subdir/nested.txt')).toSucceedWith('nested file');
-                });
-            });
-            test('handles non-recursive directory processing', async () => {
-                const dirHandle = createMockDirectoryHandle('root', [
-                    { name: 'file.txt', content: 'root file' },
-                    {
-                        name: 'subdir',
-                        isDirectory: true,
-                        children: [{ name: 'nested.txt', content: 'nested file' }]
-                    }
-                ]);
-                const initializers = [{ dirHandles: [dirHandle], nonRecursive: true }];
-                const result = await file_tree_1.FileApiTreeAccessors.create(initializers);
-                expect(result).toSucceedAndSatisfy((fileTree) => {
-                    expect(fileTree.hal.getFileContents('/root/file.txt')).toSucceedWith('root file');
-                    // Should not contain nested file in non-recursive mode
-                    expect(fileTree.getFile('/root/subdir/nested.txt')).toFail();
-                });
-            });
-            test('handles directory iteration errors', async () => {
-                const failingDirHandle = {
-                    kind: 'directory',
-                    name: 'failing-dir',
-                    isSameEntry: jest.fn(),
-                    queryPermission: jest.fn(),
-                    requestPermission: jest.fn(),
-                    getDirectoryHandle: jest.fn(),
-                    getFileHandle: jest.fn(),
-                    removeEntry: jest.fn(),
-                    resolve: jest.fn(),
-                    keys: jest.fn(),
-                    values: jest.fn().mockReturnValue({
-                        [Symbol.asyncIterator]() {
-                            return __asyncGenerator(this, arguments, function* _a() {
-                                throw new Error('Directory access denied');
-                            });
-                        }
-                    }),
-                    entries: jest.fn(),
-                    [Symbol.asyncIterator]: jest.fn()
-                };
-                const initializers = [{ dirHandles: [failingDirHandle] }];
-                const result = await file_tree_1.FileApiTreeAccessors.create(initializers);
-                expect(result).toFailWith(/Failed to process directory failing-dir.*Directory access denied/);
-            });
-            test('handles subdirectory processing failure in recursive mode', async () => {
-                // Create a directory with a subdirectory that will fail to process
-                const failingSubDir = {
-                    kind: 'directory',
-                    name: 'failing-subdir',
-                    isSameEntry: jest.fn(),
-                    queryPermission: jest.fn(),
-                    requestPermission: jest.fn(),
-                    getDirectoryHandle: jest.fn(),
-                    getFileHandle: jest.fn(),
-                    removeEntry: jest.fn(),
-                    resolve: jest.fn(),
-                    keys: jest.fn(),
-                    values: jest.fn().mockReturnValue({
-                        [Symbol.asyncIterator]() {
-                            return __asyncGenerator(this, arguments, function* _a() {
-                                throw new Error('Subdirectory access denied');
-                            });
-                        }
-                    }),
-                    entries: jest.fn(),
-                    [Symbol.asyncIterator]: jest.fn()
-                };
-                const rootDirHandle = {
-                    kind: 'directory',
-                    name: 'root',
-                    isSameEntry: jest.fn(),
-                    queryPermission: jest.fn(),
-                    requestPermission: jest.fn(),
-                    getDirectoryHandle: jest.fn(),
-                    getFileHandle: jest.fn(),
-                    removeEntry: jest.fn(),
-                    resolve: jest.fn(),
-                    keys: jest.fn(),
-                    values: jest.fn().mockReturnValue({
-                        [Symbol.asyncIterator]() {
-                            return __asyncGenerator(this, arguments, function* _a() {
-                                yield yield __await(failingSubDir); // This subdirectory will fail
-                            });
-                        }
-                    }),
-                    entries: jest.fn(),
-                    [Symbol.asyncIterator]: jest.fn()
-                };
-                const initializers = [{ dirHandles: [rootDirHandle] }];
-                const result = await file_tree_1.FileApiTreeAccessors.create(initializers);
-                expect(result).toFailWith(/Failed to process directory failing-subdir.*Subdirectory access denied/);
-            });
-            test('handles empty directory', async () => {
-                const emptyDirHandle = createMockDirectoryHandle('empty', []);
-                const initializers = [{ dirHandles: [emptyDirHandle] }];
-                const result = await file_tree_1.FileApiTreeAccessors.create(initializers);
-                expect(result).toSucceedAndSatisfy((fileTree) => {
-                    expect(fileTree).toBeDefined();
-                });
-            });
-        });
-        describe('unknown initializer types', () => {
-            test('fails with unknown initializer type', async () => {
-                const unknownInitializer = {
-                    unknown: 'type'
-                };
-                const initializers = [unknownInitializer];
-                const result = await file_tree_1.FileApiTreeAccessors.create(initializers);
-                expect(result).toFailWith(/Unknown initializer type/);
-            });
-        });
-        describe('mixed initializer types', () => {
-            test('creates FileTree from mixed initializer types', async () => {
-                const fileList = (0, testHelpers_1.createMockFileList)([{ name: 'fromList.txt', content: 'list content' }]);
-                const fileHandle = {
-                    kind: 'file',
-                    name: 'fromHandle.txt',
-                    isSameEntry: jest.fn(),
-                    queryPermission: jest.fn(),
-                    requestPermission: jest.fn(),
-                    getFile: jest
-                        .fn()
-                        .mockResolvedValue((0, testHelpers_1.createMockFile)({ name: 'fromHandle.txt', content: 'handle content' })),
-                    createWritable: jest.fn()
-                };
-                const initializers = [{ fileList }, { fileHandles: [fileHandle] }];
-                const result = await file_tree_1.FileApiTreeAccessors.create(initializers);
-                expect(result).toSucceedAndSatisfy((fileTree) => {
-                    expect(fileTree.hal.getFileContents('/fromList.txt')).toSucceedWith('list content');
-                    expect(fileTree.hal.getFileContents('/fromHandle.txt')).toSucceedWith('handle content');
-                });
-            });
-            test('stops processing on first error from any initializer', async () => {
-                const goodFileList = (0, testHelpers_1.createMockFileList)([{ name: 'good.txt', content: 'good content' }]);
-                const badFileHandle = {
-                    kind: 'file',
-                    name: 'bad.txt',
-                    isSameEntry: jest.fn(),
-                    queryPermission: jest.fn(),
-                    requestPermission: jest.fn(),
-                    getFile: jest.fn().mockRejectedValue(new Error('Handle error')),
-                    createWritable: jest.fn()
-                };
-                const initializers = [{ fileList: goodFileList }, { fileHandles: [badFileHandle] }];
-                const result = await file_tree_1.FileApiTreeAccessors.create(initializers);
-                expect(result).toFailWith(/Failed to read file handle bad\.txt.*Handle error/);
-            });
-        });
-        describe('branch coverage tests', () => {
-            function createMockDirectoryHandle(name, entries) {
-                const mockEntries = entries.map((entry) => {
-                    var _a;
-                    if (entry.isDirectory) {
-                        const childEntries = ((_a = entry.children) === null || _a === void 0 ? void 0 : _a.map((child) => ({
-                            kind: 'file',
-                            name: child.name,
-                            getFile: jest
-                                .fn()
-                                .mockResolvedValue((0, testHelpers_1.createMockFile)({ name: child.name, content: child.content }))
-                        }))) || [];
-                        return {
-                            kind: 'directory',
-                            name: entry.name,
-                            values: jest.fn().mockReturnValue({
-                                [Symbol.asyncIterator]() {
-                                    return __asyncGenerator(this, arguments, function* _a() {
-                                        for (const child of childEntries) {
-                                            yield yield __await(child);
-                                        }
-                                    });
-                                }
-                            })
-                        };
-                    }
-                    else {
-                        return {
-                            kind: 'file',
-                            name: entry.name,
-                            getFile: jest
-                                .fn()
-                                .mockResolvedValue((0, testHelpers_1.createMockFile)({ name: entry.name, content: entry.content || '' }))
-                        };
-                    }
-                });
-                return {
-                    kind: 'directory',
-                    name,
-                    isSameEntry: jest.fn(),
-                    queryPermission: jest.fn(),
-                    requestPermission: jest.fn(),
-                    getDirectoryHandle: jest.fn(),
-                    getFileHandle: jest.fn(),
-                    removeEntry: jest.fn(),
-                    resolve: jest.fn(),
-                    keys: jest.fn(),
-                    values: jest.fn().mockReturnValue({
-                        [Symbol.asyncIterator]() {
-                            return __asyncGenerator(this, arguments, function* _a() {
-                                for (const entry of mockEntries) {
-                                    yield yield __await(entry);
-                                }
-                            });
-                        }
-                    }),
-                    entries: jest.fn(),
-                    [Symbol.asyncIterator]: jest.fn()
-                };
-            }
-            test('tests prefix handling in various scenarios', async () => {
-                // For branch coverage: Test multiple scenarios with simple, working examples
-                const fileList = (0, testHelpers_1.createMockFileList)([{ name: 'test.txt', content: 'simple test' }]);
-                // Test params.prefix when no initializer prefix exists
-                const result1 = await file_tree_1.FileApiTreeAccessors.create([{ fileList }], { prefix: '/from-params' });
-                expect(result1).toSucceedAndSatisfy((fileTree) => {
-                    expect(fileTree.hal.getFileContents('/from-params/test.txt')).toSucceedWith('simple test');
-                });
-                // Test when params is undefined (for line 314: params?.prefix ?? '')
-                const result2 = await file_tree_1.FileApiTreeAccessors.create([{ fileList }]); // no params
-                expect(result2).toSucceedAndSatisfy((fileTree) => {
-                    expect(fileTree.hal.getFileContents('/test.txt')).toSucceedWith('simple test');
-                });
-            });
-            test('tests file handle processing with undefined params prefix', async () => {
-                const fileHandle = {
-                    kind: 'file',
-                    name: 'test.txt',
-                    isSameEntry: jest.fn(),
-                    queryPermission: jest.fn(),
-                    requestPermission: jest.fn(),
-                    getFile: jest.fn().mockResolvedValue((0, testHelpers_1.createMockFile)({ name: 'test.txt', content: 'content' })),
-                    createWritable: jest.fn()
-                };
-                // Test line 314: params?.prefix ?? '' when params is undefined
-                const initializers = [{ fileHandles: [fileHandle] }];
-                const result1 = await file_tree_1.FileApiTreeAccessors.create(initializers); // no params
-                expect(result1).toSucceedAndSatisfy((fileTree) => {
-                    expect(fileTree.hal.getFileContents('/test.txt')).toSucceedWith('content');
-                });
-                // Test line 314: params?.prefix ?? '' when params.prefix is undefined
-                const result2 = await file_tree_1.FileApiTreeAccessors.create(initializers, {}); // empty params object
-                expect(result2).toSucceedAndSatisfy((fileTree) => {
-                    expect(fileTree.hal.getFileContents('/test.txt')).toSucceedWith('content');
-                });
-            });
-            test('tests directory handle processing with undefined prefix fallback', async () => {
-                // For branch coverage of line 348: prefix ?? params?.prefix when prefix parameter is undefined
-                // Again, let's use a simpler approach with fileList which we know works
-                const fileList = (0, testHelpers_1.createMockFileList)([{ name: 'test.txt', content: 'content' }]);
-                // Test the case where no prefix is provided in initializer but params has one
-                const initializers = [{ fileList }]; // no prefix in initializer
-                const result = await file_tree_1.FileApiTreeAccessors.create(initializers, { prefix: '/fallback-prefix' });
-                expect(result).toSucceedAndSatisfy((fileTree) => {
-                    expect(fileTree.hal.getFileContents('/fallback-prefix/test.txt')).toSucceedWith('content');
-                });
-            });
-            test('tests inferContentType orDefault() branches with failing content type inference', async () => {
-                const fileHandle = {
-                    kind: 'file',
-                    name: 'test.txt',
-                    isSameEntry: jest.fn(),
-                    queryPermission: jest.fn(),
-                    requestPermission: jest.fn(),
-                    getFile: jest.fn().mockResolvedValue((0, testHelpers_1.createMockFile)({ name: 'test.txt', content: 'content' })),
-                    createWritable: jest.fn()
-                };
-                const dirHandle = createMockDirectoryHandle('dir', [{ name: 'file.txt', content: 'dir content' }]);
-                // Test lines 315 and 385: inferContentType returning failure, triggering orDefault()
-                const failingInferContentType = jest.fn(() => ({
-                    isSuccess: () => false,
-                    isFailure: () => true,
-                    message: 'Content type inference failed',
-                    orDefault: () => undefined
-                }));
-                const fileHandleInitializers = [{ fileHandles: [fileHandle] }];
-                const fileHandleResult = await file_tree_1.FileApiTreeAccessors.create(fileHandleInitializers, {
-                    inferContentType: failingInferContentType
-                });
-                expect(fileHandleResult).toSucceedAndSatisfy((fileTree) => {
-                    expect(fileTree.hal.getFileContents('/test.txt')).toSucceedWith('content');
-                });
-                const dirHandleInitializers = [{ dirHandles: [dirHandle] }];
-                const dirHandleResult = await file_tree_1.FileApiTreeAccessors.create(dirHandleInitializers, {
-                    inferContentType: failingInferContentType
-                });
-                expect(dirHandleResult).toSucceedAndSatisfy((fileTree) => {
-                    expect(fileTree.hal.getFileContents('/dir/file.txt')).toSucceedWith('dir content');
-                });
-            });
-            test('tests path normalization branches', async () => {
-                const fileList = (0, testHelpers_1.createMockFileList)([{ name: 'test.txt', content: 'content' }]);
-                // Test line 416: normalized.startsWith('/') ? normalized : `/${normalized}`
-                // Test the case where normalized path already starts with '/'
-                const result1 = await file_tree_1.FileApiTreeAccessors.create([{ fileList }], { prefix: '/' });
-                expect(result1).toSucceedAndSatisfy((fileTree) => {
-                    expect(fileTree.hal.getFileContents('/test.txt')).toSucceedWith('content');
-                });
-                // Test the case where normalized path doesn't start with '/' (the else branch)
-                // This is covered functionally by the tests above where prefix is provided
-                // The _normalizePath method adds '/' when the combined path doesn't start with one
-                // Test the case where normalized path DOES start with '/' (the first branch)
-                // This happens when the file path itself is absolute and no prefix is used
-                const fileListAbsolute = (0, testHelpers_1.createMockFileList)([
-                    { name: '/absolute/test.txt', content: 'absolute content' }
-                ]);
-                const result3 = await file_tree_1.FileApiTreeAccessors.create([{ fileList: fileListAbsolute }]);
-                expect(result3).toSucceedAndSatisfy((fileTree) => {
-                    expect(fileTree.hal.getFileContents('/absolute/test.txt')).toSucceedWith('absolute content');
-                });
-            });
-        });
-    });
-    describe('Content Type functionality', () => {
-        describe('inferContentType parameter', () => {
-            test('uses inferContentType function when provided', async () => {
-                const fileList = (0, testHelpers_1.createMockFileList)([
-                    { name: 'document.txt', content: 'text content', type: 'text/plain' },
-                    { name: 'data.json', content: '{"key": "value"}', type: 'application/json' }
-                ]);
-                const inferContentType = jest.fn((filePath, provided) => {
-                    if (filePath.endsWith('.txt')) {
-                        return { isSuccess: () => true, value: 'custom-text', orDefault: () => 'custom-text' };
-                    }
-                    if (filePath.endsWith('.json')) {
-                        return { isSuccess: () => true, value: 'custom-json', orDefault: () => 'custom-json' };
-                    }
-                    return { isSuccess: () => true, value: provided, orDefault: () => provided };
-                });
-                const result = await file_tree_1.FileApiTreeAccessors.fromFileList(fileList, { inferContentType });
-                expect(result).toSucceedAndSatisfy((fileTree) => {
-                    // fromFileList now consistently passes both path and MIME type parameters
-                    // This is consistent with _processFileList behavior
-                    expect(inferContentType).toHaveBeenCalledWith('/document.txt', 'text/plain');
-                    expect(inferContentType).toHaveBeenCalledWith('/data.json', 'application/json');
-                    // The specific content type assignments depend on the internal FileTree implementation
-                    expect(fileTree.getFile('/document.txt')).toSucceed();
-                    expect(fileTree.getFile('/data.json')).toSucceed();
-                });
-            });
-            test('fromFileList only passes path parameter (current limitation)', async () => {
-                const fileList = (0, testHelpers_1.createMockFileList)([
-                    { name: 'image.png', content: 'binary data', type: 'image/png' },
-                    { name: 'unknown.xyz', content: 'unknown data', type: '' }
-                ]);
-                const inferContentType = jest.fn((filePath, provided) => {
-                    return {
-                        isSuccess: () => true,
-                        value: `custom-${provided || 'unknown'}`,
-                        orDefault: () => `custom-${provided || 'unknown'}`
-                    };
-                });
-                const result = await file_tree_1.FileApiTreeAccessors.fromFileList(fileList, { inferContentType });
-                expect(result).toSucceed();
-                // fromFileList now passes both path and MIME type parameters
-                expect(inferContentType).toHaveBeenCalledWith('/image.png', 'image/png');
-                expect(inferContentType).toHaveBeenCalledWith('/unknown.xyz', 'text/plain');
-            });
-            test('works with fromDirectoryUpload', async () => {
-                const fileList = (0, testHelpers_1.createMockDirectoryFileList)([
-                    { path: 'project/src/component.tsx', content: 'React component', type: 'text/typescript' },
-                    { path: 'project/styles/main.css', content: 'CSS styles', type: 'text/css' }
-                ]);
-                const inferContentType = jest.fn((filePath, provided) => {
-                    if (filePath.includes('.tsx')) {
-                        return { isSuccess: () => true, value: 'typescript-react', orDefault: () => 'typescript-react' };
-                    }
-                    return { isSuccess: () => true, value: provided, orDefault: () => provided };
-                });
-                const result = await file_tree_1.FileApiTreeAccessors.fromDirectoryUpload(fileList, { inferContentType });
-                expect(result).toSucceed();
-                // fromDirectoryUpload now consistently passes both path and MIME type parameters
-                expect(inferContentType).toHaveBeenCalledWith('/project/src/component.tsx', 'text/typescript');
-                expect(inferContentType).toHaveBeenCalledWith('/project/styles/main.css', 'text/css');
-            });
-            test('receives provided MIME type when using create method (correct behavior)', async () => {
-                // The create method uses internal _processFileList which correctly passes both parameters
-                const fileList1 = (0, testHelpers_1.createMockFileList)([
-                    { name: 'file1.txt', content: 'content1', type: 'text/plain' }
-                ]);
-                const fileList2 = (0, testHelpers_1.createMockFileList)([
-                    { name: 'file2.md', content: '# Markdown', type: 'text/markdown' }
-                ]);
-                const inferContentType = jest.fn((filePath, provided) => {
-                    return {
-                        isSuccess: () => true,
-                        value: `inferred-${provided}`,
-                        orDefault: () => `inferred-${provided}`
-                    };
-                });
-                const initializers = [{ fileList: fileList1 }, { fileList: fileList2 }];
-                const result = await file_tree_1.FileApiTreeAccessors.create(initializers, { inferContentType });
-                expect(result).toSucceed();
-                // The create method correctly passes both path and MIME type
-                expect(inferContentType).toHaveBeenCalledWith('/file1.txt', 'text/plain');
-                expect(inferContentType).toHaveBeenCalledWith('/file2.md', 'text/markdown');
-            });
-            test('handles cases where inferContentType returns undefined', async () => {
-                const fileList = (0, testHelpers_1.createMockFileList)([
-                    { name: 'test.unknown', content: 'unknown content', type: 'application/octet-stream' }
-                ]);
-                const inferContentType = jest.fn((filePath, provided) => {
-                    // Return undefined to indicate no content type could be inferred
-                    return { isSuccess: () => true, value: undefined, orDefault: () => undefined };
-                });
-                const result = await file_tree_1.FileApiTreeAccessors.fromFileList(fileList, { inferContentType });
-                expect(result).toSucceed();
-                expect(inferContentType).toHaveBeenCalledWith('/test.unknown');
-            });
-            test('uses default behavior when inferContentType not provided', async () => {
-                const fileList = (0, testHelpers_1.createMockFileList)([
-                    { name: 'default.txt', content: 'default content', type: 'text/plain' }
-                ]);
-                // No inferContentType parameter provided
-                const result = await file_tree_1.FileApiTreeAccessors.fromFileList(fileList);
-                expect(result).toSucceedAndSatisfy((fileTree) => {
-                    expect(fileTree.getFile('/default.txt')).toSucceed();
-                });
-            });
-        });
-        describe('ContentType with FileTreeHelpers', () => {
-            test('fromFileList passes through inferContentType parameter', async () => {
-                const fileList = (0, testHelpers_1.createMockFileList)([
-                    { name: 'helper.js', content: 'JS content', type: 'application/javascript' }
-                ]);
-                const inferContentType = jest.fn((filePath, provided) => {
-                    return { isSuccess: () => true, value: 'helper-js', orDefault: () => 'helper-js' };
-                });
-                const result = await helpers_1.FileTreeHelpers.fromFileList(fileList, { inferContentType });
-                expect(result).toSucceed();
-                expect(inferContentType).toHaveBeenCalledWith('/helper.js', 'application/javascript');
-            });
-            test('fromDirectoryUpload passes through inferContentType parameter', async () => {
-                const fileList = (0, testHelpers_1.createMockDirectoryFileList)([
-                    { path: 'dist/bundle.js', content: 'bundled JS', type: 'application/javascript' }
-                ]);
-                const inferContentType = jest.fn((filePath, provided) => {
-                    return { isSuccess: () => true, value: 'bundled-js', orDefault: () => 'bundled-js' };
-                });
-                const result = await helpers_1.FileTreeHelpers.fromDirectoryUpload(fileList, { inferContentType });
-                expect(result).toSucceed();
-                expect(inferContentType).toHaveBeenCalledWith('/dist/bundle.js', 'application/javascript');
-            });
-        });
-    });
-    describe('createFromHttp', () => {
-        test('succeeds and returns a FileTree when HTTP backend loads successfully', async () => {
-            const fetchImpl = makeMockHttpFetch([
-                {
-                    ok: true,
-                    jsonValue: { path: '/', children: [{ path: '/data.json', name: 'data.json', type: 'file' }] }
-                },
-                { ok: true, jsonValue: { path: '/data.json', contents: '{"items":{}}' } }
-            ]);
-            const result = await file_tree_1.FileApiTreeAccessors.createFromHttp({
-                baseUrl: 'http://localhost:3000',
-                fetchImpl,
-                mutable: true
-            });
-            expect(result).toSucceedAndSatisfy((tree) => {
-                expect(tree).toBeInstanceOf(ts_json_base_1.FileTree.FileTree);
-                expect(tree.getFile('/data.json')).toSucceed();
-                expect(ts_json_base_1.FileTree.isPersistentAccessors(tree.hal)).toBe(true);
-            });
-        });
-        test('fails when the HTTP backend returns an error during initial load', async () => {
-            const fetchImpl = makeMockHttpFetch([{ ok: false, status: 503, textValue: 'Service Unavailable' }]);
-            const result = await file_tree_1.FileApiTreeAccessors.createFromHttp({
-                baseUrl: 'http://localhost:3000',
-                fetchImpl
-            });
-            expect(result).toFailWith(/service unavailable/i);
-        });
-    });
-});
-//# sourceMappingURL=fileApiTreeAccessors.test.js.map