canopycms 0.0.61 → 0.0.62

package/dist/cli/cli.js

@@ -112,6 +112,9 @@ import path7 from "node:path";
 import * as p from "@clack/prompts";
 import { createJiti } from "jiti";
 import path8 from "node:path";
+function canopyLogWarn(...args) {
+  active.warn(...args);
+}
 function getErrorMessage2(err) {
   if (err instanceof Error) {
     return err.message;
@@ -740,9 +743,6 @@ async function moveToCorrupt(taskDir, sourceDir, fileName, reason, logger) {
     });
   }
 }
-function canopyLogWarn(...args) {
-  active.warn(...args);
-}
 function resolveDeploymentName(config, modeDefault) {
   const envValue = process.env.CANOPYCMS_DEPLOYMENT_NAME?.trim();
   const configValue = config.deploymentName;
@@ -1047,7 +1047,7 @@ CanopyCMS worker run-once (mode: ${mode}, auth: ${authMode})
   }
   console.log("\nDone");
 }
-var __defProp2, __getOwnPropNames2, __esm2, __export2, primitiveFieldTypes, fieldTypes, init_types, fieldBaseSchema, selectOptionSchema, referenceOptionSchema, primitiveFieldSchema, ASPECT_RATIO_RE, imageFieldSchema, selectFieldSchema, referenceFieldSchema, fieldHolder, blockSchema, blockFieldSchema, objectFieldSchema, inlineGroupFieldSchema, customFieldSchema, knownFieldSchema, fieldSchema, init_field, relativePathSchema, entryTypeSchema, collectionSchema, init_collection, mediaSchema, init_media, defaultBranchAccessSchema, defaultPathAccessLevelSchema, defaultPathAccessLevelsSchema, defaultPathAccessSchema, defaultBaseBranchSchema, defaultRemoteNameSchema, defaultRemoteUrlSchema, gitBotAuthorNameSchema, gitBotAuthorEmailSchema, githubTokenEnvVarSchema, operatingModeSchema, deployedAsSchema, contentRootSchema, sourceRootSchema, deploymentNameSchema, devContentSyncSchema, devConfigSchema, editorConfigSchema, CanopyConfigSchema, DEFAULT_PROD_WORKSPACE, init_config, permissionTargetSchema, pathPermissionSchema, init_permissions, init_normalize, init_types2, init_flatten, init_validation, init_helpers, init_config2, init_error2, init_fs2, templates_exports, __dirname, TEMPLATES_DIR, SCAFFOLD_STACK_NAME, init_templates, project_detect_exports, COMMANDS, MAX_WORKSPACE_DEPTH, CDK_DEPENDENCIES, init_project_detect, task_queue_config_exports, init_task_queue_config, LOG_LEVELS, DebugLogger, testLogger, init_debug, init_atomic_write, DEFAULT_MAX_RETRIES, nullLogger, init_task_queue, init_task_queue2, task_queue_exports, debugLogger, cmsTaskQueueLogger, init_task_queue3, ProdClientSafeStrategy, DevClientSafeStrategy, active, warned, VALID_DEPLOYMENT_NAME, isValidDeploymentName, ProdStrategy, DevStrategy, strategyCache;
+var __defProp2, __getOwnPropNames2, __esm2, __export2, active, init_logger, primitiveFieldTypes, fieldTypes, init_types, fieldBaseSchema, selectOptionSchema, referenceOptionSchema, primitiveFieldSchema, ASPECT_RATIO_RE, imageFieldSchema, selectFieldSchema, referenceFieldSchema, fieldHolder, blockSchema, blockFieldSchema, objectFieldSchema, inlineGroupFieldSchema, customFieldSchema, knownFieldSchema, fieldSchema, init_field, relativePathSchema, entryTypeSchema, collectionSchema, init_collection, mediaSchema, init_media, defaultBranchAccessSchema, defaultPathAccessLevelSchema, defaultPathAccessLevelsSchema, defaultPathAccessSchema, defaultBaseBranchSchema, defaultRemoteNameSchema, defaultRemoteUrlSchema, gitBotAuthorNameSchema, gitBotAuthorEmailSchema, githubTokenEnvVarSchema, operatingModeSchema, deployedAsSchema, contentRootSchema, sourceRootSchema, deploymentNameSchema, devContentSyncSchema, devConfigSchema, editorConfigSchema, CanopyConfigSchema, DEFAULT_PROD_WORKSPACE, init_config, permissionTargetSchema, pathPermissionSchema, init_permissions, init_normalize, init_types2, init_flatten, init_mode_env, init_validation, init_helpers, init_config2, init_error2, init_fs2, templates_exports, __dirname, TEMPLATES_DIR, SCAFFOLD_STACK_NAME, init_templates, project_detect_exports, COMMANDS, MAX_WORKSPACE_DEPTH, CDK_DEPENDENCIES, init_project_detect, task_queue_config_exports, init_task_queue_config, LOG_LEVELS, DebugLogger, testLogger, init_debug, init_atomic_write, DEFAULT_MAX_RETRIES, nullLogger, init_task_queue, init_task_queue2, task_queue_exports, debugLogger, cmsTaskQueueLogger, init_task_queue3, ProdClientSafeStrategy, DevClientSafeStrategy, warned, VALID_DEPLOYMENT_NAME, isValidDeploymentName, ProdStrategy, DevStrategy, strategyCache;
 var init_init = __esm({
   "dist/cli/init.js"() {
     "use strict";
@@ -1060,6 +1060,12 @@ var init_init = __esm({
       for (var name in all)
         __defProp2(target, name, { get: all[name], enumerable: true });
     };
+    init_logger = __esm2({
+      "dist/utils/logger.js"() {
+        "use strict";
+        active = console;
+      }
+    });
     init_types = __esm2({
       "dist/config/types.js"() {
         "use strict";
@@ -1068,7 +1074,6 @@ var init_init = __esm({
           "number",
           "boolean",
           "datetime",
-          "rich-text",
           "markdown",
           "mdx",
           "code"
@@ -1353,11 +1358,18 @@ var init_init = __esm({
         init_types2();
       }
     });
+    init_mode_env = __esm2({
+      "dist/operating-mode/mode-env.js"() {
+        "use strict";
+        init_logger();
+      }
+    });
     init_validation = __esm2({
       "dist/config/validation.js"() {
         "use strict";
         init_config();
         init_flatten();
+        init_mode_env();
       }
     });
     init_helpers = __esm2({
@@ -1700,7 +1712,7 @@ var init_init = __esm({
         return true;
       }
     };
-    active = console;
+    init_logger();
     warned = 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");
@@ -1814,6 +1826,7 @@ var init_init = __esm({
       }
     };
     strategyCache = /* @__PURE__ */ new Map();
+    init_mode_env();
     init_fs2();
     init_error2();
   }
@@ -1831,62 +1844,63 @@ import { isAbsolute as isAbsolute2 } from "pathe";
 import { z as z42 } from "zod";
 import { z as z52 } from "zod";
 import { z as z6 } from "zod";
-import path62 from "node:path";
-import path18 from "node:path";
+import path82 from "node:path";
+import path19 from "node:path";
 import { createJiti as createJiti2 } from "jiti";
 import fs16 from "node:fs/promises";
-import path17 from "node:path";
-import fs8 from "node:fs/promises";
-import path82 from "node:path";
+import path18 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";
 import fs7 from "node:fs/promises";
 import path9 from "node:path";
+import path32 from "node:path";
 import fs23 from "node:fs/promises";
 import path22 from "node:path";
-import { generate } from "short-uuid";
-import path32 from "node:path";
+import lockfile from "proper-lockfile";
 import fs32 from "node:fs/promises";
 import path42 from "node:path";
-import { randomUUID } from "node:crypto";
-import fs52 from "node:fs/promises";
+import { generate } from "short-uuid";
 import path52 from "node:path";
-import { promises as fs42 } from "fs";
+import fs42 from "node:fs/promises";
+import path62 from "node:path";
+import { randomUUID } from "node:crypto";
+import fs62 from "node:fs/promises";
+import path72 from "node:path";
+import { promises as fs52 } from "fs";
 import { join as join3 } from "pathe";
 import { z as z7 } from "zod";
 import chokidar from "chokidar";
-import fs62 from "node:fs/promises";
-import { sep, resolve, relative } from "node:path";
 import fs72 from "node:fs/promises";
-import path72 from "node:path";
+import { sep, resolve, relative } from "node:path";
+import fs8 from "node:fs/promises";
 import path92 from "node:path";
-import fs9 from "node:fs/promises";
-import { minimatch } from "minimatch";
-import path15 from "node:path";
-import fs12 from "node:fs/promises";
-import path12 from "node:path";
+import path11 from "node:path";
 import fs10 from "node:fs/promises";
-import path10 from "node:path";
+import { minimatch } from "minimatch";
+import path16 from "node:path";
+import fs13 from "node:fs/promises";
+import path14 from "node:path";
 import fs11 from "node:fs/promises";
-import path11 from "node:path";
+import path12 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";
 import fs14 from "node:fs/promises";
-import path14 from "node:path";
+import path15 from "node:path";
 import { simpleGit as simpleGit2 } from "simple-git";
 import { simpleGit as simpleGit3 } from "simple-git";
-import fs13 from "node:fs/promises";
-import path13 from "node:path";
-import lockfile2 from "proper-lockfile";
 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";
-function normalizeFilesystemPath(path192) {
-  return path192.split(/[\\/]+/).filter(Boolean).join("/");
+function normalizeFilesystemPath(path202) {
+  return path202.split(/[\\/]+/).filter(Boolean).join("/");
 }
-function hasTraversalSequence(path192) {
-  const normalized = normalizeFilesystemPath(path192);
+function hasTraversalSequence(path202) {
+  const normalized = normalizeFilesystemPath(path202);
   return normalized.includes("..");
 }
 function createLogicalPath(...segments) {
@@ -1896,14 +1910,14 @@ function createLogicalPath(...segments) {
   }
   return normalized;
 }
-function trimSlashes(path192) {
+function trimSlashes(path202) {
   let start = 0;
-  let end = path192.length;
-  while (start < end && path192[start] === "/")
+  let end = path202.length;
+  while (start < end && path202[start] === "/")
     start++;
-  while (end > start && path192[end - 1] === "/")
+  while (end > start && path202[end - 1] === "/")
     end--;
-  return path192.slice(start, end);
+  return path202.slice(start, end);
 }
 function canopyLogWarn2(...args) {
   active2.warn(...args);
@@ -1911,6 +1925,28 @@ function canopyLogWarn2(...args) {
 function canopyLogError(...args) {
   active2.error(...args);
 }
+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 && !warned2) {
+    canopyLogWarn2(`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.`);
+    warned2 = true;
+  }
+  return env.value;
+}
 function clientOperatingStrategy(mode) {
   const cached = clientStrategyCache.get(mode);
   if (cached)
@@ -1937,9 +1973,9 @@ function clearClientStrategyCache() {
 function resolveDeploymentName2(config, modeDefault) {
   const envValue = process.env.CANOPYCMS_DEPLOYMENT_NAME?.trim();
   const configValue = config.deploymentName;
-  if (envValue && configValue && envValue !== configValue && !warned2) {
+  if (envValue && configValue && envValue !== configValue && !warned22) {
     canopyLogWarn2(`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.`);
-    warned2 = true;
+    warned22 = true;
   }
   const resolved = envValue || configValue || modeDefault;
   if (!isValidDeploymentName2(resolved)) {
@@ -2000,6 +2036,70 @@ async function withLock(key, fn) {
       locks.delete(key);
   }
 }
+function getErrorMessage3(err) {
+  if (err instanceof Error) {
+    return err.message;
+  }
+  if (typeof err === "string") {
+    return err;
+  }
+  return String(err);
+}
+function isNodeError3(err) {
+  return err instanceof Error && "code" in err;
+}
+function isNotFoundError3(err) {
+  return isNodeError3(err) && err.code === "ENOENT";
+}
+function isFileExistsError2(err) {
+  return isNodeError3(err) && err.code === "EEXIST";
+}
+async function acquireProvisioningLock(lockTargetDir2, lockName) {
+  await fs23.mkdir(lockTargetDir2, { recursive: true });
+  return lockfile.lock(lockTargetDir2, {
+    lockfilePath: path22.join(lockTargetDir2, lockName),
+    retries: { retries: 600, factor: 1, minTimeout: 300, maxTimeout: 800, randomize: true },
+    stale: 3e4
+  });
+}
+async function tryAcquireProvisioningLock(lockTargetDir2, lockName) {
+  await fs23.mkdir(lockTargetDir2, { recursive: true });
+  return lockfile.lock(lockTargetDir2, {
+    lockfilePath: path22.join(lockTargetDir2, lockName),
+    retries: 0,
+    stale: 3e4
+  });
+}
+function lockTargetDir(branchRoot) {
+  return path32.join(path32.resolve(branchRoot), META_DIR);
+}
+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 (!isNodeError3(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();
+  }
+}
 function flattenGroupFields(fields) {
   const result = [];
   for (const field of fields) {
@@ -2025,24 +2125,6 @@ function generateId() {
   const full = generate();
   return full.substring(0, 12);
 }
-function getErrorMessage3(err) {
-  if (err instanceof Error) {
-    return err.message;
-  }
-  if (typeof err === "string") {
-    return err;
-  }
-  return String(err);
-}
-function isNodeError3(err) {
-  return err instanceof Error && "code" in err;
-}
-function isNotFoundError3(err) {
-  return isNodeError3(err) && err.code === "ENOENT";
-}
-function isFileExistsError2(err) {
-  return isNodeError3(err) && err.code === "EEXIST";
-}
 function toLogicalCollectionPath(physicalPath) {
   if (physicalPath === ".")
     return EMPTY_LOGICAL_PATH;
@@ -2067,7 +2149,7 @@ function extractIdFromFilename(filename) {
 }
 async function resolveCollectionPath(root, logicalPath) {
   const fs172 = await import("node:fs/promises");
-  const path192 = await import("node:path");
+  const path202 = await import("node:path");
   const segments = logicalPath.split("/").filter(Boolean);
   let currentPath = root;
   for (const segment of segments) {
@@ -2080,7 +2162,7 @@ async function resolveCollectionPath(root, logicalPath) {
         return logicalName === segment.toLowerCase();
       });
       if (matchingDir) {
-        currentPath = path192.join(currentPath, matchingDir.name);
+        currentPath = path202.join(currentPath, matchingDir.name);
       } else {
         return null;
       }
@@ -2130,7 +2212,7 @@ function extractSlugFromFilename(filename, entryTypeName) {
   return filename.toLowerCase();
 }
 function registerContentIndexForInvalidation(root, target) {
-  const rootKey = path32.resolve(root);
+  const rootKey = path52.resolve(root);
   let refs = registry.get(rootKey);
   if (!refs) {
     refs = /* @__PURE__ */ new Set();
@@ -2141,8 +2223,8 @@ function registerContentIndexForInvalidation(root, target) {
   finalization.register(target, { rootKey, ref });
 }
 function invalidateContentIndexesForRoot(root) {
-  const rootKey = path32.resolve(root);
-  const prefix = rootKey + path32.sep;
+  const rootKey = path52.resolve(root);
+  const prefix = rootKey + path52.sep;
   for (const [storeRoot, refs] of registry) {
     if (storeRoot !== rootKey && !storeRoot.startsWith(prefix))
       continue;
@@ -2162,7 +2244,7 @@ function createDebugLogger2(options) {
   return new DebugLogger2(options);
 }
 function resourceGenerationPath(root, resource) {
-  return path42.resolve(root, META_DIR, `${resource}.generation`);
+  return path62.resolve(root, META_DIR2, `${resource}.generation`);
 }
 async function bumpResourceGeneration(root, resource, options) {
   const token = randomUUID();
@@ -2180,7 +2262,7 @@ async function bumpResourceGeneration(root, resource, options) {
 }
 async function readResourceGeneration(root, resource) {
   try {
-    const token = await fs32.readFile(resourceGenerationPath(root, resource), "utf-8");
+    const token = await fs42.readFile(resourceGenerationPath(root, resource), "utf-8");
     return { ok: true, token };
   } catch (err) {
     if (isNodeError3(err) && err.code === "ENOENT")
@@ -2200,7 +2282,7 @@ function stripEmbeddedIdFromName(name) {
 async function scanForCollectionMeta(baseDir, relativePath = "") {
   const collections = [];
   try {
-    const entries = await fs42.readdir(baseDir, { withFileTypes: true });
+    const entries = await fs52.readdir(baseDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory())
         continue;
@@ -2211,8 +2293,8 @@ async function scanForCollectionMeta(baseDir, relativePath = "") {
       const absolutePath = join3(baseDir, folderName);
       const metaPath = join3(absolutePath, ".collection.json");
       try {
-        await fs42.access(metaPath);
-        const content = await fs42.readFile(metaPath, "utf-8");
+        await fs52.access(metaPath);
+        const content = await fs52.readFile(metaPath, "utf-8");
         const parsed = JSON.parse(content);
         const meta = collectionMetaSchema.parse(parsed);
         collections.push({
@@ -2244,7 +2326,7 @@ async function loadCollectionMetaFiles(contentRoot) {
   let root = null;
   const rootMetaPath = join3(contentRoot, ".collection.json");
   try {
-    await fs42.access(rootMetaPath);
+    await fs52.access(rootMetaPath);
   } catch (err) {
     if (err.code === "ENOENT") {
     } else {
@@ -2252,7 +2334,7 @@ async function loadCollectionMetaFiles(contentRoot) {
     }
   }
   try {
-    const content = await fs42.readFile(rootMetaPath, "utf-8");
+    const content = await fs52.readFile(rootMetaPath, "utf-8");
     const parsed = JSON.parse(content);
     root = rootCollectionMetaSchema.parse(parsed);
   } catch (err) {
@@ -2342,16 +2424,16 @@ function isValidSchema(schema) {
 async function isStaleByMtime(dir, cachedAt) {
   let entries;
   try {
-    entries = await fs52.readdir(dir, { recursive: true, encoding: "utf-8" });
+    entries = await fs62.readdir(dir, { recursive: true, encoding: "utf-8" });
   } catch {
     return true;
   }
   for (const entry of entries) {
     if (!entry.endsWith(".collection.json"))
       continue;
-    const full = path52.join(dir, entry);
+    const full = path72.join(dir, entry);
     try {
-      const stat = await fs52.stat(full);
+      const stat = await fs62.stat(full);
       if (stat.mtimeMs > cachedAt.getTime())
         return true;
     } catch {
@@ -2374,7 +2456,7 @@ async function invalidateBranchContentCaches(root) {
 }
 async function filePathExists3(filePath) {
   try {
-    await fs62.stat(filePath);
+    await fs72.stat(filePath);
     return true;
   } catch (err) {
     if (isNotFoundError3(err))
@@ -2411,11 +2493,11 @@ function resolveBranchPath(options) {
   const safeBranch = sanitizeBranchName(options.branchName);
   const strategy = operatingStrategy2(options.mode);
   const baseRoot = resolveContentBranchesRoot(options.mode, options.basePathOverride);
-  const normalizedBase = path72.resolve(baseRoot);
-  const baseWithSep = normalizedBase.endsWith(path72.sep) ? normalizedBase : `${normalizedBase}${path72.sep}`;
+  const normalizedBase = path92.resolve(baseRoot);
+  const baseWithSep = normalizedBase.endsWith(path92.sep) ? normalizedBase : `${normalizedBase}${path92.sep}`;
   const branchRoot = strategy.getContentBranchRoot(safeBranch, options.basePathOverride);
   const withinBase = (target) => {
-    const resolved = path72.resolve(target);
+    const resolved = path92.resolve(target);
     return resolved === normalizedBase || resolved.startsWith(baseWithSep);
   };
   if (!withinBase(branchRoot)) {
@@ -2425,7 +2507,7 @@ function resolveBranchPath(options) {
 }
 async function ensureBranchRoot(options) {
   const result = resolveBranchPath(options);
-  await fs72.mkdir(result.branchRoot, { recursive: true });
+  await fs8.mkdir(result.branchRoot, { recursive: true });
   return result;
 }
 async function withLocks(keys, fn) {
@@ -2626,7 +2708,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];
@@ -2698,7 +2780,6 @@ ${String(value)}`;
       return `${heading} ${label}${descriptionLine}
 
 ${value ? "Yes" : "No"}`;
-    case "rich-text":
     case "markdown":
     case "mdx":
       return `${heading} ${label}${descriptionLine}
@@ -2957,8 +3038,8 @@ function computeEntryUrl(collection, slug, contentRoot) {
   if (slug && slug !== "index") {
     segments.push(slug);
   }
-  const path192 = segments.length > 0 ? `/${segments.join("/")}` : "/";
-  return path192.toLowerCase();
+  const path202 = segments.length > 0 ? `/${segments.join("/")}` : "/";
+  return path202.toLowerCase();
 }
 function resolveEntryUrl(location, contentRoot) {
   return computeEntryUrl(location.collection ?? "", location.slug ?? "", contentRoot);
@@ -3126,7 +3207,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(path92.basename(listEntry.relativePath));
+    const entryTypeName = extractEntryTypeFromFilename(path11.basename(listEntry.relativePath));
     if (!entryTypeName)
       continue;
     if (config?.exclude?.entryTypes?.includes(entryTypeName))
@@ -3144,7 +3225,7 @@ async function processCollection(store, collection, flatSchema, contentRoot, con
       }
       if (config?.exclude?.where?.(aiEntry))
         continue;
-      await runEntryTransform(aiEntry, doc.absolutePath, extractIdFromFilename(path92.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);
@@ -3195,7 +3276,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(path92.basename(listEntry.relativePath));
+    const entryTypeName = extractEntryTypeFromFilename(path11.basename(listEntry.relativePath));
     if (!entryTypeName)
       continue;
     if (config?.exclude?.entryTypes?.includes(entryTypeName))
@@ -3213,7 +3294,7 @@ async function processRootEntries(store, rootCollection, contentRoot, config, id
       }
       if (config?.exclude?.where?.(aiEntry))
         continue;
-      await runEntryTransform(aiEntry, doc.absolutePath, extractIdFromFilename(path92.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);
@@ -3261,19 +3342,19 @@ function docToAIEntry(doc, slug, entryTypeName, entryTypeConfig, cleanCollection
   };
 }
 function makeReadSibling(dir) {
-  const resolvedDir = path92.resolve(dir);
+  const resolvedDir = path11.resolve(dir);
   return async (name) => {
-    if (!name || name.includes("/") || name.includes("\\") || path92.isAbsolute(name) || hasTraversalSequence(name)) {
+    if (!name || name.includes("/") || name.includes("\\") || path11.isAbsolute(name) || hasTraversalSequence(name)) {
       return null;
     }
-    const abs = path92.resolve(resolvedDir, name);
-    if (path92.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 (isNodeError3(err) && (err.code === "ENOENT" || err.code === "ENOTDIR"))
         return null;
@@ -3287,7 +3368,7 @@ async function runEntryTransform(entry, absolutePath, contentId, config) {
     return;
   const ctx = {
     contentId: contentId ?? "",
-    readSibling: makeReadSibling(path92.dirname(absolutePath))
+    readSibling: makeReadSibling(path11.dirname(absolutePath))
   };
   try {
     const appended = await transform(entry, ctx);
@@ -3328,29 +3409,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 (isFileExistsError2(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;
@@ -3358,16 +3439,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;
   }
@@ -3393,13 +3474,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,
@@ -3449,6 +3530,9 @@ function isNetworkRemoteUrl(url) {
     return false;
   return COLON_BEFORE_SLASH_PATTERN.test(url);
 }
+function isMissingRemoteRefFailure(message) {
+  return MISSING_REMOTE_REF_REASONS.some((reason) => message.includes(reason));
+}
 async function detectHeadBranch(repoRoot, fallback = "main") {
   try {
     const git = simpleGit3({ baseDir: repoRoot });
@@ -3466,14 +3550,6 @@ async function resolveBaseBranch(options) {
   }
   return "main";
 }
-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
-  });
-}
 function gitChildEnv(overrides) {
   const env = {};
   for (const [key, value] of Object.entries(process.env)) {
@@ -3483,8 +3559,8 @@ function gitChildEnv(overrides) {
   return { ...env, ...FORCE_C_LOCALE, ...overrides };
 }
 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");
@@ -3644,30 +3720,30 @@ function isValidImageCropValue(value) {
   }
   return isValidCropRect(x, y, w, h);
 }
-function validateImageValue(field, value, path192) {
+function validateImageValue(field, value, path202) {
   if (!isPlainRecord2(value)) {
-    return [{ fieldPath: path192, message: "Expected an image object with { src, alt }" }];
+    return [{ fieldPath: path202, message: "Expected an image object with { src, alt }" }];
   }
   const errors = [];
   if (typeof value.src !== "string" || value.src.trim() === "") {
-    errors.push({ fieldPath: `${path192}.src`, message: "Image src is required" });
+    errors.push({ fieldPath: `${path202}.src`, message: "Image src is required" });
   }
   if (typeof value.alt !== "string") {
-    errors.push({ fieldPath: `${path192}.alt`, message: "Image alt text is required" });
+    errors.push({ fieldPath: `${path202}.alt`, message: "Image alt text is required" });
   } else if (value.alt.trim() === "" && field.altOptional !== true) {
-    errors.push({ fieldPath: `${path192}.alt`, message: "Image alt text is required" });
+    errors.push({ fieldPath: `${path202}.alt`, message: "Image alt text is required" });
   }
   if (value.width !== void 0 && !isPositiveInt(value.width)) {
-    errors.push({ fieldPath: `${path192}.width`, message: "Image width must be a positive integer" });
+    errors.push({ fieldPath: `${path202}.width`, message: "Image width must be a positive integer" });
   }
   if (value.height !== void 0 && !isPositiveInt(value.height)) {
     errors.push({
-      fieldPath: `${path192}.height`,
+      fieldPath: `${path202}.height`,
       message: "Image height must be a positive integer"
     });
   }
   if (value.crop !== void 0 && !isValidImageCropValue(value.crop)) {
-    errors.push({ fieldPath: `${path192}.crop`, message: "Invalid image crop rect" });
+    errors.push({ fieldPath: `${path202}.crop`, message: "Invalid image crop rect" });
   }
   return errors;
 }
@@ -3678,44 +3754,44 @@ function referenceValueId(value) {
     return value.id;
   return void 0;
 }
-function validateScalar(field, value, path192) {
+function validateScalar(field, value, path202) {
   switch (field.type) {
     case "number":
       if (typeof value !== "number" || !Number.isFinite(value)) {
-        return [{ fieldPath: path192, message: "Expected a number" }];
+        return [{ fieldPath: path202, message: "Expected a number" }];
       }
       return [];
     case "boolean":
       if (typeof value !== "boolean") {
-        return [{ fieldPath: path192, message: "Expected true or false" }];
+        return [{ fieldPath: path202, message: "Expected true or false" }];
       }
       return [];
     case "datetime":
       if (typeof value !== "string" || value !== "" && Number.isNaN(Date.parse(value))) {
-        return [{ fieldPath: path192, message: "Expected a valid date/time string" }];
+        return [{ fieldPath: path202, message: "Expected a valid date/time string" }];
       }
       return [];
     case "select": {
       if (typeof value !== "string") {
-        return [{ fieldPath: path192, message: "Expected a selection" }];
+        return [{ fieldPath: path202, message: "Expected a selection" }];
       }
       const options = selectOptionValues(field);
       if (value !== "" && !options.includes(value)) {
-        return [{ fieldPath: path192, message: `Must be one of: ${options.join(", ")}` }];
+        return [{ fieldPath: path202, message: `Must be one of: ${options.join(", ")}` }];
       }
       return [];
     }
     case "reference":
       if (referenceValueId(value) === void 0) {
-        return [{ fieldPath: path192, message: "Expected a reference id" }];
+        return [{ fieldPath: path202, message: "Expected a reference id" }];
       }
       return [];
     case "image":
-      return validateImageValue(field, value, path192);
+      return validateImageValue(field, value, path202);
     default:
       if (STRING_FIELD_TYPES.has(field.type)) {
         if (typeof value !== "string") {
-          return [{ fieldPath: path192, message: "Expected text" }];
+          return [{ fieldPath: path202, message: "Expected text" }];
         }
       }
       return [];
@@ -3738,12 +3814,12 @@ function validateEntryData(fields, data, pathPrefix = "") {
       errors.push(...validateEntryData(field.fields, data, pathPrefix));
       continue;
     }
-    const path192 = pathPrefix ? `${pathPrefix}.${field.name}` : field.name;
+    const path202 = 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: path192, message });
+      errors.push({ fieldPath: path202, message });
       continue;
     }
     if (value === void 0 || value === null)
@@ -3751,11 +3827,11 @@ function validateEntryData(fields, data, pathPrefix = "") {
     if (field.type === "block") {
       const blockField = field;
       if (!Array.isArray(value)) {
-        errors.push({ fieldPath: path192, message: "Expected a list of blocks" });
+        errors.push({ fieldPath: path202, message: "Expected a list of blocks" });
         continue;
       }
       value.forEach((item, index) => {
-        const itemPath = `${path192}[${index}]`;
+        const itemPath = `${path202}[${index}]`;
         if (!isPlainRecord2(item)) {
           errors.push({ fieldPath: itemPath, message: "Expected a block object" });
           return;
@@ -3777,11 +3853,11 @@ function validateEntryData(fields, data, pathPrefix = "") {
       const objectField = field;
       if (objectField.list) {
         if (!Array.isArray(value)) {
-          errors.push({ fieldPath: path192, message: "Expected a list of items" });
+          errors.push({ fieldPath: path202, message: "Expected a list of items" });
           continue;
         }
         value.forEach((item, index) => {
-          const itemPath = `${path192}[${index}]`;
+          const itemPath = `${path202}[${index}]`;
           if (!isPlainRecord2(item)) {
             errors.push({ fieldPath: itemPath, message: "Expected an object" });
             return;
@@ -3791,27 +3867,27 @@ function validateEntryData(fields, data, pathPrefix = "") {
           }
         });
       } else if (!isPlainRecord2(value)) {
-        errors.push({ fieldPath: path192, message: "Expected an object" });
+        errors.push({ fieldPath: path202, message: "Expected an object" });
       } else if (objectField.fields) {
-        errors.push(...validateEntryData(objectField.fields, value, path192));
+        errors.push(...validateEntryData(objectField.fields, value, path202));
       }
       continue;
     }
     if ("list" in field && field.list) {
       if (!Array.isArray(value)) {
-        errors.push({ fieldPath: path192, message: "Expected a list of values" });
+        errors.push({ fieldPath: path202, message: "Expected a list of values" });
         continue;
       }
       value.forEach((item, index) => {
-        errors.push(...validateScalar(field, item, `${path192}[${index}]`));
+        errors.push(...validateScalar(field, item, `${path202}[${index}]`));
       });
       continue;
     }
     if (Array.isArray(value) && KNOWN_FIELD_TYPES.has(field.type)) {
-      errors.push({ fieldPath: path192, message: "Expected a single value, not a list" });
+      errors.push({ fieldPath: path202, message: "Expected a single value, not a list" });
       continue;
     }
-    errors.push(...validateScalar(field, value, path192));
+    errors.push(...validateScalar(field, value, path202));
   }
   return errors;
 }
@@ -3877,14 +3953,14 @@ async function generateAIContentFiles(options) {
     config: aiConfig2,
     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++;
   }
@@ -3893,7 +3969,7 @@ async function generateAIContentFiles(options) {
 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);
@@ -3904,7 +3980,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);
@@ -3915,7 +3991,7 @@ async function generateAIContentCLI(options) {
   let aiConfig2;
   if (configPath) {
     try {
-      const aiConfigModule = await jiti.import(path18.resolve(configPath));
+      const aiConfigModule = await jiti.import(path19.resolve(configPath));
       aiConfig2 = aiConfigModule.aiContentConfig ?? aiConfigModule.default ?? aiConfigModule.config;
     } catch (err) {
       console.error(`Could not load AI config from ${configPath}`);
@@ -3932,7 +4008,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({
@@ -3946,7 +4022,7 @@ async function generateAIContentCLI(options) {
   console.log(`  Output: ${result.outputDir}
 `);
 }
-var __defProp3, __getOwnPropNames3, __esm3, __export3, init_normalize2, active2, init_logger, ROOT_COLLECTION_ID, init_types3, normalizePathValue, flattenSchema, init_flatten2, primitiveFieldTypes2, fieldTypes2, init_types22, fieldBaseSchema2, selectOptionSchema2, referenceOptionSchema2, primitiveFieldSchema2, ASPECT_RATIO_RE2, imageFieldSchema2, selectFieldSchema2, referenceFieldSchema2, fieldHolder2, blockSchema2, blockFieldSchema2, objectFieldSchema2, inlineGroupFieldSchema2, customFieldSchema2, knownFieldSchema2, fieldSchema2, init_field2, relativePathSchema2, entryTypeSchema2, collectionSchema2, init_collection2, mediaSchema2, init_media2, defaultBranchAccessSchema2, defaultPathAccessLevelSchema2, defaultPathAccessLevelsSchema2, defaultPathAccessSchema2, defaultBaseBranchSchema2, defaultRemoteNameSchema2, defaultRemoteUrlSchema2, gitBotAuthorNameSchema2, gitBotAuthorEmailSchema2, githubTokenEnvVarSchema2, operatingModeSchema2, deployedAsSchema2, contentRootSchema2, sourceRootSchema2, deploymentNameSchema2, devContentSyncSchema2, devConfigSchema2, editorConfigSchema2, CanopyConfigSchema2, DEFAULT_PROD_WORKSPACE2, init_config3, forEachReferenceField, init_validation2, ProdClientSafeStrategy2, DevClientSafeStrategy2, clientStrategyCache, init_client_safe_strategy, warned2, VALID_DEPLOYMENT_NAME2, isValidDeploymentName2, init_deployment_name, permissionTargetSchema2, pathPermissionSchema2, init_permissions2, init_helpers2, init_config22, ProdStrategy2, DevStrategy2, strategyCache2, init_client_unsafe_strategy, operating_mode_exports, init_operating_mode, locks, BASE58_PATTERN, CONTENT_ID_PATTERN, PHYSICAL_SEGMENT_PATTERN, isValidId, EMPTY_LOGICAL_PATH, ContentIdIndex, registry, finalization, LOG_LEVELS2, DebugLogger2, testLogger2, log2, META_DIR, entryTypeMetaSchema, collectionMetaSchema, rootCollectionMetaSchema, editDistance, closestName, forEachEntryType, collectEntryTypeNames, validateReferenceEntryTypes, isDeployedStatic, isBuildMode, STATIC_DEPLOY_USER, SCHEMA_CACHE_VERSION, MTIME_CHECK_DEBOUNCE_MS, SCHEMA_GENERATION_RESOURCE, BranchSchemaCache, RESOURCE, getFormatExtension, isDataOnlyFormat, asRecord, BranchPathError, resolveContentBranchesRoot, ContentStoreError, ContentConflictError, DEFAULT_INDEX_FRESHNESS_INTERVAL_MS, FORCED_REFRESH_MIN_INTERVAL_MS, STALE_LOOKUP, ContentStore, ATTR_CONTENT, BLOCK_PREFIX, BLOCK_SUFFIX, BLOCK_RESTORE_RE, INLINE_PREFIX, INLINE_SUFFIX, INLINE_RESTORE_RE, FLAT_CELL_TYPES, log22, BASE58_CHAR, ENTRY_LINK_PATTERN, log3, REGISTRY_FILE, REGISTRY_STALE_FILE, REGISTRY_TEMP_FILE, REGISTRY_VERSION, RESOURCE2, GET_MISS_REFRESH_MIN_INTERVAL_MS, BranchRegistry, log4, OccWriteConflictError, BRANCH_META_DIR, BRANCH_META_FILE, CURRENT_SCHEMA_VERSION, BranchMetadataConflictError, BranchMetadataCorruptError, BranchMetadataFileManager, getBranchMetadataFileManager, loadBranchContext, NETWORK_SCHEME_PATTERN, TRANSPORT_HELPER_PATTERN, LEADING_OPTION_PATTERN, WINDOWS_DRIVE_PATTERN, COLON_BEFORE_SLASH_PATTERN, log5, GIT_ENV_PASSTHROUGH, FORCE_C_LOCALE, remoteInitLocks, GITHUB_TRACKING_REF_PREFIX, GitConflictError, GitManager, log6, workspaceInitLocks, BranchWorkspaceManager, log7, normalizePath, readEntryData, parseTypedFilename, listCollectionEntries, MAX_INPUT_PIXELS, KNOWN_FIELD_TYPES, STRING_FIELD_TYPES, selectOptionValues, jiti;
+var __defProp3, __getOwnPropNames3, __esm3, __export3, init_normalize2, active2, init_logger2, ROOT_COLLECTION_ID, init_types3, normalizePathValue, flattenSchema, init_flatten2, primitiveFieldTypes2, fieldTypes2, init_types22, fieldBaseSchema2, selectOptionSchema2, referenceOptionSchema2, primitiveFieldSchema2, ASPECT_RATIO_RE2, imageFieldSchema2, selectFieldSchema2, referenceFieldSchema2, fieldHolder2, blockSchema2, blockFieldSchema2, objectFieldSchema2, inlineGroupFieldSchema2, customFieldSchema2, knownFieldSchema2, fieldSchema2, init_field2, relativePathSchema2, entryTypeSchema2, collectionSchema2, init_collection2, mediaSchema2, init_media2, defaultBranchAccessSchema2, defaultPathAccessLevelSchema2, defaultPathAccessLevelsSchema2, defaultPathAccessSchema2, defaultBaseBranchSchema2, defaultRemoteNameSchema2, defaultRemoteUrlSchema2, gitBotAuthorNameSchema2, gitBotAuthorEmailSchema2, githubTokenEnvVarSchema2, operatingModeSchema2, deployedAsSchema2, contentRootSchema2, sourceRootSchema2, deploymentNameSchema2, devContentSyncSchema2, devConfigSchema2, editorConfigSchema2, CanopyConfigSchema2, DEFAULT_PROD_WORKSPACE2, init_config3, SERVER_MODE_ENV_VAR, BROWSER_MODE_ENV_VAR, warned2, init_mode_env2, forEachReferenceField, init_validation2, ProdClientSafeStrategy2, DevClientSafeStrategy2, clientStrategyCache, init_client_safe_strategy, warned22, VALID_DEPLOYMENT_NAME2, isValidDeploymentName2, init_deployment_name, permissionTargetSchema2, pathPermissionSchema2, init_permissions2, init_helpers2, init_config22, ProdStrategy2, DevStrategy2, strategyCache2, init_client_unsafe_strategy, operating_mode_exports, init_operating_mode, locks, META_DIR, CONTENT_WRITE_LOCK_NAME, DEFAULT_CONTENT_WRITE_LOCK_WAIT_MS, ContentWriteLockBusyError, sleep, BASE58_PATTERN, CONTENT_ID_PATTERN, PHYSICAL_SEGMENT_PATTERN, isValidId, EMPTY_LOGICAL_PATH, ContentIdIndex, registry, finalization, LOG_LEVELS2, DebugLogger2, testLogger2, log2, META_DIR2, entryTypeMetaSchema, collectionMetaSchema, rootCollectionMetaSchema, editDistance, closestName, forEachEntryType, collectEntryTypeNames, validateReferenceEntryTypes, isDeployedStatic, isBuildMode, STATIC_DEPLOY_USER, SCHEMA_CACHE_VERSION, MTIME_CHECK_DEBOUNCE_MS, SCHEMA_GENERATION_RESOURCE, BranchSchemaCache, RESOURCE, getFormatExtension, isDataOnlyFormat, asRecord, BranchPathError, resolveContentBranchesRoot, ContentStoreError, ContentConflictError, BranchSyncingError, DuplicateContentIdError, DEFAULT_INDEX_FRESHNESS_INTERVAL_MS, FORCED_REFRESH_MIN_INTERVAL_MS, STALE_LOOKUP, ContentStore, ATTR_CONTENT, BLOCK_PREFIX, BLOCK_SUFFIX, BLOCK_RESTORE_RE, INLINE_PREFIX, INLINE_SUFFIX, INLINE_RESTORE_RE, FLAT_CELL_TYPES, log22, BASE58_CHAR, ENTRY_LINK_PATTERN, log3, REGISTRY_FILE, REGISTRY_STALE_FILE, REGISTRY_TEMP_FILE, REGISTRY_VERSION, RESOURCE2, GET_MISS_REFRESH_MIN_INTERVAL_MS, BranchRegistry, log4, OccWriteConflictError, BRANCH_META_DIR, BRANCH_META_FILE, CURRENT_SCHEMA_VERSION, BranchMetadataConflictError, BranchMetadataCorruptError, BranchMetadataFileManager, getBranchMetadataFileManager, loadBranchContext, NETWORK_SCHEME_PATTERN, TRANSPORT_HELPER_PATTERN, LEADING_OPTION_PATTERN, WINDOWS_DRIVE_PATTERN, COLON_BEFORE_SLASH_PATTERN, MISSING_REMOTE_REF_REASONS, log5, GIT_ENV_PASSTHROUGH, FORCE_C_LOCALE, remoteInitLocks, GITHUB_TRACKING_REF_PREFIX, GitConflictError, GitRemoteRefMissingError, GitManager, log6, workspaceInitLocks, BranchWorkspaceManager, log7, normalizePath, readEntryData, parseTypedFilename, listCollectionEntries, MAX_INPUT_PIXELS, KNOWN_FIELD_TYPES, STRING_FIELD_TYPES, selectOptionValues, jiti;
 var init_generate_ai_content = __esm({
   "dist/cli/generate-ai-content.js"() {
     "use strict";
@@ -3964,7 +4040,7 @@ var init_generate_ai_content = __esm({
         "use strict";
       }
     });
-    init_logger = __esm3({
+    init_logger2 = __esm3({
       "dist/utils/logger.js"() {
         "use strict";
         active2 = console;
@@ -4083,7 +4159,6 @@ var init_generate_ai_content = __esm({
           "number",
           "boolean",
           "datetime",
-          "rich-text",
           "markdown",
           "mdx",
           "code"
@@ -4336,11 +4411,21 @@ var init_generate_ai_content = __esm({
         DEFAULT_PROD_WORKSPACE2 = "/mnt/efs/workspace";
       }
     });
+    init_mode_env2 = __esm3({
+      "dist/operating-mode/mode-env.js"() {
+        "use strict";
+        init_logger2();
+        SERVER_MODE_ENV_VAR = "CANOPY_MODE";
+        BROWSER_MODE_ENV_VAR = "NEXT_PUBLIC_CANOPY_MODE";
+        warned2 = false;
+      }
+    });
     init_validation2 = __esm3({
       "dist/config/validation.js"() {
         "use strict";
         init_config3();
         init_flatten2();
+        init_mode_env2();
         forEachReferenceField = (fields, visit) => {
           if (!Array.isArray(fields))
             return;
@@ -4432,8 +4517,8 @@ var init_generate_ai_content = __esm({
     init_deployment_name = __esm3({
       "dist/operating-mode/deployment-name.js"() {
         "use strict";
-        init_logger();
-        warned2 = false;
+        init_logger2();
+        warned22 = false;
         VALID_DEPLOYMENT_NAME2 = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
         isValidDeploymentName2 = (name) => VALID_DEPLOYMENT_NAME2.test(name) && !name.includes("..") && !name.endsWith(".") && !name.endsWith(".lock");
       }
@@ -4486,32 +4571,32 @@ var init_generate_ai_content = __esm({
           // - shouldCommit(), shouldPush()
           // Add client-unsafe methods (use Node.js APIs)
           getWorkspaceRoot(_sourceRoot) {
-            return path62.resolve(process.env.CANOPYCMS_WORKSPACE_ROOT ?? DEFAULT_PROD_WORKSPACE2);
+            return path82.resolve(process.env.CANOPYCMS_WORKSPACE_ROOT ?? DEFAULT_PROD_WORKSPACE2);
           }
           getContentRoot(contentRoot, sourceRoot) {
-            return path62.resolve(sourceRoot ?? process.cwd(), contentRoot);
+            return path82.resolve(sourceRoot ?? process.cwd(), contentRoot);
           }
           getContentBranchesRoot(sourceRoot) {
-            return path62.join(this.getWorkspaceRoot(sourceRoot), "content-branches");
+            return path82.join(this.getWorkspaceRoot(sourceRoot), "content-branches");
           }
           getContentBranchRoot(branchName, sourceRoot) {
-            return path62.resolve(this.getContentBranchesRoot(sourceRoot), branchName);
+            return path82.resolve(this.getContentBranchesRoot(sourceRoot), branchName);
           }
           getGitExcludePattern() {
             return ".canopy-meta/";
           }
           getPermissionsFilePath(root) {
-            return path62.join(root, this.getPermissionsFileName());
+            return path82.join(root, this.getPermissionsFileName());
           }
           getGroupsFilePath(root) {
-            return path62.join(root, this.getGroupsFileName());
+            return path82.join(root, this.getGroupsFileName());
           }
           getRemoteUrlConfig() {
             return {
               shouldAutoInitLocal: false,
               defaultRemotePath: "",
               envVarName: "CANOPYCMS_REMOTE_URL",
-              autoDetectRemotePath: path62.join(this.getWorkspaceRoot(), "remote.git")
+              autoDetectRemotePath: path82.join(this.getWorkspaceRoot(), "remote.git")
             };
           }
           requiresExistingRepo() {
@@ -4523,7 +4608,7 @@ var init_generate_ai_content = __esm({
             return `canopycms-settings-${resolveDeploymentName2(config, "prod")}`;
           }
           getSettingsRoot(sourceRoot) {
-            return path62.join(this.getWorkspaceRoot(sourceRoot), "settings");
+            return path82.join(this.getWorkspaceRoot(sourceRoot), "settings");
           }
           usesSeparateSettingsBranch() {
             return true;
@@ -4540,25 +4625,25 @@ var init_generate_ai_content = __esm({
         DevStrategy2 = class extends DevClientSafeStrategy2 {
           // Inherits client-safe methods from DevClientSafeStrategy
           getWorkspaceRoot(sourceRoot) {
-            return path62.resolve(sourceRoot ?? process.cwd(), ".canopy-dev");
+            return path82.resolve(sourceRoot ?? process.cwd(), ".canopy-dev");
           }
           getContentRoot(contentRoot, sourceRoot) {
-            return path62.resolve(sourceRoot ?? process.cwd(), contentRoot);
+            return path82.resolve(sourceRoot ?? process.cwd(), contentRoot);
           }
           getContentBranchesRoot(sourceRoot) {
-            return path62.join(this.getWorkspaceRoot(sourceRoot), "content-branches");
+            return path82.join(this.getWorkspaceRoot(sourceRoot), "content-branches");
           }
           getContentBranchRoot(branchName, sourceRoot) {
-            return path62.resolve(this.getContentBranchesRoot(sourceRoot), branchName);
+            return path82.resolve(this.getContentBranchesRoot(sourceRoot), branchName);
           }
           getGitExcludePattern() {
             return ".canopy-meta/";
           }
           getPermissionsFilePath(root) {
-            return path62.join(root, this.getPermissionsFileName());
+            return path82.join(root, this.getPermissionsFileName());
           }
           getGroupsFilePath(root) {
-            return path62.join(root, this.getGroupsFileName());
+            return path82.join(root, this.getGroupsFileName());
           }
           getRemoteUrlConfig() {
             return {
@@ -4576,7 +4661,7 @@ var init_generate_ai_content = __esm({
             return `canopycms-settings-${resolveDeploymentName2(config, "local")}`;
           }
           getSettingsRoot(sourceRoot) {
-            return path62.join(this.getWorkspaceRoot(sourceRoot), "settings");
+            return path82.join(this.getWorkspaceRoot(sourceRoot), "settings");
           }
           usesSeparateSettingsBranch() {
             return true;
@@ -4592,11 +4677,15 @@ var init_generate_ai_content = __esm({
     });
     operating_mode_exports = {};
     __export3(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: () => isValidDeploymentName2,
       operatingStrategy: () => operatingStrategy2,
-      resolveDeploymentName: () => resolveDeploymentName2
+      resolveDeploymentName: () => resolveDeploymentName2,
+      resolveOperatingMode: () => resolveOperatingMode
     });
     init_operating_mode = __esm3({
       "dist/operating-mode/index.js"() {
@@ -4604,46 +4693,89 @@ var init_generate_ai_content = __esm({
         init_client_safe_strategy();
         init_client_unsafe_strategy();
         init_deployment_name();
+        init_mode_env2();
       }
     });
     locks = /* @__PURE__ */ new Map();
+    META_DIR = ".canopy-meta";
+    CONTENT_WRITE_LOCK_NAME = "content-write.lock";
+    DEFAULT_CONTENT_WRITE_LOCK_WAIT_MS = 2e3;
+    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";
+      }
+    };
+    sleep = (ms) => new Promise((resolve2) => {
+      setTimeout(resolve2, ms);
+    });
     init_normalize2();
     BASE58_PATTERN = "[123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz]";
     CONTENT_ID_PATTERN = new RegExp(`^${BASE58_PATTERN}{12}$`);
     PHYSICAL_SEGMENT_PATTERN = new RegExp(`\\.${BASE58_PATTERN}{12}(?:\\.[a-z]+)?$`);
     isValidId = isValidContentId;
+    init_logger2();
     EMPTY_LOGICAL_PATH = "";
     ContentIdIndex = class {
       constructor(root) {
         this.idToLocation = /* @__PURE__ */ new Map();
         this.pathToId = /* @__PURE__ */ new Map();
         this.byCollection = /* @__PURE__ */ new Map();
-        this.root = path22.resolve(root);
+        this.duplicateIds = /* @__PURE__ */ new Map();
+        this.root = path42.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 = path22.join(this.root, relativePath);
+        const absoluteDir = path42.join(this.root, relativePath);
         try {
-          const entries = await fs23.readdir(absoluteDir, { withFileTypes: true });
+          const entries = await fs32.readdir(absoluteDir, { withFileTypes: true });
           for (const entry of entries) {
             if (entry.name.startsWith(".") || entry.name === "_ids_") {
               continue;
             }
-            const fullRelativePath = path22.join(relativePath, entry.name);
+            const fullRelativePath = path42.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
@@ -4653,17 +4785,27 @@ var init_generate_ai_content = __esm({
               };
               if (!entry.isDirectory()) {
                 const slug = extractSlugFromFilename(entry.name);
-                const physicalCollection = path22.dirname(fullRelativePath);
+                const physicalCollection = path42.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);
+                canopyLogWarn2(`[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);
@@ -4675,6 +4817,42 @@ var init_generate_ai_content = __esm({
           }
         }
       }
+      /**
+       * 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))
        */
@@ -4767,7 +4945,7 @@ var init_generate_ai_content = __esm({
        * must already exist on disk (created by ContentStore).
        */
       add(location) {
-        const id = extractIdFromFilename(path22.basename(location.relativePath));
+        const id = extractIdFromFilename(path42.basename(location.relativePath));
         if (!id) {
           throw new Error(`Cannot add location without ID in filename: ${location.relativePath}`);
         }
@@ -4824,8 +5002,8 @@ var init_generate_ai_content = __esm({
         location.relativePath = newRelativePath;
         if (location.type === "entry") {
           const oldCollection = location.collection;
-          location.slug = extractSlugFromFilename(path22.basename(newRelativePath));
-          const physicalCollection = path22.dirname(newRelativePath);
+          location.slug = extractSlugFromFilename(path42.basename(newRelativePath));
+          const physicalCollection = path42.dirname(newRelativePath);
           location.collection = toLogicalCollectionPath(physicalCollection);
           if (oldCollection !== location.collection) {
             if (oldCollection) {
@@ -4955,8 +5133,8 @@ var init_generate_ai_content = __esm({
       throwOnError: false
     });
     log2 = createDebugLogger2({ prefix: "ResourceGeneration" });
-    META_DIR = ".canopy-meta";
-    init_logger();
+    META_DIR2 = ".canopy-meta";
+    init_logger2();
     entryTypeMetaSchema = z7.object({
       name: z7.string().min(1),
       format: z7.enum(["md", "mdx", "json", "yaml"]),
@@ -5085,7 +5263,7 @@ var init_generate_ai_content = __esm({
        * the project root, regardless of which entrypoint produced the cwd branchRoot.
        */
       skipDiskCache(branchRoot) {
-        return isBuildMode() || path52.resolve(branchRoot) === path52.resolve(process.cwd());
+        return isBuildMode() || path72.resolve(branchRoot) === path72.resolve(process.cwd());
       }
       /**
        * Get schema for a branch (loads from cache or resolves fresh).
@@ -5111,14 +5289,14 @@ var init_generate_ai_content = __esm({
        * Load schema from cache or resolve fresh if cache is missing or stale.
        */
       async loadFromCacheOrResolve(branchRoot, entrySchemaRegistry, contentRootName) {
-        const contentRoot = path52.join(branchRoot, contentRootName);
+        const contentRoot = path72.join(branchRoot, contentRootName);
         const skipDiskCache = this.skipDiskCache(branchRoot);
         if (!skipDiskCache) {
-          const cacheDir = path52.join(branchRoot, ".canopy-meta");
-          const cachePath = path52.join(cacheDir, "schema-cache.json");
+          const cacheDir = path72.join(branchRoot, ".canopy-meta");
+          const cachePath = path72.join(cacheDir, "schema-cache.json");
           let cacheData = null;
           try {
-            const cacheContent = await fs52.readFile(cachePath, "utf-8");
+            const cacheContent = await fs62.readFile(cachePath, "utf-8");
             cacheData = JSON.parse(cacheContent);
           } catch {
             cacheData = null;
@@ -5155,7 +5333,7 @@ var init_generate_ai_content = __esm({
        */
       async resolveFreshAndPersist(branchRoot, entrySchemaRegistry, contentRootName, options) {
         const { skipDiskCache } = options;
-        const contentRoot = path52.join(branchRoot, contentRootName);
+        const contentRoot = path72.join(branchRoot, contentRootName);
         const read = skipDiskCache ? null : await readResourceGeneration(branchRoot, SCHEMA_GENERATION_RESOURCE);
         const result = await this.resolveFresh(contentRoot, entrySchemaRegistry);
         if (!isValidSchema(result.schema)) {
@@ -5168,9 +5346,9 @@ var init_generate_ai_content = __esm({
         }
         const flatSchema = flattenSchema(result.schema, contentRootName);
         if (!skipDiskCache) {
-          const cacheDir = path52.join(branchRoot, ".canopy-meta");
-          const cachePath = path52.join(cacheDir, "schema-cache.json");
-          await fs52.unlink(path52.join(cacheDir, "schema-cache.stale")).catch(() => {
+          const cacheDir = path72.join(branchRoot, ".canopy-meta");
+          const cachePath = path72.join(cacheDir, "schema-cache.json");
+          await fs62.unlink(path72.join(cacheDir, "schema-cache.stale")).catch(() => {
           });
           if (read && read.ok) {
             const newCache = {
@@ -5180,13 +5358,13 @@ var init_generate_ai_content = __esm({
               cachedAt: (/* @__PURE__ */ new Date()).toISOString(),
               generation: read.token
             };
-            await fs52.mkdir(cacheDir, { recursive: true });
-            const tmpPath = path52.join(cacheDir, `schema-cache.tmp.${Date.now()}.${Math.random()}.json`);
-            await fs52.writeFile(tmpPath, JSON.stringify(newCache, null, 2), "utf-8");
+            await fs62.mkdir(cacheDir, { recursive: true });
+            const tmpPath = path72.join(cacheDir, `schema-cache.tmp.${Date.now()}.${Math.random()}.json`);
+            await fs62.writeFile(tmpPath, JSON.stringify(newCache, null, 2), "utf-8");
             try {
-              await fs52.rename(tmpPath, cachePath);
+              await fs62.rename(tmpPath, cachePath);
             } catch (err) {
-              await fs52.unlink(tmpPath).catch(() => {
+              await fs62.unlink(tmpPath).catch(() => {
               });
               throw err;
             }
@@ -5267,11 +5445,35 @@ var init_generate_ai_content = __esm({
       }
     };
     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";
       }
     };
+    BranchSyncingError = class extends ContentConflictError {
+      constructor(message) {
+        super(message);
+        this.name = "BranchSyncingError";
+      }
+    };
+    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((p5) => `"${p5}"`).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;
+      }
+    };
     DEFAULT_INDEX_FRESHNESS_INTERVAL_MS = 1e3;
     FORCED_REFRESH_MIN_INTERVAL_MS = 5e3;
     STALE_LOOKUP = Symbol("stale-index-lookup");
@@ -5283,13 +5485,40 @@ var init_generate_ai_content = __esm({
         this.lastDiskProbeMs = 0;
         this.lastForcedRefreshMs = 0;
         this.indexBuild = null;
-        this.root = path82.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.
        *
@@ -5393,26 +5622,32 @@ var init_generate_ai_content = __esm({
         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 (isNodeError3(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 path82.relative(this.root, path82.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.
@@ -5421,11 +5656,11 @@ var init_generate_ai_content = __esm({
       getSchemaItems() {
         return this.schemaIndex.values();
       }
-      assertSchemaItem(path192) {
-        const normalized = normalizeFilesystemPath(path192);
+      assertSchemaItem(path202) {
+        const normalized = normalizeFilesystemPath(path202);
         const item = this.schemaIndex.get(normalized);
         if (!item) {
-          throw new ContentStoreError(`Unknown schema item: ${path192}`, "NO_SCHEMA_ITEM");
+          throw new ContentStoreError(`Unknown schema item: ${path202}`, "NO_SCHEMA_ITEM");
         }
         return item;
       }
@@ -5508,7 +5743,7 @@ var init_generate_ai_content = __esm({
        * @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(path82.sep) ? this.root : `${this.root}${path82.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);
@@ -5541,7 +5776,7 @@ var init_generate_ai_content = __esm({
           const entryTypeName = entryTypeConfig?.name || "entry";
           let collectionRoot = await resolveCollectionPath(this.root, schemaItem.logicalPath);
           if (!collectionRoot) {
-            collectionRoot = path82.resolve(this.root, schemaItem.logicalPath);
+            collectionRoot = path10.resolve(this.root, schemaItem.logicalPath);
           }
           if (!collectionRoot.startsWith(rootWithSep)) {
             throw new ContentStoreError("Path traversal detected", "VALIDATION");
@@ -5551,7 +5786,7 @@ var init_generate_ai_content = __esm({
           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;
@@ -5577,14 +5812,14 @@ var init_generate_ai_content = __esm({
             }
             filename = `${finalEntryTypeName}.${safeSlug}.${id}${ext}`;
           }
-          const resolved = path82.resolve(collectionRoot, filename);
-          const collectionRootWithSep = collectionRoot.endsWith(path82.sep) ? collectionRoot : `${collectionRoot}${path82.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: path82.relative(this.root, resolved),
+            relativePath: path10.relative(this.root, resolved),
             id,
             entryTypeName: finalEntryTypeName,
             existed
@@ -5620,8 +5855,8 @@ var init_generate_ai_content = __esm({
       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;
@@ -5704,103 +5939,128 @@ var init_generate_ai_content = __esm({
         }
         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(path82.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 filePathExists3(absolutePath) && await filePathExists3(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 (isNodeError3(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 (isNodeError3(err) && err.code === "ENOENT") {
+                  } else {
+                    throw err;
+                  }
                 }
               }
-            }
-            if (existingId && !await filePathExists3(absolutePath)) {
-              const actualRelPath = await this.findEntryPathById(path82.dirname(absolutePath), existingId);
-              const indexedRelPath = this._idIndex.findById(existingId)?.relativePath ?? null;
-              if (actualRelPath !== null && actualRelPath !== indexedRelPath) {
-                throw new ContentConflictError();
+              if (existingId && !await filePathExists3(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 atomicWriteFile2(absolutePath, content);
-            const liveIndex = this._idIndex;
-            let staleOldAbsPath = null;
-            if (id) {
-              const existing = liveIndex.findById(id);
-              if (existing) {
-                if (existing.relativePath !== relativePath) {
-                  staleOldAbsPath = path82.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 atomicWriteFile2(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 (!isNodeError3(err) || err.code !== "ENOENT")
+                    throw err;
                 });
               }
-            }
-            if (staleOldAbsPath) {
-              await fs8.unlink(staleOldAbsPath).catch((err) => {
-                if (!isNodeError3(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).
@@ -5852,7 +6112,7 @@ var init_generate_ai_content = __esm({
         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 (isNodeError3(err) && err.code === "ENOENT")
@@ -5891,7 +6151,7 @@ var init_generate_ai_content = __esm({
         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;
       }
       /**
@@ -5915,34 +6175,36 @@ var init_generate_ai_content = __esm({
         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).
@@ -5973,70 +6235,72 @@ var init_generate_ai_content = __esm({
         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 = path82.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 = path82.dirname(currentPath);
-            const newPath = path82.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 (isNodeError3(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 (isNodeError3(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 = path82.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).
@@ -6211,7 +6475,7 @@ var init_generate_ai_content = __esm({
     log22 = createDebugLogger2({ prefix: "EntryLinks" });
     BASE58_CHAR = "[123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz]";
     ENTRY_LINK_PATTERN = new RegExp(`entry:(${BASE58_CHAR}{12})(#[^\\s)>"']*)?`, "g");
-    init_logger();
+    init_logger2();
     log3 = createDebugLogger2({ prefix: "BranchRegistry" });
     REGISTRY_FILE = "branches.json";
     REGISTRY_STALE_FILE = "branches.stale.json";
@@ -6223,10 +6487,10 @@ var init_generate_ai_content = __esm({
       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
@@ -6235,7 +6499,7 @@ var init_generate_ai_content = __esm({
       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 (isNotFoundError3(err)) {
@@ -6324,7 +6588,7 @@ var init_generate_ai_content = __esm({
       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;
@@ -6335,12 +6599,12 @@ var init_generate_ai_content = __esm({
           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;
         }
@@ -6354,12 +6618,12 @@ var init_generate_ai_content = __esm({
       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);
@@ -6410,8 +6674,8 @@ var init_generate_ai_content = __esm({
     };
     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;
       }
@@ -6420,10 +6684,10 @@ var init_generate_ai_content = __esm({
        * 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 (isNotFoundError3(err)) {
@@ -6444,7 +6708,7 @@ var init_generate_ai_content = __esm({
       }
       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 };
@@ -6506,7 +6770,7 @@ var init_generate_ai_content = __esm({
        */
       async save(incoming) {
         try {
-          await fs12.stat(this.branchRoot);
+          await fs13.stat(this.branchRoot);
         } catch (err) {
           if (isNotFoundError3(err)) {
             throw new BranchMetadataConflictError("Branch no longer exists");
@@ -6595,6 +6859,7 @@ var init_generate_ai_content = __esm({
     LEADING_OPTION_PATTERN = /^-/;
     WINDOWS_DRIVE_PATTERN = /^[a-zA-Z]:[\\/]/;
     COLON_BEFORE_SLASH_PATTERN = /^[^/\\\s]+:/;
+    MISSING_REMOTE_REF_REASONS = ["couldn't find remote ref", "Couldn't find remote ref"];
     log5 = createDebugLogger2({ prefix: "GitManager" });
     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_]*)$/;
     FORCE_C_LOCALE = { LC_ALL: "C", LANG: "C" };
@@ -6607,14 +6872,23 @@ var init_generate_ai_content = __esm({
         this.name = "GitConflictError";
       }
     };
+    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";
+      }
+    };
     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", {
@@ -6656,7 +6930,7 @@ var init_generate_ai_content = __esm({
               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 {
@@ -6762,8 +7036,8 @@ var init_generate_ai_content = __esm({
        * --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
@@ -6912,7 +7186,7 @@ var init_generate_ai_content = __esm({
        */
       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}`);
           }
@@ -7003,8 +7277,8 @@ var init_generate_ai_content = __esm({
         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,
@@ -7032,7 +7306,7 @@ var init_generate_ai_content = __esm({
       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 {
@@ -7054,12 +7328,12 @@ var init_generate_ai_content = __esm({
         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()) {
@@ -7093,7 +7367,7 @@ var init_generate_ai_content = __esm({
           }
           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);
@@ -7236,9 +7510,16 @@ var init_generate_ai_content = __esm({
       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(getErrorMessage3(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();
@@ -7300,6 +7581,44 @@ var init_generate_ai_content = __esm({
           `${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";
@@ -7346,14 +7665,6 @@ var init_generate_ai_content = __esm({
         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
        */
@@ -7407,8 +7718,8 @@ var init_generate_ai_content = __esm({
         } 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);
         }
@@ -7436,7 +7747,7 @@ var init_generate_ai_content = __esm({
                 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,
@@ -7477,7 +7788,7 @@ var init_generate_ai_content = __esm({
         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,
@@ -7585,7 +7896,7 @@ var init_generate_ai_content = __esm({
       }
       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) {
@@ -7619,7 +7930,7 @@ var init_generate_ai_content = __esm({
     init_config22();
     MAX_INPUT_PIXELS = 4096 * 4096;
     KNOWN_FIELD_TYPES = new Set(fieldTypes2);
-    STRING_FIELD_TYPES = /* @__PURE__ */ new Set(["string", "rich-text", "markdown", "mdx", "code"]);
+    STRING_FIELD_TYPES = /* @__PURE__ */ new Set(["string", "markdown", "mdx", "code"]);
     selectOptionValues = (field) => (field.options ?? []).map((opt) => typeof opt === "string" ? opt : opt.value);
     jiti = createJiti2(import.meta.url);
   }
@@ -7627,9 +7938,9 @@ var init_generate_ai_content = __esm({
 
 // dist/utils/atomic-write.js
 import fs17 from "node:fs/promises";
-import path19 from "node:path";
+import path20 from "node:path";
 async function atomicWriteFile3(filePath, content) {
-  const dir = path19.dirname(filePath);
+  const dir = path20.dirname(filePath);
   await fs17.mkdir(dir, { recursive: true });
   const tempPath = `${filePath}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`;
   await fs17.writeFile(tempPath, content, typeof content === "string" ? "utf-8" : void 0);
@@ -7757,10 +8068,10 @@ var init_debug2 = __esm({
 
 // dist/resource-generation.js
 import fs18 from "node:fs/promises";
-import path20 from "node:path";
+import path21 from "node:path";
 import { randomUUID as randomUUID3 } from "node:crypto";
 function resourceGenerationPath2(root, resource) {
-  return path20.resolve(root, META_DIR2, `${resource}.generation`);
+  return path21.resolve(root, META_DIR3, `${resource}.generation`);
 }
 async function bumpResourceGeneration2(root, resource, options) {
   const token = randomUUID3();
@@ -7792,7 +8103,7 @@ async function readResourceGeneration2(root, resource) {
 function isGenerationCurrent2(snapshotToken, read) {
   return read.ok && read.token === snapshotToken;
 }
-var log8, META_DIR2;
+var log8, META_DIR3;
 var init_resource_generation = __esm({
   "dist/resource-generation.js"() {
     "use strict";
@@ -7800,15 +8111,15 @@ var init_resource_generation = __esm({
     init_error();
     init_debug2();
     log8 = createDebugLogger3({ prefix: "ResourceGeneration" });
-    META_DIR2 = ".canopy-meta";
+    META_DIR3 = ".canopy-meta";
   }
 });
 
 // dist/content-index-registry.js
-import path21 from "node:path";
+import path23 from "node:path";
 function invalidateContentIndexesForRoot2(root) {
-  const rootKey = path21.resolve(root);
-  const prefix = rootKey + path21.sep;
+  const rootKey = path23.resolve(root);
+  const prefix = rootKey + path23.sep;
   for (const [storeRoot, refs] of registry2) {
     if (storeRoot !== rootKey && !storeRoot.startsWith(prefix))
       continue;
@@ -7848,7 +8159,7 @@ function canopyLogError2(...args) {
   active3.error(...args);
 }
 var active3;
-var init_logger2 = __esm({
+var init_logger3 = __esm({
   "dist/utils/logger.js"() {
     "use strict";
     active3 = console;
@@ -7971,6 +8282,7 @@ var init_content_id_index = __esm({
     "use strict";
     init_id();
     init_error();
+    init_logger3();
   }
 });
 
@@ -8054,7 +8366,7 @@ var init_meta_loader = __esm({
   "dist/schema/meta-loader.js"() {
     "use strict";
     init_error();
-    init_logger2();
+    init_logger3();
     init_content_id_index();
     entryTypeMetaSchema2 = z8.object({
       name: z8.string().min(1),
@@ -8120,7 +8432,6 @@ var init_types5 = __esm({
       "number",
       "boolean",
       "datetime",
-      "rich-text",
       "markdown",
       "mdx",
       "code"
@@ -8391,12 +8702,21 @@ var init_config4 = __esm({
   }
 });
 
+// dist/operating-mode/mode-env.js
+var init_mode_env3 = __esm({
+  "dist/operating-mode/mode-env.js"() {
+    "use strict";
+    init_logger3();
+  }
+});
+
 // dist/config/validation.js
 var init_validation4 = __esm({
   "dist/config/validation.js"() {
     "use strict";
     init_config4();
     init_flatten3();
+    init_mode_env3();
   }
 });
 
@@ -8459,12 +8779,12 @@ var init_content_index_generation = __esm({
 
 // dist/sync-core.js
 import fs20 from "node:fs/promises";
-import path23 from "node:path";
+import path24 from "node:path";
 import { simpleGit as simpleGit4 } from "simple-git";
 function assertWithinDir(resolved, parent, label) {
-  const normalizedResolved = path23.resolve(resolved);
-  const normalizedParent = path23.resolve(parent);
-  if (!normalizedResolved.startsWith(normalizedParent + path23.sep) && normalizedResolved !== normalizedParent) {
+  const normalizedResolved = path24.resolve(resolved);
+  const normalizedParent = path24.resolve(parent);
+  if (!normalizedResolved.startsWith(normalizedParent + path24.sep) && normalizedResolved !== normalizedParent) {
     throw new Error(`${label} escapes the expected directory: ${resolved}`);
   }
 }
@@ -8503,7 +8823,7 @@ async function listFilesRecursive(dir, prefix = "") {
       continue;
     const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
     if (entry.isDirectory()) {
-      results.push(...await listFilesRecursive(path23.join(dir, entry.name), rel));
+      results.push(...await listFilesRecursive(path24.join(dir, entry.name), rel));
     } else {
       results.push(rel);
     }
@@ -8518,8 +8838,8 @@ async function copyDir(src, dest) {
       continue;
     if (entry.isSymbolicLink())
       continue;
-    const srcPath = path23.join(src, entry.name);
-    const destPath = path23.join(dest, entry.name);
+    const srcPath = path24.join(src, entry.name);
+    const destPath = path24.join(dest, entry.name);
     if (entry.isDirectory()) {
       await copyDir(srcPath, destPath);
     } else {
@@ -8532,7 +8852,7 @@ async function pushContentToWorkspace(options) {
   if (!await filePathExists(srcContentDir)) {
     return { fileCount: 0 };
   }
-  const wsContentDir = path23.join(branchPath, contentRoot);
+  const wsContentDir = path24.join(branchPath, contentRoot);
   assertWithinDir(wsContentDir, branchPath, "content-root");
   const tmpDir = `${wsContentDir}.sync-tmp-${Date.now()}`;
   try {
@@ -8588,11 +8908,11 @@ var init_provisioning_lock = __esm({
 
 // dist/git-manager.js
 import fs21 from "node:fs/promises";
-import path24 from "node:path";
+import path25 from "node:path";
 import { simpleGit as simpleGit6 } from "simple-git";
 async function ensureGitExcludePattern2(repoPath, pattern) {
-  const excludePath = path24.join(repoPath, ".git", "info", "exclude");
-  await fs21.mkdir(path24.dirname(excludePath), { recursive: true });
+  const excludePath = path25.join(repoPath, ".git", "info", "exclude");
+  await fs21.mkdir(path25.dirname(excludePath), { recursive: true });
   let content = "";
   try {
     content = await fs21.readFile(excludePath, "utf-8");
@@ -8713,7 +9033,7 @@ var warned3, VALID_DEPLOYMENT_NAME3, isValidDeploymentName3;
 var init_deployment_name2 = __esm({
   "dist/operating-mode/deployment-name.js"() {
     "use strict";
-    init_logger2();
+    init_logger3();
     warned3 = false;
     VALID_DEPLOYMENT_NAME3 = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
     isValidDeploymentName3 = (name) => VALID_DEPLOYMENT_NAME3.test(name) && !name.includes("..") && !name.endsWith(".") && !name.endsWith(".lock");
@@ -8764,7 +9084,7 @@ var init_config5 = __esm({
 });
 
 // dist/operating-mode/client-unsafe-strategy.js
-import path25 from "node:path";
+import path26 from "node:path";
 function operatingStrategy3(mode) {
   const cached = strategyCache3.get(mode);
   if (cached)
@@ -8799,32 +9119,32 @@ var init_client_unsafe_strategy2 = __esm({
       // - shouldCommit(), shouldPush()
       // Add client-unsafe methods (use Node.js APIs)
       getWorkspaceRoot(_sourceRoot) {
-        return path25.resolve(process.env.CANOPYCMS_WORKSPACE_ROOT ?? DEFAULT_PROD_WORKSPACE3);
+        return path26.resolve(process.env.CANOPYCMS_WORKSPACE_ROOT ?? DEFAULT_PROD_WORKSPACE3);
       }
       getContentRoot(contentRoot, sourceRoot) {
-        return path25.resolve(sourceRoot ?? process.cwd(), contentRoot);
+        return path26.resolve(sourceRoot ?? process.cwd(), contentRoot);
       }
       getContentBranchesRoot(sourceRoot) {
-        return path25.join(this.getWorkspaceRoot(sourceRoot), "content-branches");
+        return path26.join(this.getWorkspaceRoot(sourceRoot), "content-branches");
       }
       getContentBranchRoot(branchName, sourceRoot) {
-        return path25.resolve(this.getContentBranchesRoot(sourceRoot), branchName);
+        return path26.resolve(this.getContentBranchesRoot(sourceRoot), branchName);
       }
       getGitExcludePattern() {
         return ".canopy-meta/";
       }
       getPermissionsFilePath(root) {
-        return path25.join(root, this.getPermissionsFileName());
+        return path26.join(root, this.getPermissionsFileName());
       }
       getGroupsFilePath(root) {
-        return path25.join(root, this.getGroupsFileName());
+        return path26.join(root, this.getGroupsFileName());
       }
       getRemoteUrlConfig() {
         return {
           shouldAutoInitLocal: false,
           defaultRemotePath: "",
           envVarName: "CANOPYCMS_REMOTE_URL",
-          autoDetectRemotePath: path25.join(this.getWorkspaceRoot(), "remote.git")
+          autoDetectRemotePath: path26.join(this.getWorkspaceRoot(), "remote.git")
         };
       }
       requiresExistingRepo() {
@@ -8836,7 +9156,7 @@ var init_client_unsafe_strategy2 = __esm({
         return `canopycms-settings-${resolveDeploymentName3(config, "prod")}`;
       }
       getSettingsRoot(sourceRoot) {
-        return path25.join(this.getWorkspaceRoot(sourceRoot), "settings");
+        return path26.join(this.getWorkspaceRoot(sourceRoot), "settings");
       }
       usesSeparateSettingsBranch() {
         return true;
@@ -8853,25 +9173,25 @@ var init_client_unsafe_strategy2 = __esm({
     DevStrategy3 = class extends DevClientSafeStrategy3 {
       // Inherits client-safe methods from DevClientSafeStrategy
       getWorkspaceRoot(sourceRoot) {
-        return path25.resolve(sourceRoot ?? process.cwd(), ".canopy-dev");
+        return path26.resolve(sourceRoot ?? process.cwd(), ".canopy-dev");
       }
       getContentRoot(contentRoot, sourceRoot) {
-        return path25.resolve(sourceRoot ?? process.cwd(), contentRoot);
+        return path26.resolve(sourceRoot ?? process.cwd(), contentRoot);
       }
       getContentBranchesRoot(sourceRoot) {
-        return path25.join(this.getWorkspaceRoot(sourceRoot), "content-branches");
+        return path26.join(this.getWorkspaceRoot(sourceRoot), "content-branches");
       }
       getContentBranchRoot(branchName, sourceRoot) {
-        return path25.resolve(this.getContentBranchesRoot(sourceRoot), branchName);
+        return path26.resolve(this.getContentBranchesRoot(sourceRoot), branchName);
       }
       getGitExcludePattern() {
         return ".canopy-meta/";
       }
       getPermissionsFilePath(root) {
-        return path25.join(root, this.getPermissionsFileName());
+        return path26.join(root, this.getPermissionsFileName());
       }
       getGroupsFilePath(root) {
-        return path25.join(root, this.getGroupsFileName());
+        return path26.join(root, this.getGroupsFileName());
       }
       getRemoteUrlConfig() {
         return {
@@ -8889,7 +9209,7 @@ var init_client_unsafe_strategy2 = __esm({
         return `canopycms-settings-${resolveDeploymentName3(config, "local")}`;
       }
       getSettingsRoot(sourceRoot) {
-        return path25.join(this.getWorkspaceRoot(sourceRoot), "settings");
+        return path26.join(this.getWorkspaceRoot(sourceRoot), "settings");
       }
       usesSeparateSettingsBranch() {
         return true;
@@ -8911,6 +9231,7 @@ var init_operating_mode2 = __esm({
     init_client_safe_strategy2();
     init_client_unsafe_strategy2();
     init_deployment_name2();
+    init_mode_env3();
   }
 });
 
@@ -8921,7 +9242,7 @@ __export(sync_exports, {
   sync: () => sync
 });
 import fs24 from "node:fs/promises";
-import path26 from "node:path";
+import path27 from "node:path";
 import { simpleGit as simpleGit7 } from "simple-git";
 import * as p2 from "@clack/prompts";
 async function detectCurrentBranch(projectDir) {
@@ -8962,7 +9283,7 @@ async function selectBranch(options, branchesDir) {
       branchName = result;
     }
   }
-  const branchPath = path26.join(branchesDir, branchName);
+  const branchPath = path27.join(branchesDir, branchName);
   assertWithinDir(branchPath, branchesDir, "--branch");
   if (!branches.includes(branchName)) {
     if (options.autoCreate) {
@@ -8983,8 +9304,8 @@ async function selectBranch(options, branchesDir) {
 async function syncPush(options) {
   const { projectDir } = options;
   const contentRoot = options.contentRoot || "content";
-  const branchesDir = path26.join(projectDir, ".canopy-dev", "content-branches");
-  const srcContentDir = path26.join(projectDir, contentRoot);
+  const branchesDir = path27.join(projectDir, ".canopy-dev", "content-branches");
+  const srcContentDir = path27.join(projectDir, contentRoot);
   assertWithinDir(srcContentDir, projectDir, "--content-root");
   if (!await filePathExists(srcContentDir)) {
     throw new SyncError(`Content directory not found: ${contentRoot}/ (expected at ${srcContentDir})`);
@@ -8992,7 +9313,7 @@ async function syncPush(options) {
   const branchName = await selectBranch({ ...options, projectDir, autoCreate: true }, branchesDir);
   if (!branchName)
     return { fileCount: 0 };
-  const branchPath = path26.join(branchesDir, branchName);
+  const branchPath = path27.join(branchesDir, branchName);
   assertWithinDir(branchPath, branchesDir, "--branch");
   const wsGit = simpleGit7({ baseDir: branchPath });
   const status = await wsGit.status();
@@ -9050,19 +9371,19 @@ async function syncPush(options) {
 async function syncPull(options) {
   const { projectDir } = options;
   const contentRoot = options.contentRoot || "content";
-  const branchesDir = path26.join(projectDir, ".canopy-dev", "content-branches");
+  const branchesDir = path27.join(projectDir, ".canopy-dev", "content-branches");
   const branchName = await selectBranch({ ...options, projectDir }, branchesDir);
   if (!branchName)
     return { fileCount: 0 };
-  const branchPath = path26.join(branchesDir, branchName);
+  const branchPath = path27.join(branchesDir, branchName);
   assertWithinDir(branchPath, branchesDir, "--branch");
-  const branchContentDir = path26.join(branchPath, contentRoot);
+  const branchContentDir = path27.join(branchPath, contentRoot);
   assertWithinDir(branchContentDir, branchPath, "--content-root");
   if (!await filePathExists(branchContentDir)) {
     throw new SyncError(`Content directory not found in branch workspace: ${branchName}/${contentRoot}`);
   }
   p2.log.step(`Pulling content from branch: ${branchName}`);
-  const destContentDir = path26.join(projectDir, contentRoot);
+  const destContentDir = path27.join(projectDir, contentRoot);
   assertWithinDir(destContentDir, projectDir, "--content-root");
   const sourceGit = simpleGit7({ baseDir: projectDir });
   const status = await sourceGit.status();
@@ -9138,8 +9459,8 @@ async function syncPull(options) {
 async function syncBoth(options) {
   const { projectDir } = options;
   const contentRoot = options.contentRoot || "content";
-  const branchesDir = path26.join(projectDir, ".canopy-dev", "content-branches");
-  const srcContentDir = path26.join(projectDir, contentRoot);
+  const branchesDir = path27.join(projectDir, ".canopy-dev", "content-branches");
+  const srcContentDir = path27.join(projectDir, contentRoot);
   assertWithinDir(srcContentDir, projectDir, "--content-root");
   if (!await filePathExists(srcContentDir)) {
     throw new SyncError(`Content directory not found: ${contentRoot}/ (expected at ${srcContentDir})`);
@@ -9147,7 +9468,7 @@ async function syncBoth(options) {
   const branchName = await selectBranch({ ...options, projectDir, autoCreate: true }, branchesDir);
   if (!branchName)
     return { pushed: 0, pulled: 0 };
-  const branchPath = path26.join(branchesDir, branchName);
+  const branchPath = path27.join(branchesDir, branchName);
   assertWithinDir(branchPath, branchesDir, "--branch");
   const wsGit = simpleGit7({ baseDir: branchPath });
   const status = await wsGit.status();
@@ -9182,7 +9503,7 @@ async function syncBoth(options) {
   try {
     const incomingBranch = `sync-incoming-${Date.now()}`;
     await wsGit.raw(["checkout", "-b", incomingBranch, baseRef]);
-    const wsContentDir = path26.join(branchPath, contentRoot);
+    const wsContentDir = path27.join(branchPath, contentRoot);
     assertWithinDir(wsContentDir, branchPath, "--content-root");
     const tmpDir = `${wsContentDir}.sync-tmp-${Date.now()}`;
     try {
@@ -9246,11 +9567,11 @@ async function syncBoth(options) {
 }
 async function syncAbort(options) {
   const { projectDir } = options;
-  const branchesDir = path26.join(projectDir, ".canopy-dev", "content-branches");
+  const branchesDir = path27.join(projectDir, ".canopy-dev", "content-branches");
   const branchName = await selectBranch({ ...options, projectDir }, branchesDir);
   if (!branchName)
     return;
-  const branchPath = path26.join(branchesDir, branchName);
+  const branchPath = path27.join(branchesDir, branchName);
   assertWithinDir(branchPath, branchesDir, "--branch");
   const wsGit = simpleGit7({ baseDir: branchPath });
   const status = await wsGit.status();
@@ -9379,7 +9700,7 @@ var init_async_mutex = __esm({
 
 // dist/utils/occ-json-write.js
 import fs25 from "node:fs/promises";
-import path27 from "node:path";
+import path28 from "node:path";
 import { randomUUID as randomUUID4 } from "node:crypto";
 import lockfile4 from "proper-lockfile";
 async function writeOccJsonFile2(filePath, payload, options) {
@@ -9388,7 +9709,7 @@ async function writeOccJsonFile2(filePath, payload, options) {
   const writeId = randomUUID4();
   const data = { ...payload, version: newVersion, writeId };
   const content = JSON.stringify(data, null, 2) + (trailingNewline ? "\n" : "");
-  const dir = path27.dirname(filePath);
+  const dir = path28.dirname(filePath);
   await fs25.mkdir(dir, { recursive: true });
   const tempPath = `${filePath}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`;
   await fs25.writeFile(tempPath, content, "utf-8");
@@ -9453,7 +9774,7 @@ async function withOccRetry2(operation, options) {
   throw new Error("Unreachable");
 }
 async function withOccFileLock2(filePath, fn) {
-  const dir = path27.dirname(filePath);
+  const dir = path28.dirname(filePath);
   await fs25.mkdir(dir, { recursive: true });
   const MAX_ATTEMPTS = 14;
   let release = null;
@@ -9514,7 +9835,7 @@ var init_occ_json_write = __esm({
 
 // dist/branch-registry.js
 import fs26 from "node:fs/promises";
-import path28 from "node:path";
+import path29 from "node:path";
 var log12, REGISTRY_FILE2, REGISTRY_STALE_FILE2, REGISTRY_TEMP_FILE2, REGISTRY_VERSION2, RESOURCE4, GET_MISS_REFRESH_MIN_INTERVAL_MS2, BranchRegistry2;
 var init_branch_registry = __esm({
   "dist/branch-registry.js"() {
@@ -9522,7 +9843,7 @@ var init_branch_registry = __esm({
     init_branch_metadata();
     init_error();
     init_debug2();
-    init_logger2();
+    init_logger3();
     init_resource_generation();
     log12 = createDebugLogger3({ prefix: "BranchRegistry" });
     REGISTRY_FILE2 = "branches.json";
@@ -9535,10 +9856,10 @@ var init_branch_registry = __esm({
       constructor(root) {
         this.regenInFlight = null;
         this.lastForcedRefreshMs = 0;
-        this.root = path28.resolve(root);
-        this.registryPath = path28.join(this.root, REGISTRY_FILE2);
-        this.stalePath = path28.join(this.root, REGISTRY_STALE_FILE2);
-        this.tempPath = path28.join(this.root, REGISTRY_TEMP_FILE2);
+        this.root = path29.resolve(root);
+        this.registryPath = path29.join(this.root, REGISTRY_FILE2);
+        this.stalePath = path29.join(this.root, REGISTRY_STALE_FILE2);
+        this.tempPath = path29.join(this.root, REGISTRY_TEMP_FILE2);
       }
       /**
        * Returns all branches. Uses the cached snapshot if its embedded generation
@@ -9671,7 +9992,7 @@ var init_branch_registry = __esm({
             if (!entry.isDirectory() || entry.name.startsWith(".")) {
               continue;
             }
-            const branchRoot = path28.join(this.root, entry.name);
+            const branchRoot = path29.join(this.root, entry.name);
             let meta;
             try {
               meta = await BranchMetadataFileManager2.loadOnly(branchRoot);
@@ -9701,7 +10022,7 @@ var init_branch_registry = __esm({
 
 // dist/branch-metadata.js
 import fs27 from "node:fs/promises";
-import path29 from "node:path";
+import path30 from "node:path";
 var BRANCH_META_DIR2, BRANCH_META_FILE2, CURRENT_SCHEMA_VERSION2, BranchMetadataConflictError2, BranchMetadataCorruptError2, BranchMetadataFileManager2;
 var init_branch_metadata = __esm({
   "dist/branch-metadata.js"() {
@@ -9730,8 +10051,8 @@ var init_branch_metadata = __esm({
     };
     BranchMetadataFileManager2 = class _BranchMetadataFileManager2 {
       constructor(branchRoot, baseRoot, options) {
-        this.branchRoot = path29.resolve(branchRoot);
-        this.filePath = path29.join(this.branchRoot, BRANCH_META_DIR2, BRANCH_META_FILE2);
+        this.branchRoot = path30.resolve(branchRoot);
+        this.filePath = path30.join(this.branchRoot, BRANCH_META_DIR2, BRANCH_META_FILE2);
         this.baseRoot = baseRoot;
         this.settleMs = options?.settleMs;
       }
@@ -9740,8 +10061,8 @@ var init_branch_metadata = __esm({
        * Use this for read-only access (e.g., in registry scanning or loadBranchContext).
        */
       static async loadOnly(branchRoot) {
-        const resolvedRoot = path29.resolve(branchRoot);
-        const filePath = path29.join(resolvedRoot, BRANCH_META_DIR2, BRANCH_META_FILE2);
+        const resolvedRoot = path30.resolve(branchRoot);
+        const filePath = path30.join(resolvedRoot, BRANCH_META_DIR2, BRANCH_META_FILE2);
         try {
           const raw = await fs27.readFile(filePath, "utf8");
           return JSON.parse(raw);
@@ -9902,7 +10223,7 @@ __export(migrate_exports, {
   slugifyName: () => slugifyName
 });
 import fs28 from "node:fs/promises";
-import path30 from "node:path";
+import path31 from "node:path";
 import * as p3 from "@clack/prompts";
 function slugifyName(name) {
   const slug = name.toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "");
@@ -9936,7 +10257,7 @@ async function planDirectory(dirPath, isRoot, ctx) {
     if (entry.name.startsWith("."))
       continue;
     if (entry.isDirectory()) {
-      const subPath = path30.join(dirPath, entry.name);
+      const subPath = path31.join(dirPath, entry.name);
       const sub = await planDirectory(subPath, false, ctx);
       if (!sub.hasContent)
         continue;
@@ -9944,10 +10265,10 @@ async function planDirectory(dirPath, isRoot, ctx) {
       ops.push(...sub.ops);
       if (!extractIdFromFilename2(entry.name)) {
         const newName = `${toValidSlug(entry.name)}.${generateId2()}`;
-        ops.push({ kind: "rename", from: subPath, to: path30.join(dirPath, newName) });
+        ops.push({ kind: "rename", from: subPath, to: path31.join(dirPath, newName) });
       }
     } else if (entry.isFile()) {
-      const ext = path30.extname(entry.name).slice(1);
+      const ext = path31.extname(entry.name).slice(1);
       const matchesFormat = ext === ctx.format || ctx.format === "yaml" && ext === "yml";
       if (!matchesFormat)
         continue;
@@ -9958,17 +10279,17 @@ async function planDirectory(dirPath, isRoot, ctx) {
         const newName = `${ctx.entryType}.${toValidSlug(base)}.${generateId2()}.${ext}`;
         ops.push({
           kind: "rename",
-          from: path30.join(dirPath, entry.name),
-          to: path30.join(dirPath, newName)
+          from: path31.join(dirPath, entry.name),
+          to: path31.join(dirPath, newName)
         });
       }
     }
   }
   const needsMeta = isRoot ? hasOwnFiles : hasContent;
-  const metaPath = path30.join(dirPath, ".collection.json");
+  const metaPath = path31.join(dirPath, ".collection.json");
   if (needsMeta && !await filePathExists(metaPath)) {
     const entryTypeMeta = { name: ctx.entryType, format: ctx.format, schema: ctx.schema };
-    const meta = isRoot ? { entries: [entryTypeMeta] } : { name: toValidSlug(stripDirIdSuffix(path30.basename(dirPath))), entries: [entryTypeMeta] };
+    const meta = isRoot ? { entries: [entryTypeMeta] } : { name: toValidSlug(stripDirIdSuffix(path31.basename(dirPath))), entries: [entryTypeMeta] };
     ops.push({ kind: "write", filePath: metaPath, content: JSON.stringify(meta, null, 2) + "\n" });
   }
   return { ops, hasContent };
@@ -9977,7 +10298,7 @@ async function migrate(options) {
   const { projectDir } = options;
   const contentRoot = options.contentRoot || "content";
   p3.intro("CanopyCMS migrate");
-  const contentDir = path30.join(projectDir, contentRoot);
+  const contentDir = path31.join(projectDir, contentRoot);
   if (!await filePathExists(contentDir)) {
     throw new MigrateError(`Content directory not found: ${contentRoot}/ (expected at ${contentDir})`);
   }
@@ -10061,7 +10382,7 @@ async function migrate(options) {
     }
   };
   if (isBranchClone) {
-    const lockPath = path30.join(projectDir, ".canopy-meta", "schema");
+    const lockPath = path31.join(projectDir, ".canopy-meta", "schema");
     try {
       await withLock2(lockPath, () => withOccFileLock2(lockPath, applyOps));
     } catch (err) {
@@ -10109,7 +10430,7 @@ var init_migrate = __esm({
         this.name = "MigrateError";
       }
     };
-    describeOp = (op, baseDir) => op.kind === "rename" ? `rename  ${path30.relative(baseDir, op.from)} \u2192 ${path30.basename(op.to)}` : `create  ${path30.relative(baseDir, op.filePath)}`;
+    describeOp = (op, baseDir) => op.kind === "rename" ? `rename  ${path31.relative(baseDir, op.from)} \u2192 ${path31.basename(op.to)}` : `create  ${path31.relative(baseDir, op.filePath)}`;
   }
 });