@bendyline/docblocks-react 2.5.0 → 2.6.1

package/dist/index.js

@@ -1,66 +1,75 @@
+import {
+  createBrowserSaveAsAdapter
+} from "./chunk-UMEDHMT7.js";
 import {
   BADGE_GLYPHS,
   BADGE_LABELS,
-  GitContext,
   buildBadgeMap,
   conflictedPaths,
-  isFileDirty,
+  isFileDirty
+} from "./chunk-V2ENBGUA.js";
+import {
+  useMenuKeyboard
+} from "./chunk-MRUK56JS.js";
+import {
+  GitContext,
   useGitContext
-} from "./chunk-HFYPTTCH.js";
+} from "./chunk-6E635KCJ.js";
 import {
   createImageSaveOutput,
   updateExportTargetExtension
 } from "./chunk-FNSRCCBC.js";
+import {
+  runExport
+} from "./chunk-ODYNOPC3.js";
+import {
+  buildExportFilename
+} from "./chunk-M5Y5WO7Z.js";
+import {
+  createLocalProofingIgnoreStore
+} from "./chunk-DUKTAKB4.js";
 import {
   AccentColorSettings,
   DB_CHROME_COLORS,
+  DEFAULT_PROOFING_PREFERENCES,
   DEFAULT_WRITE_CANVAS_FONT_SCHEME,
   DEFAULT_WRITE_CANVAS_PREFERENCES,
+  ProofingSettingsControls,
   SettingsDialog,
   ThemeSettings,
   WRITE_CANVAS_FONT_SCHEMES,
   WriteCanvasSettingsControls,
   loadAccentColor,
+  loadProofingPreferences,
   loadThemePreference,
   loadWriteCanvasPreferences,
   resolveWriteCanvasFonts,
   saveAccentColor,
+  saveProofingPreferences,
   saveThemePreference,
   saveWriteCanvasPreferences
-} from "./chunk-VRRL6VTD.js";
+} from "./chunk-Q6XNIKDG.js";
 import {
   pickEmptyDocumentPrompt,
   useResponsivePreviewViewportPreset
 } from "./chunk-JDJVRDOP.js";
 import {
   ExportDialog
-} from "./chunk-SIIEGOHY.js";
-import {
-  runExport
-} from "./chunk-ODYNOPC3.js";
-import {
-  createBrowserSaveAsAdapter
-} from "./chunk-UMEDHMT7.js";
-import {
-  useMenuKeyboard
-} from "./chunk-MRUK56JS.js";
+} from "./chunk-FMDLZ4ZG.js";
 import "./chunk-YBEYTVU2.js";
-import {
-  Dialog
-} from "./chunk-LG6HAWCK.js";
-import {
-  buildExportFilename
-} from "./chunk-M5Y5WO7Z.js";
 import {
   DEFAULT_OPTIONS,
   loadLastExportOptions
 } from "./chunk-EBWYGTN7.js";
+import {
+  Dialog
+} from "./chunk-LG6HAWCK.js";
 
 // src/FileExplorer/FileExplorer.tsx
 import { useCallback as useCallback4, useEffect as useEffect4, useMemo, useRef as useRef4, useState as useState4 } from "react";
 import {
   isFileSystemMoveStateError,
-  parseWorkspacePath as parseWorkspacePath2
+  parseWorkspacePath as parseWorkspacePath4
 } from "@bendyline/docblocks/filesystem";
 
 // src/FileExplorer/useFileTree.ts
@@ -1588,54 +1597,654 @@ function isHiddenFileEntry(entry) {
   if (name.startsWith(".")) return true;
   return entry.kind === "directory" && name.endsWith("_files");
 }
-function filterVisibleFileEntries(entries) {
-  return entries.filter((entry) => !isHiddenFileEntry(entry));
+function filterVisibleFileEntries(entries) {
+  return entries.filter((entry) => !isHiddenFileEntry(entry));
+}
+
+// src/FileExplorer/entry-sort.ts
+function compareText(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+function modifiedTime(entry) {
+  if (entry.kind !== "file" || !entry.lastModified) return null;
+  const timestamp = Date.parse(entry.lastModified);
+  return Number.isNaN(timestamp) ? null : timestamp;
+}
+function sortFileEntries(entries, mode) {
+  return [...entries].sort((left, right) => {
+    if (left.kind !== right.kind) return left.kind === "directory" ? -1 : 1;
+    if (left.kind === "directory" || right.kind === "directory" || mode === "name") {
+      return compareText(left.name, right.name);
+    }
+    const leftTime = modifiedTime(left);
+    const rightTime = modifiedTime(right);
+    if (leftTime !== null && rightTime !== null && leftTime !== rightTime) {
+      return rightTime - leftTime;
+    }
+    if (leftTime === null && rightTime !== null) return 1;
+    if (leftTime !== null && rightTime === null) return -1;
+    return compareText(left.name, right.name);
+  });
+}
+
+// src/DocBlocksShell/outside-in.ts
+import {
+  FileSystemContentContainer,
+  FsError as FsError3,
+  getFileSystemProviderV2 as getFileSystemProviderV23,
+  parseWorkspacePath as parseWorkspacePath3
+} from "@bendyline/docblocks/filesystem";
+import {
+  createFileSystemDocumentTarget
+} from "@bendyline/docblocks/document";
+
+// src/DocBlocksShell/provider-io.ts
+import {
+  FsError as FsError2,
+  getFileSystemProviderV2 as getFileSystemProviderV22,
+  parseWorkspacePath as parseWorkspacePath2
+} from "@bendyline/docblocks/filesystem";
+async function providerEntryExists(provider, path) {
+  const providerV2 = getFileSystemProviderV22(provider);
+  return providerV2 ? await providerV2.stat(parseWorkspacePath2(path)) !== null : provider.exists(path);
+}
+async function writeProviderText(provider, path, content, mode = "upsert") {
+  const providerV2 = getFileSystemProviderV22(provider);
+  if (providerV2) {
+    await providerV2.writeFile(parseWorkspacePath2(path), new TextEncoder().encode(content), {
+      mode,
+      createParents: true,
+      expectedVersion: mode === "create" ? null : void 0
+    });
+    return;
+  }
+  if (mode === "create" && await provider.exists(path)) {
+    throw new FsError2("already-exists", "File already exists.", { operation: "write", path });
+  }
+  await provider.writeFile(path, content);
+}
+async function removeProviderEntry(provider, path) {
+  const providerV2 = getFileSystemProviderV22(provider);
+  if (providerV2) {
+    await providerV2.remove(parseWorkspacePath2(path), { recursive: true, missing: "ignore" });
+    return;
+  }
+  await provider.delete(path);
+}
+
+// src/DocBlocksShell/outside-in-contract.ts
+var OUTSIDE_IN_FORMAT_IDS = ["html", "docx", "pdf", "pptx", "xlsx", "csv"];
+var FORMAT_IDS = new Set(OUTSIDE_IN_FORMAT_IDS);
+var UPDATE_FROM_MARKDOWN_KEY = "squisq-updatefrommarkdown";
+var HTML_OUTPUT_KEY = "squisq-html-output";
+async function loadOutsideInModule() {
+  return await import("@bendyline/squisq-formats/outside-in");
+}
+function normalizePath(path) {
+  const leading = path.replace(/\\/g, "/").startsWith("/") ? "/" : "";
+  const parts = path.replace(/\\/g, "/").split("/").filter(Boolean);
+  if (parts.some((part) => part === "." || part === "..")) {
+    throw new Error(`Outside-in paths must be canonical workspace paths: ${path}`);
+  }
+  return leading + parts.join("/");
+}
+function join(parent, child) {
+  if (!parent || parent === "/") return parent === "/" ? `/${child}` : child;
+  return `${parent}/${child}`;
+}
+function slug(stem) {
+  return stem.normalize("NFKD").replace(/\p{Mark}+/gu, "").toLocaleLowerCase("en-US").replace(/[^\p{Letter}\p{Number}]+/gu, "-").replace(/^-+|-+$/g, "") || "document";
+}
+function resolveOutsideInLayout(path) {
+  const targetPath = normalizePath(path);
+  const slash = targetPath.lastIndexOf("/");
+  const parentDirectory = slash < 0 ? "" : slash === 0 ? "/" : targetPath.slice(0, slash);
+  const filename = slash < 0 ? targetPath : targetPath.slice(slash + 1);
+  const dot = filename.lastIndexOf(".");
+  if (dot <= 0) return null;
+  const rawFormat = filename.slice(dot + 1).toLowerCase();
+  const format = rawFormat === "htm" ? "html" : rawFormat;
+  if (!FORMAT_IDS.has(format)) return null;
+  const stem = filename.slice(0, dot);
+  const companionName = `${stem}_files`;
+  const companionDirectory = join(parentDirectory, companionName);
+  const markdownFilename = `${slug(stem)}.md`;
+  const backupDirectory = join(companionDirectory, ".original");
+  const backupFilename = `original.${format}`;
+  return {
+    targetPath,
+    format,
+    parentDirectory,
+    stem,
+    companionName,
+    companionDirectory,
+    markdownFilename,
+    markdownPath: join(companionDirectory, markdownFilename),
+    relativeTargetPath: `../${filename}`,
+    backupDirectory,
+    backupFilename,
+    backupPath: join(backupDirectory, backupFilename)
+  };
+}
+function chooseOutsideInMarkdownPath(layout, paths) {
+  const canonical = normalizePath(layout.markdownPath);
+  const normalized = paths.map(normalizePath);
+  const exact = normalized.find((path) => path === canonical);
+  if (exact) return exact;
+  const folded = normalized.find(
+    (path) => path.toLocaleLowerCase("en-US") === canonical.toLocaleLowerCase("en-US")
+  );
+  if (folded) return folded;
+  const prefix = `${normalizePath(layout.companionDirectory).replace(/\/$/, "")}/`;
+  const markdown = normalized.filter(
+    (path) => path.startsWith(prefix) && !path.slice(prefix.length).includes("/") && path.toLocaleLowerCase("en-US").endsWith(".md")
+  );
+  return markdown.length === 1 ? markdown[0] : null;
+}
+async function readOutsideInMetadata(source) {
+  const { readOutsideInMetadata: readMetadata } = await loadOutsideInModule();
+  const metadata = readMetadata(source);
+  return metadata ? {
+    ...metadata,
+    updateFromMarkdown: await isOutsideInMarkdownEditingEnabled(source)
+  } : null;
+}
+async function withOutsideInMetadata(source, layout) {
+  const { withOutsideInMetadata: addMetadata } = await loadOutsideInModule();
+  return addMetadata(source, layout);
+}
+async function isOutsideInMarkdownEditingEnabled(source) {
+  const module = await loadOutsideInModule();
+  if (module.isOutsideInMarkdownEditingEnabled) {
+    return module.isOutsideInMarkdownEditingEnabled(source);
+  }
+  const { parseFrontmatter, splitFrontmatterBlock } = await import("@bendyline/squisq/markdown");
+  const block = splitFrontmatterBlock(source).frontmatter;
+  if (!block) return false;
+  const firstBreak = block.indexOf("\n");
+  if (firstBreak < 0) return false;
+  const yaml = block.slice(firstBreak + 1).replace(/\r?\n---(?:\r?\n)?$/, "");
+  return parseFrontmatter(yaml)?.[UPDATE_FROM_MARKDOWN_KEY] === true;
+}
+async function withOutsideInMarkdownEditing(source, layout, enabled = true) {
+  const module = await loadOutsideInModule();
+  if (module.withOutsideInMarkdownEditing) {
+    return module.withOutsideInMarkdownEditing(source, layout, enabled);
+  }
+  const { setFrontmatterValues } = await import("@bendyline/squisq/markdown");
+  return setFrontmatterValues(await withOutsideInMetadata(source, layout), {
+    [UPDATE_FROM_MARKDOWN_KEY]: enabled
+  });
+}
+async function readOutsideInHtmlOutput(source) {
+  const { parseFrontmatter, splitFrontmatterBlock } = await import("@bendyline/squisq/markdown");
+  const block = splitFrontmatterBlock(source).frontmatter;
+  if (!block) return null;
+  const firstBreak = block.indexOf("\n");
+  if (firstBreak < 0) return null;
+  const yaml = block.slice(firstBreak + 1).replace(/\r?\n---(?:\r?\n)?$/, "");
+  const value = parseFrontmatter(yaml)?.[HTML_OUTPUT_KEY];
+  return value === "interactive" || value === "static" ? value : null;
+}
+async function withOutsideInHtmlOutput(source, output) {
+  const { setFrontmatterValues } = await import("@bendyline/squisq/markdown");
+  return setFrontmatterValues(source, { [HTML_OUTPUT_KEY]: output });
+}
+async function importOutsideInDocument(source, options = {}) {
+  const { importOutsideInDocument: importDocument } = await loadOutsideInModule();
+  const imported = await importDocument(source, options);
+  const layout = resolveOutsideInLayout(source.targetPath);
+  if (!layout) throw new Error(`Outside-in editing does not support "${source.targetPath}".`);
+  return { ...imported, layout };
+}
+function isOutsideInDataFormat(format) {
+  return format === "csv" || format === "xlsx";
+}
+async function importOutsideInDataSidecar(source) {
+  const layout = resolveOutsideInLayout(source.targetPath);
+  if (!layout || !isOutsideInDataFormat(layout.format)) {
+    throw new Error(`Outside-in data import does not support "${source.targetPath}".`);
+  }
+  const data = source.data instanceof ArrayBuffer ? source.data : source.data.buffer.slice(
+    source.data.byteOffset,
+    source.data.byteOffset + source.data.byteLength
+  );
+  const sourceName = source.targetPath.replace(/\\/g, "/").split("/").pop() ?? `data.${layout.format}`;
+  const container = layout.format === "csv" ? await import("@bendyline/squisq-formats/csv").then(
+    ({ csvToContainer }) => csvToContainer(data, { sourceName, sidecar: "always" })
+  ) : await import("@bendyline/squisq-formats/xlsx").then(
+    ({ xlsxToContainer }) => xlsxToContainer(data, {
+      sourceName,
+      sidecar: "always",
+      sheetHeadings: false
+    })
+  );
+  const importedMarkdown = await container.readDocument();
+  if (importedMarkdown === null) {
+    throw new Error(
+      `The ${layout.format.toUpperCase()} importer did not create a Markdown companion.`
+    );
+  }
+  return {
+    layout,
+    markdown: await withOutsideInMetadata(importedMarkdown, layout),
+    container
+  };
+}
+async function renderOutsideInDocument(source, options = {}) {
+  const { renderOutsideInDocument: renderDocument } = await loadOutsideInModule();
+  return renderDocument(source, options);
+}
+
+// src/DocBlocksShell/outside-in.ts
+var OUTSIDE_IN_EXTENSION = /\.(?:html?|docx|pdf|pptx|xlsx|csv)$/i;
+var IMAGE_MIME_TYPES = {
+  avif: "image/avif",
+  bmp: "image/bmp",
+  gif: "image/gif",
+  ico: "image/x-icon",
+  jpeg: "image/jpeg",
+  jpg: "image/jpeg",
+  png: "image/png",
+  webp: "image/webp"
+};
+var SQUISQ_RUNTIME_DIRECTORY = "_squisq";
+var SQUISQ_RUNTIME_FILENAME = "squisq-player.js";
+function defaultOutsideInLayoutMode(outsideIn) {
+  return outsideIn && isOutsideInDataFormat(outsideIn.format) ? "block" : void 0;
+}
+function withoutLeadingSlash(path) {
+  return parseWorkspacePath3(path);
+}
+function withLegacySlash(path, like) {
+  const canonical = withoutLeadingSlash(path);
+  return like.startsWith("/") && canonical ? `/${canonical}` : canonical;
+}
+function dirname(path) {
+  const canonical = withoutLeadingSlash(path);
+  const slash = canonical.lastIndexOf("/");
+  return slash < 0 ? "" : canonical.slice(0, slash);
+}
+function join2(parent, child) {
+  return parent ? `${parent}/${child}` : child;
+}
+function relativePath(fromDirectory, targetPath) {
+  const from = withoutLeadingSlash(fromDirectory).split("/").filter(Boolean);
+  const target = withoutLeadingSlash(targetPath).split("/").filter(Boolean);
+  let shared = 0;
+  while (shared < from.length && shared < target.length && from[shared] === target[shared]) {
+    shared++;
+  }
+  const segments = [...from.slice(shared).map(() => ".."), ...target.slice(shared)];
+  return segments.join("/") || ".";
+}
+async function readText(provider, path) {
+  const v2 = getFileSystemProviderV23(provider);
+  if (!v2) return provider.readFile(path);
+  const current = await v2.readFile(parseWorkspacePath3(path));
+  if (!current) return null;
+  return new TextDecoder("utf-8", { fatal: true }).decode(current.data);
+}
+async function readBytes(provider, path) {
+  const v2 = getFileSystemProviderV23(provider);
+  if (v2) return (await v2.readFile(parseWorkspacePath3(path)))?.data ?? null;
+  return provider.readBinary(path);
+}
+async function writeBytes(provider, path, data, mode = "upsert") {
+  const v2 = getFileSystemProviderV23(provider);
+  if (v2) {
+    await v2.writeFile(parseWorkspacePath3(path), data, {
+      mode,
+      createParents: true,
+      expectedVersion: mode === "create" ? null : void 0
+    });
+    return;
+  }
+  if (mode === "create" && await provider.exists(path)) {
+    throw new FsError3("already-exists", "File already exists.", { operation: "write", path });
+  }
+  await provider.writeBinary(path, data);
+}
+async function listCompanionFiles(provider, layout) {
+  try {
+    const entries = await provider.readDirectory(layout.companionDirectory);
+    return entries.filter((entry) => entry.kind === "file").map((entry) => entry.path);
+  } catch (error) {
+    if (error instanceof FsError3 && error.code === "not-found") return [];
+    throw error;
+  }
+}
+async function removeOutsideInCompanion(provider, layout) {
+  const providerV2 = getFileSystemProviderV23(provider);
+  if (providerV2) {
+    const path = parseWorkspacePath3(layout.companionDirectory);
+    if (await providerV2.stat(path) !== null) {
+      await providerV2.remove(path, { recursive: true, missing: "ignore" });
+    }
+    return;
+  }
+  if (await provider.exists(layout.companionDirectory)) {
+    await provider.delete(layout.companionDirectory);
+  }
+}
+async function persistImportedMedia(provider, layout, container) {
+  const entries = await container.listFiles();
+  for (const entry of entries) {
+    if (/\.md$/i.test(entry.path)) continue;
+    const data = await container.readFile(entry.path);
+    if (!data) continue;
+    await writeBytes(provider, join2(layout.companionDirectory, entry.path), data, "create");
+  }
+}
+async function loadEditableShellDocument(provider, selectedPath) {
+  const imageExtension = selectedPath.slice(selectedPath.lastIndexOf(".") + 1).toLowerCase();
+  const imageMimeType = IMAGE_MIME_TYPES[imageExtension];
+  if (imageMimeType) {
+    const data = await readBytes(provider, selectedPath);
+    return data === null ? null : {
+      displayPath: selectedPath,
+      sourcePath: selectedPath,
+      content: "",
+      outsideIn: null,
+      outsideInEditingEnabled: false,
+      image: { data, mimeType: imageMimeType }
+    };
+  }
+  if (!OUTSIDE_IN_EXTENSION.test(selectedPath)) {
+    const content = await readText(provider, selectedPath);
+    return content === null ? null : {
+      displayPath: selectedPath,
+      sourcePath: selectedPath,
+      content,
+      outsideIn: null,
+      outsideInEditingEnabled: true
+    };
+  }
+  const resolved = resolveOutsideInLayout(selectedPath);
+  if (!resolved) return null;
+  const layout = {
+    ...resolved,
+    targetPath: withLegacySlash(resolved.targetPath, selectedPath),
+    companionDirectory: withLegacySlash(resolved.companionDirectory, selectedPath),
+    markdownPath: withLegacySlash(resolved.markdownPath, selectedPath)
+  };
+  const candidates = (await listCompanionFiles(provider, layout)).map(
+    (path) => withLegacySlash(path, selectedPath)
+  );
+  const chosen = chooseOutsideInMarkdownPath(layout, candidates);
+  if (chosen) {
+    const content = await readText(provider, chosen);
+    if (content === null) return null;
+    const metadata = await readOutsideInMetadata(content);
+    if (metadata && metadata.format !== layout.format) {
+      throw new Error(
+        `${chosen} is configured for ${metadata.format}, not ${layout.format}. Rename the rendered file back or repair the companion frontmatter.`
+      );
+    }
+    const linkedContent = await withOutsideInMetadata(content, layout);
+    if (linkedContent !== content) await writeProviderText(provider, chosen, linkedContent);
+    return {
+      displayPath: selectedPath,
+      sourcePath: chosen,
+      content: linkedContent,
+      outsideIn: { ...layout, markdownPath: chosen },
+      outsideInEditingEnabled: await isOutsideInMarkdownEditingEnabled(linkedContent)
+    };
+  }
+  const rendered = await readBytes(provider, selectedPath);
+  if (!rendered) return null;
+  const imported = await importOutsideInDocument({
+    data: rendered,
+    targetPath: selectedPath
+  });
+  const importedLayout = {
+    ...imported.layout,
+    targetPath: withLegacySlash(imported.layout.targetPath, selectedPath),
+    companionDirectory: withLegacySlash(imported.layout.companionDirectory, selectedPath),
+    markdownPath: withLegacySlash(imported.layout.markdownPath, selectedPath)
+  };
+  await persistImportedMedia(provider, importedLayout, imported.container);
+  await writeProviderText(provider, importedLayout.markdownPath, imported.markdown, "create");
+  return {
+    displayPath: selectedPath,
+    sourcePath: importedLayout.markdownPath,
+    content: imported.markdown,
+    outsideIn: importedLayout,
+    outsideInEditingEnabled: false
+  };
+}
+async function enableOutsideInMarkdownEditing(provider, document2) {
+  const layout = document2.outsideIn;
+  if (!layout) throw new Error("This file does not support outside-in Markdown editing.");
+  const original = await readBytes(provider, layout.targetPath);
+  if (!original) throw new Error(`The rendered file "${layout.targetPath}" was not found.`);
+  try {
+    await writeBytes(provider, layout.backupPath, original, "create");
+  } catch (error) {
+    if (!(error instanceof FsError3 && error.code === "already-exists")) throw error;
+  }
+  const content = await withOutsideInMarkdownEditing(document2.content, layout);
+  if (content !== document2.content) await writeProviderText(provider, document2.sourcePath, content);
+  return { ...document2, content, outsideIn: layout, outsideInEditingEnabled: true };
+}
+async function findRuntimePath(provider, targetPath) {
+  let directory = dirname(targetPath);
+  for (; ; ) {
+    const candidateDirectory = join2(directory, SQUISQ_RUNTIME_DIRECTORY);
+    if (await providerEntryExists(provider, candidateDirectory)) {
+      const providerV2 = getFileSystemProviderV23(provider);
+      if (providerV2) {
+        const entry = await providerV2.stat(parseWorkspacePath3(candidateDirectory));
+        if (entry?.kind !== "directory") {
+          throw new Error(`${candidateDirectory} must be a directory.`);
+        }
+      }
+      return join2(candidateDirectory, SQUISQ_RUNTIME_FILENAME);
+    }
+    if (!directory) break;
+    directory = dirname(directory);
+  }
+  return join2(SQUISQ_RUNTIME_DIRECTORY, SQUISQ_RUNTIME_FILENAME);
+}
+async function writeRuntimeIfNeeded(provider, runtimePath) {
+  const { PLAYER_BUNDLE } = await import("@bendyline/squisq-react/standalone-source");
+  const current = await readText(provider, runtimePath);
+  if (current !== PLAYER_BUNDLE) await writeProviderText(provider, runtimePath, PLAYER_BUNDLE);
 }
-
-// src/FileExplorer/entry-sort.ts
-function compareText(left, right) {
-  return left < right ? -1 : left > right ? 1 : 0;
+async function renderPlainOutsideInHtml(provider, layout, markdown) {
+  const [{ parseMarkdown }, { markdownDocToPlainHtml }] = await Promise.all([
+    import("@bendyline/squisq/markdown"),
+    import("@bendyline/squisq-formats/html")
+  ]);
+  const container = new FileSystemContentContainer(provider, layout.companionDirectory);
+  const images = /* @__PURE__ */ new Map();
+  for (const entry of await container.listFiles()) {
+    const outputPath = `${layout.companionName}/${entry.path}`;
+    images.set(entry.path, outputPath);
+    images.set(`./${entry.path}`, outputPath);
+  }
+  return new TextEncoder().encode(
+    markdownDocToPlainHtml(parseMarkdown(markdown), {
+      title: layout.stem,
+      images: images.size > 0 ? images : void 0
+    })
+  );
 }
-function modifiedTime(entry) {
-  if (entry.kind !== "file" || !entry.lastModified) return null;
-  const timestamp = Date.parse(entry.lastModified);
-  return Number.isNaN(timestamp) ? null : timestamp;
+async function prepareOutsideInRender(provider, layout, markdown) {
+  const htmlOutput = layout.format === "html" ? await readOutsideInHtmlOutput(markdown) : null;
+  if (htmlOutput === "static") {
+    return {
+      bytes: await renderPlainOutsideInHtml(provider, layout, markdown),
+      runtimePath: null
+    };
+  }
+  const runtimePath = layout.format === "html" ? await findRuntimePath(provider, layout.targetPath) : null;
+  const outputDirectory = dirname(layout.targetPath);
+  const rendered = await renderOutsideInDocument(
+    {
+      markdown,
+      targetPath: layout.targetPath,
+      container: new FileSystemContentContainer(provider, layout.companionDirectory)
+    },
+    runtimePath ? {
+      html: {
+        playerScriptPath: relativePath(outputDirectory, runtimePath),
+        basePath: relativePath(outputDirectory, layout.companionDirectory)
+      },
+      ...htmlOutput === "interactive" ? { formatOptions: { html: { mode: "slideshow" } } } : {}
+    } : {}
+  );
+  return { bytes: rendered.bytes, runtimePath };
 }
-function sortFileEntries(entries, mode) {
-  return [...entries].sort((left, right) => {
-    if (left.kind !== right.kind) return left.kind === "directory" ? -1 : 1;
-    if (left.kind === "directory" || right.kind === "directory" || mode === "name") {
-      return compareText(left.name, right.name);
-    }
-    const leftTime = modifiedTime(left);
-    const rightTime = modifiedTime(right);
-    if (leftTime !== null && rightTime !== null && leftTime !== rightTime) {
-      return rightTime - leftTime;
+async function createNewOutsideInDocument(provider, targetPath, htmlOutput) {
+  const layout = resolveOutsideInLayout(targetPath);
+  if (!layout) throw new Error(`Outside-in editing does not support "${targetPath}".`);
+  if (layout.format !== "html" && htmlOutput !== void 0) {
+    throw new Error("Only Web pages have an HTML output style.");
+  }
+  if (await providerEntryExists(provider, layout.targetPath) || await providerEntryExists(provider, layout.companionDirectory)) {
+    throw new FsError3(
+      "already-exists",
+      "A file or companion folder with that name already exists.",
+      {
+        operation: "write",
+        path: layout.targetPath
+      }
+    );
+  }
+  let content = await withOutsideInMarkdownEditing(`# ${layout.stem}
+`, layout);
+  if (layout.format === "html") {
+    content = await withOutsideInHtmlOutput(content, htmlOutput ?? "interactive");
+  }
+  const prepared = await prepareOutsideInRender(provider, layout, content);
+  if (prepared.runtimePath) await writeRuntimeIfNeeded(provider, prepared.runtimePath);
+  await writeBytes(provider, layout.targetPath, prepared.bytes, "create");
+  await writeProviderText(provider, layout.markdownPath, content, "create");
+  return {
+    displayPath: layout.targetPath,
+    sourcePath: layout.markdownPath,
+    content,
+    outsideIn: layout,
+    outsideInEditingEnabled: true
+  };
+}
+function createOutsideInDocumentTarget(provider, layout, onCommitted) {
+  const sourceTarget = createFileSystemDocumentTarget(provider, layout.markdownPath);
+  return {
+    key: `${provider.id}:outside-in:${parseWorkspacePath3(layout.targetPath)}`,
+    async commit(request) {
+      if (!await isOutsideInMarkdownEditingEnabled(request.content)) {
+        throw new Error(
+          "Outside-in editing is read-only until squisq-updatefrommarkdown: true is set."
+        );
+      }
+      const rendered = await prepareOutsideInRender(provider, layout, request.content);
+      await sourceTarget.commit({ ...request, targetKey: sourceTarget.key });
+      if (rendered.runtimePath) await writeRuntimeIfNeeded(provider, rendered.runtimePath);
+      await writeBytes(provider, layout.targetPath, rendered.bytes);
+      onCommitted?.();
+      return {};
     }
-    if (leftTime === null && rightTime !== null) return 1;
-    if (leftTime !== null && rightTime === null) return -1;
-    return compareText(left.name, right.name);
-  });
+  };
+}
+function createOutsideInContentContainer(provider, layout) {
+  return new FileSystemContentContainer(provider, layout.companionDirectory);
 }
 
-// src/FileExplorer/FileExplorer.tsx
-import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
-var SUPPORTED_EXTENSIONS = /* @__PURE__ */ new Set([
-  ".txt",
-  ".md",
+// src/DocBlocksShell/import-file-types.ts
+var OUTSIDE_IN_IMPORT_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".csv",
+  ".docx",
   ".html",
   ".htm",
-  ".docx",
   ".pdf",
   ".pptx",
-  ".xlsx",
-  ".dbk",
-  ".zip"
+  ".xlsx"
 ]);
+var BUNDLE_IMPORT_EXTENSIONS = /* @__PURE__ */ new Set([".dbk", ".zip"]);
+var DIRECT_IMPORT_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".avif",
+  ".bash",
+  ".bmp",
+  ".c",
+  ".cc",
+  ".cpp",
+  ".cs",
+  ".css",
+  ".gif",
+  ".go",
+  ".h",
+  ".hpp",
+  ".ico",
+  ".ini",
+  ".java",
+  ".jpeg",
+  ".jpg",
+  ".js",
+  ".json",
+  ".jsonc",
+  ".jsx",
+  ".kt",
+  ".kts",
+  ".less",
+  ".log",
+  ".lua",
+  ".markdown",
+  ".md",
+  ".mdown",
+  ".mjs",
+  ".php",
+  ".png",
+  ".py",
+  ".rb",
+  ".rs",
+  ".scss",
+  ".sh",
+  ".sql",
+  ".svg",
+  ".swift",
+  ".toml",
+  ".ts",
+  ".tsv",
+  ".tsx",
+  ".txt",
+  ".webp",
+  ".xml",
+  ".yaml",
+  ".yml",
+  ".zsh"
+]);
+var DIRECT_IMPORT_BASENAMES = /* @__PURE__ */ new Set(["dockerfile", "license", "makefile", "readme"]);
+function extensionOfFileName(name) {
+  const dot = name.lastIndexOf(".");
+  return dot <= 0 ? "" : name.slice(dot).toLowerCase();
+}
+function isSupportedImportFile(file) {
+  const extension = extensionOfFileName(file.name);
+  if (OUTSIDE_IN_IMPORT_EXTENSIONS.has(extension) || BUNDLE_IMPORT_EXTENSIONS.has(extension) || DIRECT_IMPORT_EXTENSIONS.has(extension)) {
+    return true;
+  }
+  const mimeType = file.type.toLowerCase();
+  if (mimeType.startsWith("text/") || mimeType.startsWith("image/")) return true;
+  return !extension && DIRECT_IMPORT_BASENAMES.has(file.name.toLowerCase());
+}
+
+// src/FileExplorer/FileExplorer.tsx
+import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
 var INTERNAL_DRAG_TYPE = "application/x-docblocks-entry";
 var NEW_ITEM_ERROR_ID = "db-new-item-error";
+var NEW_FILE_EXTENSIONS = {
+  markdown: ".md",
+  docx: ".docx",
+  xlsx: ".xlsx",
+  pdf: ".pdf",
+  "web-interactive": ".html",
+  "web-static": ".html"
+};
+var SELECTABLE_FILE_EXTENSION = /\.(?:md|docx|xlsx|pdf|html?)$/i;
 function normalisePath2(path) {
-  return parseWorkspacePath2(path);
+  return parseWorkspacePath4(path);
 }
 function hasEquivalentPath2(paths, path) {
   const canonical = normalisePath2(path);
@@ -1701,6 +2310,7 @@ function FileExplorer({
     [pinnedPaths]
   );
   const [newItemName, setNewItemName] = useState4("");
+  const [newFileFormat, setNewFileFormat] = useState4("markdown");
   const [uncontrolledSortMode, setUncontrolledSortMode] = useState4("name");
   const selectedSortMode = sortMode ?? uncontrolledSortMode;
   const selectSortMode = useCallback4(
@@ -1735,12 +2345,11 @@ function FileExplorer({
   const hasSupported = useCallback4((dt) => {
     for (const item of Array.from(dt.items)) {
       if (item.kind !== "file") continue;
-      const name = item.getAsFile?.()?.name;
-      if (!name) return true;
-      const ext = name.slice(name.lastIndexOf(".")).toLowerCase();
-      if (SUPPORTED_EXTENSIONS.has(ext)) return true;
+      const file = item.getAsFile();
+      if (!file) return true;
+      if (isSupportedImportFile(file)) return true;
     }
-    return dt.items.length > 0;
+    return Array.from(dt.files).some(isSupportedImportFile);
   }, []);
   const handleDragEnter = useCallback4(
     (e) => {
@@ -1774,11 +2383,8 @@ function FileExplorer({
       e.preventDefault();
       dragCounter.current = 0;
       setDragOver(false);
-      const supported = Array.from(e.dataTransfer.files).filter((f) => {
-        const ext = f.name.slice(f.name.lastIndexOf(".")).toLowerCase();
-        return SUPPORTED_EXTENSIONS.has(ext);
-      });
-      if (supported.length > 0) onImportFiles?.(supported);
+      const files = Array.from(e.dataTransfer.files);
+      if (files.length > 0) onImportFiles?.(files);
     },
     [onImportFiles]
   );
@@ -1817,9 +2423,24 @@ function FileExplorer({
     setNewItemCreationPending(true);
     try {
       if (itemType === "file") {
-        const filename = name.endsWith(".md") ? name : `${name}.md`;
+        const stem = name.replace(SELECTABLE_FILE_EXTENSION, "");
+        if (!stem) {
+          setNewItemError("Enter a file name before the extension.");
+          return;
+        }
+        const filename = `${stem}${NEW_FILE_EXTENSIONS[newFileFormat]}`;
         createdPath = `${prefix}${filename}`;
-        await tree.createFile(createdPath, "");
+        if (newFileFormat === "markdown") {
+          await tree.createFile(createdPath, "");
+        } else {
+          if (!provider) throw new Error("Open a workspace before creating a document.");
+          await createNewOutsideInDocument(
+            provider,
+            createdPath,
+            newFileFormat === "web-static" ? "static" : newFileFormat === "web-interactive" ? "interactive" : void 0
+          );
+          await tree.refresh();
+        }
         handleSelect(createdPath);
       } else if (itemType === "directory") {
         await tree.createDirectory(createdPath);
@@ -1834,7 +2455,7 @@ function FileExplorer({
     setNewItemName("");
     setNewItemType(null);
     onTreeChange?.({ type: "create", path: createdPath });
-  }, [newItemName, newItemType, tree, handleSelect, onTreeChange]);
+  }, [newFileFormat, newItemName, newItemType, onTreeChange, provider, tree, handleSelect]);
   const handleMoveToWorkspace = useCallback4(async () => {
     if (!onMoveToWorkspace || !moveDestinationId || movingToWorkspace) return;
     setMovingToWorkspace(true);
@@ -2196,6 +2817,7 @@ function FileExplorer({
                 disabled: newItemCreationPending,
                 onClick: () => {
                   setNewItemError(null);
+                  setNewFileFormat("markdown");
                   setNewItemType("file");
                 },
                 title: "New File",
@@ -2274,7 +2896,7 @@ function FileExplorer({
           /* @__PURE__ */ jsxs4(
             "form",
             {
-              className: "db-new-item-row",
+              className: `db-new-item-row db-new-item-row--${newItemType}`,
               "aria-busy": newItemCreationPending,
               onSubmit: (e) => {
                 e.preventDefault();
@@ -2299,14 +2921,41 @@ function FileExplorer({
                       if (e.key === "Escape") {
                         setNewItemType(null);
                         setNewItemName("");
+                        setNewFileFormat("markdown");
                         setNewItemError(null);
                       }
                     },
                     autoFocus: true
                   }
                 ),
-                newItemType === "file" && /* @__PURE__ */ jsx5("span", { className: "db-new-item-suffix", children: ".md" }),
-                /* @__PURE__ */ jsx5("button", { type: "submit", className: "db-new-item-add", disabled: newItemCreationPending, children: newItemCreationPending ? "Adding\u2026" : "Add" })
+                newItemType === "file" ? /* @__PURE__ */ jsxs4("div", { className: "db-new-item-file-controls", children: [
+                  /* @__PURE__ */ jsxs4(
+                    "select",
+                    {
+                      className: "db-new-item-format",
+                      "aria-label": "New file type",
+                      value: newFileFormat,
+                      disabled: newItemCreationPending,
+                      onChange: (event) => {
+                        setNewFileFormat(event.currentTarget.value);
+                        setNewItemError(null);
+                      },
+                      children: [
+                        /* @__PURE__ */ jsxs4("optgroup", { label: "Document", children: [
+                          /* @__PURE__ */ jsx5("option", { value: "markdown", children: "Markdown (.md)" }),
+                          /* @__PURE__ */ jsx5("option", { value: "docx", children: "Word document (.docx)" }),
+                          /* @__PURE__ */ jsx5("option", { value: "xlsx", children: "Excel workbook (.xlsx)" }),
+                          /* @__PURE__ */ jsx5("option", { value: "pdf", children: "PDF document (.pdf)" })
+                        ] }),
+                        /* @__PURE__ */ jsxs4("optgroup", { label: "Web page", children: [
+                          /* @__PURE__ */ jsx5("option", { value: "web-interactive", children: "Web page \u2014 Interactive (.html)" }),
+                          /* @__PURE__ */ jsx5("option", { value: "web-static", children: "Web page \u2014 Static (.html)" })
+                        ] })
+                      ]
+                    }
+                  ),
+                  /* @__PURE__ */ jsx5("button", { type: "submit", className: "db-new-item-add", disabled: newItemCreationPending, children: newItemCreationPending ? "Adding\u2026" : "Add" })
+                ] }) : /* @__PURE__ */ jsx5("button", { type: "submit", className: "db-new-item-add", disabled: newItemCreationPending, children: newItemCreationPending ? "Adding\u2026" : "Add" })
               ]
             }
           ),
@@ -2660,6 +3309,8 @@ function AppMenu({
   onAccentColorChange,
   writeCanvasSettings = DEFAULT_WRITE_CANVAS_PREFERENCES,
   onWriteCanvasSettingsChange,
+  proofingPreferences = DEFAULT_PROOFING_PREFERENCES,
+  onProofingPreferencesChange,
   versioningPreference = "browser-only",
   onVersioningPreferenceChange,
   onDownloadAllWorkspaces,
@@ -2834,6 +3485,13 @@ function AppMenu({
           onChange: (settings) => onWriteCanvasSettingsChange?.(settings)
         }
       ),
+      /* @__PURE__ */ jsx7(
+        ProofingSettingsControls,
+        {
+          value: proofingPreferences,
+          onChange: (settings) => onProofingPreferencesChange?.(settings)
+        }
+      ),
       getStorageEstimate && /* @__PURE__ */ jsxs6("fieldset", { className: "db-settings-fieldset", children: [
         /* @__PURE__ */ jsx7("legend", { className: "db-settings-legend", children: "Storage" }),
         /* @__PURE__ */ jsx7("p", { className: "db-settings-hint", children: storageEstimate ? `DocBlocks documents and app data are using ${formatBytes(
@@ -3236,7 +3894,7 @@ function useDocumentSession(autoSaveDelayMs = 500) {
 import { lazy, Suspense } from "react";
 import { jsx as jsx10 } from "react/jsx-runtime";
 var ExportToolbarControlsImplementation = lazy(
-  () => import("./ExportToolbarControls-BUVJCSMV.js").then((module) => ({
+  () => import("./ExportToolbarControls-QYLBRWM7.js").then((module) => ({
     default: module.ExportToolbarControls
   }))
 );
@@ -3359,27 +4017,39 @@ function useGit(provider, requestedWorkspaceId, theme) {
   const available = gitApi !== null && capabilities?.gitAvailable === true;
   const [repo, setRepo] = useState10(null);
   const [remoteWeb, setRemoteWeb] = useState10(null);
+  const [pendingGrant, setPendingGrant] = useState10(null);
+  const loadRemote = useCallback9(
+    (repositoryId2, isCancelled) => {
+      if (!gitApi) return;
+      void gitApi.listRemotes(repositoryId2).then(
+        (remotes) => {
+          if (isCancelled() || !remotes.ok) return;
+          const first = remotes.value[0];
+          setRemoteWeb(first?.web ?? null);
+        },
+        () => void 0
+      );
+    },
+    [gitApi]
+  );
   useEffect9(() => {
     setRepo(null);
     setRemoteWeb(null);
+    setPendingGrant(null);
     if (!gitApi || !workspaceId || !available) return;
     let cancelled = false;
+    const isCancelled = () => cancelled;
     void gitApi.detectRepo(workspaceId).then(
       (result) => {
-        if (cancelled || !result.ok || !result.value.isRepo || !result.value.repositoryId) {
+        if (cancelled || !result.ok || !result.value.isRepo) return;
+        if (!result.value.repositoryId) {
+          if (result.value.requiresExpandedGrant) {
+            setPendingGrant({ repositoryRoot: result.value.repositoryRoot ?? null });
+          }
           return;
         }
         setRepo(result.value);
-        void gitApi.listRemotes(result.value.repositoryId).then(
-          (remotes) => {
-            if (cancelled || !remotes.ok) return;
-            const first = remotes.value[0];
-            setRemoteWeb(first?.web ?? null);
-          },
-          // No remote is a supported state; a failed probe degrades to it
-          // rather than surfacing an unhandled rejection.
-          () => void 0
-        );
+        loadRemote(result.value.repositoryId, isCancelled);
       },
       /* detection failure → not a repo, which is the default state */
       () => void 0
@@ -3387,7 +4057,25 @@ function useGit(provider, requestedWorkspaceId, theme) {
     return () => {
       cancelled = true;
     };
-  }, [gitApi, workspaceId, available]);
+  }, [gitApi, workspaceId, available, loadRemote]);
+  const [grantBusy, setGrantBusy] = useState10(false);
+  const enableExpandedRepo = useCallback9(
+    async (opts) => {
+      if (!gitApi || !workspaceId) return false;
+      setGrantBusy(true);
+      try {
+        const result = await gitApi.grantExpandedRepo(workspaceId, opts);
+        if (!result.ok || !result.value.repositoryId) return false;
+        setRepo(result.value);
+        setPendingGrant(null);
+        loadRemote(result.value.repositoryId, () => false);
+        return true;
+      } finally {
+        setGrantBusy(false);
+      }
+    },
+    [gitApi, workspaceId, loadRemote]
+  );
   const repositoryId = repo?.repositoryId ?? null;
   const isRepo = repositoryId !== null;
   const { status, refresh, scheduleRefresh } = useGitStatus(gitApi, repositoryId, isRepo);
@@ -3536,6 +4224,9 @@ function useGit(provider, requestedWorkspaceId, theme) {
       capabilities,
       repo,
       repositoryId,
+      pendingGrant,
+      grantBusy,
+      enableExpandedRepo,
       remoteWeb,
       gitApi,
       provider,
@@ -3563,6 +4254,9 @@ function useGit(provider, requestedWorkspaceId, theme) {
       capabilities,
       repo,
       repositoryId,
+      pendingGrant,
+      grantBusy,
+      enableExpandedRepo,
       remoteWeb,
       gitApi,
       provider,
@@ -3753,159 +4447,11 @@ function hasControlCharacter(value) {
 }
 
 // src/DocBlocksShell/import-files.ts
-import {
-  FsError as FsError3,
-  getFileSystemProviderV2 as getFileSystemProviderV23,
-  parseWorkspacePath as parseWorkspacePath4
-} from "@bendyline/docblocks/filesystem";
-
-// src/DocBlocksShell/outside-in-contract.ts
-var OUTSIDE_IN_FORMAT_IDS = ["html", "docx", "pdf", "pptx", "xlsx"];
-var FORMAT_IDS = new Set(OUTSIDE_IN_FORMAT_IDS);
-var UPDATE_FROM_MARKDOWN_KEY = "squisq-updatefrommarkdown";
-function normalizePath(path) {
-  const leading = path.replace(/\\/g, "/").startsWith("/") ? "/" : "";
-  const parts = path.replace(/\\/g, "/").split("/").filter(Boolean);
-  if (parts.some((part) => part === "." || part === "..")) {
-    throw new Error(`Outside-in paths must be canonical workspace paths: ${path}`);
-  }
-  return leading + parts.join("/");
-}
-function join(parent, child) {
-  if (!parent || parent === "/") return parent === "/" ? `/${child}` : child;
-  return `${parent}/${child}`;
-}
-function slug(stem) {
-  return stem.normalize("NFKD").replace(/\p{Mark}+/gu, "").toLocaleLowerCase("en-US").replace(/[^\p{Letter}\p{Number}]+/gu, "-").replace(/^-+|-+$/g, "") || "document";
-}
-function resolveOutsideInLayout(path) {
-  const targetPath = normalizePath(path);
-  const slash = targetPath.lastIndexOf("/");
-  const parentDirectory = slash < 0 ? "" : slash === 0 ? "/" : targetPath.slice(0, slash);
-  const filename = slash < 0 ? targetPath : targetPath.slice(slash + 1);
-  const dot = filename.lastIndexOf(".");
-  if (dot <= 0) return null;
-  const rawFormat = filename.slice(dot + 1).toLowerCase();
-  const format = rawFormat === "htm" ? "html" : rawFormat;
-  if (!FORMAT_IDS.has(format)) return null;
-  const stem = filename.slice(0, dot);
-  const companionName = `${stem}_files`;
-  const companionDirectory = join(parentDirectory, companionName);
-  const markdownFilename = `${slug(stem)}.md`;
-  const backupDirectory = join(companionDirectory, ".original");
-  const backupFilename = `original.${format}`;
-  return {
-    targetPath,
-    format,
-    parentDirectory,
-    stem,
-    companionName,
-    companionDirectory,
-    markdownFilename,
-    markdownPath: join(companionDirectory, markdownFilename),
-    relativeTargetPath: `../${filename}`,
-    backupDirectory,
-    backupFilename,
-    backupPath: join(backupDirectory, backupFilename)
-  };
-}
-function chooseOutsideInMarkdownPath(layout, paths) {
-  const canonical = normalizePath(layout.markdownPath);
-  const normalized = paths.map(normalizePath);
-  const exact = normalized.find((path) => path === canonical);
-  if (exact) return exact;
-  const folded = normalized.find(
-    (path) => path.toLocaleLowerCase("en-US") === canonical.toLocaleLowerCase("en-US")
-  );
-  if (folded) return folded;
-  const prefix = `${normalizePath(layout.companionDirectory).replace(/\/$/, "")}/`;
-  const markdown = normalized.filter(
-    (path) => path.startsWith(prefix) && !path.slice(prefix.length).includes("/") && path.toLocaleLowerCase("en-US").endsWith(".md")
-  );
-  return markdown.length === 1 ? markdown[0] : null;
-}
-async function readOutsideInMetadata(source) {
-  const { readOutsideInMetadata: readMetadata } = await import("@bendyline/squisq-formats/outside-in");
-  const metadata = readMetadata(source);
-  return metadata ? {
-    ...metadata,
-    updateFromMarkdown: await isOutsideInMarkdownEditingEnabled(source)
-  } : null;
-}
-async function withOutsideInMetadata(source, layout) {
-  const { withOutsideInMetadata: addMetadata } = await import("@bendyline/squisq-formats/outside-in");
-  return addMetadata(source, layout);
-}
-async function isOutsideInMarkdownEditingEnabled(source) {
-  const module = await import("@bendyline/squisq-formats/outside-in");
-  if (module.isOutsideInMarkdownEditingEnabled) {
-    return module.isOutsideInMarkdownEditingEnabled(source);
-  }
-  const { parseFrontmatter, splitFrontmatterBlock } = await import("@bendyline/squisq/markdown");
-  const block = splitFrontmatterBlock(source).frontmatter;
-  if (!block) return false;
-  const firstBreak = block.indexOf("\n");
-  if (firstBreak < 0) return false;
-  const yaml = block.slice(firstBreak + 1).replace(/\r?\n---(?:\r?\n)?$/, "");
-  return parseFrontmatter(yaml)?.[UPDATE_FROM_MARKDOWN_KEY] === true;
-}
-async function withOutsideInMarkdownEditing(source, layout, enabled = true) {
-  const module = await import("@bendyline/squisq-formats/outside-in");
-  if (module.withOutsideInMarkdownEditing) {
-    return module.withOutsideInMarkdownEditing(source, layout, enabled);
-  }
-  const { setFrontmatterValues } = await import("@bendyline/squisq/markdown");
-  return setFrontmatterValues(await withOutsideInMetadata(source, layout), {
-    [UPDATE_FROM_MARKDOWN_KEY]: enabled
-  });
-}
-async function importOutsideInDocument(source, options = {}) {
-  const { importOutsideInDocument: importDocument } = await import("@bendyline/squisq-formats/outside-in");
-  const imported = await importDocument(source, options);
-  const layout = resolveOutsideInLayout(source.targetPath);
-  if (!layout) throw new Error(`Outside-in editing does not support "${source.targetPath}".`);
-  return { ...imported, layout };
-}
-async function renderOutsideInDocument(source, options = {}) {
-  const { renderOutsideInDocument: renderDocument } = await import("@bendyline/squisq-formats/outside-in");
-  return renderDocument(source, options);
-}
-
-// src/DocBlocksShell/provider-io.ts
-import {
-  FsError as FsError2,
-  getFileSystemProviderV2 as getFileSystemProviderV22,
-  parseWorkspacePath as parseWorkspacePath3
-} from "@bendyline/docblocks/filesystem";
-async function providerEntryExists(provider, path) {
-  const providerV2 = getFileSystemProviderV22(provider);
-  return providerV2 ? await providerV2.stat(parseWorkspacePath3(path)) !== null : provider.exists(path);
-}
-async function writeProviderText(provider, path, content, mode = "upsert") {
-  const providerV2 = getFileSystemProviderV22(provider);
-  if (providerV2) {
-    await providerV2.writeFile(parseWorkspacePath3(path), new TextEncoder().encode(content), {
-      mode,
-      createParents: true,
-      expectedVersion: mode === "create" ? null : void 0
-    });
-    return;
-  }
-  if (mode === "create" && await provider.exists(path)) {
-    throw new FsError2("already-exists", "File already exists.", { operation: "write", path });
-  }
-  await provider.writeFile(path, content);
-}
-async function removeProviderEntry(provider, path) {
-  const providerV2 = getFileSystemProviderV22(provider);
-  if (providerV2) {
-    await providerV2.remove(parseWorkspacePath3(path), { recursive: true, missing: "ignore" });
-    return;
-  }
-  await provider.delete(path);
-}
-
-// src/DocBlocksShell/import-files.ts
+import {
+  FsError as FsError4,
+  getFileSystemProviderV2 as getFileSystemProviderV24,
+  parseWorkspacePath as parseWorkspacePath5
+} from "@bendyline/docblocks/filesystem";
 var MAX_NAME_ATTEMPTS = 100;
 function withCopySuffix(path, n) {
   const dot = path.lastIndexOf(".");
@@ -3914,7 +4460,7 @@ function withCopySuffix(path, n) {
   return `${path.slice(0, dot)} (${n})${path.slice(dot)}`;
 }
 function isAlreadyExists(error) {
-  return error instanceof FsError3 && error.code === "already-exists";
+  return error instanceof FsError4 && error.code === "already-exists";
 }
 async function claimAvailablePath(provider, desiredPath) {
   for (let attempt = 1; attempt <= MAX_NAME_ATTEMPTS; attempt++) {
@@ -3929,9 +4475,9 @@ async function claimAvailablePath(provider, desiredPath) {
   throw new Error(`Too many documents are already named like \u201C${desiredPath}\u201D.`);
 }
 async function writeProviderBytes(provider, path, data, mode) {
-  const providerV2 = getFileSystemProviderV23(provider);
+  const providerV2 = getFileSystemProviderV24(provider);
   if (providerV2) {
-    await providerV2.writeFile(parseWorkspacePath4(path), data, {
+    await providerV2.writeFile(parseWorkspacePath5(path), data, {
       mode,
       createParents: true,
       expectedVersion: mode === "create" ? null : void 0
@@ -3939,11 +4485,10 @@ async function writeProviderBytes(provider, path, data, mode) {
     return;
   }
   if (mode === "create" && await providerEntryExists(provider, path)) {
-    throw new FsError3("already-exists", "File already exists.", { operation: "write", path });
+    throw new FsError4("already-exists", "File already exists.", { operation: "write", path });
   }
   await provider.writeBinary(path, data);
 }
-var OUTSIDE_IN_EXTENSIONS = /* @__PURE__ */ new Set([".html", ".htm", ".docx", ".pdf", ".pptx", ".xlsx"]);
 async function claimOutsideInTarget(provider, desiredPath) {
   for (let attempt = 1; attempt <= MAX_NAME_ATTEMPTS; attempt++) {
     const candidate = attempt === 1 ? desiredPath : withCopySuffix(desiredPath, attempt);
@@ -3964,10 +4509,9 @@ async function importOutsideInFile(file, provider) {
   const created = [claim.path];
   try {
     const sourceBytes = await file.arrayBuffer();
-    const imported = await importOutsideInDocument({
-      data: sourceBytes,
-      targetPath: claim.path
-    });
+    const layout = resolveOutsideInLayout(claim.path);
+    if (!layout) throw new Error(`Outside-in editing does not support \u201C${claim.path}\u201D.`);
+    const imported = await (isOutsideInDataFormat(layout.format) ? importOutsideInDataSidecar({ data: sourceBytes, targetPath: claim.path }) : importOutsideInDocument({ data: sourceBytes, targetPath: claim.path }));
     for (const entry of await imported.container.listFiles()) {
       if (/\.md$/i.test(entry.path)) continue;
       const data = await imported.container.readFile(entry.path);
@@ -3987,10 +4531,7 @@ async function importOutsideInFile(file, provider) {
     throw error;
   }
 }
-async function readImportedMarkdown(file, ext, destPath, provider) {
-  if (ext === ".md" || ext === ".txt") {
-    return file.text();
-  }
+async function readImportedMarkdown(file, destPath, provider) {
   const snapshot = await decodeDbkWorkspace(await file.arrayBuffer(), {
     targetDocumentPath: destPath
   });
@@ -4004,27 +4545,31 @@ async function writeDbkCompanions(snapshot, provider) {
     await writeProviderText(provider, entry.path, entry.content, "create");
   }
 }
-var SUPPORTED_EXTENSIONS2 = /* @__PURE__ */ new Set([".md", ".txt", ...OUTSIDE_IN_EXTENSIONS, ".dbk", ".zip"]);
 async function importDroppedFiles(files, provider) {
   const result = { imported: [], failed: [], unsupported: [] };
   for (const file of files) {
-    const ext = file.name.slice(file.name.lastIndexOf(".")).toLowerCase();
-    if (!SUPPORTED_EXTENSIONS2.has(ext)) {
+    const ext = extensionOfFileName(file.name);
+    if (!isSupportedImportFile(file)) {
       result.unsupported.push(file.name);
       continue;
     }
-    const baseName = file.name.replace(/\.[^.]+$/, "");
     let claimed = null;
     try {
-      if (OUTSIDE_IN_EXTENSIONS.has(ext)) {
+      if (OUTSIDE_IN_IMPORT_EXTENSIONS.has(ext)) {
         const imported = await importOutsideInFile(file, provider);
         result.imported.push({ source: file.name, ...imported });
         continue;
       }
-      const claim = await claimAvailablePath(provider, `${baseName}.md`);
+      const isBundle = BUNDLE_IMPORT_EXTENSIONS.has(ext);
+      const desiredPath = isBundle ? `${file.name.replace(/\.[^.]+$/, "")}.md` : file.name;
+      const claim = await claimAvailablePath(provider, desiredPath);
       claimed = claim.path;
-      const markdown = await readImportedMarkdown(file, ext, claim.path, provider);
-      await writeProviderText(provider, claim.path, markdown);
+      if (isBundle) {
+        const markdown = await readImportedMarkdown(file, claim.path, provider);
+        await writeProviderText(provider, claim.path, markdown);
+      } else {
+        await writeProviderBytes(provider, claim.path, await file.arrayBuffer(), "upsert");
+      }
       result.imported.push({ source: file.name, path: claim.path, renamed: claim.renamed });
     } catch (error) {
       if (claimed) {
@@ -4040,16 +4585,13 @@ async function importDroppedFiles(files, provider) {
 }
 function summariseImport(result) {
   const { imported, failed, unsupported } = result;
-  if (failed.length > 0) {
-    const detail = failed.length === 1 ? `Could not import ${failed[0].source} \u2014 ${failed[0].message}` : `Could not import ${failed.length} of ${failed.length + imported.length} files.`;
+  const rejectedCount = failed.length + unsupported.length;
+  if (rejectedCount > 0) {
+    const detail = failed.length === 1 && unsupported.length === 0 ? `Could not import ${failed[0].source} \u2014 ${failed[0].message}` : unsupported.length === 1 && failed.length === 0 ? `${unsupported[0]} is not a file type DocBlocks can import.` : `Could not import ${rejectedCount} of ${rejectedCount + imported.length} files.`;
     return { kind: "error", message: detail };
   }
   if (imported.length === 0) {
-    if (unsupported.length === 0) return null;
-    return {
-      kind: "error",
-      message: unsupported.length === 1 ? `${unsupported[0]} is not a file type DocBlocks can import.` : `${unsupported.length} dropped files are not file types DocBlocks can import.`
-    };
+    return null;
   }
   const renamed = imported.filter((entry) => entry.renamed);
   if (renamed.length === 1) {
@@ -4067,241 +4609,6 @@ function summariseImport(result) {
   return null;
 }
 
-// src/DocBlocksShell/outside-in.ts
-import {
-  FileSystemContentContainer,
-  FsError as FsError4,
-  getFileSystemProviderV2 as getFileSystemProviderV24,
-  parseWorkspacePath as parseWorkspacePath5
-} from "@bendyline/docblocks/filesystem";
-import {
-  createFileSystemDocumentTarget
-} from "@bendyline/docblocks/document";
-var OUTSIDE_IN_EXTENSION = /\.(?:html?|docx|pdf|pptx|xlsx)$/i;
-var SQUISQ_RUNTIME_DIRECTORY = "_squisq";
-var SQUISQ_RUNTIME_FILENAME = "squisq-player.js";
-function withoutLeadingSlash(path) {
-  return parseWorkspacePath5(path);
-}
-function withLegacySlash(path, like) {
-  const canonical = withoutLeadingSlash(path);
-  return like.startsWith("/") && canonical ? `/${canonical}` : canonical;
-}
-function dirname(path) {
-  const canonical = withoutLeadingSlash(path);
-  const slash = canonical.lastIndexOf("/");
-  return slash < 0 ? "" : canonical.slice(0, slash);
-}
-function join2(parent, child) {
-  return parent ? `${parent}/${child}` : child;
-}
-function relativePath(fromDirectory, targetPath) {
-  const from = withoutLeadingSlash(fromDirectory).split("/").filter(Boolean);
-  const target = withoutLeadingSlash(targetPath).split("/").filter(Boolean);
-  let shared = 0;
-  while (shared < from.length && shared < target.length && from[shared] === target[shared]) {
-    shared++;
-  }
-  const segments = [...from.slice(shared).map(() => ".."), ...target.slice(shared)];
-  return segments.join("/") || ".";
-}
-async function readText(provider, path) {
-  const v2 = getFileSystemProviderV24(provider);
-  if (!v2) return provider.readFile(path);
-  const current = await v2.readFile(parseWorkspacePath5(path));
-  if (!current) return null;
-  return new TextDecoder("utf-8", { fatal: true }).decode(current.data);
-}
-async function readBytes(provider, path) {
-  const v2 = getFileSystemProviderV24(provider);
-  if (v2) return (await v2.readFile(parseWorkspacePath5(path)))?.data ?? null;
-  return provider.readBinary(path);
-}
-async function writeBytes(provider, path, data, mode = "upsert") {
-  const v2 = getFileSystemProviderV24(provider);
-  if (v2) {
-    await v2.writeFile(parseWorkspacePath5(path), data, {
-      mode,
-      createParents: true,
-      expectedVersion: mode === "create" ? null : void 0
-    });
-    return;
-  }
-  if (mode === "create" && await provider.exists(path)) {
-    throw new FsError4("already-exists", "File already exists.", { operation: "write", path });
-  }
-  await provider.writeBinary(path, data);
-}
-async function listCompanionFiles(provider, layout) {
-  try {
-    const entries = await provider.readDirectory(layout.companionDirectory);
-    return entries.filter((entry) => entry.kind === "file").map((entry) => entry.path);
-  } catch (error) {
-    if (error instanceof FsError4 && error.code === "not-found") return [];
-    throw error;
-  }
-}
-async function removeOutsideInCompanion(provider, layout) {
-  const providerV2 = getFileSystemProviderV24(provider);
-  if (providerV2) {
-    const path = parseWorkspacePath5(layout.companionDirectory);
-    if (await providerV2.stat(path) !== null) {
-      await providerV2.remove(path, { recursive: true, missing: "ignore" });
-    }
-    return;
-  }
-  if (await provider.exists(layout.companionDirectory)) {
-    await provider.delete(layout.companionDirectory);
-  }
-}
-async function persistImportedMedia(provider, layout, container) {
-  const entries = await container.listFiles();
-  for (const entry of entries) {
-    if (/\.md$/i.test(entry.path)) continue;
-    const data = await container.readFile(entry.path);
-    if (!data) continue;
-    await writeBytes(provider, join2(layout.companionDirectory, entry.path), data, "create");
-  }
-}
-async function loadEditableShellDocument(provider, selectedPath) {
-  if (!OUTSIDE_IN_EXTENSION.test(selectedPath)) {
-    const content = await readText(provider, selectedPath);
-    return content === null ? null : {
-      displayPath: selectedPath,
-      sourcePath: selectedPath,
-      content,
-      outsideIn: null,
-      outsideInEditingEnabled: true
-    };
-  }
-  const resolved = resolveOutsideInLayout(selectedPath);
-  if (!resolved) return null;
-  const layout = {
-    ...resolved,
-    targetPath: withLegacySlash(resolved.targetPath, selectedPath),
-    companionDirectory: withLegacySlash(resolved.companionDirectory, selectedPath),
-    markdownPath: withLegacySlash(resolved.markdownPath, selectedPath)
-  };
-  const candidates = (await listCompanionFiles(provider, layout)).map(
-    (path) => withLegacySlash(path, selectedPath)
-  );
-  const chosen = chooseOutsideInMarkdownPath(layout, candidates);
-  if (chosen) {
-    const content = await readText(provider, chosen);
-    if (content === null) return null;
-    const metadata = await readOutsideInMetadata(content);
-    if (metadata && metadata.format !== layout.format) {
-      throw new Error(
-        `${chosen} is configured for ${metadata.format}, not ${layout.format}. Rename the rendered file back or repair the companion frontmatter.`
-      );
-    }
-    const linkedContent = await withOutsideInMetadata(content, layout);
-    if (linkedContent !== content) await writeProviderText(provider, chosen, linkedContent);
-    return {
-      displayPath: selectedPath,
-      sourcePath: chosen,
-      content: linkedContent,
-      outsideIn: { ...layout, markdownPath: chosen },
-      outsideInEditingEnabled: await isOutsideInMarkdownEditingEnabled(linkedContent)
-    };
-  }
-  const rendered = await readBytes(provider, selectedPath);
-  if (!rendered) return null;
-  const imported = await importOutsideInDocument({
-    data: rendered,
-    targetPath: selectedPath
-  });
-  const importedLayout = {
-    ...imported.layout,
-    targetPath: withLegacySlash(imported.layout.targetPath, selectedPath),
-    companionDirectory: withLegacySlash(imported.layout.companionDirectory, selectedPath),
-    markdownPath: withLegacySlash(imported.layout.markdownPath, selectedPath)
-  };
-  await persistImportedMedia(provider, importedLayout, imported.container);
-  await writeProviderText(provider, importedLayout.markdownPath, imported.markdown, "create");
-  return {
-    displayPath: selectedPath,
-    sourcePath: importedLayout.markdownPath,
-    content: imported.markdown,
-    outsideIn: importedLayout,
-    outsideInEditingEnabled: false
-  };
-}
-async function enableOutsideInMarkdownEditing(provider, document2) {
-  const layout = document2.outsideIn;
-  if (!layout) throw new Error("This file does not support outside-in Markdown editing.");
-  const original = await readBytes(provider, layout.targetPath);
-  if (!original) throw new Error(`The rendered file "${layout.targetPath}" was not found.`);
-  try {
-    await writeBytes(provider, layout.backupPath, original, "create");
-  } catch (error) {
-    if (!(error instanceof FsError4 && error.code === "already-exists")) throw error;
-  }
-  const content = await withOutsideInMarkdownEditing(document2.content, layout);
-  if (content !== document2.content) await writeProviderText(provider, document2.sourcePath, content);
-  return { ...document2, content, outsideIn: layout, outsideInEditingEnabled: true };
-}
-async function findRuntimePath(provider, targetPath) {
-  let directory = dirname(targetPath);
-  for (; ; ) {
-    const candidateDirectory = join2(directory, SQUISQ_RUNTIME_DIRECTORY);
-    if (await providerEntryExists(provider, candidateDirectory)) {
-      const providerV2 = getFileSystemProviderV24(provider);
-      if (providerV2) {
-        const entry = await providerV2.stat(parseWorkspacePath5(candidateDirectory));
-        if (entry?.kind !== "directory") {
-          throw new Error(`${candidateDirectory} must be a directory.`);
-        }
-      }
-      return join2(candidateDirectory, SQUISQ_RUNTIME_FILENAME);
-    }
-    if (!directory) break;
-    directory = dirname(directory);
-  }
-  return join2(SQUISQ_RUNTIME_DIRECTORY, SQUISQ_RUNTIME_FILENAME);
-}
-async function writeRuntimeIfNeeded(provider, runtimePath) {
-  const { PLAYER_BUNDLE } = await import("@bendyline/squisq-react/standalone-source");
-  const current = await readText(provider, runtimePath);
-  if (current !== PLAYER_BUNDLE) await writeProviderText(provider, runtimePath, PLAYER_BUNDLE);
-}
-function createOutsideInDocumentTarget(provider, layout, onCommitted) {
-  const sourceTarget = createFileSystemDocumentTarget(provider, layout.markdownPath);
-  return {
-    key: `${provider.id}:outside-in:${parseWorkspacePath5(layout.targetPath)}`,
-    async commit(request) {
-      if (!await isOutsideInMarkdownEditingEnabled(request.content)) {
-        throw new Error(
-          "Outside-in editing is read-only until squisq-updatefrommarkdown: true is set."
-        );
-      }
-      const runtimePath = layout.format === "html" ? await findRuntimePath(provider, layout.targetPath) : null;
-      const outputDirectory = dirname(layout.targetPath);
-      const rendered = await renderOutsideInDocument(
-        {
-          markdown: request.content,
-          targetPath: layout.targetPath,
-          container: new FileSystemContentContainer(provider, layout.companionDirectory)
-        },
-        runtimePath ? {
-          html: {
-            playerScriptPath: relativePath(outputDirectory, runtimePath),
-            basePath: relativePath(outputDirectory, layout.companionDirectory)
-          }
-        } : {}
-      );
-      await sourceTarget.commit({ ...request, targetKey: sourceTarget.key });
-      if (runtimePath) await writeRuntimeIfNeeded(provider, runtimePath);
-      await writeBytes(provider, layout.targetPath, rendered.bytes);
-      onCommitted?.();
-      return {};
-    }
-  };
-}
-function createOutsideInContentContainer(provider, layout) {
-  return new FileSystemContentContainer(provider, layout.companionDirectory);
-}
-
 // src/components/usePromptDialog.ts
 import React2, { useCallback as useCallback11, useEffect as useEffect12, useRef as useRef11, useState as useState12 } from "react";
 
@@ -5130,9 +5437,12 @@ function loadEditorShell() {
   return editorShellModulePromise;
 }
 var EditorShell = lazy2(loadEditorShell);
-var GitUI = lazy2(() => import("./GitUI-CAKFVKWY.js").then((m) => ({ default: m.GitUI })));
+var GitUI = lazy2(() => import("./GitUI-L5T3XHZG.js").then((m) => ({ default: m.GitUI })));
+var GitGrantNotice = lazy2(
+  () => import("./GitGrantNotice-I2VNKPLH.js").then((m) => ({ default: m.GitGrantNotice }))
+);
 var GitToolbarControl = lazy2(
-  () => import("./GitToolbarControl-VJVK2B4X.js").then((m) => ({ default: m.GitToolbarControl }))
+  () => import("./GitToolbarControl-O5AXBC6T.js").then((m) => ({ default: m.GitToolbarControl }))
 );
 var DOCBLOCKS_VIDEO_EXPORT_PALETTE = Object.freeze({
   overlay: "rgba(0, 0, 0, 0.72)",
@@ -5403,6 +5713,8 @@ function useIsMobile(breakpoint = 768) {
   }, [breakpoint]);
   return isMobile;
 }
+var DESKTOP_TOOLBAR_WRAP_WIDTH = 900;
+var WEB_TOOLBAR_WRAP_WIDTH = 700;
 function FolderGlyph() {
   return /* @__PURE__ */ jsx14(
     "svg",
@@ -5434,12 +5746,35 @@ function FileGlyph() {
     }
   );
 }
+function CollapseSidebarGlyph() {
+  return /* @__PURE__ */ jsxs12(
+    "svg",
+    {
+      viewBox: "0 0 64 64",
+      fill: "none",
+      stroke: "currentColor",
+      strokeWidth: "3",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      "aria-hidden": "true",
+      children: [
+        /* @__PURE__ */ jsx14("rect", { x: "7", y: "10", width: "50", height: "44", rx: "6" }),
+        /* @__PURE__ */ jsx14("path", { d: "M24 10v44" }),
+        /* @__PURE__ */ jsx14("path", { d: "m17 25-7 7 7 7" })
+      ]
+    }
+  );
+}
 function DocBlocksShell({
   theme: hostTheme = "auto",
   logoUrl,
   issueReportVersion,
   appBuildDate,
   ffmpegWasm,
+  calcEngineFactory,
+  proofing,
+  proofingDefaultEnabled,
+  proofingIgnoreStore,
   homeDocumentTitle,
   homeDocumentPath,
   allowVersioning = true,
@@ -5492,6 +5827,11 @@ function DocBlocksShell({
     setWriteCanvasSettings(settings);
     saveWriteCanvasPreferences(settings);
   }, []);
+  const [proofingPreferences, setProofingPreferences] = useState15(loadProofingPreferences);
+  const handleProofingPreferencesChange = useCallback15((settings) => {
+    setProofingPreferences(settings);
+    saveProofingPreferences(settings);
+  }, []);
   const [viewPreferences, setViewPreferences] = useState15(loadViewPreferences);
   const handleViewPreferencesChange = useCallback15((prefs) => {
     setViewPreferences(prefs);
@@ -5508,6 +5848,27 @@ function DocBlocksShell({
   const [sidebarWidth, setSidebarWidth] = useState15(loadSidebarWidth);
   const [compactLayout, setCompactLayout] = useState15(false);
   const effectiveCompact = isMobile || compactLayout;
+  const editorAreaRef = useRef15(null);
+  const [desktopToolbarWrapped, setDesktopToolbarWrapped] = useState15(false);
+  useEffect15(() => {
+    const editorArea = editorAreaRef.current;
+    if (!editorArea || effectiveCompact) {
+      setDesktopToolbarWrapped(false);
+      return;
+    }
+    const wrapWidth = isElectronHost3() ? DESKTOP_TOOLBAR_WRAP_WIDTH : WEB_TOOLBAR_WRAP_WIDTH;
+    const updateWrappedState = () => {
+      setDesktopToolbarWrapped(editorArea.getBoundingClientRect().width <= wrapWidth);
+    };
+    updateWrappedState();
+    if (typeof ResizeObserver === "undefined") {
+      window.addEventListener("resize", updateWrappedState);
+      return () => window.removeEventListener("resize", updateWrappedState);
+    }
+    const observer = new ResizeObserver(updateWrappedState);
+    observer.observe(editorArea);
+    return () => observer.disconnect();
+  }, [effectiveCompact]);
   const showBrowserStorageWarning = !isElectronHost3();
   const appVersion = isElectronHost3() ? `${getDocBlocksHost().env.appVersion} desktop` : issueReportVersion ?? "web";
   const issueReportUrl = buildIssueReportUrl({
@@ -5553,13 +5914,13 @@ function DocBlocksShell({
         lastRaw = drag.startWidth + (ev.clientX - drag.startX);
         if (lastRaw < SIDEBAR_COLLAPSE_THRESHOLD && sidebarRef.current) {
           sidebarRef.current.style.width = `${SIDEBAR_WIDTH_MIN}px`;
-          sidebarRef.current.style.opacity = "0.45";
+          sidebarRef.current.classList.add("db-shell-sidebar--collapse-preview");
           return;
         }
         const clamped = Math.min(SIDEBAR_WIDTH_MAX, Math.max(SIDEBAR_WIDTH_MIN, lastRaw));
         if (sidebarRef.current) {
           sidebarRef.current.style.width = `${clamped}px`;
-          sidebarRef.current.style.opacity = "";
+          sidebarRef.current.classList.remove("db-shell-sidebar--collapse-preview");
         }
       };
       const onUp = () => {
@@ -5568,7 +5929,7 @@ function DocBlocksShell({
         document.body.style.userSelect = "";
         document.body.classList.remove("db-resizing-sidebar");
         if (sidebarRef.current) {
-          sidebarRef.current.style.opacity = "";
+          sidebarRef.current.classList.remove("db-shell-sidebar--collapse-preview");
         }
         if (lastRaw < SIDEBAR_COLLAPSE_THRESHOLD) {
           setCompactLayout(true);
@@ -5595,6 +5956,11 @@ function DocBlocksShell({
   const [workspaceStartupError, setWorkspaceStartupError] = useState15(null);
   const [activeWorkspaceId, setActiveWorkspaceId] = useState15(null);
   const [activeWorkspaceDescriptor, setActiveWorkspaceDescriptor] = useState15(null);
+  const defaultProofingIgnoreStore = useMemo3(
+    () => createLocalProofingIgnoreStore(() => activeWorkspaceId),
+    [activeWorkspaceId]
+  );
+  const effectiveProofingIgnoreStore = proofingIgnoreStore === void 0 ? defaultProofingIgnoreStore : proofingIgnoreStore;
   useEffect15(() => {
     if (!provider || getTransientWorkspace(provider.id)) return;
     const providerV2 = getFileSystemProviderV27(provider);
@@ -5751,11 +6117,17 @@ function DocBlocksShell({
   const [selectedSourceFile, setSelectedSourceFile] = useState15(null);
   const [selectedOutsideIn, setSelectedOutsideIn] = useState15(null);
   const [selectedOutsideInEditingEnabled, setSelectedOutsideInEditingEnabled] = useState15(false);
+  const [selectedImage, setSelectedImage] = useState15(void 0);
+  const editorViewPreferences = useMemo3(() => {
+    const layoutMode = defaultOutsideInLayoutMode(selectedOutsideIn);
+    return layoutMode && viewPreferences.layoutMode === void 0 ? { ...viewPreferences, layoutMode } : viewPreferences;
+  }, [selectedOutsideIn, viewPreferences]);
   const adoptSelectedDocument = useCallback15((document2) => {
     setSelectedFile(document2?.displayPath ?? null);
     setSelectedSourceFile(document2?.sourcePath ?? null);
     setSelectedOutsideIn(document2?.outsideIn ?? null);
     setSelectedOutsideInEditingEnabled(document2?.outsideInEditingEnabled ?? false);
+    setSelectedImage(document2?.image);
   }, []);
   const adoptRegularDocument = useCallback15((path) => {
     if (path === null) {
@@ -5763,13 +6135,27 @@ function DocBlocksShell({
       setSelectedSourceFile(null);
       setSelectedOutsideIn(null);
       setSelectedOutsideInEditingEnabled(false);
+      setSelectedImage(void 0);
       return;
     }
     setSelectedFile(path);
     setSelectedSourceFile(path);
     setSelectedOutsideIn(null);
     setSelectedOutsideInEditingEnabled(false);
+    setSelectedImage(void 0);
   }, []);
+  const selectedImageUrl = useMemo3(() => {
+    if (!selectedImage || typeof URL === "undefined" || typeof URL.createObjectURL !== "function") {
+      return void 0;
+    }
+    return URL.createObjectURL(new Blob([selectedImage.data], { type: selectedImage.mimeType }));
+  }, [selectedImage]);
+  useEffect15(
+    () => () => {
+      if (selectedImageUrl) URL.revokeObjectURL(selectedImageUrl);
+    },
+    [selectedImageUrl]
+  );
   useDocumentTitle(selectedFile, homeDocumentTitle, homeDocumentPath);
   const exportDestinationAdapter = useMemo3(() => {
     if (!selectedFile) return void 0;
@@ -6632,7 +7018,7 @@ function DocBlocksShell({
     const providerV2 = getFileSystemProviderV27(provider);
     if (!providerV2?.capabilities.watch) return;
     const watchedFile = selectedSourceFile ?? selectedFile;
-    if (!watchedFile || !documentSnapshot.targetKey) return;
+    if (!watchedFile || !documentSnapshot.targetKey || selectedImage) return;
     const targetKey = documentSnapshot.targetKey;
     let disposed = false;
     let reading = false;
@@ -6686,7 +7072,14 @@ function DocBlocksShell({
       disposed = true;
       void subscription.dispose();
     };
-  }, [provider, selectedFile, selectedSourceFile, documentSession, documentSnapshot.targetKey]);
+  }, [
+    provider,
+    selectedFile,
+    selectedSourceFile,
+    selectedImage,
+    documentSession,
+    documentSnapshot.targetKey
+  ]);
   const transitionAwayFromDocument = useCallback15(
     async (requestId) => {
       if (requestId !== navigationRequestRef.current) return false;
@@ -7698,7 +8091,7 @@ function DocBlocksShell({
         const nextFile = selectedFile ? relocateProviderPath(selectedFile, change.oldPath, change.newPath) : null;
         const nextFolder = selectedFolder ? relocateProviderPath(selectedFolder, change.oldPath, change.newPath) : null;
         if (nextFile !== selectedFile) {
-          if (nextFile && selectedOutsideIn) {
+          if (nextFile) {
             const opened = await loadEditableShellDocument(provider, nextFile);
             adoptSelectedDocument(opened);
           } else {
@@ -7743,7 +8136,6 @@ function DocBlocksShell({
       adoptRegularDocument,
       adoptSelectedDocument,
       selectedFile,
-      selectedOutsideIn,
       selectedFolder,
       activeWorkspaceId,
       pinnedDocuments,
@@ -8372,7 +8764,7 @@ function DocBlocksShell({
   return /* @__PURE__ */ jsx14(
     "div",
     {
-      className: `db-shell${effectiveCompact ? " db-shell--mobile" : ""}`,
+      className: `db-shell${effectiveCompact ? " db-shell--mobile" : ""}${desktopToolbarWrapped ? " db-shell--desktop-toolbar-wrapped" : ""}`,
       "data-theme": resolvedTheme,
       "data-accent": accentColor,
       "data-document-status": documentSnapshot.status,
@@ -8433,6 +8825,8 @@ function DocBlocksShell({
                       onAccentColorChange: handleAccentColorChange,
                       writeCanvasSettings,
                       onWriteCanvasSettingsChange: handleWriteCanvasSettingsChange,
+                      proofingPreferences,
+                      onProofingPreferencesChange: handleProofingPreferencesChange,
                       versioningPreference,
                       onVersioningPreferenceChange: handleVersioningPreferenceChange,
                       onDownloadAllWorkspaces: handleDownloadAllWorkspaces,
@@ -8544,6 +8938,7 @@ function DocBlocksShell({
                     ]
                   }
                 ),
+                git.available && git.pendingGrant && /* @__PURE__ */ jsx14(Suspense2, { fallback: null, children: /* @__PURE__ */ jsx14(GitGrantNotice, {}) }),
                 /* @__PURE__ */ jsxs12("div", { className: "db-shell-sidebar-footer", children: [
                   /* @__PURE__ */ jsx14("a", { href: "https://docblocks.com/docs/", target: "_blank", rel: "noopener noreferrer", children: "Docs" }),
                   /* @__PURE__ */ jsx14("span", { className: "db-shell-sidebar-footer-separator", "aria-hidden": "true", children: "\u2022" }),
@@ -8563,6 +8958,10 @@ function DocBlocksShell({
                       }
                     )
                   ] })
+                ] }),
+                /* @__PURE__ */ jsxs12("div", { className: "db-sidebar-collapse-preview", "aria-hidden": "true", children: [
+                  /* @__PURE__ */ jsx14("span", { className: "db-sidebar-collapse-preview-icon", children: /* @__PURE__ */ jsx14(CollapseSidebarGlyph, {}) }),
+                  /* @__PURE__ */ jsx14("span", { className: "db-sidebar-collapse-preview-label", children: "Release to hide files" })
                 ] })
               ]
             }
@@ -8580,6 +8979,7 @@ function DocBlocksShell({
           (!effectiveCompact || mobileShowEditor) && /* @__PURE__ */ jsxs12(
             "main",
             {
+              ref: editorAreaRef,
               "aria-label": "Document editor",
               className: updateAvailable && onApplyUpdate && updateStatusBarVisible ? "db-shell-editor-area db-shell-editor-area--has-update" : "db-shell-editor-area",
               style: {
@@ -8599,11 +8999,13 @@ function DocBlocksShell({
                         EditorShell,
                         {
                           initialMarkdown: editorContent,
-                          readOnly: selectedOutsideIn !== null && !selectedOutsideInEditingEnabled,
+                          readOnly: selectedImage !== void 0 || selectedOutsideIn !== null && !selectedOutsideInEditingEnabled,
                           initialView,
                           defaultViewportPreset: defaultPreviewViewportPreset,
                           articleId: selectedFile,
-                          fileName: selectedFile,
+                          fileName: selectedSourceFile ?? selectedFile,
+                          imageSrc: selectedImageUrl,
+                          imageAlt: basenameOf(selectedFile),
                           saveCoverImageOutput: saveRenderedImageOutput,
                           saveDashboardImageOutput: saveRenderedImageOutput,
                           onChange: handleEditorChange,
@@ -8614,6 +9016,12 @@ function DocBlocksShell({
                           placeholder: editorPlaceholder,
                           outlineWidth: 280,
                           mediaProvider,
+                          calcEngineFactory,
+                          proofing,
+                          proofingDefaultEnabled,
+                          proofingSpellingEnabled: proofingPreferences.spelling,
+                          proofingGrammarEnabled: proofingPreferences.grammar,
+                          proofingIgnoreStore: effectiveProofingIgnoreStore,
                           showCodeCopyButton,
                           onCopyCode,
                           allowRecording,
@@ -8621,8 +9029,8 @@ function DocBlocksShell({
                           allowPresentationFullscreen,
                           documentLinkProvider,
                           workspaceContainer: versionsContainer ?? void 0,
-                          allowVersioning: effectiveVersioning,
-                          viewPreferences,
+                          allowVersioning: selectedImage === void 0 && effectiveVersioning,
+                          viewPreferences: editorViewPreferences,
                           onViewPreferencesChange: handleViewPreferencesChange,
                           versionBasename: versionBasename ?? stripExtension(basenameOf(selectedFile)),
                           versioningPrunePolicy,
@@ -8764,12 +9172,14 @@ export {
   AccentColorSettings,
   AppMenu,
   DEFAULT_OPTIONS,
+  DEFAULT_PROOFING_PREFERENCES,
   DEFAULT_WRITE_CANVAS_FONT_SCHEME,
   DocBlocksShell,
   ExportDialog,
   ExportToolbarControls,
   FileExplorer,
   FileTreeNode,
+  ProofingSettingsControls,
   SettingsDialog,
   ThemeSettings,
   WRITE_CANVAS_FONT_SCHEMES,
@@ -8780,8 +9190,10 @@ export {
   createImageSaveOutput as createDashboardImageSaveOutput,
   createImageSaveOutput,
   loadLastExportOptions,
+  loadProofingPreferences,
   resolveWriteCanvasFonts,
   runExport,
+  saveProofingPreferences,
   updateExportTargetExtension,
   useDocumentSession,
   useFileTree