@bendyline/docblocks 2.0.0 → 2.1.1

package/dist/filesystem/dbk-workspace.js

@@ -1,85 +0,0 @@
-import { documentCompanionPath } from './move-entry.js';
-function normaliseRelativePath(path, label) {
-    if (path.includes('\\') || path.includes('\0')) {
-        throw new Error(`DBK ${label} must use a safe forward-slash path: ${path}`);
-    }
-    const normalized = path.replace(/^\/+|\/+$/g, '').replace(/\/+/g, '/');
-    const segments = normalized ? normalized.split('/') : [];
-    if (segments.length === 0 || segments.some((segment) => segment === '.' || segment === '..')) {
-        throw new Error(`DBK ${label} must not be empty or traverse directories: ${path}`);
-    }
-    return segments.join('/');
-}
-function joinPath(parent, child) {
-    return `${parent.replace(/\/+$/g, '')}/${child.replace(/^\/+/, '')}`;
-}
-/**
- * Fully materialize and validate a DBK container before touching its target
- * provider. A missing or unreadable entry fails the snapshot as a whole.
- */
-export async function createDbkWorkspaceSnapshot(source, options) {
-    const targetDocumentPath = normaliseRelativePath(options.targetDocumentPath, 'target document path');
-    const discoveredDocumentPath = await source.getDocumentPath();
-    if (!discoveredDocumentPath)
-        throw new Error('The external DBK has no primary markdown document.');
-    const sourceDocumentPath = normaliseRelativePath(discoveredDocumentPath, 'primary document path');
-    const requestedLayout = options.assetLayout ?? 'auto';
-    const assetLayout = requestedLayout === 'auto'
-        ? sourceDocumentPath === targetDocumentPath
-            ? 'preserve'
-            : 'companion'
-        : requestedLayout;
-    const companionPath = normaliseRelativePath(documentCompanionPath(targetDocumentPath), 'companion directory path');
-    const listed = await source.listFiles();
-    const entries = [...listed].sort((a, b) => a.path.localeCompare(b.path));
-    const seenSourcePaths = new Set();
-    const files = [];
-    let documentContent = null;
-    for (const entry of entries) {
-        const sourcePath = normaliseRelativePath(entry.path, 'entry path');
-        if (seenSourcePaths.has(sourcePath)) {
-            throw new Error(`The external DBK contains duplicate paths: ${sourcePath}`);
-        }
-        seenSourcePaths.add(sourcePath);
-        const data = await source.readFile(entry.path);
-        if (data === null) {
-            throw new Error(`The external DBK changed while reading: ${sourcePath}`);
-        }
-        if (sourcePath === sourceDocumentPath) {
-            documentContent = new TextDecoder().decode(data);
-            files.push({ kind: 'text', path: targetDocumentPath, content: documentContent });
-            continue;
-        }
-        const targetPath = assetLayout === 'preserve' ? sourcePath : joinPath(companionPath, sourcePath);
-        if (/\.(?:md|mdx|txt)$/i.test(sourcePath)) {
-            files.push({ kind: 'text', path: targetPath, content: new TextDecoder().decode(data) });
-        }
-        else {
-            files.push({ kind: 'binary', path: targetPath, data });
-        }
-    }
-    if (documentContent === null) {
-        throw new Error(`The external DBK did not include its primary document: ${sourceDocumentPath}`);
-    }
-    return {
-        sourceDocumentPath,
-        targetDocumentPath,
-        documentContent,
-        assetLayout,
-        files,
-    };
-}
-/**
- * Replace a transient DBK workspace as one logical operation.
- *
- * Container reads and validation happen before provider mutation. The memory
- * provider then stages and swaps the full tree synchronously, which removes
- * stale files and guarantees the old tree survives any failed replacement.
- */
-export async function replaceMemoryWorkspaceFromDbk(provider, source, options) {
-    const expectedTreeVersion = provider.treeVersion;
-    const snapshot = await createDbkWorkspaceSnapshot(source, options);
-    provider.replaceContents(snapshot, expectedTreeVersion);
-    return snapshot;
-}
-//# sourceMappingURL=dbk-workspace.js.map

package/dist/filesystem/dbk-workspace.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"dbk-workspace.js","sourceRoot":"","sources":["../../src/filesystem/dbk-workspace.ts"],"names":[],"mappings":"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"}

package/dist/filesystem/electron-provider-v2.d.ts

@@ -1,36 +0,0 @@
-import { type WorkspacePath } from './workspace-path.js';
-import { type FileSystemCreateDirectoryOptions, type FileSystemDirectorySnapshot, type FileSystemEntrySnapshot, type FileSystemFileRead, type FileSystemFileSnapshot, type FileSystemMoveOptions, type FileSystemProviderCapabilities, type FileSystemProviderV2, type FileSystemRemoveOptions, type FileSystemRemoveResult, type FileSystemSnapshot, type FileSystemWatchEvent, type FileSystemWatchOptions, type FileSystemWatchSubscription, type FileSystemWriteOptions } from './v2.js';
-/** Pure renderer-side client for the typed Electron filesystem v2 transport. */
-export declare class ElectronFileSystemProviderV2 implements FileSystemProviderV2 {
-    readonly id: string;
-    readonly label: string;
-    readonly capabilities: FileSystemProviderCapabilities;
-    private readonly rootPath;
-    private readonly instanceId;
-    private readonly watchers;
-    private readonly subscriptions;
-    private readonly inFlight;
-    private openPromise;
-    private removeWatchBridge;
-    private disposePromise;
-    private hostOpened;
-    private disposed;
-    constructor(id: string, label: string, rootPath: string);
-    getRootPath(): string;
-    stat(path: WorkspacePath): Promise<FileSystemEntrySnapshot | null>;
-    readFile(path: WorkspacePath): Promise<FileSystemFileRead | null>;
-    readDirectory(path: WorkspacePath): Promise<readonly FileSystemEntrySnapshot[]>;
-    writeFile(path: WorkspacePath, data: ArrayBuffer | Uint8Array, options?: FileSystemWriteOptions): Promise<FileSystemFileSnapshot>;
-    createDirectory(path: WorkspacePath, options?: FileSystemCreateDirectoryOptions): Promise<FileSystemDirectorySnapshot>;
-    remove(path: WorkspacePath, options?: FileSystemRemoveOptions): Promise<FileSystemRemoveResult>;
-    move(oldPath: WorkspacePath, newPath: WorkspacePath, options?: FileSystemMoveOptions): Promise<FileSystemEntrySnapshot>;
-    snapshot(): Promise<FileSystemSnapshot>;
-    watch(listener: (event: FileSystemWatchEvent) => void, options?: FileSystemWatchOptions): FileSystemWatchSubscription;
-    dispose(): Promise<void>;
-    private request;
-    private ensureOpen;
-    private ensureWatchBridge;
-    private handleWatchMessage;
-    private assertOpen;
-}
-//# sourceMappingURL=electron-provider-v2.d.ts.map

package/dist/filesystem/electron-provider-v2.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"electron-provider-v2.d.ts","sourceRoot":"","sources":["../../src/filesystem/electron-provider-v2.ts"],"names":[],"mappings":"AAcA,OAAO,EAKL,KAAK,aAAa,EACnB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAEL,KAAK,gCAAgC,EACrC,KAAK,2BAA2B,EAChC,KAAK,uBAAuB,EAC5B,KAAK,kBAAkB,EACvB,KAAK,sBAAsB,EAC3B,KAAK,qBAAqB,EAC1B,KAAK,8BAA8B,EACnC,KAAK,oBAAoB,EACzB,KAAK,uBAAuB,EAC5B,KAAK,sBAAsB,EAC3B,KAAK,kBAAkB,EAEvB,KAAK,oBAAoB,EACzB,KAAK,sBAAsB,EAC3B,KAAK,2BAA2B,EAChC,KAAK,sBAAsB,EAC5B,MAAM,SAAS,CAAC;AAmBjB,gFAAgF;AAChF,qBAAa,4BAA6B,YAAW,oBAAoB;IACvE,SAAgB,EAAE,EAAE,MAAM,CAAC;IAC3B,SAAgB,KAAK,EAAE,MAAM,CAAC;IAC9B,SAAgB,YAAY,iCAAwC;IAEpE,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAsB;IACjD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAoC;IAC7D,OAAO,CAAC,QAAQ,CAAC,aAAa,CAA0C;IACxE,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA+B;IACxD,OAAO,CAAC,WAAW,CAA8B;IACjD,OAAO,CAAC,iBAAiB,CAA6B;IACtD,OAAO,CAAC,cAAc,CAA8B;IACpD,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,QAAQ,CAAS;gBAEN,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM;IAMvD,WAAW,IAAI,MAAM;IAIf,IAAI,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO,CAAC,uBAAuB,GAAG,IAAI,CAAC;IASlE,QAAQ,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO,CAAC,kBAAkB,GAAG,IAAI,CAAC;IAiBjE,aAAa,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO,CAAC,SAAS,uBAAuB,EAAE,CAAC;IAS/E,SAAS,CACpB,IAAI,EAAE,aAAa,EACnB,IAAI,EAAE,WAAW,GAAG,UAAU,EAC9B,OAAO,CAAC,EAAE,sBAAsB,GAC/B,OAAO,CAAC,sBAAsB,CAAC;IAUrB,eAAe,CAC1B,IAAI,EAAE,aAAa,EACnB,OAAO,CAAC,EAAE,gCAAgC,GACzC,OAAO,CAAC,2BAA2B,CAAC;IAS1B,MAAM,CACjB,IAAI,EAAE,aAAa,EACnB,OAAO,CAAC,EAAE,uBAAuB,GAChC,OAAO,CAAC,sBAAsB,CAAC;IASrB,IAAI,CACf,OAAO,EAAE,aAAa,EACtB,OAAO,EAAE,aAAa,EACtB,OAAO,CAAC,EAAE,qBAAqB,GAC9B,OAAO,CAAC,uBAAuB,CAAC;IAUtB,QAAQ,IAAI,OAAO,CAAC,kBAAkB,CAAC;IAQ7C,KAAK,CACV,QAAQ,EAAE,CAAC,KAAK,EAAE,oBAAoB,KAAK,IAAI,EAC/C,OAAO,GAAE,sBAA2B,GACnC,2BAA2B;IAqDvB,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAiC/B,OAAO,CAAC,OAAO;IAqBf,OAAO,CAAC,UAAU;IAwBlB,OAAO,CAAC,iBAAiB;IAOzB,OAAO,CAAC,kBAAkB;IAkC1B,OAAO,CAAC,UAAU;CAInB"}

package/dist/filesystem/electron-provider-v2.js

@@ -1,503 +0,0 @@
-import { ELECTRON_FILE_SYSTEM_V2_CAPABILITIES, maybeGetDocBlocksHost, } from '../host/index.js';
-import { FsError, deserializeFsError, fsErrorFromUnknown, isSerializedFsError, } from './fs-error.js';
-import { WORKSPACE_ROOT, parseWorkspacePath, workspacePathBasename, workspacePathDirname, } from './workspace-path.js';
-import { parseFileSystemVersion, } from './v2.js';
-let fallbackInstanceSequence = 0;
-function getHostFsV2(operation) {
-    const host = maybeGetDocBlocksHost();
-    if (!host?.fsV2) {
-        throw new FsError('not-supported', 'Electron filesystem v2 host is unavailable.', {
-            operation,
-        });
-    }
-    return host.fsV2;
-}
-/** Pure renderer-side client for the typed Electron filesystem v2 transport. */
-export class ElectronFileSystemProviderV2 {
-    constructor(id, label, rootPath) {
-        this.capabilities = ELECTRON_FILE_SYSTEM_V2_CAPABILITIES;
-        this.instanceId = createInstanceId();
-        this.watchers = new Map();
-        this.subscriptions = new Set();
-        this.inFlight = new Set();
-        this.openPromise = null;
-        this.removeWatchBridge = null;
-        this.disposePromise = null;
-        this.hostOpened = false;
-        this.disposed = false;
-        this.id = id;
-        this.label = label;
-        this.rootPath = rootPath;
-    }
-    getRootPath() {
-        return this.rootPath;
-    }
-    async stat(path) {
-        const canonical = parseWorkspacePath(String(path));
-        return this.request('stat', () => getHostFsV2('stat').stat(this.instanceId, canonical), (value) => (value ? normalizeEntry(value) : null));
-    }
-    async readFile(path) {
-        const canonical = parseWorkspacePath(String(path));
-        return this.request('read', () => getHostFsV2('read').readFile(this.instanceId, canonical), (value) => {
-            if (!value)
-                return null;
-            const entry = normalizeFile(value.entry);
-            const data = copyWireBuffer(value.data);
-            if (data.byteLength !== entry.size) {
-                throw new TypeError('Filesystem transport returned file bytes with the wrong size.');
-            }
-            return Object.freeze({ entry, data });
-        });
-    }
-    async readDirectory(path) {
-        const canonical = parseWorkspacePath(String(path));
-        return this.request('list', () => getHostFsV2('list').readDirectory(this.instanceId, canonical), (value) => normalizeDirectoryListing(value, canonical));
-    }
-    async writeFile(path, data, options) {
-        const canonical = parseWorkspacePath(String(path));
-        const owned = copyBytes(data);
-        return this.request('write', () => getHostFsV2('write').writeFile(this.instanceId, canonical, owned, options), normalizeFile);
-    }
-    async createDirectory(path, options) {
-        const canonical = parseWorkspacePath(String(path));
-        return this.request('create-directory', () => getHostFsV2('create-directory').createDirectory(this.instanceId, canonical, options), normalizeDirectory);
-    }
-    async remove(path, options) {
-        const canonical = parseWorkspacePath(String(path));
-        return this.request('remove', () => getHostFsV2('remove').remove(this.instanceId, canonical, options), normalizeRemoveResult);
-    }
-    async move(oldPath, newPath, options) {
-        const source = parseWorkspacePath(String(oldPath));
-        const destination = parseWorkspacePath(String(newPath));
-        return this.request('move', () => getHostFsV2('move').move(this.instanceId, source, destination, options), normalizeEntry);
-    }
-    async snapshot() {
-        return this.request('snapshot', () => getHostFsV2('snapshot').snapshot(this.instanceId), normalizeSnapshot);
-    }
-    watch(listener, options = {}) {
-        this.assertOpen('watch');
-        this.ensureWatchBridge();
-        const subscriptionId = createInstanceId();
-        const watcher = { listener, onError: options.onError };
-        this.watchers.set(subscriptionId, watcher);
-        let closed = false;
-        let subscribed = false;
-        let closePromise = null;
-        const ready = this.ensureOpen('watch')
-            .then(async () => {
-            if (closed)
-                return;
-            unwrap(await getHostFsV2('watch').watchSubscribe(this.instanceId, subscriptionId), 'watch');
-            subscribed = true;
-        })
-            .catch((error) => {
-            closed = true;
-            this.watchers.delete(subscriptionId);
-            const typed = error instanceof FsError ? error : new FsError('io', String(error));
-            try {
-                watcher.onError?.(typed);
-            }
-            catch {
-                // Isolate observers.
-            }
-            throw typed;
-        });
-        const subscription = {
-            get closed() {
-                return closed;
-            },
-            ready,
-            dispose: () => {
-                if (closePromise)
-                    return closePromise;
-                closed = true;
-                this.watchers.delete(subscriptionId);
-                this.subscriptions.delete(subscription);
-                closePromise = (async () => {
-                    await ready.catch(() => undefined);
-                    if (subscribed) {
-                        unwrap(await getHostFsV2('watch').watchUnsubscribe(this.instanceId, subscriptionId), 'watch');
-                    }
-                })();
-                return closePromise;
-            },
-        };
-        this.subscriptions.add(subscription);
-        return subscription;
-    }
-    dispose() {
-        if (this.disposePromise)
-            return this.disposePromise;
-        this.disposed = true;
-        this.disposePromise = (async () => {
-            await Promise.allSettled([...this.inFlight]);
-            await Promise.all([...this.subscriptions].map((subscription) => subscription.dispose()));
-            try {
-                if (this.openPromise) {
-                    try {
-                        await this.openPromise;
-                    }
-                    catch {
-                        // A failed request normally creates no host record. `hostOpened`
-                        // separately tracks a successful open whose response validation
-                        // failed after the main-side record had already been published.
-                    }
-                }
-                if (this.hostOpened) {
-                    try {
-                        unwrap(await getHostFsV2('dispose').dispose(this.instanceId), 'dispose');
-                    }
-                    catch (error) {
-                        if (!(error instanceof FsError && error.code === 'closed'))
-                            throw error;
-                    }
-                    finally {
-                        this.hostOpened = false;
-                    }
-                }
-            }
-            finally {
-                this.removeWatchBridge?.();
-                this.removeWatchBridge = null;
-            }
-        })();
-        return this.disposePromise;
-    }
-    request(operation, send, normalize) {
-        this.assertOpen(operation);
-        const promise = this.ensureOpen(operation).then(async () => {
-            try {
-                return normalize(unwrap(await send(), operation));
-            }
-            catch (error) {
-                throw transportErrorFromUnknown(error, operation);
-            }
-        });
-        this.inFlight.add(promise);
-        void promise.then(() => this.inFlight.delete(promise), () => this.inFlight.delete(promise));
-        return promise;
-    }
-    ensureOpen(operation) {
-        this.assertOpen(operation);
-        if (!this.openPromise) {
-            const attempt = getHostFsV2(operation)
-                .open({
-                instanceId: this.instanceId,
-                providerId: this.id,
-                label: this.label,
-            })
-                .then((result) => {
-                if (isRecord(result) && result.ok === true)
-                    this.hostOpened = true;
-                const capabilities = unwrap(result, operation);
-                assertCapabilities(capabilities, operation);
-            })
-                .catch((error) => {
-                const typed = withOperation(fsErrorFromUnknown(error, { operation }), operation);
-                if (typed.retryable && this.openPromise === attempt)
-                    this.openPromise = null;
-                throw typed;
-            });
-            this.openPromise = attempt;
-        }
-        return this.openPromise;
-    }
-    ensureWatchBridge() {
-        if (this.removeWatchBridge)
-            return;
-        this.removeWatchBridge = getHostFsV2('watch').onWatchMessage((message) => this.handleWatchMessage(message));
-    }
-    handleWatchMessage(message) {
-        if (message.instanceId !== this.instanceId)
-            return;
-        const watcher = this.watchers.get(message.subscriptionId);
-        if (!watcher)
-            return;
-        if (message.kind === 'error') {
-            const typed = isSerializedFsError(message.error)
-                ? deserializeFsError(message.error)
-                : invalidTransport('watch', 'Filesystem transport returned an invalid watch error.');
-            try {
-                watcher.onError?.(typed);
-            }
-            catch {
-                // Isolate observers.
-            }
-            return;
-        }
-        let event;
-        try {
-            event = normalizeWatchEvent(message.event);
-        }
-        catch (error) {
-            try {
-                watcher.onError?.(transportErrorFromUnknown(error, 'watch'));
-            }
-            catch {
-                // Isolate observers.
-            }
-            return;
-        }
-        try {
-            watcher.listener(event);
-        }
-        catch {
-            // Watch callbacks are observational.
-        }
-    }
-    assertOpen(operation) {
-        if (!this.disposed)
-            return;
-        throw new FsError('disposed', 'Filesystem provider is disposed.', { operation });
-    }
-}
-function unwrap(result, operation) {
-    if (!isRecord(result) || typeof result.ok !== 'boolean') {
-        throw invalidTransport(operation, 'Filesystem transport returned an invalid result envelope.');
-    }
-    if (result.ok) {
-        if (!('value' in result)) {
-            throw invalidTransport(operation, 'Filesystem transport omitted a result value.');
-        }
-        return result.value;
-    }
-    if (!isSerializedFsError(result.error)) {
-        throw invalidTransport(operation, 'Filesystem transport returned an invalid error envelope.');
-    }
-    throw deserializeFsError(result.error);
-}
-function normalizeEntry(entry) {
-    if (!isRecord(entry))
-        throw new TypeError('Expected a filesystem entry object.');
-    if (typeof entry.path !== 'string')
-        throw new TypeError('Filesystem entry path must be a string.');
-    if (typeof entry.name !== 'string')
-        throw new TypeError('Filesystem entry name must be a string.');
-    if (typeof entry.lastModified !== 'string') {
-        throw new TypeError('Filesystem entry timestamp must be a string.');
-    }
-    const path = parseWorkspacePath(entry.path);
-    if (entry.name !== workspacePathBasename(path)) {
-        throw new TypeError('Filesystem entry name does not match its canonical path.');
-    }
-    const common = {
-        path,
-        name: entry.name,
-        version: parseFileSystemVersion(entry.version),
-        lastModified: new Date(entry.lastModified).toISOString(),
-    };
-    if (entry.kind === 'file') {
-        if (!isNonNegativeSafeInteger(entry.size)) {
-            throw new TypeError('Filesystem file size must be a non-negative safe integer.');
-        }
-        return Object.freeze({ ...common, kind: 'file', size: entry.size });
-    }
-    if (entry.kind === 'directory') {
-        if (entry.size !== null)
-            throw new TypeError('Filesystem directory size must be null.');
-        return Object.freeze({ ...common, kind: 'directory', size: null });
-    }
-    throw new TypeError('Unknown filesystem entry kind.');
-}
-function normalizeDirectoryListing(value, parent) {
-    if (!Array.isArray(value))
-        throw new TypeError('Expected a filesystem directory listing.');
-    const entries = value.map(normalizeEntry);
-    const seen = new Set();
-    for (const entry of entries) {
-        if (entry.path === WORKSPACE_ROOT || workspacePathDirname(entry.path) !== parent) {
-            throw new TypeError('Filesystem listing contained a non-child entry.');
-        }
-        if (seen.has(entry.path))
-            throw new TypeError('Filesystem listing contained a duplicate path.');
-        seen.add(entry.path);
-    }
-    const ordered = [...entries].sort(compareDirectoryEntries);
-    if (ordered.some((entry, index) => entry.path !== entries[index]?.path)) {
-        throw new TypeError('Filesystem listing was not in canonical deterministic order.');
-    }
-    return Object.freeze(entries);
-}
-function normalizeFile(entry) {
-    const normalized = normalizeEntry(entry);
-    if (normalized.kind !== 'file')
-        throw new TypeError('Expected a file snapshot.');
-    return normalized;
-}
-function normalizeDirectory(entry) {
-    const normalized = normalizeEntry(entry);
-    if (normalized.kind !== 'directory')
-        throw new TypeError('Expected a directory snapshot.');
-    return normalized;
-}
-function normalizeSnapshot(snapshot) {
-    if (!isRecord(snapshot) || !Array.isArray(snapshot.entries)) {
-        throw new TypeError('Expected a filesystem snapshot object.');
-    }
-    const version = parseFileSystemVersion(snapshot.version);
-    const entries = snapshot.entries.map((entry) => {
-        if (entry.kind === 'file') {
-            const file = normalizeFile(entry);
-            const data = copyWireBuffer(entry.data);
-            if (data.byteLength !== file.size) {
-                throw new TypeError('Filesystem snapshot file bytes have the wrong size.');
-            }
-            return Object.freeze({ ...file, data });
-        }
-        if (entry.kind === 'directory')
-            return normalizeDirectory(entry);
-        throw new TypeError('Unknown filesystem snapshot entry kind.');
-    });
-    const roots = entries.filter((entry) => entry.path === WORKSPACE_ROOT);
-    if (roots.length !== 1 || roots[0]?.kind !== 'directory' || roots[0].version !== version) {
-        throw new TypeError('Filesystem snapshot must contain one matching root directory.');
-    }
-    const seen = new Set();
-    for (const entry of entries) {
-        if (seen.has(entry.path))
-            throw new TypeError('Filesystem snapshot contained a duplicate path.');
-        seen.add(entry.path);
-    }
-    const ordered = [...entries].sort((left, right) => compareText(left.path, right.path));
-    if (ordered.some((entry, index) => entry.path !== entries[index]?.path)) {
-        throw new TypeError('Filesystem snapshot was not in canonical deterministic order.');
-    }
-    return Object.freeze({
-        version,
-        entries: Object.freeze(entries),
-    });
-}
-function normalizeWatchEvent(event) {
-    if (!isRecord(event))
-        throw new TypeError('Expected a filesystem watch event object.');
-    if (!isPositiveSafeInteger(event.sequence)) {
-        throw new TypeError('Filesystem watch sequence must be a positive safe integer.');
-    }
-    if (!isWatchOrigin(event.origin))
-        throw new TypeError('Unknown filesystem watch origin.');
-    if (typeof event.path !== 'string')
-        throw new TypeError('Watch event path must be a string.');
-    const path = parseWorkspacePath(event.path);
-    if (event.type === 'overflow') {
-        if (event.kind !== null ||
-            event.destinationPath !== null ||
-            event.version !== null ||
-            event.previousVersion !== null) {
-            throw new TypeError('Filesystem overflow event has entry-specific fields.');
-        }
-        return Object.freeze({
-            sequence: event.sequence,
-            origin: event.origin,
-            type: 'overflow',
-            kind: null,
-            path,
-            destinationPath: null,
-            version: null,
-            previousVersion: null,
-        });
-    }
-    if (!isEntryWatchType(event.type))
-        throw new TypeError('Unknown filesystem watch event type.');
-    if (event.kind !== 'file' && event.kind !== 'directory') {
-        throw new TypeError('Unknown filesystem watch entry kind.');
-    }
-    const destinationPath = event.destinationPath === null
-        ? null
-        : typeof event.destinationPath === 'string'
-            ? parseWorkspacePath(event.destinationPath)
-            : (() => {
-                throw new TypeError('Watch destination path must be a string or null.');
-            })();
-    if ((event.type === 'moved') !== (destinationPath !== null)) {
-        throw new TypeError('Only moved watch events may have a destination path.');
-    }
-    return Object.freeze({
-        sequence: event.sequence,
-        origin: event.origin,
-        type: event.type,
-        kind: event.kind,
-        path,
-        destinationPath,
-        version: event.version === null ? null : parseFileSystemVersion(event.version),
-        previousVersion: event.previousVersion === null ? null : parseFileSystemVersion(event.previousVersion),
-    });
-}
-function normalizeRemoveResult(value) {
-    if (!isRecord(value) || typeof value.removed !== 'boolean') {
-        throw new TypeError('Filesystem transport returned an invalid remove result.');
-    }
-    return Object.freeze({ removed: value.removed, version: parseFileSystemVersion(value.version) });
-}
-function assertCapabilities(value, operation) {
-    if (!isRecord(value)) {
-        throw invalidTransport(operation, 'Filesystem host returned invalid capabilities.');
-    }
-    for (const key of Object.keys(ELECTRON_FILE_SYSTEM_V2_CAPABILITIES)) {
-        if (value[key] !== ELECTRON_FILE_SYSTEM_V2_CAPABILITIES[key]) {
-            throw invalidTransport(operation, `Filesystem host capability mismatch: ${key}.`);
-        }
-    }
-}
-function compareDirectoryEntries(left, right) {
-    if (left.kind !== right.kind)
-        return left.kind === 'directory' ? -1 : 1;
-    return compareText(left.path, right.path);
-}
-function compareText(left, right) {
-    return left < right ? -1 : left > right ? 1 : 0;
-}
-function isWatchOrigin(value) {
-    return value === 'local' || value === 'external' || value === 'unknown';
-}
-function isEntryWatchType(value) {
-    return value === 'created' || value === 'modified' || value === 'removed' || value === 'moved';
-}
-function isNonNegativeSafeInteger(value) {
-    return typeof value === 'number' && Number.isSafeInteger(value) && value >= 0;
-}
-function isPositiveSafeInteger(value) {
-    return isNonNegativeSafeInteger(value) && value > 0;
-}
-function isRecord(value) {
-    return typeof value === 'object' && value !== null;
-}
-function invalidTransport(operation, message) {
-    return new FsError('io', message, { operation, retryable: false });
-}
-function transportErrorFromUnknown(error, operation) {
-    if (error instanceof TypeError)
-        return invalidTransport(operation, error.message);
-    return withOperation(fsErrorFromUnknown(error, { operation }), operation);
-}
-function withOperation(error, operation) {
-    if (error.operation === operation)
-        return error;
-    return new FsError(error.code, error.message, {
-        operation,
-        path: error.path ?? undefined,
-        destinationPath: error.destinationPath ?? undefined,
-        retryable: error.retryable,
-    });
-}
-function copyBytes(data) {
-    const source = ArrayBuffer.isView(data)
-        ? new Uint8Array(data.buffer, data.byteOffset, data.byteLength)
-        : new Uint8Array(data);
-    const copy = new Uint8Array(source.byteLength);
-    copy.set(source);
-    return copy.buffer;
-}
-function copyWireBuffer(data) {
-    if (Object.prototype.toString.call(data) !== '[object ArrayBuffer]') {
-        throw new TypeError('Expected an ArrayBuffer from the filesystem transport.');
-    }
-    return data.slice(0);
-}
-function createInstanceId() {
-    const randomUUID = globalThis.crypto?.randomUUID;
-    if (typeof randomUUID === 'function')
-        return randomUUID.call(globalThis.crypto);
-    fallbackInstanceSequence += 1;
-    return `electron-fs-v2-${Date.now()}-${fallbackInstanceSequence}`;
-}
-//# sourceMappingURL=electron-provider-v2.js.map