@bendyline/docblocks 2.0.0 → 2.1.1

package/README.md

@@ -55,8 +55,8 @@ compatibility `filesystem` barrel still re-exports every provider, but eagerly
 constructing from that barrel puts mutually exclusive backends in one startup
 bundle.
 
-Mutation behavior is explicit: `writeFile` requires a `create`, `replace`, or
-`upsert` mode; `remove` distinguishes an empty-directory removal from a
+Mutation behavior is explicit: `writeFile` accepts a `create`, `replace`, or
+`upsert` mode and defaults to `upsert` when omitted; `remove` distinguishes an empty-directory removal from a
 recursive tree removal; and `move` never overwrites its destination. Missing
 entries are returned as `null` only by `stat` and `readFile`. Permission,
 wrong-kind, conflict, quota, and I/O failures remain typed `FsError`s.

package/dist/{chunk-2D7Y4IR3.js → chunk-4437YWLE.js}

@@ -1,9 +1,19 @@
 import {
   withFileCommitLock
-} from "./chunk-AEHCVWU5.js";
+} from "./chunk-DZB666V7.js";
 import {
+  parentChain
+} from "./chunk-KQ6756AJ.js";
+import {
+  bytesEqual,
+  compareSnapshotsByName,
+  compareText,
+  copyBytes,
   parseFileSystemVersion
-} from "./chunk-AYZ4HN5M.js";
+} from "./chunk-M62ZGJ5I.js";
+import {
+  decodeUtf8Text
+} from "./chunk-M5ZNQGR5.js";
 import {
   FsError,
   WORKSPACE_ROOT,
@@ -13,7 +23,7 @@ import {
   workspacePathContains,
   workspacePathDirname,
   workspacePathJoin
-} from "./chunk-SI2LU2RP.js";
+} from "./chunk-AYWKIZLD.js";
 
 // src/filesystem/native-provider-v2.ts
 var NativeFileSystemMoveRecoveryError = class extends FsError {
@@ -102,7 +112,7 @@ var NativeFileSystemProviderV2 = class {
           withoutData((await this.scanMetadataHandle(childPath, childHandle, "list")).root)
         );
       }
-      children.sort(compareSnapshots);
+      children.sort(compareSnapshotsByName);
       return Object.freeze(children);
     });
   }
@@ -141,7 +151,7 @@ var NativeFileSystemProviderV2 = class {
         await this.writeBytes(canonical, ownedData);
         writeCompleted = true;
         const written = await this.requireSnapshot(canonical, "write");
-        if (written.root.kind !== "file" || !equalBytes(written.root.data, ownedData)) {
+        if (written.root.kind !== "file" || !bytesEqual(written.root.data, ownedData)) {
           throw this.error(
             "conflict",
             "write",
@@ -282,7 +292,7 @@ var NativeFileSystemProviderV2 = class {
       }
       const createdParents = await this.createDirectories(missingParents);
       let destinationVersion = null;
-      let sourceDeleted = false;
+      let sourceDeleteAttempted = false;
       try {
         await this.writeTree(source, sourcePath, destinationPath);
         const copied = await this.requireSnapshot(destinationPath, "move");
@@ -302,8 +312,15 @@ var NativeFileSystemProviderV2 = class {
             destinationPath
           });
         }
+        if (!await this.matchesCapturedSource(sourcePath, source)) {
+          throw new FsError("conflict", "Source changed while the move was copied.", {
+            operation: "move",
+            path: sourcePath,
+            destinationPath
+          });
+        }
+        sourceDeleteAttempted = true;
         await this.removeEntry(sourcePath, source.root.kind === "directory");
-        sourceDeleted = true;
         const [sourceAfter, destinationAfter] = await Promise.all([
           this.tryScanMetadata(sourcePath, "move"),
           this.tryScanMetadata(destinationPath, "move")
@@ -323,7 +340,7 @@ var NativeFileSystemProviderV2 = class {
           source,
           createdParents,
           destinationVersion,
-          sourceDeleted,
+          sourceDeleteAttempted,
           error
         );
       }
@@ -513,7 +530,7 @@ var NativeFileSystemProviderV2 = class {
         await this.scanHandle(workspacePathJoin(path, name), childHandle, operation, scanFile)
       );
     }
-    const childRoots = children.map((child) => child.root).sort(compareSnapshots);
+    const childRoots = children.map((child) => child.root).sort(compareSnapshotsByName);
     const version = await metadataVersion(
       "directory",
       new TextEncoder().encode(
@@ -574,6 +591,25 @@ var NativeFileSystemProviderV2 = class {
       kind: "file",
       path,
       name: workspacePathBasename(path),
+      // Derived from size + mtime, never from content. This keeps stat/list
+      // proportional to entry count instead of bytes (see scanMetadataHandle),
+      // which is what makes large workspaces listable in a browser tab at all.
+      //
+      // The cost is a real blind spot: an external same-size rewrite inside one
+      // mtime tick is invisible here. FAT/exFAT stamp mtime at 2-second
+      // granularity, and network shares can be coarser, so this is reachable on
+      // removable and mounted volumes rather than merely theoretical. Two
+      // consequences follow, and neither is hypothetical:
+      //   - a conditional write guarded on expectedVersion accepts, silently
+      //     overwriting the external edit;
+      //   - move() re-checks this version to prove the source is unchanged
+      //     before deleting it, so it can delete a source whose bytes it never
+      //     copied, losing the edit outright.
+      // `conditionalWrite: 'process'` declares the first (expectedVersion binds
+      // only against writers in this process). The second is a provider-internal
+      // check that the token cannot actually support; closing it means
+      // byte-comparing the captured source before the delete, not hashing
+      // content here, which would undo the scan-by-metadata property above.
       size: file.size,
       version: await metadataVersion(
         "file",
@@ -663,28 +699,44 @@ var NativeFileSystemProviderV2 = class {
       if (entry.kind === "file") await this.writeBytes(path, entry.data);
     }
   }
-  async rollbackMoveAndThrow(sourcePath, destinationPath, source, createdParents, destinationVersion, sourceDeleted, primary) {
+  async rollbackMoveAndThrow(sourcePath, destinationPath, source, createdParents, destinationVersion, sourceDeleteAttempted, primary) {
     const primaryError = this.translateError(primary, "move", sourcePath, destinationPath);
     const recoveryErrors = [];
-    const sourceCurrent = await this.probeScan(sourcePath);
-    if (sourceCurrent === null && sourceDeleted) {
-      try {
-        await this.writeTree(source, sourcePath, sourcePath);
-        const restored = await this.probeSnapshot(sourcePath);
-        if (!restored || !equalTreeContents(source, sourcePath, restored, sourcePath)) {
-          throw new FsError("conflict", "Restored source does not match its captured state.", {
-            operation: "move",
-            path: sourcePath,
-            destinationPath
-          });
+    let sourceWhole = true;
+    if (sourceDeleteAttempted) {
+      sourceWhole = await this.matchesCapturedSource(sourcePath, source);
+      if (!sourceWhole) {
+        try {
+          await this.writeTree(source, sourcePath, sourcePath);
+          const restored = await this.probeSnapshot(sourcePath);
+          if (!restored || !equalTreeContents(source, sourcePath, restored, sourcePath)) {
+            throw new FsError("conflict", "Restored source does not match its captured state.", {
+              operation: "move",
+              path: sourcePath,
+              destinationPath
+            });
+          }
+          sourceWhole = true;
+        } catch (error) {
+          recoveryErrors.push(this.translateError(error, "move", sourcePath, destinationPath));
         }
-      } catch (error) {
-        recoveryErrors.push(this.translateError(error, "move", sourcePath, destinationPath));
       }
     }
     const destinationCurrent = await this.probeScan(destinationPath);
     if (destinationCurrent) {
-      if (destinationVersion && destinationCurrent.root.version !== destinationVersion) {
+      if (!sourceWhole) {
+        recoveryErrors.push(
+          new FsError(
+            "conflict",
+            "Source is incomplete; rollback kept the copy at the destination.",
+            {
+              operation: "move",
+              path: sourcePath,
+              destinationPath
+            }
+          )
+        );
+      } else if (destinationVersion && destinationCurrent.root.version !== destinationVersion) {
         recoveryErrors.push(
           new FsError("conflict", "Destination changed; rollback will not delete it.", {
             operation: "move",
@@ -716,6 +768,18 @@ var NativeFileSystemProviderV2 = class {
       state
     );
   }
+  /**
+   * Whether the source still holds exactly the bytes the move captured.
+   *
+   * A probe that fails answers "no": rollback must never treat an unverifiable
+   * source as whole, because that is precisely what licenses deleting the copy
+   * at the destination.
+   */
+  async matchesCapturedSource(sourcePath, source) {
+    const current = await this.probeSnapshot(sourcePath);
+    if (!current) return false;
+    return equalTreeContents(source, sourcePath, current, sourcePath);
+  }
   async probeScan(path) {
     try {
       return await this.tryScanMetadata(path, "move");
@@ -784,15 +848,6 @@ async function metadataVersion(kind, metadata, operation, path) {
   const hex = [...new Uint8Array(digest)].map((value) => value.toString(16).padStart(2, "0")).join("");
   return parseFileSystemVersion(`sha256:${hex}`);
 }
-function parentChain(path) {
-  const parents = [];
-  let current = workspacePathDirname(path);
-  while (current) {
-    parents.unshift(current);
-    current = workspacePathDirname(current);
-  }
-  return parents;
-}
 function pathDepth(path) {
   return path ? path.split("/").length : 0;
 }
@@ -805,17 +860,6 @@ function isMissingOrKindError(error) {
   const name = errorName(error);
   return name === "NotFoundError" || name === "TypeMismatchError";
 }
-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 equalBytes(left, right) {
-  const leftBytes = new Uint8Array(left);
-  const rightBytes = new Uint8Array(right);
-  return leftBytes.byteLength === rightBytes.byteLength && leftBytes.every((value, index) => value === rightBytes[index]);
-}
 function equalTreeContents(left, leftRoot, right, rightRoot) {
   if (left.entries.length !== right.entries.length) return false;
   const rightByRelativePath = /* @__PURE__ */ new Map();
@@ -830,7 +874,7 @@ function equalTreeContents(left, leftRoot, right, rightRoot) {
     const counterpart = rightByRelativePath.get(relativePath);
     if (!counterpart || counterpart.kind !== entry.kind) return false;
     if (entry.kind === "file") {
-      if (counterpart.kind !== "file" || !equalBytes(entry.data, counterpart.data)) return false;
+      if (counterpart.kind !== "file" || !bytesEqual(entry.data, counterpart.data)) return false;
     }
   }
   return true;
@@ -871,13 +915,6 @@ function newestLastModified(children) {
   }
   return newest ? new Date(newest).toISOString() : EPOCH;
 }
-function compareSnapshots(left, right) {
-  if (left.kind !== right.kind) return left.kind === "directory" ? -1 : 1;
-  return compareText(left.name, right.name);
-}
-function compareText(left, right) {
-  return left < right ? -1 : left > right ? 1 : 0;
-}
 
 // src/filesystem/native-provider.ts
 function isNativeFileSystemSupported() {
@@ -950,6 +987,21 @@ function isMissingEntryError(error) {
   const name = errorName2(error);
   return name === "NotFoundError" || name === "TypeMismatchError";
 }
+function isKindMismatchError(error) {
+  return errorName2(error) === "TypeMismatchError";
+}
+function rootIsNotAMutationTarget(operation, path) {
+  return new FsError("invalid-path", "The workspace root is not a file entry.", {
+    operation,
+    path
+  });
+}
+function notAFile(operation, path) {
+  return new FsError("type-mismatch", "Expected a file but found a directory.", {
+    operation,
+    path
+  });
+}
 function isPermissionError(error) {
   const name = errorName2(error);
   return name === "NotAllowedError" || name === "SecurityError";
@@ -1036,22 +1088,16 @@ var NativeFileSystemProvider = class {
   }
   async readFile(path) {
     const p = normalisePath(path);
-    const dir = await resolveDir(this.root, parentDir(p));
-    if (!dir) return null;
-    try {
-      const fileHandle = await dir.getFileHandle(baseName(p));
-      const file = await fileHandle.getFile();
-      return file.text();
-    } catch (error) {
-      if (isMissingEntryError(error)) return null;
-      throw error;
-    }
+    const data = await this.readBinary(p);
+    if (data === null) return null;
+    return decodeUtf8Text(data, { label: "The file", operation: "read", path: p });
   }
   async writeFile(path, content) {
     return this.withMutationLock(() => this.writeFileUnlocked(path, content));
   }
   async writeFileUnlocked(path, content) {
     const p = normalisePath(path);
+    if (!p) throw rootIsNotAMutationTarget("write", path);
     const dir = await resolveDirCreate(this.root, parentDir(p));
     const fileHandle = await dir.getFileHandle(baseName(p), { create: true });
     const writable = await fileHandle.createWritable();
@@ -1079,7 +1125,7 @@ var NativeFileSystemProvider = class {
   }
   async deleteUnlocked(path) {
     const p = normalisePath(path);
-    if (!p) throw new Error("Cannot delete the filesystem root");
+    if (!p) throw rootIsNotAMutationTarget("remove", path);
     const parent = parentDir(p);
     const name = baseName(p);
     const dir = await resolveDir(this.root, parent);
@@ -1098,9 +1144,7 @@ var NativeFileSystemProvider = class {
     const op = normalisePath(oldPath);
     const np = normalisePath(newPath);
     if (op === np) return;
-    if (!op || !np) {
-      throw new Error("Cannot rename the filesystem root");
-    }
+    if (!op || !np) throw rootIsNotAMutationTarget("move", !op ? oldPath : newPath);
     if (np.startsWith(op + "/")) {
       throw new Error("Cannot move a directory into itself");
     }
@@ -1154,6 +1198,14 @@ var NativeFileSystemProvider = class {
     try {
       await this.deleteUnlocked(op);
     } catch (error) {
+      try {
+        await this.copyDirectory(np, op);
+      } catch (restoreError) {
+        throw new NativeMoveRecoveryError(
+          `Move partially deleted the source and it could not be restored; the copy at ${newPath} was kept: ${oldPath} -> ${newPath}`,
+          [error, restoreError]
+        );
+      }
       try {
         await this.deleteUnlocked(np);
       } catch (rollbackError) {
@@ -1186,6 +1238,7 @@ var NativeFileSystemProvider = class {
   }
   async exists(path) {
     const p = normalisePath(path);
+    if (!p) return true;
     const parent = parentDir(p);
     const name = baseName(p);
     const dir = await resolveDir(this.root, parent);
@@ -1212,6 +1265,7 @@ var NativeFileSystemProvider = class {
   }
   async stat(path) {
     const p = normalisePath(path);
+    if (!p) return null;
     const dir = await resolveDir(this.root, parentDir(p));
     if (!dir) return null;
     try {
@@ -1230,6 +1284,7 @@ var NativeFileSystemProvider = class {
   }
   async readBinary(path) {
     const p = normalisePath(path);
+    if (!p) throw notAFile("read", p);
     const dir = await resolveDir(this.root, parentDir(p));
     if (!dir) return null;
     try {
@@ -1237,6 +1292,7 @@ var NativeFileSystemProvider = class {
       const file = await fileHandle.getFile();
       return file.arrayBuffer();
     } catch (error) {
+      if (isKindMismatchError(error)) throw notAFile("read", p);
       if (isMissingEntryError(error)) return null;
       throw error;
     }
@@ -1246,6 +1302,7 @@ var NativeFileSystemProvider = class {
   }
   async writeBinaryUnlocked(path, data) {
     const p = normalisePath(path);
+    if (!p) throw rootIsNotAMutationTarget("write", path);
     const dir = await resolveDirCreate(this.root, parentDir(p));
     const fileHandle = await dir.getFileHandle(baseName(p), { create: true });
     const writable = await fileHandle.createWritable();
@@ -1290,4 +1347,3 @@ export {
   openNativeFolder,
   restoreNativeFolder
 };
-//# sourceMappingURL=chunk-2D7Y4IR3.js.map

package/dist/{chunk-5MYAICRE.js → chunk-45T5AFCN.js}

@@ -1,12 +1,19 @@
 import {
+  guessMimeType
+} from "./chunk-YM7O3PWO.js";
+import {
+  bytesEqual,
+  compareSnapshotsByName,
+  compareText,
+  copyBytes,
   parseFileSystemVersion
-} from "./chunk-AYZ4HN5M.js";
+} from "./chunk-M62ZGJ5I.js";
 import {
   FileSystemMoveRecoveryError,
   FileSystemPartialMoveError,
   describeEntryMove,
   describePartialMove
-} from "./chunk-EGNDADXB.js";
+} from "./chunk-QI6YKTQV.js";
 import {
   FsError,
   WORKSPACE_ROOT,
@@ -17,10 +24,10 @@ import {
   workspacePathDirname,
   workspacePathJoin,
   workspacePathToLegacy
-} from "./chunk-SI2LU2RP.js";
+} from "./chunk-AYWKIZLD.js";
 import {
   getFileSystemProviderV2
-} from "./chunk-EZKJZUNJ.js";
+} from "./chunk-XAMILHQP.js";
 
 // src/filesystem/legacy-v2-adapter.ts
 var EPOCH = (/* @__PURE__ */ new Date(0)).toISOString();
@@ -76,7 +83,7 @@ var LegacyFileSystemProviderV2Adapter = class {
       if (entry.kind !== "directory") {
         throw this.error("type-mismatch", "list", canonical, "Expected a directory, found a file.");
       }
-      const children = [...tree.entries.entries()].filter(([entryPath]) => entryPath && workspacePathDirname(entryPath) === canonical).map(([, child]) => copyEntrySnapshot(child)).sort(compareSnapshots);
+      const children = [...tree.entries.entries()].filter(([entryPath]) => entryPath && workspacePathDirname(entryPath) === canonical).map(([, child]) => copyEntrySnapshot(child)).sort(compareSnapshotsByName);
       return Object.freeze(children);
     });
   }
@@ -109,7 +116,7 @@ var LegacyFileSystemProviderV2Adapter = class {
         canonical
       );
       const written = (await this.captureTree("write")).entries.get(canonical);
-      if (written?.kind !== "file" || !equalBytes(written.data, ownedData)) {
+      if (written?.kind !== "file" || !bytesEqual(written.data, ownedData)) {
         throw this.error(
           "io",
           "write",
@@ -435,7 +442,7 @@ var LegacyFileSystemProviderV2Adapter = class {
           children.push(file);
         }
       }
-      children.sort(compareSnapshots);
+      children.sort(compareSnapshotsByName);
       const version = await contentVersion(
         "directory",
         new TextEncoder().encode(
@@ -543,17 +550,6 @@ function isLegacyEntry(value) {
   const candidate = value;
   return (candidate.kind === "file" || candidate.kind === "directory") && typeof candidate.name === "string" && typeof candidate.path === "string";
 }
-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 equalBytes(left, right) {
-  const leftBytes = new Uint8Array(left);
-  const rightBytes = new Uint8Array(right);
-  return leftBytes.byteLength === rightBytes.byteLength && leftBytes.every((value, index) => value === rightBytes[index]);
-}
 function fileMetadata(file) {
   return Object.freeze({
     kind: "file",
@@ -581,13 +577,6 @@ function newestLastModified(children) {
   }
   return newest ? new Date(newest).toISOString() : EPOCH;
 }
-function compareSnapshots(left, right) {
-  if (left.kind !== right.kind) return left.kind === "directory" ? -1 : 1;
-  return compareText(left.name, right.name);
-}
-function compareText(left, right) {
-  return left < right ? -1 : left > right ? 1 : 0;
-}
 
 // src/filesystem/move-entry.ts
 function normalisePath(path) {
@@ -690,7 +679,10 @@ async function moveFileSystemEntry(provider, oldPath, newPath, kind) {
 
 // src/filesystem/dbk-workspace.ts
 function normaliseRelativePath(path, label) {
-  if (path.includes("\\") || path.includes("\0")) {
+  if (path.includes("\\") || /^[a-zA-Z]:/u.test(path) || [...path].some((character) => {
+    const codePoint = character.codePointAt(0) ?? 0;
+    return codePoint <= 31 || codePoint === 127;
+  })) {
     throw new Error(`DBK ${label} must use a safe forward-slash path: ${path}`);
   }
   const normalized = path.replace(/^\/+|\/+$/g, "").replace(/\/+/g, "/");
@@ -700,6 +692,18 @@ function normaliseRelativePath(path, label) {
   }
   return segments.join("/");
 }
+function decodeMarkdownFile(data, path) {
+  let content;
+  try {
+    content = new TextDecoder("utf-8", { fatal: true }).decode(data);
+  } catch {
+    throw new Error(`The external DBK contains invalid UTF-8 Markdown: ${path}`);
+  }
+  if (content.includes("\0")) {
+    throw new Error(`The external DBK contains a NUL character in Markdown: ${path}`);
+  }
+  return content;
+}
 function joinPath(parent, child) {
   return `${parent.replace(/\/+$/g, "")}/${child.replace(/^\/+/, "")}`;
 }
@@ -721,6 +725,7 @@ async function createDbkWorkspaceSnapshot(source, options) {
   const listed = await source.listFiles();
   const entries = [...listed].sort((a, b) => a.path.localeCompare(b.path));
   const seenSourcePaths = /* @__PURE__ */ new Set();
+  const validatedEntries = [];
   const files = [];
   let documentContent = null;
   for (const entry of entries) {
@@ -729,21 +734,27 @@ async function createDbkWorkspaceSnapshot(source, options) {
       throw new Error(`The external DBK contains duplicate paths: ${sourcePath}`);
     }
     seenSourcePaths.add(sourcePath);
-    const data = await source.readFile(entry.path);
+    if (!/\.md$/iu.test(sourcePath)) {
+      throw new Error(
+        `The external DBK is corrupt: only Markdown (.md) files are allowed (${sourcePath}).`
+      );
+    }
+    validatedEntries.push({ sourcePath, containerPath: entry.path });
+  }
+  for (const entry of validatedEntries) {
+    const { sourcePath } = entry;
+    const data = await source.readFile(entry.containerPath);
     if (data === null) {
       throw new Error(`The external DBK changed while reading: ${sourcePath}`);
     }
+    const content = decodeMarkdownFile(data, sourcePath);
     if (sourcePath === sourceDocumentPath) {
-      documentContent = new TextDecoder().decode(data);
+      documentContent = content;
       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 });
-    }
+    files.push({ kind: "text", path: targetPath, content });
   }
   if (documentContent === null) {
     throw new Error(`The external DBK did not include its primary document: ${sourceDocumentPath}`);
@@ -765,29 +776,6 @@ async function replaceMemoryWorkspaceFromDbk(provider, source, options) {
 
 // src/filesystem/filesystem-content-container.ts
 import { findDocumentPath } from "@bendyline/squisq/storage";
-var EXTENSION_MIME_MAP = {
-  ".md": "text/markdown",
-  ".txt": "text/plain",
-  ".json": "application/json",
-  ".jpg": "image/jpeg",
-  ".jpeg": "image/jpeg",
-  ".png": "image/png",
-  ".gif": "image/gif",
-  ".svg": "image/svg+xml",
-  ".webp": "image/webp",
-  ".avif": "image/avif",
-  ".mp4": "video/mp4",
-  ".webm": "video/webm",
-  ".mp3": "audio/mpeg",
-  ".wav": "audio/wav",
-  ".ogg": "audio/ogg"
-};
-function guessMimeType(path) {
-  const dot = path.lastIndexOf(".");
-  if (dot === -1) return "application/octet-stream";
-  const ext = path.slice(dot).toLowerCase();
-  return EXTENSION_MIME_MAP[ext] ?? "application/octet-stream";
-}
 function joinPrefix(prefix, p) {
   return workspacePathJoin(parseWorkspacePath(prefix), p);
 }
@@ -954,4 +942,3 @@ export {
   FileSystemContentContainer,
   createFileMediaProvider
 };
-//# sourceMappingURL=chunk-5MYAICRE.js.map

package/dist/{chunk-PGR7LK6D.js → chunk-6L3JRDE7.js}

@@ -1,13 +1,16 @@
 import {
   isFileSystemMoveStateError
-} from "./chunk-EGNDADXB.js";
+} from "./chunk-QI6YKTQV.js";
+import {
+  decodeUtf8Text
+} from "./chunk-M5ZNQGR5.js";
 import {
   FsError,
   parseWorkspacePath
-} from "./chunk-SI2LU2RP.js";
+} from "./chunk-AYWKIZLD.js";
 import {
   getFileSystemProviderV2
-} from "./chunk-EZKJZUNJ.js";
+} from "./chunk-XAMILHQP.js";
 
 // src/document/document-session.ts
 var DEFAULT_AUTO_SAVE_RETRY_DELAYS_MS = [1e3, 3e3, 1e4];
@@ -668,7 +671,10 @@ function createFileSystemDocumentTarget(provider, path, options = {}) {
     async commit(request) {
       if (providerV2 && providerV2.capabilities.conditionalWrite !== "none") {
         const current = await providerV2.readFile(canonicalPath);
-        const currentContent = current ? new TextDecoder().decode(current.data) : null;
+        const currentContent = current ? decodeUtf8Text(current.data, {
+          label: "The external document",
+          path: canonicalPath
+        }) : null;
         if (currentContent !== request.persistedContent && currentContent !== request.content) {
           throw new DocumentCommitConflictError(
             "The document changed outside DocBlocks: " + path,
@@ -697,7 +703,10 @@ function createFileSystemDocumentTarget(provider, path, options = {}) {
             const external = await providerV2.readFile(canonicalPath);
             throw new DocumentCommitConflictError(
               "The document changed outside DocBlocks: " + path,
-              external ? new TextDecoder().decode(external.data) : null,
+              external ? decodeUtf8Text(external.data, {
+                label: "The external document",
+                path: canonicalPath
+              }) : null,
               external?.entry.version ?? null
             );
           }
@@ -1059,4 +1068,3 @@ export {
   DocumentRecoveryJournal,
   getDefaultDocumentRecoveryStorage
 };
-//# sourceMappingURL=chunk-PGR7LK6D.js.map

package/dist/{chunk-RVQHY3XU.js → chunk-6XHOOBYF.js}

@@ -34,4 +34,3 @@ export {
   getDocBlocksHost,
   maybeGetDocBlocksHost
 };
-//# sourceMappingURL=chunk-RVQHY3XU.js.map

package/dist/chunk-73OOROXH.js

@@ -0,0 +1,8 @@
+// src/filesystem/internal/records.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+
+export {
+  isRecord
+};

package/dist/{chunk-SI2LU2RP.js → chunk-AYWKIZLD.js}

@@ -8,6 +8,7 @@ var FS_ERROR_CODES = /* @__PURE__ */ new Set([
   "not-empty",
   "permission-denied",
   "conflict",
+  "corrupt",
   "quota-exceeded",
   "not-supported",
   "busy",
@@ -221,4 +222,3 @@ export {
   workspacePathBasename,
   workspacePathContains
 };
-//# sourceMappingURL=chunk-SI2LU2RP.js.map