@bendyline/docblocks 1.1.2 → 2.1.0

package/dist/chunk-RVPGQBWR.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/filesystem/indexeddb-store.ts"],"sourcesContent":["/**\n * Minimal, error-propagating IndexedDB store used by the virtual filesystem.\n *\n * The previous Squisq LocalForage adapter intentionally converted failed\n * reads/enumerations/removals into null/empty/success. Those semantics are\n * unsuitable for filesystem mutations: an unavailable database must never be\n * interpreted as an absent file. This layer opens the old database and object\n * store directly so existing data can be migrated in one transaction.\n */\n\nexport type IndexedDBFileSystemTransactionMode = 'readonly' | 'readwrite';\n\n/** The database holding one browser-local workspace's files. */\nexport function indexedDBWorkspaceDatabaseName(workspaceId: string): string {\n  return `docblocks-fs-${workspaceId}`;\n}\n\n/**\n * Delete a database and everything in it.\n *\n * Open connections do not have to be closed first: deletion fires\n * `versionchange` on them, and this module's connections close themselves in\n * response, after which the deletion proceeds. A `blocked` event is therefore\n * transient (an in-flight transaction) and is deliberately not treated as a\n * failure — the deletion still completes once that transaction finishes.\n */\nexport function deleteIndexedDBDatabase(databaseName: string): Promise<void> {\n  if (typeof indexedDB === 'undefined') {\n    return Promise.reject(new Error('IndexedDB is not available in this environment.'));\n  }\n  return new Promise((resolve, reject) => {\n    const request = indexedDB.deleteDatabase(databaseName);\n    request.onsuccess = () => resolve();\n    request.onerror = () =>\n      reject(request.error ?? new Error(`Failed to delete the \"${databaseName}\" database.`));\n  });\n}\n\n/**\n * Delete a browser-local workspace's stored files.\n *\n * Removing a workspace descriptor alone leaves these bytes behind: invisible to\n * the user, still counted against the origin's quota, and ready to reappear\n * under any later workspace that reuses the same id.\n */\nexport function deleteIndexedDBWorkspaceData(workspaceId: string): Promise<void> {\n  return deleteIndexedDBDatabase(indexedDBWorkspaceDatabaseName(workspaceId));\n}\n\nexport interface IndexedDBFileSystemTransaction {\n  get<T>(key: string): Promise<T | null>;\n  put<T>(key: string, value: T): Promise<void>;\n  delete(key: string): Promise<void>;\n  keys(): Promise<string[]>;\n  /** O(log n) namespace probe in the concrete IndexedDB implementation. */\n  hasKeyWithPrefix(prefix: string): Promise<boolean>;\n}\n\nexport interface IndexedDBFileSystemStore {\n  transaction<T>(\n    mode: IndexedDBFileSystemTransactionMode,\n    operation: (transaction: IndexedDBFileSystemTransaction) => Promise<T>,\n  ): Promise<T>;\n  close?(): void;\n}\n\nexport class RawIndexedDBFileSystemStore implements IndexedDBFileSystemStore {\n  private database: IDBDatabase | null = null;\n  private opening: Promise<IDBDatabase> | null = null;\n  private closed = false;\n\n  public constructor(\n    private readonly databaseName: string,\n    private readonly storeName: string,\n  ) {}\n\n  public async transaction<T>(\n    mode: IndexedDBFileSystemTransactionMode,\n    operation: (transaction: IndexedDBFileSystemTransaction) => Promise<T>,\n  ): Promise<T> {\n    const database = await this.getDatabase();\n    const nativeTransaction = database.transaction(this.storeName, mode);\n    const completion = waitForTransaction(nativeTransaction);\n    const transaction = new RawIndexedDBFileSystemTransaction(\n      nativeTransaction.objectStore(this.storeName),\n    );\n\n    let result: T;\n    try {\n      result = await operation(transaction);\n    } catch (error: unknown) {\n      try {\n        nativeTransaction.abort();\n      } catch {\n        // The request failure may already have aborted the transaction.\n      }\n      await completion.catch(() => undefined);\n      throw error;\n    }\n\n    await completion;\n    return result;\n  }\n\n  public close(): void {\n    if (this.closed) return;\n    this.closed = true;\n    this.database?.close();\n    this.database = null;\n    this.opening = null;\n  }\n\n  private getDatabase(): Promise<IDBDatabase> {\n    if (this.closed) {\n      return Promise.reject(new Error('The IndexedDB filesystem store is closed.'));\n    }\n    if (this.database) return Promise.resolve(this.database);\n    if (this.opening) return this.opening;\n    if (typeof indexedDB === 'undefined') {\n      return Promise.reject(new Error('IndexedDB is not available in this environment.'));\n    }\n\n    this.opening = openDatabaseWithStore(this.databaseName, this.storeName)\n      .then((database) => {\n        if (this.closed) {\n          database.close();\n          throw new Error('The IndexedDB filesystem store is closed.');\n        }\n        this.database = database;\n        this.opening = null;\n        database.onversionchange = () => {\n          database.close();\n          if (this.database === database) this.database = null;\n        };\n        return database;\n      })\n      .catch((error: unknown) => {\n        this.opening = null;\n        throw error;\n      });\n    return this.opening;\n  }\n}\n\nclass RawIndexedDBFileSystemTransaction implements IndexedDBFileSystemTransaction {\n  public constructor(private readonly store: IDBObjectStore) {}\n\n  public async get<T>(key: string): Promise<T | null> {\n    const value = await requestResult(this.store.get(key));\n    return value === undefined ? null : (value as T);\n  }\n\n  public async put<T>(key: string, value: T): Promise<void> {\n    await requestResult(this.store.put(value, key));\n  }\n\n  public async delete(key: string): Promise<void> {\n    await requestResult(this.store.delete(key));\n  }\n\n  public async keys(): Promise<string[]> {\n    const keys = await requestResult(this.store.getAllKeys());\n    return keys.map((key) => {\n      if (typeof key !== 'string') {\n        throw new Error('The DocBlocks filesystem store contains a non-string key.');\n      }\n      return key;\n    });\n  }\n\n  public async hasKeyWithPrefix(prefix: string): Promise<boolean> {\n    const cursor = await requestResult(this.store.openKeyCursor(IDBKeyRange.lowerBound(prefix)));\n    return cursor !== null && typeof cursor.key === 'string' && cursor.key.startsWith(prefix);\n  }\n}\n\nasync function openDatabaseWithStore(\n  databaseName: string,\n  storeName: string,\n): Promise<IDBDatabase> {\n  const database = await openDatabase(databaseName, undefined, (upgradeDatabase) => {\n    if (!upgradeDatabase.objectStoreNames.contains(storeName)) {\n      upgradeDatabase.createObjectStore(storeName);\n    }\n  });\n  if (database.objectStoreNames.contains(storeName)) return database;\n\n  const nextVersion = database.version + 1;\n  database.close();\n  return openDatabase(databaseName, nextVersion, (upgradeDatabase) => {\n    if (!upgradeDatabase.objectStoreNames.contains(storeName)) {\n      upgradeDatabase.createObjectStore(storeName);\n    }\n  });\n}\n\nfunction openDatabase(\n  databaseName: string,\n  version: number | undefined,\n  upgrade: (database: IDBDatabase) => void,\n): Promise<IDBDatabase> {\n  return new Promise((resolve, reject) => {\n    const request =\n      version === undefined ? indexedDB.open(databaseName) : indexedDB.open(databaseName, version);\n    let settled = false;\n\n    request.onupgradeneeded = () => upgrade(request.result);\n    request.onsuccess = () => {\n      if (settled) {\n        request.result.close();\n        return;\n      }\n      settled = true;\n      resolve(request.result);\n    };\n    request.onerror = () => {\n      if (settled) return;\n      settled = true;\n      reject(request.error ?? new Error(`Could not open IndexedDB database ${databaseName}.`));\n    };\n    request.onblocked = () => {\n      if (settled) return;\n      settled = true;\n      reject(new Error(`IndexedDB database ${databaseName} is blocked by another open page.`));\n    };\n  });\n}\n\nfunction requestResult<T>(request: IDBRequest<T>): Promise<T> {\n  return new Promise((resolve, reject) => {\n    request.onsuccess = () => resolve(request.result);\n    request.onerror = () => reject(request.error ?? new Error('IndexedDB request failed.'));\n  });\n}\n\nfunction waitForTransaction(transaction: IDBTransaction): Promise<void> {\n  return new Promise((resolve, reject) => {\n    transaction.oncomplete = () => resolve();\n    transaction.onabort = () =>\n      reject(transaction.error ?? new Error('IndexedDB transaction was aborted.'));\n    transaction.onerror = () =>\n      reject(transaction.error ?? new Error('IndexedDB transaction failed.'));\n  });\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-U722UUFN.js

@@ -0,0 +1,9 @@
+// src/filesystem/internal/records.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+
+export {
+  isRecord
+};
+//# sourceMappingURL=chunk-U722UUFN.js.map

package/dist/chunk-U722UUFN.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/filesystem/internal/records.ts"],"sourcesContent":["/**\n * Structural guard shared by the filesystem providers that validate untrusted\n * payloads — stored IndexedDB records and Electron transport messages.\n */\n\n/** True for any non-null object, including arrays and class instances. */\nexport function isRecord(value: unknown): value is Record<string, unknown> {\n  return typeof value === 'object' && value !== null;\n}\n"],"mappings":";AAMO,SAAS,SAAS,OAAkD;AACzE,SAAO,OAAO,UAAU,YAAY,UAAU;AAChD;","names":[]}

package/dist/chunk-VTCSF7VS.js

@@ -0,0 +1,553 @@
+import {
+  ELECTRON_FILE_SYSTEM_V2_CAPABILITIES,
+  maybeGetDocBlocksHost
+} from "./chunk-BNKV7MTO.js";
+import {
+  isRecord
+} from "./chunk-U722UUFN.js";
+import {
+  compareSnapshotsByPath,
+  compareText,
+  copyBytes,
+  parseFileSystemVersion
+} from "./chunk-P4WATND4.js";
+import {
+  FsError,
+  WORKSPACE_ROOT,
+  deserializeFsError,
+  fsErrorFromUnknown,
+  isSerializedFsError,
+  parseWorkspacePath,
+  workspacePathBasename,
+  workspacePathDirname
+} from "./chunk-JS6XFWQK.js";
+
+// src/filesystem/electron-provider-v2.ts
+var 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;
+}
+var ElectronFileSystemProviderV2 = class {
+  constructor(id, label, rootPath) {
+    this.capabilities = ELECTRON_FILE_SYSTEM_V2_CAPABILITIES;
+    this.instanceId = createInstanceId();
+    this.watchers = /* @__PURE__ */ new Map();
+    this.subscriptions = /* @__PURE__ */ new Set();
+    this.inFlight = /* @__PURE__ */ 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 {
+      }
+      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(() => void 0);
+          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 {
+          }
+        }
+        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 {
+      }
+      return;
+    }
+    let event;
+    try {
+      event = normalizeWatchEvent(message.event);
+    } catch (error) {
+      try {
+        watcher.onError?.(transportErrorFromUnknown(error, "watch"));
+      } catch {
+      }
+      return;
+    }
+    try {
+      watcher.listener(event);
+    } catch {
+    }
+  }
+  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 = /* @__PURE__ */ 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(compareSnapshotsByPath);
+  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 = /* @__PURE__ */ 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 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 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 ?? void 0,
+    destinationPath: error.destinationPath ?? void 0,
+    retryable: error.retryable
+  });
+}
+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}`;
+}
+
+// src/filesystem/electron-provider.ts
+function getHostFs() {
+  const host = maybeGetDocBlocksHost();
+  if (!host) {
+    throw new Error(
+      "ElectronFileSystemProvider: docBlocksHost is not available \u2014 not running under Electron?"
+    );
+  }
+  return host.fs;
+}
+var ElectronFileSystemProvider = class {
+  constructor(id, label, rootPath) {
+    this.id = id;
+    this.label = label;
+    this.rootPath = rootPath;
+    this.v2 = new ElectronFileSystemProviderV2(id, label, rootPath);
+  }
+  /** Absolute path this provider is rooted at. */
+  getRootPath() {
+    return this.rootPath;
+  }
+  readFile(path) {
+    return getHostFs().readFile(this.id, path);
+  }
+  writeFile(path, content) {
+    return getHostFs().writeFile(this.id, path, content);
+  }
+  commitFile(path, content, expectedContent) {
+    return getHostFs().commitFile(this.id, path, content, expectedContent);
+  }
+  delete(path) {
+    return getHostFs().delete(this.id, path);
+  }
+  rename(oldPath, newPath) {
+    return getHostFs().rename(this.id, oldPath, newPath);
+  }
+  readDirectory(path) {
+    return getHostFs().readDirectory(this.id, path);
+  }
+  exists(path) {
+    return getHostFs().exists(this.id, path);
+  }
+  createDirectory(path) {
+    return getHostFs().createDirectory(this.id, path);
+  }
+  stat(path) {
+    return getHostFs().stat(this.id, path);
+  }
+  readBinary(path) {
+    return getHostFs().readBinary(this.id, path);
+  }
+  writeBinary(path, data) {
+    return getHostFs().writeBinary(this.id, path, data);
+  }
+  /** Subscribe to external change notifications under this root. */
+  watch(onChange) {
+    return getHostFs().watch(this.id, onChange);
+  }
+};
+
+export {
+  ElectronFileSystemProviderV2,
+  ElectronFileSystemProvider
+};
+//# sourceMappingURL=chunk-VTCSF7VS.js.map