@bendyline/docblocks 2.6.2 → 2.7.0

package/dist/{chunk-5MJC4KOE.js → chunk-L6PRMR7T.js}

@@ -1,22 +1,26 @@
 import {
-  ELECTRON_FILE_SYSTEM_V2_CAPABILITIES,
   FILE_SYSTEM_TRANSFER_LIMITS,
   maybeGetDocBlocksHost
-} from "./chunk-KFWPPIJH.js";
+} from "./chunk-YNUQG4GF.js";
+import {
+  parseFileSystemCapabilities
+} from "./chunk-245W57QP.js";
 import {
   HOST_WIRE_LIMITS,
   isBoundedBytePayload,
   isBoundedString
-} from "./chunk-2WDJ27EH.js";
+} 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,
@@ -28,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();
@@ -54,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;
@@ -62,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
     );
   }
@@ -71,11 +80,11 @@ var ElectronFileSystemProviderV2 = class {
     return this.request(
       "read",
       async () => {
-        const host = getHostFsV2("read");
+        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 > FILE_SYSTEM_TRANSFER_LIMITS.chunkBytes) {
+          if (stat?.kind === "file" && stat.size > this.limits.chunkBytes) {
             return { ok: true, value: await this.readTransferredFile(host, canonical) };
           }
         }
@@ -95,15 +104,15 @@ var ElectronFileSystemProviderV2 = class {
     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 > FILE_SYSTEM_TRANSFER_LIMITS.fileBytes) {
-      throw new FsError("quota-exceeded", "This file exceeds the 1 GiB desktop file limit.", {
+    if (data.byteLength > this.limits.fileBytes) {
+      throw new FsError("quota-exceeded", "This file exceeds this host\u2019s file size limit.", {
         operation: "write",
         path: canonical
       });
@@ -112,8 +121,8 @@ var ElectronFileSystemProviderV2 = class {
     return this.request(
       "write",
       async () => {
-        const host = getHostFsV2("write");
-        if (owned.byteLength > FILE_SYSTEM_TRANSFER_LIMITS.chunkBytes && host.beginWrite && host.writeChunk && host.finishWrite && host.closeTransfer) {
+        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),
@@ -121,13 +130,13 @@ var ElectronFileSystemProviderV2 = class {
             )
           );
           try {
-            for (let offset = 0; offset < owned.byteLength; offset += FILE_SYSTEM_TRANSFER_LIMITS.chunkBytes) {
+            for (let offset = 0; offset < owned.byteLength; offset += this.limits.chunkBytes) {
               unwrap(
                 await host.writeChunk(
                   this.instanceId,
                   id,
                   offset,
-                  owned.slice(offset, offset + FILE_SYSTEM_TRANSFER_LIMITS.chunkBytes)
+                  owned.slice(offset, offset + this.limits.chunkBytes)
                 ),
                 "write"
               );
@@ -140,7 +149,7 @@ var ElectronFileSystemProviderV2 = class {
         if (owned.byteLength > HOST_WIRE_LIMITS.binaryBytes) {
           throw new FsError(
             "not-supported",
-            "This desktop version does not support large file transfers. Update DocBlocks and retry."
+            "This host does not support large file transfers. Update DocBlocks and retry."
           );
         }
         return host.writeFile(this.instanceId, canonical, owned, options);
@@ -160,13 +169,13 @@ var ElectronFileSystemProviderV2 = class {
     const id = normalizeTransferId(transfer.transferId);
     try {
       const entry = normalizeFile(transfer.entry);
-      if (entry.path !== path || entry.size > FILE_SYSTEM_TRANSFER_LIMITS.fileBytes) {
+      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, FILE_SYSTEM_TRANSFER_LIMITS.chunkBytes) || chunk.byteLength === 0 || offset + chunk.byteLength > data.byteLength) {
+        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);
@@ -181,7 +190,7 @@ var ElectronFileSystemProviderV2 = class {
     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
     );
   }
@@ -189,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
     );
   }
@@ -198,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
     );
   }
@@ -220,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;
@@ -246,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"
             );
           }
@@ -272,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 {
@@ -305,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;
@@ -324,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)
     );
   }
@@ -355,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 });
@@ -525,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}.`);
     }
   }
@@ -576,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,