@bendyline/docblocks-react 2.3.4 → 2.5.0

package/dist/index.js

@@ -8,8 +8,9 @@ import {
   useGitContext
 } from "./chunk-HFYPTTCH.js";
 import {
+  createImageSaveOutput,
   updateExportTargetExtension
-} from "./chunk-BI7NVU6T.js";
+} from "./chunk-FNSRCCBC.js";
 import {
   AccentColorSettings,
   DB_CHROME_COLORS,
@@ -97,6 +98,22 @@ function equivalentPathKeys(path) {
 function hasEquivalentPath(paths, path) {
   return equivalentPathKeys(path).some((candidate) => paths.has(candidate));
 }
+function sameEntry(left, right) {
+  if (left.kind !== right.kind || left.name !== right.name || left.path !== right.path)
+    return false;
+  if (left.kind === "file" && right.kind === "file") {
+    return left.lastModified === right.lastModified;
+  }
+  return true;
+}
+function reconcileEntries(current, incoming) {
+  const currentByPath = new Map(current.map((entry) => [entry.path, entry]));
+  const reconciled = incoming.map((entry) => {
+    const previous = currentByPath.get(entry.path);
+    return previous && sameEntry(previous, entry) ? previous : entry;
+  });
+  return reconciled.length === current.length && reconciled.every((entry, index) => entry === current[index]) ? current : reconciled;
+}
 async function readProviderDirectory(provider, path) {
   const canonical = parseWorkspacePath(path);
   const readOnce = async () => {
@@ -172,7 +189,7 @@ function useFileTree(provider, metadataRefreshKey, metadataRefreshPath) {
     try {
       const root = await readProviderDirectory(sourceProvider, "");
       if (!isCurrent()) return;
-      setEntries(root);
+      setEntries((current) => reconcileEntries(current, root));
       setRootIssue(null);
     } catch (caught) {
       if (isCurrent()) setRootIssue(readIssue(caught, ""));
@@ -191,8 +208,11 @@ function useFileTree(provider, metadataRefreshKey, metadataRefreshPath) {
       const children = await readProviderDirectory(sourceProvider, dirPath);
       if (!isCurrent()) return;
       setChildEntries((prev) => {
+        const current = prev.get(canonical) ?? [];
+        const reconciled = reconcileEntries(current, children);
+        if (prev.has(canonical) && reconciled === current) return prev;
         const next = new Map(prev);
-        next.set(canonical, children);
+        next.set(canonical, reconciled);
         return next;
       });
       setChildIssues((prev) => {
@@ -259,7 +279,7 @@ function useFileTree(provider, metadataRefreshKey, metadataRefreshPath) {
     [loadChildren]
   );
   const refresh = useCallback(async () => {
-    await loadRoot();
+    await loadRoot(false);
     const expandedPaths = [...expanded];
     for (const dirPath of expandedPaths) {
       await loadChildren(dirPath);
@@ -333,18 +353,21 @@ function useFileTree(provider, metadataRefreshKey, metadataRefreshPath) {
       directoriesToRefresh.clear();
       drainRefreshes();
     };
-    const requestMetadataRefresh = (path) => {
+    const requestDirectoryRefresh = (path) => {
       if (disposed || fullRefreshRequested) return;
       directoriesToRefresh.add(workspacePathDirname(parseWorkspacePath(path)));
       drainRefreshes();
     };
     const subscription = providerV2.watch(
       (event) => {
-        if (event.type === "modified") {
-          requestMetadataRefresh(event.path);
-          return;
+        if (event.type !== "overflow") {
+          requestDirectoryRefresh(event.path);
+          if (event.type === "moved" && event.destinationPath !== null) {
+            requestDirectoryRefresh(event.destinationPath);
+          }
+        } else {
+          requestRefresh();
         }
-        requestRefresh();
       },
       {
         onError: (caught) => {
@@ -498,6 +521,9 @@ function NewFileIcon() {
 function NewFolderIcon() {
   return /* @__PURE__ */ jsx(FontAwesomeIcon, { icon: "fa-solid fa-folder-plus" });
 }
+function OpenFolderIcon() {
+  return /* @__PURE__ */ jsx(FontAwesomeIcon, { icon: "fa-solid fa-folder-open" });
+}
 function SortByNameIcon() {
   return /* @__PURE__ */ jsx(FontAwesomeIcon, { icon: "fa-solid fa-arrow-down-a-z" });
 }
@@ -658,6 +684,7 @@ function FileTreeNode({
   selected,
   badge,
   gitActions,
+  actions = [],
   focusable = true,
   posInSet,
   setSize,
@@ -829,6 +856,18 @@ function FileTreeNode({
       );
     }
   }, [closeMenu, entry.path, onTogglePin, pinned]);
+  const handleCustomAction = useCallback2(
+    async (action) => {
+      closeMenu(false);
+      setActionError(null);
+      try {
+        await action.onSelect();
+      } catch (caught) {
+        setActionError(caught instanceof Error ? caught.message : `Unable to ${action.label}.`);
+      }
+    },
+    [closeMenu]
+  );
   useEffect2(() => {
     if (!showContext) return;
     function handleClose(e) {
@@ -1009,6 +1048,22 @@ function FileTreeNode({
                 children: pinned ? "Unpin" : "Pin"
               }
             ),
+            actions.length > 0 && /* @__PURE__ */ jsxs2(Fragment, { children: [
+              /* @__PURE__ */ jsx3("div", { className: "db-tree-context-divider", role: "separator" }),
+              actions.map((action) => /* @__PURE__ */ jsx3(
+                "button",
+                {
+                  type: "button",
+                  role: "menuitem",
+                  tabIndex: -1,
+                  className: "db-tree-context-item",
+                  disabled: action.disabled,
+                  onClick: () => void handleCustomAction(action),
+                  children: action.label
+                },
+                action.label
+              ))
+            ] }),
             gitActions && (gitActions.viewChanges || gitActions.fileHistory) && /* @__PURE__ */ jsxs2(Fragment, { children: [
               /* @__PURE__ */ jsx3("div", { className: "db-tree-context-divider", role: "separator" }),
               gitActions.viewChanges && /* @__PURE__ */ jsx3(
@@ -1565,7 +1620,18 @@ function sortFileEntries(entries, mode) {
 
 // src/FileExplorer/FileExplorer.tsx
 import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
-var SUPPORTED_EXTENSIONS = /* @__PURE__ */ new Set([".txt", ".md", ".docx", ".pdf", ".dbk", ".zip"]);
+var SUPPORTED_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".txt",
+  ".md",
+  ".html",
+  ".htm",
+  ".docx",
+  ".pdf",
+  ".pptx",
+  ".xlsx",
+  ".dbk",
+  ".zip"
+]);
 var INTERNAL_DRAG_TYPE = "application/x-docblocks-entry";
 var NEW_ITEM_ERROR_ID = "db-new-item-error";
 function normalisePath2(path) {
@@ -1616,6 +1682,8 @@ function FileExplorer({
   onPinnedDocumentDelete,
   onTogglePin,
   onSelect,
+  onOpenWorkspaceFolder,
+  actionsForEntry,
   onTreeMutation,
   onTreeChange,
   onImportFiles,
@@ -1975,6 +2043,7 @@ function FileExplorer({
             selected: tree.selectedPath !== null && normalisePath2(tree.selectedPath) === normalisePath2(entry.path),
             badge: badgeFor(entry),
             gitActions: gitActionsFor(entry),
+            actions: actionsForEntry?.(entry),
             onToggle: tree.toggleExpand,
             onSelect: handleSelect,
             confirmDelete,
@@ -2029,6 +2098,7 @@ function FileExplorer({
       childIssues,
       badgeFor,
       gitActionsFor,
+      actionsForEntry,
       draggedEntry,
       dropTarget,
       handleInternalDragStart,
@@ -2092,6 +2162,17 @@ function FileExplorer({
               )
             ] }),
             /* @__PURE__ */ jsx5("span", { className: "db-explorer-action-divider", "aria-hidden": "true" }),
+            onOpenWorkspaceFolder && /* @__PURE__ */ jsx5(
+              "button",
+              {
+                type: "button",
+                className: "db-explorer-btn",
+                onClick: onOpenWorkspaceFolder,
+                title: "Open this folder",
+                "aria-label": "Open this folder",
+                children: /* @__PURE__ */ jsx5(OpenFolderIcon, {})
+              }
+            ),
             /* @__PURE__ */ jsx5(
               "button",
               {
@@ -2523,21 +2604,22 @@ import {
   DocumentVersionManager
 } from "@bendyline/squisq/versions";
 import {
-  FileSystemContentContainer,
+  FileSystemContentContainer as FileSystemContentContainer2,
   createFileMediaProvider,
   decodeUtf8Text,
-  FsError as FsError5,
-  getFileSystemProviderV2 as getFileSystemProviderV25,
+  FsError as FsError6,
+  getFileSystemProviderV2 as getFileSystemProviderV27,
   isQuotaExceededError,
   moveFileSystemEntry as moveFileSystemEntry2,
-  parseWorkspacePath as parseWorkspacePath5,
+  parseWorkspacePath as parseWorkspacePath7,
   workspacePathContains
 } from "@bendyline/docblocks/filesystem";
 import {
-  createFileSystemDocumentTarget,
+  createFileSystemDocumentTarget as createFileSystemDocumentTarget2,
   DocumentCommitConflictError,
   DocumentSessionConflictError
 } from "@bendyline/docblocks/document";
+import { createMediaProviderFromContainer } from "@bendyline/squisq/storage";
 import { isElectronHost as isElectronHost3, getDocBlocksHost } from "@bendyline/docblocks/host";
 import {
   parseSharedDocumentHash
@@ -3154,7 +3236,7 @@ function useDocumentSession(autoSaveDelayMs = 500) {
 import { lazy, Suspense } from "react";
 import { jsx as jsx10 } from "react/jsx-runtime";
 var ExportToolbarControlsImplementation = lazy(
-  () => import("./ExportToolbarControls-N3TCL5DD.js").then((module) => ({
+  () => import("./ExportToolbarControls-BUVJCSMV.js").then((module) => ({
     default: module.ExportToolbarControls
   }))
 );
@@ -3671,7 +3753,123 @@ function hasControlCharacter(value) {
 }
 
 // src/DocBlocksShell/import-files.ts
-import { FsError as FsError3 } from "@bendyline/docblocks/filesystem";
+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 {
@@ -3730,23 +3928,68 @@ async function claimAvailablePath(provider, desiredPath) {
   }
   throw new Error(`Too many documents are already named like \u201C${desiredPath}\u201D.`);
 }
-async function readImportedMarkdown(file, ext, destPath, provider, deps) {
-  if (ext === ".md" || ext === ".txt") {
-    return file.text();
+async function writeProviderBytes(provider, path, data, mode) {
+  const providerV2 = getFileSystemProviderV23(provider);
+  if (providerV2) {
+    await providerV2.writeFile(parseWorkspacePath4(path), data, {
+      mode,
+      createParents: true,
+      expectedVersion: mode === "create" ? null : void 0
+    });
+    return;
   }
-  if (ext === ".docx") {
-    const { docxToContainer } = await import("@bendyline/squisq-formats/docx");
-    const container = await docxToContainer(await file.arrayBuffer());
-    const markdown = await container.readDocument() ?? "";
-    await deps.persistMedia(container, destPath);
-    return markdown;
+  if (mode === "create" && await providerEntryExists(provider, path)) {
+    throw new FsError3("already-exists", "File already exists.", { operation: "write", path });
   }
-  if (ext === ".pdf") {
-    const { pdfToContainer } = await import("@bendyline/squisq-formats/pdf");
-    const container = await pdfToContainer(await file.arrayBuffer());
-    const markdown = await container.readDocument() ?? "";
-    await deps.persistMedia(container, destPath);
-    return markdown;
+  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);
+    const layout = resolveOutsideInLayout(candidate);
+    if (!layout) throw new Error(`Outside-in editing does not support \u201C${desiredPath}\u201D.`);
+    if (await providerEntryExists(provider, layout.companionDirectory)) continue;
+    try {
+      await writeProviderBytes(provider, candidate, new Uint8Array(), "create");
+      return { path: candidate, renamed: attempt > 1 };
+    } catch (error) {
+      if (!isAlreadyExists(error)) throw error;
+    }
+  }
+  throw new Error(`Too many documents are already named like \u201C${desiredPath}\u201D.`);
+}
+async function importOutsideInFile(file, provider) {
+  const claim = await claimOutsideInTarget(provider, file.name);
+  const created = [claim.path];
+  try {
+    const sourceBytes = await file.arrayBuffer();
+    const imported = await 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);
+      if (!data) continue;
+      const destination = `${imported.layout.companionDirectory}/${entry.path.replace(/^\/+/, "")}`;
+      await writeProviderBytes(provider, destination, data, "create");
+      created.push(destination);
+    }
+    await writeProviderText(provider, imported.layout.markdownPath, imported.markdown, "create");
+    created.push(imported.layout.markdownPath);
+    await writeProviderBytes(provider, claim.path, sourceBytes, "upsert");
+    return claim;
+  } catch (error) {
+    for (const path of created.reverse()) {
+      await removeProviderEntry(provider, path).catch(() => void 0);
+    }
+    throw error;
+  }
+}
+async function readImportedMarkdown(file, ext, destPath, provider) {
+  if (ext === ".md" || ext === ".txt") {
+    return file.text();
   }
   const snapshot = await decodeDbkWorkspace(await file.arrayBuffer(), {
     targetDocumentPath: destPath
@@ -3761,8 +4004,8 @@ async function writeDbkCompanions(snapshot, provider) {
     await writeProviderText(provider, entry.path, entry.content, "create");
   }
 }
-var SUPPORTED_EXTENSIONS2 = /* @__PURE__ */ new Set([".md", ".txt", ".docx", ".pdf", ".dbk", ".zip"]);
-async function importDroppedFiles(files, provider, deps) {
+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();
@@ -3773,9 +4016,14 @@ async function importDroppedFiles(files, provider, deps) {
     const baseName = file.name.replace(/\.[^.]+$/, "");
     let claimed = null;
     try {
+      if (OUTSIDE_IN_EXTENSIONS.has(ext)) {
+        const imported = await importOutsideInFile(file, provider);
+        result.imported.push({ source: file.name, ...imported });
+        continue;
+      }
       const claim = await claimAvailablePath(provider, `${baseName}.md`);
       claimed = claim.path;
-      const markdown = await readImportedMarkdown(file, ext, claim.path, provider, deps);
+      const markdown = await readImportedMarkdown(file, ext, claim.path, provider);
       await writeProviderText(provider, claim.path, markdown);
       result.imported.push({ source: file.name, path: claim.path, renamed: claim.renamed });
     } catch (error) {
@@ -3807,7 +4055,7 @@ function summariseImport(result) {
   if (renamed.length === 1) {
     return {
       kind: "success",
-      message: `Imported as ${renamed[0].path} \u2014 a document named ${renamed[0].source.replace(/\.[^.]+$/, "")}.md already exists.`
+      message: `Imported as ${renamed[0].path} \u2014 a document with that name or companion folder already exists.`
     };
   }
   if (renamed.length > 1) {
@@ -3819,6 +4067,241 @@ 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";
 
@@ -4232,9 +4715,9 @@ import { useCallback as useCallback14, useEffect as useEffect14, useRef as useRe
 
 // src/DocBlocksShell/document-links.ts
 import {
-  FsError as FsError4,
-  getFileSystemProviderV2 as getFileSystemProviderV23,
-  parseWorkspacePath as parseWorkspacePath4
+  FsError as FsError5,
+  getFileSystemProviderV2 as getFileSystemProviderV25,
+  parseWorkspacePath as parseWorkspacePath6
 } from "@bendyline/docblocks/filesystem";
 var DEFAULT_DOCUMENT_DISCOVERY_LIMITS = Object.freeze({
   entries: 1e4,
@@ -4257,9 +4740,9 @@ function positiveLimit(value, fallback, label) {
   return selected;
 }
 async function readDirectory(provider, path) {
-  const providerV2 = getFileSystemProviderV23(provider);
+  const providerV2 = getFileSystemProviderV25(provider);
   if (!providerV2) return provider.readDirectory(path);
-  const entries = await providerV2.readDirectory(parseWorkspacePath4(path));
+  const entries = await providerV2.readDirectory(parseWorkspacePath6(path));
   return entries.map((entry) => ({ kind: entry.kind, name: entry.name, path: entry.path }));
 }
 function cancellationError(signal) {
@@ -4326,7 +4809,7 @@ async function collectMarkdownFiles(provider, root, options = {}) {
   while (pending.length > 0) {
     if (options.signal?.aborted) throw cancellationError(options.signal);
     const current = pending.pop();
-    const canonical = parseWorkspacePath4(current.path);
+    const canonical = parseWorkspacePath6(current.path);
     if (visited.has(canonical)) continue;
     visited.add(canonical);
     if (visited.size > maxDirectories) {
@@ -4339,7 +4822,7 @@ async function collectMarkdownFiles(provider, root, options = {}) {
     try {
       entries = await readWithBudget(provider, canonical, deadline, options.signal);
     } catch (error) {
-      if (error instanceof FsError4 && error.code === "not-found") continue;
+      if (error instanceof FsError5 && error.code === "not-found") continue;
       throw error;
     }
     entryCount += entries.length;
@@ -4368,7 +4851,7 @@ async function collectMarkdownFiles(provider, root, options = {}) {
   }
   return markdown;
 }
-function dirname(path) {
+function dirname2(path) {
   const clean = path.replace(/^\/+/, "");
   const index = clean.lastIndexOf("/");
   return index < 0 ? "" : clean.slice(0, index);
@@ -4392,16 +4875,16 @@ function relativeMarkdownLink(fromFile, toFile) {
 }
 function createDocumentLinkCandidates(entries, selectedFile, query) {
   const normalizedQuery = query.trim().toLowerCase();
-  const selected = parseWorkspacePath4(selectedFile);
+  const selected = parseWorkspacePath6(selectedFile);
   const candidates = [];
   for (const entry of entries) {
-    if (entry.kind !== "file" || parseWorkspacePath4(entry.path) === selected) continue;
+    if (entry.kind !== "file" || parseWorkspacePath6(entry.path) === selected) continue;
     const label = entry.name.replace(/\.md$/iu, "");
     const path = relativeMarkdownLink(selectedFile, entry.path);
     if (normalizedQuery && !label.toLowerCase().includes(normalizedQuery) && !path.toLowerCase().includes(normalizedQuery)) {
       continue;
     }
-    const description = dirname(entry.path);
+    const description = dirname2(entry.path);
     candidates.push(description ? { path, label, description } : { path, label });
   }
   candidates.sort((left, right) => left.label.localeCompare(right.label));
@@ -4465,14 +4948,14 @@ var WorkspaceAuthorityBarrier = class {
 
 // src/DocBlocksShell/transient-workspace-move.ts
 import {
-  getFileSystemProviderV2 as getFileSystemProviderV24
+  getFileSystemProviderV2 as getFileSystemProviderV26
 } from "@bendyline/docblocks/filesystem";
 function pathDepth(path) {
   return path ? path.split("/").length : 0;
 }
 async function copyTransientWorkspaceContents(source, destination) {
-  const sourceV2 = getFileSystemProviderV24(source);
-  const destinationV2 = getFileSystemProviderV24(destination);
+  const sourceV2 = getFileSystemProviderV26(source);
+  const destinationV2 = getFileSystemProviderV26(destination);
   if (!sourceV2 || !destinationV2) {
     throw new Error("Moving a temporary document requires a current workspace provider.");
   }
@@ -4534,6 +5017,21 @@ async function copyTransientWorkspaceContents(source, destination) {
   }
 }
 
+// src/DocBlocksShell/native-file-actions.ts
+function createNativeFileActions(entry, workspaceId, host) {
+  if (entry.kind !== "file" || workspaceId === null || host === null) return [];
+  return [
+    {
+      label: "Open containing folder",
+      onSelect: () => host.shell.revealInFolder(workspaceId, entry.path)
+    },
+    {
+      label: "Copy full path",
+      onSelect: () => host.clipboard.writeWorkspacePath(workspaceId, entry.path)
+    }
+  ];
+}
+
 // src/DocBlocksShell/welcome-document.ts
 var WELCOME_DOCUMENT_PATH = "/aboutDocBlocks.md";
 var WELCOME_DOCUMENT_CONTENT = [
@@ -4542,7 +5040,7 @@ var WELCOME_DOCUMENT_CONTENT = [
   "squisq-cover-slide: false",
   "---",
   "",
-  '# DocBlocks: one Markdown file, many finished forms {[title subtitle="Local-first writing for pages, documents, slideshows, and video"]}',
+  '# DocBlocks {[title subtitle="Local-first writing for pages, documents, slideshows, and video"]}',
   "",
   "Write in plain Markdown. Shape it visually. Keep it portable.",
   "",
@@ -4756,7 +5254,7 @@ function stripExtension(name) {
   return name.replace(/\.[^.]+$/, "");
 }
 function normaliseProviderPath(p) {
-  const canonical = parseWorkspacePath5(p);
+  const canonical = parseWorkspacePath7(p);
   return canonical ? `/${canonical}` : "/";
 }
 function sameProviderPath(a, b) {
@@ -4769,32 +5267,32 @@ function relocateProviderPath(path, oldPath, newPath) {
   return `${newPath.replace(/\/+$/, "")}${current.slice(oldNormalised.length)}`;
 }
 function pathContains(parentPath2, candidatePath) {
-  return workspacePathContains(parseWorkspacePath5(parentPath2), parseWorkspacePath5(candidatePath));
+  return workspacePathContains(parseWorkspacePath7(parentPath2), parseWorkspacePath7(candidatePath));
 }
 async function readProviderDirectory2(provider, path) {
-  const providerV2 = getFileSystemProviderV25(provider);
+  const providerV2 = getFileSystemProviderV27(provider);
   if (!providerV2) return provider.readDirectory(path);
-  const entries = await providerV2.readDirectory(parseWorkspacePath5(path));
+  const entries = await providerV2.readDirectory(parseWorkspacePath7(path));
   return entries.map((entry) => ({ kind: entry.kind, name: entry.name, path: entry.path }));
 }
 async function readProviderText(provider, path) {
-  const providerV2 = getFileSystemProviderV25(provider);
+  const providerV2 = getFileSystemProviderV27(provider);
   if (!providerV2) return provider.readFile(path);
-  const file = await providerV2.readFile(parseWorkspacePath5(path));
-  return file ? decodeUtf8Text(file.data, { label: "The document", path: parseWorkspacePath5(path) }) : null;
+  const file = await providerV2.readFile(parseWorkspacePath7(path));
+  return file ? decodeUtf8Text(file.data, { label: "The document", path: parseWorkspacePath7(path) }) : null;
 }
 async function pinnedProviderFileExists(provider, path) {
-  const providerV2 = getFileSystemProviderV25(provider);
+  const providerV2 = getFileSystemProviderV27(provider);
   if (!providerV2) return provider.exists(path);
-  const entry = await providerV2.stat(parseWorkspacePath5(path));
+  const entry = await providerV2.stat(parseWorkspacePath7(path));
   if (!entry) return false;
   if (entry.kind !== "file") throw new Error("The pinned path is no longer a document.");
   return true;
 }
 async function removePinnedProviderFile(provider, path) {
-  const providerV2 = getFileSystemProviderV25(provider);
+  const providerV2 = getFileSystemProviderV27(provider);
   if (providerV2) {
-    const canonical = parseWorkspacePath5(path);
+    const canonical = parseWorkspacePath7(path);
     const entry = await providerV2.stat(canonical);
     if (!entry) return false;
     if (entry.kind !== "file") throw new Error("The pinned path is no longer a document.");
@@ -4810,13 +5308,13 @@ async function removePinnedProviderFile(provider, path) {
   return true;
 }
 async function readStableFileSnapshot(provider, path) {
-  const providerV2 = getFileSystemProviderV25(provider);
+  const providerV2 = getFileSystemProviderV27(provider);
   if (providerV2) {
-    const read = await providerV2.readFile(parseWorkspacePath5(path));
+    const read = await providerV2.readFile(parseWorkspacePath7(path));
     return {
       content: read ? decodeUtf8Text(read.data, {
         label: "The document",
-        path: parseWorkspacePath5(path)
+        path: parseWorkspacePath7(path)
       }) : null,
       version: read?.entry.version ?? null
     };
@@ -4852,7 +5350,7 @@ async function ensureHandleWritePermission(handle) {
   }
 }
 async function copyProviderToContainer(src, container, pathPrefix) {
-  const providerV2 = getFileSystemProviderV25(src);
+  const providerV2 = getFileSystemProviderV27(src);
   if (providerV2) {
     const snapshot = await providerV2.snapshot();
     for (const entry of snapshot.entries) {
@@ -5099,7 +5597,7 @@ function DocBlocksShell({
   const [activeWorkspaceDescriptor, setActiveWorkspaceDescriptor] = useState15(null);
   useEffect15(() => {
     if (!provider || getTransientWorkspace(provider.id)) return;
-    const providerV2 = getFileSystemProviderV25(provider);
+    const providerV2 = getFileSystemProviderV27(provider);
     return providerV2 ? retainFileSystemProvider(providerV2) : void 0;
   }, [provider]);
   const [descriptorRefreshKey, setDescriptorRefreshKey] = useState15(0);
@@ -5186,7 +5684,7 @@ function DocBlocksShell({
     void scan();
     const scanOnFocus = () => void scan();
     window.addEventListener("focus", scanOnFocus);
-    const providerV2 = getFileSystemProviderV25(provider);
+    const providerV2 = getFileSystemProviderV27(provider);
     const subscription = providerV2?.capabilities.watch ? providerV2.watch(
       (event) => {
         if (event.type !== "modified") void scan();
@@ -5224,8 +5722,8 @@ function DocBlocksShell({
       cancelled = true;
     };
   }, [activeWorkspaceDescriptor]);
-  const gitWorkspaceId = provider && activeWorkspaceDescriptor?.id === activeWorkspaceId && provider.id === activeWorkspaceId && activeWorkspaceDescriptor.type === "electron-native" ? activeWorkspaceDescriptor.id : null;
-  const git = useGit(provider, gitWorkspaceId, resolvedTheme);
+  const nativeWorkspaceId = provider && activeWorkspaceDescriptor?.id === activeWorkspaceId && provider.id === activeWorkspaceId && activeWorkspaceDescriptor.type === "electron-native" ? activeWorkspaceDescriptor.id : null;
+  const git = useGit(provider, nativeWorkspaceId, resolvedTheme);
   const gitRef = useRef15(git);
   gitRef.current = git;
   const { scheduleRefresh: gitScheduleRefresh } = git;
@@ -5250,6 +5748,28 @@ function DocBlocksShell({
     [activeWorkspaceDescriptor]
   );
   const [selectedFile, setSelectedFile] = useState15(null);
+  const [selectedSourceFile, setSelectedSourceFile] = useState15(null);
+  const [selectedOutsideIn, setSelectedOutsideIn] = useState15(null);
+  const [selectedOutsideInEditingEnabled, setSelectedOutsideInEditingEnabled] = useState15(false);
+  const adoptSelectedDocument = useCallback15((document2) => {
+    setSelectedFile(document2?.displayPath ?? null);
+    setSelectedSourceFile(document2?.sourcePath ?? null);
+    setSelectedOutsideIn(document2?.outsideIn ?? null);
+    setSelectedOutsideInEditingEnabled(document2?.outsideInEditingEnabled ?? false);
+  }, []);
+  const adoptRegularDocument = useCallback15((path) => {
+    if (path === null) {
+      setSelectedFile(null);
+      setSelectedSourceFile(null);
+      setSelectedOutsideIn(null);
+      setSelectedOutsideInEditingEnabled(false);
+      return;
+    }
+    setSelectedFile(path);
+    setSelectedSourceFile(path);
+    setSelectedOutsideIn(null);
+    setSelectedOutsideInEditingEnabled(false);
+  }, []);
   useDocumentTitle(selectedFile, homeDocumentTitle, homeDocumentPath);
   const exportDestinationAdapter = useMemo3(() => {
     if (!selectedFile) return void 0;
@@ -5264,6 +5784,10 @@ function DocBlocksShell({
     }
     return createBrowserSaveAsAdapter();
   }, [activeWorkspaceId, selectedFile]);
+  const saveRenderedImageOutput = useMemo3(
+    () => isElectronHost3() && exportDestinationAdapter ? createImageSaveOutput(exportDestinationAdapter) : void 0,
+    [exportDestinationAdapter]
+  );
   const [selectedFolder, setSelectedFolder] = useState15(null);
   const [folderEntries, setFolderEntries] = useState15([]);
   const visibleFolderEntries = useMemo3(
@@ -5300,9 +5824,12 @@ function DocBlocksShell({
   const preparedCloseRequestRef = useRef15(null);
   const pendingDbkConflictsRef = useRef15(/* @__PURE__ */ new Map());
   const createDocumentTarget = useCallback15(
-    (fsProvider, workspaceId, filePath) => {
+    (fsProvider, workspaceId, filePath, outsideIn = null) => {
+      if (outsideIn) {
+        return createOutsideInDocumentTarget(fsProvider, outsideIn, gitScheduleRefresh);
+      }
       const transient = getTransientWorkspace(workspaceId);
-      const baseTarget = createFileSystemDocumentTarget(fsProvider, filePath);
+      const baseTarget = createFileSystemDocumentTarget2(fsProvider, filePath);
       const originKind = transient?.descriptor.origin?.kind;
       const needsElectronHost = originKind === "loose-file" || originKind === "dbk";
       if (!transient?.descriptor.origin || needsElectronHost && !isElectronHost3()) {
@@ -5506,52 +6033,58 @@ function DocBlocksShell({
       try {
         await touchWorkspace2(ws.id);
         if (requestId !== navigationRequestRef.current) return null;
-        let openedFile = null;
-        let openedContent = "";
+        let openedDocument = null;
         const transitioned = await documentSession.transitionWithLoad(async () => {
           if (requestId !== navigationRequestRef.current) return null;
           if (filePath) {
-            const content = await readProviderText(fsProvider, filePath);
+            const document2 = await loadEditableShellDocument(fsProvider, filePath);
             if (requestId !== navigationRequestRef.current) return null;
-            if (content !== null) {
-              openedFile = filePath;
-              openedContent = content;
-            }
+            if (document2 !== null) openedDocument = document2;
           }
           return {
-            target: openedFile ? createDocumentTarget(fsProvider, ws.id, openedFile) : null,
-            content: openedContent
+            target: openedDocument ? createDocumentTarget(
+              fsProvider,
+              ws.id,
+              openedDocument.sourcePath,
+              openedDocument.outsideIn
+            ) : null,
+            content: openedDocument?.content ?? ""
           };
         });
         if (!transitioned) return null;
+        const acceptedDocument = openedDocument;
         setProvider(fsProvider);
         adopted = true;
         setActiveWorkspaceId(ws.id);
-        if (openedFile) {
-          setSelectedFile(openedFile);
+        if (acceptedDocument) {
+          adoptSelectedDocument(acceptedDocument);
           setSelectedFolder(null);
           setFolderEntries([]);
           const effectiveView = view ?? "wysiwyg";
           setInitialView(effectiveView);
           setInitialSharedMode(sharedMode);
           if (!transient) {
-            saveLastState({ workspaceId: wsId, filePath: openedFile, view: effectiveView });
+            saveLastState({
+              workspaceId: wsId,
+              filePath: acceptedDocument.displayPath,
+              view: effectiveView
+            });
           }
         } else {
-          setSelectedFile(null);
+          adoptSelectedDocument(null);
           setSelectedFolder(null);
           setFolderEntries([]);
           setInitialSharedMode(null);
         }
         if (push) {
-          pushHash(ws.id, openedFile);
+          pushHash(ws.id, acceptedDocument?.displayPath ?? null);
         }
         return fsProvider;
       } finally {
-        if (!transient && !adopted) await getFileSystemProviderV25(fsProvider)?.dispose();
+        if (!transient && !adopted) await getFileSystemProviderV27(fsProvider)?.dispose();
       }
     },
-    [createDocumentTarget, documentSession, pushHash]
+    [adoptSelectedDocument, createDocumentTarget, documentSession, pushHash]
   );
   const adoptTransientWorkspace = useCallback15(
     async (options) => {
@@ -5594,7 +6127,7 @@ function DocBlocksShell({
         });
         mem.replaceContents(snapshot);
       } catch (error) {
-        await getFileSystemProviderV25(mem)?.dispose();
+        await getFileSystemProviderV27(mem)?.dispose();
         throw error;
       }
       return adoptTransientWorkspace({
@@ -5622,7 +6155,7 @@ function DocBlocksShell({
         if (content !== null && isCurrent()) {
           await documentSession.transitionTo(createDocumentTarget(fs, fs.id, aboutPath), content);
           if (!isCurrent()) return;
-          setSelectedFile(aboutPath);
+          adoptRegularDocument(aboutPath);
           setInitialView("preview");
           setInitialSharedMode(null);
           setExplorerKey((k) => k + 1);
@@ -5639,7 +6172,7 @@ function DocBlocksShell({
       try {
         await writeProviderText(fs, welcomePath, welcomeContent, "create");
       } catch (error) {
-        if (!(error instanceof FsError5 && error.code === "already-exists")) throw error;
+        if (!(error instanceof FsError6 && error.code === "already-exists")) throw error;
         const existing = await readProviderText(fs, welcomePath);
         if (existing === null) throw error;
         seededContent = existing;
@@ -5650,7 +6183,7 @@ function DocBlocksShell({
         seededContent
       );
       if (!isCurrent()) return;
-      setSelectedFile(welcomePath);
+      adoptRegularDocument(welcomePath);
       setInitialView("preview");
       setInitialSharedMode(null);
       setExplorerKey((k) => k + 1);
@@ -5658,7 +6191,7 @@ function DocBlocksShell({
       saveLastState({ workspaceId: fs.id, filePath: welcomePath, view: "preview" });
       if (!isWelcomeGatewayDismissed()) setShowWelcomeGateway(true);
     },
-    [createDocumentTarget, documentSession, pushHash]
+    [adoptRegularDocument, createDocumentTarget, documentSession, pushHash]
   );
   const startupOpenFromIdsRef = useRef15(openFromIds);
   startupOpenFromIdsRef.current = openFromIds;
@@ -5784,12 +6317,12 @@ function DocBlocksShell({
           const p = await createElectronProviderFromWorkspace(ws);
           if (!p) continue;
           if (!isCurrent()) {
-            await getFileSystemProviderV25(p)?.dispose();
+            await getFileSystemProviderV27(p)?.dispose();
             return;
           }
           await touchWorkspace2(ws.id);
           if (!isCurrent()) {
-            await getFileSystemProviderV25(p)?.dispose();
+            await getFileSystemProviderV27(p)?.dispose();
             return;
           }
           fsProvider = p;
@@ -5798,12 +6331,12 @@ function DocBlocksShell({
           const restored = await (await loadNativeFileSystem()).restoreNativeFolder(ws.id);
           if (restored) {
             if (!isCurrent()) {
-              await getFileSystemProviderV25(restored)?.dispose();
+              await getFileSystemProviderV27(restored)?.dispose();
               return;
             }
             await touchWorkspace2(ws.id);
             if (!isCurrent()) {
-              await getFileSystemProviderV25(restored)?.dispose();
+              await getFileSystemProviderV27(restored)?.dispose();
               return;
             }
             fsProvider = restored;
@@ -5812,12 +6345,12 @@ function DocBlocksShell({
         } else {
           const p = await createIndexedDbFileSystemProvider(ws.id, ws.name);
           if (!isCurrent()) {
-            await getFileSystemProviderV25(p)?.dispose();
+            await getFileSystemProviderV27(p)?.dispose();
             return;
           }
           await touchWorkspace2(ws.id);
           if (!isCurrent()) {
-            await getFileSystemProviderV25(p)?.dispose();
+            await getFileSystemProviderV27(p)?.dispose();
             return;
           }
           fsProvider = p;
@@ -5839,7 +6372,7 @@ function DocBlocksShell({
           if (!isCurrent()) return;
           const p = await createElectronFileSystemProvider(info.id, info.name, info.rootPath);
           if (!isCurrent()) {
-            await getFileSystemProviderV25(p)?.dispose();
+            await getFileSystemProviderV27(p)?.dispose();
             return;
           }
           fsProvider = p;
@@ -5848,7 +6381,7 @@ function DocBlocksShell({
           if (!isCurrent()) return;
           const p = await createIndexedDbFileSystemProvider(defaultWs.id, defaultWs.name);
           if (!isCurrent()) {
-            await getFileSystemProviderV25(p)?.dispose();
+            await getFileSystemProviderV27(p)?.dispose();
             return;
           }
           fsProvider = p;
@@ -5864,7 +6397,7 @@ function DocBlocksShell({
         setActiveWorkspaceId(fsProvider.id);
         adopted = true;
       } finally {
-        if (!adopted) await getFileSystemProviderV25(fsProvider)?.dispose();
+        if (!adopted) await getFileSystemProviderV27(fsProvider)?.dispose();
       }
     })().catch(() => {
       if (isCurrent()) {
@@ -6047,12 +6580,21 @@ function DocBlocksShell({
       setVersionsContainer(null);
       return;
     }
+    if (selectedOutsideIn) {
+      const container2 = createOutsideInContentContainer(provider, selectedOutsideIn);
+      const mp2 = createMediaProviderFromContainer(container2);
+      mediaContainerRef.current = container2;
+      versionsContainerRef.current = container2;
+      setMediaProvider(mp2);
+      setVersionsContainer(container2);
+      return () => mp2.dispose();
+    }
     const parentDir = dirnameOf(selectedFile);
     const base = basenameOf(selectedFile);
     const baseNoExt = base.replace(/\.[^.]+$/, "");
-    const container = new FileSystemContentContainer(provider, parentDir);
+    const container = new FileSystemContentContainer2(provider, parentDir);
     const vPrefix = parentDir ? `${parentDir}/${baseNoExt}_files` : `${baseNoExt}_files`;
-    const vContainer = new FileSystemContentContainer(provider, vPrefix);
+    const vContainer = new FileSystemContentContainer2(provider, vPrefix);
     const mp = createFileMediaProvider(container, base);
     mediaContainerRef.current = container;
     versionsContainerRef.current = vContainer;
@@ -6061,8 +6603,12 @@ function DocBlocksShell({
     return () => {
       mp.dispose();
     };
-  }, [provider, selectedFile, mediaEpoch]);
-  const documentLinkProvider = useDocumentLinkProvider(provider, selectedFile, documentLinkEpoch);
+  }, [provider, selectedFile, selectedOutsideIn, mediaEpoch]);
+  const documentLinkProvider = useDocumentLinkProvider(
+    provider,
+    selectedSourceFile ?? selectedFile,
+    documentLinkEpoch
+  );
   useEffect15(() => {
     const ref = versioningRef;
     if (!ref) return;
@@ -6083,10 +6629,10 @@ function DocBlocksShell({
   }, [versioningRef, effectiveVersioning, versionBasename, selectedFile, versionsContainer]);
   useEffect15(() => {
     if (!provider) return;
-    const providerV2 = getFileSystemProviderV25(provider);
+    const providerV2 = getFileSystemProviderV27(provider);
     if (!providerV2?.capabilities.watch) return;
-    if (!selectedFile || !documentSnapshot.targetKey) return;
-    const watchedFile = selectedFile;
+    const watchedFile = selectedSourceFile ?? selectedFile;
+    if (!watchedFile || !documentSnapshot.targetKey) return;
     const targetKey = documentSnapshot.targetKey;
     let disposed = false;
     let reading = false;
@@ -6140,7 +6686,7 @@ function DocBlocksShell({
       disposed = true;
       void subscription.dispose();
     };
-  }, [provider, selectedFile, documentSession, documentSnapshot.targetKey]);
+  }, [provider, selectedFile, selectedSourceFile, documentSession, documentSnapshot.targetKey]);
   const transitionAwayFromDocument = useCallback15(
     async (requestId) => {
       if (requestId !== navigationRequestRef.current) return false;
@@ -6173,7 +6719,7 @@ function DocBlocksShell({
       }
       const snapshot = await documentSession.resolveConflict("use-external");
       if (!snapshot.targetKey) {
-        setSelectedFile(null);
+        adoptSelectedDocument(null);
         if (activeWorkspaceId) pushHash(activeWorkspaceId, null);
       }
     } catch (error) {
@@ -6182,7 +6728,7 @@ function DocBlocksShell({
         message: error instanceof Error ? error.message : "Could not reload the external document."
       });
     }
-  }, [activeWorkspaceId, documentSession, pushHash]);
+  }, [activeWorkspaceId, adoptSelectedDocument, documentSession, pushHash]);
   const handleKeepLocalDocument = useCallback15(async () => {
     const conflictKey = documentSession.getSnapshot().conflict?.targetKey;
     try {
@@ -6274,12 +6820,12 @@ function DocBlocksShell({
       if (!await transitionAwayFromDocument(requestId)) return;
       setProvider(nextProvider);
       setActiveWorkspaceId(ws.id);
-      setSelectedFile(null);
+      adoptSelectedDocument(null);
       setSelectedFolder(null);
       setFolderEntries([]);
       pushHash(ws.id, null);
     },
-    [pushHash, transitionAwayFromDocument]
+    [adoptSelectedDocument, pushHash, transitionAwayFromDocument]
   );
   const unpinDocument = useCallback15((document2) => {
     const key = pinnedDocumentKey(document2);
@@ -6307,7 +6853,7 @@ function DocBlocksShell({
   const handleTogglePin = useCallback15(
     (path) => {
       if (!activeWorkspaceId || !provider) return;
-      const canonicalPath = parseWorkspacePath5(path);
+      const canonicalPath = parseWorkspacePath7(path);
       if (!canonicalPath) return;
       const document2 = {
         workspaceId: activeWorkspaceId,
@@ -6397,17 +6943,23 @@ function DocBlocksShell({
           return;
         }
         let disappearedDuringRead = false;
+        let openedDocument = null;
         const transitioned = await documentSession.transitionWithLoad(async () => {
           if (requestId !== navigationRequestRef.current) return null;
-          const content = await readProviderText(openedProvider, document2.path);
-          if (content === null) {
+          openedDocument = await loadEditableShellDocument(openedProvider, document2.path);
+          if (openedDocument === null) {
             disappearedDuringRead = true;
             return null;
           }
           if (requestId !== navigationRequestRef.current) return null;
           return {
-            target: createDocumentTarget(openedProvider, workspace.id, document2.path),
-            content
+            target: createDocumentTarget(
+              openedProvider,
+              workspace.id,
+              openedDocument.sourcePath,
+              openedDocument.outsideIn
+            ),
+            content: openedDocument.content
           };
         });
         if (!transitioned) {
@@ -6419,7 +6971,8 @@ function DocBlocksShell({
         setProvider(openedProvider);
         setActiveWorkspaceId(workspace.id);
         setActiveWorkspaceDescriptor(workspace);
-        setSelectedFile(document2.path);
+        if (!openedDocument) return;
+        adoptSelectedDocument(openedDocument);
         setSelectedFolder(null);
         setFolderEntries([]);
         setInitialView("wysiwyg");
@@ -6439,7 +6992,7 @@ function DocBlocksShell({
       } finally {
         if (nextProvider && ownsNextProvider && !adoptedNextProvider) {
           try {
-            await getFileSystemProviderV25(nextProvider)?.dispose();
+            await getFileSystemProviderV27(nextProvider)?.dispose();
           } catch {
           }
         }
@@ -6447,6 +7000,7 @@ function DocBlocksShell({
     },
     [
       activeWorkspaceId,
+      adoptSelectedDocument,
       closeWelcomeGateway,
       confirmMissingPinnedDocument,
       createDocumentTarget,
@@ -6513,7 +7067,7 @@ function DocBlocksShell({
         setProvider(openedDestination);
         setActiveWorkspaceId(destination.id);
         setActiveWorkspaceDescriptor(destination);
-        setSelectedFile(selectedFile);
+        adoptRegularDocument(selectedFile);
         setPinnedDocuments(
           (current) => movePinnedDocumentsToWorkspace(current, activeWorkspaceId, {
             workspaceId: destination.id,
@@ -6550,7 +7104,7 @@ function DocBlocksShell({
       } catch (error) {
         if (destinationProvider && !adoptedDestination) {
           try {
-            await getFileSystemProviderV25(destinationProvider)?.dispose();
+            await getFileSystemProviderV27(destinationProvider)?.dispose();
           } catch {
           }
         }
@@ -6559,6 +7113,7 @@ function DocBlocksShell({
     },
     [
       activeWorkspaceId,
+      adoptRegularDocument,
       closeWelcomeGateway,
       createDocumentTarget,
       documentSession,
@@ -6590,7 +7145,7 @@ function DocBlocksShell({
         if (!await transitionAwayFromDocument(requestId)) return;
         setProvider(provider2);
         setActiveWorkspaceId(descriptor2.id);
-        setSelectedFile(null);
+        adoptSelectedDocument(null);
         setSelectedFolder(null);
         setFolderEntries([]);
         pushHash(descriptor2.id, null);
@@ -6609,13 +7164,13 @@ function DocBlocksShell({
       if (!await transitionAwayFromDocument(requestId)) return;
       setProvider(nativeProvider);
       setActiveWorkspaceId(descriptor.id);
-      setSelectedFile(null);
+      adoptSelectedDocument(null);
       setSelectedFolder(null);
       setFolderEntries([]);
       pushHash(descriptor.id, null);
     } catch {
     }
-  }, [pushHash, transitionAwayFromDocument]);
+  }, [adoptSelectedDocument, pushHash, transitionAwayFromDocument]);
   const handleWorkspaceCloned = useCallback15(
     (info) => {
       const requestId = ++navigationRequestRef.current;
@@ -6637,13 +7192,13 @@ function DocBlocksShell({
         if (!await transitionAwayFromDocument(requestId)) return;
         setProvider(cloneProvider);
         setActiveWorkspaceId(descriptor.id);
-        setSelectedFile(null);
+        adoptSelectedDocument(null);
         setSelectedFolder(null);
         setFolderEntries([]);
         pushHash(descriptor.id, null);
       })();
     },
-    [pushHash, transitionAwayFromDocument]
+    [adoptSelectedDocument, pushHash, transitionAwayFromDocument]
   );
   const handleNewFile = useCallback15(async () => {
     if (!provider) return;
@@ -6661,12 +7216,12 @@ function DocBlocksShell({
     try {
       const transitioned = await documentSession.transitionWithLoad(async () => {
         if (requestId !== navigationRequestRef.current) return null;
-        const providerV2 = getFileSystemProviderV25(provider);
+        const providerV2 = getFileSystemProviderV27(provider);
         if (providerV2) {
           try {
             await writeProviderText(provider, path, content, "create");
           } catch (error) {
-            if (error instanceof FsError5 && error.code === "already-exists") {
+            if (error instanceof FsError6 && error.code === "already-exists") {
               throw new Error("A document with that name already exists.");
             }
             throw error;
@@ -6693,7 +7248,7 @@ function DocBlocksShell({
       showToast("error", error instanceof Error ? error.message : "Could not create the document.");
       return;
     }
-    setSelectedFile(path);
+    adoptRegularDocument(path);
     setInitialView("wysiwyg");
     setInitialSharedMode(null);
     setExplorerKey((k) => k + 1);
@@ -6703,6 +7258,7 @@ function DocBlocksShell({
     }
   }, [
     provider,
+    adoptRegularDocument,
     activeWorkspaceId,
     pushHash,
     closeWelcomeGateway,
@@ -6727,9 +7283,9 @@ function DocBlocksShell({
     }
     const path = `/${folderName}`;
     try {
-      const providerV2 = getFileSystemProviderV25(provider);
+      const providerV2 = getFileSystemProviderV27(provider);
       if (providerV2) {
-        await providerV2.createDirectory(parseWorkspacePath5(path), { mode: "create" });
+        await providerV2.createDirectory(parseWorkspacePath7(path), { mode: "create" });
       } else {
         if (await providerEntryExists(provider, path)) {
           throw new Error("A file or folder with that name already exists.");
@@ -6737,11 +7293,11 @@ function DocBlocksShell({
         await provider.createDirectory(path);
       }
     } catch (error) {
-      const message = error instanceof FsError5 && error.code === "already-exists" ? "A file or folder with that name already exists." : error instanceof Error ? error.message : "Could not create the folder.";
+      const message = error instanceof FsError6 && error.code === "already-exists" ? "A file or folder with that name already exists." : error instanceof Error ? error.message : "Could not create the folder.";
       showToast("error", message);
       return;
     }
-    setSelectedFile(null);
+    adoptSelectedDocument(null);
     setSelectedFolder(path);
     setFolderEntries([]);
     setExplorerKey((key) => key + 1);
@@ -6750,6 +7306,7 @@ function DocBlocksShell({
     if (effectiveCompact) setMobileShowEditor(true);
   }, [
     provider,
+    adoptSelectedDocument,
     promptForText,
     showToast,
     closeWelcomeGateway,
@@ -6780,6 +7337,15 @@ function DocBlocksShell({
       await getDocBlocksHost().shell.revealInFolder(ws.id);
     }
   }, [activeWorkspaceId]);
+  const handleOpenWorkspaceFolder = useCallback15(() => {
+    if (!isElectronHost3() || !nativeWorkspaceId) return;
+    void getDocBlocksHost().shell.openWorkspaceFolder(nativeWorkspaceId).catch((error) => {
+      showToast(
+        "error",
+        error instanceof Error ? error.message : "Could not open this workspace folder."
+      );
+    });
+  }, [nativeWorkspaceId, showToast]);
   useEffect15(() => {
     if (!isElectronHost3()) return;
     const host = getDocBlocksHost();
@@ -6851,22 +7417,27 @@ function DocBlocksShell({
       if (kind === "directory") {
         if (!await transitionAwayFromDocument(requestId)) return;
         if (requestId !== navigationRequestRef.current) return;
-        setSelectedFile(null);
+        adoptSelectedDocument(null);
         setSelectedFolder(path);
         const entries = await readProviderDirectory2(provider, path);
         if (requestId !== navigationRequestRef.current) return;
         setFolderEntries(entries);
         pushHash(activeWorkspaceId, null);
       } else {
-        let content = null;
+        let openedDocument = null;
         try {
           const transitioned = await documentSession.transitionWithLoad(async () => {
             if (requestId !== navigationRequestRef.current) return null;
-            content = await readProviderText(provider, path);
-            if (requestId !== navigationRequestRef.current || content === null) return null;
+            openedDocument = await loadEditableShellDocument(provider, path);
+            if (requestId !== navigationRequestRef.current || openedDocument === null) return null;
             return {
-              target: createDocumentTarget(provider, activeWorkspaceId, path),
-              content
+              target: createDocumentTarget(
+                provider,
+                activeWorkspaceId,
+                openedDocument.sourcePath,
+                openedDocument.outsideIn
+              ),
+              content: openedDocument.content
             };
           });
           if (!transitioned) return;
@@ -6878,7 +7449,8 @@ function DocBlocksShell({
           return;
         }
         if (requestId !== navigationRequestRef.current) return;
-        setSelectedFile(path);
+        if (!openedDocument) return;
+        adoptSelectedDocument(openedDocument);
         setSelectedFolder(null);
         setFolderEntries([]);
         setInitialView("wysiwyg");
@@ -6895,15 +7467,91 @@ function DocBlocksShell({
       pushHash,
       effectiveCompact,
       closeWelcomeGateway,
+      adoptSelectedDocument,
       createDocumentTarget,
       documentSession,
       transitionAwayFromDocument,
       showToast
     ]
   );
+  const handleEnableOutsideInEditing = useCallback15(
+    async (path) => {
+      if (!provider || !activeWorkspaceId) {
+        throw new Error("Open the workspace before enabling Markdown editing.");
+      }
+      const requestId = ++navigationRequestRef.current;
+      const editableRef = { current: null };
+      const transitioned = await documentSession.transitionWithLoad(async () => {
+        if (requestId !== navigationRequestRef.current) return null;
+        const opened = await loadEditableShellDocument(provider, path);
+        if (!opened?.outsideIn) {
+          throw new Error("This file does not support outside-in Markdown editing.");
+        }
+        const editable2 = await enableOutsideInMarkdownEditing(provider, opened);
+        editableRef.current = editable2;
+        return {
+          target: createDocumentTarget(
+            provider,
+            activeWorkspaceId,
+            editable2.sourcePath,
+            editable2.outsideIn
+          ),
+          content: editable2.content
+        };
+      });
+      const editable = editableRef.current;
+      if (!transitioned || !editable || requestId !== navigationRequestRef.current) return;
+      adoptSelectedDocument(editable);
+      setSelectedFolder(null);
+      setFolderEntries([]);
+      setInitialView("wysiwyg");
+      setInitialSharedMode(null);
+      closeWelcomeGateway();
+      pushHash(activeWorkspaceId, path);
+      saveLastState({ workspaceId: activeWorkspaceId, filePath: path, view: "wysiwyg" });
+      if (effectiveCompact) setMobileShowEditor(true);
+      showToast(
+        "success",
+        `Markdown editing enabled. The original is backed up at ${editable.outsideIn.backupPath}.`
+      );
+    },
+    [
+      activeWorkspaceId,
+      adoptSelectedDocument,
+      closeWelcomeGateway,
+      createDocumentTarget,
+      documentSession,
+      effectiveCompact,
+      provider,
+      pushHash,
+      showToast
+    ]
+  );
+  const outsideInActionsForEntry = useCallback15(
+    (entry) => {
+      if (entry.kind !== "file" || resolveOutsideInLayout(entry.path) === null) return [];
+      if (selectedOutsideInEditingEnabled && selectedFile !== null && sameProviderPath(selectedFile, entry.path)) {
+        return [];
+      }
+      return [
+        {
+          label: "Allow editing via markdown",
+          onSelect: () => handleEnableOutsideInEditing(entry.path)
+        }
+      ];
+    },
+    [handleEnableOutsideInEditing, selectedFile, selectedOutsideInEditingEnabled]
+  );
+  const actionsForEntry = useCallback15(
+    (entry) => {
+      const nativeActions = isElectronHost3() ? createNativeFileActions(entry, nativeWorkspaceId, getDocBlocksHost()) : [];
+      return [...nativeActions, ...outsideInActionsForEntry(entry)];
+    },
+    [nativeWorkspaceId, outsideInActionsForEntry]
+  );
   const handleEditorLinkClick = useCallback15(
     (href) => {
-      const target = resolveShellEditorLinkTarget(href, selectedFile);
+      const target = resolveShellEditorLinkTarget(href, selectedSourceFile ?? selectedFile);
       if (!target) {
         showToast(
           "error",
@@ -6949,31 +7597,93 @@ function DocBlocksShell({
       })();
       return true;
     },
-    [handleSelect, provider, selectedFile, showToast]
+    [handleSelect, provider, selectedFile, selectedSourceFile, showToast]
   );
   const handleTreeMutation = useCallback15(
     async (change, mutate) => {
-      if (!provider || !activeWorkspaceId || !selectedFile) {
+      if (!provider) {
         await mutate();
         return;
       }
+      let mutateDocument = mutate;
+      if (change.kind === "file") {
+        const oldLayout = resolveOutsideInLayout(
+          change.type === "move" ? change.oldPath : change.path
+        );
+        if (oldLayout && change.type === "move") {
+          const nextLayout = resolveOutsideInLayout(change.newPath);
+          if (!nextLayout || nextLayout.format !== oldLayout.format) {
+            throw new Error(
+              `Keep the .${oldLayout.format} extension when renaming this outside-in document.`
+            );
+          }
+        }
+        if (oldLayout && change.type === "delete") {
+          mutateDocument = async () => {
+            await mutate();
+            try {
+              await removeOutsideInCompanion(provider, oldLayout);
+            } catch (error) {
+              showToast(
+                "error",
+                error instanceof Error ? `The rendered file was deleted, but its companion could not be removed: ${error.message}` : "The rendered file was deleted, but its companion could not be removed."
+              );
+            }
+          };
+        }
+      }
+      if (!activeWorkspaceId || !selectedFile) {
+        await mutateDocument();
+        return;
+      }
       if (change.type === "move") {
         const nextFile = relocateProviderPath(selectedFile, change.oldPath, change.newPath);
         if (nextFile !== selectedFile) {
-          await documentSession.retarget(
-            createDocumentTarget(provider, activeWorkspaceId, nextFile),
-            mutate
+          const nextSource = relocateProviderPath(
+            selectedSourceFile ?? selectedFile,
+            change.oldPath,
+            change.newPath
           );
+          let nextOutsideIn = null;
+          if (selectedOutsideIn) {
+            const resolved = resolveOutsideInLayout(nextFile);
+            if (!resolved)
+              throw new Error("The outside-in target must keep a supported extension.");
+            nextOutsideIn = { ...resolved, markdownPath: nextSource };
+          }
+          const snapshot = await documentSession.retarget(
+            createDocumentTarget(provider, activeWorkspaceId, nextSource, nextOutsideIn),
+            mutateDocument
+          );
+          if (nextOutsideIn) {
+            const linkedContent = await withOutsideInMetadata(snapshot.content, nextOutsideIn);
+            if (linkedContent !== snapshot.content && snapshot.targetKey) {
+              documentSession.edit(linkedContent, {
+                targetKey: snapshot.targetKey,
+                generation: snapshot.generation
+              });
+              await documentSession.flush("transition");
+            }
+          }
           return;
         }
       }
       if (change.type === "delete" && pathContains(change.path, selectedFile)) {
-        await documentSession.delete(mutate);
+        await documentSession.delete(mutateDocument);
         return;
       }
-      await mutate();
+      await mutateDocument();
     },
-    [provider, activeWorkspaceId, selectedFile, documentSession, createDocumentTarget]
+    [
+      provider,
+      activeWorkspaceId,
+      selectedFile,
+      selectedSourceFile,
+      selectedOutsideIn,
+      documentSession,
+      createDocumentTarget,
+      showToast
+    ]
   );
   const handleTreeChange = useCallback15(
     async (change) => {
@@ -6988,7 +7698,12 @@ 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) {
-          setSelectedFile(nextFile);
+          if (nextFile && selectedOutsideIn) {
+            const opened = await loadEditableShellDocument(provider, nextFile);
+            adoptSelectedDocument(opened);
+          } else {
+            adoptRegularDocument(nextFile);
+          }
           if (activeWorkspaceId) {
             pushHash(activeWorkspaceId, nextFile);
             if (nextFile) {
@@ -7014,7 +7729,7 @@ function DocBlocksShell({
       if (selectedFile) {
         const exists = await providerEntryExists(provider, selectedFile);
         if (!exists) {
-          setSelectedFile(null);
+          adoptSelectedDocument(null);
           if (activeWorkspaceId) pushHash(activeWorkspaceId, null);
         }
       }
@@ -7025,7 +7740,10 @@ function DocBlocksShell({
     },
     [
       provider,
+      adoptRegularDocument,
+      adoptSelectedDocument,
       selectedFile,
+      selectedOutsideIn,
       selectedFolder,
       activeWorkspaceId,
       pinnedDocuments,
@@ -7097,7 +7815,7 @@ function DocBlocksShell({
       const parent = dirnameOf(document2.path);
       let newPath;
       try {
-        newPath = parseWorkspacePath5(parent ? `${parent}/${newName}` : newName);
+        newPath = parseWorkspacePath7(parent ? `${parent}/${newName}` : newName);
       } catch {
         showToast("error", "Use a valid document name.");
         return;
@@ -7139,7 +7857,7 @@ function DocBlocksShell({
       } finally {
         if (access.owned) {
           try {
-            await getFileSystemProviderV25(access.provider)?.dispose();
+            await getFileSystemProviderV27(access.provider)?.dispose();
           } catch {
           }
         }
@@ -7208,7 +7926,7 @@ function DocBlocksShell({
       } finally {
         if (access.owned) {
           try {
-            await getFileSystemProviderV25(access.provider)?.dispose();
+            await getFileSystemProviderV27(access.provider)?.dispose();
           } catch {
           }
         }
@@ -7226,42 +7944,15 @@ function DocBlocksShell({
       showToast
     ]
   );
-  const persistImportedMedia = useCallback15(
-    async (source, target, importedMarkdownPath) => {
-      const parentDir = dirnameOf(importedMarkdownPath);
-      const folder = basenameOf(importedMarkdownPath).replace(/\.[^.]+$/, "") + "_files";
-      const mediaRoot = parentDir ? `${parentDir}/${folder}` : folder;
-      const entries = await source.listFiles();
-      const targetV2 = getFileSystemProviderV25(target);
-      for (const entry of entries) {
-        if (entry.path.endsWith(".md")) continue;
-        const data = await source.readFile(entry.path);
-        if (!data) continue;
-        const cleanPath = entry.path.replace(/^\/+/, "");
-        const destination = `${mediaRoot}/${cleanPath}`;
-        if (targetV2) {
-          await targetV2.writeFile(parseWorkspacePath5(destination), data, {
-            mode: "upsert",
-            createParents: true
-          });
-        } else {
-          await target.writeBinary(destination, data);
-        }
-      }
-    },
-    []
-  );
   const handleImportFiles = useCallback15(
     async (files) => {
       if (!provider) return;
-      const result = await importDroppedFiles(files, provider, {
-        persistMedia: (source, path) => persistImportedMedia(source, provider, path)
-      });
+      const result = await importDroppedFiles(files, provider);
       setExplorerKey((k) => k + 1);
       const summary = summariseImport(result);
       if (summary) showToast(summary.kind, summary.message);
     },
-    [provider, persistImportedMedia, showToast]
+    [provider, showToast]
   );
   const handleEditorChange = useCallback15(
     (source) => {
@@ -7308,7 +7999,7 @@ function DocBlocksShell({
         throw error;
       }
       if (!isCurrent()) {
-        await getFileSystemProviderV25(mem)?.dispose();
+        await getFileSystemProviderV27(mem)?.dispose();
         await revokeAbandonedResource();
         return;
       }
@@ -7356,7 +8047,7 @@ function DocBlocksShell({
       } finally {
         try {
           if (!adoptionStarted) {
-            await getFileSystemProviderV25(mem)?.dispose();
+            await getFileSystemProviderV27(mem)?.dispose();
           }
         } finally {
           if (!opened) await revokeAbandonedResource();
@@ -7426,7 +8117,7 @@ function DocBlocksShell({
           push: true
         });
       } finally {
-        if (!adoptionStarted) await getFileSystemProviderV25(mem)?.dispose();
+        if (!adoptionStarted) await getFileSystemProviderV27(mem)?.dispose();
       }
     },
     [adoptTransientWorkspace]
@@ -7523,7 +8214,7 @@ function DocBlocksShell({
         try {
           await copyProviderToContainer(p, container, folder);
         } finally {
-          if (ownsProvider) await getFileSystemProviderV25(p)?.dispose();
+          if (ownsProvider) await getFileSystemProviderV27(p)?.dispose();
         }
       }
       if (usedFolders.size === 0) {
@@ -7657,7 +8348,7 @@ function DocBlocksShell({
       const p = await createElectronFileSystemProvider(info.id, info.name, info.rootPath);
       setProvider(p);
       setActiveWorkspaceId(info.id);
-      setSelectedFile(null);
+      adoptSelectedDocument(null);
       setSelectedFolder(null);
       setFolderEntries([]);
     } else {
@@ -7665,12 +8356,13 @@ function DocBlocksShell({
       const fsProvider = await createIndexedDbFileSystemProvider(defaultWs.id, defaultWs.name);
       setProvider(fsProvider);
       setActiveWorkspaceId(defaultWs.id);
-      setSelectedFile(null);
+      adoptSelectedDocument(null);
       setSelectedFolder(null);
       setFolderEntries([]);
     }
   }, [
     activeWorkspaceId,
+    adoptSelectedDocument,
     confirmAction,
     handleWorkspaceSelect,
     pinnedDocuments,
@@ -7807,6 +8499,8 @@ function DocBlocksShell({
                     onPinnedDocumentDelete: handlePinnedDocumentDelete,
                     onTogglePin: handleTogglePin,
                     onSelect: handleSelect,
+                    onOpenWorkspaceFolder: isElectronHost3() && nativeWorkspaceId ? handleOpenWorkspaceFolder : void 0,
+                    actionsForEntry,
                     onTreeMutation: handleTreeMutation,
                     onTreeChange: handleTreeChange,
                     onImportFiles: handleImportFiles,
@@ -7905,10 +8599,13 @@ function DocBlocksShell({
                         EditorShell,
                         {
                           initialMarkdown: editorContent,
+                          readOnly: selectedOutsideIn !== null && !selectedOutsideInEditingEnabled,
                           initialView,
                           defaultViewportPreset: defaultPreviewViewportPreset,
                           articleId: selectedFile,
                           fileName: selectedFile,
+                          saveCoverImageOutput: saveRenderedImageOutput,
+                          saveDashboardImageOutput: saveRenderedImageOutput,
                           onChange: handleEditorChange,
                           onLinkClick: handleEditorLinkClick,
                           colorScheme: resolvedTheme,
@@ -8079,6 +8776,9 @@ export {
   WorkspacePicker,
   WriteCanvasSettingsControls,
   buildExportFilename,
+  createImageSaveOutput as createCoverImageSaveOutput,
+  createImageSaveOutput as createDashboardImageSaveOutput,
+  createImageSaveOutput,
   loadLastExportOptions,
   resolveWriteCanvasFonts,
   runExport,