@bendyline/docblocks 1.1.2 → 2.0.0

package/dist/chunk-RQJRQF46.js

@@ -0,0 +1,787 @@
+import {
+  parseFileSystemVersion
+} from "./chunk-AYZ4HN5M.js";
+import {
+  FsError,
+  WORKSPACE_ROOT,
+  parseWorkspacePath,
+  workspacePathBasename,
+  workspacePathContains,
+  workspacePathDirname
+} from "./chunk-SI2LU2RP.js";
+
+// src/filesystem/memory-provider-v2.ts
+var MEMORY_CAPABILITIES = Object.freeze({
+  writeAtomicity: "process",
+  moveAtomicity: "process",
+  snapshotAtomicity: "process",
+  conditionalWrite: "process",
+  recursiveRemove: true,
+  watch: true,
+  caseSensitivity: "sensitive",
+  symlinkPolicy: "unsupported",
+  durability: "volatile"
+});
+var MemoryFileSystemProviderV2 = class {
+  constructor(id, label) {
+    this.capabilities = MEMORY_CAPABILITIES;
+    this.watchers = /* @__PURE__ */ new Set();
+    this.subscriptions = /* @__PURE__ */ new Set();
+    this.pendingEvents = [];
+    this.emittingEvents = false;
+    this.mutationCounter = 0;
+    this.eventSequence = 0;
+    this.disposed = false;
+    this.disposePromise = null;
+    this.id = id;
+    this.label = label;
+    this.treeVersion = parseFileSystemVersion(`${id}:0`);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    this.entries = /* @__PURE__ */ new Map([
+      [WORKSPACE_ROOT, { kind: "directory", version: this.treeVersion, lastModified: now }]
+    ]);
+  }
+  /** Monotonic in-process revision used by synchronous transient-workspace staging. */
+  get mutationRevision() {
+    return this.mutationCounter;
+  }
+  /** @internal Atomically couple owned bytes to their v1 compatibility kind. */
+  readCompatibilityFile(path) {
+    this.assertOpen("read");
+    const canonical = this.canonical(path);
+    const entry = this.entries.get(canonical);
+    if (!entry) return null;
+    if (entry.kind !== "file") {
+      throw this.error(
+        "type-mismatch",
+        "read",
+        canonical,
+        "Expected a file but found a directory."
+      );
+    }
+    return Object.freeze({ data: entry.data.slice(0), payloadKind: entry.payloadKind });
+  }
+  /** @internal Capture an owned synchronous copy for DBK whole-tree staging. */
+  captureState() {
+    this.assertOpen("snapshot");
+    const files = [];
+    const directories = [];
+    for (const [path, entry] of [...this.entries].sort(
+      ([left], [right]) => compareText(left, right)
+    )) {
+      if (!path) continue;
+      if (entry.kind === "directory") directories.push(path);
+      else {
+        files.push(
+          Object.freeze({ path, data: entry.data.slice(0), payloadKind: entry.payloadKind })
+        );
+      }
+    }
+    return Object.freeze({
+      revision: this.mutationCounter,
+      files: Object.freeze(files),
+      directories: Object.freeze(directories)
+    });
+  }
+  /** @internal Atomically replace a transient workspace after complete validation. */
+  replaceState(replacement, expectedRevision) {
+    this.assertOpen("write");
+    const stagedFiles = /* @__PURE__ */ new Map();
+    const stagedDirectories = /* @__PURE__ */ new Set();
+    const explicitDirectories = /* @__PURE__ */ new Set();
+    for (const rawDirectory of replacement.directories ?? []) {
+      const directory = this.canonicalNonRoot(rawDirectory, "create-directory");
+      if (explicitDirectories.has(directory)) {
+        throw this.error(
+          "already-exists",
+          "create-directory",
+          directory,
+          "Duplicate replacement directory."
+        );
+      }
+      explicitDirectories.add(directory);
+      stagedDirectories.add(directory);
+      addParentPaths(stagedDirectories, directory);
+    }
+    for (const rawFile of replacement.files) {
+      const path = this.canonicalNonRoot(rawFile.path, "write");
+      if (stagedFiles.has(path)) {
+        throw this.error("already-exists", "write", path, "Duplicate replacement file.");
+      }
+      if (!isMemoryFilePayloadKind(rawFile.payloadKind)) {
+        throw this.error("type-mismatch", "write", path, "Invalid replacement payload kind.");
+      }
+      stagedFiles.set(path, {
+        data: copyBytes(rawFile.data),
+        payloadKind: rawFile.payloadKind
+      });
+      addParentPaths(stagedDirectories, path);
+    }
+    for (const path of stagedFiles.keys()) {
+      if (stagedDirectories.has(path)) {
+        throw this.error(
+          "type-mismatch",
+          "write",
+          path,
+          "Replacement path has conflicting file and directory kinds."
+        );
+      }
+      for (const parent of parentChain(path)) {
+        if (parent && stagedFiles.has(parent)) {
+          throw this.error("type-mismatch", "write", parent, "A replacement parent is a file.");
+        }
+      }
+    }
+    if (expectedRevision !== void 0 && expectedRevision !== this.mutationCounter) {
+      throw this.error(
+        "conflict",
+        "write",
+        WORKSPACE_ROOT,
+        "Memory filesystem changed while replacement contents were staged."
+      );
+    }
+    const version = this.nextVersion();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const next = /* @__PURE__ */ new Map([
+      [WORKSPACE_ROOT, { kind: "directory", version, lastModified: now }]
+    ]);
+    this.addDirectories(next, [...stagedDirectories], version, now);
+    for (const [path, file] of stagedFiles) {
+      next.set(path, {
+        kind: "file",
+        data: file.data,
+        payloadKind: file.payloadKind,
+        version,
+        lastModified: now
+      });
+    }
+    this.entries = next;
+    this.emit({
+      type: "overflow",
+      kind: null,
+      path: WORKSPACE_ROOT,
+      destinationPath: null,
+      version: null,
+      previousVersion: null
+    });
+  }
+  /** @internal Synchronous setup hook used before a transient provider is published. */
+  seedText(path, content) {
+    this.writeFileNow(path, new TextEncoder().encode(content), { createParents: true }, "text");
+  }
+  /** @internal Legacy text write that preserves text/binary compatibility metadata. */
+  async writeText(path, content, options = {}) {
+    return this.writeFileNow(path, new TextEncoder().encode(content), options, "text");
+  }
+  /** @internal Legacy binary write that explicitly changes compatibility payload kind. */
+  async writeBinary(path, data, options = {}) {
+    return this.writeFileNow(path, data, options, "binary");
+  }
+  /** @internal Atomic legacy compare-and-write over the authoritative v2 entry. */
+  async commitText(path, content, expectedContent) {
+    this.assertOpen("write");
+    const canonical = this.canonicalNonRoot(path, "write");
+    const existing = this.entries.get(canonical);
+    if (existing?.kind === "directory") {
+      throw this.error("type-mismatch", "write", canonical, "Cannot replace a directory.");
+    }
+    const currentContent = existing?.kind === "file" && existing.payloadKind === "text" ? new TextDecoder().decode(existing.data) : null;
+    if (existing?.kind === "file" && existing.payloadKind === "binary" || currentContent !== expectedContent && currentContent !== content) {
+      return {
+        status: "conflict",
+        content: currentContent,
+        version: existing?.version ?? null
+      };
+    }
+    const written = this.writeFileNow(
+      canonical,
+      new TextEncoder().encode(content),
+      { createParents: true, expectedVersion: existing?.version ?? null },
+      "text"
+    );
+    return { status: "committed", version: written.version };
+  }
+  async stat(path) {
+    this.assertOpen("stat");
+    const canonical = this.canonical(path);
+    const entry = this.entries.get(canonical);
+    return entry ? this.toEntrySnapshot(canonical, entry) : null;
+  }
+  async readFile(path) {
+    this.assertOpen("read");
+    const canonical = this.canonical(path);
+    const entry = this.entries.get(canonical);
+    if (!entry) return null;
+    if (entry.kind !== "file") {
+      throw this.error(
+        "type-mismatch",
+        "read",
+        canonical,
+        "Expected a file but found a directory."
+      );
+    }
+    return Object.freeze({
+      entry: this.toFileSnapshot(canonical, entry),
+      data: entry.data.slice(0)
+    });
+  }
+  async readDirectory(path) {
+    this.assertOpen("list");
+    const canonical = this.canonical(path);
+    const directory = this.entries.get(canonical);
+    if (!directory) {
+      throw this.error("not-found", "list", canonical, "Directory does not exist.");
+    }
+    if (directory.kind !== "directory") {
+      throw this.error(
+        "type-mismatch",
+        "list",
+        canonical,
+        "Expected a directory but found a file."
+      );
+    }
+    const children = [];
+    for (const [entryPath2, entry] of this.entries) {
+      if (entryPath2 && workspacePathDirname(entryPath2) === canonical) {
+        children.push(this.toEntrySnapshot(entryPath2, entry));
+      }
+    }
+    children.sort(compareSnapshots);
+    return Object.freeze(children);
+  }
+  async writeFile(path, data, options = {}) {
+    return this.writeFileNow(path, data, options);
+  }
+  writeFileNow(path, data, options, payloadKind) {
+    this.assertOpen("write");
+    const canonical = this.canonicalNonRoot(path, "write");
+    const existing = this.entries.get(canonical);
+    if (existing?.kind === "directory") {
+      throw this.error(
+        "type-mismatch",
+        "write",
+        canonical,
+        "Cannot replace a directory with a file."
+      );
+    }
+    const mode = options.mode ?? "upsert";
+    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, options.expectedVersion, "write", canonical);
+    const missingParents = this.planParents(canonical, options.createParents ?? false, "write");
+    const ownedData = copyBytes(data);
+    const version = this.nextVersion();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const next = new Map(this.entries);
+    this.addDirectories(next, missingParents, version, now);
+    next.set(canonical, {
+      kind: "file",
+      data: ownedData,
+      payloadKind: payloadKind ?? (existing?.kind === "file" ? existing.payloadKind : "binary"),
+      version,
+      lastModified: now
+    });
+    this.touchParents(next, canonical, version, now);
+    this.entries = next;
+    for (const directoryPath of missingParents) {
+      this.emit({
+        type: "created",
+        kind: "directory",
+        path: directoryPath,
+        destinationPath: null,
+        version,
+        previousVersion: null
+      });
+    }
+    this.emit({
+      type: existing ? "modified" : "created",
+      kind: "file",
+      path: canonical,
+      destinationPath: null,
+      version,
+      previousVersion: existing?.version ?? null
+    });
+    return this.toFileSnapshot(canonical, next.get(canonical));
+  }
+  async createDirectory(path, options = {}) {
+    this.assertOpen("create-directory");
+    const canonical = this.canonical(path);
+    const existing = this.entries.get(canonical);
+    if (existing) {
+      if (existing.kind !== "directory") {
+        throw this.error(
+          "type-mismatch",
+          "create-directory",
+          canonical,
+          "Cannot replace a file with a directory."
+        );
+      }
+      if ((options.mode ?? "ensure") === "create") {
+        throw this.error(
+          "already-exists",
+          "create-directory",
+          canonical,
+          "Directory already exists."
+        );
+      }
+      return this.toDirectorySnapshot(canonical, existing);
+    }
+    const missingParents = this.planParents(
+      canonical,
+      options.createParents ?? false,
+      "create-directory"
+    );
+    const version = this.nextVersion();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const next = new Map(this.entries);
+    const created = [...missingParents, canonical];
+    this.addDirectories(next, created, version, now);
+    this.touchParents(next, canonical, version, now);
+    this.entries = next;
+    for (const directoryPath of created) {
+      this.emit({
+        type: "created",
+        kind: "directory",
+        path: directoryPath,
+        destinationPath: null,
+        version,
+        previousVersion: null
+      });
+    }
+    return this.toDirectorySnapshot(canonical, next.get(canonical));
+  }
+  async remove(path, options = {}) {
+    this.assertOpen("remove");
+    const canonical = this.canonicalNonRoot(path, "remove");
+    const existing = this.entries.get(canonical);
+    if (!existing) {
+      if ((options.missing ?? "error") === "ignore") {
+        return Object.freeze({ removed: false, version: this.treeVersion });
+      }
+      throw this.error("not-found", "remove", canonical, "Entry does not exist.");
+    }
+    this.assertExpectedVersion(existing, options.expectedVersion, "remove", canonical);
+    const descendants = [...this.entries.keys()].filter(
+      (candidate) => workspacePathContains(canonical, candidate, false)
+    );
+    if (existing.kind === "directory" && descendants.length > 0 && !options.recursive) {
+      throw this.error("not-empty", "remove", canonical, "Directory is not empty.");
+    }
+    const version = this.nextVersion();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const next = new Map(this.entries);
+    next.delete(canonical);
+    if (existing.kind === "directory") {
+      for (const descendant of descendants) next.delete(descendant);
+    }
+    this.touchParents(next, canonical, version, now);
+    this.entries = next;
+    this.emit({
+      type: "removed",
+      kind: existing.kind,
+      path: canonical,
+      destinationPath: null,
+      version: null,
+      previousVersion: existing.version
+    });
+    return Object.freeze({ removed: true, version });
+  }
+  async move(oldPath, newPath, options = {}) {
+    this.assertOpen("move");
+    const sourcePath = this.canonicalNonRoot(oldPath, "move");
+    const destinationPath = this.canonicalNonRoot(newPath, "move");
+    const source = this.entries.get(sourcePath);
+    if (!source) throw this.error("not-found", "move", sourcePath, "Source does not exist.");
+    this.assertExpectedVersion(source, options.expectedVersion, "move", sourcePath);
+    if (sourcePath === destinationPath) return this.toEntrySnapshot(sourcePath, source);
+    if (this.entries.has(destinationPath)) {
+      throw new FsError("already-exists", "Destination already exists.", {
+        operation: "move",
+        path: sourcePath,
+        destinationPath
+      });
+    }
+    if (source.kind === "directory" && workspacePathContains(sourcePath, destinationPath, false)) {
+      throw new FsError("invalid-path", "Cannot move a directory into itself.", {
+        operation: "move",
+        path: sourcePath,
+        destinationPath
+      });
+    }
+    const missingParents = this.planParents(
+      destinationPath,
+      options.createParents ?? false,
+      "move"
+    );
+    const sourcePaths = [...this.entries.keys()].filter(
+      (candidate) => workspacePathContains(sourcePath, candidate)
+    );
+    const sourceSet = new Set(sourcePaths);
+    const remapped = sourcePaths.map((currentPath) => {
+      const suffix = currentPath.slice(sourcePath.length);
+      const target = parseWorkspacePath(`${destinationPath}${suffix}`);
+      if (this.entries.has(target) && !sourceSet.has(target)) {
+        throw new FsError("already-exists", "A destination descendant already exists.", {
+          operation: "move",
+          path: currentPath,
+          destinationPath: target
+        });
+      }
+      return [currentPath, target];
+    });
+    const version = this.nextVersion();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const next = new Map(this.entries);
+    for (const currentPath of sourcePaths) next.delete(currentPath);
+    this.addDirectories(next, missingParents, version, now);
+    for (const [currentPath, targetPath] of remapped) {
+      const current = this.entries.get(currentPath);
+      next.set(targetPath, this.withVersion(current, version, now));
+    }
+    this.touchParents(next, sourcePath, version, now);
+    this.touchParents(next, destinationPath, version, now);
+    this.entries = next;
+    for (const directoryPath of missingParents) {
+      this.emit({
+        type: "created",
+        kind: "directory",
+        path: directoryPath,
+        destinationPath: null,
+        version,
+        previousVersion: null
+      });
+    }
+    this.emit({
+      type: "moved",
+      kind: source.kind,
+      path: sourcePath,
+      destinationPath,
+      version,
+      previousVersion: source.version
+    });
+    return this.toEntrySnapshot(destinationPath, next.get(destinationPath));
+  }
+  async snapshot() {
+    this.assertOpen("snapshot");
+    const entries = [...this.entries.entries()].sort(([left], [right]) => compareText(left, right)).map(([path, entry]) => {
+      if (entry.kind === "file") {
+        return Object.freeze({ ...this.toFileSnapshot(path, entry), data: entry.data.slice(0) });
+      }
+      return this.toDirectorySnapshot(path, entry);
+    });
+    return Object.freeze({ version: this.treeVersion, entries: Object.freeze(entries) });
+  }
+  watch(listener, options = {}) {
+    this.assertOpen("watch");
+    const watcher = { listener, onError: options.onError };
+    this.watchers.add(watcher);
+    let closed = false;
+    let disposePromise = null;
+    const subscription = {
+      get closed() {
+        return closed;
+      },
+      ready: Promise.resolve(),
+      dispose: () => {
+        if (disposePromise) return disposePromise;
+        closed = true;
+        this.watchers.delete(watcher);
+        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 = Promise.all(
+      [...this.subscriptions].map((subscription) => subscription.dispose())
+    ).then(() => void 0);
+    return this.disposePromise;
+  }
+  canonical(path) {
+    return parseWorkspacePath(path);
+  }
+  canonicalNonRoot(path, operation) {
+    const canonical = this.canonical(path);
+    if (!canonical) {
+      throw this.error(
+        "invalid-path",
+        operation,
+        canonical,
+        "The workspace root is not a file entry."
+      );
+    }
+    return canonical;
+  }
+  assertOpen(operation) {
+    if (!this.disposed) return;
+    throw new FsError("disposed", "Filesystem provider is disposed.", { operation });
+  }
+  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."
+    );
+  }
+  planParents(path, createParents, operation) {
+    const missing = [];
+    for (const parent of parentChain(path)) {
+      if (!parent) continue;
+      const entry = this.entries.get(parent);
+      if (entry?.kind === "file") {
+        throw this.error(
+          "type-mismatch",
+          operation,
+          parent,
+          "A parent path is a file, not a directory."
+        );
+      }
+      if (!entry) {
+        if (!createParents) {
+          throw this.error("not-found", operation, parent, "Parent directory does not exist.");
+        }
+        missing.push(parent);
+      }
+    }
+    return missing;
+  }
+  addDirectories(target, paths, version, lastModified) {
+    for (const path of paths) {
+      target.set(path, { kind: "directory", version, lastModified });
+    }
+  }
+  touchParents(target, path, version, lastModified) {
+    for (const parent of parentChain(path)) {
+      const entry = target.get(parent);
+      if (entry?.kind === "directory") {
+        target.set(parent, { kind: "directory", version, lastModified });
+      }
+    }
+  }
+  withVersion(entry, version, lastModified) {
+    return entry.kind === "file" ? {
+      kind: "file",
+      data: entry.data,
+      payloadKind: entry.payloadKind,
+      version,
+      lastModified
+    } : { kind: "directory", version, lastModified };
+  }
+  nextVersion() {
+    this.mutationCounter += 1;
+    this.treeVersion = parseFileSystemVersion(`${this.id}:${this.mutationCounter}`);
+    return this.treeVersion;
+  }
+  toEntrySnapshot(path, entry) {
+    return entry.kind === "file" ? this.toFileSnapshot(path, entry) : this.toDirectorySnapshot(path, entry);
+  }
+  toFileSnapshot(path, entry) {
+    return Object.freeze({
+      kind: "file",
+      path,
+      name: workspacePathBasename(path),
+      size: entry.data.byteLength,
+      version: entry.version,
+      lastModified: entry.lastModified
+    });
+  }
+  toDirectorySnapshot(path, entry) {
+    return Object.freeze({
+      kind: "directory",
+      path,
+      name: workspacePathBasename(path),
+      size: null,
+      version: entry.version,
+      lastModified: entry.lastModified
+    });
+  }
+  emit(event) {
+    const complete = Object.freeze({
+      ...event,
+      sequence: ++this.eventSequence,
+      origin: "local"
+    });
+    this.pendingEvents.push(complete);
+    if (this.emittingEvents) return;
+    this.emittingEvents = true;
+    try {
+      while (this.pendingEvents.length > 0) {
+        const pending = this.pendingEvents.shift();
+        if (!pending) continue;
+        for (const watcher of [...this.watchers]) {
+          try {
+            watcher.listener(pending);
+          } catch {
+          }
+        }
+      }
+    } finally {
+      this.emittingEvents = false;
+    }
+  }
+  error(code, operation, path, message) {
+    return new FsError(code, message, { operation, path });
+  }
+};
+function parentChain(path) {
+  const parents = [];
+  let current = workspacePathDirname(path);
+  while (true) {
+    parents.unshift(current);
+    if (!current) return parents;
+    current = workspacePathDirname(current);
+  }
+}
+function addParentPaths(target, path) {
+  for (const parent of parentChain(path)) {
+    if (parent) target.add(parent);
+  }
+}
+function isMemoryFilePayloadKind(value) {
+  return value === "text" || value === "binary";
+}
+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 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/memory-provider.ts
+function canonicalPath(path) {
+  return parseWorkspacePath(path);
+}
+function entryPath(path, operation) {
+  const canonical = canonicalPath(path);
+  if (!canonical) {
+    throw new FsError("invalid-path", "The workspace root is not a file entry.", {
+      operation,
+      path
+    });
+  }
+  return canonical;
+}
+function decode(data) {
+  return new TextDecoder().decode(data);
+}
+var MemoryFileSystemProvider = class {
+  constructor(id, label) {
+    this.id = id;
+    this.label = label;
+    this.v2 = new MemoryFileSystemProviderV2(id, label);
+  }
+  /** Monotonic version of the complete in-memory tree. */
+  get treeVersion() {
+    return this.v2.mutationRevision;
+  }
+  /** Capture an owned deterministic copy of the complete transient tree. */
+  captureContents() {
+    const state = this.v2.captureState();
+    return {
+      files: state.files.map(
+        (file) => file.payloadKind === "text" ? { kind: "text", path: file.path, content: decode(file.data) } : { kind: "binary", path: file.path, data: file.data.slice(0) }
+      ),
+      directories: [...state.directories]
+    };
+  }
+  /** Atomically replace the complete tree after validating and owning all input. */
+  replaceContents(snapshot, expectedTreeVersion) {
+    const files = snapshot.files.map((file) => ({
+      path: entryPath(file.path, "write"),
+      payloadKind: file.kind,
+      data: file.kind === "text" ? new TextEncoder().encode(file.content) : file.data
+    }));
+    const directories = (snapshot.directories ?? []).map(
+      (path) => entryPath(path, "create-directory")
+    );
+    this.v2.replaceState({ files, directories }, expectedTreeVersion);
+  }
+  /** Seed synchronously before publishing a transient provider to consumers. */
+  seedText(path, content) {
+    this.v2.seedText(entryPath(path, "write"), content);
+  }
+  async readFile(path) {
+    const file = await this.v2.readFile(entryPath(path, "read"));
+    return file ? decode(file.data) : null;
+  }
+  async writeFile(path, content) {
+    await this.v2.writeText(entryPath(path, "write"), content, { createParents: true });
+  }
+  commitFile(path, content, expectedContent) {
+    return this.v2.commitText(entryPath(path, "write"), content, expectedContent);
+  }
+  async delete(path) {
+    await this.v2.remove(entryPath(path, "remove"), { recursive: true, missing: "ignore" });
+  }
+  async rename(oldPath, newPath) {
+    await this.v2.move(entryPath(oldPath, "move"), entryPath(newPath, "move"), {
+      createParents: true
+    });
+  }
+  async readDirectory(path) {
+    const canonical = canonicalPath(path);
+    try {
+      const entries = await this.v2.readDirectory(canonical);
+      return entries.map((entry) => ({
+        kind: entry.kind,
+        name: entry.name,
+        path: entry.path
+      }));
+    } catch (error) {
+      if (error instanceof FsError && error.code === "not-found") return [];
+      throw error;
+    }
+  }
+  async exists(path) {
+    return await this.v2.stat(canonicalPath(path)) !== null;
+  }
+  async createDirectory(path) {
+    await this.v2.createDirectory(canonicalPath(path), { createParents: true });
+  }
+  async stat(path) {
+    const canonical = canonicalPath(path);
+    if (!canonical) return null;
+    const entry = await this.v2.stat(canonical);
+    if (!entry || entry.kind !== "file") return null;
+    return {
+      name: entry.name,
+      path: entry.path,
+      size: entry.size,
+      lastModified: entry.lastModified
+    };
+  }
+  async readBinary(path) {
+    const canonical = entryPath(path, "read");
+    const file = this.v2.readCompatibilityFile(canonical);
+    if (!file || file.payloadKind !== "binary") return null;
+    return file.data;
+  }
+  async writeBinary(path, data) {
+    await this.v2.writeBinary(entryPath(path, "write"), data, { createParents: true });
+  }
+};
+
+export {
+  MemoryFileSystemProviderV2,
+  MemoryFileSystemProvider
+};
+//# sourceMappingURL=chunk-RQJRQF46.js.map