@bendyline/docblocks 1.1.2 → 2.0.0

package/dist/chunk-5MYAICRE.js

@@ -0,0 +1,957 @@
+import {
+  parseFileSystemVersion
+} from "./chunk-AYZ4HN5M.js";
+import {
+  FileSystemMoveRecoveryError,
+  FileSystemPartialMoveError,
+  describeEntryMove,
+  describePartialMove
+} from "./chunk-EGNDADXB.js";
+import {
+  FsError,
+  WORKSPACE_ROOT,
+  fsErrorFromUnknown,
+  parseWorkspacePath,
+  workspacePathBasename,
+  workspacePathContains,
+  workspacePathDirname,
+  workspacePathJoin,
+  workspacePathToLegacy
+} from "./chunk-SI2LU2RP.js";
+import {
+  getFileSystemProviderV2
+} from "./chunk-EZKJZUNJ.js";
+
+// src/filesystem/legacy-v2-adapter.ts
+var EPOCH = (/* @__PURE__ */ new Date(0)).toISOString();
+var LegacyFileSystemProviderV2Adapter = class {
+  constructor(provider, options) {
+    this.provider = provider;
+    this.options = options;
+    this.operationTail = Promise.resolve();
+    this.subscriptions = /* @__PURE__ */ new Set();
+    this.closing = false;
+    this.disposed = false;
+    this.disposePromise = null;
+    this.id = provider.id;
+    this.label = provider.label;
+    this.capabilities = Object.freeze({
+      writeAtomicity: options.writeAtomicity ?? "none",
+      moveAtomicity: options.moveAtomicity ?? "none",
+      // A tree snapshot spans multiple v1 calls; callers that bypass this
+      // adapter can still interleave, even though adapter operations serialize.
+      snapshotAtomicity: "none",
+      conditionalWrite: "process",
+      recursiveRemove: true,
+      watch: false,
+      caseSensitivity: options.caseSensitivity ?? "platform",
+      symlinkPolicy: options.symlinkPolicy ?? "unsupported",
+      durability: options.durability ?? "best-effort"
+    });
+  }
+  async stat(path) {
+    const canonical = this.canonical(path);
+    return this.enqueue("stat", async () => {
+      const entry = (await this.captureTree("stat")).entries.get(canonical);
+      return entry ? copyEntrySnapshot(entry) : null;
+    });
+  }
+  async readFile(path) {
+    const canonical = this.canonical(path);
+    return this.enqueue("read", async () => {
+      const entry = (await this.captureTree("read")).entries.get(canonical);
+      if (!entry) return null;
+      if (entry.kind !== "file") {
+        throw this.error("type-mismatch", "read", canonical, "Expected a file, found a directory.");
+      }
+      return Object.freeze({ entry: fileMetadata(entry), data: entry.data.slice(0) });
+    });
+  }
+  async readDirectory(path) {
+    const canonical = this.canonical(path);
+    return this.enqueue("list", async () => {
+      const tree = await this.captureTree("list");
+      const entry = tree.entries.get(canonical);
+      if (!entry) throw this.error("not-found", "list", canonical, "Directory does not exist.");
+      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);
+      return Object.freeze(children);
+    });
+  }
+  async writeFile(path, data, options = {}) {
+    const canonical = this.canonicalNonRoot(path, "write");
+    const ownedData = copyBytes(data);
+    return this.enqueue("write", async () => {
+      const tree = await this.captureTree("write");
+      const existing = tree.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);
+      this.assertParents(tree, canonical, options.createParents ?? false, "write");
+      await this.invoke(
+        () => this.provider.writeBinary(workspacePathToLegacy(canonical), ownedData),
+        "write",
+        canonical
+      );
+      const written = (await this.captureTree("write")).entries.get(canonical);
+      if (written?.kind !== "file" || !equalBytes(written.data, ownedData)) {
+        throw this.error(
+          "io",
+          "write",
+          canonical,
+          "The legacy provider did not persist the requested bytes."
+        );
+      }
+      return fileMetadata(written);
+    });
+  }
+  async createDirectory(path, options = {}) {
+    const canonical = this.canonical(path);
+    return this.enqueue("create-directory", async () => {
+      const tree = await this.captureTree("create-directory");
+      const existing = tree.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 copyDirectorySnapshot(existing);
+      }
+      this.assertParents(tree, canonical, options.createParents ?? false, "create-directory");
+      await this.invoke(
+        () => this.provider.createDirectory(workspacePathToLegacy(canonical)),
+        "create-directory",
+        canonical
+      );
+      const created = (await this.captureTree("create-directory")).entries.get(canonical);
+      if (created?.kind !== "directory") {
+        throw this.error(
+          "io",
+          "create-directory",
+          canonical,
+          "The legacy provider did not create the directory."
+        );
+      }
+      return copyDirectorySnapshot(created);
+    });
+  }
+  async remove(path, options = {}) {
+    const canonical = this.canonicalNonRoot(path, "remove");
+    return this.enqueue("remove", async () => {
+      const tree = await this.captureTree("remove");
+      const existing = tree.entries.get(canonical);
+      if (!existing) {
+        if ((options.missing ?? "error") === "ignore") {
+          return Object.freeze({ removed: false, version: tree.version });
+        }
+        throw this.error("not-found", "remove", canonical, "Entry does not exist.");
+      }
+      this.assertExpectedVersion(existing, options.expectedVersion, "remove", canonical);
+      if (existing.kind === "directory" && !options.recursive && [...tree.entries.keys()].some(
+        (candidate) => workspacePathContains(canonical, candidate, false)
+      )) {
+        throw this.error("not-empty", "remove", canonical, "Directory is not empty.");
+      }
+      await this.invoke(
+        () => this.provider.delete(workspacePathToLegacy(canonical)),
+        "remove",
+        canonical
+      );
+      const after = await this.captureTree("remove");
+      if ([...after.entries.keys()].some((candidate) => workspacePathContains(canonical, candidate))) {
+        throw this.error(
+          "io",
+          "remove",
+          canonical,
+          "The legacy provider did not remove the complete entry."
+        );
+      }
+      return Object.freeze({ removed: true, version: after.version });
+    });
+  }
+  async move(oldPath, newPath, options = {}) {
+    const sourcePath = this.canonicalNonRoot(oldPath, "move");
+    const destinationPath = this.canonicalNonRoot(newPath, "move");
+    return this.enqueue("move", async () => {
+      const tree = await this.captureTree("move");
+      const source = tree.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 copyEntrySnapshot(source);
+      if (tree.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
+        });
+      }
+      this.assertParents(tree, destinationPath, options.createParents ?? false, "move");
+      const sourceEntries = [...tree.entries.entries()].filter(
+        ([candidate]) => workspacePathContains(sourcePath, candidate)
+      );
+      await this.invoke(
+        () => this.provider.rename(
+          workspacePathToLegacy(sourcePath),
+          workspacePathToLegacy(destinationPath)
+        ),
+        "move",
+        sourcePath,
+        destinationPath
+      );
+      const after = await this.captureTree("move");
+      if ([...after.entries.keys()].some((candidate) => workspacePathContains(sourcePath, candidate))) {
+        throw this.error(
+          "io",
+          "move",
+          sourcePath,
+          "The legacy provider left source entries behind."
+        );
+      }
+      for (const [oldEntryPath, oldEntry] of sourceEntries) {
+        const suffix = oldEntryPath.slice(sourcePath.length);
+        const movedPath = parseWorkspacePath(`${destinationPath}${suffix}`);
+        const moved = after.entries.get(movedPath);
+        if (!moved || moved.kind !== oldEntry.kind || moved.version !== oldEntry.version) {
+          throw new FsError(
+            "io",
+            "The legacy provider did not move the complete entry unchanged.",
+            {
+              operation: "move",
+              path: oldEntryPath,
+              destinationPath: movedPath
+            }
+          );
+        }
+      }
+      return copyEntrySnapshot(after.entries.get(destinationPath));
+    });
+  }
+  async snapshot() {
+    return this.enqueue("snapshot", async () => {
+      const tree = await this.captureTree("snapshot");
+      const entries = [...tree.entries.values()].sort((left, right) => compareText(left.path, right.path)).map((entry) => copySnapshotEntry(entry));
+      return Object.freeze({ version: tree.version, entries: Object.freeze(entries) });
+    });
+  }
+  watch(_listener, options = {}) {
+    this.assertAccepting("watch");
+    const error = new FsError(
+      "not-supported",
+      "The legacy adapter cannot observe external changes.",
+      {
+        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.closing = true;
+    const run = this.operationTail.then(async () => {
+      try {
+        await Promise.all([...this.subscriptions].map((subscription) => subscription.dispose()));
+        await this.options.dispose?.();
+      } catch (error) {
+        throw fsErrorFromUnknown(error, { operation: "dispose" });
+      } finally {
+        this.disposed = true;
+      }
+    });
+    this.operationTail = run.then(
+      () => void 0,
+      () => void 0
+    );
+    this.disposePromise = run;
+    return run;
+  }
+  enqueue(operation, task) {
+    this.assertAccepting(operation);
+    const run = this.operationTail.then(task);
+    this.operationTail = run.then(
+      () => void 0,
+      () => void 0
+    );
+    return run;
+  }
+  assertAccepting(operation) {
+    if (!this.closing && !this.disposed) return;
+    throw new FsError("disposed", "Filesystem provider is disposed.", { operation });
+  }
+  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 an entry target."
+      );
+    }
+    return canonical;
+  }
+  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."
+    );
+  }
+  assertParents(tree, path, createParents, operation) {
+    let parent = workspacePathDirname(path);
+    const parents = [];
+    while (parent) {
+      parents.unshift(parent);
+      parent = workspacePathDirname(parent);
+    }
+    for (const candidate of parents) {
+      const entry = tree.entries.get(candidate);
+      if (entry?.kind === "file") {
+        throw this.error("type-mismatch", operation, candidate, "A parent path is a file.");
+      }
+      if (!entry && !createParents) {
+        throw this.error("not-found", operation, candidate, "Parent directory does not exist.");
+      }
+    }
+  }
+  async captureTree(operation) {
+    const entries = /* @__PURE__ */ new Map();
+    const visiting = /* @__PURE__ */ new Set();
+    const visitDirectory = async (path) => {
+      if (visiting.has(path)) {
+        throw this.error("io", operation, path, "The legacy provider returned a directory cycle.");
+      }
+      visiting.add(path);
+      const listed = await this.invoke(
+        () => this.provider.readDirectory(workspacePathToLegacy(path)),
+        operation,
+        path
+      );
+      if (!Array.isArray(listed)) {
+        throw this.error(
+          "io",
+          operation,
+          path,
+          "The legacy provider returned an invalid directory listing."
+        );
+      }
+      const children = [];
+      const seen = /* @__PURE__ */ new Set();
+      for (const candidate of listed) {
+        if (!isLegacyEntry(candidate)) {
+          throw this.error(
+            "io",
+            operation,
+            path,
+            "The legacy provider returned an invalid directory entry."
+          );
+        }
+        const legacyEntry = candidate;
+        const childPath = parseWorkspacePath(legacyEntry.path);
+        if (!childPath || workspacePathDirname(childPath) !== path || workspacePathBasename(childPath) !== legacyEntry.name) {
+          throw this.error(
+            "io",
+            operation,
+            path,
+            "The legacy provider returned a non-child entry."
+          );
+        }
+        if (seen.has(childPath) || entries.has(childPath)) {
+          throw this.error(
+            "io",
+            operation,
+            childPath,
+            "The legacy provider returned duplicate entry paths."
+          );
+        }
+        seen.add(childPath);
+        if (legacyEntry.kind === "directory") {
+          children.push(await visitDirectory(childPath));
+        } else {
+          const file = await this.captureFile(childPath, operation);
+          entries.set(childPath, file);
+          children.push(file);
+        }
+      }
+      children.sort(compareSnapshots);
+      const version = await contentVersion(
+        "directory",
+        new TextEncoder().encode(
+          children.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(children)
+      });
+      entries.set(path, directory);
+      visiting.delete(path);
+      return directory;
+    };
+    const root = await visitDirectory(WORKSPACE_ROOT);
+    return { entries, version: root.version };
+  }
+  async captureFile(path, operation) {
+    const legacyPath = workspacePathToLegacy(path);
+    let data;
+    if (this.options.payloadModel === "binary-authoritative") {
+      const binary = await this.invoke(() => this.provider.readBinary(legacyPath), operation, path);
+      data = binary ? binary.slice(0) : null;
+    } else if (this.options.payloadModel === "binary-first-text-fallback") {
+      const binary = await this.invoke(() => this.provider.readBinary(legacyPath), operation, path);
+      if (binary) {
+        data = binary.slice(0);
+      } else {
+        const text = await this.invoke(() => this.provider.readFile(legacyPath), operation, path);
+        data = text === null ? null : new TextEncoder().encode(text).buffer;
+      }
+    } else {
+      const binary = await this.invoke(() => this.provider.readBinary(legacyPath), operation, path);
+      const text = await this.invoke(() => this.provider.readFile(legacyPath), operation, path);
+      if (binary !== null && text !== null) {
+        throw this.error(
+          "conflict",
+          operation,
+          path,
+          "The split legacy store contains both text and binary payloads."
+        );
+      }
+      data = binary ? binary.slice(0) : text === null ? null : new TextEncoder().encode(text).buffer;
+    }
+    if (!data) {
+      throw this.error(
+        "io",
+        operation,
+        path,
+        "The legacy provider listed a file without a payload."
+      );
+    }
+    const meta = await this.invoke(() => this.provider.stat(legacyPath), operation, path);
+    if (!meta || parseWorkspacePath(meta.path) !== path || meta.name !== workspacePathBasename(path) || meta.size !== data.byteLength || !Number.isFinite(Date.parse(meta.lastModified))) {
+      throw this.error(
+        "io",
+        operation,
+        path,
+        "The legacy provider returned inconsistent file metadata."
+      );
+    }
+    return Object.freeze({
+      kind: "file",
+      path,
+      name: workspacePathBasename(path),
+      size: data.byteLength,
+      version: await contentVersion("file", new Uint8Array(data), operation, path),
+      lastModified: meta.lastModified,
+      data
+    });
+  }
+  async invoke(task, operation, path, destinationPath) {
+    try {
+      return await task();
+    } catch (error) {
+      throw fsErrorFromUnknown(error, { operation, path, destinationPath });
+    }
+  }
+  error(code, operation, path, message) {
+    return new FsError(code, message, { operation, path });
+  }
+};
+async function contentVersion(kind, data, operation, path) {
+  const prefix = new TextEncoder().encode(`${kind}\0`);
+  const input = new Uint8Array(prefix.byteLength + data.byteLength);
+  input.set(prefix);
+  input.set(data, 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 isLegacyEntry(value) {
+  if (!value || typeof value !== "object") return false;
+  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",
+    path: file.path,
+    name: file.name,
+    size: file.size,
+    version: file.version,
+    lastModified: file.lastModified
+  });
+}
+function copyDirectorySnapshot(directory) {
+  return Object.freeze({ ...directory });
+}
+function copyEntrySnapshot(entry) {
+  return entry.kind === "file" ? fileMetadata(entry) : copyDirectorySnapshot(entry);
+}
+function copySnapshotEntry(entry) {
+  return entry.kind === "file" ? Object.freeze({ ...fileMetadata(entry), data: entry.data.slice(0) }) : copyDirectorySnapshot(entry);
+}
+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/move-entry.ts
+function normalisePath(path) {
+  return parseWorkspacePath(path);
+}
+function dirname(path) {
+  const slash = path.lastIndexOf("/");
+  return slash < 0 ? "" : path.slice(0, slash);
+}
+function basename(path) {
+  const slash = path.lastIndexOf("/");
+  return slash < 0 ? path : path.slice(slash + 1);
+}
+function documentCompanionPath(documentPath) {
+  const rooted = documentPath.replace(/\\/g, "/").startsWith("/");
+  const clean = parseWorkspacePath(documentPath);
+  if (!clean) throw new Error("The workspace root has no document companion path.");
+  const parent = dirname(clean);
+  const name = basename(clean).replace(/\.[^.]+$/, "");
+  if (parent) return `${parent}/${name}_files`;
+  return rooted ? `/${name}_files` : `${name}_files`;
+}
+function isMarkdownPath(path) {
+  return /\.md$/i.test(basename(path));
+}
+async function moveFileSystemEntry(provider, oldPath, newPath, kind) {
+  const providerV2 = getFileSystemProviderV2(provider);
+  const exists = (candidate) => providerV2 ? providerV2.stat(parseWorkspacePath(candidate)).then((entry) => entry !== null) : provider.exists(candidate);
+  const move = (source, destination) => providerV2 ? providerV2.move(parseWorkspacePath(source), parseWorkspacePath(destination), {
+    createParents: true
+  }).then(() => void 0) : provider.rename(source, destination);
+  const oldNormalised = normalisePath(oldPath);
+  const newNormalised = normalisePath(newPath);
+  if (oldNormalised === newNormalised) return;
+  if (kind === "directory" && newNormalised.startsWith(`${oldNormalised}/`)) {
+    throw new Error("A folder cannot be moved into itself.");
+  }
+  if (await exists(newPath)) {
+    throw new Error(`An entry named "${basename(newPath)}" already exists there.`);
+  }
+  let oldCompanion = null;
+  let newCompanion = null;
+  if (kind === "file" && isMarkdownPath(oldPath)) {
+    const candidate = documentCompanionPath(oldPath);
+    if (await exists(candidate)) {
+      oldCompanion = candidate;
+      newCompanion = documentCompanionPath(newPath);
+      if (normalisePath(oldCompanion) !== normalisePath(newCompanion) && await exists(newCompanion)) {
+        throw new Error(`The companion folder "${basename(newCompanion)}" already exists there.`);
+      }
+    }
+  }
+  try {
+    await move(oldPath, newPath);
+  } catch (error) {
+    const state = await describeEntryMove(provider, oldPath, newPath);
+    if (state.source === "present" && state.destination === "missing") throw error;
+    throw new FileSystemMoveRecoveryError(oldPath, newPath, state, error);
+  }
+  if (!oldCompanion || !newCompanion) return;
+  try {
+    await move(oldCompanion, newCompanion);
+  } catch (error) {
+    try {
+      await move(newPath, oldPath);
+    } catch (rollbackError) {
+      const state2 = await describePartialMove(
+        provider,
+        oldPath,
+        newPath,
+        oldCompanion,
+        newCompanion
+      );
+      throw new FileSystemPartialMoveError(
+        oldPath,
+        newPath,
+        oldCompanion,
+        newCompanion,
+        state2,
+        error,
+        rollbackError
+      );
+    }
+    const state = await describePartialMove(provider, oldPath, newPath, oldCompanion, newCompanion);
+    const restoredSourceOnly = state.source === "present" && state.destination === "missing" && state.companionSource === "present" && state.companionDestination === "missing";
+    if (!restoredSourceOnly) {
+      throw new FileSystemPartialMoveError(
+        oldPath,
+        newPath,
+        oldCompanion,
+        newCompanion,
+        state,
+        error,
+        null
+      );
+    }
+    throw error;
+  }
+}
+
+// src/filesystem/dbk-workspace.ts
+function normaliseRelativePath(path, label) {
+  if (path.includes("\\") || path.includes("\0")) {
+    throw new Error(`DBK ${label} must use a safe forward-slash path: ${path}`);
+  }
+  const normalized = path.replace(/^\/+|\/+$/g, "").replace(/\/+/g, "/");
+  const segments = normalized ? normalized.split("/") : [];
+  if (segments.length === 0 || segments.some((segment) => segment === "." || segment === "..")) {
+    throw new Error(`DBK ${label} must not be empty or traverse directories: ${path}`);
+  }
+  return segments.join("/");
+}
+function joinPath(parent, child) {
+  return `${parent.replace(/\/+$/g, "")}/${child.replace(/^\/+/, "")}`;
+}
+async function createDbkWorkspaceSnapshot(source, options) {
+  const targetDocumentPath = normaliseRelativePath(
+    options.targetDocumentPath,
+    "target document path"
+  );
+  const discoveredDocumentPath = await source.getDocumentPath();
+  if (!discoveredDocumentPath)
+    throw new Error("The external DBK has no primary markdown document.");
+  const sourceDocumentPath = normaliseRelativePath(discoveredDocumentPath, "primary document path");
+  const requestedLayout = options.assetLayout ?? "auto";
+  const assetLayout = requestedLayout === "auto" ? sourceDocumentPath === targetDocumentPath ? "preserve" : "companion" : requestedLayout;
+  const companionPath = normaliseRelativePath(
+    documentCompanionPath(targetDocumentPath),
+    "companion directory path"
+  );
+  const listed = await source.listFiles();
+  const entries = [...listed].sort((a, b) => a.path.localeCompare(b.path));
+  const seenSourcePaths = /* @__PURE__ */ new Set();
+  const files = [];
+  let documentContent = null;
+  for (const entry of entries) {
+    const sourcePath = normaliseRelativePath(entry.path, "entry path");
+    if (seenSourcePaths.has(sourcePath)) {
+      throw new Error(`The external DBK contains duplicate paths: ${sourcePath}`);
+    }
+    seenSourcePaths.add(sourcePath);
+    const data = await source.readFile(entry.path);
+    if (data === null) {
+      throw new Error(`The external DBK changed while reading: ${sourcePath}`);
+    }
+    if (sourcePath === sourceDocumentPath) {
+      documentContent = new TextDecoder().decode(data);
+      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 });
+    }
+  }
+  if (documentContent === null) {
+    throw new Error(`The external DBK did not include its primary document: ${sourceDocumentPath}`);
+  }
+  return {
+    sourceDocumentPath,
+    targetDocumentPath,
+    documentContent,
+    assetLayout,
+    files
+  };
+}
+async function replaceMemoryWorkspaceFromDbk(provider, source, options) {
+  const expectedTreeVersion = provider.treeVersion;
+  const snapshot = await createDbkWorkspaceSnapshot(source, options);
+  provider.replaceContents(snapshot, expectedTreeVersion);
+  return snapshot;
+}
+
+// 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);
+}
+var FileSystemContentContainer = class {
+  constructor(provider, prefix = ".docblocks/media") {
+    this.provider = provider;
+    this.prefix = parseWorkspacePath(prefix);
+  }
+  async readFile(path) {
+    const full = joinPrefix(this.prefix, path);
+    const providerV2 = getFileSystemProviderV2(this.provider);
+    if (providerV2) return (await providerV2.readFile(parseWorkspacePath(full)))?.data ?? null;
+    const binary = await this.provider.readBinary(full);
+    if (binary) return binary;
+    const text = await this.provider.readFile(full);
+    if (text === null) return null;
+    return new TextEncoder().encode(text).buffer;
+  }
+  async writeFile(path, data, _mimeType) {
+    const full = joinPrefix(this.prefix, path);
+    const providerV2 = getFileSystemProviderV2(this.provider);
+    if (providerV2) {
+      await providerV2.writeFile(parseWorkspacePath(full), data, {
+        mode: "upsert",
+        createParents: true
+      });
+      return;
+    }
+    await this.provider.writeBinary(full, data);
+  }
+  async removeFile(path) {
+    const full = joinPrefix(this.prefix, path);
+    const providerV2 = getFileSystemProviderV2(this.provider);
+    if (providerV2) {
+      await providerV2.remove(parseWorkspacePath(full), { missing: "ignore" });
+      return;
+    }
+    await this.provider.delete(full);
+  }
+  async listFiles(prefix) {
+    const entries = [];
+    const providerV2 = getFileSystemProviderV2(this.provider);
+    const root = parseWorkspacePath(this.prefix);
+    const walk = async (dir) => {
+      let children;
+      try {
+        children = providerV2 ? await providerV2.readDirectory(parseWorkspacePath(dir)) : await this.provider.readDirectory(dir);
+      } catch (error) {
+        if (dir === root && error instanceof FsError && error.code === "not-found") return;
+        throw error;
+      }
+      for (const child of children) {
+        if (child.kind === "directory") {
+          await walk(child.path);
+        } else {
+          const childPath = parseWorkspacePath(child.path);
+          const prefixPath = parseWorkspacePath(this.prefix);
+          if (!workspacePathContains(prefixPath, childPath)) continue;
+          const rel = childPath === prefixPath ? "" : childPath.slice(prefixPath.length + 1);
+          if (prefix && !rel.startsWith(prefix)) continue;
+          const size = child.size ?? (await this.provider.stat(child.path))?.size ?? 0;
+          entries.push({
+            path: rel,
+            mimeType: guessMimeType(rel),
+            size
+          });
+        }
+      }
+    };
+    await walk(root);
+    return entries;
+  }
+  async exists(path) {
+    const full = joinPrefix(this.prefix, path);
+    const providerV2 = getFileSystemProviderV2(this.provider);
+    return providerV2 ? await providerV2.stat(parseWorkspacePath(full)) !== null : this.provider.exists(full);
+  }
+  async getDocumentPath() {
+    return findDocumentPath(await this.listFiles());
+  }
+  async readDocument() {
+    const docPath = await this.getDocumentPath();
+    if (!docPath) return null;
+    const data = await this.readFile(docPath);
+    if (!data) return null;
+    return new TextDecoder().decode(data);
+  }
+  async writeDocument(markdown, filename) {
+    const name = filename ?? "index.md";
+    const data = new TextEncoder().encode(markdown);
+    await this.writeFile(name, data, "text/markdown");
+  }
+};
+
+// src/filesystem/file-media-provider.ts
+function stripExt(name) {
+  return name.replace(/\.[^.]+$/, "");
+}
+function createFileMediaProvider(container, markdownBasename) {
+  const folder = stripExt(markdownBasename) + "_files";
+  const prefix = folder + "/";
+  const blobUrlCache = /* @__PURE__ */ new Map();
+  function toKey(ref) {
+    const clean = ref.replace(/^\/+/, "");
+    return clean.startsWith(prefix) ? clean : prefix + clean;
+  }
+  return {
+    async resolveUrl(ref) {
+      const key = toKey(ref);
+      const cached = blobUrlCache.get(key);
+      if (cached) return cached;
+      const data = await container.readFile(key);
+      if (!data) return ref;
+      const entries = await container.listFiles();
+      const entry = entries.find((e) => e.path === key);
+      const mimeType = entry?.mimeType ?? "application/octet-stream";
+      const url = URL.createObjectURL(new Blob([data], { type: mimeType }));
+      blobUrlCache.set(key, url);
+      return url;
+    },
+    async listMedia() {
+      const entries = await container.listFiles(prefix);
+      return entries.filter((e) => !e.path.toLowerCase().endsWith(".md")).map((e) => ({
+        name: e.path,
+        mimeType: e.mimeType,
+        size: e.size
+      }));
+    },
+    async addMedia(name, data, mimeType) {
+      const key = toKey(name);
+      const cached = blobUrlCache.get(key);
+      if (cached) {
+        URL.revokeObjectURL(cached);
+        blobUrlCache.delete(key);
+      }
+      const buffer = data instanceof Blob ? new Uint8Array(await data.arrayBuffer()) : data;
+      await container.writeFile(key, buffer, mimeType);
+      return key;
+    },
+    async removeMedia(ref) {
+      const key = toKey(ref);
+      const cached = blobUrlCache.get(key);
+      if (cached) {
+        URL.revokeObjectURL(cached);
+        blobUrlCache.delete(key);
+      }
+      await container.removeFile(key);
+    },
+    dispose() {
+      for (const url of blobUrlCache.values()) {
+        URL.revokeObjectURL(url);
+      }
+      blobUrlCache.clear();
+    }
+  };
+}
+
+export {
+  LegacyFileSystemProviderV2Adapter,
+  documentCompanionPath,
+  moveFileSystemEntry,
+  createDbkWorkspaceSnapshot,
+  replaceMemoryWorkspaceFromDbk,
+  FileSystemContentContainer,
+  createFileMediaProvider
+};
+//# sourceMappingURL=chunk-5MYAICRE.js.map