canopycms 0.6.0 → 0.7.0

package/dist/cli/generate-ai-content.js

@@ -780,7 +780,7 @@ var init_collection = __esm({
 
 // dist/config/schemas/url.js
 import { z as z4 } from "zod";
-var uploadTargetUrlSchema, previewPrefixSchema;
+var uploadTargetUrlSchema, previewPrefixSchema, editorUrlSchema;
 var init_url = __esm({
   "dist/config/schemas/url.js"() {
     "use strict";
@@ -791,6 +791,14 @@ var init_url = __esm({
     previewPrefixSchema = z4.string().trim().refine((value) => isHttpUrlOrSameOriginPath(value), {
       message: 'editor.previewPrefix must be an absolute http(s) URL or a site-relative path beginning with a single "/", with no query or fragment'
     });
+    editorUrlSchema = z4.string().trim().refine((value) => {
+      if (!isHttpUrlOrSameOriginPath(value) || !/^https?:\/\//i.test(value))
+        return false;
+      const url = new URL(value);
+      return !url.username && !url.password;
+    }, {
+      message: "editorUrl must be an absolute http(s) URL with no credentials, query or fragment"
+    });
   }
 });
 
@@ -941,6 +949,7 @@ var init_config = __esm({
       contentRoot: contentRootSchema.default("content"),
       sourceRoot: sourceRootSchema.optional(),
       basePath: basePathSchema,
+      editorUrl: editorUrlSchema.optional(),
       unauthenticatedStatus: z6.union([z6.literal(401), z6.literal(419)]).optional(),
       danglingReferences: z6.enum(["error", "warn"]).optional(),
       editor: editorConfigSchema.optional(),
@@ -1533,6 +1542,428 @@ import { gfm } from "micromark-extension-gfm";
 import { mdxjs } from "micromark-extension-mdxjs";
 init_error();
 
+// dist/utils/markdown-export-options.js
+var MARKDOWN_EXPORT_OPTIONS = {
+  listItemIndent: "one",
+  bullet: "-",
+  emphasis: "_",
+  strong: "*",
+  rule: "-"
+};
+
+// dist/utils/markdown-restyle.js
+var BULLETS = [MARKDOWN_EXPORT_OPTIONS.bullet, "*"];
+var DELIMITERS = [".", ")"];
+var EMPHASIS = MARKDOWN_EXPORT_OPTIONS.emphasis;
+var STRONG = MARKDOWN_EXPORT_OPTIONS.strong.repeat(2);
+var RULE = MARKDOWN_EXPORT_OPTIONS.rule.repeat(3);
+var WORD_CHAR = /[^\s\p{P}\p{S}]/u;
+var GAP = /^[ \t>]*(?:\r?\n[ \t>]*)+$/;
+function startOf(node) {
+  return node?.position?.start.offset;
+}
+function endOf(node) {
+  return node?.position?.end.offset;
+}
+function apply(source, edits, from = 0, to = source.length) {
+  let out = "";
+  let at = from;
+  for (const edit of [...edits].sort((a, b) => a.start - b.start)) {
+    if (edit.start < at || edit.end > to)
+      continue;
+    out += source.slice(at, edit.start) + edit.text;
+    at = edit.end;
+  }
+  return out + source.slice(at, to);
+}
+function underscoreStarts(node) {
+  const bare = startOf(node) === startOf(node.children?.[0]);
+  if (node.type === "link" && !bare || node.type === "linkReference")
+    return [];
+  if (node.type === "text" || node.type === "mdxTextExpression") {
+    const start = startOf(node);
+    return start !== void 0 && (node.value ?? "").includes("_") ? [start] : [];
+  }
+  return (node.children ?? []).flatMap(underscoreStarts);
+}
+function orderedNumber(numbers, index) {
+  const [first = 1, second, third] = numbers;
+  if (index === 0)
+    return first;
+  const ones = numbers.length > 1 && second === 1 && (first !== 0 || numbers.length < 3 || third === 1);
+  return ones ? 1 : first + index;
+}
+var Restyler = class {
+  constructor(source) {
+    this.source = source;
+    this.listMarker = /* @__PURE__ */ new Map();
+    this.underscores = /* @__PURE__ */ new Map();
+  }
+  /** Edits for `node` and everything under it, given its ancestors (nearest last). */
+  collect(node, ancestors, out) {
+    const inside = [...ancestors, node];
+    switch (node.type) {
+      case "emphasis":
+        this.emphasis(node, ancestors, out);
+        break;
+      case "strong":
+        this.strong(node, out);
+        break;
+      case "text":
+        this.text(node, ancestors, out);
+        return;
+      case "thematicBreak":
+        this.replaceWhole(node, this.ruleIn(ancestors), out);
+        return;
+      case "code":
+        this.fence(node, out);
+        return;
+      case "heading":
+        this.heading(node, inside, out);
+        return;
+      case "table":
+        this.table(node, inside, out);
+        return;
+      default:
+        break;
+    }
+    this.children(node, inside, out);
+  }
+  /**
+   * Edits for `parent`'s children and the gaps between them. `fixed` names children whose text
+   * must stay as it is (untouched top-level blocks); their lists still count for alternation.
+   */
+  children(parent, inside, out, fixed = () => false, outFor = () => out) {
+    const children = parent.children ?? [];
+    const markers = this.listMarkers(children, fixed);
+    children.forEach((child, index) => {
+      if (fixed(index))
+        return;
+      const edits = outFor(index);
+      const marker = markers.get(child);
+      if (marker !== void 0)
+        this.list(child, marker, edits);
+      this.collect(child, inside, edits);
+    });
+    const always = parent.type === "root" || parent.type === "blockquote";
+    const spaced = always || parent.type === "list" || parent.type === "listItem";
+    if (!spaced)
+      return;
+    for (let index = 1; index < children.length; index++) {
+      if (fixed(index) && fixed(index - 1))
+        continue;
+      this.gap(children[index - 1], children[index], always, outFor(fixed(index) ? index - 1 : index));
+    }
+  }
+  /** The marker each list among `children` takes: its own, then alternating with the one before. */
+  listMarkers(children, fixed) {
+    const markers = /* @__PURE__ */ new Map();
+    let previous;
+    children.forEach((child, index) => {
+      if (child.type !== "list") {
+        previous = void 0;
+        return;
+      }
+      const ordered = Boolean(child.ordered);
+      const current = this.markerOf(child);
+      if (current === void 0) {
+        previous = void 0;
+        return;
+      }
+      let marker = current;
+      if (!fixed(index)) {
+        const choices = ordered ? DELIMITERS : BULLETS;
+        const next = children[index + 1];
+        const nextFixed = next?.type === "list" && Boolean(next.ordered) === ordered && fixed(index + 1) ? this.markerOf(next) : void 0;
+        const before = previous?.ordered === ordered ? previous.marker : void 0;
+        marker = choices.find((choice) => choice !== before && choice !== nextFixed) ?? current;
+        markers.set(child, marker);
+      }
+      this.listMarker.set(child, marker);
+      previous = { ordered, marker };
+    });
+    return markers;
+  }
+  /**
+   * A rule's text: `---`, but inside a list Prettier writes `***`, or `---` when the list takes
+   * the alternate marker.
+   */
+  ruleIn(ancestors) {
+    const list = [...ancestors].reverse().find((a) => a.type === "list");
+    if (list === void 0)
+      return RULE;
+    const marker = this.listMarker.get(list);
+    return marker === BULLETS[0] || marker === DELIMITERS[0] ? "***" : RULE;
+  }
+  /** A list's bullet, or its ordered delimiter, read from its first item. */
+  markerOf(list) {
+    const at = startOf(list.children?.[0]);
+    if (at === void 0)
+      return void 0;
+    if (!list.ordered)
+      return this.source[at];
+    return /^\d{1,9}([.)])/.exec(this.source.slice(at, at + 10))?.[1];
+  }
+  /** Item markers: the list's bullet or delimiter, and Prettier's numbering where widths allow. */
+  list(list, marker, out) {
+    const items = list.children ?? [];
+    const starts = items.map(startOf);
+    if (!list.ordered) {
+      for (const at of starts) {
+        if (at !== void 0 && this.source[at] !== marker) {
+          out.push({ start: at, end: at + 1, text: marker });
+        }
+      }
+      return;
+    }
+    const numbers = starts.map((at) => at === void 0 ? null : /^(\d{1,9})[.)]/.exec(this.source.slice(at, at + 11)));
+    const typed = numbers.map((match) => Number(match?.[1]));
+    const renumber = numbers.every((match, i) => match !== null && String(orderedNumber(typed, i)).length === match[1]?.length);
+    numbers.forEach((match, i) => {
+      const at = starts[i];
+      if (match === null || at === void 0)
+        return;
+      const digits = match[1] ?? "";
+      const wanted = renumber ? String(orderedNumber(typed, i)) : digits;
+      if (wanted !== digits || match[0].slice(-1) !== marker) {
+        out.push({ start: at, end: at + match[0].length, text: wanted + marker });
+      }
+    });
+  }
+  /**
+   * The gap between two siblings with exactly one blank line, kept in the container's own
+   * prefix and line ending; where `always` is false, only a gap that had a blank line.
+   */
+  gap(a, b, always, out) {
+    const end = this.contentEnd(a);
+    const start = startOf(b);
+    if (end === void 0 || start === void 0)
+      return;
+    const gap = this.source.slice(end, start);
+    if (!GAP.test(gap))
+      return;
+    const lines = gap.split(/\r?\n/);
+    if (!always && lines.length < 3)
+      return;
+    const eol = gap.includes("\r\n") ? "\r\n" : "\n";
+    const prefix = lines[lines.length - 1] ?? "";
+    const together = a?.type === "definition" && b?.type === "definition";
+    const text = together ? eol + prefix : eol + prefix.trimEnd() + eol + prefix;
+    if (text !== gap)
+      out.push({ start: end, end: start, text });
+  }
+  /**
+   * Where `node`'s last line of content ends: a list's position runs on over the blank lines
+   * after it, which in a block quote are lines of `>`.
+   */
+  contentEnd(node) {
+    const start = startOf(node);
+    let end = endOf(node);
+    if (start === void 0 || end === void 0)
+      return end;
+    for (; ; ) {
+      const lineStart = this.source.lastIndexOf("\n", end - 1);
+      if (lineStart <= start || !/^[ \t>]*$/.test(this.source.slice(lineStart + 1, end)))
+        break;
+      end = this.source[lineStart - 1] === "\r" ? lineStart - 1 : lineStart;
+    }
+    return end;
+  }
+  emphasis(node, ancestors, out) {
+    const start = startOf(node);
+    const end = endOf(node);
+    if (start === void 0 || end === void 0)
+      return;
+    const open = this.source[start];
+    if (open !== this.source[end - 1] || open !== "*" && open !== "_")
+      return;
+    const marker = ancestors.some((a) => a.type === "emphasis") || this.besideWord(start, end) || this.afterUnderscore(start, ancestors) ? "*" : EMPHASIS;
+    if (open === marker)
+      return;
+    out.push({ start, end: start + 1, text: marker }, { start: end - 1, end, text: marker });
+  }
+  strong(node, out) {
+    const start = startOf(node);
+    const end = endOf(node);
+    if (start === void 0 || end === void 0)
+      return;
+    if (this.source.slice(start, start + 2) !== "__" || this.source.slice(end - 2, end) !== "__") {
+      return;
+    }
+    out.push({ start, end: start + 2, text: STRONG }, { start: end - 2, end, text: STRONG });
+  }
+  /** Whether the characters past the markers around `[start, end)` include a word character. */
+  besideWord(start, end) {
+    const markers = "*_";
+    let before = start - 1;
+    while (before >= 0 && markers.includes(this.source[before] ?? ""))
+      before--;
+    let after = end;
+    while (after < this.source.length && markers.includes(this.source[after] ?? ""))
+      after++;
+    return WORD_CHAR.test(this.source[before] ?? " ") || WORD_CHAR.test(this.source[after] ?? " ");
+  }
+  afterUnderscore(start, ancestors) {
+    const block = [...ancestors].reverse().find((a) => a.type === "paragraph" || a.type === "heading" || a.type === "tableCell");
+    if (block === void 0)
+      return false;
+    let starts = this.underscores.get(block);
+    if (starts === void 0) {
+      starts = underscoreStarts(block);
+      this.underscores.set(block, starts);
+    }
+    const link = [...ancestors].reverse().find((a) => a.type === "link" || a.type === "linkReference");
+    const inLink = (link?.children ?? []).flatMap(underscoreStarts);
+    return [...starts, ...inLink].some((at) => at < start);
+  }
+  text(node, ancestors, out) {
+    const start = startOf(node);
+    const end = endOf(node);
+    if (start === void 0 || end === void 0)
+      return;
+    const raw = this.source.slice(start, end);
+    for (const match of raw.matchAll(/[ \t]+(?=\r?\n)/g)) {
+      out.push({ start: start + match.index, end: start + match.index + match[0].length, text: "" });
+    }
+    if (ancestors.some((a) => a.type === "link" || a.type === "linkReference"))
+      return;
+    const block = [...ancestors].reverse().find((a) => a.type === "paragraph" || a.type === "heading" || a.type === "tableCell");
+    const blockStart = startOf(block);
+    const blockEnd = endOf(block);
+    if (blockStart === void 0 || blockEnd === void 0)
+      return;
+    if (/\$|\[\[/.test(this.source.slice(blockStart, blockEnd)))
+      return;
+    for (const match of raw.matchAll(/(?<=[\p{L}\p{N}])\\_(?=[\p{L}\p{N}])/gu)) {
+      out.push({ start: start + match.index, end: start + match.index + 1, text: "" });
+    }
+  }
+  replaceWhole(node, text, out) {
+    const start = startOf(node);
+    const end = endOf(node);
+    if (start === void 0 || end === void 0)
+      return;
+    if (this.source.slice(start, end) !== text)
+      out.push({ start, end, text });
+  }
+  /** A `~~~` fence as backticks, when nothing inside it would end a backtick fence. */
+  fence(node, out) {
+    const start = startOf(node);
+    const end = endOf(node);
+    if (start === void 0 || end === void 0)
+      return;
+    const raw = this.source.slice(start, end);
+    const close = /(?:\r?\n)[ \t>]*(~{3,})[ \t]*$/.exec(raw);
+    if (!/^~~~(?!~)[^`\n]*\n/.test(raw) || close?.[1] === void 0 || raw.includes("`"))
+      return;
+    const closeAt = start + close.index + close[0].indexOf("~");
+    out.push({ start, end: start + 3, text: "```" }, { start: closeAt, end: closeAt + close[1].length, text: "```" });
+  }
+  /** A one-line heading as `# x`, its content with its own edits. */
+  heading(node, inside, out) {
+    const inner = [];
+    this.children(node, inside, inner);
+    const children = node.children ?? [];
+    const start = startOf(node);
+    const end = endOf(node);
+    const contentStart = startOf(children[0]);
+    const contentEnd = endOf(children[children.length - 1]);
+    if (start === void 0 || end === void 0 || contentStart === void 0 || contentEnd === void 0 || /[\r\n]/.test(this.source.slice(contentStart, contentEnd))) {
+      out.push(...inner);
+      return;
+    }
+    const content = apply(this.source, inner, contentStart, contentEnd);
+    const text = `${"#".repeat(node.depth ?? 1)} ${content}`;
+    if (text !== this.source.slice(start, end))
+      out.push({ start, end, text });
+    else
+      out.push(...inner);
+  }
+  /** A table padded to its columns, as Prettier pads it; its cells keep their own text. */
+  table(node, inside, out) {
+    const start = startOf(node);
+    const end = endOf(node);
+    if (start === void 0 || end === void 0)
+      return;
+    const prefix = this.source.slice(this.source.lastIndexOf("\n", start - 1) + 1, start);
+    const inner = [];
+    const rows = (node.children ?? []).map((row) => (row.children ?? []).map((cell) => {
+      const edits = [];
+      this.children(cell, [...inside, row, cell], edits);
+      inner.push(...edits);
+      const content = cell.children ?? [];
+      const from = startOf(content[0]);
+      const to = endOf(content[content.length - 1]);
+      return from === void 0 || to === void 0 ? "" : apply(this.source, edits, from, to);
+    }));
+    const plain = rows.every((row) => row.every((cell) => /^[\x20-\x7e]*$/.test(cell)));
+    if (!plain || !/^[ \t>]*$/.test(prefix)) {
+      out.push(...inner);
+      return;
+    }
+    const align = node.align ?? [];
+    const columns = Math.max(...rows.map((row) => row.length), align.length);
+    const widths = Array.from({ length: columns }, (_, c) => Math.max(3, ...rows.map((row) => row[c]?.length ?? 0)));
+    const pad = (text2, c) => {
+      const room = (widths[c] ?? 3) - text2.length;
+      if (align[c] === "right")
+        return " ".repeat(room) + text2;
+      if (align[c] === "center") {
+        const left = Math.floor(room / 2);
+        return " ".repeat(left) + text2 + " ".repeat(room - left);
+      }
+      return text2 + " ".repeat(room);
+    };
+    const delimiter = widths.map((width, c) => {
+      const a = align[c];
+      if (a === "left")
+        return `:${"-".repeat(width - 1)}`;
+      if (a === "right")
+        return `${"-".repeat(width - 1)}:`;
+      if (a === "center")
+        return `:${"-".repeat(width - 2)}:`;
+      return "-".repeat(width);
+    });
+    const line = (cells) => `| ${cells.join(" | ")} |`;
+    const lines = rows.map((row) => line(row.map(pad)));
+    lines.splice(1, 0, line(delimiter));
+    const eol = this.source.slice(start, end).includes("\r\n") ? "\r\n" : "\n";
+    const text = lines.join(eol + prefix);
+    if (text !== this.source.slice(start, end))
+      out.push({ start, end, text });
+  }
+};
+function restyleMarkdown(source, tree, fixed, readsBack) {
+  if (source.startsWith("\uFEFF"))
+    return void 0;
+  const blocks = tree.children ?? [];
+  const groups = blocks.map(() => []);
+  new Restyler(source).children(tree, [], [], fixed, (index) => groups[index] ?? []);
+  const changed = groups.filter((group) => group.length > 0);
+  if (changed.length === 0)
+    return void 0;
+  let kept = [];
+  let best;
+  let budget = 8 * Math.ceil(Math.log2(changed.length + 1)) + 8;
+  const attempt = (tried) => {
+    if (budget-- <= 0)
+      return;
+    const trial = [...kept, ...tried.flat()];
+    const text = apply(source, trial);
+    const parsed = readsBack(text);
+    if (parsed !== void 0) {
+      kept = trial;
+      best = { text, tree: parsed };
+    } else if (tried.length > 1) {
+      const half = Math.ceil(tried.length / 2);
+      attempt(tried.slice(0, half));
+      attempt(tried.slice(half));
+    }
+  };
+  attempt(changed);
+  return best;
+}
+
 // dist/utils/yaml-source-splice.js
 import { isDeepStrictEqual } from "node:util";
 import { Document, parseDocument, isAlias, isCollection, isMap, isNode, isPair, isScalar, isSeq, YAMLMap, visit, YAMLSeq } from "yaml";
@@ -1971,15 +2402,15 @@ function canonical(node) {
 function kindOf(node) {
   return `${node.type}:${String(node.ordered ?? "")}:${String(node.checked ?? "")}`;
 }
-function startOf(node) {
+function startOf2(node) {
   return node?.position?.start.offset;
 }
-function endOf(node) {
+function endOf2(node) {
   return node?.position?.end.offset;
 }
 function sliceOf(text, node) {
-  const start = startOf(node);
-  const end = endOf(node);
+  const start = startOf2(node);
+  const end = endOf2(node);
   return start === void 0 || end === void 0 ? void 0 : text.slice(start, end);
 }
 function reindent(text, from, to) {
@@ -2053,8 +2484,8 @@ var Splicer = class {
   body(before, after) {
     const oNodes = before.children ?? [];
     const nNodes = after.children ?? [];
-    const first = startOf(oNodes[0]);
-    const last = endOf(oNodes[oNodes.length - 1]);
+    const first = startOf2(oNodes[0]);
+    const last = endOf2(oNodes[oNodes.length - 1]);
     if (first === void 0 || last === void 0 || nNodes.length === 0)
       return void 0;
     const o = { text: this.original, indent: "" };
@@ -2162,9 +2593,9 @@ var Splicer = class {
   item(o, oItem, n, nItem) {
     const oChildren = oItem.children ?? [];
     const nChildren = nItem.children ?? [];
-    const oStart = startOf(oItem);
-    const oContent = startOf(oChildren[0]);
-    const nContent = startOf(nChildren[0]);
+    const oStart = startOf2(oItem);
+    const oContent = startOf2(oChildren[0]);
+    const nContent = startOf2(nChildren[0]);
     if (oStart === void 0 || oContent === void 0 || nContent === void 0)
       return void 0;
     const prefix = o.text.slice(oStart, oContent);
@@ -2202,12 +2633,12 @@ var Splicer = class {
   }
 };
 function gapBetween(text, a, b) {
-  const end = endOf(a);
-  const start = startOf(b);
+  const end = endOf2(a);
+  const start = startOf2(b);
   return end === void 0 || start === void 0 ? void 0 : text.slice(end, start);
 }
 function listMarkers(text, items, ordered) {
-  const firstStart = startOf(items[0]);
+  const firstStart = startOf2(items[0]);
   if (firstStart === void 0)
     return void 0;
   if (!ordered) {
@@ -2220,16 +2651,14 @@ function listMarkers(text, items, ordered) {
   const first = numberAt(firstStart);
   if (first === null)
     return void 0;
-  const start = Number(first[1]);
   const delimiter = first[2] ?? ".";
   const padTo = first[1]?.startsWith("0") ? first[1].length : 0;
-  const second = items.length > 1 ? numberAt(startOf(items[1])) : null;
-  const step = second !== null && Number(second[1]) === start ? 0 : 1;
+  const typed = items.map((item) => Number(numberAt(startOf2(item))?.[1]));
   return (itemText, index) => {
     const current = /^\d{1,9}[.)]/.exec(itemText);
     if (current === null)
       return void 0;
-    const marker = `${String(start + step * index).padStart(padTo, "0")}${delimiter}`;
+    const marker = `${String(orderedNumber(typed, index)).padStart(padTo, "0")}${delimiter}`;
     if (marker.length !== current[0].length && itemText.includes("\n"))
       return void 0;
     return marker + itemText.slice(current[0].length);
@@ -2245,22 +2674,56 @@ function preserveMarkdownSource(original, updated, format) {
     return updated;
   }
 }
+function diskBlocks(oNodes, nNodes) {
+  const oKeys = oNodes.map(canonical);
+  const nKeys = nNodes.map(canonical);
+  const pairs = matchSequences(oKeys, nKeys);
+  const fromDisk = new Set(pairs.map(([, ni]) => ni));
+  const matched = new Set(pairs.map(([oi]) => oi));
+  const unmatched = /* @__PURE__ */ new Map();
+  oKeys.forEach((key, index) => {
+    if (!matched.has(index))
+      unmatched.set(key, (unmatched.get(key) ?? 0) + 1);
+  });
+  nKeys.forEach((key, index) => {
+    const left = unmatched.get(key) ?? 0;
+    if (fromDisk.has(index) || left === 0)
+      return;
+    unmatched.set(key, left - 1);
+    fromDisk.add(index);
+  });
+  return fromDisk;
+}
 function splice(original, updated, format) {
-  const before = parse(original, format);
+  const before = original === void 0 ? void 0 : parse(original, format);
   const after = parse(updated, format);
-  if (before === void 0 || after === void 0)
+  if (after === void 0)
     return void 0;
   const target = canonical(after);
-  for (const deep of [true, false]) {
-    const candidate = new Splicer(original, updated, deep).body(before, after);
-    if (candidate === void 0)
-      continue;
-    const reparsed = parse(candidate, format);
-    if (reparsed !== void 0 && canonical(reparsed) === target)
-      return candidate;
-    log.debug("markdown-body-splice", "splice does not read back as the edit", { deep });
+  const fromDisk = diskBlocks(before?.children ?? [], after.children);
+  const restyled = restyleMarkdown(updated, after, (index) => fromDisk.has(index), (text) => {
+    const tree = parse(text, format);
+    return tree !== void 0 && canonical(tree) === target ? tree : void 0;
+  });
+  if (original === void 0 || before === void 0)
+    return restyled?.text;
+  const asSent = { text: updated, tree: after };
+  const edits = restyled === void 0 || restyled.text === updated ? [asSent] : [restyled, asSent];
+  for (const edit of edits) {
+    for (const deep of [true, false]) {
+      const candidate = new Splicer(original, edit.text, deep).body(before, edit.tree);
+      if (candidate === void 0)
+        continue;
+      const reparsed = parse(candidate, format);
+      if (reparsed !== void 0 && canonical(reparsed) === target)
+        return candidate;
+      log.debug("markdown-body-splice", "splice does not read back as the edit", {
+        deep,
+        restyled: edit !== asSent
+      });
+    }
   }
-  return void 0;
+  return restyled?.text;
 }
 
 // dist/utils/content-serialize.js
@@ -2549,7 +3012,7 @@ function writesFrontmatter(data) {
 }
 function bodyToWrite(body, data, format, existingRaw) {
   const priorBody = existingRaw === void 0 ? void 0 : extractBody(existingRaw);
-  const spliced = priorBody === void 0 ? body : preserveMarkdownSource(priorBody, body, format);
+  const spliced = preserveMarkdownSource(priorBody, body, format);
   if (!writesFrontmatter(data)) {
     const flush = spliced.replace(/^(?:\r?\n)+/, "");
     return /^\uFEFF?---/.test(flush) ? `
@@ -3255,12 +3718,41 @@ var isValidId = isValidContentId;
 // dist/content-id-index.js
 init_error();
 init_logger();
+
+// dist/utils/typed-filename.js
+var parseTypedFilename = (filename, entryTypes) => {
+  if (filename.startsWith("."))
+    return null;
+  const lastDot = filename.lastIndexOf(".");
+  if (lastDot === -1)
+    return null;
+  const nameWithoutExt = filename.slice(0, lastDot);
+  const parts = nameWithoutExt.split(".");
+  if (parts.length < 3)
+    return null;
+  const potentialType = parts[0];
+  if (entryTypes && !entryTypes.some((e) => e.name === potentialType)) {
+    return null;
+  }
+  const id = parts[parts.length - 1];
+  if (!isValidId(id))
+    return null;
+  const slug = parts.slice(1, -1).join(".").toLowerCase();
+  return {
+    type: potentialType,
+    slug,
+    id
+  };
+};
+
+// dist/content-id-index.js
 var EMPTY_LOGICAL_PATH = "";
 function toLogicalCollectionPath(physicalPath) {
   if (physicalPath === ".")
     return EMPTY_LOGICAL_PATH;
   return physicalPath.split("/").map((seg) => extractSlugFromFilename(seg)).join("/");
 }
+var ENTRY_EXTENSIONS = new Set(Object.keys({ md: true, mdx: true, json: true, yaml: true }).map((format) => getFormatExtension(format)));
 var ContentIdIndex = class {
   constructor(root) {
     this.idToLocation = /* @__PURE__ */ new Map();
@@ -3631,34 +4123,6 @@ function extractSlugFromFilename(filename, entryTypeName) {
 
 // dist/url-collision.js
 init_error();
-
-// dist/utils/typed-filename.js
-var parseTypedFilename = (filename, entryTypes) => {
-  if (filename.startsWith("."))
-    return null;
-  const lastDot = filename.lastIndexOf(".");
-  if (lastDot === -1)
-    return null;
-  const nameWithoutExt = filename.slice(0, lastDot);
-  const parts = nameWithoutExt.split(".");
-  if (parts.length < 3)
-    return null;
-  const potentialType = parts[0];
-  if (entryTypes && !entryTypes.some((e) => e.name === potentialType)) {
-    return null;
-  }
-  const id = parts[parts.length - 1];
-  if (!isValidId(id))
-    return null;
-  const slug = parts.slice(1, -1).join(".").toLowerCase();
-  return {
-    type: potentialType,
-    slug,
-    id
-  };
-};
-
-// dist/url-collision.js
 var CONTENT_EXTENSIONS = [".md", ".mdx", ".json", ".yaml"];
 async function readDirSafe(dir) {
   try {
@@ -7155,6 +7619,7 @@ var branchMetadataShape = {
   pullRequestNumber: z7.number().int().optional(),
   submittedAt: z7.string().optional(),
   pushedToGitHubAt: z7.string().optional(),
+  editorUrl: z7.string().optional(),
   syncStatus: enumOf({
     synced: "synced",
     "pending-sync": "pending-sync",
@@ -8547,7 +9012,7 @@ var GitManager = class _GitManager {
       });
       await step("clone", () => _GitManager.cloneWorkspace(remoteUrl, options.workspacePath, baseBranch, {
         remoteName,
-        noCheckout: options.branchType === "content",
+        noCheckout: true,
         config: identity
       }));
       justCloned = true;
@@ -9015,7 +9480,7 @@ var GitManager = class _GitManager {
       log9.debug("git", "Checked out the remote settings branch", { branchName });
       return;
     }
-    await this.git.raw(["checkout", "--orphan", branchName]);
+    await this.git.raw(["switch", "--orphan", branchName]);
     await this.git.raw(["rm", "-r", "-f", "-q", "--sparse", "--ignore-unmatch", "--", "."]);
     const leftover = (await this.git.raw(["ls-files"])).trim();
     if (leftover) {