@nuasite/cli 0.56.0 → 0.56.1

package/dist/index.js

@@ -22482,8 +22482,23 @@ function parseSource(source) {
     return null;
   }
 }
+async function classifyEmptyContentConfig(fs) {
+  let found = false;
+  for (const configPath of CONTENT_CONFIG_PATHS) {
+    try {
+      await fs.stat(configPath);
+    } catch {
+      continue;
+    }
+    found = true;
+    if (parseSource(await fs.readFile(configPath)) === null) {
+      return "unparseable";
+    }
+  }
+  return found ? "no-collections" : "missing";
+}
 async function parseContentConfig(fs, cache) {
-  for (const configPath of ["src/content/config.ts", "src/content.config.ts"]) {
+  for (const configPath of CONTENT_CONFIG_PATHS) {
     let stat;
     try {
       stat = await fs.stat(configPath);
@@ -23166,7 +23181,7 @@ function dropNestedDerivedFrom(collectionName, path2, fields) {
     dropNestedDerivedFrom(collectionName, fieldPath, field.fields);
   }
 }
-var import_parser, FIELD_HELPER_TYPES, VALID_HINT_KEYS, WRAPPER_METHODS;
+var import_parser, FIELD_HELPER_TYPES, VALID_HINT_KEYS, WRAPPER_METHODS, CONTENT_CONFIG_PATHS;
 var init_content_config_ast = __esm(() => {
   init_src();
   import_parser = __toESM(require_lib(), 1);
@@ -23198,6 +23213,7 @@ var init_content_config_ast = __esm(() => {
     "accept"
   ]);
   WRAPPER_METHODS = new Set(["optional", "nullable", "nullish", "default"]);
+  CONTENT_CONFIG_PATHS = ["src/content/config.ts", "src/content.config.ts"];
 });
 
 // ../cms-core/src/shared.ts
@@ -23362,12 +23378,15 @@ async function checkContent(fs, options = {}) {
   const findings = [];
   const config = await parseContentConfig(fs, new Map);
   if (config.size === 0) {
-    findings.push({
-      severity: "error",
-      code: "config/no-collections",
-      file: "src/content.config.ts",
-      message: "No collections found \u2014 the content config is missing, unreadable, or declares nothing."
-    });
+    const reason = await classifyEmptyContentConfig(fs);
+    if (reason !== "no-collections") {
+      findings.push({
+        severity: "error",
+        code: reason === "missing" ? "config/missing" : "config/unreadable",
+        file: "src/content.config.ts",
+        message: reason === "missing" ? `No content config found \u2014 expected one of ${CONTENT_CONFIG_PATHS.join(" or ")}.` : "The content config could not be parsed."
+      });
+    }
     return { findings, collections: 0, entries: 0 };
   }
   const collections = await loadCollections(fs, config);
@@ -33552,7 +33571,7 @@ async function applyImageChange(content, change, absFilePath, originUrl) {
       break;
     }
   }
-  if (replacedIndex < 0 && change.sourceSnippet) {
+  if (replacedIndex < 0 && change.sourceSnippet && isYamlValueSource(newContent, change.sourceSnippet, change.sourcePath)) {
     for (const srcToFind of srcCandidates) {
       const yamlResult = tryYamlValueReplacement(change.sourceSnippet, srcToFind, newSrc);
       if (yamlResult !== null) {
@@ -33859,7 +33878,7 @@ function replaceLiteralInSnippet(content, snippet, oldValue, newValue) {
       continue;
     const updated = snippet.replace(pattern, `${quote}${safeNewValue}${quote}`);
     if (updated !== snippet)
-      return content.replace(snippet, updated);
+      return content.replace(snippet, escapeReplacement(updated));
   }
   return;
 }
@@ -33953,35 +33972,66 @@ function applyTextChange(content, change, manifest) {
   if (!content.includes(sourceSnippet)) {
     return { success: false, error: "Source snippet not found in file" };
   }
-  const stylingAllowed = manifest.entries[change.cmsId]?.allowStyling !== false;
+  const entry = manifest.entries[change.cmsId];
+  const insideYaml = isYamlValueSource(content, sourceSnippet, change.sourcePath);
+  const stylingAllowed = entry?.allowStyling !== false && !insideYaml;
   const newText = stylingAllowed ? htmlValue ?? newValue : newValue;
   const placeholderPattern = /\{\{cms:[^}]+\}\}/g;
   if (placeholderPattern.test(originalValue)) {
-    return applyTextChangeWithPlaceholders(content, sourceSnippet, originalValue, newText);
+    return applyTextChangeWithPlaceholders(insideYaml, content, sourceSnippet, originalValue, newText);
   }
   const resolvedNewText = resolveCmsPlaceholders(newText, manifest);
   const resolvedOriginal = resolveCmsPlaceholders(originalValue, manifest);
-  const updatedSnippet = sourceSnippet.replace(resolvedOriginal, resolvedNewText);
-  if (updatedSnippet === sourceSnippet) {
-    const yamlResult = tryYamlValueReplacement(sourceSnippet, resolvedOriginal, resolvedNewText);
-    if (yamlResult !== null) {
-      return { success: true, content: content.replace(sourceSnippet, yamlResult) };
+  const write = (updatedSnippet2) => writeSnippet(content, sourceSnippet, updatedSnippet2, insideYaml, resolvedNewText);
+  const snippetIsJavaScript = isJavaScriptSource(change.sourcePath) && (!!entry?.variableName || !looksLikeMarkup(sourceSnippet));
+  if (snippetIsJavaScript) {
+    const literalResult = tryJsStringLiteralChange(sourceSnippet, resolvedOriginal, resolvedNewText);
+    if (literalResult !== null) {
+      return write(literalResult);
+    }
+  }
+  if (insideYaml) {
+    const frontmatterResult = tryYamlValueReplacement(sourceSnippet, resolvedOriginal, resolvedNewText, true);
+    if (frontmatterResult !== null) {
+      return write(frontmatterResult);
     }
+  }
+  const updatedSnippet = sourceSnippet.replace(resolvedOriginal, escapeReplacement(resolvedNewText));
+  if (updatedSnippet === sourceSnippet) {
     const brResult = tryBrNormalizedChange(sourceSnippet, resolvedOriginal, resolvedNewText);
     if (brResult !== null) {
-      return { success: true, content: content.replace(sourceSnippet, brResult) };
+      return write(brResult);
+    }
+    if (snippetIsJavaScript) {
+      const literalResult = tryJsStringLiteralChange(sourceSnippet, resolvedOriginal, resolvedNewText);
+      if (literalResult !== null) {
+        return write(literalResult);
+      }
     }
     const matchedText = findTextInSnippet(sourceSnippet, resolvedOriginal);
     if (matchedText) {
-      const updatedWithEntity = sourceSnippet.replace(matchedText, resolvedNewText);
-      return { success: true, content: content.replace(sourceSnippet, updatedWithEntity) };
+      const spliced = /<[^>]+>/.test(resolvedNewText) ? null : spliceIntoEntitySource(matchedText, resolvedOriginal, resolvedNewText);
+      const replacement = spliced ?? (/<[^>]+>/.test(resolvedNewText) ? encodeNbspLike(resolvedNewText, matchedText) : encodeEntitiesLike(resolvedNewText, matchedText));
+      const updatedWithEntity = sourceSnippet.replace(matchedText, escapeReplacement(replacement));
+      return write(updatedWithEntity);
     }
     const innerMatch = sourceSnippet.match(/^(\s*<(\w+)\b[^>]*>)([\s\S]*)(<\/\2>\s*)$/);
     if (innerMatch) {
       const [, openTag, , innerContent, closeTag] = innerMatch;
       const textOnly = innerContent.replace(/<[^>]+>/g, "");
       if (textOnly === resolvedOriginal) {
-        return { success: true, content: content.replace(sourceSnippet, openTag + resolvedNewText + closeTag) };
+        const isHtmlReplacement = /<[^>]+>/.test(resolvedNewText);
+        if (isHtmlReplacement || !/<[^>]+>/.test(innerContent)) {
+          return write(openTag + resolvedNewText + closeTag);
+        }
+        const splicedInner = spliceTextAcrossInlineMarkup(innerContent, resolvedOriginal, resolvedNewText);
+        if (splicedInner !== null) {
+          return write(openTag + splicedInner + closeTag);
+        }
+        return {
+          success: false,
+          error: "Cannot apply this edit without dropping the inline markup inside the element " + "\u2014 edit the styled part separately"
+        };
       }
     }
     return {
@@ -33989,9 +34039,9 @@ function applyTextChange(content, change, manifest) {
       error: `Original text "${resolvedOriginal.substring(0, 50)}..." not found in source snippet`
     };
   }
-  return { success: true, content: content.replace(sourceSnippet, updatedSnippet) };
+  return write(updatedSnippet);
 }
-function applyTextChangeWithPlaceholders(content, sourceSnippet, originalValue, newText) {
+function applyTextChangeWithPlaceholders(insideYaml, content, sourceSnippet, originalValue, newText) {
   const placeholderPattern = /\{\{cms:[^}]+\}\}/g;
   const originalParts = originalValue.split(placeholderPattern);
   const newParts = newText.split(placeholderPattern);
@@ -34011,7 +34061,7 @@ function applyTextChangeWithPlaceholders(content, sourceSnippet, originalValue,
       if (matchedText !== oldPart) {
         newPart = encodeEntitiesLike(newPart, matchedText);
       }
-      updatedSnippet = updatedSnippet.replace(matchedText, newPart);
+      updatedSnippet = updatedSnippet.replace(matchedText, escapeReplacement(newPart));
       anyChange = true;
     } else {
       return {
@@ -34023,27 +34073,192 @@ function applyTextChangeWithPlaceholders(content, sourceSnippet, originalValue,
   if (!anyChange) {
     return { success: false, error: "No text changes detected between original and new values" };
   }
-  return { success: true, content: content.replace(sourceSnippet, updatedSnippet) };
+  return writeSnippet(content, sourceSnippet, updatedSnippet, insideYaml, newText);
+}
+function isJavaScriptSource(sourcePath) {
+  return !!sourcePath && JAVASCRIPT_SOURCE.test(sourcePath);
+}
+function isYamlValueSource(content, sourceSnippet, sourcePath) {
+  if (!sourcePath)
+    return false;
+  if (YAML_DOCUMENT_SOURCE.test(sourcePath))
+    return true;
+  if (!YAML_FRONTMATTER_SOURCE.test(sourcePath))
+    return false;
+  const block = frontmatterBlock(content);
+  if (!block)
+    return false;
+  const snippetStart = content.indexOf(sourceSnippet);
+  return snippetStart >= block.start && snippetStart + sourceSnippet.length <= block.end;
+}
+function frontmatterBlock(content) {
+  const opening = /^(?:\uFEFF)?(?:[ \t]*\r?\n)*(---|\+\+\+)[ \t]*\r?\n/.exec(content);
+  if (!opening || opening[1] !== "---")
+    return null;
+  const start = opening[0].length;
+  const closing = /\n(?:---|\+\+\+)[ \t]*(\r?\n|$)/.exec(content.slice(start));
+  return closing ? { start, end: start + closing.index } : null;
+}
+function looksLikeMarkup(text) {
+  return /<[a-zA-Z/!]/.test(text);
+}
+function decodeJsString(raw) {
+  let out = "";
+  for (let i2 = 0;i2 < raw.length; i2++) {
+    const char = raw[i2];
+    if (char !== "\\") {
+      out += char;
+      continue;
+    }
+    const next = raw[++i2];
+    if (next === undefined)
+      break;
+    if (next === "u") {
+      if (raw[i2 + 1] === "{") {
+        const close = raw.indexOf("}", i2 + 2);
+        if (close !== -1) {
+          const code2 = parseInt(raw.slice(i2 + 2, close), 16);
+          if (!Number.isNaN(code2)) {
+            out += String.fromCodePoint(code2);
+            i2 = close;
+            continue;
+          }
+        }
+      }
+      const code = parseInt(raw.slice(i2 + 1, i2 + 5), 16);
+      if (!Number.isNaN(code)) {
+        out += String.fromCharCode(code);
+        i2 += 4;
+        continue;
+      }
+    }
+    if (next === "x") {
+      const code = parseInt(raw.slice(i2 + 1, i2 + 3), 16);
+      if (!Number.isNaN(code)) {
+        out += String.fromCharCode(code);
+        i2 += 2;
+        continue;
+      }
+    }
+    if (next === `
+`)
+      continue;
+    out += JS_ESCAPES[next] ?? next;
+  }
+  return out;
+}
+function encodeJsString(value, quote, escapeNbsp) {
+  let out = value.replace(/\\/g, "\\\\").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t").replaceAll(quote, `\\${quote}`);
+  if (escapeNbsp)
+    out = out.replace(/\u00A0/g, "\\u00A0");
+  if (quote === "`")
+    out = out.replace(/\$\{/g, "\\${");
+  return quote + out + quote;
+}
+function findStringLiterals(snippet) {
+  const literals = [];
+  for (let i2 = 0;i2 < snippet.length; i2++) {
+    const quote = snippet[i2];
+    if (quote !== "'" && quote !== '"' && quote !== "`")
+      continue;
+    let j = i2 + 1;
+    while (j < snippet.length) {
+      if (snippet[j] === "\\")
+        j += 2;
+      else if (snippet[j] === quote)
+        break;
+      else
+        j++;
+    }
+    if (j >= snippet.length)
+      break;
+    const raw = snippet.slice(i2 + 1, j);
+    literals.push({ start: i2, end: j + 1, quote, value: decodeJsString(raw) });
+    i2 = j;
+  }
+  return literals;
+}
+function tryJsStringLiteralChange(sourceSnippet, resolvedOriginal, resolvedNewText) {
+  const literals = findStringLiterals(sourceSnippet);
+  if (literals.length === 0)
+    return null;
+  const splice = (start, end, replacement) => sourceSnippet.slice(0, start) + replacement + sourceSnippet.slice(end);
+  for (const literal of literals) {
+    if (literal.value !== resolvedOriginal)
+      continue;
+    const escapeNbsp = /\\u00[aA]0/.test(sourceSnippet.slice(literal.start, literal.end));
+    return splice(literal.start, literal.end, encodeJsString(resolvedNewText, literal.quote, escapeNbsp));
+  }
+  for (let first = 0;first < literals.length; first++) {
+    let combined = "";
+    for (let last = first;last < literals.length; last++) {
+      if (last > first) {
+        const between = sourceSnippet.slice(literals[last - 1].end, literals[last].start);
+        if (!/^\s*\+\s*$/.test(between))
+          break;
+      }
+      combined += literals[last].value;
+      if (last === first || combined !== resolvedOriginal)
+        continue;
+      const start = literals[first].start;
+      const end = literals[last].end;
+      const escapeNbsp = /\\u00[aA]0/.test(sourceSnippet.slice(start, end));
+      return splice(start, end, encodeJsString(resolvedNewText, literals[first].quote, escapeNbsp));
+    }
+  }
+  return null;
+}
+function pickRunAtSeam(tokens, earlier, later) {
+  const seam = tokens.slice(earlier.index + 1, later.index).find((token) => token.startsWith("<"));
+  return seam?.startsWith("</") ? later : earlier;
+}
+function spliceTextAcrossInlineMarkup(innerContent, originalText, newText) {
+  const tokens = innerContent.split(/(<[^>]+>)/);
+  const isTag = (token2) => token2.startsWith("<");
+  const runs = [];
+  let plain = "";
+  for (let i2 = 0;i2 < tokens.length; i2++) {
+    const token2 = tokens[i2];
+    if (isTag(token2) || !token2)
+      continue;
+    runs.push({ index: i2, start: plain.length, end: plain.length + token2.length });
+    plain += token2;
+  }
+  if (plain !== originalText)
+    return null;
+  let start = 0;
+  while (start < originalText.length && start < newText.length && originalText[start] === newText[start])
+    start++;
+  let tail = 0;
+  while (tail < originalText.length - start && tail < newText.length - start && originalText[originalText.length - 1 - tail] === newText[newText.length - 1 - tail])
+    tail++;
+  const originalEnd = originalText.length - tail;
+  const newEnd = newText.length - tail;
+  if (start === originalEnd && start === newEnd)
+    return innerContent;
+  if (start === originalEnd) {
+    const inserted = newText.slice(start, newEnd);
+    if (start === 0)
+      return inserted + innerContent;
+    if (start === originalText.length)
+      return innerContent + inserted;
+  }
+  const fitting = runs.filter((r) => start >= r.start && originalEnd <= r.end);
+  const run = start === originalEnd && fitting.length > 1 ? pickRunAtSeam(tokens, fitting[0], fitting[fitting.length - 1]) : fitting[0];
+  if (!run)
+    return null;
+  const token = tokens[run.index];
+  tokens[run.index] = token.slice(0, start - run.start) + newText.slice(start, newEnd) + token.slice(originalEnd - run.start);
+  return tokens.join("");
 }
 function findTextInSnippet(snippet, decodedText) {
   if (snippet.includes(decodedText)) {
     return decodedText;
   }
-  const entityMap = [
-    ["&", "&amp;"],
-    [" ", "&nbsp;"],
-    [" ", "&#160;"],
-    ["<", "&lt;"],
-    [">", "&gt;"],
-    ['"', "&quot;"],
-    ["'", "&#39;"],
-    ["'", "&apos;"]
-  ];
-  let pattern = escapeRegex(decodedText);
-  for (const [char, entity] of entityMap) {
-    const escapedChar = escapeRegex(char);
-    const escapedEntity = escapeRegex(entity);
-    pattern = pattern.replace(new RegExp(escapedChar, "g"), `(?:${escapedChar}|${escapedEntity})`);
+  let pattern = "";
+  for (const char of decodedText) {
+    const alternatives = ENTITY_ALTERNATIVES.get(char);
+    pattern += alternatives ? `(?:${[char, ...alternatives].map(escapeRegex).join("|")})` : escapeRegex(char);
   }
   const regex = new RegExp(pattern);
   const match = snippet.match(regex);
@@ -34055,11 +34270,70 @@ function findTextInSnippet(snippet, decodedText) {
   const brMatch = snippet.match(brRegex);
   return brMatch && brMatch[0] !== decodedText ? brMatch[0] : null;
 }
+function sameCharacter(a, b2) {
+  if (a === b2)
+    return true;
+  const spaceLike = (c) => c === " " || c === "\xA0";
+  return spaceLike(a) && spaceLike(b2);
+}
+function decodeEntitiesWithOffsets(source) {
+  const entityPattern = /&(?:#x([0-9a-f]+)|#(\d+)|([a-z]+));/iy;
+  let text = "";
+  const offsets = [];
+  let i2 = 0;
+  while (i2 < source.length) {
+    entityPattern.lastIndex = i2;
+    const match = entityPattern.exec(source);
+    const decoded = match ? decodeEntityMatch(match) : undefined;
+    offsets.push(i2);
+    if (decoded !== undefined) {
+      text += decoded;
+      i2 += match[0].length;
+    } else {
+      text += source[i2];
+      i2++;
+    }
+  }
+  offsets.push(source.length);
+  return { text, offsets };
+}
+function decodeEntityMatch(match) {
+  const [, hex, dec, name] = match;
+  if (hex)
+    return String.fromCodePoint(parseInt(hex, 16));
+  if (dec)
+    return String.fromCodePoint(parseInt(dec, 10));
+  return name ? NAMED_ENTITIES[name.toLowerCase()] : undefined;
+}
+function spliceIntoEntitySource(source, original, replacement) {
+  const { text: decoded, offsets } = decodeEntitiesWithOffsets(source);
+  if (decoded.length !== original.length)
+    return null;
+  for (let i2 = 0;i2 < decoded.length; i2++) {
+    if (!sameCharacter(decoded[i2], original[i2]))
+      return null;
+  }
+  let start = 0;
+  while (start < original.length && start < replacement.length && sameCharacter(original[start], replacement[start])) {
+    start++;
+  }
+  let tail = 0;
+  while (tail < original.length - start && tail < replacement.length - start && sameCharacter(original[original.length - 1 - tail], replacement[replacement.length - 1 - tail]))
+    tail++;
+  const originalEnd = original.length - tail;
+  const newEnd = replacement.length - tail;
+  if (start === originalEnd && start === newEnd)
+    return source;
+  const head = source.slice(0, offsets[start]);
+  const rest = source.slice(offsets[originalEnd]);
+  return head + encodeEntitiesLike(replacement.slice(start, newEnd), source) + rest;
+}
 function encodeEntitiesLike(text, reference) {
   let result = text;
   if (reference.includes("&amp;")) {
     result = result.replace(/&/g, "&amp;");
   }
+  result = encodeNbspLike(result, reference);
   if (reference.includes("&lt;")) {
     result = result.replace(/</g, "&lt;");
   }
@@ -34074,6 +34348,13 @@ function encodeEntitiesLike(text, reference) {
   }
   return result;
 }
+function encodeNbspLike(text, reference) {
+  if (reference.includes("&nbsp;"))
+    return text.replace(/\u00A0/g, "&nbsp;");
+  if (reference.includes("&#160;"))
+    return text.replace(/\u00A0/g, "&#160;");
+  return text;
+}
 function resolveCmsPlaceholders(text, manifest) {
   const placeholderPattern = /\{\{cms:([^}]+)\}\}/g;
   return text.replace(placeholderPattern, (match, cmsId) => {
@@ -34135,24 +34416,164 @@ function getVisibleText(html) {
 `);
   return text.trim();
 }
-function tryYamlValueReplacement(sourceSnippet, resolvedOriginal, resolvedNewText) {
-  const keyMatch = sourceSnippet.match(/^(\s*([\w][\w-]*):\s*)/);
-  if (!keyMatch)
+function findYamlTargets(sourceSnippet, allowQuotedKey) {
+  let doc;
+  try {
+    doc = import_yaml6.parseDocument(sourceSnippet);
+    if (doc.errors.length > 0)
+      return [];
+  } catch {
+    return [];
+  }
+  const targets = [];
+  import_yaml6.visit(doc, {
+    Scalar(key, node, path13) {
+      if (key === "key" || !node.range)
+        return;
+      if (typeof node.value !== "string" && typeof node.value !== "number")
+        return;
+      const parent = path13[path13.length - 1];
+      const pair = key === "value" && parent && "key" in parent ? parent : null;
+      if (!allowQuotedKey && (pair ? pair.key?.type !== "PLAIN" : node.type !== "PLAIN"))
+        return;
+      const ownerStart = pair ? pair.key.range[0] : dashBefore(sourceSnippet, node.range[0]);
+      const [start, end] = node.range;
+      const value = node.value;
+      const trailingCr = typeof value === "string" && value.endsWith("\r") && sourceSnippet[end - 1] === "\r";
+      targets.push({
+        start,
+        end: trailingCr ? end - 1 : end,
+        value: trailingCr ? value.slice(0, -1) : value,
+        key: pair ? String(pair.key.value) : null,
+        ownerColumn: columnOf(sourceSnippet, ownerStart)
+      });
+    }
+  });
+  return targets;
+}
+function dashBefore(sourceSnippet, valueStart) {
+  const dash = sourceSnippet.lastIndexOf("-", valueStart);
+  return dash < 0 ? valueStart : dash;
+}
+function columnOf(sourceSnippet, offset) {
+  return offset - (sourceSnippet.lastIndexOf(`
+`, offset - 1) + 1);
+}
+function tryYamlValueReplacement(sourceSnippet, resolvedOriginal, resolvedNewText, allowQuotedKey = false) {
+  const matches = findYamlTargets(sourceSnippet, allowQuotedKey).filter((candidate) => String(candidate.value) === resolvedOriginal);
+  if (matches.length !== 1)
     return null;
+  const target = matches[0];
+  const fieldIsTyped = resolvesAsNonString(sourceSnippet.slice(target.start, target.end));
+  const replacement = typeof target.value === "number" && YAML_PLAIN_NUMBER.test(resolvedNewText) ? resolvedNewText : serializeYamlValue(resolvedNewText, target.key, target.ownerColumn, fieldIsTyped);
+  if (replacement === null)
+    return null;
+  const updated = sourceSnippet.slice(0, target.start) + replacement + sourceSnippet.slice(target.end);
+  return yamlValueRoundTrips(updated, resolvedNewText) ? updated : null;
+}
+function yamlValueRoundTrips(updatedSnippet, expected) {
+  return findYamlTargets(normalizeCr(updatedSnippet), true).some((target) => scalarSays(target.value, expected));
+}
+function scalarSays(actual, expected) {
+  if (String(actual) === expected)
+    return true;
+  if (typeof actual !== "number")
+    return false;
+  const parsed = tryParseYaml(expected);
+  return typeof parsed === "number" && parsed === actual;
+}
+function writeSnippet(content, sourceSnippet, updatedSnippet, insideYaml, expected) {
+  if (insideYaml && !yamlSnippetSurvives(sourceSnippet, updatedSnippet, expected)) {
+    return {
+      success: false,
+      error: `"${expected.substring(0, 50)}" cannot be written into this frontmatter field without breaking it`
+    };
+  }
+  return { success: true, content: content.replace(sourceSnippet, escapeReplacement(updatedSnippet)) };
+}
+function yamlSnippetSurvives(sourceSnippet, updatedSnippet, expected) {
+  const before = yamlScalars(sourceSnippet);
+  const after = yamlScalars(updatedSnippet);
+  if (!before || !after || before.length !== after.length)
+    return false;
+  let changed = 0;
+  for (let i2 = 0;i2 < before.length; i2++) {
+    if (before[i2].owner !== after[i2].owner)
+      return false;
+    const wrote = after[i2].value;
+    if (String(before[i2].value) === String(wrote))
+      continue;
+    changed++;
+    const saysIt = expected === "" ? wrote === "" : scalarSays(wrote, expected) || String(wrote).includes(expected);
+    if (!saysIt)
+      return false;
+  }
+  return changed > 0;
+}
+function yamlScalars(snippet) {
   try {
-    const parsed = import_yaml6.parse(sourceSnippet);
-    if (parsed == null || typeof parsed !== "object")
+    const doc = import_yaml6.parseDocument(normalizeCr(snippet));
+    if (doc.errors.length > 0)
       return null;
-    const value = parsed[keyMatch[2]];
-    if (typeof value !== "string" && typeof value !== "number")
-      return null;
-    if (String(value) !== resolvedOriginal)
+    const scalars = [];
+    import_yaml6.visit(doc, {
+      Scalar(key, node) {
+        scalars.push({ owner: String(key), value: node.value });
+      }
+    });
+    return scalars;
+  } catch {
+    return null;
+  }
+}
+function normalizeCr(snippet) {
+  return snippet.replace(/\r(?=\n|$)/g, "");
+}
+function serializeYamlValue(value, key, ownerColumn, fieldIsTyped = false) {
+  let body = renderYamlValue(value, key, undefined);
+  if (!fieldIsTyped && body !== null && !body.includes(`
+`) && resolvesAsNonString(body)) {
+    body = renderYamlValue(value, key, "QUOTE_DOUBLE");
+  }
+  if (body === null || !body.includes(`
+`))
+    return body;
+  const pad = " ".repeat(ownerColumn);
+  const [header, ...rest] = body.split(`
+`);
+  return [header, ...rest.map((line) => line === "" ? line : pad + line)].join(`
+`);
+}
+function renderYamlValue(value, key, defaultStringType) {
+  const options = { lineWidth: 0, ...defaultStringType ? { defaultStringType, defaultKeyType: "PLAIN" } : {} };
+  const rendered = key === null ? import_yaml6.stringify([value], options) : import_yaml6.stringify({ [key]: value }, options);
+  let valueStart;
+  try {
+    const doc = import_yaml6.parseDocument(rendered);
+    const first = doc.contents?.items?.[0];
+    const node = key === null ? first : first?.value;
+    if (!node?.range)
       return null;
+    valueStart = node.range[0];
   } catch {
     return null;
   }
-  const serialized = import_yaml6.stringify(resolvedNewText, { lineWidth: 0 }).trimEnd();
-  return `${keyMatch[1]}${serialized}`;
+  const text = rendered.slice(valueStart);
+  return /^[|>]\d*\+/.test(text) ? text : text.replace(/\n$/, "");
+}
+function resolvesAsNonString(scalar) {
+  try {
+    return typeof import_yaml6.parse(scalar, { version: "1.1" }) !== "string";
+  } catch {
+    return false;
+  }
+}
+function tryParseYaml(text) {
+  try {
+    return import_yaml6.parse(text);
+  } catch {
+    return;
+  }
 }
 function tryDataFileValueReplacement(content, sourceSnippet, originalValue, newValue, sourceLine) {
   const doubleQuoted = `"${originalValue}"`;
@@ -34168,7 +34589,7 @@ function tryDataFileValueReplacement(content, sourceSnippet, originalValue, newV
   } else {
     return null;
   }
-  const updatedSnippet = sourceSnippet.replace(quotedOriginal, quotedNew);
+  const updatedSnippet = sourceSnippet.replace(quotedOriginal, escapeReplacement(quotedNew));
   if (updatedSnippet === sourceSnippet)
     return null;
   let searchStart = 0;
@@ -34232,14 +34653,14 @@ function tryBrNormalizedChange(sourceSnippet, resolvedOriginal, resolvedNewText)
         const leadingWs = raw.slice(0, raw.indexOf(trimmed));
         const trailingWs = raw.slice(raw.indexOf(trimmed) + trimmed.length);
         const newRaw = leadingWs + newSegment + trailingWs;
-        result = result.replace(raw, newRaw);
+        result = result.replace(raw, escapeReplacement(newRaw));
         break;
       }
     }
   }
   return result !== sourceSnippet ? result : null;
 }
-var import_node_html_parser, import_yaml6, ASSET_IMPORT_EXT_RE, REMOTE_FETCH_TIMEOUT_MS = 15000, REMOTE_FETCH_MAX_BYTES, QUOTED_LITERAL_DELIMITERS;
+var import_node_html_parser, import_yaml6, ASSET_IMPORT_EXT_RE, REMOTE_FETCH_TIMEOUT_MS = 15000, REMOTE_FETCH_MAX_BYTES, QUOTED_LITERAL_DELIMITERS, JAVASCRIPT_SOURCE, YAML_DOCUMENT_SOURCE, YAML_FRONTMATTER_SOURCE, JS_ESCAPES, ENTITY_ALTERNATIVES, NAMED_ENTITIES, YAML_PLAIN_NUMBER;
 var init_source_writer = __esm(() => {
   init_astro_image_paths();
   init_config();
@@ -34250,6 +34671,37 @@ var init_source_writer = __esm(() => {
   ASSET_IMPORT_EXT_RE = /\.(jpe?g|png|gif|webp|avif|svg|ico|bmp|tiff?)$/i;
   REMOTE_FETCH_MAX_BYTES = 50 * 1024 * 1024;
   QUOTED_LITERAL_DELIMITERS = [`'`, `"`, "`"];
+  JAVASCRIPT_SOURCE = /\.(astro|[cm]?[jt]sx?)$/i;
+  YAML_DOCUMENT_SOURCE = /\.ya?ml$/i;
+  YAML_FRONTMATTER_SOURCE = /\.(md|mdx|markdown)$/i;
+  JS_ESCAPES = {
+    n: `
+`,
+    r: "\r",
+    t: "\t",
+    b: "\b",
+    f: "\f",
+    v: "\v",
+    0: "\x00"
+  };
+  ENTITY_ALTERNATIVES = new Map([
+    ["&", ["&amp;"]],
+    ["\xA0", ["&nbsp;", "&#160;", " "]],
+    [" ", ["&nbsp;", "&#160;"]],
+    ["<", ["&lt;"]],
+    [">", ["&gt;"]],
+    ['"', ["&quot;"]],
+    ["'", ["&#39;", "&apos;"]]
+  ]);
+  NAMED_ENTITIES = {
+    amp: "&",
+    lt: "<",
+    gt: ">",
+    quot: '"',
+    apos: "'",
+    nbsp: "\xA0"
+  };
+  YAML_PLAIN_NUMBER = /^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?$/;
 });
 
 // ../cms/src/handlers/api-routes.ts