@bendyline/docblocks 2.6.1 → 2.7.0

package/dist/{chunk-BVY7GGNV.js → chunk-L6PRMR7T.js}

@@ -1,16 +1,26 @@
 import {
-  ELECTRON_FILE_SYSTEM_V2_CAPABILITIES,
+  FILE_SYSTEM_TRANSFER_LIMITS,
   maybeGetDocBlocksHost
-} from "./chunk-6XHOOBYF.js";
+} from "./chunk-YNUQG4GF.js";
+import {
+  parseFileSystemCapabilities
+} from "./chunk-245W57QP.js";
+import {
+  HOST_WIRE_LIMITS,
+  isBoundedBytePayload,
+  isBoundedString
+} from "./chunk-46AGYHDY.js";
 import {
   isRecord
 } from "./chunk-73OOROXH.js";
 import {
   compareSnapshotsByPath,
   compareText,
-  copyBytes,
+  copyBytes
+} from "./chunk-HABG2JM3.js";
+import {
   parseFileSystemVersion
-} from "./chunk-M62ZGJ5I.js";
+} from "./chunk-LPIJ6HKL.js";
 import {
   FsError,
   WORKSPACE_ROOT,
@@ -22,20 +32,19 @@ import {
   workspacePathDirname
 } from "./chunk-AYWKIZLD.js";
 
-// src/filesystem/electron-provider-v2.ts
+// src/filesystem/host-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.", {
+    throw new FsError("not-supported", "Native filesystem v2 host is unavailable.", {
       operation
     });
   }
   return host.fsV2;
 }
-var ElectronFileSystemProviderV2 = class {
-  constructor(id, label, rootPath) {
-    this.capabilities = ELECTRON_FILE_SYSTEM_V2_CAPABILITIES;
+var HostFileSystemProviderV2 = class {
+  constructor(id, label, rootPath, options) {
     this.instanceId = createInstanceId();
     this.watchers = /* @__PURE__ */ new Map();
     this.subscriptions = /* @__PURE__ */ new Set();
@@ -48,6 +57,12 @@ var ElectronFileSystemProviderV2 = class {
     this.id = id;
     this.label = label;
     this.rootPath = rootPath;
+    this.capabilities = parseFileSystemCapabilities(options.capabilities);
+    this.limits = options.limits ?? FILE_SYSTEM_TRANSFER_LIMITS;
+    if (!Number.isSafeInteger(this.limits.fileBytes) || this.limits.fileBytes < 1 || this.limits.fileBytes > FILE_SYSTEM_TRANSFER_LIMITS.fileBytes || !Number.isSafeInteger(this.limits.chunkBytes) || this.limits.chunkBytes < 1 || this.limits.chunkBytes > FILE_SYSTEM_TRANSFER_LIMITS.chunkBytes || this.limits.chunkBytes > this.limits.fileBytes) {
+      throw new TypeError("Invalid native filesystem transfer limits.");
+    }
+    this.transport = options.transport;
   }
   getRootPath() {
     return this.rootPath;
@@ -56,7 +71,7 @@ var ElectronFileSystemProviderV2 = class {
     const canonical = parseWorkspacePath(String(path));
     return this.request(
       "stat",
-      () => getHostFsV2("stat").stat(this.instanceId, canonical),
+      () => this.getTransport("stat").stat(this.instanceId, canonical),
       (value) => value ? normalizeEntry(value) : null
     );
   }
@@ -64,40 +79,118 @@ var ElectronFileSystemProviderV2 = class {
     const canonical = parseWorkspacePath(String(path));
     return this.request(
       "read",
-      () => getHostFsV2("read").readFile(this.instanceId, canonical),
-      (value) => {
-        if (!value) return null;
+      async () => {
+        const host = this.getTransport("read");
+        if (host.beginRead && host.readChunk && host.closeTransfer) {
+          const value2 = unwrap(await host.stat(this.instanceId, canonical), "read");
+          const stat = value2 ? normalizeEntry(value2) : null;
+          if (stat?.kind === "file" && stat.size > this.limits.chunkBytes) {
+            return { ok: true, value: await this.readTransferredFile(host, canonical) };
+          }
+        }
+        const value = unwrap(await host.readFile(this.instanceId, canonical), "read");
+        if (!value) return { ok: true, value: 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 });
-      }
+        return { ok: true, value: Object.freeze({ entry, data }) };
+      },
+      (value) => value
     );
   }
   async readDirectory(path) {
     const canonical = parseWorkspacePath(String(path));
     return this.request(
       "list",
-      () => getHostFsV2("list").readDirectory(this.instanceId, canonical),
+      () => this.getTransport("list").readDirectory(this.instanceId, canonical),
       (value) => normalizeDirectoryListing(value, canonical)
     );
   }
   async writeFile(path, data, options) {
     const canonical = parseWorkspacePath(String(path));
+    this.assertOpen("write");
+    if (data.byteLength > this.limits.fileBytes) {
+      throw new FsError("quota-exceeded", "This file exceeds this host\u2019s file size limit.", {
+        operation: "write",
+        path: canonical
+      });
+    }
     const owned = copyBytes(data);
     return this.request(
       "write",
-      () => getHostFsV2("write").writeFile(this.instanceId, canonical, owned, options),
+      async () => {
+        const host = this.getTransport("write");
+        if (owned.byteLength > this.limits.chunkBytes && host.beginWrite && host.writeChunk && host.finishWrite && host.closeTransfer) {
+          const id = normalizeTransferId(
+            unwrap(
+              await host.beginWrite(this.instanceId, canonical, owned.byteLength, options),
+              "write"
+            )
+          );
+          try {
+            for (let offset = 0; offset < owned.byteLength; offset += this.limits.chunkBytes) {
+              unwrap(
+                await host.writeChunk(
+                  this.instanceId,
+                  id,
+                  offset,
+                  owned.slice(offset, offset + this.limits.chunkBytes)
+                ),
+                "write"
+              );
+            }
+            return await host.finishWrite(this.instanceId, id);
+          } finally {
+            unwrap(await host.closeTransfer(this.instanceId, id), "write");
+          }
+        }
+        if (owned.byteLength > HOST_WIRE_LIMITS.binaryBytes) {
+          throw new FsError(
+            "not-supported",
+            "This host does not support large file transfers. Update DocBlocks and retry."
+          );
+        }
+        return host.writeFile(this.instanceId, canonical, owned, options);
+      },
       normalizeFile
     );
   }
+  async readTransferredFile(host, path) {
+    if (!host.beginRead || !host.readChunk || !host.closeTransfer) {
+      throw new FsError("not-supported", "Large file transfers are unavailable.");
+    }
+    const transfer = unwrap(await host.beginRead(this.instanceId, path), "read");
+    if (transfer === null) return null;
+    if (!isRecord(transfer) || Object.keys(transfer).some((key) => key !== "transferId" && key !== "entry")) {
+      throw new TypeError("Filesystem returned an invalid transfer.");
+    }
+    const id = normalizeTransferId(transfer.transferId);
+    try {
+      const entry = normalizeFile(transfer.entry);
+      if (entry.path !== path || entry.size > this.limits.fileBytes) {
+        throw new TypeError("Filesystem transfer returned an invalid file.");
+      }
+      const data = new Uint8Array(entry.size);
+      for (let offset = 0; offset < data.byteLength; ) {
+        const chunk = unwrap(await host.readChunk(this.instanceId, id, offset), "read");
+        if (!isBoundedBytePayload(chunk, this.limits.chunkBytes) || chunk.byteLength === 0 || offset + chunk.byteLength > data.byteLength) {
+          throw new TypeError("Filesystem transfer returned an invalid chunk.");
+        }
+        data.set(chunk instanceof Uint8Array ? chunk : new Uint8Array(chunk), offset);
+        offset += chunk.byteLength;
+      }
+      return Object.freeze({ entry, data: data.buffer });
+    } finally {
+      unwrap(await host.closeTransfer(this.instanceId, id), "read");
+    }
+  }
   async createDirectory(path, options) {
     const canonical = parseWorkspacePath(String(path));
     return this.request(
       "create-directory",
-      () => getHostFsV2("create-directory").createDirectory(this.instanceId, canonical, options),
+      () => this.getTransport("create-directory").createDirectory(this.instanceId, canonical, options),
       normalizeDirectory
     );
   }
@@ -105,7 +198,7 @@ var ElectronFileSystemProviderV2 = class {
     const canonical = parseWorkspacePath(String(path));
     return this.request(
       "remove",
-      () => getHostFsV2("remove").remove(this.instanceId, canonical, options),
+      () => this.getTransport("remove").remove(this.instanceId, canonical, options),
       normalizeRemoveResult
     );
   }
@@ -114,14 +207,14 @@ var ElectronFileSystemProviderV2 = class {
     const destination = parseWorkspacePath(String(newPath));
     return this.request(
       "move",
-      () => getHostFsV2("move").move(this.instanceId, source, destination, options),
+      () => this.getTransport("move").move(this.instanceId, source, destination, options),
       normalizeEntry
     );
   }
   async snapshot() {
     return this.request(
       "snapshot",
-      () => getHostFsV2("snapshot").snapshot(this.instanceId),
+      () => this.getTransport("snapshot").snapshot(this.instanceId),
       normalizeSnapshot
     );
   }
@@ -136,7 +229,10 @@ var ElectronFileSystemProviderV2 = class {
     let closePromise = null;
     const ready = this.ensureOpen("watch").then(async () => {
       if (closed) return;
-      unwrap(await getHostFsV2("watch").watchSubscribe(this.instanceId, subscriptionId), "watch");
+      unwrap(
+        await this.getTransport("watch").watchSubscribe(this.instanceId, subscriptionId),
+        "watch"
+      );
       subscribed = true;
     }).catch((error) => {
       closed = true;
@@ -162,7 +258,7 @@ var ElectronFileSystemProviderV2 = class {
           await ready.catch(() => void 0);
           if (subscribed) {
             unwrap(
-              await getHostFsV2("watch").watchUnsubscribe(this.instanceId, subscriptionId),
+              await this.getTransport("watch").watchUnsubscribe(this.instanceId, subscriptionId),
               "watch"
             );
           }
@@ -188,7 +284,7 @@ var ElectronFileSystemProviderV2 = class {
         }
         if (this.hostOpened) {
           try {
-            unwrap(await getHostFsV2("dispose").dispose(this.instanceId), "dispose");
+            unwrap(await this.getTransport("dispose").dispose(this.instanceId), "dispose");
           } catch (error) {
             if (!(error instanceof FsError && error.code === "closed")) throw error;
           } finally {
@@ -221,14 +317,14 @@ var ElectronFileSystemProviderV2 = class {
   ensureOpen(operation) {
     this.assertOpen(operation);
     if (!this.openPromise) {
-      const attempt = getHostFsV2(operation).open({
+      const attempt = this.getTransport(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);
+        assertCapabilities(capabilities, this.capabilities, operation);
       }).catch((error) => {
         const typed = withOperation(fsErrorFromUnknown(error, { operation }), operation);
         if (typed.retryable && this.openPromise === attempt) this.openPromise = null;
@@ -240,7 +336,7 @@ var ElectronFileSystemProviderV2 = class {
   }
   ensureWatchBridge() {
     if (this.removeWatchBridge) return;
-    this.removeWatchBridge = getHostFsV2("watch").onWatchMessage(
+    this.removeWatchBridge = this.getTransport("watch").onWatchMessage(
       (message) => this.handleWatchMessage(message)
     );
   }
@@ -271,6 +367,9 @@ var ElectronFileSystemProviderV2 = class {
     } catch {
     }
   }
+  getTransport(operation) {
+    return this.transport ?? getHostFsV2(operation);
+  }
   assertOpen(operation) {
     if (!this.disposed) return;
     throw new FsError("disposed", "Filesystem provider is disposed.", { operation });
@@ -291,6 +390,12 @@ function unwrap(result, operation) {
   }
   throw deserializeFsError(result.error);
 }
+function normalizeTransferId(value) {
+  if (!isBoundedString(value, HOST_WIRE_LIMITS.identifierCharacters, 1)) {
+    throw new TypeError("Filesystem returned an invalid transfer ID.");
+  }
+  return value;
+}
 function normalizeEntry(entry) {
   if (!isRecord(entry)) throw new TypeError("Expected a filesystem entry object.");
   if (typeof entry.path !== "string")
@@ -435,12 +540,10 @@ function normalizeRemoveResult(value) {
   }
   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]) {
+function assertCapabilities(input, expected, operation) {
+  const value = parseFileSystemCapabilities(input);
+  for (const key of Object.keys(expected)) {
+    if (value[key] !== expected[key]) {
       throw invalidTransport(operation, `Filesystem host capability mismatch: ${key}.`);
     }
   }
@@ -486,67 +589,6 @@ function createInstanceId() {
   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
+  HostFileSystemProviderV2
 };

package/dist/chunk-LPIJ6HKL.js

@@ -0,0 +1,19 @@
+// src/filesystem/v2.ts
+function parseFileSystemVersion(value) {
+  if (typeof value !== "string" || !value || value.length > 1024 || value.includes("\0")) {
+    throw new TypeError("Filesystem version tokens must be non-empty bounded strings.");
+  }
+  return value;
+}
+function tryParseFileSystemVersion(value) {
+  try {
+    return parseFileSystemVersion(value);
+  } catch {
+    return null;
+  }
+}
+
+export {
+  parseFileSystemVersion,
+  tryParseFileSystemVersion
+};

package/dist/{chunk-SJBB5OD7.js → chunk-QS5WTLUZ.js}

@@ -1,6 +1,6 @@
 import {
   RawIndexedDBFileSystemStore
-} from "./chunk-OQCPBOQA.js";
+} from "./chunk-DAPFSEKY.js";
 import {
   getFileSystemProviderV2
 } from "./chunk-XAMILHQP.js";
@@ -23,13 +23,14 @@ function parsePersistedWorkspace(value, index) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
     throw new Error(`Persisted workspace ${index} must be an object.`);
   }
-  const record = value;
+  const record = { ...value };
+  if (record.type === "electron-native") record.type = "host-native";
   const allowed = ["id", "name", "type", "lastOpened", "rootPath", "versioningOverride"];
   const unknownKey = Object.keys(record).find((key) => !allowed.includes(key));
   if (unknownKey) throw new Error(`Persisted workspace ${index} has unknown field ${unknownKey}.`);
   const id = boundedString(record.id, MAX_IDENTIFIER_CHARACTERS, `workspace ${index} id`);
   const name = boundedString(record.name, MAX_LABEL_CHARACTERS, `workspace ${index} name`);
-  if (record.type !== "indexeddb" && record.type !== "native" && record.type !== "electron-native") {
+  if (record.type !== "indexeddb" && record.type !== "native" && record.type !== "host-native") {
     throw new Error(`Persisted workspace ${index} has an invalid provider type.`);
   }
   const lastOpened = boundedString(
@@ -48,10 +49,10 @@ function parsePersistedWorkspace(value, index) {
       `workspace ${index} rootPath`
     );
   }
-  if (record.type === "electron-native" && descriptor.rootPath === void 0) {
+  if (record.type === "host-native" && descriptor.rootPath === void 0) {
     throw new Error(`Persisted Electron workspace ${index} is missing rootPath.`);
   }
-  if (record.type !== "electron-native" && descriptor.rootPath !== void 0) {
+  if (record.type !== "host-native" && descriptor.rootPath !== void 0) {
     throw new Error(`Persisted workspace ${index} must not contain rootPath.`);
   }
   if (record.versioningOverride !== void 0) {
@@ -181,13 +182,13 @@ function comparableRoot(rootPath, platform) {
   return platform === "win32" ? normalized.toLowerCase() : normalized;
 }
 function reconcileElectronWorkspaceDescriptors(local, hostWorkspaces, platform, now) {
-  const electron = local.filter((workspace) => workspace.type === "electron-native");
+  const electron = local.filter((workspace) => workspace.type === "host-native");
   const matchedLocalIds = /* @__PURE__ */ new Set();
   const idRemap = {};
   const upsert = hostWorkspaces.map((hostWorkspace) => {
     const root = comparableRoot(hostWorkspace.rootPath, platform);
     const candidates = electron.filter(
-      (workspace) => workspace.rootPath && comparableRoot(workspace.rootPath, platform) === root
+      (workspace) => workspace.id === hostWorkspace.id || platform !== "ios" && platform !== "android" && workspace.rootPath && comparableRoot(workspace.rootPath, platform) === root
     );
     const matching = candidates.sort(
       (left, right) => right.lastOpened.localeCompare(left.lastOpened)
@@ -199,7 +200,7 @@ function reconcileElectronWorkspaceDescriptors(local, hostWorkspaces, platform,
     return {
       id: hostWorkspace.id,
       name: matching?.name ?? hostWorkspace.name,
-      type: "electron-native",
+      type: "host-native",
       rootPath: hostWorkspace.rootPath,
       lastOpened: matching?.lastOpened ?? now,
       ...matching?.versioningOverride ? { versioningOverride: matching.versioningOverride } : {}
@@ -214,6 +215,7 @@ function reconcileElectronWorkspaceDescriptors(local, hostWorkspaces, platform,
 
 export {
   parsePersistedWorkspaceList,
+  DEFAULT_WORKSPACE_ID,
   registerTransientWorkspace,
   getTransientWorkspace,
   unregisterTransientWorkspace,