canopycms 0.0.61 → 0.0.63

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

@@ -9,11 +9,11 @@ var __export = (target, all) => {
 };
 
 // dist/paths/normalize.js
-function normalizeFilesystemPath(path19) {
-  return path19.split(/[\\/]+/).filter(Boolean).join("/");
+function normalizeFilesystemPath(path20) {
+  return path20.split(/[\\/]+/).filter(Boolean).join("/");
 }
-function hasTraversalSequence(path19) {
-  const normalized = normalizeFilesystemPath(path19);
+function hasTraversalSequence(path20) {
+  const normalized = normalizeFilesystemPath(path20);
   return normalized.includes("..");
 }
 function createLogicalPath(...segments) {
@@ -23,14 +23,14 @@ function createLogicalPath(...segments) {
   }
   return normalized;
 }
-function trimSlashes(path19) {
+function trimSlashes(path20) {
   let start = 0;
-  let end = path19.length;
-  while (start < end && path19[start] === "/")
+  let end = path20.length;
+  while (start < end && path20[start] === "/")
     start++;
-  while (end > start && path19[end - 1] === "/")
+  while (end > start && path20[end - 1] === "/")
     end--;
-  return path19.slice(start, end);
+  return path20.slice(start, end);
 }
 var init_normalize = __esm({
   "dist/paths/normalize.js"() {
@@ -175,7 +175,6 @@ var init_types2 = __esm({
       "number",
       "boolean",
       "datetime",
-      "rich-text",
       "markdown",
       "mdx",
       "code"
@@ -446,6 +445,40 @@ var init_config = __esm({
   }
 });
 
+// dist/operating-mode/mode-env.js
+function readModeEnv() {
+  if (typeof process === "undefined" || typeof process.env === "undefined")
+    return void 0;
+  const inBrowser = typeof window !== "undefined";
+  const name = inBrowser ? BROWSER_MODE_ENV_VAR : SERVER_MODE_ENV_VAR;
+  const raw = inBrowser ? process.env.NEXT_PUBLIC_CANOPY_MODE : process.env.CANOPY_MODE;
+  const value = raw?.trim();
+  return value ? { name, value } : void 0;
+}
+function resolveOperatingMode(configMode) {
+  const env = readModeEnv();
+  if (!env)
+    return configMode;
+  if (env.value !== "prod" && env.value !== "dev") {
+    throw new Error(`CanopyCMS: invalid ${env.name}=${JSON.stringify(env.value)}. It must be exactly "prod" or "dev". Refusing to fall back to the configured mode (${JSON.stringify(configMode)}): a typo here would silently deploy dev auth semantics.`);
+  }
+  if (env.value !== configMode && !warned) {
+    canopyLogWarn(`CanopyCMS: ${env.name}="${env.value}" overrides config.mode="${configMode}". The environment wins by design \u2014 it is the per-deployment value, while canopycms.config.ts is shared by local dev, the image build and the deployment. See operating-mode/mode-env.ts.`);
+    warned = true;
+  }
+  return env.value;
+}
+var SERVER_MODE_ENV_VAR, BROWSER_MODE_ENV_VAR, warned;
+var init_mode_env = __esm({
+  "dist/operating-mode/mode-env.js"() {
+    "use strict";
+    init_logger();
+    SERVER_MODE_ENV_VAR = "CANOPY_MODE";
+    BROWSER_MODE_ENV_VAR = "NEXT_PUBLIC_CANOPY_MODE";
+    warned = false;
+  }
+});
+
 // dist/config/validation.js
 var forEachReferenceField;
 var init_validation = __esm({
@@ -453,6 +486,7 @@ var init_validation = __esm({
     "use strict";
     init_config();
     init_flatten();
+    init_mode_env();
     forEachReferenceField = (fields, visit) => {
       if (!Array.isArray(fields))
         return;
@@ -572,9 +606,9 @@ var init_client_safe_strategy = __esm({
 function resolveDeploymentName(config, modeDefault) {
   const envValue = process.env.CANOPYCMS_DEPLOYMENT_NAME?.trim();
   const configValue = config.deploymentName;
-  if (envValue && configValue && envValue !== configValue && !warned) {
+  if (envValue && configValue && envValue !== configValue && !warned2) {
     canopyLogWarn(`CanopyCMS: CANOPYCMS_DEPLOYMENT_NAME ("${envValue}") differs from config.deploymentName ("${configValue}") \u2014 using the env var (infra-stamped env wins over shared-repo config by design; see resolveDeploymentName's doc comment). Update config.deploymentName to match if this mismatch was unintentional.`);
-    warned = true;
+    warned2 = true;
   }
   const resolved = envValue || configValue || modeDefault;
   if (!isValidDeploymentName(resolved)) {
@@ -583,12 +617,12 @@ function resolveDeploymentName(config, modeDefault) {
   }
   return resolved;
 }
-var warned, VALID_DEPLOYMENT_NAME, isValidDeploymentName;
+var warned2, VALID_DEPLOYMENT_NAME, isValidDeploymentName;
 var init_deployment_name = __esm({
   "dist/operating-mode/deployment-name.js"() {
     "use strict";
     init_logger();
-    warned = false;
+    warned2 = false;
     VALID_DEPLOYMENT_NAME = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
     isValidDeploymentName = (name) => VALID_DEPLOYMENT_NAME.test(name) && !name.includes("..") && !name.endsWith(".") && !name.endsWith(".lock");
   }
@@ -638,7 +672,7 @@ var init_config2 = __esm({
 });
 
 // dist/operating-mode/client-unsafe-strategy.js
-import path6 from "node:path";
+import path8 from "node:path";
 function operatingStrategy(mode) {
   const cached = strategyCache.get(mode);
   if (cached)
@@ -676,32 +710,32 @@ var init_client_unsafe_strategy = __esm({
       // - shouldCommit(), shouldPush()
       // Add client-unsafe methods (use Node.js APIs)
       getWorkspaceRoot(_sourceRoot) {
-        return path6.resolve(process.env.CANOPYCMS_WORKSPACE_ROOT ?? DEFAULT_PROD_WORKSPACE);
+        return path8.resolve(process.env.CANOPYCMS_WORKSPACE_ROOT ?? DEFAULT_PROD_WORKSPACE);
       }
       getContentRoot(contentRoot, sourceRoot) {
-        return path6.resolve(sourceRoot ?? process.cwd(), contentRoot);
+        return path8.resolve(sourceRoot ?? process.cwd(), contentRoot);
       }
       getContentBranchesRoot(sourceRoot) {
-        return path6.join(this.getWorkspaceRoot(sourceRoot), "content-branches");
+        return path8.join(this.getWorkspaceRoot(sourceRoot), "content-branches");
       }
       getContentBranchRoot(branchName, sourceRoot) {
-        return path6.resolve(this.getContentBranchesRoot(sourceRoot), branchName);
+        return path8.resolve(this.getContentBranchesRoot(sourceRoot), branchName);
       }
       getGitExcludePattern() {
         return ".canopy-meta/";
       }
       getPermissionsFilePath(root) {
-        return path6.join(root, this.getPermissionsFileName());
+        return path8.join(root, this.getPermissionsFileName());
       }
       getGroupsFilePath(root) {
-        return path6.join(root, this.getGroupsFileName());
+        return path8.join(root, this.getGroupsFileName());
       }
       getRemoteUrlConfig() {
         return {
           shouldAutoInitLocal: false,
           defaultRemotePath: "",
           envVarName: "CANOPYCMS_REMOTE_URL",
-          autoDetectRemotePath: path6.join(this.getWorkspaceRoot(), "remote.git")
+          autoDetectRemotePath: path8.join(this.getWorkspaceRoot(), "remote.git")
         };
       }
       requiresExistingRepo() {
@@ -713,7 +747,7 @@ var init_client_unsafe_strategy = __esm({
         return `canopycms-settings-${resolveDeploymentName(config, "prod")}`;
       }
       getSettingsRoot(sourceRoot) {
-        return path6.join(this.getWorkspaceRoot(sourceRoot), "settings");
+        return path8.join(this.getWorkspaceRoot(sourceRoot), "settings");
       }
       usesSeparateSettingsBranch() {
         return true;
@@ -730,25 +764,25 @@ var init_client_unsafe_strategy = __esm({
     DevStrategy = class extends DevClientSafeStrategy {
       // Inherits client-safe methods from DevClientSafeStrategy
       getWorkspaceRoot(sourceRoot) {
-        return path6.resolve(sourceRoot ?? process.cwd(), ".canopy-dev");
+        return path8.resolve(sourceRoot ?? process.cwd(), ".canopy-dev");
       }
       getContentRoot(contentRoot, sourceRoot) {
-        return path6.resolve(sourceRoot ?? process.cwd(), contentRoot);
+        return path8.resolve(sourceRoot ?? process.cwd(), contentRoot);
       }
       getContentBranchesRoot(sourceRoot) {
-        return path6.join(this.getWorkspaceRoot(sourceRoot), "content-branches");
+        return path8.join(this.getWorkspaceRoot(sourceRoot), "content-branches");
       }
       getContentBranchRoot(branchName, sourceRoot) {
-        return path6.resolve(this.getContentBranchesRoot(sourceRoot), branchName);
+        return path8.resolve(this.getContentBranchesRoot(sourceRoot), branchName);
       }
       getGitExcludePattern() {
         return ".canopy-meta/";
       }
       getPermissionsFilePath(root) {
-        return path6.join(root, this.getPermissionsFileName());
+        return path8.join(root, this.getPermissionsFileName());
       }
       getGroupsFilePath(root) {
-        return path6.join(root, this.getGroupsFileName());
+        return path8.join(root, this.getGroupsFileName());
       }
       getRemoteUrlConfig() {
         return {
@@ -766,7 +800,7 @@ var init_client_unsafe_strategy = __esm({
         return `canopycms-settings-${resolveDeploymentName(config, "local")}`;
       }
       getSettingsRoot(sourceRoot) {
-        return path6.join(this.getWorkspaceRoot(sourceRoot), "settings");
+        return path8.join(this.getWorkspaceRoot(sourceRoot), "settings");
       }
       usesSeparateSettingsBranch() {
         return true;
@@ -784,11 +818,15 @@ var init_client_unsafe_strategy = __esm({
 // dist/operating-mode/index.js
 var operating_mode_exports = {};
 __export(operating_mode_exports, {
+  BROWSER_MODE_ENV_VAR: () => BROWSER_MODE_ENV_VAR,
+  SERVER_MODE_ENV_VAR: () => SERVER_MODE_ENV_VAR,
   clearClientStrategyCache: () => clearClientStrategyCache,
   clearStrategyCache: () => clearStrategyCache,
   clientOperatingStrategy: () => clientOperatingStrategy,
+  isValidDeploymentName: () => isValidDeploymentName,
   operatingStrategy: () => operatingStrategy,
-  resolveDeploymentName: () => resolveDeploymentName
+  resolveDeploymentName: () => resolveDeploymentName,
+  resolveOperatingMode: () => resolveOperatingMode
 });
 var init_operating_mode = __esm({
   "dist/operating-mode/index.js"() {
@@ -796,20 +834,21 @@ var init_operating_mode = __esm({
     init_client_safe_strategy();
     init_client_unsafe_strategy();
     init_deployment_name();
+    init_mode_env();
   }
 });
 
 // dist/cli/generate-ai-content.js
-import path18 from "node:path";
+import path19 from "node:path";
 import { createJiti } from "jiti";
 
 // dist/build/generate-ai-content.js
 import fs16 from "node:fs/promises";
-import path17 from "node:path";
+import path18 from "node:path";
 
 // dist/content-store.js
-import fs8 from "node:fs/promises";
-import path8 from "node:path";
+import fs9 from "node:fs/promises";
+import path10 from "node:path";
 import matter from "gray-matter";
 import { parse as yamlParse, stringify as yamlStringify } from "yaml";
 
@@ -849,6 +888,94 @@ async function withLock(key, fn) {
   }
 }
 
+// dist/utils/content-write-lock.js
+import path3 from "node:path";
+
+// dist/utils/error.js
+function getErrorMessage(err) {
+  if (err instanceof Error) {
+    return err.message;
+  }
+  if (typeof err === "string") {
+    return err;
+  }
+  return String(err);
+}
+function isNodeError(err) {
+  return err instanceof Error && "code" in err;
+}
+function isNotFoundError(err) {
+  return isNodeError(err) && err.code === "ENOENT";
+}
+function isFileExistsError(err) {
+  return isNodeError(err) && err.code === "EEXIST";
+}
+
+// dist/utils/provisioning-lock.js
+import fs2 from "node:fs/promises";
+import path2 from "node:path";
+import lockfile from "proper-lockfile";
+async function acquireProvisioningLock(lockTargetDir2, lockName) {
+  await fs2.mkdir(lockTargetDir2, { recursive: true });
+  return lockfile.lock(lockTargetDir2, {
+    lockfilePath: path2.join(lockTargetDir2, lockName),
+    retries: { retries: 600, factor: 1, minTimeout: 300, maxTimeout: 800, randomize: true },
+    stale: 3e4
+  });
+}
+async function tryAcquireProvisioningLock(lockTargetDir2, lockName) {
+  await fs2.mkdir(lockTargetDir2, { recursive: true });
+  return lockfile.lock(lockTargetDir2, {
+    lockfilePath: path2.join(lockTargetDir2, lockName),
+    retries: 0,
+    stale: 3e4
+  });
+}
+
+// dist/utils/content-write-lock.js
+var META_DIR = ".canopy-meta";
+var CONTENT_WRITE_LOCK_NAME = "content-write.lock";
+var DEFAULT_CONTENT_WRITE_LOCK_WAIT_MS = 2e3;
+var ContentWriteLockBusyError = class extends Error {
+  constructor(message = "This branch is busy (syncing with the base branch, or another save is in flight); the change was not saved. Try again in a moment.") {
+    super(message);
+    this.name = "ContentWriteLockBusyError";
+  }
+};
+function lockTargetDir(branchRoot) {
+  return path3.join(path3.resolve(branchRoot), META_DIR);
+}
+var sleep = (ms) => new Promise((resolve2) => {
+  setTimeout(resolve2, ms);
+});
+function tryAcquireContentWriteLock(branchRoot) {
+  return tryAcquireProvisioningLock(lockTargetDir(branchRoot), CONTENT_WRITE_LOCK_NAME);
+}
+async function acquireContentWriteLock(branchRoot, waitMs = DEFAULT_CONTENT_WRITE_LOCK_WAIT_MS) {
+  const startedAt = Date.now();
+  for (let attempt = 0; ; attempt++) {
+    try {
+      return await tryAcquireContentWriteLock(branchRoot);
+    } catch (err) {
+      if (!isNodeError(err) || err.code !== "ELOCKED")
+        throw err;
+      const remaining = waitMs - (Date.now() - startedAt);
+      if (remaining <= 0)
+        throw new ContentWriteLockBusyError();
+      const base = Math.min(40 * 2 ** attempt, 250);
+      await sleep(Math.min(base * (0.5 + Math.random()), remaining));
+    }
+  }
+}
+async function withContentWriteLock(branchRoot, fn, waitMs = DEFAULT_CONTENT_WRITE_LOCK_WAIT_MS) {
+  const release = await acquireContentWriteLock(branchRoot, waitMs);
+  try {
+    return await fn();
+  } finally {
+    await release();
+  }
+}
+
 // dist/utils/flatten-group-fields.js
 function flattenGroupFields(fields) {
   const result = [];
@@ -872,8 +999,8 @@ function findBodyFieldName(fields) {
 }
 
 // dist/content-id-index.js
-import fs2 from "node:fs/promises";
-import path2 from "node:path";
+import fs3 from "node:fs/promises";
+import path4 from "node:path";
 
 // dist/id.js
 import { generate } from "short-uuid";
@@ -894,27 +1021,8 @@ function generateId() {
 }
 var isValidId = isValidContentId;
 
-// dist/utils/error.js
-function getErrorMessage(err) {
-  if (err instanceof Error) {
-    return err.message;
-  }
-  if (typeof err === "string") {
-    return err;
-  }
-  return String(err);
-}
-function isNodeError(err) {
-  return err instanceof Error && "code" in err;
-}
-function isNotFoundError(err) {
-  return isNodeError(err) && err.code === "ENOENT";
-}
-function isFileExistsError(err) {
-  return isNodeError(err) && err.code === "EEXIST";
-}
-
 // dist/content-id-index.js
+init_logger();
 var EMPTY_LOGICAL_PATH = "";
 function toLogicalCollectionPath(physicalPath) {
   if (physicalPath === ".")
@@ -926,32 +1034,61 @@ var ContentIdIndex = class {
     this.idToLocation = /* @__PURE__ */ new Map();
     this.pathToId = /* @__PURE__ */ new Map();
     this.byCollection = /* @__PURE__ */ new Map();
-    this.root = path2.resolve(root);
+    this.duplicateIds = /* @__PURE__ */ new Map();
+    this.root = path4.resolve(root);
   }
   /**
-   * Build index by scanning filenames recursively.
-   * Throws if duplicate IDs found (collision detection).
+   * Build index by scanning filenames recursively. Duplicate embedded IDs
+   * are quarantined, not thrown on -- see the class doc comment's
+   * "Duplicate-ID quarantine" section and {@link getDuplicateIds}.
    */
   async buildFromFilenames(startPath = "") {
     await this.scanDirectory(startPath);
   }
+  /** Insert a location into all three indexes. Caller must ensure no existing entry for this id. */
+  insertLocation(id, location) {
+    this.idToLocation.set(id, location);
+    this.pathToId.set(location.relativePath, id);
+    if (location.type === "entry" && location.collection) {
+      if (!this.byCollection.has(location.collection)) {
+        this.byCollection.set(location.collection, /* @__PURE__ */ new Set());
+      }
+      this.byCollection.get(location.collection).add(id);
+    }
+  }
+  /** Remove a location from all three indexes -- used when a lexicographically-earlier duplicate displaces it. */
+  evictLocation(location) {
+    this.idToLocation.delete(location.id);
+    this.pathToId.delete(location.relativePath);
+    if (location.type === "entry" && location.collection) {
+      const idSet = this.byCollection.get(location.collection);
+      if (idSet) {
+        idSet.delete(location.id);
+        if (idSet.size === 0)
+          this.byCollection.delete(location.collection);
+      }
+    }
+  }
+  /** Record a quarantined duplicate path for admin-facing health reporting (see getDuplicateIds). */
+  recordDuplicate(id, droppedPath) {
+    let dropped = this.duplicateIds.get(id);
+    if (!dropped) {
+      dropped = /* @__PURE__ */ new Set();
+      this.duplicateIds.set(id, dropped);
+    }
+    dropped.add(droppedPath);
+  }
   async scanDirectory(relativePath) {
-    const absoluteDir = path2.join(this.root, relativePath);
+    const absoluteDir = path4.join(this.root, relativePath);
     try {
-      const entries = await fs2.readdir(absoluteDir, { withFileTypes: true });
+      const entries = await fs3.readdir(absoluteDir, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.name.startsWith(".") || entry.name === "_ids_") {
           continue;
         }
-        const fullRelativePath = path2.join(relativePath, entry.name);
+        const fullRelativePath = path4.join(relativePath, entry.name);
         const id = extractIdFromFilename(entry.name);
         if (id) {
-          if (this.idToLocation.has(id)) {
-            const existing = this.idToLocation.get(id);
-            throw new Error(`ID collision detected: ${id}
-  File 1: ${existing.relativePath}
-  File 2: ${fullRelativePath}`);
-          }
           const location = {
             id,
             // already ContentId from extractIdFromFilename
@@ -961,17 +1098,27 @@ var ContentIdIndex = class {
           };
           if (!entry.isDirectory()) {
             const slug = extractSlugFromFilename(entry.name);
-            const physicalCollection = path2.dirname(fullRelativePath);
+            const physicalCollection = path4.dirname(fullRelativePath);
             const collectionPath = toLogicalCollectionPath(physicalCollection);
             location.slug = slug;
             location.collection = collectionPath;
-            if (!this.byCollection.has(collectionPath)) {
-              this.byCollection.set(collectionPath, /* @__PURE__ */ new Set());
+          }
+          const existing = this.idToLocation.get(id);
+          if (existing) {
+            const newWins = fullRelativePath < existing.relativePath;
+            const kept = newWins ? fullRelativePath : existing.relativePath;
+            const dropped = newWins ? existing.relativePath : fullRelativePath;
+            if (newWins) {
+              this.evictLocation(existing);
+              this.recordDuplicate(id, existing.relativePath);
+              this.insertLocation(id, location);
+            } else {
+              this.recordDuplicate(id, fullRelativePath);
             }
-            this.byCollection.get(collectionPath).add(id);
+            canopyLogWarn(`[ContentIdIndex] Duplicate content ID ${id}: "${kept}" and "${dropped}" both embed this ID. Keeping "${kept}" for ID-based lookups (reads, references, listings); "${dropped}" is excluded from those lookups for now but has NOT been deleted -- it is still on disk at that path, and saves addressed to it are refused until this is resolved. An admin can resolve this via the repair-content-duplicates admin action for this branch, which archives "${dropped}" with a dot-prefixed name so future scans stop flagging it. Root: ${this.root}`);
+          } else {
+            this.insertLocation(id, location);
           }
-          this.idToLocation.set(id, location);
-          this.pathToId.set(fullRelativePath, id);
         }
         if (entry.isDirectory()) {
           await this.scanDirectory(fullRelativePath);
@@ -983,6 +1130,42 @@ var ContentIdIndex = class {
       }
     }
   }
+  /**
+   * IDs discovered on more than one file during the last buildFromFilenames
+   * scan. Empty unless the content tree currently has a duplicate-ID pair
+   * (see the class doc comment). Consumed by branch-health.ts's admin scan
+   * and by the repair-content-duplicates admin action
+   * (api/admin-branch-health.ts).
+   */
+  getDuplicateIds() {
+    const result = [];
+    for (const id of this.duplicateIds.keys()) {
+      const duplicate = this.getDuplicateFor(id);
+      if (duplicate)
+        result.push(duplicate);
+    }
+    return result;
+  }
+  /**
+   * The quarantine record for ONE id, or null when that id is not
+   * duplicated. The O(1) counterpart to {@link getDuplicateIds} for the
+   * write path, which has to ask this question on every save whose resolved
+   * path disagrees with the index (ContentStore.write()'s duplicate-ID
+   * guard) and must not pay for materializing the whole list.
+   */
+  getDuplicateFor(id) {
+    const dropped = this.duplicateIds.get(id);
+    if (!dropped)
+      return null;
+    const kept = this.idToLocation.get(id);
+    if (!kept)
+      return null;
+    return {
+      id,
+      keptPath: kept.relativePath,
+      droppedPaths: Array.from(dropped).sort()
+    };
+  }
   /**
    * Forward lookup: ID → location (O(1))
    */
@@ -1075,7 +1258,7 @@ var ContentIdIndex = class {
    * must already exist on disk (created by ContentStore).
    */
   add(location) {
-    const id = extractIdFromFilename(path2.basename(location.relativePath));
+    const id = extractIdFromFilename(path4.basename(location.relativePath));
     if (!id) {
       throw new Error(`Cannot add location without ID in filename: ${location.relativePath}`);
     }
@@ -1132,8 +1315,8 @@ var ContentIdIndex = class {
     location.relativePath = newRelativePath;
     if (location.type === "entry") {
       const oldCollection = location.collection;
-      location.slug = extractSlugFromFilename(path2.basename(newRelativePath));
-      const physicalCollection = path2.dirname(newRelativePath);
+      location.slug = extractSlugFromFilename(path4.basename(newRelativePath));
+      const physicalCollection = path4.dirname(newRelativePath);
       location.collection = toLogicalCollectionPath(physicalCollection);
       if (oldCollection !== location.collection) {
         if (oldCollection) {
@@ -1175,7 +1358,7 @@ function extractIdFromFilename(filename) {
 }
 async function resolveCollectionPath(root, logicalPath) {
   const fs17 = await import("node:fs/promises");
-  const path19 = await import("node:path");
+  const path20 = await import("node:path");
   const segments = logicalPath.split("/").filter(Boolean);
   let currentPath = root;
   for (const segment of segments) {
@@ -1188,7 +1371,7 @@ async function resolveCollectionPath(root, logicalPath) {
         return logicalName === segment.toLowerCase();
       });
       if (matchingDir) {
-        currentPath = path19.join(currentPath, matchingDir.name);
+        currentPath = path20.join(currentPath, matchingDir.name);
       } else {
         return null;
       }
@@ -1239,7 +1422,7 @@ function extractSlugFromFilename(filename, entryTypeName) {
 }
 
 // dist/content-index-registry.js
-import path3 from "node:path";
+import path5 from "node:path";
 var registry = /* @__PURE__ */ new Map();
 var finalization = new FinalizationRegistry(({ rootKey, ref }) => {
   const refs = registry.get(rootKey);
@@ -1250,7 +1433,7 @@ var finalization = new FinalizationRegistry(({ rootKey, ref }) => {
     registry.delete(rootKey);
 });
 function registerContentIndexForInvalidation(root, target) {
-  const rootKey = path3.resolve(root);
+  const rootKey = path5.resolve(root);
   let refs = registry.get(rootKey);
   if (!refs) {
     refs = /* @__PURE__ */ new Set();
@@ -1261,8 +1444,8 @@ function registerContentIndexForInvalidation(root, target) {
   finalization.register(target, { rootKey, ref });
 }
 function invalidateContentIndexesForRoot(root) {
-  const rootKey = path3.resolve(root);
-  const prefix = rootKey + path3.sep;
+  const rootKey = path5.resolve(root);
+  const prefix = rootKey + path5.sep;
   for (const [storeRoot, refs] of registry) {
     if (storeRoot !== rootKey && !storeRoot.startsWith(prefix))
       continue;
@@ -1280,8 +1463,8 @@ function invalidateContentIndexesForRoot(root) {
 }
 
 // dist/resource-generation.js
-import fs3 from "node:fs/promises";
-import path4 from "node:path";
+import fs4 from "node:fs/promises";
+import path6 from "node:path";
 import { randomUUID } from "node:crypto";
 
 // dist/utils/debug.js
@@ -1388,9 +1571,9 @@ var testLogger = createDebugLogger({
 
 // dist/resource-generation.js
 var log = createDebugLogger({ prefix: "ResourceGeneration" });
-var META_DIR = ".canopy-meta";
+var META_DIR2 = ".canopy-meta";
 function resourceGenerationPath(root, resource) {
-  return path4.resolve(root, META_DIR, `${resource}.generation`);
+  return path6.resolve(root, META_DIR2, `${resource}.generation`);
 }
 async function bumpResourceGeneration(root, resource, options) {
   const token = randomUUID();
@@ -1408,7 +1591,7 @@ async function bumpResourceGeneration(root, resource, options) {
 }
 async function readResourceGeneration(root, resource) {
   try {
-    const token = await fs3.readFile(resourceGenerationPath(root, resource), "utf-8");
+    const token = await fs4.readFile(resourceGenerationPath(root, resource), "utf-8");
     return { ok: true, token };
   } catch (err) {
     if (isNodeError(err) && err.code === "ENOENT")
@@ -1424,11 +1607,11 @@ function isGenerationCurrent(snapshotToken, read) {
 }
 
 // dist/branch-schema-cache.js
-import fs5 from "node:fs/promises";
-import path5 from "node:path";
+import fs6 from "node:fs/promises";
+import path7 from "node:path";
 
 // dist/schema/meta-loader.js
-import { promises as fs4 } from "fs";
+import { promises as fs5 } from "fs";
 import { join } from "pathe";
 import { z } from "zod";
 import chokidar from "chokidar";
@@ -1465,7 +1648,7 @@ function stripEmbeddedIdFromName(name) {
 async function scanForCollectionMeta(baseDir, relativePath = "") {
   const collections = [];
   try {
-    const entries = await fs4.readdir(baseDir, { withFileTypes: true });
+    const entries = await fs5.readdir(baseDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory())
         continue;
@@ -1476,8 +1659,8 @@ async function scanForCollectionMeta(baseDir, relativePath = "") {
       const absolutePath = join(baseDir, folderName);
       const metaPath = join(absolutePath, ".collection.json");
       try {
-        await fs4.access(metaPath);
-        const content = await fs4.readFile(metaPath, "utf-8");
+        await fs5.access(metaPath);
+        const content = await fs5.readFile(metaPath, "utf-8");
         const parsed = JSON.parse(content);
         const meta = collectionMetaSchema.parse(parsed);
         collections.push({
@@ -1509,7 +1692,7 @@ async function loadCollectionMetaFiles(contentRoot) {
   let root = null;
   const rootMetaPath = join(contentRoot, ".collection.json");
   try {
-    await fs4.access(rootMetaPath);
+    await fs5.access(rootMetaPath);
   } catch (err) {
     if (err.code === "ENOENT") {
     } else {
@@ -1517,7 +1700,7 @@ async function loadCollectionMetaFiles(contentRoot) {
     }
   }
   try {
-    const content = await fs4.readFile(rootMetaPath, "utf-8");
+    const content = await fs5.readFile(rootMetaPath, "utf-8");
     const parsed = JSON.parse(content);
     root = rootCollectionMetaSchema.parse(parsed);
   } catch (err) {
@@ -1704,16 +1887,16 @@ var SCHEMA_GENERATION_RESOURCE = "schema";
 async function isStaleByMtime(dir, cachedAt) {
   let entries;
   try {
-    entries = await fs5.readdir(dir, { recursive: true, encoding: "utf-8" });
+    entries = await fs6.readdir(dir, { recursive: true, encoding: "utf-8" });
   } catch {
     return true;
   }
   for (const entry of entries) {
     if (!entry.endsWith(".collection.json"))
       continue;
-    const full = path5.join(dir, entry);
+    const full = path7.join(dir, entry);
     try {
-      const stat = await fs5.stat(full);
+      const stat = await fs6.stat(full);
       if (stat.mtimeMs > cachedAt.getTime())
         return true;
     } catch {
@@ -1737,7 +1920,7 @@ var BranchSchemaCache = class {
    * the project root, regardless of which entrypoint produced the cwd branchRoot.
    */
   skipDiskCache(branchRoot) {
-    return isBuildMode() || path5.resolve(branchRoot) === path5.resolve(process.cwd());
+    return isBuildMode() || path7.resolve(branchRoot) === path7.resolve(process.cwd());
   }
   /**
    * Get schema for a branch (loads from cache or resolves fresh).
@@ -1763,14 +1946,14 @@ var BranchSchemaCache = class {
    * Load schema from cache or resolve fresh if cache is missing or stale.
    */
   async loadFromCacheOrResolve(branchRoot, entrySchemaRegistry, contentRootName) {
-    const contentRoot = path5.join(branchRoot, contentRootName);
+    const contentRoot = path7.join(branchRoot, contentRootName);
     const skipDiskCache = this.skipDiskCache(branchRoot);
     if (!skipDiskCache) {
-      const cacheDir = path5.join(branchRoot, ".canopy-meta");
-      const cachePath = path5.join(cacheDir, "schema-cache.json");
+      const cacheDir = path7.join(branchRoot, ".canopy-meta");
+      const cachePath = path7.join(cacheDir, "schema-cache.json");
       let cacheData = null;
       try {
-        const cacheContent = await fs5.readFile(cachePath, "utf-8");
+        const cacheContent = await fs6.readFile(cachePath, "utf-8");
         cacheData = JSON.parse(cacheContent);
       } catch {
         cacheData = null;
@@ -1807,7 +1990,7 @@ var BranchSchemaCache = class {
    */
   async resolveFreshAndPersist(branchRoot, entrySchemaRegistry, contentRootName, options) {
     const { skipDiskCache } = options;
-    const contentRoot = path5.join(branchRoot, contentRootName);
+    const contentRoot = path7.join(branchRoot, contentRootName);
     const read = skipDiskCache ? null : await readResourceGeneration(branchRoot, SCHEMA_GENERATION_RESOURCE);
     const result = await this.resolveFresh(contentRoot, entrySchemaRegistry);
     if (!isValidSchema(result.schema)) {
@@ -1820,9 +2003,9 @@ var BranchSchemaCache = class {
     }
     const flatSchema = flattenSchema(result.schema, contentRootName);
     if (!skipDiskCache) {
-      const cacheDir = path5.join(branchRoot, ".canopy-meta");
-      const cachePath = path5.join(cacheDir, "schema-cache.json");
-      await fs5.unlink(path5.join(cacheDir, "schema-cache.stale")).catch(() => {
+      const cacheDir = path7.join(branchRoot, ".canopy-meta");
+      const cachePath = path7.join(cacheDir, "schema-cache.json");
+      await fs6.unlink(path7.join(cacheDir, "schema-cache.stale")).catch(() => {
       });
       if (read && read.ok) {
         const newCache = {
@@ -1832,13 +2015,13 @@ var BranchSchemaCache = class {
           cachedAt: (/* @__PURE__ */ new Date()).toISOString(),
           generation: read.token
         };
-        await fs5.mkdir(cacheDir, { recursive: true });
-        const tmpPath = path5.join(cacheDir, `schema-cache.tmp.${Date.now()}.${Math.random()}.json`);
-        await fs5.writeFile(tmpPath, JSON.stringify(newCache, null, 2), "utf-8");
+        await fs6.mkdir(cacheDir, { recursive: true });
+        const tmpPath = path7.join(cacheDir, `schema-cache.tmp.${Date.now()}.${Math.random()}.json`);
+        await fs6.writeFile(tmpPath, JSON.stringify(newCache, null, 2), "utf-8");
         try {
-          await fs5.rename(tmpPath, cachePath);
+          await fs6.rename(tmpPath, cachePath);
         } catch (err) {
-          await fs5.unlink(tmpPath).catch(() => {
+          await fs6.unlink(tmpPath).catch(() => {
           });
           throw err;
         }
@@ -1910,10 +2093,10 @@ async function invalidateBranchContentCaches(root) {
 }
 
 // dist/utils/fs.js
-import fs6 from "node:fs/promises";
+import fs7 from "node:fs/promises";
 async function filePathExists(filePath) {
   try {
-    await fs6.stat(filePath);
+    await fs7.stat(filePath);
     return true;
   } catch (err) {
     if (isNotFoundError(err))
@@ -1959,8 +2142,8 @@ function validateAndNormalizePath(root, target) {
 
 // dist/paths/branch.js
 init_operating_mode();
-import fs7 from "node:fs/promises";
-import path7 from "node:path";
+import fs8 from "node:fs/promises";
+import path9 from "node:path";
 
 // dist/paths/branch-name.js
 function sanitizeBranchName(branchName) {
@@ -1983,11 +2166,11 @@ function resolveBranchPath(options) {
   const safeBranch = sanitizeBranchName(options.branchName);
   const strategy = operatingStrategy(options.mode);
   const baseRoot = resolveContentBranchesRoot(options.mode, options.basePathOverride);
-  const normalizedBase = path7.resolve(baseRoot);
-  const baseWithSep = normalizedBase.endsWith(path7.sep) ? normalizedBase : `${normalizedBase}${path7.sep}`;
+  const normalizedBase = path9.resolve(baseRoot);
+  const baseWithSep = normalizedBase.endsWith(path9.sep) ? normalizedBase : `${normalizedBase}${path9.sep}`;
   const branchRoot = strategy.getContentBranchRoot(safeBranch, options.basePathOverride);
   const withinBase = (target) => {
-    const resolved = path7.resolve(target);
+    const resolved = path9.resolve(target);
     return resolved === normalizedBase || resolved.startsWith(baseWithSep);
   };
   if (!withinBase(branchRoot)) {
@@ -1997,7 +2180,7 @@ function resolveBranchPath(options) {
 }
 async function ensureBranchRoot(options) {
   const result = resolveBranchPath(options);
-  await fs7.mkdir(result.branchRoot, { recursive: true });
+  await fs8.mkdir(result.branchRoot, { recursive: true });
   return result;
 }
 
@@ -2014,11 +2197,35 @@ var ContentStoreError = class extends Error {
   }
 };
 var ContentConflictError = class extends Error {
-  constructor() {
-    super("Content was modified by another editor");
+  constructor(message = "Content was modified by another editor") {
+    super(message);
     this.name = "ContentConflictError";
   }
 };
+var BranchSyncingError = class extends ContentConflictError {
+  constructor(message) {
+    super(message);
+    this.name = "BranchSyncingError";
+  }
+};
+var DuplicateContentIdError = class extends ContentConflictError {
+  constructor(contentId, paths) {
+    const sorted = Array.from(new Set(paths)).sort();
+    super(
+      // Names the STATE, not an action. The repair-content-duplicates
+      // endpoint exists but nothing in the editor renders it, so telling an
+      // editor "an admin can run X" sent them to an admin who could neither
+      // run X nor see that the branch was affected. Say what is true; the
+      // admin panel's read-only duplicate list (SystemHealthPanel) is the
+      // diagnosis half, and the repair UI is tracked in
+      // .claude/future-tasks/duplicate-content-id-repair-ui.md.
+      `Content ID ${contentId} is on more than one file (${sorted.map((p) => `"${p}"`).join(" and ")}), so this save was refused rather than risk overwriting or deleting the wrong one. An administrator needs to resolve the duplicate on the server before this entry can be saved.`
+    );
+    this.name = "DuplicateContentIdError";
+    this.contentId = contentId;
+    this.paths = sorted;
+  }
+};
 function getDefaultEntryType(entries) {
   if (!entries || entries.length === 0)
     return void 0;
@@ -2043,13 +2250,40 @@ var ContentStore = class {
     this.lastDiskProbeMs = 0;
     this.lastForcedRefreshMs = 0;
     this.indexBuild = null;
-    this.root = path8.resolve(root);
+    this.root = path10.resolve(root);
     this.contentRootName = options.contentRootName || "content";
     this.indexFreshnessIntervalMs = options.indexFreshnessIntervalMs ?? DEFAULT_INDEX_FRESHNESS_INTERVAL_MS;
+    this.contentWriteLockWaitMs = options.contentWriteLockWaitMs ?? DEFAULT_CONTENT_WRITE_LOCK_WAIT_MS;
     this.schemaIndex = new Map(flatSchema.map((item) => [item.logicalPath, item]));
     this._idIndex = new ContentIdIndex(this.root);
     registerContentIndexForInvalidation(this.root, this);
   }
+  /**
+   * [SYNC-C1] Run a working-tree mutation under the branch's cross-host
+   * content-write lock (utils/content-write-lock.ts), on top of the
+   * in-process locks the callee takes for itself.
+   *
+   * The in-process mutex serializes writers inside ONE process; it says
+   * nothing about the EC2 worker rebasing this same tree on shared EFS, which
+   * destroys an in-flight save (`checkout --theirs` overwrites it and the
+   * rebase then reports success; `rebase --abort` hard-resets it). This is the
+   * layer that actually excludes the two.
+   *
+   * Reads deliberately do NOT take it -- an extra EFS round-trip per read is
+   * not an acceptable cost, and reads cannot be destroyed by a rebase.
+   *
+   * Acquisition order is always content lock -> `withLock`, never the reverse,
+   * so the two cannot deadlock.
+   */
+  async withContentWriteExclusion(fn) {
+    try {
+      return await withContentWriteLock(this.root, fn, this.contentWriteLockWaitMs);
+    } catch (err) {
+      if (err instanceof ContentWriteLockBusyError)
+        throw new BranchSyncingError(err.message);
+      throw err;
+    }
+  }
   /**
    * Mark the ID index stale so the next idIndex() access rebuilds it from disk.
    *
@@ -2153,26 +2387,32 @@ var ContentStore = class {
     return true;
   }
   /**
-   * Find the file in `dir` whose filename embeds `id`.
-   * Returns its root-relative path, or null if no such file (or no such dir).
+   * Every file in `dir` whose filename embeds `id`, as root-relative paths
+   * (empty when there is no such file, or no such dir).
+   *
+   * [F1] Returns ALL matches, not the first: more than one match is a
+   * duplicate-ID pair, and callers must be able to tell that apart from a
+   * clean single hit rather than silently picking whichever one `readdir()`
+   * happened to yield first.
    */
-  async findEntryPathById(dir, id) {
+  async findEntryPathsById(dir, id) {
     let entries;
     try {
-      entries = await fs8.readdir(dir, { withFileTypes: true });
+      entries = await fs9.readdir(dir, { withFileTypes: true });
     } catch (err) {
       if (isNodeError(err) && err.code === "ENOENT")
-        return null;
+        return [];
       throw err;
     }
+    const matches = [];
     for (const entry of entries) {
       if (entry.isDirectory())
         continue;
       if (extractIdFromFilename(entry.name) === id) {
-        return path8.relative(this.root, path8.join(dir, entry.name));
+        matches.push(path10.relative(this.root, path10.join(dir, entry.name)));
       }
     }
-    return null;
+    return matches.sort();
   }
   /**
    * Get all schema items for iteration.
@@ -2181,11 +2421,11 @@ var ContentStore = class {
   getSchemaItems() {
     return this.schemaIndex.values();
   }
-  assertSchemaItem(path19) {
-    const normalized = normalizeFilesystemPath(path19);
+  assertSchemaItem(path20) {
+    const normalized = normalizeFilesystemPath(path20);
     const item = this.schemaIndex.get(normalized);
     if (!item) {
-      throw new ContentStoreError(`Unknown schema item: ${path19}`, "NO_SCHEMA_ITEM");
+      throw new ContentStoreError(`Unknown schema item: ${path20}`, "NO_SCHEMA_ITEM");
     }
     return item;
   }
@@ -2268,7 +2508,7 @@ var ContentStore = class {
    * @param options.entryTypeName - For collections with multiple entry types, specify which one to use. Defaults to the default entry type.
    */
   async buildPaths(schemaItem, slug, options = {}) {
-    const rootWithSep = this.root.endsWith(path8.sep) ? this.root : `${this.root}${path8.sep}`;
+    const rootWithSep = this.root.endsWith(path10.sep) ? this.root : `${this.root}${path10.sep}`;
     if (schemaItem.type === "entry-type") {
       const parentPath = schemaItem.parentPath || "";
       const parentCollection = this.schemaIndex.get(parentPath);
@@ -2301,7 +2541,7 @@ var ContentStore = class {
       const entryTypeName = entryTypeConfig?.name || "entry";
       let collectionRoot = await resolveCollectionPath(this.root, schemaItem.logicalPath);
       if (!collectionRoot) {
-        collectionRoot = path8.resolve(this.root, schemaItem.logicalPath);
+        collectionRoot = path10.resolve(this.root, schemaItem.logicalPath);
       }
       if (!collectionRoot.startsWith(rootWithSep)) {
         throw new ContentStoreError("Path traversal detected", "VALIDATION");
@@ -2311,7 +2551,7 @@ var ContentStore = class {
       let existingEntryType;
       let foundExisting = false;
       if (!id) {
-        const entries = await fs8.readdir(collectionRoot, { withFileTypes: true }).catch(() => []);
+        const entries = await fs9.readdir(collectionRoot, { withFileTypes: true }).catch(() => []);
         const existingFile = entries.find((entry) => {
           if (entry.isDirectory())
             return false;
@@ -2337,14 +2577,14 @@ var ContentStore = class {
         }
         filename = `${finalEntryTypeName}.${safeSlug}.${id}${ext}`;
       }
-      const resolved = path8.resolve(collectionRoot, filename);
-      const collectionRootWithSep = collectionRoot.endsWith(path8.sep) ? collectionRoot : `${collectionRoot}${path8.sep}`;
+      const resolved = path10.resolve(collectionRoot, filename);
+      const collectionRootWithSep = collectionRoot.endsWith(path10.sep) ? collectionRoot : `${collectionRoot}${path10.sep}`;
       if (!resolved.startsWith(collectionRootWithSep)) {
         throw new ContentStoreError("Path traversal detected", "VALIDATION");
       }
       return {
         absolutePath: resolved,
-        relativePath: path8.relative(this.root, resolved),
+        relativePath: path10.relative(this.root, resolved),
         id,
         entryTypeName: finalEntryTypeName,
         existed
@@ -2380,8 +2620,8 @@ var ContentStore = class {
   async read(collectionPath, slug = "", options = {}) {
     const schemaItem = this.assertSchemaItem(collectionPath);
     const { absolutePath, relativePath, entryTypeName: resolvedEntryTypeName } = await this.buildPaths(schemaItem, slug);
-    const stat = await fs8.stat(absolutePath);
-    const raw = await fs8.readFile(absolutePath, "utf8");
+    const stat = await fs9.stat(absolutePath);
+    const raw = await fs9.readFile(absolutePath, "utf8");
     let doc;
     let format;
     let fields;
@@ -2464,103 +2704,128 @@ var ContentStore = class {
     }
     const prePass = await this.buildPaths(schemaItem, slug, { entryTypeName, existingId });
     let lockKey = this.entryLockKey(schemaItem, slug, prePass);
-    const RETRY_KEY = Symbol("retry-with-new-lock-key");
-    for (let attempt = 0; attempt < 10; attempt++) {
-      const outcome = await withLock(lockKey, async () => {
-        const inLock = await this.buildPaths(schemaItem, slug, {
-          entryTypeName,
-          existingId
-        });
-        const currentKey = this.entryLockKey(schemaItem, slug, inLock);
-        if (currentKey !== lockKey) {
-          lockKey = currentKey;
-          return RETRY_KEY;
-        }
-        const { absolutePath, relativePath, id } = inLock;
-        await fs8.mkdir(path8.dirname(absolutePath), { recursive: true });
-        if (input.expectedVersion !== void 0) {
-          try {
-            const existing = await fs8.stat(absolutePath);
-            if (existing.mtimeMs !== input.expectedVersion) {
-              throw new ContentConflictError();
+    return this.withContentWriteExclusion(async () => {
+      const RETRY_KEY = Symbol("retry-with-new-lock-key");
+      for (let attempt = 0; attempt < 10; attempt++) {
+        const outcome = await withLock(lockKey, async () => {
+          const inLock = await this.buildPaths(schemaItem, slug, {
+            entryTypeName,
+            existingId
+          });
+          const currentKey = this.entryLockKey(schemaItem, slug, inLock);
+          if (currentKey !== lockKey) {
+            lockKey = currentKey;
+            return RETRY_KEY;
+          }
+          const { absolutePath, relativePath, id } = inLock;
+          if (id) {
+            const guardIndex = this._idIndex;
+            const indexedPath = guardIndex.findById(id)?.relativePath ?? null;
+            if (indexedPath && indexedPath !== relativePath) {
+              const quarantined = guardIndex.getDuplicateFor(id);
+              const bothOnDisk = await filePathExists(absolutePath) && await filePathExists(path10.join(this.root, indexedPath));
+              if (quarantined || bothOnDisk) {
+                throw new DuplicateContentIdError(id, [
+                  indexedPath,
+                  relativePath,
+                  ...quarantined?.droppedPaths ?? [],
+                  ...quarantined ? [quarantined.keptPath] : []
+                ]);
+              }
             }
-          } catch (err) {
-            if (err instanceof ContentConflictError)
-              throw err;
-            if (isNodeError(err) && err.code === "ENOENT") {
-            } else {
-              throw err;
+          }
+          await fs9.mkdir(path10.dirname(absolutePath), { recursive: true });
+          if (input.expectedVersion !== void 0) {
+            try {
+              const existing = await fs9.stat(absolutePath);
+              if (input.expectedVersion === null) {
+                throw new ContentConflictError("An entry with this slug already exists");
+              }
+              if (existing.mtimeMs !== input.expectedVersion) {
+                throw new ContentConflictError();
+              }
+            } catch (err) {
+              if (err instanceof ContentConflictError)
+                throw err;
+              if (isNodeError(err) && err.code === "ENOENT") {
+              } else {
+                throw err;
+              }
             }
           }
-        }
-        if (existingId && !await filePathExists(absolutePath)) {
-          const actualRelPath = await this.findEntryPathById(path8.dirname(absolutePath), existingId);
-          const indexedRelPath = this._idIndex.findById(existingId)?.relativePath ?? null;
-          if (actualRelPath !== null && actualRelPath !== indexedRelPath) {
-            throw new ContentConflictError();
+          if (existingId && !await filePathExists(absolutePath)) {
+            const actualRelPaths = await this.findEntryPathsById(path10.dirname(absolutePath), existingId);
+            if (actualRelPaths.length > 1) {
+              throw new DuplicateContentIdError(existingId, actualRelPaths);
+            }
+            const actualRelPath = actualRelPaths[0] ?? null;
+            const indexedRelPath = this._idIndex.findById(existingId)?.relativePath ?? null;
+            if (actualRelPath !== null && actualRelPath !== indexedRelPath) {
+              throw new ContentConflictError();
+            }
           }
-        }
-        let content;
-        if (input.format === "json") {
-          content = `${JSON.stringify(input.data ?? {}, null, 2)}
+          let content;
+          if (input.format === "json") {
+            content = `${JSON.stringify(input.data ?? {}, null, 2)}
 `;
-        } else if (input.format === "yaml") {
-          content = yamlStringify(input.data ?? {});
-        } else {
-          content = matter.stringify(input.body, input.data ?? {});
-        }
-        await atomicWriteFile(absolutePath, content);
-        const liveIndex = this._idIndex;
-        let staleOldAbsPath = null;
-        if (id) {
-          const existing = liveIndex.findById(id);
-          if (existing) {
-            if (existing.relativePath !== relativePath) {
-              staleOldAbsPath = path8.join(this.root, existing.relativePath);
-              liveIndex.updatePath(existing.id, relativePath);
-            }
+          } else if (input.format === "yaml") {
+            content = yamlStringify(input.data ?? {});
           } else {
-            liveIndex.add({
-              type: "entry",
-              relativePath,
-              collection: collectionPath,
-              slug: slug || void 0
+            content = matter.stringify(input.body, input.data ?? {});
+          }
+          await atomicWriteFile(absolutePath, content);
+          const liveIndex = this._idIndex;
+          let staleOldAbsPath = null;
+          if (id) {
+            const existing = liveIndex.findById(id);
+            if (existing) {
+              if (existing.relativePath !== relativePath) {
+                staleOldAbsPath = path10.join(this.root, existing.relativePath);
+                liveIndex.updatePath(existing.id, relativePath);
+              }
+            } else {
+              liveIndex.add({
+                type: "entry",
+                relativePath,
+                collection: collectionPath,
+                slug: slug || void 0
+              });
+            }
+          }
+          if (staleOldAbsPath) {
+            await fs9.unlink(staleOldAbsPath).catch((err) => {
+              if (!isNodeError(err) || err.code !== "ENOENT")
+                throw err;
             });
           }
-        }
-        if (staleOldAbsPath) {
-          await fs8.unlink(staleOldAbsPath).catch((err) => {
-            if (!isNodeError(err) || err.code !== "ENOENT")
-              throw err;
-          });
-        }
-        await this.recordOwnMutation(liveIndex);
-        const afterStat = await fs8.stat(absolutePath);
-        const base = {
-          collection: schemaItem.logicalPath,
-          collectionName: schemaItem.name,
-          relativePath,
-          absolutePath,
-          version: afterStat.mtimeMs
-        };
-        if (input.format === "json") {
-          return { ...base, format: "json", data: input.data ?? {} };
-        }
-        if (input.format === "yaml") {
-          return { ...base, format: "yaml", data: input.data ?? {} };
-        }
-        return {
-          ...base,
-          format: input.format,
-          data: input.data ?? {},
-          body: input.body,
-          bodyFieldName: findBodyFieldName(fields)
-        };
-      });
-      if (typeof outcome !== "symbol")
-        return outcome;
-    }
-    throw new ContentConflictError();
+          await this.recordOwnMutation(liveIndex);
+          const afterStat = await fs9.stat(absolutePath);
+          const base = {
+            collection: schemaItem.logicalPath,
+            collectionName: schemaItem.name,
+            relativePath,
+            absolutePath,
+            version: afterStat.mtimeMs
+          };
+          if (input.format === "json") {
+            return { ...base, format: "json", data: input.data ?? {} };
+          }
+          if (input.format === "yaml") {
+            return { ...base, format: "yaml", data: input.data ?? {} };
+          }
+          return {
+            ...base,
+            format: input.format,
+            data: input.data ?? {},
+            body: input.body,
+            bodyFieldName: findBodyFieldName(fields)
+          };
+        });
+        if (typeof outcome !== "symbol")
+          return outcome;
+      }
+      throw new ContentConflictError();
+    });
   }
   /**
    * Read an entry by its ID (UUID).
@@ -2612,7 +2877,7 @@ var ContentStore = class {
     const schemaItem = this.assertSchemaItem(collectionPath);
     const { absolutePath } = await this.buildPaths(schemaItem, slug);
     try {
-      await fs8.access(absolutePath);
+      await fs9.access(absolutePath);
       return true;
     } catch (err) {
       if (isNodeError(err) && err.code === "ENOENT")
@@ -2651,7 +2916,7 @@ var ContentStore = class {
     const collectionRoot = await resolveCollectionPath(this.root, collectionPath);
     if (!collectionRoot)
       return 0;
-    const entries = await fs8.readdir(collectionRoot, { withFileTypes: true }).catch(() => []);
+    const entries = await fs9.readdir(collectionRoot, { withFileTypes: true }).catch(() => []);
     return entries.filter((entry) => !entry.isDirectory() && extractEntryTypeFromFilename(entry.name) === entryTypeName).length;
   }
   /**
@@ -2675,34 +2940,36 @@ var ContentStore = class {
     const collection = this.assertCollection(collectionPath);
     const prePass = await this.buildPaths(collection, slug);
     if (!prePass.existed) {
-      await fs8.unlink(prePass.absolutePath);
+      await fs9.unlink(prePass.absolutePath);
       return;
     }
     let lockKey = this.entryLockKey(collection, slug, prePass);
     await this.afterPrePassForTesting();
-    const RETRY_KEY = Symbol("retry-with-new-lock-key");
-    for (let attempt = 0; attempt < 10; attempt++) {
-      const outcome = await withLock(lockKey, async () => {
-        const inLock = await this.buildPaths(collection, slug);
-        const currentKey = this.entryLockKey(collection, slug, inLock);
-        if (currentKey !== lockKey) {
-          lockKey = currentKey;
-          return RETRY_KEY;
-        }
-        const { absolutePath, relativePath } = inLock;
-        await fs8.unlink(absolutePath);
-        const liveIndex = this._idIndex;
-        const id = liveIndex.findByPath(relativePath);
-        if (id) {
-          liveIndex.remove(id);
-        }
-        await this.recordOwnMutation(liveIndex);
-        return void 0;
-      });
-      if (outcome !== RETRY_KEY)
-        return;
-    }
-    throw new ContentConflictError();
+    return this.withContentWriteExclusion(async () => {
+      const RETRY_KEY = Symbol("retry-with-new-lock-key");
+      for (let attempt = 0; attempt < 10; attempt++) {
+        const outcome = await withLock(lockKey, async () => {
+          const inLock = await this.buildPaths(collection, slug);
+          const currentKey = this.entryLockKey(collection, slug, inLock);
+          if (currentKey !== lockKey) {
+            lockKey = currentKey;
+            return RETRY_KEY;
+          }
+          const { absolutePath, relativePath } = inLock;
+          await fs9.unlink(absolutePath);
+          const liveIndex = this._idIndex;
+          const id = liveIndex.findByPath(relativePath);
+          if (id) {
+            liveIndex.remove(id);
+          }
+          await this.recordOwnMutation(liveIndex);
+          return void 0;
+        });
+        if (outcome !== RETRY_KEY)
+          return;
+      }
+      throw new ContentConflictError();
+    });
   }
   /**
    * Rename an entry by changing its slug (middle segment of filename).
@@ -2733,70 +3000,72 @@ var ContentStore = class {
     let sourceId = prePass.id;
     let destLockKey = this.createLockKey(collection, safeNewSlug);
     await this.afterPrePassForTesting();
-    const RETRY_KEY = Symbol("retry-with-new-lock-key");
-    for (let attempt = 0; attempt < 10; attempt++) {
-      const outcome = await withLocks([sourceLockKey, destLockKey], async () => {
-        const inLock = await this.buildPaths(collection, currentSlug);
-        if (!inLock.existed) {
-          throw new ContentStoreError(`Entry not found: ${currentSlug}`, "NOT_FOUND");
-        }
-        const currentSourceKey = this.entryLockKey(collection, currentSlug, inLock);
-        const currentDestKey = this.createLockKey(collection, safeNewSlug);
-        if (currentSourceKey !== sourceLockKey || inLock.id !== sourceId) {
-          sourceLockKey = currentSourceKey;
+    return this.withContentWriteExclusion(async () => {
+      const RETRY_KEY = Symbol("retry-with-new-lock-key");
+      for (let attempt = 0; attempt < 10; attempt++) {
+        const outcome = await withLocks([sourceLockKey, destLockKey], async () => {
+          const inLock = await this.buildPaths(collection, currentSlug);
+          if (!inLock.existed) {
+            throw new ContentStoreError(`Entry not found: ${currentSlug}`, "NOT_FOUND");
+          }
+          const currentSourceKey = this.entryLockKey(collection, currentSlug, inLock);
+          const currentDestKey = this.createLockKey(collection, safeNewSlug);
+          if (currentSourceKey !== sourceLockKey || inLock.id !== sourceId) {
+            sourceLockKey = currentSourceKey;
+            destLockKey = currentDestKey;
+            sourceId = inLock.id;
+            return RETRY_KEY;
+          }
           destLockKey = currentDestKey;
-          sourceId = inLock.id;
-          return RETRY_KEY;
-        }
-        destLockKey = currentDestKey;
-        const { absolutePath: currentPath, relativePath: currentRelPath } = inLock;
-        const currentFilename = path8.basename(currentPath);
-        const parts = currentFilename.split(".");
-        if (parts.length < 4) {
-          throw new ContentStoreError(`Invalid entry filename format: ${currentFilename}`, "VALIDATION");
-        }
-        const entryTypeName = parts[0];
-        const contentId = parts[parts.length - 2];
-        const ext = `.${parts[parts.length - 1]}`;
-        const newFilename = `${entryTypeName}.${safeNewSlug}.${contentId}${ext}`;
-        const parentDir = path8.dirname(currentPath);
-        const newPath = path8.join(parentDir, newFilename);
-        try {
-          const entries = await fs8.readdir(parentDir, { withFileTypes: true });
-          for (const entry of entries) {
-            if (entry.isDirectory())
-              continue;
-            const existingSlug = extractSlugFromFilename(entry.name, entryTypeName);
-            if (existingSlug === safeNewSlug) {
-              throw new ContentStoreError(`Entry with slug "${safeNewSlug}" already exists in collection "${collectionPath}"`, "VALIDATION");
+          const { absolutePath: currentPath, relativePath: currentRelPath } = inLock;
+          const currentFilename = path10.basename(currentPath);
+          const parts = currentFilename.split(".");
+          if (parts.length < 4) {
+            throw new ContentStoreError(`Invalid entry filename format: ${currentFilename}`, "VALIDATION");
+          }
+          const entryTypeName = parts[0];
+          const contentId = parts[parts.length - 2];
+          const ext = `.${parts[parts.length - 1]}`;
+          const newFilename = `${entryTypeName}.${safeNewSlug}.${contentId}${ext}`;
+          const parentDir = path10.dirname(currentPath);
+          const newPath = path10.join(parentDir, newFilename);
+          try {
+            const entries = await fs9.readdir(parentDir, { withFileTypes: true });
+            for (const entry of entries) {
+              if (entry.isDirectory())
+                continue;
+              const existingSlug = extractSlugFromFilename(entry.name, entryTypeName);
+              if (existingSlug === safeNewSlug) {
+                throw new ContentStoreError(`Entry with slug "${safeNewSlug}" already exists in collection "${collectionPath}"`, "VALIDATION");
+              }
             }
+          } catch (err) {
+            if (err instanceof ContentStoreError)
+              throw err;
           }
-        } catch (err) {
-          if (err instanceof ContentStoreError)
+          try {
+            await fs9.link(currentPath, newPath);
+          } catch (err) {
+            if (isNodeError(err) && err.code === "EEXIST") {
+              throw new ContentStoreError(`Entry with slug "${safeNewSlug}" already exists in collection "${collectionPath}"`, "VALIDATION");
+            }
             throw err;
-        }
-        try {
-          await fs8.link(currentPath, newPath);
-        } catch (err) {
-          if (isNodeError(err) && err.code === "EEXIST") {
-            throw new ContentStoreError(`Entry with slug "${safeNewSlug}" already exists in collection "${collectionPath}"`, "VALIDATION");
           }
-          throw err;
-        }
-        await fs8.unlink(currentPath);
-        const newRelativePath = path8.relative(this.root, newPath);
-        const liveIndex = this._idIndex;
-        const entryId = liveIndex.findByPath(currentRelPath);
-        if (entryId) {
-          liveIndex.updatePath(entryId, newRelativePath);
-        }
-        await this.recordOwnMutation(liveIndex);
-        return { newPath: `${collectionPath}/${safeNewSlug}` };
-      });
-      if (typeof outcome !== "symbol")
-        return outcome;
-    }
-    throw new ContentConflictError();
+          await fs9.unlink(currentPath);
+          const newRelativePath = path10.relative(this.root, newPath);
+          const liveIndex = this._idIndex;
+          const entryId = liveIndex.findByPath(currentRelPath);
+          if (entryId) {
+            liveIndex.updatePath(entryId, newRelativePath);
+          }
+          await this.recordOwnMutation(liveIndex);
+          return { newPath: `${collectionPath}/${safeNewSlug}` };
+        });
+        if (typeof outcome !== "symbol")
+          return outcome;
+      }
+      throw new ContentConflictError();
+    });
   }
   /**
    * List all entries in a collection tree (including subcollections).
@@ -2953,8 +3222,8 @@ var ContentStore = class {
 };
 
 // dist/ai/generate.js
-import path9 from "node:path";
-import fs9 from "node:fs/promises";
+import path11 from "node:path";
+import fs10 from "node:fs/promises";
 import { minimatch } from "minimatch";
 
 // dist/ai/strip-mdx.js
@@ -3029,14 +3298,44 @@ var BLOCK_RESTORE_RE = /<<CODEBLOCK(\d+)>>/g;
 var INLINE_PREFIX = "<<INLINECODE";
 var INLINE_SUFFIX = ">>";
 var INLINE_RESTORE_RE = /<<INLINECODE(\d+)>>/g;
+function isFenceCloseLine(line, marker) {
+  return line.startsWith(marker) && /^\s*$/.test(line.slice(marker.length));
+}
+function maskFencedCodeBlocks(body, blocks) {
+  const lines = body.split("\n");
+  const lineCount = lines.length;
+  const nextCloseLine = {
+    "```": new Array(lineCount + 1).fill(-1),
+    "~~~": new Array(lineCount + 1).fill(-1)
+  };
+  for (let i2 = lineCount - 1; i2 >= 0; i2--) {
+    nextCloseLine["```"][i2] = isFenceCloseLine(lines[i2], "```") ? i2 : nextCloseLine["```"][i2 + 1];
+    nextCloseLine["~~~"][i2] = isFenceCloseLine(lines[i2], "~~~") ? i2 : nextCloseLine["~~~"][i2 + 1];
+  }
+  const outLines = [];
+  let i = 0;
+  while (i < lineCount) {
+    const line = lines[i];
+    const marker = line.startsWith("```") ? "```" : line.startsWith("~~~") ? "~~~" : null;
+    const searchFrom = i + 2;
+    const closeIndex = marker && searchFrom < lineCount ? nextCloseLine[marker][searchFrom] : -1;
+    if (!marker || closeIndex === -1) {
+      outLines.push(line);
+      i++;
+      continue;
+    }
+    const block = lines.slice(i, closeIndex + 1).join("\n");
+    const idx = blocks.length;
+    blocks.push(block);
+    outLines.push(`${BLOCK_PREFIX}${idx}${BLOCK_SUFFIX}`);
+    i = closeIndex + 1;
+  }
+  return outLines.join("\n");
+}
 function maskCodeBlocks(body) {
   const blocks = [];
   const inlines = [];
-  let masked = body.replace(/^(```|~~~).*\n[\s\S]*?\n\1\s*$/gm, (block) => {
-    const idx = blocks.length;
-    blocks.push(block);
-    return `${BLOCK_PREFIX}${idx}${BLOCK_SUFFIX}`;
-  });
+  let masked = maskFencedCodeBlocks(body, blocks);
   masked = masked.replace(/``[^`]+``|`[^`]+`/g, (span) => {
     const idx = inlines.length;
     inlines.push(span);
@@ -3149,7 +3448,7 @@ function entryToMarkdown(entry, config) {
 }
 function renderMarkdownEntry(entry, config, skipFields) {
   const parts = [];
-  const bodyFieldTypes = /* @__PURE__ */ new Set(["rich-text", "markdown", "mdx"]);
+  const bodyFieldTypes = /* @__PURE__ */ new Set(["markdown", "mdx"]);
   const metadataFields = flattenGroupFields(entry.fields).filter((f) => !bodyFieldTypes.has(f.type) && !skipFields.has(f.name));
   for (const field of metadataFields) {
     const value = entry.data[field.name];
@@ -3221,7 +3520,6 @@ ${String(value)}`;
       return `${heading} ${label}${descriptionLine}
 
 ${value ? "Yes" : "No"}`;
-    case "rich-text":
     case "markdown":
     case "mdx":
       return `${heading} ${label}${descriptionLine}
@@ -3492,8 +3790,8 @@ function computeEntryUrl(collection, slug, contentRoot) {
   if (slug && slug !== "index") {
     segments.push(slug);
   }
-  const path19 = segments.length > 0 ? `/${segments.join("/")}` : "/";
-  return path19.toLowerCase();
+  const path20 = segments.length > 0 ? `/${segments.join("/")}` : "/";
+  return path20.toLowerCase();
 }
 
 // dist/entry-link-resolver.js
@@ -3668,7 +3966,7 @@ async function processCollection(store, collection, flatSchema, contentRoot, con
   const listed = await store.getCollectionEntryPaths(collection.logicalPath);
   const directEntries = listed.filter((e) => e.collection === collection.logicalPath);
   for (const listEntry of directEntries) {
-    const entryTypeName = extractEntryTypeFromFilename(path9.basename(listEntry.relativePath));
+    const entryTypeName = extractEntryTypeFromFilename(path11.basename(listEntry.relativePath));
     if (!entryTypeName)
       continue;
     if (config?.exclude?.entryTypes?.includes(entryTypeName))
@@ -3686,7 +3984,7 @@ async function processCollection(store, collection, flatSchema, contentRoot, con
       }
       if (config?.exclude?.where?.(aiEntry))
         continue;
-      await runEntryTransform(aiEntry, doc.absolutePath, extractIdFromFilename(path9.basename(listEntry.relativePath)), config);
+      await runEntryTransform(aiEntry, doc.absolutePath, extractIdFromFilename(path11.basename(listEntry.relativePath)), config);
       entries.push(aiEntry);
       const entryFilePath = `${cleanPath}/${listEntry.slug}.md`;
       const entryMarkdown = entryToMarkdown(aiEntry, config);
@@ -3737,7 +4035,7 @@ async function processRootEntries(store, rootCollection, contentRoot, config, id
   const listed = await store.getCollectionEntryPaths(rootCollection.logicalPath);
   const directEntries = listed.filter((e) => e.collection === rootCollection.logicalPath);
   for (const listEntry of directEntries) {
-    const entryTypeName = extractEntryTypeFromFilename(path9.basename(listEntry.relativePath));
+    const entryTypeName = extractEntryTypeFromFilename(path11.basename(listEntry.relativePath));
     if (!entryTypeName)
       continue;
     if (config?.exclude?.entryTypes?.includes(entryTypeName))
@@ -3755,7 +4053,7 @@ async function processRootEntries(store, rootCollection, contentRoot, config, id
       }
       if (config?.exclude?.where?.(aiEntry))
         continue;
-      await runEntryTransform(aiEntry, doc.absolutePath, extractIdFromFilename(path9.basename(listEntry.relativePath)), config);
+      await runEntryTransform(aiEntry, doc.absolutePath, extractIdFromFilename(path11.basename(listEntry.relativePath)), config);
       entries.push(aiEntry);
       const entryFilePath = `${listEntry.slug}.md`;
       const entryMarkdown = entryToMarkdown(aiEntry, config);
@@ -3803,19 +4101,19 @@ function docToAIEntry(doc, slug, entryTypeName, entryTypeConfig, cleanCollection
   };
 }
 function makeReadSibling(dir) {
-  const resolvedDir = path9.resolve(dir);
+  const resolvedDir = path11.resolve(dir);
   return async (name) => {
-    if (!name || name.includes("/") || name.includes("\\") || path9.isAbsolute(name) || hasTraversalSequence(name)) {
+    if (!name || name.includes("/") || name.includes("\\") || path11.isAbsolute(name) || hasTraversalSequence(name)) {
       return null;
     }
-    const abs = path9.resolve(resolvedDir, name);
-    if (path9.dirname(abs) !== resolvedDir)
+    const abs = path11.resolve(resolvedDir, name);
+    if (path11.dirname(abs) !== resolvedDir)
       return null;
     try {
-      const stats = await fs9.lstat(abs);
+      const stats = await fs10.lstat(abs);
       if (!stats.isFile())
         return null;
-      return await fs9.readFile(abs, "utf8");
+      return await fs10.readFile(abs, "utf8");
     } catch (err) {
       if (isNodeError(err) && (err.code === "ENOENT" || err.code === "ENOTDIR"))
         return null;
@@ -3829,7 +4127,7 @@ async function runEntryTransform(entry, absolutePath, contentId, config) {
     return;
   const ctx = {
     contentId: contentId ?? "",
-    readSibling: makeReadSibling(path9.dirname(absolutePath))
+    readSibling: makeReadSibling(path11.dirname(absolutePath))
   };
   try {
     const appended = await transform(entry, ctx);
@@ -3866,15 +4164,15 @@ function matchesBundleFilter(entry, filter, contentRoot) {
 }
 
 // dist/branch-workspace.js
-import path15 from "node:path";
+import path16 from "node:path";
 
 // dist/branch-metadata.js
-import fs12 from "node:fs/promises";
-import path12 from "node:path";
+import fs13 from "node:fs/promises";
+import path14 from "node:path";
 
 // dist/branch-registry.js
-import fs10 from "node:fs/promises";
-import path10 from "node:path";
+import fs11 from "node:fs/promises";
+import path12 from "node:path";
 init_logger();
 var log3 = createDebugLogger({ prefix: "BranchRegistry" });
 var REGISTRY_FILE = "branches.json";
@@ -3887,10 +4185,10 @@ var BranchRegistry = class {
   constructor(root) {
     this.regenInFlight = null;
     this.lastForcedRefreshMs = 0;
-    this.root = path10.resolve(root);
-    this.registryPath = path10.join(this.root, REGISTRY_FILE);
-    this.stalePath = path10.join(this.root, REGISTRY_STALE_FILE);
-    this.tempPath = path10.join(this.root, REGISTRY_TEMP_FILE);
+    this.root = path12.resolve(root);
+    this.registryPath = path12.join(this.root, REGISTRY_FILE);
+    this.stalePath = path12.join(this.root, REGISTRY_STALE_FILE);
+    this.tempPath = path12.join(this.root, REGISTRY_TEMP_FILE);
   }
   /**
    * Returns all branches. Uses the cached snapshot if its embedded generation
@@ -3899,7 +4197,7 @@ var BranchRegistry = class {
   async list() {
     let parsed;
     try {
-      const raw = await fs10.readFile(this.registryPath, "utf8");
+      const raw = await fs11.readFile(this.registryPath, "utf8");
       parsed = JSON.parse(raw);
     } catch (err) {
       if (isNotFoundError(err)) {
@@ -3988,7 +4286,7 @@ var BranchRegistry = class {
   async performRegenerate() {
     const read = await readResourceGeneration(this.root, RESOURCE2);
     const branches = await this.scanBranchDirectories();
-    await fs10.unlink(this.stalePath).catch(() => {
+    await fs11.unlink(this.stalePath).catch(() => {
     });
     if (!read.ok) {
       return branches;
@@ -3999,12 +4297,12 @@ var BranchRegistry = class {
       generation: read.token
     };
     const uniqueTempPath = `${this.tempPath}.${Date.now()}.${Math.random().toString(36).slice(2)}`;
-    await fs10.mkdir(this.root, { recursive: true });
-    await fs10.writeFile(uniqueTempPath, JSON.stringify(snapshot, null, 2) + "\n", "utf8");
+    await fs11.mkdir(this.root, { recursive: true });
+    await fs11.writeFile(uniqueTempPath, JSON.stringify(snapshot, null, 2) + "\n", "utf8");
     try {
-      await fs10.rename(uniqueTempPath, this.registryPath);
+      await fs11.rename(uniqueTempPath, this.registryPath);
     } catch (err) {
-      await fs10.unlink(uniqueTempPath).catch(() => {
+      await fs11.unlink(uniqueTempPath).catch(() => {
       });
       throw err;
     }
@@ -4018,12 +4316,12 @@ var BranchRegistry = class {
   async scanBranchDirectories() {
     const branches = [];
     try {
-      const entries = await fs10.readdir(this.root, { withFileTypes: true });
+      const entries = await fs11.readdir(this.root, { withFileTypes: true });
       for (const entry of entries) {
         if (!entry.isDirectory() || entry.name.startsWith(".")) {
           continue;
         }
-        const branchRoot = path10.join(this.root, entry.name);
+        const branchRoot = path12.join(this.root, entry.name);
         let meta;
         try {
           meta = await BranchMetadataFileManager.loadOnly(branchRoot);
@@ -4050,10 +4348,10 @@ var BranchRegistry = class {
 };
 
 // dist/utils/occ-json-write.js
-import fs11 from "node:fs/promises";
-import path11 from "node:path";
+import fs12 from "node:fs/promises";
+import path13 from "node:path";
 import { randomUUID as randomUUID2 } from "node:crypto";
-import lockfile from "proper-lockfile";
+import lockfile2 from "proper-lockfile";
 var log4 = createDebugLogger({ prefix: "OccJsonWrite" });
 var OccWriteConflictError = class extends Error {
   constructor(message = "Concurrent modification detected") {
@@ -4067,29 +4365,29 @@ async function writeOccJsonFile(filePath, payload, options) {
   const writeId = randomUUID2();
   const data = { ...payload, version: newVersion, writeId };
   const content = JSON.stringify(data, null, 2) + (trailingNewline ? "\n" : "");
-  const dir = path11.dirname(filePath);
-  await fs11.mkdir(dir, { recursive: true });
+  const dir = path13.dirname(filePath);
+  await fs12.mkdir(dir, { recursive: true });
   const tempPath = `${filePath}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`;
-  await fs11.writeFile(tempPath, content, "utf-8");
+  await fs12.writeFile(tempPath, content, "utf-8");
   if (expectedVersion === null) {
     try {
-      await fs11.link(tempPath, filePath);
+      await fs12.link(tempPath, filePath);
     } catch (err) {
-      await fs11.unlink(tempPath).catch(() => {
+      await fs12.unlink(tempPath).catch(() => {
       });
       if (isFileExistsError(err)) {
         throw new OccWriteConflictError();
       }
       throw err;
     }
-    await fs11.unlink(tempPath).catch(() => {
+    await fs12.unlink(tempPath).catch(() => {
     });
     return { version: newVersion, writeId };
   }
   try {
     let currentVersion = null;
     try {
-      const current = JSON.parse(await fs11.readFile(filePath, "utf-8"));
+      const current = JSON.parse(await fs12.readFile(filePath, "utf-8"));
       currentVersion = current.version ?? 0;
     } catch {
       currentVersion = null;
@@ -4097,16 +4395,16 @@ async function writeOccJsonFile(filePath, payload, options) {
     if (currentVersion !== expectedVersion) {
       throw new OccWriteConflictError();
     }
-    await fs11.rename(tempPath, filePath);
+    await fs12.rename(tempPath, filePath);
     if (settleMs > 0) {
       await new Promise((resolve2) => setTimeout(resolve2, settleMs));
     }
-    const afterWrite = JSON.parse(await fs11.readFile(filePath, "utf-8"));
+    const afterWrite = JSON.parse(await fs12.readFile(filePath, "utf-8"));
     if (afterWrite.writeId !== writeId) {
       throw new OccWriteConflictError();
     }
   } catch (err) {
-    await fs11.unlink(tempPath).catch(() => {
+    await fs12.unlink(tempPath).catch(() => {
     });
     throw err;
   }
@@ -4132,13 +4430,13 @@ async function withOccRetry(operation, options) {
   throw new Error("Unreachable");
 }
 async function withOccFileLock(filePath, fn) {
-  const dir = path11.dirname(filePath);
-  await fs11.mkdir(dir, { recursive: true });
+  const dir = path13.dirname(filePath);
+  await fs12.mkdir(dir, { recursive: true });
   const MAX_ATTEMPTS = 14;
   let release = null;
   for (let attempt = 1; release === null; attempt++) {
     try {
-      release = await lockfile.lock(filePath, {
+      release = await lockfile2.lock(filePath, {
         lockfilePath: `${filePath}.lock`,
         realpath: false,
         stale: 1e4,
@@ -4196,8 +4494,8 @@ var BranchMetadataCorruptError = class extends Error {
 };
 var BranchMetadataFileManager = class _BranchMetadataFileManager {
   constructor(branchRoot, baseRoot, options) {
-    this.branchRoot = path12.resolve(branchRoot);
-    this.filePath = path12.join(this.branchRoot, BRANCH_META_DIR, BRANCH_META_FILE);
+    this.branchRoot = path14.resolve(branchRoot);
+    this.filePath = path14.join(this.branchRoot, BRANCH_META_DIR, BRANCH_META_FILE);
     this.baseRoot = baseRoot;
     this.settleMs = options?.settleMs;
   }
@@ -4206,10 +4504,10 @@ var BranchMetadataFileManager = class _BranchMetadataFileManager {
    * Use this for read-only access (e.g., in registry scanning or loadBranchContext).
    */
   static async loadOnly(branchRoot) {
-    const resolvedRoot = path12.resolve(branchRoot);
-    const filePath = path12.join(resolvedRoot, BRANCH_META_DIR, BRANCH_META_FILE);
+    const resolvedRoot = path14.resolve(branchRoot);
+    const filePath = path14.join(resolvedRoot, BRANCH_META_DIR, BRANCH_META_FILE);
     try {
-      const raw = await fs12.readFile(filePath, "utf8");
+      const raw = await fs13.readFile(filePath, "utf8");
       return JSON.parse(raw);
     } catch (err) {
       if (isNotFoundError(err)) {
@@ -4230,7 +4528,7 @@ var BranchMetadataFileManager = class _BranchMetadataFileManager {
   }
   async load() {
     try {
-      const raw = await fs12.readFile(this.filePath, "utf8");
+      const raw = await fs13.readFile(this.filePath, "utf8");
       const parsed = JSON.parse(raw);
       const version = parsed.version ?? 0;
       return { meta: parsed, version };
@@ -4292,7 +4590,7 @@ var BranchMetadataFileManager = class _BranchMetadataFileManager {
    */
   async save(incoming) {
     try {
-      await fs12.stat(this.branchRoot);
+      await fs13.stat(this.branchRoot);
     } catch (err) {
       if (isNotFoundError(err)) {
         throw new BranchMetadataConflictError("Branch no longer exists");
@@ -4381,7 +4679,7 @@ init_operating_mode();
 
 // dist/git-manager.js
 import fs14 from "node:fs/promises";
-import path14 from "node:path";
+import path15 from "node:path";
 import { simpleGit as simpleGit2 } from "simple-git";
 
 // dist/utils/git.js
@@ -4404,6 +4702,10 @@ function isNetworkRemoteUrl(url) {
     return false;
   return COLON_BEFORE_SLASH_PATTERN.test(url);
 }
+var MISSING_REMOTE_REF_REASONS = ["couldn't find remote ref", "Couldn't find remote ref"];
+function isMissingRemoteRefFailure(message) {
+  return MISSING_REMOTE_REF_REASONS.some((reason) => message.includes(reason));
+}
 async function detectHeadBranch(repoRoot, fallback = "main") {
   try {
     const git = simpleGit({ baseDir: repoRoot });
@@ -4422,19 +4724,6 @@ async function resolveBaseBranch(options) {
   return "main";
 }
 
-// dist/utils/provisioning-lock.js
-import fs13 from "node:fs/promises";
-import path13 from "node:path";
-import lockfile2 from "proper-lockfile";
-async function acquireProvisioningLock(lockTargetDir, lockName) {
-  await fs13.mkdir(lockTargetDir, { recursive: true });
-  return lockfile2.lock(lockTargetDir, {
-    lockfilePath: path13.join(lockTargetDir, lockName),
-    retries: { retries: 600, factor: 1, minTimeout: 300, maxTimeout: 800, randomize: true },
-    stale: 3e4
-  });
-}
-
 // dist/git-manager.js
 var log5 = 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_]*)$/;
@@ -4450,8 +4739,8 @@ function gitChildEnv(overrides) {
 var remoteInitLocks = /* @__PURE__ */ new Map();
 var GITHUB_TRACKING_REF_PREFIX = "refs/remotes/github/";
 async function ensureGitExcludePattern(repoPath, pattern) {
-  const excludePath = path14.join(repoPath, ".git", "info", "exclude");
-  await fs14.mkdir(path14.dirname(excludePath), { recursive: true });
+  const excludePath = path15.join(repoPath, ".git", "info", "exclude");
+  await fs14.mkdir(path15.dirname(excludePath), { recursive: true });
   let content = "";
   try {
     content = await fs14.readFile(excludePath, "utf-8");
@@ -4476,14 +4765,23 @@ var GitConflictError = class extends Error {
     this.name = "GitConflictError";
   }
 };
+var GitRemoteRefMissingError = class extends Error {
+  constructor(branch, remote, gitError) {
+    super(`Remote '${remote}' has no ref for branch '${branch}' yet`);
+    this.branch = branch;
+    this.remote = remote;
+    this.gitError = gitError;
+    this.name = "GitRemoteRefMissingError";
+  }
+};
 var GitManager = class _GitManager {
   constructor(options, gitOptions) {
-    this.repoPath = path14.resolve(options.repoPath);
+    this.repoPath = path15.resolve(options.repoPath);
     this.baseBranch = options.baseBranch ?? "main";
     this.remote = options.remote ?? "origin";
     this.skipIndexMarker = options.skipIndexMarker ?? false;
     this.git = simpleGit2({ baseDir: this.repoPath, ...gitOptions });
-    this.git.env(gitChildEnv({ GIT_CEILING_DIRECTORIES: path14.dirname(this.repoPath) }));
+    this.git.env(gitChildEnv({ GIT_CEILING_DIRECTORIES: path15.dirname(this.repoPath) }));
   }
   static async cloneRepo(remoteUrl, targetPath, baseBranch = "main") {
     log5.debug("git", "Cloning repository", {
@@ -4525,7 +4823,7 @@ var GitManager = class _GitManager {
           remotePath: options.remotePath,
           baseBranch: options.baseBranch
         });
-        const remoteParent = path14.dirname(options.remotePath);
+        const remoteParent = path15.dirname(options.remotePath);
         releaseLock = await acquireProvisioningLock(remoteParent, ".remote-init.lock");
         let remoteExists = false;
         try {
@@ -4631,8 +4929,8 @@ var GitManager = class _GitManager {
    * --list` instead of `rev-parse --verify --quiet`: simple-git only fails a
    * task on stderr output, and `--quiet` suppresses exactly that).
    * `--end-of-options` guards the ref-name positionals the same way
-   * `push`/`forcePush` below do, since `branch` here can be a sanitized but
-   * otherwise caller-influenced string.
+   * `push` below does, since `branch` here can be a sanitized but otherwise
+   * caller-influenced string.
    *
    * A failure here therefore means the remote itself is unreadable and is
    * surfaced, NOT treated as "branch absent" — that would route
@@ -4781,7 +5079,7 @@ var GitManager = class _GitManager {
    */
   static async validateGitRepoExists(repoPath) {
     try {
-      const stat = await fs14.stat(path14.join(repoPath, ".git"));
+      const stat = await fs14.stat(path15.join(repoPath, ".git"));
       if (!stat.isDirectory()) {
         throw new Error(`Expected git repo at ${repoPath}`);
       }
@@ -4872,8 +5170,8 @@ var GitManager = class _GitManager {
     if (config.shouldAutoInitLocal) {
       const gitRoot = await this.findGitRoot();
       const sourceRoot = options.sourceRoot;
-      const sourcePath = sourceRoot ? path14.resolve(gitRoot, sourceRoot) : gitRoot;
-      const localRemotePath = path14.join(sourcePath, config.defaultRemotePath);
+      const sourcePath = sourceRoot ? path15.resolve(gitRoot, sourceRoot) : gitRoot;
+      const localRemotePath = path15.join(sourcePath, config.defaultRemotePath);
       await this.ensureLocalSimulatedRemote({
         remotePath: localRemotePath,
         sourcePath: gitRoot,
@@ -4901,7 +5199,7 @@ var GitManager = class _GitManager {
   static async repoExistsAt(workspacePath) {
     try {
       const checkGit = simpleGit2({ baseDir: workspacePath });
-      checkGit.env(gitChildEnv({ GIT_CEILING_DIRECTORIES: path14.dirname(workspacePath) }));
+      checkGit.env(gitChildEnv({ GIT_CEILING_DIRECTORIES: path15.dirname(workspacePath) }));
       await checkGit.raw(["rev-parse", "--git-dir"]);
       return true;
     } catch {
@@ -4923,12 +5221,12 @@ var GitManager = class _GitManager {
     const baseBranch = await resolveBaseBranch({
       defaultBaseBranch: options.baseBranch,
       mode: options.mode,
-      detectFrom: options.sourceRoot ? path14.resolve(process.cwd(), options.sourceRoot) : process.cwd()
+      detectFrom: options.sourceRoot ? path15.resolve(process.cwd(), options.sourceRoot) : process.cwd()
     });
     const remoteName = options.remoteName ?? "origin";
     const repoExists = await _GitManager.repoExistsAt(options.workspacePath);
     if (!repoExists) {
-      const gitPath = path14.join(options.workspacePath, ".git");
+      const gitPath = path15.join(options.workspacePath, ".git");
       try {
         const stat = await fs14.stat(gitPath);
         if (stat.isDirectory()) {
@@ -4962,7 +5260,7 @@ var GitManager = class _GitManager {
       }
       justCloned = true;
       const freshGit = simpleGit2({ baseDir: options.workspacePath });
-      freshGit.env(gitChildEnv({ GIT_CEILING_DIRECTORIES: path14.dirname(options.workspacePath) }));
+      freshGit.env(gitChildEnv({ GIT_CEILING_DIRECTORIES: path15.dirname(options.workspacePath) }));
       await freshGit.addConfig("canopycms.managed", "true");
       await freshGit.addConfig("user.name", options.gitBotAuthorName);
       await freshGit.addConfig("user.email", options.gitBotAuthorEmail);
@@ -5105,9 +5403,16 @@ var GitManager = class _GitManager {
   async pullCurrentBranchInner() {
     const branches = await this.git.branch();
     const currentBranch = branches.current;
-    await this.git.fetch(this.remote, currentBranch);
     try {
-      await this.git.merge([`${this.remote}/${currentBranch}`]);
+      await this.git.fetch(this.remote, currentBranch);
+    } catch (err) {
+      if (!isMissingRemoteRefFailure(getErrorMessage(err)))
+        throw err;
+      throw new GitRemoteRefMissingError(currentBranch, this.remote, err);
+    }
+    const fetchedTip = (await this.git.revparse(["FETCH_HEAD"])).trim();
+    try {
+      await this.git.merge([fetchedTip]);
     } catch (err) {
       try {
         const status = await this.git.status();
@@ -5169,6 +5474,44 @@ var GitManager = class _GitManager {
       `${target}:${target}`
     ]);
   }
+  /**
+   * Check whether the local branch has commits the remote mirror doesn't
+   * have -- i.e. whether push() would actually move the remote ref forward.
+   *
+   * Exists so callers (submitBranch) can gate pushing on "is there anything
+   * new to send" rather than on "is the working tree dirty": committing
+   * cleans the tree, so a dirty-tree gate around commit+push skips the push
+   * entirely on a retry after a failed push, even though the just-created
+   * commit never reached the remote (see services.ts submitBranch).
+   *
+   * Workspaces are cloned `--single-branch`, so the remote-tracking ref for
+   * any branch other than the one cloned never exists locally -- same
+   * constraint pullBaseInner works around. This fetches the specific branch
+   * directly (bypassing the configured single-branch refspec, exactly like
+   * pullBaseInner) and pins the result to FETCH_HEAD's SHA immediately after
+   * the fetch that populated it, rather than trusting `<remote>/<branch>`:
+   * FETCH_HEAD is a shared mutable file that any other fetch in this clone
+   * can repoint before it's read.
+   *
+   * A branch that has never been pushed has no ref on the remote at all --
+   * `git fetch` then fails ("couldn't find remote ref"), which this treats
+   * as "ahead" (needs pushing) rather than an error.
+   */
+  async hasUnpushedCommits(branch) {
+    const target = branch ?? await this.git.revparse(["--abbrev-ref", "--end-of-options", "HEAD"]);
+    const localSha = (await this.git.revparse(["--end-of-options", target])).trim();
+    let fetchedTip;
+    try {
+      await this.git.raw(["fetch", "--end-of-options", this.remote, target]);
+      fetchedTip = (await this.git.revparse(["--end-of-options", "FETCH_HEAD"])).trim();
+    } catch {
+      return true;
+    }
+    if (fetchedTip === localSha)
+      return false;
+    const aheadCount = (await this.git.raw(["rev-list", "--count", `${fetchedTip}..${localSha}`])).trim();
+    return aheadCount !== "0";
+  }
   async ensureAuthor(author) {
     const config = await this.git.listConfig();
     const isManaged = config.all["canopycms.managed"] === "true";
@@ -5215,14 +5558,6 @@ var GitManager = class _GitManager {
     const status = await this.status();
     return status.files.map((f) => f.path);
   }
-  /**
-   * Force push (use with caution - for PR updates only)
-   * Uses --force-with-lease for safer force pushes
-   */
-  async forcePush(branch) {
-    const target = branch ?? await this.git.revparse(["--abbrev-ref", "HEAD"]);
-    await this.git.raw(["push", "--force-with-lease", "--end-of-options", this.remote, target]);
-  }
   /**
    * Get remote URL for current repo
    */
@@ -5276,8 +5611,8 @@ var GitManager = class _GitManager {
     } catch {
     }
     for (const [filePath, content] of Object.entries(initialFiles)) {
-      const absolutePath = path14.join(this.repoPath, filePath);
-      await fs14.mkdir(path14.dirname(absolutePath), { recursive: true });
+      const absolutePath = path15.join(this.repoPath, filePath);
+      await fs14.mkdir(path15.dirname(absolutePath), { recursive: true });
       await fs14.writeFile(absolutePath, content, "utf-8");
       await this.git.add(filePath);
     }
@@ -5307,7 +5642,7 @@ var BranchWorkspaceManager = class {
             branchName: options.branchName,
             mode: options.mode
           });
-          releaseLock = await acquireProvisioningLock(path15.dirname(options.branchRoot), `.${path15.basename(options.branchRoot)}.init.lock`);
+          releaseLock = await acquireProvisioningLock(path16.dirname(options.branchRoot), `.${path16.basename(options.branchRoot)}.init.lock`);
           await GitManager.initializeWorkspace({
             workspacePath: options.branchRoot,
             branchName: options.branchName,
@@ -5348,7 +5683,7 @@ var BranchWorkspaceManager = class {
     const baseBranch = await resolveBaseBranch({
       defaultBaseBranch: this.config.defaultBaseBranch,
       mode,
-      detectFrom: this.config.sourceRoot ? path15.resolve(process.cwd(), this.config.sourceRoot) : void 0
+      detectFrom: this.config.sourceRoot ? path16.resolve(process.cwd(), this.config.sourceRoot) : void 0
     });
     await this.ensureGitWorkspace({
       branchRoot,
@@ -5433,7 +5768,7 @@ async function resolveBranchRoot(config) {
 
 // dist/content-listing.js
 import fs15 from "node:fs/promises";
-import path16 from "node:path";
+import path17 from "node:path";
 import matter2 from "gray-matter";
 import { parse as yamlParse2 } from "yaml";
 var log7 = createDebugLogger({ prefix: "ContentListing" });
@@ -5467,38 +5802,48 @@ var readEntryData = async (filePath, format, bodyFieldName = "body") => {
   }
 };
 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) {
-    const potentialType = parts[0];
-    const matchingType = entryTypes.find((e) => e.name === potentialType);
-    if (matchingType) {
-      const id = parts[parts.length - 1];
-      if (!isValidId(id))
-        return null;
-      const slug = parts.slice(1, -1).join(".").toLowerCase();
-      return {
-        type: potentialType,
-        slug,
-        id
-      };
-    }
+  if (parts.length < 3)
+    return null;
+  const potentialType = parts[0];
+  if (entryTypes && !entryTypes.some((e) => e.name === potentialType)) {
+    return null;
   }
-  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
+  };
 };
-async function listEntries(branchRoot, flatSchema, contentRootName, options) {
+async function listEntries(branchRoot, flatSchema, contentRootName, options, visibility) {
   const rootPath = options?.rootPath ?? contentRootName;
   const extract = options?.extract;
   const filter = options?.filter;
   const customSort = options?.sort;
   const collections = flatSchema.filter((item) => item.type === "collection" && item.entries !== void 0 && (item.logicalPath === rootPath || item.logicalPath.startsWith(`${rootPath}/`)));
+  const shouldInclude = visibility?.shouldInclude;
+  const skippedFiles = [];
   const collectionResults = await Promise.all(collections.map(async (collection) => {
-    const entries = await listCollectionEntries(branchRoot, collection);
-    return entries.map((entry) => ({ entry, collection }));
+    const entries = await listCollectionEntries(branchRoot, collection, (file) => skippedFiles.push(file));
+    const visible = shouldInclude ? entries.filter((e) => shouldInclude(e.physicalPath)) : entries;
+    return visible.map((entry) => ({ entry, collection }));
   }));
+  if (isBuildMode() && skippedFiles.length > 0) {
+    const lines = skippedFiles.map(({ filename, collectionPath }) => `  - ${collectionPath}/${filename}`);
+    throw new Error(`CanopyCMS static build: found ${skippedFiles.length} file(s) that look like malformed content entries inside a content collection:
+${lines.join("\n")}
+Expected {type}.{slug}.{id}.{ext} with a known entry type (a name declared in that collection's entries config) and a valid 12-char Base58 ID. This usually means a schema rename without a matching file rename, an entry type declared in one collection but not another, or a stray file placed directly in a collection directory. If this is meant to be a colocated sibling artifact (e.g. an entry's contentId-prefixed data file read via an entryTransforms readSibling call), keep its name to three or fewer dot-separated segments (id.suffix.ext) so it is never mistaken for an entry attempt. Otherwise rename or move the file, or fix the schema, then rebuild.`);
+  }
   const contentPrefix = contentRootName ? `${contentRootName}/` : "";
   const items = [];
   for (const results of collectionResults) {
@@ -5525,7 +5870,8 @@ async function listEntries(branchRoot, flatSchema, contentRootName, options) {
         entryType: entry.entryType,
         format: entry.format,
         data,
-        schema: collection.entries?.find((e) => e.name === entry.entryType)?.schema
+        schema: collection.entries?.find((e) => e.name === entry.entryType)?.schema,
+        updatedAt: entry.updatedAt
       };
       if (filter && !filter(item))
         continue;
@@ -5539,7 +5885,15 @@ async function listEntries(branchRoot, flatSchema, contentRootName, options) {
   }
   return items;
 }
-var listCollectionEntries = async (root, collection) => {
+var looksLikeMalformedEntry = (filename, entryTypes) => {
+  if (filename.startsWith(".") || filename.startsWith("_"))
+    return false;
+  const segments = filename.split(".");
+  if (segments.length >= 4)
+    return true;
+  return segments.length === 3 && entryTypes.some((e) => e.name === segments[0]);
+};
+var listCollectionEntries = async (root, collection, onSkip) => {
   if (collection.type !== "collection" || !collection.entries) {
     return [];
   }
@@ -5567,11 +5921,14 @@ var listCollectionEntries = async (root, collection) => {
   }
   const files = dirents.filter((d) => d.isFile() && validExts.some((ext) => d.name.endsWith(ext)) && d.name !== ".collection.json").sort((a, b) => a.name.localeCompare(b.name));
   const entries = await Promise.all(files.map(async (file) => {
-    const absolutePath = path16.join(collectionRoot, file.name);
+    const absolutePath = path17.join(collectionRoot, file.name);
     const relativePath = normalizePath(root, absolutePath);
     const parsed = parseTypedFilename(file.name, entryTypes);
     if (!parsed) {
       log7.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 });
+      }
       return null;
     }
     const { type: entryTypeName, slug, id: contentId } = parsed;
@@ -5633,7 +5990,7 @@ function resolveBlockItem(blockField, item) {
 
 // dist/validation/entry-validator.js
 var KNOWN_FIELD_TYPES = new Set(fieldTypes);
-var STRING_FIELD_TYPES = /* @__PURE__ */ new Set(["string", "rich-text", "markdown", "mdx", "code"]);
+var STRING_FIELD_TYPES = /* @__PURE__ */ new Set(["string", "markdown", "mdx", "code"]);
 function isPlainRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -5649,30 +6006,30 @@ function isValidImageCropValue(value) {
   }
   return isValidCropRect(x, y, w, h);
 }
-function validateImageValue(field, value, path19) {
+function validateImageValue(field, value, path20) {
   if (!isPlainRecord2(value)) {
-    return [{ fieldPath: path19, message: "Expected an image object with { src, alt }" }];
+    return [{ fieldPath: path20, message: "Expected an image object with { src, alt }" }];
   }
   const errors = [];
   if (typeof value.src !== "string" || value.src.trim() === "") {
-    errors.push({ fieldPath: `${path19}.src`, message: "Image src is required" });
+    errors.push({ fieldPath: `${path20}.src`, message: "Image src is required" });
   }
   if (typeof value.alt !== "string") {
-    errors.push({ fieldPath: `${path19}.alt`, message: "Image alt text is required" });
+    errors.push({ fieldPath: `${path20}.alt`, message: "Image alt text is required" });
   } else if (value.alt.trim() === "" && field.altOptional !== true) {
-    errors.push({ fieldPath: `${path19}.alt`, message: "Image alt text is required" });
+    errors.push({ fieldPath: `${path20}.alt`, message: "Image alt text is required" });
   }
   if (value.width !== void 0 && !isPositiveInt(value.width)) {
-    errors.push({ fieldPath: `${path19}.width`, message: "Image width must be a positive integer" });
+    errors.push({ fieldPath: `${path20}.width`, message: "Image width must be a positive integer" });
   }
   if (value.height !== void 0 && !isPositiveInt(value.height)) {
     errors.push({
-      fieldPath: `${path19}.height`,
+      fieldPath: `${path20}.height`,
       message: "Image height must be a positive integer"
     });
   }
   if (value.crop !== void 0 && !isValidImageCropValue(value.crop)) {
-    errors.push({ fieldPath: `${path19}.crop`, message: "Invalid image crop rect" });
+    errors.push({ fieldPath: `${path20}.crop`, message: "Invalid image crop rect" });
   }
   return errors;
 }
@@ -5684,44 +6041,44 @@ function referenceValueId(value) {
   return void 0;
 }
 var selectOptionValues = (field) => (field.options ?? []).map((opt) => typeof opt === "string" ? opt : opt.value);
-function validateScalar(field, value, path19) {
+function validateScalar(field, value, path20) {
   switch (field.type) {
     case "number":
       if (typeof value !== "number" || !Number.isFinite(value)) {
-        return [{ fieldPath: path19, message: "Expected a number" }];
+        return [{ fieldPath: path20, message: "Expected a number" }];
       }
       return [];
     case "boolean":
       if (typeof value !== "boolean") {
-        return [{ fieldPath: path19, message: "Expected true or false" }];
+        return [{ fieldPath: path20, message: "Expected true or false" }];
       }
       return [];
     case "datetime":
       if (typeof value !== "string" || value !== "" && Number.isNaN(Date.parse(value))) {
-        return [{ fieldPath: path19, message: "Expected a valid date/time string" }];
+        return [{ fieldPath: path20, message: "Expected a valid date/time string" }];
       }
       return [];
     case "select": {
       if (typeof value !== "string") {
-        return [{ fieldPath: path19, message: "Expected a selection" }];
+        return [{ fieldPath: path20, message: "Expected a selection" }];
       }
       const options = selectOptionValues(field);
       if (value !== "" && !options.includes(value)) {
-        return [{ fieldPath: path19, message: `Must be one of: ${options.join(", ")}` }];
+        return [{ fieldPath: path20, message: `Must be one of: ${options.join(", ")}` }];
       }
       return [];
     }
     case "reference":
       if (referenceValueId(value) === void 0) {
-        return [{ fieldPath: path19, message: "Expected a reference id" }];
+        return [{ fieldPath: path20, message: "Expected a reference id" }];
       }
       return [];
     case "image":
-      return validateImageValue(field, value, path19);
+      return validateImageValue(field, value, path20);
     default:
       if (STRING_FIELD_TYPES.has(field.type)) {
         if (typeof value !== "string") {
-          return [{ fieldPath: path19, message: "Expected text" }];
+          return [{ fieldPath: path20, message: "Expected text" }];
         }
       }
       return [];
@@ -5744,12 +6101,12 @@ function validateEntryData(fields, data, pathPrefix = "") {
       errors.push(...validateEntryData(field.fields, data, pathPrefix));
       continue;
     }
-    const path19 = pathPrefix ? `${pathPrefix}.${field.name}` : field.name;
+    const path20 = pathPrefix ? `${pathPrefix}.${field.name}` : field.name;
     const value = data[field.name];
     const isRequired = "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: path19, message });
+      errors.push({ fieldPath: path20, message });
       continue;
     }
     if (value === void 0 || value === null)
@@ -5757,11 +6114,11 @@ function validateEntryData(fields, data, pathPrefix = "") {
     if (field.type === "block") {
       const blockField = field;
       if (!Array.isArray(value)) {
-        errors.push({ fieldPath: path19, message: "Expected a list of blocks" });
+        errors.push({ fieldPath: path20, message: "Expected a list of blocks" });
         continue;
       }
       value.forEach((item, index) => {
-        const itemPath = `${path19}[${index}]`;
+        const itemPath = `${path20}[${index}]`;
         if (!isPlainRecord2(item)) {
           errors.push({ fieldPath: itemPath, message: "Expected a block object" });
           return;
@@ -5783,11 +6140,11 @@ function validateEntryData(fields, data, pathPrefix = "") {
       const objectField = field;
       if (objectField.list) {
         if (!Array.isArray(value)) {
-          errors.push({ fieldPath: path19, message: "Expected a list of items" });
+          errors.push({ fieldPath: path20, message: "Expected a list of items" });
           continue;
         }
         value.forEach((item, index) => {
-          const itemPath = `${path19}[${index}]`;
+          const itemPath = `${path20}[${index}]`;
           if (!isPlainRecord2(item)) {
             errors.push({ fieldPath: itemPath, message: "Expected an object" });
             return;
@@ -5797,27 +6154,27 @@ function validateEntryData(fields, data, pathPrefix = "") {
           }
         });
       } else if (!isPlainRecord2(value)) {
-        errors.push({ fieldPath: path19, message: "Expected an object" });
+        errors.push({ fieldPath: path20, message: "Expected an object" });
       } else if (objectField.fields) {
-        errors.push(...validateEntryData(objectField.fields, value, path19));
+        errors.push(...validateEntryData(objectField.fields, value, path20));
       }
       continue;
     }
     if ("list" in field && field.list) {
       if (!Array.isArray(value)) {
-        errors.push({ fieldPath: path19, message: "Expected a list of values" });
+        errors.push({ fieldPath: path20, message: "Expected a list of values" });
         continue;
       }
       value.forEach((item, index) => {
-        errors.push(...validateScalar(field, item, `${path19}[${index}]`));
+        errors.push(...validateScalar(field, item, `${path20}[${index}]`));
       });
       continue;
     }
     if (Array.isArray(value) && KNOWN_FIELD_TYPES.has(field.type)) {
-      errors.push({ fieldPath: path19, message: "Expected a single value, not a list" });
+      errors.push({ fieldPath: path20, message: "Expected a single value, not a list" });
       continue;
     }
-    errors.push(...validateScalar(field, value, path19));
+    errors.push(...validateScalar(field, value, path20));
   }
   return errors;
 }
@@ -5887,14 +6244,14 @@ async function generateAIContentFiles(options) {
     config: aiConfig,
     entryLinkUrl: config.entryLinkUrl
   });
-  const absoluteOutputDir = path17.resolve(outputDir) + path17.sep;
+  const absoluteOutputDir = path18.resolve(outputDir) + path18.sep;
   let fileCount = 0;
   for (const [filePath, content] of result.files) {
-    const absolutePath = path17.resolve(path17.join(absoluteOutputDir, filePath));
+    const absolutePath = path18.resolve(path18.join(absoluteOutputDir, filePath));
     if (!absolutePath.startsWith(absoluteOutputDir)) {
       throw new Error(`Path traversal detected in AI content output: ${filePath}`);
     }
-    await fs16.mkdir(path17.dirname(absolutePath), { recursive: true });
+    await fs16.mkdir(path18.dirname(absolutePath), { recursive: true });
     await fs16.writeFile(absolutePath, content, "utf-8");
     fileCount++;
   }
@@ -5906,7 +6263,7 @@ var jiti = createJiti(import.meta.url);
 async function generateAIContentCLI(options) {
   const { projectDir, outputDir = "public/ai", configPath, appDir = "app" } = options;
   console.log("\nCanopyCMS generate-ai-content\n");
-  const canopyConfigPath = path18.join(projectDir, "canopycms.config.ts");
+  const canopyConfigPath = path19.join(projectDir, "canopycms.config.ts");
   let canopyConfigModule;
   try {
     canopyConfigModule = await jiti.import(canopyConfigPath);
@@ -5917,7 +6274,7 @@ async function generateAIContentCLI(options) {
   }
   const configExport = canopyConfigModule.default ?? canopyConfigModule.config ?? canopyConfigModule;
   const serverConfig = typeof configExport === "object" && configExport !== null && "server" in configExport ? configExport.server : configExport;
-  const schemasPath = path18.join(projectDir, appDir, "schemas.ts");
+  const schemasPath = path19.join(projectDir, appDir, "schemas.ts");
   let entrySchemaRegistry = {};
   try {
     const schemasModule = await jiti.import(schemasPath);
@@ -5928,7 +6285,7 @@ async function generateAIContentCLI(options) {
   let aiConfig;
   if (configPath) {
     try {
-      const aiConfigModule = await jiti.import(path18.resolve(configPath));
+      const aiConfigModule = await jiti.import(path19.resolve(configPath));
       aiConfig = aiConfigModule.aiContentConfig ?? aiConfigModule.default ?? aiConfigModule.config;
     } catch (err) {
       console.error(`Could not load AI config from ${configPath}`);
@@ -5945,7 +6302,7 @@ async function generateAIContentCLI(options) {
     console.error("Make sure canopycms.config.ts uses defineCanopyConfig().");
     process.exit(1);
   }
-  const resolvedOutput = path18.resolve(projectDir, outputDir);
+  const resolvedOutput = path19.resolve(projectDir, outputDir);
   console.log(`  Output: ${resolvedOutput}`);
   console.log(`  Mode: ${serverConfig.mode ?? "dev"}`);
   const result = await generateAIContentFiles({