canopycms 0.11.1 → 0.12.1

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

@@ -186,6 +186,21 @@ function withItemKeys(fields, data, fill) {
   return out;
 }
 function keyList(field, items, fill) {
+  const keys = listKeys(items, fill);
+  let changed = false;
+  const out = items.map((item, i) => {
+    if (!isPlainRecord(item))
+      return item;
+    let next = keyInside(field, item, fill);
+    if (keys[i] !== item[ITEM_KEY])
+      next = { ...next, [ITEM_KEY]: keys[i] };
+    if (next !== item)
+      changed = true;
+    return next;
+  });
+  return changed ? out : items;
+}
+function listKeys(items, fill) {
   const held = /* @__PURE__ */ new Set();
   if (fill !== "fresh") {
     for (const item of items) {
@@ -194,25 +209,19 @@ function keyList(field, items, fill) {
     }
   }
   const kept = /* @__PURE__ */ new Set();
-  let changed = false;
-  const out = items.map((item) => {
+  return items.map((item) => {
     if (!isPlainRecord(item))
-      return item;
-    let next = keyInside(field, item, fill);
+      return void 0;
     const own = item[ITEM_KEY];
     if (fill !== "fresh" && isItemKey(own) && !kept.has(own)) {
       kept.add(own);
-    } else {
-      const key = fill === "content" ? unheld(contentKey(item), held) : mintItemKey();
-      held.add(key);
-      kept.add(key);
-      next = { ...next, [ITEM_KEY]: key };
+      return own;
     }
-    if (next !== item)
-      changed = true;
-    return next;
+    const key = fill === "content" ? unheld(contentKey(item), held) : mintItemKey();
+    held.add(key);
+    kept.add(key);
+    return key;
   });
-  return changed ? out : items;
 }
 function unheld(key, held) {
   let out = key;
@@ -314,11 +323,11 @@ var init_sanitize_href = __esm({
 });
 
 // dist/paths/normalize.js
-function normalizeFilesystemPath(path27) {
-  return path27.split(/[\\/]+/).filter(Boolean).join("/");
+function normalizeFilesystemPath(path28) {
+  return path28.split(/[\\/]+/).filter(Boolean).join("/");
 }
-function hasTraversalSequence(path27) {
-  const normalized = normalizeFilesystemPath(path27);
+function hasTraversalSequence(path28) {
+  const normalized = normalizeFilesystemPath(path28);
   return normalized.includes("..");
 }
 function createLogicalPath(...segments) {
@@ -331,14 +340,14 @@ function createLogicalPath(...segments) {
 function entryLogicalPath(collectionLogicalPath, slug) {
   return collectionLogicalPath ? `${collectionLogicalPath}/${slug}` : slug;
 }
-function trimSlashes(path27) {
+function trimSlashes(path28) {
   let start = 0;
-  let end = path27.length;
-  while (start < end && path27[start] === "/")
+  let end = path28.length;
+  while (start < end && path28[start] === "/")
     start++;
-  while (end > start && path27[end - 1] === "/")
+  while (end > start && path28[end - 1] === "/")
     end--;
-  return path27.slice(start, end);
+  return path28.slice(start, end);
 }
 var init_normalize = __esm({
   "dist/paths/normalize.js"() {
@@ -1175,6 +1184,9 @@ var init_client_safe_strategy = __esm({
       supportsPullRequests() {
         return true;
       }
+      syncsBranchesWithBase() {
+        return true;
+      }
       getPermissionsFileName() {
         return "permissions.json";
       }
@@ -1201,6 +1213,9 @@ var init_client_safe_strategy = __esm({
       supportsPullRequests() {
         return false;
       }
+      syncsBranchesWithBase() {
+        return false;
+      }
       getPermissionsFileName() {
         return "permissions.json";
       }
@@ -1610,8 +1625,7 @@ var init_worker_status = __esm({
 });
 
 // dist/cli/generate-ai-content.js
-import path26 from "node:path";
-import { createJiti } from "jiti";
+import path27 from "node:path";
 
 // dist/build/generate-ai-content.js
 init_error();
@@ -1626,7 +1640,7 @@ import matter2 from "gray-matter";
 import { parse as yamlParse } from "yaml";
 
 // dist/utils/content-serialize.js
-import { isDeepStrictEqual as isDeepStrictEqual2 } from "node:util";
+import { isDeepStrictEqual as isDeepStrictEqual3 } from "node:util";
 import matter from "gray-matter";
 import { isCollection as isCollection2, isMap as isMap2, isNode as isNode2, isScalar as isScalar2, isSeq as isSeq2, parseDocument as parseDocument2, Scalar, stringify as yamlStringify, visit as visit2 } from "yaml";
 
@@ -1805,13 +1819,112 @@ var testLogger = createDebugLogger({
 // dist/utils/content-serialize.js
 init_error();
 
+// dist/utils/json-source-splice.js
+import { isDeepStrictEqual } from "node:util";
+import { applyEdits, modify } from "jsonc-parser";
+init_error();
+var log = createDebugLogger({ prefix: "JsonSourceSplice" });
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function plainStringify(data) {
+  return `${JSON.stringify(data, null, 2)}
+`;
+}
+function detectFormatting(text) {
+  const indent = /^([ \t]+)\S/m.exec(text)?.[1];
+  const eol = text.includes("\r\n") ? "\r\n" : "\n";
+  if (indent?.startsWith("	"))
+    return { insertSpaces: false, tabSize: 1, eol };
+  return { insertSpaces: true, tabSize: indent?.length ?? 2, eol };
+}
+function insertMember(text, path28, key, value, formattingOptions) {
+  const at = [...path28, key];
+  const [edit] = modify(text, at, value, {});
+  const closing = edit ? /^[ \t]*\r?\n([ \t]*)\}/.exec(text.slice(edit.offset)) : null;
+  if (edit && closing && edit.length === 0 && edit.content.startsWith(",")) {
+    const unit = formattingOptions.insertSpaces ? " ".repeat(formattingOptions.tabSize ?? 2) : "	";
+    const eol = formattingOptions.eol ?? "\n";
+    const indent = closing[1] + unit;
+    const rendered = JSON.stringify(value, null, unit).split("\n").join(eol + indent);
+    return applyEdits(text, [
+      { ...edit, content: `,${eol}${indent}${JSON.stringify(key)}: ${rendered}` }
+    ]);
+  }
+  return applyEdits(text, modify(text, at, value, { formattingOptions }));
+}
+function removeMember(text, path28) {
+  return applyEdits(text, modify(text, path28, void 0, {}).map((edit) => {
+    const removed = text.slice(edit.offset, edit.offset + edit.length);
+    const lead = /^\s+/.exec(removed)?.[0].length ?? 0;
+    const atMember = /\S/.test(text.charAt(edit.offset + edit.length));
+    return edit.content === "" && lead > 0 && atMember ? { ...edit, offset: edit.offset + lead, length: edit.length - lead } : edit;
+  }));
+}
+function reconcile(text, path28, before, after, formattingOptions) {
+  if (isRecord(before) && isRecord(after)) {
+    if (Object.keys(after).length === 0 && Object.keys(before).length > 0) {
+      return applyEdits(text, modify(text, path28, {}, { formattingOptions }));
+    }
+    let next = text;
+    for (const key of Object.keys(before)) {
+      if (!Object.prototype.hasOwnProperty.call(after, key))
+        next = removeMember(next, [...path28, key]);
+    }
+    for (const key of Object.keys(after)) {
+      next = Object.prototype.hasOwnProperty.call(before, key) ? reconcile(next, [...path28, key], before[key], after[key], formattingOptions) : insertMember(next, path28, key, after[key], formattingOptions);
+    }
+    return next;
+  }
+  if (Array.isArray(before) && Array.isArray(after) && before.length === after.length) {
+    return after.reduce((next, item, index) => reconcile(next, [...path28, index], before[index], item, formattingOptions), text);
+  }
+  if (JSON.stringify(before) === JSON.stringify(after))
+    return text;
+  return applyEdits(text, modify(text, path28, after, { formattingOptions }));
+}
+function serializeJson(data, existingRaw) {
+  if (existingRaw === void 0)
+    return plainStringify(data);
+  try {
+    const normalised = JSON.parse(JSON.stringify(data));
+    const existing = JSON.parse(existingRaw);
+    if (!isRecord(normalised) || !isRecord(existing))
+      return plainStringify(data);
+    const spliced = reconcile(existingRaw, [], existing, normalised, detectFormatting(existingRaw));
+    if (isDeepStrictEqual(JSON.parse(spliced), normalised))
+      return spliced;
+    log.debug("json-source-splice", "splice does not read back as data; writing JSON.stringify");
+  } catch (err) {
+    log.debug("json-source-splice", "splice failed; writing JSON.stringify", {
+      error: getErrorMessage(err)
+    });
+  }
+  return plainStringify(data);
+}
+
 // dist/utils/markdown-body-splice.js
+init_error();
+
+// dist/utils/markdown-parse.js
 import { fromMarkdown } from "mdast-util-from-markdown";
 import { gfmFromMarkdown } from "mdast-util-gfm";
 import { mdxFromMarkdown } from "mdast-util-mdx";
 import { gfm } from "micromark-extension-gfm";
 import { mdxjs } from "micromark-extension-mdxjs";
 init_error();
+var log2 = createDebugLogger({ prefix: "MarkdownParse" });
+function parseMarkdownBody(text, format) {
+  try {
+    return format === "mdx" ? fromMarkdown(text, {
+      extensions: [gfm(), mdxjs()],
+      mdastExtensions: [gfmFromMarkdown(), mdxFromMarkdown()]
+    }) : fromMarkdown(text, { extensions: [gfm()], mdastExtensions: [gfmFromMarkdown()] });
+  } catch (err) {
+    log2.debug("markdown-parse", "body does not parse", { error: getErrorMessage(err) });
+    return void 0;
+  }
+}
 
 // dist/utils/markdown-export-options.js
 var MARKDOWN_EXPORT_OPTIONS = {
@@ -2236,7 +2349,7 @@ function restyleMarkdown(source, tree, fixed, readsBack) {
 }
 
 // dist/utils/yaml-source-splice.js
-import { isDeepStrictEqual } from "node:util";
+import { isDeepStrictEqual as isDeepStrictEqual2 } from "node:util";
 import { Document, parseDocument, isAlias, isCollection, isMap, isNode, isPair, isScalar, isSeq, YAMLMap, visit, YAMLSeq } from "yaml";
 var END = Symbol("end");
 var FRESH = Symbol("fresh");
@@ -2639,7 +2752,7 @@ function printsAs(candidate, reconciled, printed) {
   const reparsed = parseDocument(candidate);
   if (reparsed.errors.length > 0)
     return false;
-  if (!isDeepStrictEqual(reparsed.toJS(), reconciled.toJS()))
+  if (!isDeepStrictEqual2(reparsed.toJS(), reconciled.toJS()))
     return false;
   return layoutFree(reparsed.toString()) === layoutFree(parseDocument(printed).toString());
 }
@@ -2648,19 +2761,8 @@ function layoutFree(text) {
 }
 
 // dist/utils/markdown-body-splice.js
-var log = createDebugLogger({ prefix: "MarkdownBodySplice" });
+var log3 = createDebugLogger({ prefix: "MarkdownBodySplice" });
 var MAX_LCS_CELLS = 4e6;
-function parse(text, format) {
-  try {
-    return format === "mdx" ? fromMarkdown(text, {
-      extensions: [gfm(), mdxjs()],
-      mdastExtensions: [gfmFromMarkdown(), mdxFromMarkdown()]
-    }) : fromMarkdown(text, { extensions: [gfm()], mdastExtensions: [gfmFromMarkdown()] });
-  } catch (err) {
-    log.debug("markdown-body-splice", "body does not parse", { error: getErrorMessage(err) });
-    return void 0;
-  }
-}
 function canonical(node) {
   return JSON.stringify(node, (key, value) => {
     if (key === "position" || key === "data")
@@ -2941,7 +3043,7 @@ function preserveMarkdownSource(original, updated, format) {
   try {
     return splice(original, updated, format) ?? updated;
   } catch (err) {
-    log.debug("markdown-body-splice", "splice failed", { error: getErrorMessage(err) });
+    log3.debug("markdown-body-splice", "splice failed", { error: getErrorMessage(err) });
     return updated;
   }
 }
@@ -2966,14 +3068,14 @@ function diskBlocks(oNodes, nNodes) {
   return fromDisk;
 }
 function splice(original, updated, format) {
-  const before = original === void 0 ? void 0 : parse(original, format);
-  const after = parse(updated, format);
+  const before = original === void 0 ? void 0 : parseMarkdownBody(original, format);
+  const after = parseMarkdownBody(updated, format);
   if (after === void 0)
     return void 0;
   const target = canonical(after);
   const fromDisk = diskBlocks(before?.children ?? [], after.children);
   const restyled = restyleMarkdown(updated, after, (index) => fromDisk.has(index), (text) => {
-    const tree = parse(text, format);
+    const tree = parseMarkdownBody(text, format);
     return tree !== void 0 && canonical(tree) === target ? tree : void 0;
   });
   if (original === void 0 || before === void 0)
@@ -2985,10 +3087,10 @@ function splice(original, updated, format) {
       const candidate = new Splicer(original, edit.text, deep).body(before, edit.tree);
       if (candidate === void 0)
         continue;
-      const reparsed = parse(candidate, format);
+      const reparsed = parseMarkdownBody(candidate, format);
       if (reparsed !== void 0 && canonical(reparsed) === target)
         return candidate;
-      log.debug("markdown-body-splice", "splice does not read back as the edit", {
+      log3.debug("markdown-body-splice", "splice does not read back as the edit", {
         deep,
         restyled: edit !== asSent
       });
@@ -2998,7 +3100,7 @@ function splice(original, updated, format) {
 }
 
 // dist/utils/content-serialize.js
-var log2 = createDebugLogger({ prefix: "ContentSerialize" });
+var log4 = createDebugLogger({ prefix: "ContentSerialize" });
 function createNode(ctx, value, asKey = false) {
   const node = ctx.doc.createNode(value);
   const { quote } = ctx;
@@ -3242,9 +3344,9 @@ function reconcileYamlSource(raw, data, { rootAtColumnZero = false, quote } = {}
     if (spliced !== void 0 && !(rootAtColumnZero && /^\s*[ \t]\S/.test(spliced))) {
       return spliced;
     }
-    log2.debug("content-serialize", "source splice not used; writing as yaml prints it");
+    log4.debug("content-serialize", "source splice not used; writing as yaml prints it");
   } catch (err) {
-    log2.debug("content-serialize", "source splice failed; writing as yaml prints it", {
+    log4.debug("content-serialize", "source splice failed; writing as yaml prints it", {
       error: getErrorMessage(err)
     });
   }
@@ -3252,7 +3354,7 @@ function reconcileYamlSource(raw, data, { rootAtColumnZero = false, quote } = {}
 }
 function readsBackAs(text, doc) {
   const reparsed = parseDocument2(text);
-  return reparsed.errors.length === 0 && isDeepStrictEqual2(reparsed.toJS(), doc.toJS());
+  return reparsed.errors.length === 0 && isDeepStrictEqual3(reparsed.toJS(), doc.toJS());
 }
 function serializeYaml(data, existingRaw) {
   if (existingRaw === void 0)
@@ -3389,94 +3491,17 @@ function serializeFrontmatter(editorBody, data, existingRaw, format, fields = []
       }
     }
   });
-  if (isDeepStrictEqual2(frontmatterAsRead(written, fields), asJson(data)))
+  if (isDeepStrictEqual3(frontmatterAsRead(written, fields), asJson(data)))
     return written;
-  log2.debug("content-serialize", "reconciled frontmatter reads back differently; writing as gray-matter prints it");
+  log4.debug("content-serialize", "reconciled frontmatter reads back differently; writing as gray-matter prints it");
   return matter.stringify(file, data);
 }
-
-// dist/utils/json-source-splice.js
-import { isDeepStrictEqual as isDeepStrictEqual3 } from "node:util";
-import { applyEdits, modify } from "jsonc-parser";
-init_error();
-var log3 = createDebugLogger({ prefix: "JsonSourceSplice" });
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function plainStringify(data) {
-  return `${JSON.stringify(data, null, 2)}
-`;
-}
-function detectFormatting(text) {
-  const indent = /^([ \t]+)\S/m.exec(text)?.[1];
-  const eol = text.includes("\r\n") ? "\r\n" : "\n";
-  if (indent?.startsWith("	"))
-    return { insertSpaces: false, tabSize: 1, eol };
-  return { insertSpaces: true, tabSize: indent?.length ?? 2, eol };
-}
-function insertMember(text, path27, key, value, formattingOptions) {
-  const at = [...path27, key];
-  const [edit] = modify(text, at, value, {});
-  const closing = edit ? /^[ \t]*\r?\n([ \t]*)\}/.exec(text.slice(edit.offset)) : null;
-  if (edit && closing && edit.length === 0 && edit.content.startsWith(",")) {
-    const unit = formattingOptions.insertSpaces ? " ".repeat(formattingOptions.tabSize ?? 2) : "	";
-    const eol = formattingOptions.eol ?? "\n";
-    const indent = closing[1] + unit;
-    const rendered = JSON.stringify(value, null, unit).split("\n").join(eol + indent);
-    return applyEdits(text, [
-      { ...edit, content: `,${eol}${indent}${JSON.stringify(key)}: ${rendered}` }
-    ]);
-  }
-  return applyEdits(text, modify(text, at, value, { formattingOptions }));
-}
-function removeMember(text, path27) {
-  return applyEdits(text, modify(text, path27, void 0, {}).map((edit) => {
-    const removed = text.slice(edit.offset, edit.offset + edit.length);
-    const lead = /^\s+/.exec(removed)?.[0].length ?? 0;
-    const atMember = /\S/.test(text.charAt(edit.offset + edit.length));
-    return edit.content === "" && lead > 0 && atMember ? { ...edit, offset: edit.offset + lead, length: edit.length - lead } : edit;
-  }));
-}
-function reconcile(text, path27, before, after, formattingOptions) {
-  if (isRecord(before) && isRecord(after)) {
-    if (Object.keys(after).length === 0 && Object.keys(before).length > 0) {
-      return applyEdits(text, modify(text, path27, {}, { formattingOptions }));
-    }
-    let next = text;
-    for (const key of Object.keys(before)) {
-      if (!Object.prototype.hasOwnProperty.call(after, key))
-        next = removeMember(next, [...path27, key]);
-    }
-    for (const key of Object.keys(after)) {
-      next = Object.prototype.hasOwnProperty.call(before, key) ? reconcile(next, [...path27, key], before[key], after[key], formattingOptions) : insertMember(next, path27, key, after[key], formattingOptions);
-    }
-    return next;
-  }
-  if (Array.isArray(before) && Array.isArray(after) && before.length === after.length) {
-    return after.reduce((next, item, index) => reconcile(next, [...path27, index], before[index], item, formattingOptions), text);
-  }
-  if (JSON.stringify(before) === JSON.stringify(after))
-    return text;
-  return applyEdits(text, modify(text, path27, after, { formattingOptions }));
-}
-function serializeJson(data, existingRaw) {
-  if (existingRaw === void 0)
-    return plainStringify(data);
-  try {
-    const normalised = JSON.parse(JSON.stringify(data));
-    const existing = JSON.parse(existingRaw);
-    if (!isRecord(normalised) || !isRecord(existing))
-      return plainStringify(data);
-    const spliced = reconcile(existingRaw, [], existing, normalised, detectFormatting(existingRaw));
-    if (isDeepStrictEqual3(JSON.parse(spliced), normalised))
-      return spliced;
-    log3.debug("json-source-splice", "splice does not read back as data; writing JSON.stringify");
-  } catch (err) {
-    log3.debug("json-source-splice", "splice failed; writing JSON.stringify", {
-      error: getErrorMessage(err)
-    });
-  }
-  return plainStringify(data);
+function serializeEntry(entry, existingRaw, fields) {
+  if (entry.format === "json")
+    return serializeJson(entry.data, existingRaw);
+  if (entry.format === "yaml")
+    return serializeYaml(entry.data, existingRaw);
+  return serializeFrontmatter(entry.body, entry.data ?? {}, existingRaw, entry.format, fields);
 }
 
 // dist/utils/async-mutex.js
@@ -3922,8 +3947,8 @@ function computeEntryUrl(collection, slug, contentRoot) {
   if (slug && !isIndexSlug(slug)) {
     segments.push(slug);
   }
-  const path27 = segments.length > 0 ? `/${segments.join("/")}` : "/";
-  return path27.toLowerCase();
+  const path28 = segments.length > 0 ? `/${segments.join("/")}` : "/";
+  return path28.toLowerCase();
 }
 
 // dist/url-collision.js
@@ -4286,7 +4311,7 @@ function extractIdFromFilename(filename) {
 }
 async function resolveCollectionPath(root, logicalPath) {
   const fs22 = await import("node:fs/promises");
-  const path27 = await import("node:path");
+  const path28 = await import("node:path");
   const segments = logicalPath.split("/").filter(Boolean);
   let currentPath = root;
   for (const segment of segments) {
@@ -4299,7 +4324,7 @@ async function resolveCollectionPath(root, logicalPath) {
         return logicalName === segment.toLowerCase();
       });
       if (matchingDir) {
-        currentPath = path27.join(currentPath, matchingDir.name);
+        currentPath = path28.join(currentPath, matchingDir.name);
       } else {
         return null;
       }
@@ -4466,7 +4491,7 @@ import fs5 from "node:fs/promises";
 import path7 from "node:path";
 import { randomUUID } from "node:crypto";
 init_logger();
-var log4 = createDebugLogger({ prefix: "ResourceGeneration" });
+var log5 = createDebugLogger({ prefix: "ResourceGeneration" });
 var META_DIR2 = ".canopy-meta";
 function resourceGenerationPath(root, resource) {
   return path7.resolve(root, META_DIR2, `${resource}.generation`);
@@ -4490,7 +4515,7 @@ async function readResourceGeneration(root, resource) {
   } catch (err) {
     if (isNodeError(err) && err.code === "ENOENT")
       return { ok: true, token: null };
-    log4.warn("generation", `Failed to read ${resource} generation for ${root}`, {
+    log5.warn("generation", `Failed to read ${resource} generation for ${root}`, {
       error: getErrorMessage(err)
     });
     return { ok: false };
@@ -4858,7 +4883,7 @@ var STATIC_DEPLOY_USER = Object.freeze({
 // dist/utils/request-timing.js
 import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
 var storage = new AsyncLocalStorage2();
-var log5 = createDebugLogger({ prefix: "CanopyCMS" });
+var log6 = createDebugLogger({ prefix: "CanopyCMS" });
 async function timeRequestPhase(phase, fn) {
   const parent = storage.getStore();
   if (!parent)
@@ -5325,6 +5350,8 @@ var ContentStoreError = class extends Error {
     this.code = code;
   }
 };
+var RESTORE_SLUG_TAKEN_MESSAGE = "Another entry now has this entry's URL. Change that entry's URL, then restore this one.";
+var RESTORE_ID_TAKEN_MESSAGE = "This entry is already on the branch, so there is nothing to restore. Refresh to see where it is.";
 var ContentConflictError = class extends Error {
   constructor(message = "Content was modified by another editor") {
     super(message);
@@ -5387,13 +5414,13 @@ function entryRecord(parsed, emptyIsRecord) {
 }
 function fillEmptyTopLevelField(raw, format, field, value) {
   if (format === "json" || format === "yaml") {
-    const parse2 = (text) => format === "json" ? entryRecord(JSON.parse(text), false) : entryRecord(yamlParse(text), true);
-    const data = parse2(raw);
+    const parse = (text) => format === "json" ? entryRecord(JSON.parse(text), false) : entryRecord(yamlParse(text), true);
+    const data = parse(raw);
     if (!isEmptyFieldValue(data[field]))
       return void 0;
     const next = { ...data, [field]: value };
     const content2 = format === "json" ? serializeJson(next, raw) : serializeYaml(next, raw);
-    if (parse2(content2)[field] !== value)
+    if (parse(content2)[field] !== value)
       throw new Error(`"${field}" does not read back as written`);
     return content2;
   }
@@ -5583,11 +5610,11 @@ var ContentStore = class {
   getSchemaItems() {
     return this.schemaIndex.values();
   }
-  assertSchemaItem(path27) {
-    const normalized = normalizeFilesystemPath(path27);
+  assertSchemaItem(path28) {
+    const normalized = normalizeFilesystemPath(path28);
     const item = this.schemaIndex.get(normalized);
     if (!item) {
-      throw new ContentStoreError(`Unknown schema item: ${path27}`, "NO_SCHEMA_ITEM");
+      throw new ContentStoreError(`Unknown schema item: ${path28}`, "NO_SCHEMA_ITEM");
     }
     return item;
   }
@@ -5905,7 +5932,7 @@ var ContentStore = class {
     doc.version = stat.mtimeMs;
     return doc;
   }
-  async write(collectionPath, slug = "", input, entryTypeName, existingId) {
+  async write(collectionPath, slug = "", input, entryTypeName, existingId, options = {}) {
     await this.idIndex();
     const schemaItem = this.assertSchemaItem(collectionPath);
     let expectedFormat;
@@ -5993,14 +6020,7 @@ var ContentStore = class {
             }
           }
           const existingRaw = current?.content;
-          let content;
-          if (input.format === "json") {
-            content = serializeJson(input.data ?? {}, existingRaw);
-          } else if (input.format === "yaml") {
-            content = serializeYaml(input.data ?? {}, existingRaw);
-          } else {
-            content = serializeFrontmatter(input.body, input.data ?? {}, existingRaw, input.format, fields);
-          }
+          const content = serializeEntry(input, existingRaw, fields);
           await atomicWriteFile(absolutePath, content);
           const liveIndex = this._idIndex;
           let staleOldAbsPath = null;
@@ -6027,6 +6047,7 @@ var ContentStore = class {
             });
           }
           await this.recordOwnMutation(liveIndex);
+          await options.afterWrite?.({ id, relativePath });
           const afterStat = await fs9.stat(absolutePath);
           const base = {
             collection: schemaItem.logicalPath,
@@ -6179,14 +6200,21 @@ var ContentStore = class {
    */
   async afterPrePassForTesting() {
   }
-  /** Delete an entry and remove it from the index. */
-  async delete(collectionPath, slug) {
+  /**
+   * Delete an entry and remove it from the index. With `expectId`, only the entry of that content
+   * ID: another at the slug, or none, is `EntryGoneError`. `beforeDelete` runs under both of the
+   * delete's locks before anything changes, and throwing refuses; `afterDelete` runs once it is
+   * gone, under them too.
+   */
+  async delete(collectionPath, slug, options = {}) {
     await this.idIndex();
     const collection = this.assertCollection(collectionPath);
     const prePass = await this.buildPaths(collection, slug);
     if (prePass.existed)
       this.assertEntryTypeAvailable(collection, prePass.entryTypeName);
-    if (!prePass.existed) {
+    if (!prePass.existed || options.expectId !== void 0 && prePass.id !== options.expectId) {
+      if (options.expectId !== void 0)
+        throw new EntryGoneError();
       await fs9.unlink(prePass.absolutePath);
       return;
     }
@@ -6203,6 +6231,10 @@ var ContentStore = class {
             return RETRY_KEY;
           }
           const { absolutePath, relativePath } = inLock;
+          if (options.expectId !== void 0 && (!inLock.existed || inLock.id !== options.expectId)) {
+            throw new EntryGoneError();
+          }
+          await options.beforeDelete?.();
           await fs9.unlink(absolutePath);
           const liveIndex = this._idIndex;
           const id = liveIndex.findByPath(relativePath);
@@ -6210,6 +6242,7 @@ var ContentStore = class {
             liveIndex.remove(id);
           }
           await this.recordOwnMutation(liveIndex);
+          await options.afterDelete?.({ id: id ?? inLock.id });
           return void 0;
         });
         if (outcome !== RETRY_KEY)
@@ -6218,6 +6251,93 @@ var ContentStore = class {
       throw new ContentConflictError();
     });
   }
+  /**
+   * Puts back an entry deleted on this branch: `raw`, its file as the base holds it, verbatim,
+   * under its old slug, entry type and content ID, so references and comment threads find it
+   * again and the branch no longer differs from the base there.
+   *
+   * A create under write()'s locks and create-only guards that never replaces or relocates
+   * anything. It refuses with `ContentConflictError` while a file holds the slug, or the index
+   * or the target directory holds the ID: unlike write(), it has no index repair, so an ID
+   * found elsewhere is a moved entry, not a deleted one, and is left alone. The index is
+   * warmed outside the lock, as write() warms it, and rescanned under the lock only when the
+   * generation marker says another host changed the tree.
+   */
+  async restore(collectionPath, slug, entry, options = {}) {
+    await this.idIndex();
+    const collection = this.assertCollection(collectionPath);
+    if (!collection.entries?.some((e) => e.name === entry.entryTypeName)) {
+      throw new ContentStoreError(`Entry type '${entry.entryTypeName}' not found in collection`, "NO_SCHEMA_ITEM");
+    }
+    this.assertEntryTypeAvailable(collection, entry.entryTypeName);
+    return this.withContentWriteExclusion(async () => {
+      await options.beforeWrite?.();
+      if (await readContentIndexGeneration(this.root) !== this.loadedDiskGeneration) {
+        this.invalidateIndex();
+      }
+      await this.idIndex();
+      return withLock(this.createLockKey(collection, slug), async () => {
+        const target = await this.buildPaths(collection, slug, {
+          existingId: entry.id,
+          entryTypeName: entry.entryTypeName
+        });
+        const dir = path11.dirname(target.absolutePath);
+        const liveIndex = this._idIndex;
+        if (liveIndex.findById(entry.id) || liveIndex.getDuplicateFor(entry.id) || (await this.findEntryPathsById(dir, entry.id)).length > 0) {
+          throw new ContentConflictError(RESTORE_ID_TAKEN_MESSAGE);
+        }
+        if ((await this.buildPaths(collection, slug)).existed) {
+          throw new ContentConflictError(RESTORE_SLUG_TAKEN_MESSAGE);
+        }
+        const routable = parseSlug(target.slug);
+        if (!routable.ok) {
+          throw new ContentStoreError(`Cannot restore entry "${target.slug}": ${routable.error}.`, "VALIDATION");
+        }
+        await this.assertUrlPathAvailable(dir, target.slug);
+        await fs9.mkdir(dir, { recursive: true });
+        await atomicWriteFile(target.absolutePath, entry.raw);
+        const index = this._idIndex;
+        if (!index.findById(entry.id)) {
+          index.add({
+            type: "entry",
+            relativePath: target.relativePath,
+            collection: collectionPath,
+            slug
+          });
+        }
+        await this.recordOwnMutation(index);
+        await options.afterWrite?.();
+        return { relativePath: target.relativePath };
+      });
+    });
+  }
+  /**
+   * Replace the file of entry `id`, at `slug` in `collectionPath`, with `raw`, verbatim, under
+   * write()'s locks; `beforeWrite` runs under them first, and throwing refuses, and `afterWrite`
+   * after. For a file no parse can be trusted with, so nothing is re-serialised. `EntryGoneError`
+   * when no file of that id is there.
+   */
+  async replaceRaw(collectionPath, slug, entry, options = {}) {
+    await this.idIndex();
+    const collection = this.assertCollection(collectionPath);
+    const prePass = await this.buildPaths(collection, slug);
+    if (!prePass.existed || prePass.id !== entry.id)
+      throw new EntryGoneError();
+    this.assertEntryTypeAvailable(collection, prePass.entryTypeName);
+    const lockKey = this.entryLockKey(collection, slug, prePass);
+    return this.withContentWriteExclusion(() => withLock(lockKey, async () => {
+      const inLock = await this.buildPaths(collection, slug);
+      if (!inLock.existed || inLock.id !== entry.id)
+        throw new EntryGoneError();
+      if (this.entryLockKey(collection, slug, inLock) !== lockKey) {
+        throw new ContentConflictError();
+      }
+      await options.beforeWrite?.();
+      await atomicWriteFile(inLock.absolutePath, entry.raw);
+      await this.recordOwnMutation(this._idIndex);
+      await options.afterWrite?.();
+    }));
+  }
   /**
    * Rename an entry by changing its slug (middle segment of filename).
    * Entry filename pattern: {entryTypeName}.{slug}.{id}.{ext}
@@ -7178,7 +7298,7 @@ function yamlValue(value) {
 import path12 from "node:path";
 
 // dist/entry-link-resolver.js
-var log6 = createDebugLogger({ prefix: "EntryLinks" });
+var log7 = createDebugLogger({ prefix: "EntryLinks" });
 var BASE58_CHAR = "[123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz]";
 var ENTRY_LINK_PATTERN = new RegExp(`entry:(${BASE58_CHAR}{12})(#[^\\s)>"']*)?`, "g");
 function resolveEntryUrl(location, contentRoot) {
@@ -7194,7 +7314,7 @@ function resolveEntryLinksInText(text, idIndex, contentRoot, customResolver, opt
     return partText.replace(ENTRY_LINK_PATTERN, (_match, id, anchor) => {
       const location = findEntry(idIndex, id);
       if (!location) {
-        log6.warn("resolve", `Entry link target not found: entry:${id}`);
+        log7.warn("resolve", `Entry link target not found: entry:${id}`);
         return isLinkable ? "#" : anchor ?? "#";
       }
       if (isLinkable && !isLinkable(id))
@@ -7930,6 +8050,14 @@ var branchMetadataShape = {
     state: z7.enum(["approved", "changes-requested"]),
     by: z7.object({ userId: z7.string(), name: z7.string().optional() }),
     at: z7.string()
+  }).optional().catch(void 0),
+  baseUpdateRequestedAt: z7.string().optional().catch(void 0),
+  // Dropped when malformed: it only ends the editor's wait, which then times out instead.
+  lastBaseUpdate: z7.object({
+    at: z7.string(),
+    outcome: z7.enum(["merged", "up-to-date", "conflicts", "failed"]),
+    baseSha: z7.string().optional(),
+    keptEntries: z7.number().int().nonnegative().optional()
   }).optional().catch(void 0)
 };
 var branchMetadataSchema = z7.object(branchMetadataShape).passthrough();
@@ -7985,7 +8113,7 @@ function parseBranchMetadataFile(branchRoot, raw) {
 // dist/branch-registry.js
 init_error();
 init_logger();
-var log7 = createDebugLogger({ prefix: "BranchRegistry" });
+var log8 = createDebugLogger({ prefix: "BranchRegistry" });
 var REGISTRY_FILE = "branches.json";
 var REGISTRY_STALE_FILE = "branches.stale.json";
 var REGISTRY_TEMP_FILE = "branches.tmp.json";
@@ -8111,7 +8239,7 @@ var BranchRegistry = class {
         });
       await this.regenerate();
     } catch (err) {
-      log7.warn("invalidate", "Eager regeneration after invalidate() failed", {
+      log8.warn("invalidate", "Eager regeneration after invalidate() failed", {
         error: getErrorMessage(err)
       });
     }
@@ -8207,7 +8335,7 @@ import path16 from "node:path";
 import { randomUUID as randomUUID2 } from "node:crypto";
 import lockfile2 from "proper-lockfile";
 init_logger();
-var log8 = createDebugLogger({ prefix: "OccJsonWrite" });
+var log9 = createDebugLogger({ prefix: "OccJsonWrite" });
 var OccWriteConflictError = class extends Error {
   constructor(message = "Concurrent modification detected") {
     super(message);
@@ -8325,7 +8453,7 @@ async function withOccFileLock(filePath, fn) {
     await release().catch((err) => {
       if (isNodeError(err) && err.code === "ENOENT")
         return;
-      log8.warn("lock", `Failed to release lock for ${filePath}`, { error: getErrorMessage(err) });
+      log9.warn("lock", `Failed to release lock for ${filePath}`, { error: getErrorMessage(err) });
     });
   }
 }
@@ -8778,7 +8906,7 @@ function feedStdin(child, source, touch, onSourceError) {
 }
 
 // dist/git-manager.js
-var log9 = createDebugLogger({ prefix: "GitManager" });
+var log10 = createDebugLogger({ prefix: "GitManager" });
 var GIT_ENV_PASSTHROUGH = /^(PATH|HOME|USER|LANG|LC_[A-Z]+|TZ|TMPDIR|GIT_(AUTHOR|COMMITTER)_(NAME|EMAIL|DATE)|GIT_TERMINAL_PROMPT|GIT_TRACE[0-9A-Z_]*)$/;
 var FORCE_C_LOCALE = { LC_ALL: "C", LANG: "C" };
 function gitChildEnv(overrides) {
@@ -8900,13 +9028,13 @@ async function ensureGitExcludePattern(repoPath, pattern) {
   }
   const lines = content.split("\n");
   if (lines.some((line) => line.trim() === pattern)) {
-    log9.debug("git", "Pattern already in .git/info/exclude", { pattern });
+    log10.debug("git", "Pattern already in .git/info/exclude", { pattern });
     return;
   }
   const needsLeadingNewline = content.length > 0 && !content.endsWith("\n");
   const newContent = content + (needsLeadingNewline ? "\n" : "") + pattern + "\n";
   await fs16.writeFile(excludePath, newContent, "utf-8");
-  log9.debug("git", "Added pattern to .git/info/exclude", { pattern });
+  log10.debug("git", "Added pattern to .git/info/exclude", { pattern });
 }
 var BaseBranchMissingError = class extends Error {
   constructor(remote, baseBranch) {
@@ -8992,7 +9120,7 @@ var GitManager = class _GitManager {
    * target that held files beforehand is never touched.
    */
   static async cloneRepo(remoteUrl, targetPath, baseBranch = "main", options = {}) {
-    log9.debug("git", "Cloning repository", {
+    log10.debug("git", "Cloning repository", {
       remoteUrl,
       targetPath,
       baseBranch
@@ -9024,7 +9152,7 @@ var GitManager = class _GitManager {
         await fs16.mkdir(targetPath);
       await git.clone(remoteUrl, targetPath, args);
     }
-    log9.debug("git", "Clone complete");
+    log10.debug("git", "Clone complete");
   }
   /**
    * Initializes a local bare git repository to simulate a remote for dev mode,
@@ -9038,15 +9166,15 @@ var GitManager = class _GitManager {
   static async ensureLocalSimulatedRemote(options) {
     const existingLock = remoteInitLocks.get(options.remotePath);
     if (existingLock) {
-      log9.debug("git", "Waiting for existing remote initialization", {
+      log10.debug("git", "Waiting for existing remote initialization", {
         remotePath: options.remotePath
       });
       await existingLock;
     }
-    const lockPromise = log9.timed("git", "ensureLocalSimulatedRemote", async () => {
+    const lockPromise = log10.timed("git", "ensureLocalSimulatedRemote", async () => {
       let releaseLock;
       try {
-        log9.debug("git", "Initializing local simulated remote", {
+        log10.debug("git", "Initializing local simulated remote", {
           remotePath: options.remotePath,
           baseBranch: options.baseBranch
         });
@@ -9064,15 +9192,15 @@ var GitManager = class _GitManager {
           try {
             const repack = await repackBareRemoteIfNeeded(options.remotePath);
             if (repack.repacked)
-              log9.debug("git", "Repacked local simulated remote", repack);
+              log10.debug("git", "Repacked local simulated remote", repack);
           } catch (err) {
-            log9.debug("git", "Could not repack local simulated remote", {
+            log10.debug("git", "Could not repack local simulated remote", {
               error: getErrorMessage(err)
             });
           }
         }
         if (remoteExists && await _GitManager.bareRemoteHasBranch(options.remotePath, options.baseBranch)) {
-          log9.debug("git", "Remote already has base branch, skipping");
+          log10.debug("git", "Remote already has base branch, skipping");
           await ensureRemoteGitConfig(options.remotePath);
           return;
         }
@@ -9092,8 +9220,8 @@ var GitManager = class _GitManager {
         }
         let hasCommits = false;
         try {
-          const log11 = await sourceGit.log(["-1"]);
-          hasCommits = log11.total > 0;
+          const log12 = await sourceGit.log(["-1"]);
+          hasCommits = log12.total > 0;
         } catch {
           hasCommits = false;
         }
@@ -9105,12 +9233,12 @@ var GitManager = class _GitManager {
           throw new Error(`Cannot initialize local simulated remote: base branch '${options.baseBranch}' does not exist locally. Please checkout '${options.baseBranch}' first or provide an explicit remoteUrl.`);
         }
         if (remoteExists) {
-          log9.debug("git", "Existing remote is missing base branch \u2014 pushing it from source", {
+          log10.debug("git", "Existing remote is missing base branch \u2014 pushing it from source", {
             remotePath: options.remotePath,
             baseBranch: options.baseBranch
           });
         } else {
-          log9.debug("git", "Creating bare remote repository");
+          log10.debug("git", "Creating bare remote repository");
           await simpleGit2().raw([
             "init",
             "--bare",
@@ -9125,13 +9253,13 @@ var GitManager = class _GitManager {
           baseBranch: options.baseBranch,
           subdirectory: options.subdirectory
         });
-        log9.debug("git", "Remote initialization complete");
+        log10.debug("git", "Remote initialization complete");
       } finally {
         if (releaseLock) {
           try {
             await releaseLock();
           } catch (err) {
-            log9.debug("git", "Failed to release remote-init lock", { err });
+            log10.debug("git", "Failed to release remote-init lock", { err });
           }
         }
         remoteInitLocks.delete(options.remotePath);
@@ -9413,7 +9541,7 @@ var GitManager = class _GitManager {
         throw new Error(`CanopyCMS: cannot read the git remote at ${remotePath}: ${getErrorMessage(err)}`);
       });
       if (stat?.isDirectory()) {
-        log9.debug("git", "Auto-detected local remote", { path: remotePath });
+        log10.debug("git", "Auto-detected local remote", { path: remotePath });
         return remotePath;
       }
       if (stat) {
@@ -9539,7 +9667,7 @@ var GitManager = class _GitManager {
       try {
         const stat = await fs16.stat(gitPath);
         if (stat.isDirectory()) {
-          log9.debug("git", "Removing corrupt .git directory", {
+          log10.debug("git", "Removing corrupt .git directory", {
             workspacePath: options.workspacePath
           });
           await fs16.rm(gitPath, { recursive: true });
@@ -10005,17 +10133,17 @@ var GitManager = class _GitManager {
     const changes = [];
     for (let i = 0; i + 1 < tokens.length; i += 2) {
       const [srcMode, dstMode, srcSha, dstSha, code] = tokens[i].slice(1).split(" ");
-      const path27 = tokens[i + 1];
+      const path28 = tokens[i + 1];
       const letter = code?.charAt(0);
       if (letter === "A" || letter === "D")
-        changes.push({ status: letter, path: path27 });
+        changes.push({ status: letter, path: path28 });
       else if (letter === "M" || letter === "T") {
         const unhashed = /^0+$/.test(dstSha) && srcMode === dstMode ? srcSha : void 0;
-        changes.push({ status: "M", path: path27, unhashed });
+        changes.push({ status: "M", path: path28, unhashed });
       }
     }
     const unchanged = await this.matchingBlobs(changes.flatMap((c) => c.unhashed ? [{ path: c.path, sha: c.unhashed }] : []));
-    return changes.filter((c) => !unchanged.has(c.path)).map(({ status, path: path27 }) => ({ status, path: path27 }));
+    return changes.filter((c) => !unchanged.has(c.path)).map(({ status, path: path28 }) => ({ status, path: path28 }));
   }
   /**
    * The paths whose working-tree file hashes to `sha`, as git hashes it: a symlink's blob is its
@@ -10110,6 +10238,32 @@ var GitManager = class _GitManager {
       throw err;
     }
   }
+  /**
+   * The text of the blob `sha`, `'too-large'` when it is over `maxBytes`, or `undefined` when this
+   * clone has no such blob. Any other failure throws.
+   */
+  async readBlob(sha, maxBytes) {
+    if (!/^(?:[0-9a-f]{40}|[0-9a-f]{64})$/.test(sha))
+      return void 0;
+    let sizeText;
+    try {
+      sizeText = (await this.git.raw(["cat-file", "-s", "--end-of-options", sha])).trim();
+    } catch (err) {
+      if (/could not get object info|Not a valid object name/.test(getErrorMessage(err))) {
+        return void 0;
+      }
+      throw err;
+    }
+    if (!/^\d+$/.test(sizeText))
+      throw new Error(`git cat-file -s ${sha} printed no size`);
+    const size = Number(sizeText);
+    if (size > maxBytes)
+      return "too-large";
+    const text = await this.git.raw(["cat-file", "blob", "--end-of-options", sha]);
+    if (size > 0 && text === "")
+      throw new Error(`git cat-file blob ${sha} printed nothing`);
+    return text;
+  }
   async ensureAuthor(author) {
     const config = await this.git.listConfig();
     const isManaged = config.all["canopycms.managed"] === "true";
@@ -10198,7 +10352,7 @@ var GitManager = class _GitManager {
     }
   }
   async createOrphanSettingsBranchInner(branchName, initialFiles) {
-    log9.debug("git", "Ensuring settings branch", { branchName });
+    log10.debug("git", "Ensuring settings branch", { branchName });
     const branches = await this.git.branch();
     const localExists = branches.all.includes(branchName);
     if (localExists) {
@@ -10209,7 +10363,7 @@ var GitManager = class _GitManager {
       remoteTip = await this.remoteBranchTip(branchName);
     } catch (err) {
       if (localExists && !await this.isEmptyInitialBranch(branchName)) {
-        log9.debug("git", "Remote unreadable; serving the local settings branch", { branchName });
+        log10.debug("git", "Remote unreadable; serving the local settings branch", { branchName });
         return;
       }
       throw new SettingsRemoteUnreadableError(branchName, this.remote, err);
@@ -10222,7 +10376,7 @@ var GitManager = class _GitManager {
       const fetchedTip = await this.fetchBranchTip(branchName);
       await this.assertNotContentHistory(branchName, fetchedTip);
       await this.git.raw(["checkout", "-b", branchName, fetchedTip]);
-      log9.debug("git", "Checked out the remote settings branch", { branchName });
+      log10.debug("git", "Checked out the remote settings branch", { branchName });
       return;
     }
     await this.git.raw(["switch", "--orphan", branchName]);
@@ -10238,7 +10392,7 @@ var GitManager = class _GitManager {
       await this.git.add(filePath);
     }
     await this.git.commit("Initialize settings branch", ["--allow-empty"]);
-    log9.debug("git", "Orphan settings branch created", { branchName });
+    log10.debug("git", "Orphan settings branch created", { branchName });
   }
   /**
    * Compares the checked-out local settings branch with the remote's tip.
@@ -10271,7 +10425,7 @@ var GitManager = class _GitManager {
     }
     await this.assertNotContentHistory(branchName, fetchedTip);
     await this.git.raw(["checkout", "-B", branchName, fetchedTip]);
-    log9.debug("git", "Replaced an empty settings branch with the remote one", { branchName });
+    log10.debug("git", "Replaced an empty settings branch with the remote one", { branchName });
   }
   /**
    * The remote's tip for `branch`, or `undefined` when the remote has no such
@@ -10541,10 +10695,10 @@ async function hasBranchMetadata(branchRoot) {
   return fs17.access(path21.join(branchRoot, BRANCH_META_DIR, BRANCH_META_FILE)).then(() => true, () => false);
 }
 async function stageBranchWorkspace(options) {
-  const { provisionLog: log11 } = options;
+  const { provisionLog: log12 } = options;
   const stagingPath = path21.join(options.baseRoot, stagingDirName(options.dirName));
   try {
-    await log11.step("clone", () => GitManager.cloneWorkspace(options.remoteUrl, stagingPath, options.baseBranch, {
+    await log12.step("clone", () => GitManager.cloneWorkspace(options.remoteUrl, stagingPath, options.baseBranch, {
       ...options.clone,
       noCheckout: true
     }));
@@ -10555,14 +10709,14 @@ async function stageBranchWorkspace(options) {
     });
     const cone = options.sparseCone;
     if (cone)
-      await log11.step("sparse", () => git.setSparseCone(cone));
+      await log12.step("sparse", () => git.setSparseCone(cone));
     if (await hasBranchMetadata(path21.join(options.baseRoot, options.dirName))) {
       await removeLeftoverDir(stagingPath);
       return { kind: "exists" };
     }
-    await log11.step("checkout", () => git.checkoutFreshClone(options.branchName));
-    await log11.step("exclude", () => git.ensureGitExclude(options.gitExcludePattern));
-    const written = await log11.step("metadata", () => writeOccJsonFile(path21.join(stagingPath, BRANCH_META_DIR, BRANCH_META_FILE), { ...options.metadata }, { expectedVersion: null, trailingNewline: true }));
+    await log12.step("checkout", () => git.checkoutFreshClone(options.branchName));
+    await log12.step("exclude", () => git.ensureGitExclude(options.gitExcludePattern));
+    const written = await log12.step("metadata", () => writeOccJsonFile(path21.join(stagingPath, BRANCH_META_DIR, BRANCH_META_FILE), { ...options.metadata }, { expectedVersion: null, trailingNewline: true }));
     return {
       kind: "staged",
       stagingPath,
@@ -11034,7 +11188,7 @@ import path24 from "node:path";
 import matter3 from "gray-matter";
 import { parse as yamlParse2 } from "yaml";
 init_error();
-var log10 = createDebugLogger({ prefix: "ContentListing" });
+var log11 = createDebugLogger({ prefix: "ContentListing" });
 var normalizePath = (root, target) => {
   const result = validateAndNormalizePath(root, target);
   if (!result.valid) {
@@ -11062,7 +11216,7 @@ var readEntryData = async (filePath, format, bodyFieldName = "body") => {
   } catch (err) {
     if (isNotFoundError(err))
       return {};
-    log10.warn("readEntryData", `Failed to read entry data from ${filePath}: ${getErrorMessage(err)}`);
+    log11.warn("readEntryData", `Failed to read entry data from ${filePath}: ${getErrorMessage(err)}`);
     return {};
   }
 };
@@ -11188,7 +11342,7 @@ var listCollectionEntries = async (root, collection, onSkip, readsId) => {
     const relativePath = normalizePath(root, absolutePath);
     const parsed = parseTypedFilename(file.name, entryTypes);
     if (!parsed) {
-      log10.warn("listCollectionEntries", `Skipping file with unrecognized filename format: ${file.name} (expected {type}.{slug}.{id}.{ext} with a known entry type and valid 12-char Base58 ID)`);
+      log11.warn("listCollectionEntries", `Skipping file with unrecognized filename format: ${file.name} (expected {type}.{slug}.{id}.{ext} with a known entry type and valid 12-char Base58 ID)`);
       if (looksLikeMalformedEntry(file.name, entryTypes)) {
         onSkip?.({ filename: file.name, collectionPath: collection.logicalPath });
       }
@@ -11277,77 +11431,77 @@ function isValidImageCropValue(value) {
   const rounded = roundCropRect({ x, y, w, h });
   return isValidCropRect(rounded.x, rounded.y, rounded.w, rounded.h);
 }
-function validateImageValue(field, value, path27) {
+function validateImageValue(field, value, path28) {
   if (!isPlainRecord3(value)) {
-    return [{ fieldPath: path27, message: "Expected an image object with { src, alt }" }];
+    return [{ fieldPath: path28, message: "Expected an image object with { src, alt }" }];
   }
   const errors = [];
   if (typeof value.src !== "string" || value.src.trim() === "") {
-    errors.push({ fieldPath: `${path27}.src`, message: "Image src is required" });
+    errors.push({ fieldPath: `${path28}.src`, message: "Image src is required" });
   }
   if (typeof value.alt !== "string") {
-    errors.push({ fieldPath: `${path27}.alt`, message: "Image alt text is required" });
+    errors.push({ fieldPath: `${path28}.alt`, message: "Image alt text is required" });
   } else if (value.alt.trim() === "" && field.altOptional !== true) {
-    errors.push({ fieldPath: `${path27}.alt`, message: "Image alt text is required" });
+    errors.push({ fieldPath: `${path28}.alt`, message: "Image alt text is required" });
   }
   if (value.width !== void 0 && !isPositiveInt(value.width)) {
-    errors.push({ fieldPath: `${path27}.width`, message: "Image width must be a positive integer" });
+    errors.push({ fieldPath: `${path28}.width`, message: "Image width must be a positive integer" });
   }
   if (value.height !== void 0 && !isPositiveInt(value.height)) {
     errors.push({
-      fieldPath: `${path27}.height`,
+      fieldPath: `${path28}.height`,
       message: "Image height must be a positive integer"
     });
   }
   if (value.crop !== void 0 && !isValidImageCropValue(value.crop)) {
-    errors.push({ fieldPath: `${path27}.crop`, message: "Invalid image crop rect" });
+    errors.push({ fieldPath: `${path28}.crop`, message: "Invalid image crop rect" });
   }
   return errors;
 }
 var selectOptionValues = (field) => (field.options ?? []).map((opt) => typeof opt === "string" ? opt : opt.value);
-function validateScalar(field, value, path27) {
+function validateScalar(field, value, path28) {
   switch (field.type) {
     case "number":
       if (typeof value !== "number" || !Number.isFinite(value)) {
-        return [{ fieldPath: path27, message: "Expected a number" }];
+        return [{ fieldPath: path28, message: "Expected a number" }];
       }
       return [];
     case "boolean":
       if (typeof value !== "boolean") {
-        return [{ fieldPath: path27, message: "Expected true or false" }];
+        return [{ fieldPath: path28, message: "Expected true or false" }];
       }
       return [];
     case "date":
       if (value !== "" && !isCalendarDay(value)) {
-        return [{ fieldPath: path27, message: "Expected a real date, written YYYY-MM-DD" }];
+        return [{ fieldPath: path28, message: "Expected a real date, written YYYY-MM-DD" }];
       }
       return [];
     case "datetime":
       if (typeof value !== "string" || value !== "" && Number.isNaN(Date.parse(value))) {
-        return [{ fieldPath: path27, message: "Expected a valid date/time string" }];
+        return [{ fieldPath: path28, message: "Expected a valid date/time string" }];
       }
       return [];
     case "select": {
       if (typeof value !== "string") {
-        return [{ fieldPath: path27, message: "Expected a selection" }];
+        return [{ fieldPath: path28, message: "Expected a selection" }];
       }
       const options = selectOptionValues(field);
       if (value !== "" && !options.includes(value)) {
-        return [{ fieldPath: path27, message: `Must be one of: ${options.join(", ")}` }];
+        return [{ fieldPath: path28, message: `Must be one of: ${options.join(", ")}` }];
       }
       return [];
     }
     case "reference":
       if (referenceValueId(value) === void 0) {
-        return [{ fieldPath: path27, message: "Expected a reference id" }];
+        return [{ fieldPath: path28, message: "Expected a reference id" }];
       }
       return [];
     case "image":
-      return validateImageValue(field, value, path27);
+      return validateImageValue(field, value, path28);
     default:
       if (STRING_FIELD_TYPES.has(field.type)) {
         if (typeof value !== "string") {
-          return [{ fieldPath: path27, message: "Expected text" }];
+          return [{ fieldPath: path28, message: "Expected text" }];
         }
       }
       return [];
@@ -11370,12 +11524,12 @@ function validateEntryData(fields, data, pathPrefix = "", options = {}) {
       errors.push(...validateEntryData(field.fields, data, pathPrefix, options));
       continue;
     }
-    const path27 = pathPrefix ? `${pathPrefix}.${field.name}` : field.name;
+    const path28 = pathPrefix ? `${pathPrefix}.${field.name}` : field.name;
     const value = data[field.name];
     const isRequired = options.required !== false && "required" in field && field.required === true;
     if (isRequired && isEmptyForRequired(field, value)) {
       const message = Array.isArray(value) ? "At least one item is required" : "This field is required";
-      errors.push({ fieldPath: path27, message });
+      errors.push({ fieldPath: path28, message });
       continue;
     }
     if (value === void 0 || value === null)
@@ -11383,7 +11537,7 @@ function validateEntryData(fields, data, pathPrefix = "", options = {}) {
     if (Array.isArray(value) && "maxItems" in field && typeof field.maxItems === "number" && value.length > field.maxItems) {
       const cap = field.maxItems;
       errors.push({
-        fieldPath: path27,
+        fieldPath: path28,
         message: `At most ${cap} ${cap === 1 ? "item" : "items"}; this list has ${value.length}`,
         maxItems: { count: value.length, cap }
       });
@@ -11391,11 +11545,11 @@ function validateEntryData(fields, data, pathPrefix = "", options = {}) {
     if (field.type === "block") {
       const blockField = field;
       if (!Array.isArray(value)) {
-        errors.push({ fieldPath: path27, message: "Expected a list of blocks" });
+        errors.push({ fieldPath: path28, message: "Expected a list of blocks" });
         continue;
       }
       value.forEach((item, index) => {
-        const itemPath = `${path27}[${index}]`;
+        const itemPath = `${path28}[${index}]`;
         if (!isPlainRecord3(item)) {
           errors.push({ fieldPath: itemPath, message: "Expected a block object" });
           return;
@@ -11417,11 +11571,11 @@ function validateEntryData(fields, data, pathPrefix = "", options = {}) {
       const objectField = field;
       if (objectField.list) {
         if (!Array.isArray(value)) {
-          errors.push({ fieldPath: path27, message: "Expected a list of items" });
+          errors.push({ fieldPath: path28, message: "Expected a list of items" });
           continue;
         }
         value.forEach((item, index) => {
-          const itemPath = `${path27}[${index}]`;
+          const itemPath = `${path28}[${index}]`;
           if (!isPlainRecord3(item)) {
             errors.push({ fieldPath: itemPath, message: "Expected an object" });
             return;
@@ -11431,27 +11585,27 @@ function validateEntryData(fields, data, pathPrefix = "", options = {}) {
           }
         });
       } else if (!isPlainRecord3(value)) {
-        errors.push({ fieldPath: path27, message: "Expected an object" });
+        errors.push({ fieldPath: path28, message: "Expected an object" });
       } else if (objectField.fields) {
-        errors.push(...validateEntryData(objectField.fields, value, path27, options));
+        errors.push(...validateEntryData(objectField.fields, value, path28, options));
       }
       continue;
     }
     if ("list" in field && field.list) {
       if (!Array.isArray(value)) {
-        errors.push({ fieldPath: path27, message: "Expected a list of values" });
+        errors.push({ fieldPath: path28, message: "Expected a list of values" });
         continue;
       }
       value.forEach((item, index) => {
-        errors.push(...validateScalar(field, item, `${path27}[${index}]`));
+        errors.push(...validateScalar(field, item, `${path28}[${index}]`));
       });
       continue;
     }
     if (Array.isArray(value) && KNOWN_FIELD_TYPES.has(field.type)) {
-      errors.push({ fieldPath: path27, message: "Expected a single value, not a list" });
+      errors.push({ fieldPath: path28, message: "Expected a single value, not a list" });
       continue;
     }
-    errors.push(...validateScalar(field, value, path27));
+    errors.push(...validateScalar(field, value, path28));
   }
   return errors;
 }
@@ -11653,33 +11807,50 @@ ${cached.issues.map((issue) => `  - ${issue.message}`).join("\n")}`);
 
 // dist/cli/generate-ai-content.js
 init_error();
+
+// dist/cli/site-config.js
+import path26 from "node:path";
+import { createJiti } from "jiti";
 var jiti = createJiti(import.meta.url);
+async function importSiteModule(filePath) {
+  return await jiti.import(filePath);
+}
+async function importSiteServerConfig(projectDir) {
+  const configPath = path26.join(projectDir, "canopycms.config.ts");
+  const mod = await importSiteModule(configPath);
+  const configExport = mod.default ?? mod.config ?? mod;
+  const server = typeof configExport === "object" && configExport !== null && "server" in configExport ? configExport.server : configExport;
+  return { configPath, server };
+}
+async function importSiteEntrySchemaRegistry(projectDir, appDir) {
+  const schemasPath = path26.join(projectDir, appDir, "schemas.ts");
+  const mod = await importSiteModule(schemasPath);
+  const registry2 = mod.entrySchemaRegistry ?? mod;
+  return { schemasPath, registry: registry2 };
+}
+
+// dist/cli/generate-ai-content.js
 async function generateAIContentCLI(options) {
   const { projectDir, outputDir = "public/ai", configPath, appDir = "app" } = options;
   console.log("\nCanopyCMS generate-ai-content\n");
-  const canopyConfigPath = path26.join(projectDir, "canopycms.config.ts");
-  let canopyConfigModule;
+  let serverConfig;
   try {
-    canopyConfigModule = await jiti.import(canopyConfigPath);
+    serverConfig = (await importSiteServerConfig(projectDir)).server;
   } catch (err) {
-    console.error(`Could not load config from ${canopyConfigPath}`);
+    console.error(`Could not load config from ${path27.join(projectDir, "canopycms.config.ts")}`);
     console.error(getErrorMessage(err));
     process.exit(1);
   }
-  const configExport = canopyConfigModule.default ?? canopyConfigModule.config ?? canopyConfigModule;
-  const serverConfig = typeof configExport === "object" && configExport !== null && "server" in configExport ? configExport.server : configExport;
-  const schemasPath = path26.join(projectDir, appDir, "schemas.ts");
   let entrySchemaRegistry = {};
   try {
-    const schemasModule = await jiti.import(schemasPath);
-    entrySchemaRegistry = schemasModule.entrySchemaRegistry ?? schemasModule;
+    entrySchemaRegistry = (await importSiteEntrySchemaRegistry(projectDir, appDir)).registry;
   } catch {
     console.warn(`  No ${appDir}/schemas.ts found, using empty entry schema registry`);
   }
   let aiConfig;
   if (configPath) {
     try {
-      const aiConfigModule = await jiti.import(path26.resolve(configPath));
+      const aiConfigModule = await importSiteModule(path27.resolve(configPath));
       aiConfig = aiConfigModule.aiContentConfig ?? aiConfigModule.default ?? aiConfigModule.config;
     } catch (err) {
       console.error(`Could not load AI config from ${configPath}`);
@@ -11696,7 +11867,7 @@ async function generateAIContentCLI(options) {
     console.error("Make sure canopycms.config.ts uses defineCanopyConfig().");
     process.exit(1);
   }
-  const resolvedOutput = path26.resolve(projectDir, outputDir);
+  const resolvedOutput = path27.resolve(projectDir, outputDir);
   console.log(`  Output: ${resolvedOutput}`);
   console.log(`  Mode: ${serverConfig.mode ?? "dev"}`);
   const result = await generateAIContentFiles({