@bendyline/docblocks 1.1.2 → 2.0.0

package/dist/chunk-2D7Y4IR3.js

@@ -0,0 +1,1293 @@
+import {
+  withFileCommitLock
+} from "./chunk-AEHCVWU5.js";
+import {
+  parseFileSystemVersion
+} from "./chunk-AYZ4HN5M.js";
+import {
+  FsError,
+  WORKSPACE_ROOT,
+  fsErrorFromUnknown,
+  parseWorkspacePath,
+  workspacePathBasename,
+  workspacePathContains,
+  workspacePathDirname,
+  workspacePathJoin
+} from "./chunk-SI2LU2RP.js";
+
+// src/filesystem/native-provider-v2.ts
+var NativeFileSystemMoveRecoveryError = class extends FsError {
+  constructor(sourcePath, destinationPath, primaryError, recoveryErrors, state) {
+    super(
+      "io",
+      `Native move recovery is incomplete (source: ${state.source}, destination: ${state.destination}).`,
+      {
+        operation: "move",
+        path: sourcePath,
+        destinationPath,
+        retryable: false
+      }
+    );
+    this.name = "NativeFileSystemMoveRecoveryError";
+    this.primaryError = primaryError;
+    this.recoveryErrors = Object.freeze([...recoveryErrors]);
+    this.state = Object.freeze({ ...state });
+  }
+};
+var EPOCH = (/* @__PURE__ */ new Date(0)).toISOString();
+var NATIVE_V2_CAPABILITIES = Object.freeze({
+  writeAtomicity: "none",
+  moveAtomicity: "none",
+  snapshotAtomicity: "none",
+  conditionalWrite: "process",
+  recursiveRemove: true,
+  watch: false,
+  caseSensitivity: "platform",
+  symlinkPolicy: "unsupported",
+  durability: "best-effort"
+});
+var NativeFileSystemProviderV2 = class {
+  constructor(id, root) {
+    this.capabilities = NATIVE_V2_CAPABILITIES;
+    this.subscriptions = /* @__PURE__ */ new Set();
+    this.inFlight = /* @__PURE__ */ new Set();
+    this.disposed = false;
+    this.disposePromise = null;
+    this.id = id;
+    this.label = root.name;
+    this.root = root;
+    this.lockKey = `native:${id}:workspace`;
+  }
+  async stat(path) {
+    const canonical = this.canonical(path);
+    return this.execute("stat", canonical, null, async () => {
+      const scanned = await this.tryScanMetadata(canonical, "stat");
+      return scanned ? withoutData(scanned.root) : null;
+    });
+  }
+  async readFile(path) {
+    const canonical = this.canonical(path);
+    return this.execute("read", canonical, null, async () => {
+      const handle = await this.getHandle(canonical);
+      if (!handle) return null;
+      if (handle.kind !== "file") {
+        throw this.error("type-mismatch", "read", canonical, "Expected a file, found a directory.");
+      }
+      const scanned = await this.scanSnapshotHandle(canonical, handle, "read");
+      if (scanned.root.kind !== "file") {
+        throw this.error("io", "read", canonical, "Native file handle changed kind during read.");
+      }
+      return Object.freeze({
+        entry: withoutData(scanned.root),
+        data: scanned.root.data.slice(0)
+      });
+    });
+  }
+  async readDirectory(path) {
+    const canonical = this.canonical(path);
+    return this.execute("list", canonical, null, async () => {
+      const handle = await this.getHandle(canonical);
+      if (!handle) throw this.error("not-found", "list", canonical, "Directory does not exist.");
+      if (handle.kind !== "directory") {
+        throw this.error("type-mismatch", "list", canonical, "Expected a directory, found a file.");
+      }
+      const children = [];
+      for (const [name, childHandle] of await listDirectory(
+        handle,
+        "list",
+        canonical
+      )) {
+        const childPath = workspacePathJoin(canonical, name);
+        children.push(
+          withoutData((await this.scanMetadataHandle(childPath, childHandle, "list")).root)
+        );
+      }
+      children.sort(compareSnapshots);
+      return Object.freeze(children);
+    });
+  }
+  async writeFile(path, data, options = {}) {
+    const canonical = this.canonicalNonRoot(path, "write");
+    const ownedData = copyBytes(data);
+    return this.mutate("write", canonical, null, async () => {
+      const mode = options.mode ?? "upsert";
+      if (mode !== "upsert" && mode !== "create" && mode !== "replace") {
+        throw this.error("invalid-path", "write", canonical, "Invalid write mode.");
+      }
+      const existing = await this.tryScanMetadata(canonical, "write");
+      if (existing?.root.kind === "directory") {
+        throw this.error(
+          "type-mismatch",
+          "write",
+          canonical,
+          "Cannot replace a directory with a file."
+        );
+      }
+      if (mode === "create" && existing) {
+        throw this.error("already-exists", "write", canonical, "File already exists.");
+      }
+      if (mode === "replace" && !existing) {
+        throw this.error("not-found", "write", canonical, "File does not exist.");
+      }
+      this.assertExpectedVersion(existing?.root, options.expectedVersion, "write", canonical);
+      const missingParents = await this.planParents(
+        canonical,
+        options.createParents ?? false,
+        "write"
+      );
+      const createdParents = await this.createDirectories(missingParents);
+      let writeCompleted = false;
+      try {
+        await this.writeBytes(canonical, ownedData);
+        writeCompleted = true;
+        const written = await this.requireSnapshot(canonical, "write");
+        if (written.root.kind !== "file" || !equalBytes(written.root.data, ownedData)) {
+          throw this.error(
+            "conflict",
+            "write",
+            canonical,
+            "Stored bytes changed before the write could be verified."
+          );
+        }
+        return withoutData(written.root);
+      } catch (error) {
+        if (!existing && !writeCompleted) {
+          await this.removeEmptyFileIfPresent(canonical).catch(() => void 0);
+        }
+        await this.rollbackDirectories(createdParents);
+        throw error;
+      }
+    });
+  }
+  async createDirectory(path, options = {}) {
+    const canonical = this.canonical(path);
+    return this.mutate("create-directory", canonical, null, async () => {
+      const mode = options.mode ?? "ensure";
+      if (mode !== "ensure" && mode !== "create") {
+        throw this.error("invalid-path", "create-directory", canonical, "Invalid directory mode.");
+      }
+      const existing = await this.tryScanMetadata(canonical, "create-directory");
+      if (existing) {
+        if (existing.root.kind !== "directory") {
+          throw this.error(
+            "type-mismatch",
+            "create-directory",
+            canonical,
+            "Cannot replace a file with a directory."
+          );
+        }
+        if (mode === "create") {
+          throw this.error(
+            "already-exists",
+            "create-directory",
+            canonical,
+            "Directory already exists."
+          );
+        }
+        return withoutData(existing.root);
+      }
+      const missingParents = await this.planParents(
+        canonical,
+        options.createParents ?? false,
+        "create-directory"
+      );
+      const planned = [...missingParents, canonical];
+      const created = await this.createDirectories(planned);
+      try {
+        const scanned = await this.requireMetadata(canonical, "create-directory");
+        if (scanned.root.kind !== "directory") {
+          throw this.error(
+            "io",
+            "create-directory",
+            canonical,
+            "The native backend did not create a directory."
+          );
+        }
+        return withoutData(scanned.root);
+      } catch (error) {
+        await this.rollbackDirectories(created);
+        throw error;
+      }
+    });
+  }
+  async remove(path, options = {}) {
+    const canonical = this.canonicalNonRoot(path, "remove");
+    return this.mutate("remove", canonical, null, async () => {
+      const existing = await this.tryScanMetadata(canonical, "remove");
+      if (!existing) {
+        if ((options.missing ?? "error") === "ignore") {
+          return Object.freeze({
+            removed: false,
+            version: await this.currentTreeVersion("remove")
+          });
+        }
+        throw this.error("not-found", "remove", canonical, "Entry does not exist.");
+      }
+      this.assertExpectedVersion(existing.root, options.expectedVersion, "remove", canonical);
+      if (existing.root.kind === "directory" && !options.recursive) {
+        const handle = await this.getHandle(canonical);
+        if (!handle || handle.kind !== "directory") {
+          throw this.error("conflict", "remove", canonical, "Directory changed before removal.");
+        }
+        if ((await listDirectory(handle, "remove", canonical)).length > 0) {
+          throw this.error("not-empty", "remove", canonical, "Directory is not empty.");
+        }
+      }
+      await this.removeEntry(canonical, existing.root.kind === "directory" && !!options.recursive);
+      if (await this.getHandle(canonical)) {
+        throw this.error("conflict", "remove", canonical, "Entry was recreated during removal.");
+      }
+      return Object.freeze({
+        removed: true,
+        version: await this.currentTreeVersion("remove")
+      });
+    });
+  }
+  async move(oldPath, newPath, options = {}) {
+    const sourcePath = this.canonicalNonRoot(oldPath, "move");
+    const destinationPath = this.canonicalNonRoot(newPath, "move");
+    return this.mutate("move", sourcePath, destinationPath, async () => {
+      const sourceMetadata = await this.tryScanMetadata(sourcePath, "move");
+      if (!sourceMetadata) {
+        throw this.error("not-found", "move", sourcePath, "Source does not exist.");
+      }
+      this.assertExpectedVersion(sourceMetadata.root, options.expectedVersion, "move", sourcePath);
+      if (sourcePath === destinationPath) return withoutData(sourceMetadata.root);
+      if (sourceMetadata.root.kind === "directory" && workspacePathContains(sourcePath, destinationPath, false)) {
+        throw new FsError("invalid-path", "Cannot move a directory into itself.", {
+          operation: "move",
+          path: sourcePath,
+          destinationPath
+        });
+      }
+      if (await this.getHandle(destinationPath)) {
+        throw new FsError("already-exists", "Destination already exists.", {
+          operation: "move",
+          path: sourcePath,
+          destinationPath
+        });
+      }
+      const missingParents = await this.planParents(
+        destinationPath,
+        options.createParents ?? false,
+        "move"
+      );
+      const source = await this.tryScanSnapshot(sourcePath, "move");
+      if (!source || source.root.kind !== sourceMetadata.root.kind || source.root.version !== sourceMetadata.root.version) {
+        throw new FsError("conflict", "Source changed before the move could be copied.", {
+          operation: "move",
+          path: sourcePath,
+          destinationPath
+        });
+      }
+      const createdParents = await this.createDirectories(missingParents);
+      let destinationVersion = null;
+      let sourceDeleted = false;
+      try {
+        await this.writeTree(source, sourcePath, destinationPath);
+        const copied = await this.requireSnapshot(destinationPath, "move");
+        destinationVersion = copied.root.version;
+        if (!equalTreeContents(source, sourcePath, copied, destinationPath)) {
+          throw new FsError("conflict", "Destination changed while the move was copied.", {
+            operation: "move",
+            path: sourcePath,
+            destinationPath
+          });
+        }
+        const sourceBeforeDelete = await this.tryScanMetadata(sourcePath, "move");
+        if (!sourceBeforeDelete || sourceBeforeDelete.root.kind !== source.root.kind || sourceBeforeDelete.root.version !== source.root.version) {
+          throw new FsError("conflict", "Source changed while the move was copied.", {
+            operation: "move",
+            path: sourcePath,
+            destinationPath
+          });
+        }
+        await this.removeEntry(sourcePath, source.root.kind === "directory");
+        sourceDeleted = true;
+        const [sourceAfter, destinationAfter] = await Promise.all([
+          this.tryScanMetadata(sourcePath, "move"),
+          this.tryScanMetadata(destinationPath, "move")
+        ]);
+        if (sourceAfter || !destinationAfter || destinationAfter.root.kind !== source.root.kind || destinationAfter.root.version !== destinationVersion) {
+          throw new FsError("conflict", "Move state changed before it could be verified.", {
+            operation: "move",
+            path: sourcePath,
+            destinationPath
+          });
+        }
+        return withoutData(destinationAfter.root);
+      } catch (error) {
+        return await this.rollbackMoveAndThrow(
+          sourcePath,
+          destinationPath,
+          source,
+          createdParents,
+          destinationVersion,
+          sourceDeleted,
+          error
+        );
+      }
+    });
+  }
+  async snapshot() {
+    return this.mutate("snapshot", WORKSPACE_ROOT, null, async () => {
+      const scanned = await this.scanSnapshotHandle(WORKSPACE_ROOT, this.root, "snapshot");
+      const entries = [...scanned.entries].sort((left, right) => compareText(left.path, right.path)).map(copySnapshotEntry);
+      return Object.freeze({ version: scanned.root.version, entries: Object.freeze(entries) });
+    });
+  }
+  watch(_listener, options = {}) {
+    this.assertOpen("watch");
+    const error = new FsError("not-supported", "Native filesystem watching is unavailable.", {
+      operation: "watch"
+    });
+    let closed = false;
+    let disposePromise = null;
+    const ready = Promise.reject(error);
+    void ready.catch((caught) => {
+      try {
+        options.onError?.(caught);
+      } catch {
+      }
+    });
+    const subscription = {
+      get closed() {
+        return closed;
+      },
+      ready,
+      dispose: () => {
+        if (disposePromise) return disposePromise;
+        closed = true;
+        this.subscriptions.delete(subscription);
+        disposePromise = Promise.resolve();
+        return disposePromise;
+      }
+    };
+    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()));
+    })();
+    return this.disposePromise;
+  }
+  canonical(path) {
+    return parseWorkspacePath(String(path));
+  }
+  canonicalNonRoot(path, operation) {
+    const canonical = this.canonical(path);
+    if (!canonical) {
+      throw this.error("invalid-path", operation, canonical, "Workspace root cannot be mutated.");
+    }
+    return canonical;
+  }
+  execute(operation, path, destinationPath, work) {
+    this.assertOpen(operation);
+    const promise = (async () => {
+      try {
+        return await work();
+      } catch (error) {
+        throw this.translateError(error, operation, path, destinationPath);
+      }
+    })();
+    this.inFlight.add(promise);
+    void promise.then(
+      () => this.inFlight.delete(promise),
+      () => this.inFlight.delete(promise)
+    );
+    return promise;
+  }
+  mutate(operation, path, destinationPath, work) {
+    return this.execute(
+      operation,
+      path,
+      destinationPath,
+      () => withFileCommitLock(this.lockKey, work)
+    );
+  }
+  assertOpen(operation) {
+    if (!this.disposed) return;
+    throw new FsError("disposed", "Filesystem provider is disposed.", { operation });
+  }
+  translateError(error, operation, path, destinationPath) {
+    if (error instanceof FsError) return error;
+    return fsErrorFromUnknown(error, {
+      operation,
+      path: path ?? void 0,
+      destinationPath: destinationPath ?? void 0
+    });
+  }
+  error(code, operation, path, message) {
+    return new FsError(code, message, { operation, path });
+  }
+  assertExpectedVersion(entry, expected, operation, path) {
+    if (expected === void 0) return;
+    if (expected === null ? !entry : entry?.version === expected) return;
+    throw this.error(
+      "conflict",
+      operation,
+      path,
+      "Entry version does not match the expected version."
+    );
+  }
+  async resolveDirectory(path) {
+    if (!path) return this.root;
+    let current = this.root;
+    for (const segment of path.split("/")) {
+      try {
+        current = await current.getDirectoryHandle(segment);
+      } catch (error) {
+        if (errorName(error) === "NotFoundError") return null;
+        throw error;
+      }
+    }
+    return current;
+  }
+  async getHandle(path) {
+    if (!path) return this.root;
+    const parent = await this.resolveDirectory(workspacePathDirname(path));
+    if (!parent) return null;
+    const name = workspacePathBasename(path);
+    try {
+      return await parent.getFileHandle(name);
+    } catch (error) {
+      if (!isMissingOrKindError(error)) throw error;
+    }
+    try {
+      return await parent.getDirectoryHandle(name);
+    } catch (error) {
+      if (!isMissingOrKindError(error)) throw error;
+      return null;
+    }
+  }
+  async tryScanMetadata(path, operation) {
+    const handle = await this.getHandle(path);
+    return handle ? this.scanMetadataHandle(path, handle, operation) : null;
+  }
+  async tryScanSnapshot(path, operation) {
+    const handle = await this.getHandle(path);
+    return handle ? this.scanSnapshotHandle(path, handle, operation) : null;
+  }
+  async requireMetadata(path, operation) {
+    const scanned = await this.tryScanMetadata(path, operation);
+    if (!scanned) throw this.error("not-found", operation, path, "Entry does not exist.");
+    return scanned;
+  }
+  async requireSnapshot(path, operation) {
+    const scanned = await this.tryScanSnapshot(path, operation);
+    if (!scanned) throw this.error("not-found", operation, path, "Entry does not exist.");
+    return scanned;
+  }
+  scanMetadataHandle(path, handle, operation) {
+    return this.scanHandle(
+      path,
+      handle,
+      operation,
+      (filePath, fileHandle) => this.scanFileMetadata(filePath, fileHandle, operation)
+    );
+  }
+  scanSnapshotHandle(path, handle, operation) {
+    return this.scanHandle(
+      path,
+      handle,
+      operation,
+      (filePath, fileHandle) => this.scanFileSnapshot(filePath, fileHandle, operation)
+    );
+  }
+  async scanHandle(path, handle, operation, scanFile) {
+    if (handle.kind === "file") {
+      const entry = await scanFile(path, handle);
+      return { root: entry, entries: Object.freeze([entry]) };
+    }
+    const children = [];
+    for (const [name, childHandle] of await listDirectory(
+      handle,
+      operation,
+      path
+    )) {
+      children.push(
+        await this.scanHandle(workspacePathJoin(path, name), childHandle, operation, scanFile)
+      );
+    }
+    const childRoots = children.map((child) => child.root).sort(compareSnapshots);
+    const version = await metadataVersion(
+      "directory",
+      new TextEncoder().encode(
+        childRoots.map((child) => `${child.kind}\0${child.name.length}:${child.name}\0${child.version}`).join("\n")
+      ),
+      operation,
+      path
+    );
+    const directory = Object.freeze({
+      kind: "directory",
+      path,
+      name: workspacePathBasename(path),
+      size: null,
+      version,
+      lastModified: newestLastModified(childRoots)
+    });
+    return {
+      root: directory,
+      entries: Object.freeze([directory, ...children.flatMap((child) => child.entries)])
+    };
+  }
+  async scanFileMetadata(path, handle, operation) {
+    const file = await this.getFileSnapshot(handle, path, operation);
+    return this.fileMetadata(file, path, operation);
+  }
+  async scanFileSnapshot(path, handle, operation) {
+    const file = await this.getFileSnapshot(handle, path, operation);
+    const metadata = await this.fileMetadata(file, path, operation);
+    let data;
+    try {
+      data = copyBytes(await file.arrayBuffer());
+    } catch (error) {
+      throw this.translateError(error, operation, path, null);
+    }
+    if (metadata.size !== data.byteLength) {
+      throw this.error("io", operation, path, "Native file metadata is inconsistent.");
+    }
+    return Object.freeze({ ...metadata, data });
+  }
+  async getFileSnapshot(handle, path, operation) {
+    try {
+      return await handle.getFile();
+    } catch (error) {
+      throw this.translateError(error, operation, path, null);
+    }
+  }
+  async fileMetadata(file, path, operation) {
+    if (!Number.isSafeInteger(file.size) || file.size < 0 || !Number.isFinite(file.lastModified)) {
+      throw this.error("io", operation, path, "Native file metadata is inconsistent.");
+    }
+    let lastModified;
+    try {
+      lastModified = new Date(file.lastModified).toISOString();
+    } catch {
+      throw this.error("io", operation, path, "Native file metadata is inconsistent.");
+    }
+    return Object.freeze({
+      kind: "file",
+      path,
+      name: workspacePathBasename(path),
+      size: file.size,
+      version: await metadataVersion(
+        "file",
+        new TextEncoder().encode(`${file.size}\0${file.lastModified}`),
+        operation,
+        path
+      ),
+      lastModified
+    });
+  }
+  async planParents(path, createParents, operation) {
+    const missing = [];
+    for (const parent of parentChain(path)) {
+      const handle = await this.getHandle(parent);
+      if (handle?.kind === "file") {
+        throw this.error("type-mismatch", operation, parent, "A parent path is a file.");
+      }
+      if (!handle) {
+        if (!createParents) {
+          throw this.error("not-found", operation, parent, "Parent directory does not exist.");
+        }
+        missing.push(parent);
+      }
+    }
+    return missing;
+  }
+  async createDirectories(paths) {
+    const created = [];
+    try {
+      for (const path of paths) {
+        if (!path) continue;
+        const parent = await this.resolveDirectory(workspacePathDirname(path));
+        if (!parent) {
+          throw new DOMException("Parent directory does not exist.", "NotFoundError");
+        }
+        await parent.getDirectoryHandle(workspacePathBasename(path), { create: true });
+        created.push(path);
+      }
+      return created;
+    } catch (error) {
+      await this.rollbackDirectories(created);
+      throw error;
+    }
+  }
+  async rollbackDirectories(paths) {
+    for (const path of [...paths].reverse()) {
+      try {
+        await this.removeEntry(path, false);
+      } catch {
+      }
+    }
+  }
+  async writeBytes(path, data) {
+    const parent = await this.resolveDirectory(workspacePathDirname(path));
+    if (!parent) throw new DOMException("Parent directory does not exist.", "NotFoundError");
+    const fileHandle = await parent.getFileHandle(workspacePathBasename(path), { create: true });
+    const writable = await fileHandle.createWritable();
+    await writeAndClose(writable, data);
+  }
+  async removeEntry(path, recursive) {
+    const parent = await this.resolveDirectory(workspacePathDirname(path));
+    if (!parent) throw new DOMException("Parent directory does not exist.", "NotFoundError");
+    await parent.removeEntry(workspacePathBasename(path), { recursive });
+  }
+  async removeEmptyFileIfPresent(path) {
+    const current = await this.tryScanMetadata(path, "write");
+    if (current?.root.kind !== "file" || current.root.size !== 0) return;
+    await this.removeEntry(path, false);
+  }
+  async currentTreeVersion(operation) {
+    return (await this.scanMetadataHandle(WORKSPACE_ROOT, this.root, operation)).root.version;
+  }
+  async writeTree(source, sourcePath, destinationPath) {
+    const remapped = source.entries.map((entry) => {
+      const suffix = entry.path.slice(sourcePath.length);
+      return [entry, parseWorkspacePath(`${destinationPath}${suffix}`)];
+    });
+    const directories = remapped.filter(
+      (item) => item[0].kind === "directory"
+    ).sort((left, right) => pathDepth(left[1]) - pathDepth(right[1]));
+    for (const [, path] of directories) {
+      const parent = await this.resolveDirectory(workspacePathDirname(path));
+      if (!parent) throw new DOMException("Parent directory does not exist.", "NotFoundError");
+      await parent.getDirectoryHandle(workspacePathBasename(path), { create: true });
+    }
+    for (const [entry, path] of remapped) {
+      if (entry.kind === "file") await this.writeBytes(path, entry.data);
+    }
+  }
+  async rollbackMoveAndThrow(sourcePath, destinationPath, source, createdParents, destinationVersion, sourceDeleted, 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
+          });
+        }
+      } catch (error) {
+        recoveryErrors.push(this.translateError(error, "move", sourcePath, destinationPath));
+      }
+    }
+    const destinationCurrent = await this.probeScan(destinationPath);
+    if (destinationCurrent) {
+      if (destinationVersion && destinationCurrent.root.version !== destinationVersion) {
+        recoveryErrors.push(
+          new FsError("conflict", "Destination changed; rollback will not delete it.", {
+            operation: "move",
+            path: sourcePath,
+            destinationPath
+          })
+        );
+      } else {
+        try {
+          await this.removeEntry(destinationPath, destinationCurrent.root.kind === "directory");
+        } catch (error) {
+          recoveryErrors.push(this.translateError(error, "move", sourcePath, destinationPath));
+        }
+      }
+    }
+    await this.rollbackDirectories(createdParents);
+    const state = {
+      source: await this.probePresence(sourcePath),
+      destination: await this.probePresence(destinationPath)
+    };
+    if (recoveryErrors.length === 0 && state.source === "present" && state.destination === "missing") {
+      throw primaryError;
+    }
+    throw new NativeFileSystemMoveRecoveryError(
+      sourcePath,
+      destinationPath,
+      primaryError,
+      recoveryErrors,
+      state
+    );
+  }
+  async probeScan(path) {
+    try {
+      return await this.tryScanMetadata(path, "move");
+    } catch {
+      return void 0;
+    }
+  }
+  async probeSnapshot(path) {
+    try {
+      return await this.tryScanSnapshot(path, "move");
+    } catch {
+      return void 0;
+    }
+  }
+  async probePresence(path) {
+    try {
+      return await this.getHandle(path) ? "present" : "missing";
+    } catch {
+      return "unknown";
+    }
+  }
+};
+async function listDirectory(directory, operation, path) {
+  const entries = [];
+  try {
+    for await (const entry of directory) {
+      const [name, handle] = entry;
+      if (typeof name !== "string" || !handle || handle.kind !== "file" && handle.kind !== "directory") {
+        throw new FsError("io", "Native directory returned an invalid entry.", {
+          operation,
+          path
+        });
+      }
+      entries.push([name, handle]);
+    }
+  } catch (error) {
+    throw fsErrorFromUnknown(error, { operation, path });
+  }
+  entries.sort(([left], [right]) => compareText(left, right));
+  return entries;
+}
+async function writeAndClose(writable, data) {
+  try {
+    await writable.write(data);
+    await writable.close();
+  } catch (error) {
+    await writable.abort(error).catch(() => void 0);
+    throw error;
+  }
+}
+async function metadataVersion(kind, metadata, operation, path) {
+  const prefix = new TextEncoder().encode(`${kind}\0`);
+  const input = new Uint8Array(prefix.byteLength + metadata.byteLength);
+  input.set(prefix);
+  input.set(metadata, prefix.byteLength);
+  let digest;
+  try {
+    digest = await globalThis.crypto.subtle.digest("SHA-256", input.buffer);
+  } catch (error) {
+    throw fsErrorFromUnknown(error, {
+      operation,
+      path,
+      defaultCode: "not-supported"
+    });
+  }
+  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;
+}
+function errorName(error) {
+  if (!error || typeof error !== "object") return null;
+  const name = error.name;
+  return typeof name === "string" ? name : null;
+}
+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();
+  for (const entry of right.entries) {
+    const relativePath = treeRelativePath(rightRoot, entry.path);
+    if (relativePath === null || rightByRelativePath.has(relativePath)) return false;
+    rightByRelativePath.set(relativePath, entry);
+  }
+  for (const entry of left.entries) {
+    const relativePath = treeRelativePath(leftRoot, entry.path);
+    if (relativePath === null) return false;
+    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;
+    }
+  }
+  return true;
+}
+function treeRelativePath(root, path) {
+  if (path === root) return "";
+  const prefix = root ? `${root}/` : "";
+  return path.startsWith(prefix) ? path.slice(prefix.length) : null;
+}
+function withoutData(entry) {
+  if (entry.kind === "directory") return Object.freeze({ ...entry });
+  return Object.freeze({
+    kind: "file",
+    path: entry.path,
+    name: entry.name,
+    size: entry.size,
+    version: entry.version,
+    lastModified: entry.lastModified
+  });
+}
+function copySnapshotEntry(entry) {
+  if (entry.kind === "directory") return Object.freeze({ ...entry });
+  return Object.freeze({
+    kind: "file",
+    path: entry.path,
+    name: entry.name,
+    size: entry.size,
+    version: entry.version,
+    lastModified: entry.lastModified,
+    data: entry.data.slice(0)
+  });
+}
+function newestLastModified(children) {
+  let newest = 0;
+  for (const child of children) {
+    const timestamp = Date.parse(child.lastModified);
+    if (Number.isFinite(timestamp)) newest = Math.max(newest, timestamp);
+  }
+  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() {
+  return typeof globalThis !== "undefined" && typeof globalThis.showDirectoryPicker === "function";
+}
+var HANDLE_DB_NAME = "docblocks-handles";
+var HANDLE_STORE_NAME = "directory-handles";
+function openHandleDB() {
+  return new Promise((resolve, reject) => {
+    const req = indexedDB.open(HANDLE_DB_NAME, 1);
+    req.onupgradeneeded = () => {
+      req.result.createObjectStore(HANDLE_STORE_NAME);
+    };
+    req.onsuccess = () => resolve(req.result);
+    req.onerror = () => reject(req.error);
+  });
+}
+async function storeDirectoryHandle(workspaceId, handle) {
+  const db = await openHandleDB();
+  return new Promise((resolve, reject) => {
+    const tx = db.transaction(HANDLE_STORE_NAME, "readwrite");
+    tx.objectStore(HANDLE_STORE_NAME).put(handle, workspaceId);
+    tx.oncomplete = () => {
+      db.close();
+      resolve();
+    };
+    tx.onerror = () => {
+      db.close();
+      reject(tx.error);
+    };
+  });
+}
+async function loadDirectoryHandle(workspaceId) {
+  const db = await openHandleDB();
+  return new Promise((resolve, reject) => {
+    const tx = db.transaction(HANDLE_STORE_NAME, "readonly");
+    const req = tx.objectStore(HANDLE_STORE_NAME).get(workspaceId);
+    req.onsuccess = () => {
+      db.close();
+      resolve(req.result ?? null);
+    };
+    req.onerror = () => {
+      db.close();
+      reject(req.error);
+    };
+  });
+}
+async function removeDirectoryHandle(workspaceId) {
+  const db = await openHandleDB();
+  return new Promise((resolve, reject) => {
+    const tx = db.transaction(HANDLE_STORE_NAME, "readwrite");
+    tx.objectStore(HANDLE_STORE_NAME).delete(workspaceId);
+    tx.oncomplete = () => {
+      db.close();
+      resolve();
+    };
+    tx.onerror = () => {
+      db.close();
+      reject(tx.error);
+    };
+  });
+}
+function normalisePath(p) {
+  return parseWorkspacePath(p);
+}
+function errorName2(error) {
+  return typeof error === "object" && error !== null && "name" in error ? String(error.name) : void 0;
+}
+function isMissingEntryError(error) {
+  const name = errorName2(error);
+  return name === "NotFoundError" || name === "TypeMismatchError";
+}
+function isPermissionError(error) {
+  const name = errorName2(error);
+  return name === "NotAllowedError" || name === "SecurityError";
+}
+var NativeMoveRecoveryError = class extends Error {
+  constructor(message, causes) {
+    super(message);
+    this.name = "NativeMoveRecoveryError";
+    this.causes = causes;
+  }
+};
+async function resolveDir(root, dirPath) {
+  if (!dirPath) return root;
+  const parts = dirPath.split("/");
+  let current = root;
+  for (const part of parts) {
+    try {
+      current = await current.getDirectoryHandle(part);
+    } catch (error) {
+      if (isMissingEntryError(error)) return null;
+      throw error;
+    }
+  }
+  return current;
+}
+async function resolveDirCreate(root, dirPath) {
+  if (!dirPath) return root;
+  const parts = dirPath.split("/");
+  let current = root;
+  for (const part of parts) {
+    current = await current.getDirectoryHandle(part, { create: true });
+  }
+  return current;
+}
+function parentDir(p) {
+  const idx = p.lastIndexOf("/");
+  return idx === -1 ? "" : p.slice(0, idx);
+}
+function baseName(p) {
+  const idx = p.lastIndexOf("/");
+  return idx === -1 ? p : p.slice(idx + 1);
+}
+function toWritableBinary(data) {
+  if (data instanceof ArrayBuffer) return data;
+  const copy = new Uint8Array(data.byteLength);
+  copy.set(data);
+  return copy.buffer;
+}
+async function writeAndClose2(writable, data) {
+  try {
+    await writable.write(data);
+    await writable.close();
+  } catch (error) {
+    await writable.abort(error).catch(() => void 0);
+    throw error;
+  }
+}
+var NativeFileSystemProvider = class {
+  constructor(id, root) {
+    this.id = id;
+    this.label = root.name;
+    this.root = root;
+    this.v2 = new NativeFileSystemProviderV2(id, root);
+  }
+  withMutationLock(operation) {
+    return withFileCommitLock(`native:${this.id}:workspace`, operation);
+  }
+  async copyDirectory(oldDirPath, newDirPath) {
+    const source = await resolveDir(this.root, oldDirPath);
+    if (!source)
+      throw new DOMException(`Source directory does not exist: ${oldDirPath}`, "NotFoundError");
+    await resolveDirCreate(this.root, newDirPath);
+    for await (const [name, handle] of source) {
+      const oldChild = oldDirPath ? `${oldDirPath}/${name}` : name;
+      const newChild = newDirPath ? `${newDirPath}/${name}` : name;
+      if (handle.kind === "directory") {
+        await this.copyDirectory(oldChild, newChild);
+      } else {
+        const fileHandle = await source.getFileHandle(name);
+        const file = await fileHandle.getFile();
+        await this.writeBinaryUnlocked(newChild, await file.arrayBuffer());
+      }
+    }
+  }
+  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;
+    }
+  }
+  async writeFile(path, content) {
+    return this.withMutationLock(() => this.writeFileUnlocked(path, content));
+  }
+  async writeFileUnlocked(path, content) {
+    const p = normalisePath(path);
+    const dir = await resolveDirCreate(this.root, parentDir(p));
+    const fileHandle = await dir.getFileHandle(baseName(p), { create: true });
+    const writable = await fileHandle.createWritable();
+    await writeAndClose2(writable, content);
+  }
+  async commitFile(path, content, expectedContent) {
+    const p = normalisePath(path);
+    return this.withMutationLock(async () => {
+      const current = await this.readFile(p);
+      if (current !== expectedContent && current !== content) {
+        const meta2 = await this.stat(p);
+        return {
+          status: "conflict",
+          content: current,
+          version: meta2?.lastModified ?? null
+        };
+      }
+      await this.writeFileUnlocked(p, content);
+      const meta = await this.stat(p);
+      return { status: "committed", version: meta?.lastModified ?? null };
+    });
+  }
+  async delete(path) {
+    return this.withMutationLock(() => this.deleteUnlocked(path));
+  }
+  async deleteUnlocked(path) {
+    const p = normalisePath(path);
+    if (!p) throw new Error("Cannot delete the filesystem root");
+    const parent = parentDir(p);
+    const name = baseName(p);
+    const dir = await resolveDir(this.root, parent);
+    if (!dir) return;
+    try {
+      await dir.removeEntry(name, { recursive: true });
+    } catch (error) {
+      if (isMissingEntryError(error)) return;
+      throw error;
+    }
+  }
+  async rename(oldPath, newPath) {
+    return this.withMutationLock(() => this.renameUnlocked(oldPath, newPath));
+  }
+  async renameUnlocked(oldPath, newPath) {
+    const op = normalisePath(oldPath);
+    const np = normalisePath(newPath);
+    if (op === np) return;
+    if (!op || !np) {
+      throw new Error("Cannot rename the filesystem root");
+    }
+    if (np.startsWith(op + "/")) {
+      throw new Error("Cannot move a directory into itself");
+    }
+    if (!await this.exists(op)) {
+      throw new Error(`Source does not exist: ${oldPath}`);
+    }
+    if (await this.exists(np)) {
+      throw new Error(`Destination exists: ${newPath}`);
+    }
+    const oldParent = await resolveDir(this.root, parentDir(op));
+    if (!oldParent) {
+      throw new DOMException(`Source does not exist: ${oldPath}`, "NotFoundError");
+    }
+    let fileHandle = null;
+    try {
+      fileHandle = await oldParent.getFileHandle(baseName(op));
+    } catch (error) {
+      if (!isMissingEntryError(error)) throw error;
+    }
+    if (fileHandle) {
+      const file = await fileHandle.getFile();
+      await this.writeBinaryUnlocked(np, await file.arrayBuffer());
+      try {
+        await this.deleteUnlocked(op);
+      } catch (error) {
+        try {
+          await this.deleteUnlocked(np);
+        } catch (rollbackError) {
+          throw new NativeMoveRecoveryError(
+            `Move partially completed and rollback failed: ${oldPath} -> ${newPath}`,
+            [error, rollbackError]
+          );
+        }
+        throw error;
+      }
+      return;
+    }
+    try {
+      await this.copyDirectory(op, np);
+    } catch (error) {
+      try {
+        await this.deleteUnlocked(np);
+      } catch (rollbackError) {
+        throw new NativeMoveRecoveryError(
+          `Move failed and destination cleanup failed: ${oldPath} -> ${newPath}`,
+          [error, rollbackError]
+        );
+      }
+      throw error;
+    }
+    try {
+      await this.deleteUnlocked(op);
+    } catch (error) {
+      try {
+        await this.deleteUnlocked(np);
+      } catch (rollbackError) {
+        throw new NativeMoveRecoveryError(
+          `Move partially completed and rollback failed: ${oldPath} -> ${newPath}`,
+          [error, rollbackError]
+        );
+      }
+      throw error;
+    }
+  }
+  async readDirectory(path) {
+    const p = normalisePath(path);
+    const dir = await resolveDir(this.root, p);
+    if (!dir) return [];
+    const entries = [];
+    for await (const [name, handle] of dir) {
+      const entryPath = p ? `${p}/${name}` : name;
+      if (handle.kind === "directory") {
+        entries.push({ kind: "directory", name, path: entryPath });
+      } else {
+        entries.push({ kind: "file", name, path: entryPath });
+      }
+    }
+    entries.sort((a, b) => {
+      if (a.kind !== b.kind) return a.kind === "directory" ? -1 : 1;
+      return a.name.localeCompare(b.name);
+    });
+    return entries;
+  }
+  async exists(path) {
+    const p = normalisePath(path);
+    const parent = parentDir(p);
+    const name = baseName(p);
+    const dir = await resolveDir(this.root, parent);
+    if (!dir) return false;
+    try {
+      await dir.getFileHandle(name);
+      return true;
+    } catch (fileError) {
+      if (!isMissingEntryError(fileError)) throw fileError;
+      try {
+        await dir.getDirectoryHandle(name);
+        return true;
+      } catch (directoryError) {
+        if (!isMissingEntryError(directoryError)) throw directoryError;
+        return false;
+      }
+    }
+  }
+  async createDirectory(path) {
+    return this.withMutationLock(async () => {
+      const p = normalisePath(path);
+      await resolveDirCreate(this.root, p);
+    });
+  }
+  async stat(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 {
+        name: file.name,
+        path: p,
+        size: file.size,
+        lastModified: new Date(file.lastModified).toISOString()
+      };
+    } catch (error) {
+      if (isMissingEntryError(error)) return null;
+      throw error;
+    }
+  }
+  async readBinary(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.arrayBuffer();
+    } catch (error) {
+      if (isMissingEntryError(error)) return null;
+      throw error;
+    }
+  }
+  async writeBinary(path, data) {
+    return this.withMutationLock(() => this.writeBinaryUnlocked(path, data));
+  }
+  async writeBinaryUnlocked(path, data) {
+    const p = normalisePath(path);
+    const dir = await resolveDirCreate(this.root, parentDir(p));
+    const fileHandle = await dir.getFileHandle(baseName(p), { create: true });
+    const writable = await fileHandle.createWritable();
+    await writeAndClose2(writable, toWritableBinary(data));
+  }
+};
+async function openNativeFolder() {
+  if (!isNativeFileSystemSupported()) {
+    throw new Error("File System Access API is not supported in this browser");
+  }
+  const handle = await globalThis.showDirectoryPicker({ mode: "readwrite" });
+  const id = `native-${handle.name}-${Date.now()}`;
+  await storeDirectoryHandle(id, handle);
+  return new NativeFileSystemProvider(id, handle);
+}
+async function restoreNativeFolder(workspaceId) {
+  const handle = await loadDirectoryHandle(workspaceId);
+  if (!handle) return null;
+  const opts = { mode: "readwrite" };
+  const h = handle;
+  try {
+    if (await h.queryPermission(opts) === "granted") {
+      return new NativeFileSystemProvider(workspaceId, handle);
+    }
+    if (await h.requestPermission(opts) === "granted") {
+      return new NativeFileSystemProvider(workspaceId, handle);
+    }
+  } catch (error) {
+    if (!isPermissionError(error)) throw error;
+  }
+  return null;
+}
+
+export {
+  NativeFileSystemMoveRecoveryError,
+  NativeFileSystemProviderV2,
+  isNativeFileSystemSupported,
+  storeDirectoryHandle,
+  loadDirectoryHandle,
+  removeDirectoryHandle,
+  NativeFileSystemProvider,
+  openNativeFolder,
+  restoreNativeFolder
+};
+//# sourceMappingURL=chunk-2D7Y4IR3.js.map