@bendyline/docblocks 1.1.2 → 2.0.0

package/dist/filesystem/dbk-workspace.js

@@ -0,0 +1,85 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,36 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,503 @@
+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