@bendyline/docblocks 2.6.1 → 2.7.0

package/dist/catalog-BQK05tne.d.ts

@@ -0,0 +1,122 @@
+import { MarkdownDocument } from '@bendyline/squisq/markdown';
+import { C as CatalogSortOrder } from './settings-HrrCikVX.js';
+
+/**
+ * Synchronous outside-in path layout.
+ *
+ * The canonical contract is `@bendyline/squisq-formats/outside-in`, but that
+ * entry also loads every format runtime. DocBlocks surfaces that only need
+ * the path rules — the shell's navigation, the workspace catalog walker, and
+ * the VS Code extension host — share this one copy instead.
+ */
+declare const OUTSIDE_IN_FORMAT_IDS: readonly ["html", "docx", "pdf", "pptx", "xlsx", "csv"];
+type OutsideInFormatId = (typeof OUTSIDE_IN_FORMAT_IDS)[number];
+interface OutsideInLayout {
+    targetPath: string;
+    format: OutsideInFormatId;
+    parentDirectory: string;
+    stem: string;
+    companionName: string;
+    companionDirectory: string;
+    markdownFilename: string;
+    markdownPath: string;
+    relativeTargetPath: string;
+    backupDirectory: string;
+    backupFilename: string;
+    backupPath: string;
+}
+declare function resolveOutsideInLayout(path: string): OutsideInLayout | null;
+/** Move the companion root while preserving the authored Markdown slug. */
+declare function relocateOutsideInLayout(layout: OutsideInLayout, targetPath: string): OutsideInLayout;
+declare function chooseOutsideInMarkdownPath(layout: OutsideInLayout, paths: readonly string[]): string | null;
+
+/**
+ * Workspace catalog model — the data behind the generated catalog JSON and
+ * catalog HTML page.
+ *
+ * Everything here is deterministic: identical inputs produce identical bytes
+ * on every surface (shell, VS Code extension host, CLI). There are no
+ * timestamps, no filesystem mtimes, and no locale-sensitive ordering, so a
+ * catalog committed to git only changes when the documents do.
+ */
+
+declare const CATALOG_GENERATOR = "docblocks-workspace-catalog";
+declare const CATALOG_FORMAT_VERSION = 1;
+declare const CATALOG_LIMITS: {
+    readonly maxOutlineEntries: 100;
+    readonly maxOutlineTitleCharacters: 256;
+    readonly maxExcerptCharacters: 280;
+    readonly maxDescriptionCharacters: 1024;
+    readonly maxMetadataCharacters: 256;
+    readonly maxTags: 32;
+};
+type CatalogDocumentFormat = 'markdown' | OutsideInFormatId;
+interface CatalogOutlineEntry {
+    readonly level: number;
+    readonly title: string;
+}
+interface CatalogEntry {
+    /** The document people open — the rendered file for outside-in documents. */
+    readonly path: string;
+    /** The Markdown source when it differs from `path` (outside-in companion). */
+    readonly source?: string;
+    readonly format: CatalogDocumentFormat;
+    readonly title: string;
+    readonly description?: string;
+    readonly author?: string;
+    readonly date?: string;
+    readonly tags?: readonly string[];
+    readonly theme?: string;
+    readonly outline: readonly CatalogOutlineEntry[];
+    readonly wordCount: number;
+    readonly excerpt?: string;
+    /** Present only when the catalog is configured with `content: "markdown"`. */
+    readonly markdown?: string;
+}
+interface WorkspaceCatalog {
+    readonly generator: typeof CATALOG_GENERATOR;
+    readonly version: typeof CATALOG_FORMAT_VERSION;
+    readonly title: string;
+    readonly documents: readonly CatalogEntry[];
+}
+interface CatalogSource {
+    readonly path: string;
+    readonly source?: string;
+    readonly format: CatalogDocumentFormat;
+}
+interface CatalogEntryHints {
+    /** Title used when the document has neither a frontmatter title nor a heading. */
+    readonly fallbackTitle?: string;
+    readonly description?: string;
+}
+/** Build a catalog entry from an already-parsed Markdown document. */
+declare function catalogEntryFromDocument(source: CatalogSource, document: MarkdownDocument, hints?: CatalogEntryHints): Promise<CatalogEntry>;
+/** Parse Markdown source and build its catalog entry. */
+declare function catalogEntryFromMarkdown(source: CatalogSource, markdown: string, options?: {
+    readonly includeMarkdown?: boolean;
+}): Promise<CatalogEntry>;
+/** A document whose content cannot be read (e.g. an un-imported DOCX): listed by name only. */
+declare function catalogEntryForUnreadable(source: CatalogSource): CatalogEntry;
+declare function sortCatalogEntries(entries: readonly CatalogEntry[], order: CatalogSortOrder): CatalogEntry[];
+declare function createWorkspaceCatalog(title: string, entries: readonly CatalogEntry[], order: CatalogSortOrder): WorkspaceCatalog;
+/**
+ * Deterministic catalog JSON. The fixed leading `"generator"` key doubles as
+ * the marker that lets DocBlocks recognize — and only ever replace — a file
+ * it generated.
+ */
+declare function serializeCatalogJson(catalog: WorkspaceCatalog): string;
+declare function isGeneratedCatalogJson(text: string): boolean;
+/** Insert the generator marker directly after the doctype so it cannot affect quirks mode. */
+declare function stampCatalogHtml(html: string, inputsDigest: string): string;
+declare function readCatalogHtmlDigest(text: string): string | null;
+declare function isGeneratedCatalogHtml(text: string): boolean;
+/** Relative, per-segment-encoded URL from the catalog's directory to a document. */
+declare function relativeCatalogLink(fromDirectory: string, toPath: string): string;
+/**
+ * Build the catalog page as a Markdown AST rather than Markdown text, so a
+ * document title or description can never inject Markdown or HTML: every
+ * value reaches the renderer as an escaped text node.
+ */
+declare function buildCatalogMarkdownDocument(catalog: WorkspaceCatalog, outputPath: string): MarkdownDocument;
+
+export { type CatalogEntry as C, OUTSIDE_IN_FORMAT_IDS as O, type WorkspaceCatalog as W, CATALOG_FORMAT_VERSION as a, CATALOG_GENERATOR as b, CATALOG_LIMITS as c, type CatalogDocumentFormat as d, type CatalogEntryHints as e, type CatalogOutlineEntry as f, type CatalogSource as g, type OutsideInFormatId as h, type OutsideInLayout as i, buildCatalogMarkdownDocument as j, catalogEntryForUnreadable as k, catalogEntryFromDocument as l, catalogEntryFromMarkdown as m, chooseOutsideInMarkdownPath as n, createWorkspaceCatalog as o, isGeneratedCatalogHtml as p, isGeneratedCatalogJson as q, readCatalogHtmlDigest as r, relativeCatalogLink as s, relocateOutsideInLayout as t, resolveOutsideInLayout as u, serializeCatalogJson as v, sortCatalogEntries as w, stampCatalogHtml as x };

package/dist/chunk-245W57QP.js

@@ -0,0 +1,31 @@
+// src/filesystem/capabilities.ts
+function parseFileSystemCapabilities(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new TypeError("Invalid filesystem capabilities.");
+  }
+  const record = value;
+  const choices = {
+    writeAtomicity: ["none", "process", "cross-context"],
+    moveAtomicity: ["none", "process", "cross-context"],
+    snapshotAtomicity: ["none", "process", "cross-context"],
+    conditionalWrite: ["none", "process", "cross-context", "storage-atomic"],
+    recursiveRemove: [true, false],
+    watch: [true, false],
+    caseSensitivity: ["sensitive", "insensitive", "platform"],
+    symlinkPolicy: ["unsupported", "reject", "follow-contained", "preserve"],
+    durability: ["volatile", "best-effort", "durable"]
+  };
+  if (Object.keys(record).length !== Object.keys(choices).length) {
+    throw new TypeError("Unexpected filesystem capability fields.");
+  }
+  for (const [key, values] of Object.entries(choices)) {
+    if (!values.includes(record[key])) {
+      throw new TypeError(`Invalid filesystem capability: ${key}.`);
+    }
+  }
+  return Object.freeze({ ...record });
+}
+
+export {
+  parseFileSystemCapabilities
+};

package/dist/{chunk-2WDJ27EH.js → chunk-46AGYHDY.js}

@@ -11,6 +11,13 @@ var HOST_WIRE_LIMITS = Object.freeze({
   base64Characters: 140 * 1024 * 1024,
   arrayEntries: 1e4
 });
+var EXPORT_TRANSFER_LIMITS = Object.freeze({
+  fileBytes: 16 * 1024 * 1024 * 1024,
+  chunkBytes: 4 * 1024 * 1024,
+  transfers: 4,
+  idleMs: 12e4,
+  lifetimeMs: 60 * 6e4
+});
 function hasExactKeys(value, keys) {
   const actual = Object.keys(value);
   return actual.length === keys.length && keys.every((key) => Object.prototype.hasOwnProperty.call(value, key));
@@ -91,6 +98,7 @@ function isTrustedRendererUrl(value, developmentOrigin) {
 export {
   MAX_HOST_PINNED_DOCUMENTS,
   HOST_WIRE_LIMITS,
+  EXPORT_TRANSFER_LIMITS,
   isBoundedString,
   isBoundedBytePayload,
   parseOpenRequest,

package/dist/{chunk-4437YWLE.js → chunk-6UPO2GE6.js}

@@ -8,9 +8,11 @@ import {
   bytesEqual,
   compareSnapshotsByName,
   compareText,
-  copyBytes,
+  copyBytes
+} from "./chunk-HABG2JM3.js";
+import {
   parseFileSystemVersion
-} from "./chunk-M62ZGJ5I.js";
+} from "./chunk-LPIJ6HKL.js";
 import {
   decodeUtf8Text
 } from "./chunk-M5ZNQGR5.js";

package/dist/{chunk-UMWCTEXW.js → chunk-7SN7YQL4.js}

@@ -1,19 +1,26 @@
 import {
   guessMimeType
-} from "./chunk-YM7O3PWO.js";
+} from "./chunk-HKOOHM67.js";
 import {
   bytesEqual,
   compareSnapshotsByName,
   compareText,
-  copyBytes,
+  copyBytes
+} from "./chunk-HABG2JM3.js";
+import {
   parseFileSystemVersion
-} from "./chunk-M62ZGJ5I.js";
+} from "./chunk-LPIJ6HKL.js";
 import {
+  DocumentSession,
   FileSystemMoveRecoveryError,
   FileSystemPartialMoveError,
+  createFileSystemDocumentTarget,
   describeEntryMove,
   describePartialMove
-} from "./chunk-QI6YKTQV.js";
+} from "./chunk-IGB2VSRE.js";
+import {
+  getFileSystemProviderV2
+} from "./chunk-XAMILHQP.js";
 import {
   FsError,
   WORKSPACE_ROOT,
@@ -25,9 +32,6 @@ import {
   workspacePathJoin,
   workspacePathToLegacy
 } from "./chunk-AYWKIZLD.js";
-import {
-  getFileSystemProviderV2
-} from "./chunk-XAMILHQP.js";
 
 // src/filesystem/legacy-v2-adapter.ts
 var EPOCH = (/* @__PURE__ */ new Date(0)).toISOString();
@@ -578,6 +582,93 @@ function newestLastModified(children) {
   return newest ? new Date(newest).toISOString() : EPOCH;
 }
 
+// src/filesystem/companion-references.ts
+async function rewriteCompanionReferences(content, oldPath, newPath) {
+  const companionName = (path) => path.split("/").pop().replace(/\.[^.]+$/, "") + "_files";
+  const oldName = companionName(oldPath);
+  const newName = companionName(newPath);
+  if (oldName === newName || !content.includes(oldName) && !content.includes(encodeURI(oldName)))
+    return content;
+  const { parseMarkdown, stringifyMarkdown } = await import("@bendyline/squisq/markdown");
+  const document = parseMarkdown(content);
+  let changed = false;
+  const rewrite = (value) => {
+    const relative = value.startsWith("./") ? "./" : "";
+    const path = value.slice(relative.length);
+    for (const [before, after] of [
+      [oldName, newName],
+      [encodeURI(oldName), encodeURI(newName)]
+    ]) {
+      if (path.startsWith(`${before}/`)) {
+        changed = true;
+        return `${relative}${after}/${path.slice(before.length + 1)}`;
+      }
+    }
+    return value;
+  };
+  const mediaFields = /* @__PURE__ */ new Set([
+    "src",
+    "href",
+    "poster",
+    "audio",
+    "video",
+    "image",
+    "backgroundImage"
+  ]);
+  const visit = (value) => {
+    if (!value || typeof value !== "object") return;
+    if (Array.isArray(value)) {
+      value.forEach(visit);
+      return;
+    }
+    const node = value;
+    if (["image", "link", "definition"].includes(String(node.type)) && typeof node.url === "string") {
+      node.url = rewrite(node.url);
+    }
+    if ((node.type === "htmlBlock" || node.type === "htmlInline") && typeof node.rawHtml === "string") {
+      node.rawHtml = node.rawHtml.replace(
+        /<(?:img|audio|video|source|a)\b[^>]*>/gi,
+        (tag) => tag.replace(
+          /(\s)(src|href|poster)(\s*=\s*)(?:"([^"]*)"|'([^']*)'|([^\s"'=<>`]+))/gi,
+          (_match, space, name, equals, doubleQuoted, singleQuoted, unquoted) => {
+            const quote = doubleQuoted !== void 0 ? '"' : singleQuoted !== void 0 ? "'" : "";
+            return `${space}${name}${equals}${quote}${rewrite(doubleQuoted ?? singleQuoted ?? unquoted ?? "")}${quote}`;
+          }
+        )
+      );
+    }
+    for (const field of ["attributes", "params"]) {
+      const attributes = node[field];
+      if (attributes && typeof attributes === "object" && !Array.isArray(attributes)) {
+        const values = attributes;
+        for (const key of mediaFields)
+          if (typeof values[key] === "string") values[key] = rewrite(values[key]);
+      }
+    }
+    for (const [key, child] of Object.entries(node)) {
+      if (key !== "frontmatter" && key !== "position" && key !== "htmlChildren") visit(child);
+    }
+  };
+  const replacements = [];
+  for (const block of document.children) {
+    changed = false;
+    visit(block);
+    if (!changed) continue;
+    const start = block.position?.start.offset;
+    const end = block.position?.end.offset;
+    if (start === void 0 || end === void 0) {
+      throw new Error("Cannot locate a media reference in the Markdown source.");
+    }
+    let text = stringifyMarkdown({ type: "document", children: [block] }).replace(/\n+$/, "");
+    if (content.includes("\r\n")) text = text.replace(/\n/g, "\r\n");
+    replacements.push({ start, end, text });
+  }
+  for (const replacement of replacements.reverse()) {
+    content = content.slice(0, replacement.start) + replacement.text + content.slice(replacement.end);
+  }
+  return content;
+}
+
 // src/filesystem/move-entry.ts
 function normalisePath(path) {
   return parseWorkspacePath(path);
@@ -600,9 +691,9 @@ function documentCompanionPath(documentPath) {
   return rooted ? `/${name}_files` : `${name}_files`;
 }
 function hasDocumentCompanion(path) {
-  return /\.(?:md|html?|docx|pdf|pptx|xlsx)$/i.test(basename(path));
+  return /\.(?:md|html?|docx|pdf|pptx|xlsx|csv)$/i.test(basename(path));
 }
-async function moveFileSystemEntry(provider, oldPath, newPath, kind) {
+async function moveFileSystemEntry(provider, oldPath, newPath, kind, options = {}) {
   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), {
@@ -629,6 +720,16 @@ async function moveFileSystemEntry(provider, oldPath, newPath, kind) {
       }
     }
   }
+  let markdown;
+  if (oldCompanion && options.rewriteMarkdown !== false && /\.md$/i.test(oldPath)) {
+    const source = providerV2 ? await providerV2.readFile(parseWorkspacePath(oldPath)).then(
+      (read) => read ? new TextDecoder("utf-8", { fatal: true }).decode(read.data) : null
+    ) : await provider.readFile(oldPath);
+    if (source !== null) {
+      const next = await rewriteCompanionReferences(source, oldPath, newPath);
+      if (source !== next) markdown = { previous: source, next };
+    }
+  }
   try {
     await move(oldPath, newPath);
   } catch (error) {
@@ -675,6 +776,26 @@ async function moveFileSystemEntry(provider, oldPath, newPath, kind) {
     }
     throw error;
   }
+  if (markdown) {
+    const session = new DocumentSession({ autoSaveEnabled: false });
+    try {
+      const state = await session.transitionTo(
+        createFileSystemDocumentTarget(provider, newPath),
+        markdown.previous
+      );
+      session.edit(markdown.next, { targetKey: state.targetKey, generation: state.generation });
+      await session.flush("transition");
+    } catch (error) {
+      throw new FileSystemMoveRecoveryError(
+        oldPath,
+        newPath,
+        await describeEntryMove(provider, oldPath, newPath),
+        error
+      );
+    } finally {
+      await session.cancel();
+    }
+  }
 }
 
 // src/filesystem/dbk-workspace.ts
@@ -734,6 +855,7 @@ async function createDbkWorkspaceSnapshot(source, options) {
       throw new Error(`The external DBK contains duplicate paths: ${sourcePath}`);
     }
     seenSourcePaths.add(sourcePath);
+    if (sourcePath.startsWith(".docblocks/")) continue;
     if (!/\.md$/iu.test(sourcePath)) {
       throw new Error(
         `The external DBK is corrupt: only Markdown (.md) files are allowed (${sourcePath}).`
@@ -779,13 +901,33 @@ import { findDocumentPath } from "@bendyline/squisq/storage";
 function joinPrefix(prefix, p) {
   return workspacePathJoin(parseWorkspacePath(prefix), p);
 }
+function canonicalPrefixFolder(prefix) {
+  const folder = prefix?.includes("/") ? prefix.slice(0, prefix.lastIndexOf("/")) : "";
+  try {
+    return folder && parseWorkspacePath(folder) === folder ? folder : "";
+  } catch {
+    return "";
+  }
+}
 var FileSystemContentContainer = class {
-  constructor(provider, prefix = ".docblocks/media") {
+  constructor(provider, prefix = ".docblocks/media", options = {}) {
     this.provider = provider;
     this.prefix = parseWorkspacePath(prefix);
+    this.documentMediaPrefix = parseWorkspacePath(options.documentMediaPrefix ?? "");
+  }
+  /** A document-scoped container also accepts the media references written
+   * into its Markdown, e.g. notes_files/audio/take.webm. Version paths and
+   * container-relative discovery still live directly under the scoped root. */
+  resolve(path) {
+    const canonical = parseWorkspacePath(path);
+    const alias = this.documentMediaPrefix;
+    return joinPrefix(
+      this.prefix,
+      alias && canonical.startsWith(`${alias}/`) ? canonical.slice(alias.length + 1) : canonical
+    );
   }
   async readFile(path) {
-    const full = joinPrefix(this.prefix, path);
+    const full = this.resolve(path);
     const providerV2 = getFileSystemProviderV2(this.provider);
     if (providerV2) return (await providerV2.readFile(parseWorkspacePath(full)))?.data ?? null;
     const binary = await this.provider.readBinary(full);
@@ -795,7 +937,7 @@ var FileSystemContentContainer = class {
     return new TextEncoder().encode(text).buffer;
   }
   async writeFile(path, data, _mimeType) {
-    const full = joinPrefix(this.prefix, path);
+    const full = this.resolve(path);
     const providerV2 = getFileSystemProviderV2(this.provider);
     if (providerV2) {
       await providerV2.writeFile(parseWorkspacePath(full), data, {
@@ -807,7 +949,7 @@ var FileSystemContentContainer = class {
     await this.provider.writeBinary(full, data);
   }
   async removeFile(path) {
-    const full = joinPrefix(this.prefix, path);
+    const full = this.resolve(path);
     const providerV2 = getFileSystemProviderV2(this.provider);
     if (providerV2) {
       await providerV2.remove(parseWorkspacePath(full), { missing: "ignore" });
@@ -819,22 +961,26 @@ var FileSystemContentContainer = class {
     const entries = [];
     const providerV2 = getFileSystemProviderV2(this.provider);
     const root = parseWorkspacePath(this.prefix);
+    const relativePath = (childPath) => root ? childPath === root ? "" : childPath.slice(root.length + 1) : childPath;
+    const prefixFolder = canonicalPrefixFolder(prefix);
+    const start = prefixFolder ? workspacePathJoin(root, prefixFolder) : root;
     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;
+        const absent = error instanceof FsError && (error.code === "not-found" || dir !== root && error.code === "type-mismatch");
+        if (dir === start && absent) return;
         throw error;
       }
       for (const child of children) {
+        const childPath = parseWorkspacePath(child.path);
         if (child.kind === "directory") {
+          if (prefix && !`${relativePath(childPath)}/`.startsWith(prefix)) continue;
           await walk(child.path);
         } else {
-          const childPath = parseWorkspacePath(child.path);
-          const prefixPath = parseWorkspacePath(this.prefix);
-          if (!workspacePathContains(prefixPath, childPath)) continue;
-          const rel = prefixPath ? childPath === prefixPath ? "" : childPath.slice(prefixPath.length + 1) : childPath;
+          if (!workspacePathContains(root, childPath)) continue;
+          const rel = relativePath(childPath);
           if (prefix && !rel.startsWith(prefix)) continue;
           const size = child.size ?? (await this.provider.stat(child.path))?.size ?? 0;
           entries.push({
@@ -845,11 +991,11 @@ var FileSystemContentContainer = class {
         }
       }
     };
-    await walk(root);
+    await walk(start);
     return entries;
   }
   async exists(path) {
-    const full = joinPrefix(this.prefix, path);
+    const full = this.resolve(path);
     const providerV2 = getFileSystemProviderV2(this.provider);
     return providerV2 ? await providerV2.stat(parseWorkspacePath(full)) !== null : this.provider.exists(full);
   }
@@ -878,24 +1024,46 @@ function createFileMediaProvider(container, markdownBasename) {
   const folder = stripExt(markdownBasename) + "_files";
   const prefix = folder + "/";
   const blobUrlCache = /* @__PURE__ */ new Map();
+  const pending = /* @__PURE__ */ new Map();
+  const generations = /* @__PURE__ */ new Map();
+  let disposed = false;
   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;
+  function invalidate(key) {
+    generations.set(key, (generations.get(key) ?? 0) + 1);
+    pending.delete(key);
+    const cached = blobUrlCache.get(key);
+    if (cached) URL.revokeObjectURL(cached);
+    blobUrlCache.delete(key);
+  }
+  function resolveUrl(ref) {
+    if (disposed) return Promise.resolve(ref);
+    const key = toKey(ref);
+    const cached = blobUrlCache.get(key);
+    if (cached) return Promise.resolve(cached);
+    const existing = pending.get(key);
+    if (existing) {
+      return existing.promise.then((url) => url === existing.ref ? ref : url);
+    }
+    const generation = generations.get(key) ?? 0;
+    const work = (async () => {
       const data = await container.readFile(key);
+      if (disposed) return ref;
+      if ((generations.get(key) ?? 0) !== generation) return resolveUrl(ref);
       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 }));
+      const url = URL.createObjectURL(new Blob([data], { type: guessMimeType(key) }));
       blobUrlCache.set(key, url);
       return url;
-    },
+    })().finally(() => {
+      if (pending.get(key)?.promise === work) pending.delete(key);
+    });
+    pending.set(key, { ref, promise: work });
+    return work;
+  }
+  return {
+    resolveUrl,
     async listMedia() {
       const entries = await container.listFiles(prefix);
       return entries.filter((e) => !e.path.toLowerCase().endsWith(".md")).map((e) => ({
@@ -906,25 +1074,27 @@ function createFileMediaProvider(container, markdownBasename) {
     },
     async addMedia(name, data, mimeType) {
       const key = toKey(name);
-      const cached = blobUrlCache.get(key);
-      if (cached) {
-        URL.revokeObjectURL(cached);
-        blobUrlCache.delete(key);
-      }
+      invalidate(key);
+      const generation = generations.get(key);
       const buffer = data instanceof Blob ? new Uint8Array(await data.arrayBuffer()) : data;
       await container.writeFile(key, buffer, mimeType);
+      const canCacheUpload = generations.get(key) === generation;
+      invalidate(key);
+      if (!disposed && canCacheUpload) {
+        const bytes = ArrayBuffer.isView(buffer) ? new Uint8Array(buffer).slice().buffer : buffer;
+        blobUrlCache.set(key, URL.createObjectURL(new Blob([bytes], { type: mimeType })));
+      }
       return key;
     },
     async removeMedia(ref) {
       const key = toKey(ref);
-      const cached = blobUrlCache.get(key);
-      if (cached) {
-        URL.revokeObjectURL(cached);
-        blobUrlCache.delete(key);
-      }
+      invalidate(key);
       await container.removeFile(key);
+      invalidate(key);
     },
     dispose() {
+      disposed = true;
+      pending.clear();
       for (const url of blobUrlCache.values()) {
         URL.revokeObjectURL(url);
       }
@@ -935,6 +1105,7 @@ function createFileMediaProvider(container, markdownBasename) {
 
 export {
   LegacyFileSystemProviderV2Adapter,
+  rewriteCompanionReferences,
   documentCompanionPath,
   moveFileSystemEntry,
   createDbkWorkspaceSnapshot,

package/dist/{chunk-OQCPBOQA.js → chunk-DAPFSEKY.js}

@@ -106,7 +106,42 @@ var RawIndexedDBFileSystemTransaction = class {
     const cursor = await requestResult(this.store.openKeyCursor(IDBKeyRange.lowerBound(prefix)));
     return cursor !== null && typeof cursor.key === "string" && cursor.key.startsWith(prefix);
   }
+  childKeys(prefix) {
+    return new Promise((resolve, reject) => {
+      const keys = [];
+      const request = this.store.openKeyCursor(IDBKeyRange.lowerBound(prefix));
+      request.onerror = () => reject(request.error ?? new Error("IndexedDB request failed."));
+      request.onsuccess = () => {
+        const cursor = request.result;
+        if (!cursor) {
+          resolve(keys);
+          return;
+        }
+        const key = cursor.key;
+        if (typeof key !== "string") {
+          reject(new Error("The DocBlocks filesystem store contains a non-string key."));
+          return;
+        }
+        const step = childKeyStep(prefix, key);
+        if (step.kind === "done") {
+          resolve(keys);
+          return;
+        }
+        if (step.kind === "child") keys.push(key);
+        if (step.kind === "skip") cursor.continue(step.seek);
+        else cursor.continue();
+      };
+    });
+  }
 };
+function childKeyStep(prefix, key) {
+  if (!key.startsWith(prefix)) return { kind: "done" };
+  const rest = key.slice(prefix.length);
+  if (!rest) return { kind: "self" };
+  const slash = rest.indexOf("/");
+  if (slash === -1) return { kind: "child" };
+  return { kind: "skip", seek: `${prefix}${rest.slice(0, slash)}0` };
+}
 async function openDatabaseWithStore(databaseName, storeName) {
   const database = await openDatabase(databaseName, void 0, (upgradeDatabase) => {
     if (!upgradeDatabase.objectStoreNames.contains(storeName)) {

package/dist/{chunk-M62ZGJ5I.js → chunk-HABG2JM3.js}

@@ -1,18 +1,3 @@
-// src/filesystem/v2.ts
-function parseFileSystemVersion(value) {
-  if (typeof value !== "string" || !value || value.length > 1024 || value.includes("\0")) {
-    throw new TypeError("Filesystem version tokens must be non-empty bounded strings.");
-  }
-  return value;
-}
-function tryParseFileSystemVersion(value) {
-  try {
-    return parseFileSystemVersion(value);
-  } catch {
-    return null;
-  }
-}
-
 // src/filesystem/internal/bytes.ts
 function copyBytes(data) {
   const source = ArrayBuffer.isView(data) ? new Uint8Array(data.buffer, data.byteOffset, data.byteLength) : new Uint8Array(data);
@@ -41,8 +26,6 @@ function compareSnapshotsByPath(left, right) {
 }
 
 export {
-  parseFileSystemVersion,
-  tryParseFileSystemVersion,
   copyBytes,
   bytesEqual,
   compareText,