canopycms 0.0.10 → 0.0.12

package/dist/cli/init.js

@@ -9,107 +9,6 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// dist/operating-mode/client-safe-strategy.js
-var ProdClientSafeStrategy, LocalProdSimClientSafeStrategy, LocalSimpleClientSafeStrategy;
-var init_client_safe_strategy = __esm({
-  "dist/operating-mode/client-safe-strategy.js"() {
-    "use strict";
-    ProdClientSafeStrategy = class {
-      constructor() {
-        this.mode = "prod";
-      }
-      // UI Feature Flags
-      supportsBranching() {
-        return true;
-      }
-      supportsStatusBadge() {
-        return true;
-      }
-      supportsComments() {
-        return true;
-      }
-      supportsPullRequests() {
-        return true;
-      }
-      // Simple Data
-      getPermissionsFileName() {
-        return "permissions.json";
-      }
-      getGroupsFileName() {
-        return "groups.json";
-      }
-      shouldCommit() {
-        return true;
-      }
-      shouldPush() {
-        return true;
-      }
-    };
-    LocalProdSimClientSafeStrategy = class {
-      constructor() {
-        this.mode = "prod-sim";
-      }
-      // UI Feature Flags
-      supportsBranching() {
-        return true;
-      }
-      supportsStatusBadge() {
-        return true;
-      }
-      supportsComments() {
-        return true;
-      }
-      supportsPullRequests() {
-        return false;
-      }
-      // Simple Data
-      getPermissionsFileName() {
-        return "permissions.json";
-      }
-      getGroupsFileName() {
-        return "groups.json";
-      }
-      shouldCommit() {
-        return true;
-      }
-      shouldPush() {
-        return true;
-      }
-    };
-    LocalSimpleClientSafeStrategy = class {
-      constructor() {
-        this.mode = "dev";
-      }
-      // UI Feature Flags
-      supportsBranching() {
-        return false;
-      }
-      supportsStatusBadge() {
-        return false;
-      }
-      supportsComments() {
-        return false;
-      }
-      supportsPullRequests() {
-        return false;
-      }
-      // Simple Data
-      getPermissionsFileName() {
-        return "permissions.json";
-      }
-      getGroupsFileName() {
-        return "groups.json";
-      }
-      shouldCommit() {
-        return false;
-      }
-      shouldPush() {
-        return false;
-      }
-    };
-  }
-});
-
 // dist/config/types.js
 var primitiveFieldTypes, fieldTypes;
 var init_types = __esm({
@@ -295,7 +194,7 @@ var init_config = __esm({
     gitBotAuthorNameSchema = z4.string().min(1);
     gitBotAuthorEmailSchema = z4.string().email();
     githubTokenEnvVarSchema = z4.string().default("GITHUB_BOT_TOKEN");
-    operatingModeSchema = z4.enum(["prod", "prod-sim", "dev"]).default("dev");
+    operatingModeSchema = z4.enum(["prod", "dev"]).default("dev");
     deployedAsSchema = z4.enum(["static", "server"]).default("server");
     contentRootSchema = relativePathSchema.default("content");
     sourceRootSchema = z4.string().min(1).optional();
@@ -358,20 +257,6 @@ var init_permissions = __esm({
 });
 
 // dist/paths/normalize.js
-function normalizeFilesystemPath(path16) {
-  return path16.split(/[\\/]+/).filter(Boolean).join("/");
-}
-function hasTraversalSequence(path16) {
-  const normalized = normalizeFilesystemPath(path16);
-  return normalized.includes("..");
-}
-function createLogicalPath(...segments) {
-  const normalized = segments.map((s) => normalizeFilesystemPath(s)).filter(Boolean).join("/");
-  if (hasTraversalSequence(normalized)) {
-    throw new Error(`Invalid path: contains traversal sequence: ${normalized}`);
-  }
-  return normalized;
-}
 var init_normalize = __esm({
   "dist/paths/normalize.js"() {
     "use strict";
@@ -379,116 +264,19 @@ var init_normalize = __esm({
 });
 
 // dist/paths/types.js
-var ROOT_COLLECTION_ID;
 var init_types2 = __esm({
   "dist/paths/types.js"() {
     "use strict";
-    ROOT_COLLECTION_ID = "__rootcoll__";
   }
 });
 
 // dist/config/flatten.js
 import { join, normalize } from "pathe";
-var normalizePathValue, flattenSchema;
 var init_flatten = __esm({
   "dist/config/flatten.js"() {
     "use strict";
     init_normalize();
     init_types2();
-    normalizePathValue = (val) => normalize(val).split("/").filter(Boolean).join("/");
-    flattenSchema = (root, basePath = "") => {
-      const flat = [];
-      const base = normalizePathValue(basePath || "");
-      const walkCollection = (collection, parentPath) => {
-        const normalizedPath = normalizePathValue(collection.path);
-        let logicalPath;
-        if (parentPath && parentPath !== base) {
-          logicalPath = join(parentPath, collection.name);
-        } else if (parentPath === base) {
-          logicalPath = join(base, normalizedPath);
-        } else {
-          logicalPath = normalizedPath;
-        }
-        const normalizedFull = normalizePathValue(logicalPath);
-        flat.push({
-          type: "collection",
-          logicalPath: createLogicalPath(normalizedFull),
-          name: collection.name,
-          label: collection.label,
-          description: collection.description,
-          contentId: collection.contentId,
-          parentPath: parentPath ? createLogicalPath(parentPath) : void 0,
-          entries: collection.entries,
-          collections: collection.collections,
-          order: collection.order
-        });
-        if (collection.entries) {
-          for (const entryType of collection.entries) {
-            const entryTypePath = join(normalizedFull, entryType.name);
-            flat.push({
-              type: "entry-type",
-              logicalPath: createLogicalPath(normalizePathValue(entryTypePath)),
-              name: entryType.name,
-              label: entryType.label,
-              description: entryType.description,
-              parentPath: createLogicalPath(normalizedFull),
-              format: entryType.format,
-              schema: entryType.schema,
-              schemaRef: entryType.schemaRef,
-              default: entryType.default,
-              maxItems: entryType.maxItems
-            });
-          }
-        }
-        if (collection.collections) {
-          for (const child of collection.collections) {
-            walkCollection(child, normalizedFull);
-          }
-        }
-      };
-      if (base) {
-        flat.push({
-          type: "collection",
-          logicalPath: createLogicalPath(base),
-          name: base,
-          // Use base path as the name (e.g., 'content')
-          label: void 0,
-          // Root collection has no label
-          contentId: ROOT_COLLECTION_ID,
-          // Sentinel — root dir has no embedded ID
-          parentPath: void 0,
-          // No parent - this is the root
-          entries: root.entries,
-          collections: root.collections,
-          order: root.order
-        });
-      }
-      if (root.entries) {
-        for (const entryType of root.entries) {
-          const entryTypePath = base ? join(base, entryType.name) : entryType.name;
-          flat.push({
-            type: "entry-type",
-            logicalPath: createLogicalPath(normalizePathValue(entryTypePath)),
-            name: entryType.name,
-            label: entryType.label,
-            description: entryType.description,
-            parentPath: base ? createLogicalPath(base) : createLogicalPath(""),
-            // Now references the root collection (e.g., 'content')
-            format: entryType.format,
-            schema: entryType.schema,
-            schemaRef: entryType.schemaRef,
-            default: entryType.default,
-            maxItems: entryType.maxItems
-          });
-        }
-      }
-      if (root.collections) {
-        for (const collection of root.collections) {
-          walkCollection(collection, base || "");
-        }
-      }
-      return flat;
-    };
   }
 });
 
@@ -533,208 +321,6 @@ var init_config3 = __esm({
   }
 });
 
-// dist/operating-mode/client-unsafe-strategy.js
-import path from "node:path";
-function operatingStrategy(mode) {
-  const cached = strategyCache.get(mode);
-  if (cached)
-    return cached;
-  let strategy;
-  switch (mode) {
-    case "prod":
-      strategy = new ProdStrategy();
-      break;
-    case "prod-sim":
-      strategy = new LocalProdSimStrategy();
-      break;
-    case "dev":
-      strategy = new LocalSimpleStrategy();
-      break;
-    default: {
-      const _exhaustive = mode;
-      throw new Error(`Unknown operating mode: ${_exhaustive}`);
-    }
-  }
-  strategyCache.set(mode, strategy);
-  return strategy;
-}
-var ProdStrategy, LocalProdSimStrategy, LocalSimpleStrategy, strategyCache;
-var init_client_unsafe_strategy = __esm({
-  "dist/operating-mode/client-unsafe-strategy.js"() {
-    "use strict";
-    init_client_safe_strategy();
-    init_config3();
-    ProdStrategy = class extends ProdClientSafeStrategy {
-      // All client-safe methods inherited automatically from ProdClientSafeStrategy:
-      // - mode, supportsBranching(), supportsStatusBadge(), supportsComments()
-      // - supportsPullRequests(), getPermissionsFileName(), getGroupsFileName()
-      // - shouldCommit(), shouldPush()
-      // Add client-unsafe methods (use Node.js APIs)
-      getWorkspaceRoot(_sourceRoot) {
-        return path.resolve(process.env.CANOPYCMS_WORKSPACE_ROOT ?? DEFAULT_PROD_WORKSPACE);
-      }
-      getContentRoot(sourceRoot) {
-        return path.resolve(sourceRoot ?? process.cwd(), "content");
-      }
-      getContentBranchesRoot(sourceRoot) {
-        return path.join(this.getWorkspaceRoot(sourceRoot), "content-branches");
-      }
-      getContentBranchRoot(branchName, sourceRoot) {
-        return path.resolve(this.getContentBranchesRoot(sourceRoot), branchName);
-      }
-      getGitExcludePattern() {
-        return ".canopy-meta/";
-      }
-      getPermissionsFilePath(root) {
-        return path.join(root, this.getPermissionsFileName());
-      }
-      getGroupsFilePath(root) {
-        return path.join(root, this.getGroupsFileName());
-      }
-      getRemoteUrlConfig() {
-        return {
-          shouldAutoInitLocal: false,
-          defaultRemotePath: "",
-          envVarName: "CANOPYCMS_REMOTE_URL",
-          autoDetectRemotePath: path.join(this.getWorkspaceRoot(), "remote.git")
-        };
-      }
-      requiresExistingRepo() {
-        return false;
-      }
-      getSettingsBranchName(config) {
-        if (config.settingsBranch)
-          return config.settingsBranch;
-        const deploymentName = config.deploymentName ?? "prod";
-        return `canopycms-settings-${deploymentName}`;
-      }
-      getSettingsRoot(sourceRoot) {
-        return path.join(this.getWorkspaceRoot(sourceRoot), "settings");
-      }
-      usesSeparateSettingsBranch() {
-        return true;
-      }
-      validateConfig(config) {
-        if (!config.gitBotAuthorName || !config.gitBotAuthorEmail) {
-          throw new Error("gitBotAuthorName and gitBotAuthorEmail are required in prod mode");
-        }
-      }
-      shouldCreateSettingsPR(config) {
-        return config.autoCreateSettingsPR ?? true;
-      }
-    };
-    LocalProdSimStrategy = class extends LocalProdSimClientSafeStrategy {
-      // Inherits client-safe methods from LocalProdSimClientSafeStrategy
-      getWorkspaceRoot(sourceRoot) {
-        return path.resolve(sourceRoot ?? process.cwd(), ".canopy-prod-sim");
-      }
-      getContentRoot(sourceRoot) {
-        return path.resolve(sourceRoot ?? process.cwd(), "content");
-      }
-      getContentBranchesRoot(sourceRoot) {
-        return path.join(this.getWorkspaceRoot(sourceRoot), "content-branches");
-      }
-      getContentBranchRoot(branchName, sourceRoot) {
-        return path.resolve(this.getContentBranchesRoot(sourceRoot), branchName);
-      }
-      getGitExcludePattern() {
-        return ".canopy-meta/";
-      }
-      getPermissionsFilePath(root) {
-        return path.join(root, this.getPermissionsFileName());
-      }
-      getGroupsFilePath(root) {
-        return path.join(root, this.getGroupsFileName());
-      }
-      getRemoteUrlConfig() {
-        return {
-          shouldAutoInitLocal: true,
-          defaultRemotePath: ".canopy-prod-sim/remote.git",
-          envVarName: "CANOPYCMS_REMOTE_URL"
-        };
-      }
-      requiresExistingRepo() {
-        return false;
-      }
-      getSettingsBranchName(config) {
-        if (config.settingsBranch)
-          return config.settingsBranch;
-        const deploymentName = config.deploymentName ?? "prod";
-        return `canopycms-settings-${deploymentName}`;
-      }
-      getSettingsRoot(sourceRoot) {
-        return path.join(this.getWorkspaceRoot(sourceRoot), "settings");
-      }
-      usesSeparateSettingsBranch() {
-        return true;
-      }
-      validateConfig(_config) {
-      }
-      shouldCreateSettingsPR(_config) {
-        return false;
-      }
-    };
-    LocalSimpleStrategy = class extends LocalSimpleClientSafeStrategy {
-      // Inherits: supportsBranching() returns false, getPermissionsFileName() returns 'permissions.local.json'
-      getWorkspaceRoot(sourceRoot) {
-        return path.resolve(sourceRoot ?? process.cwd(), ".canopy-dev");
-      }
-      getContentRoot(sourceRoot) {
-        return path.resolve(sourceRoot ?? process.cwd(), "content");
-      }
-      getContentBranchesRoot(_sourceRoot) {
-        throw new Error("No branching in dev mode");
-      }
-      getContentBranchRoot(_branchName, _sourceRoot) {
-        throw new Error("No branching in dev mode");
-      }
-      getGitExcludePattern() {
-        return ".canopy-meta/";
-      }
-      getPermissionsFilePath(root) {
-        return path.join(this.getWorkspaceRoot(root), "settings", "permissions.json");
-      }
-      getGroupsFilePath(root) {
-        return path.join(this.getWorkspaceRoot(root), "settings", "groups.json");
-      }
-      getRemoteUrlConfig() {
-        return {
-          shouldAutoInitLocal: false,
-          defaultRemotePath: "",
-          envVarName: "CANOPYCMS_REMOTE_URL"
-        };
-      }
-      requiresExistingRepo() {
-        return true;
-      }
-      getSettingsBranchName(config) {
-        return config.defaultBaseBranch ?? "main";
-      }
-      getSettingsRoot(sourceRoot) {
-        return path.join(this.getWorkspaceRoot(sourceRoot), "settings");
-      }
-      usesSeparateSettingsBranch() {
-        return false;
-      }
-      validateConfig(_config) {
-      }
-      shouldCreateSettingsPR(_config) {
-        return false;
-      }
-    };
-    strategyCache = /* @__PURE__ */ new Map();
-  }
-});
-
-// dist/operating-mode/index.js
-var init_operating_mode = __esm({
-  "dist/operating-mode/index.js"() {
-    "use strict";
-    init_client_safe_strategy();
-    init_client_unsafe_strategy();
-  }
-});
-
 // dist/cli/templates.js
 var templates_exports = {};
 __export(templates_exports, {
@@ -748,11 +334,11 @@ __export(templates_exports, {
   githubWorkflowCms: () => githubWorkflowCms,
   schemasTemplate: () => schemasTemplate
 });
-import fs from "node:fs/promises";
+import fs2 from "node:fs/promises";
 import path2 from "node:path";
 import { fileURLToPath } from "node:url";
 async function readTemplate(name) {
-  return fs.readFile(path2.join(TEMPLATES_DIR, name), "utf-8");
+  return fs2.readFile(path2.join(TEMPLATES_DIR, name), "utf-8");
 }
 async function canopyCmsConfig(options) {
   const template = await readTemplate("canopycms.config.ts.template");
@@ -807,11 +393,9 @@ function getTaskQueueDir(config) {
       const workspace = process.env.CANOPYCMS_WORKSPACE_ROOT ?? DEFAULT_PROD_WORKSPACE;
       return path3.join(path3.resolve(workspace), ".tasks");
     }
-    case "prod-sim": {
-      return path3.join(process.cwd(), ".canopy-prod-sim", ".tasks");
+    case "dev": {
+      return path3.join(process.cwd(), ".canopy-dev", ".tasks");
     }
-    case "dev":
-      return null;
   }
 }
 var init_task_queue_config = __esm({
@@ -919,17 +503,17 @@ var init_debug = __esm({
 });
 
 // dist/utils/atomic-write.js
-import fs2 from "node:fs/promises";
+import fs3 from "node:fs/promises";
 import path4 from "node:path";
 async function atomicWriteFile(filePath, content) {
   const dir = path4.dirname(filePath);
-  await fs2.mkdir(dir, { recursive: true });
+  await fs3.mkdir(dir, { recursive: true });
   const tempPath = `${filePath}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`;
-  await fs2.writeFile(tempPath, content, "utf-8");
+  await fs3.writeFile(tempPath, content, "utf-8");
   try {
-    await fs2.rename(tempPath, filePath);
+    await fs3.rename(tempPath, filePath);
   } catch (err) {
-    await fs2.unlink(tempPath).catch(() => {
+    await fs3.unlink(tempPath).catch(() => {
     });
     throw err;
   }
@@ -941,10 +525,10 @@ var init_atomic_write = __esm({
 });
 
 // dist/task-queue/task-queue.js
-import fs3 from "node:fs/promises";
+import fs4 from "node:fs/promises";
 import path5 from "node:path";
 import crypto from "node:crypto";
-function isNotFoundError(err) {
+function isNotFoundError2(err) {
   return err instanceof Error && "code" in err && err.code === "ENOENT";
 }
 async function enqueueTask(taskDir, task, logger = nullLogger) {
@@ -969,7 +553,7 @@ async function dequeueTask(taskDir, logger = nullLogger) {
   const processingDir = path5.join(taskDir, "processing");
   let files;
   try {
-    files = await fs3.readdir(pendingDir);
+    files = await fs4.readdir(pendingDir);
   } catch {
     return null;
   }
@@ -980,7 +564,7 @@ async function dequeueTask(taskDir, logger = nullLogger) {
   const tasks = [];
   for (const fileName2 of jsonFiles) {
     try {
-      const content = await fs3.readFile(path5.join(pendingDir, fileName2), "utf-8");
+      const content = await fs4.readFile(path5.join(pendingDir, fileName2), "utf-8");
       const task2 = parseTaskJson(content);
       if (!task2) {
         await moveToCorrupt(taskDir, pendingDir, fileName2, "Invalid JSON", logger);
@@ -991,7 +575,7 @@ async function dequeueTask(taskDir, logger = nullLogger) {
       }
       tasks.push({ fileName: fileName2, task: task2 });
     } catch (err) {
-      if (isNotFoundError(err))
+      if (isNotFoundError2(err))
         continue;
       throw err;
     }
@@ -1001,7 +585,7 @@ async function dequeueTask(taskDir, logger = nullLogger) {
   tasks.sort((a, b) => a.task.createdAt.localeCompare(b.task.createdAt) || a.task.id.localeCompare(b.task.id));
   const { fileName, task } = tasks[0];
   if (await taskExistsIn(taskDir, task.id, ["completed", "failed"])) {
-    await fs3.unlink(path5.join(pendingDir, fileName)).catch(() => {
+    await fs4.unlink(path5.join(pendingDir, fileName)).catch(() => {
     });
     logger.debug("Skipped already-finished task", { id: task.id });
     return null;
@@ -1011,11 +595,11 @@ async function dequeueTask(taskDir, logger = nullLogger) {
   try {
     task.status = "processing";
     await atomicWriteFile(destPath, JSON.stringify(task, null, 2));
-    await fs3.unlink(sourcePath);
+    await fs4.unlink(sourcePath);
     logger.debug("Dequeued task", { id: task.id, action: task.action });
     return task;
   } catch (err) {
-    if (isNotFoundError(err))
+    if (isNotFoundError2(err))
       return null;
     throw err;
   }
@@ -1026,17 +610,17 @@ async function completeTask(taskDir, taskId, result, logger = nullLogger) {
   const completedPath = path5.join(completedDir, `${taskId}.json`);
   let task;
   try {
-    const content = await fs3.readFile(processingPath, "utf-8");
+    const content = await fs4.readFile(processingPath, "utf-8");
     const parsed = parseTaskJson(content);
     if (!parsed) {
       logger.debug("Corrupt task file in processing, removing", { id: taskId });
-      await fs3.unlink(processingPath).catch(() => {
+      await fs4.unlink(processingPath).catch(() => {
       });
       return;
     }
     task = parsed;
   } catch (err) {
-    if (isNotFoundError(err))
+    if (isNotFoundError2(err))
       return;
     throw err;
   }
@@ -1044,7 +628,7 @@ async function completeTask(taskDir, taskId, result, logger = nullLogger) {
   task.completedAt = (/* @__PURE__ */ new Date()).toISOString();
   task.result = result;
   await atomicWriteFile(completedPath, JSON.stringify(task, null, 2));
-  await fs3.unlink(processingPath).catch(() => {
+  await fs4.unlink(processingPath).catch(() => {
   });
   logger.debug("Completed task", { id: taskId });
 }
@@ -1054,17 +638,17 @@ async function failTask(taskDir, taskId, error, logger = nullLogger) {
   const failedPath = path5.join(failedDir, `${taskId}.json`);
   let task;
   try {
-    const content = await fs3.readFile(processingPath, "utf-8");
+    const content = await fs4.readFile(processingPath, "utf-8");
     const parsed = parseTaskJson(content);
     if (!parsed) {
       logger.debug("Corrupt task file in processing, removing", { id: taskId });
-      await fs3.unlink(processingPath).catch(() => {
+      await fs4.unlink(processingPath).catch(() => {
       });
       return;
     }
     task = parsed;
   } catch (err) {
-    if (isNotFoundError(err))
+    if (isNotFoundError2(err))
       return;
     throw err;
   }
@@ -1072,7 +656,7 @@ async function failTask(taskDir, taskId, error, logger = nullLogger) {
   task.completedAt = (/* @__PURE__ */ new Date()).toISOString();
   task.error = error;
   await atomicWriteFile(failedPath, JSON.stringify(task, null, 2));
-  await fs3.unlink(processingPath).catch(() => {
+  await fs4.unlink(processingPath).catch(() => {
   });
   logger.debug("Failed task", { id: taskId, error });
 }
@@ -1082,17 +666,17 @@ async function retryTask(taskDir, taskId, error, logger = nullLogger) {
   const pendingPath = path5.join(pendingDir, `${taskId}.json`);
   let task;
   try {
-    const content = await fs3.readFile(processingPath, "utf-8");
+    const content = await fs4.readFile(processingPath, "utf-8");
     const parsed = parseTaskJson(content);
     if (!parsed) {
       logger.debug("Corrupt task file in processing, removing", { id: taskId });
-      await fs3.unlink(processingPath).catch(() => {
+      await fs4.unlink(processingPath).catch(() => {
       });
       return;
     }
     task = parsed;
   } catch (err) {
-    if (isNotFoundError(err))
+    if (isNotFoundError2(err))
       return;
     throw err;
   }
@@ -1103,7 +687,7 @@ async function retryTask(taskDir, taskId, error, logger = nullLogger) {
   task.retryAfter = new Date(Date.now() + backoffMs).toISOString();
   task.error = error;
   await atomicWriteFile(pendingPath, JSON.stringify(task, null, 2));
-  await fs3.unlink(processingPath).catch(() => {
+  await fs4.unlink(processingPath).catch(() => {
   });
   logger.debug("Retrying task", { id: taskId, retryCount, backoffMs });
 }
@@ -1112,7 +696,7 @@ async function recoverOrphanedTasks(taskDir, maxAgeMs = 5 * 6e4, logger = nullLo
   const pendingDir = path5.join(taskDir, "pending");
   let files;
   try {
-    files = await fs3.readdir(processingDir);
+    files = await fs4.readdir(processingDir);
   } catch {
     return 0;
   }
@@ -1121,16 +705,16 @@ async function recoverOrphanedTasks(taskDir, maxAgeMs = 5 * 6e4, logger = nullLo
   for (const fileName of files.filter((f) => f.endsWith(".json"))) {
     const filePath = path5.join(processingDir, fileName);
     try {
-      const stat = await fs3.stat(filePath);
+      const stat = await fs4.stat(filePath);
       if (now - stat.mtimeMs >= maxAgeMs) {
-        const content = await fs3.readFile(filePath, "utf-8");
+        const content = await fs4.readFile(filePath, "utf-8");
         const task = parseTaskJson(content);
         if (!task) {
           await moveToCorrupt(taskDir, processingDir, fileName, "Invalid JSON during recovery", logger);
           continue;
         }
         if (await taskExistsIn(taskDir, task.id, ["completed", "failed"])) {
-          await fs3.unlink(filePath).catch(() => {
+          await fs4.unlink(filePath).catch(() => {
           });
           logger.debug("Cleaned up orphaned task (already finished)", {
             id: task.id
@@ -1139,7 +723,7 @@ async function recoverOrphanedTasks(taskDir, maxAgeMs = 5 * 6e4, logger = nullLo
         }
         task.status = "pending";
         await atomicWriteFile(path5.join(pendingDir, fileName), JSON.stringify(task, null, 2));
-        await fs3.unlink(filePath);
+        await fs4.unlink(filePath);
         logger.debug("Recovered orphaned task", {
           id: task.id,
           action: task.action
@@ -1147,7 +731,7 @@ async function recoverOrphanedTasks(taskDir, maxAgeMs = 5 * 6e4, logger = nullLo
         recovered++;
       }
     } catch (err) {
-      if (isNotFoundError(err))
+      if (isNotFoundError2(err))
         continue;
       logger.debug("Failed to recover task", { fileName });
     }
@@ -1161,16 +745,16 @@ async function cleanupOldTasks(taskDir, maxAgeMs = 30 * 24 * 60 * 6e4, logger =
     const dir = path5.join(taskDir, subdir);
     let files;
     try {
-      files = await fs3.readdir(dir);
+      files = await fs4.readdir(dir);
     } catch {
       continue;
     }
     for (const fileName of files.filter((f) => f.endsWith(".json"))) {
       try {
         const filePath = path5.join(dir, fileName);
-        const stat = await fs3.stat(filePath);
+        const stat = await fs4.stat(filePath);
         if (now - stat.mtimeMs >= maxAgeMs) {
-          await fs3.unlink(filePath);
+          await fs4.unlink(filePath);
           cleaned++;
         }
       } catch {
@@ -1186,7 +770,7 @@ async function getTask(taskDir, taskId) {
   for (const subdir of ["completed", "failed", "processing", "pending"]) {
     const filePath = path5.join(taskDir, subdir, `${taskId}.json`);
     try {
-      const content = await fs3.readFile(filePath, "utf-8");
+      const content = await fs4.readFile(filePath, "utf-8");
       return parseTaskJson(content);
     } catch {
       continue;
@@ -1198,7 +782,7 @@ async function listTasks(taskDir, status, limit = 100) {
   const dir = path5.join(taskDir, status);
   let files;
   try {
-    files = await fs3.readdir(dir);
+    files = await fs4.readdir(dir);
   } catch {
     return [];
   }
@@ -1207,7 +791,7 @@ async function listTasks(taskDir, status, limit = 100) {
     if (tasks.length >= limit)
       break;
     try {
-      const content = await fs3.readFile(path5.join(dir, fileName), "utf-8");
+      const content = await fs4.readFile(path5.join(dir, fileName), "utf-8");
       const task = parseTaskJson(content);
       if (task)
         tasks.push(task);
@@ -1229,7 +813,7 @@ async function getQueueStats(taskDir) {
   for (const status of ["pending", "processing", "completed", "failed", "corrupt"]) {
     const dir = path5.join(taskDir, status);
     try {
-      const files = await fs3.readdir(dir);
+      const files = await fs4.readdir(dir);
       stats[status] = files.filter((f) => f.endsWith(".json")).length;
     } catch {
     }
@@ -1250,7 +834,7 @@ function parseTaskJson(content) {
 async function taskExistsIn(taskDir, taskId, subdirs) {
   for (const subdir of subdirs) {
     try {
-      await fs3.stat(path5.join(taskDir, subdir, `${taskId}.json`));
+      await fs4.stat(path5.join(taskDir, subdir, `${taskId}.json`));
       return true;
     } catch {
     }
@@ -1260,11 +844,11 @@ async function taskExistsIn(taskDir, taskId, subdirs) {
 async function moveToCorrupt(taskDir, sourceDir, fileName, reason, logger) {
   const corruptDir = path5.join(taskDir, "corrupt");
   try {
-    await fs3.mkdir(corruptDir, { recursive: true });
-    await fs3.rename(path5.join(sourceDir, fileName), path5.join(corruptDir, fileName));
+    await fs4.mkdir(corruptDir, { recursive: true });
+    await fs4.rename(path5.join(sourceDir, fileName), path5.join(corruptDir, fileName));
     logger.debug("Moved corrupt task file", { fileName, reason });
   } catch {
-    await fs3.unlink(path5.join(sourceDir, fileName)).catch(() => {
+    await fs4.unlink(path5.join(sourceDir, fileName)).catch(() => {
     });
   }
 }
@@ -1318,2256 +902,237 @@ var init_task_queue3 = __esm({
   }
 });
 
-// dist/paths/validation.js
-function isValidContentId(id) {
-  return CONTENT_ID_PATTERN.test(id);
-}
-var BASE58_PATTERN, CONTENT_ID_PATTERN, PHYSICAL_SEGMENT_PATTERN;
-var init_validation2 = __esm({
-  "dist/paths/validation.js"() {
-    "use strict";
-    init_normalize();
-    BASE58_PATTERN = "[123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz]";
-    CONTENT_ID_PATTERN = new RegExp(`^${BASE58_PATTERN}{12}$`);
-    PHYSICAL_SEGMENT_PATTERN = new RegExp(`\\.${BASE58_PATTERN}{12}(?:\\.[a-z]+)?$`);
-  }
-});
+// dist/cli/init.js
+import fs5 from "node:fs/promises";
+import path6 from "node:path";
+import * as p from "@clack/prompts";
 
-// dist/id.js
-import { generate } from "short-uuid";
-function generateId() {
-  const full = generate();
-  return full.substring(0, 12);
-}
-var isValidId;
-var init_id = __esm({
-  "dist/id.js"() {
-    "use strict";
-    init_validation2();
-    isValidId = isValidContentId;
+// dist/operating-mode/client-safe-strategy.js
+var ProdClientSafeStrategy = class {
+  constructor() {
+    this.mode = "prod";
   }
-});
-
-// dist/utils/error.js
-function getErrorMessage(err) {
-  if (err instanceof Error) {
-    return err.message;
+  // UI Feature Flags
+  supportsBranching() {
+    return true;
   }
-  if (typeof err === "string") {
-    return err;
+  supportsStatusBadge() {
+    return true;
   }
-  return String(err);
-}
-function isNodeError(err) {
-  return err instanceof Error && "code" in err;
-}
-function isNotFoundError2(err) {
-  return isNodeError(err) && err.code === "ENOENT";
-}
-function isFileExistsError(err) {
-  return isNodeError(err) && err.code === "EEXIST";
-}
-var init_error = __esm({
-  "dist/utils/error.js"() {
-    "use strict";
+  supportsComments() {
+    return true;
   }
-});
+  supportsPullRequests() {
+    return true;
+  }
+  // Simple Data
+  getPermissionsFileName() {
+    return "permissions.json";
+  }
+  getGroupsFileName() {
+    return "groups.json";
+  }
+  shouldCommit() {
+    return true;
+  }
+  shouldPush() {
+    return true;
+  }
+};
+var DevClientSafeStrategy = class {
+  constructor() {
+    this.mode = "dev";
+  }
+  // UI Feature Flags
+  supportsBranching() {
+    return true;
+  }
+  supportsStatusBadge() {
+    return true;
+  }
+  supportsComments() {
+    return true;
+  }
+  supportsPullRequests() {
+    return false;
+  }
+  // Simple Data
+  getPermissionsFileName() {
+    return "permissions.json";
+  }
+  getGroupsFileName() {
+    return "groups.json";
+  }
+  shouldCommit() {
+    return true;
+  }
+  shouldPush() {
+    return true;
+  }
+};
 
-// dist/content-id-index.js
-import fs4 from "node:fs/promises";
-import path6 from "node:path";
-function toLogicalCollectionPath(physicalPath) {
-  if (physicalPath === ".")
-    return EMPTY_LOGICAL_PATH;
-  return physicalPath.split("/").map((seg) => extractSlugFromFilename(seg)).join("/");
-}
-function extractIdFromFilename(filename) {
-  if (filename.startsWith(".")) {
-    return null;
+// dist/operating-mode/client-unsafe-strategy.js
+import path from "node:path";
+init_config3();
+var ProdStrategy = class extends ProdClientSafeStrategy {
+  // All client-safe methods inherited automatically from ProdClientSafeStrategy:
+  // - mode, supportsBranching(), supportsStatusBadge(), supportsComments()
+  // - supportsPullRequests(), getPermissionsFileName(), getGroupsFileName()
+  // - shouldCommit(), shouldPush()
+  // Add client-unsafe methods (use Node.js APIs)
+  getWorkspaceRoot(_sourceRoot) {
+    return path.resolve(process.env.CANOPYCMS_WORKSPACE_ROOT ?? DEFAULT_PROD_WORKSPACE);
   }
-  const parts = filename.split(".");
-  if (parts.length >= 3) {
-    const candidate = parts[parts.length - 2];
-    if (isValidId(candidate))
-      return candidate;
+  getContentRoot(sourceRoot) {
+    return path.resolve(sourceRoot ?? process.cwd(), "content");
   }
-  if (parts.length === 2) {
-    const candidate = parts[parts.length - 1];
-    if (isValidId(candidate))
-      return candidate;
+  getContentBranchesRoot(sourceRoot) {
+    return path.join(this.getWorkspaceRoot(sourceRoot), "content-branches");
   }
-  return null;
-}
-async function resolveCollectionPath(root, logicalPath) {
-  const fs12 = await import("node:fs/promises");
-  const path16 = await import("node:path");
-  const segments = logicalPath.split("/").filter(Boolean);
-  let currentPath = root;
-  for (const segment of segments) {
-    try {
-      const entries = await fs12.readdir(currentPath, { withFileTypes: true });
-      const matchingDir = entries.find((entry) => {
-        if (!entry.isDirectory())
-          return false;
-        const logicalName = extractSlugFromFilename(entry.name);
-        return logicalName === segment;
-      });
-      if (matchingDir) {
-        currentPath = path16.join(currentPath, matchingDir.name);
-      } else {
-        return null;
-      }
-    } catch (err) {
-      if (isNotFoundError2(err))
-        return null;
-      throw err;
-    }
+  getContentBranchRoot(branchName, sourceRoot) {
+    return path.resolve(this.getContentBranchesRoot(sourceRoot), branchName);
   }
-  return currentPath;
-}
-function extractEntryTypeFromFilename(filename) {
-  if (filename.startsWith("."))
-    return null;
-  const parts = filename.split(".");
-  if (parts.length >= 4) {
-    const possibleId = parts[parts.length - 2];
-    if (isValidId(possibleId)) {
-      return parts[0];
-    }
+  getGitExcludePattern() {
+    return ".canopy-meta/";
   }
-  return null;
-}
-function extractSlugFromFilename(filename, entryTypeName) {
-  const parts = filename.split(".");
-  if (parts.length >= 3) {
-    const possibleId = parts[parts.length - 2];
-    if (isValidId(possibleId)) {
-      let slugParts = parts.slice(0, parts.length - 2);
-      if (entryTypeName && slugParts.length > 1 && slugParts[0] === entryTypeName) {
-        slugParts = slugParts.slice(1);
-      } else if (parts.length >= 4 && slugParts.length > 1) {
-        slugParts = slugParts.slice(1);
-      }
-      return slugParts.join(".");
-    }
+  getPermissionsFilePath(root) {
+    return path.join(root, this.getPermissionsFileName());
+  }
+  getGroupsFilePath(root) {
+    return path.join(root, this.getGroupsFileName());
+  }
+  getRemoteUrlConfig() {
+    return {
+      shouldAutoInitLocal: false,
+      defaultRemotePath: "",
+      envVarName: "CANOPYCMS_REMOTE_URL",
+      autoDetectRemotePath: path.join(this.getWorkspaceRoot(), "remote.git")
+    };
+  }
+  requiresExistingRepo() {
+    return false;
+  }
+  getSettingsBranchName(config) {
+    if (config.settingsBranch)
+      return config.settingsBranch;
+    const deploymentName = config.deploymentName ?? "prod";
+    return `canopycms-settings-${deploymentName}`;
   }
-  if (parts.length === 2) {
-    const possibleId = parts[parts.length - 1];
-    if (isValidId(possibleId)) {
-      return parts[0];
+  getSettingsRoot(sourceRoot) {
+    return path.join(this.getWorkspaceRoot(sourceRoot), "settings");
+  }
+  usesSeparateSettingsBranch() {
+    return true;
+  }
+  validateConfig(config) {
+    if (!config.gitBotAuthorName || !config.gitBotAuthorEmail) {
+      throw new Error("gitBotAuthorName and gitBotAuthorEmail are required in prod mode");
     }
   }
-  if (parts.length > 1) {
-    return parts.slice(0, -1).join(".");
+  shouldCreateSettingsPR(config) {
+    return config.autoCreateSettingsPR ?? true;
   }
-  return filename;
-}
-var EMPTY_LOGICAL_PATH, ContentIdIndex;
-var init_content_id_index = __esm({
-  "dist/content-id-index.js"() {
-    "use strict";
-    init_id();
-    init_error();
-    EMPTY_LOGICAL_PATH = "";
-    ContentIdIndex = class {
-      constructor(root) {
-        this.idToLocation = /* @__PURE__ */ new Map();
-        this.pathToId = /* @__PURE__ */ new Map();
-        this.byCollection = /* @__PURE__ */ new Map();
-        this.root = path6.resolve(root);
-      }
-      /**
-       * Build index by scanning filenames recursively.
-       * Throws if duplicate IDs found (collision detection).
-       */
-      async buildFromFilenames(startPath = "") {
-        await this.scanDirectory(startPath);
-      }
-      async scanDirectory(relativePath) {
-        const absoluteDir = path6.join(this.root, relativePath);
-        try {
-          const entries = await fs4.readdir(absoluteDir, { withFileTypes: true });
-          for (const entry of entries) {
-            if (entry.name.startsWith(".") || entry.name === "_ids_") {
-              continue;
-            }
-            const fullRelativePath = path6.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
-                type: entry.isDirectory() ? "collection" : "entry",
-                relativePath: fullRelativePath
-                // filesystem path with embedded IDs
-              };
-              if (!entry.isDirectory()) {
-                const slug = extractSlugFromFilename(entry.name);
-                const physicalCollection = path6.dirname(fullRelativePath);
-                const collectionPath = toLogicalCollectionPath(physicalCollection);
-                location.slug = slug;
-                location.collection = collectionPath;
-                if (!this.byCollection.has(collectionPath)) {
-                  this.byCollection.set(collectionPath, /* @__PURE__ */ new Set());
-                }
-                this.byCollection.get(collectionPath).add(id);
-              }
-              this.idToLocation.set(id, location);
-              this.pathToId.set(fullRelativePath, id);
-            }
-            if (entry.isDirectory()) {
-              await this.scanDirectory(fullRelativePath);
-            }
-          }
-        } catch (err) {
-          if (err.code !== "ENOENT") {
-            throw err;
-          }
-        }
-      }
-      /**
-       * Forward lookup: ID → location (O(1))
-       */
-      findById(id) {
-        return this.idToLocation.get(id) || null;
-      }
-      /**
-       * Reverse lookup: path → ID (O(1))
-       */
-      findByPath(relativePath) {
-        return this.pathToId.get(relativePath) || null;
-      }
-      /**
-       * Get all ID locations in the index.
-       * Useful for validation and checking references.
-       */
-      getAllLocations() {
-        return Array.from(this.idToLocation.values());
-      }
-      /**
-       * Get all entries in a collection by collection path.
-       *
-       * Performance: O(1) + O(m) where m is the number of entries in the collection.
-       *
-       * @param collectionPath - The collection path (e.g., "content/posts")
-       * @returns Array of IdLocation objects for entries in the collection
-       */
-      getEntriesInCollection(collectionPath) {
-        const idSet = this.byCollection.get(collectionPath);
-        if (!idSet) {
-          return [];
-        }
-        const locations = [];
-        for (const id of idSet) {
-          const location = this.idToLocation.get(id);
-          if (location) {
-            locations.push(location);
-          }
-        }
-        return locations;
-      }
-      /**
-       * Add a new entry or collection to the index.
-       * Note: This only updates the in-memory index. The file with embedded ID
-       * must already exist on disk (created by ContentStore).
-       */
-      add(location) {
-        const id = extractIdFromFilename(path6.basename(location.relativePath));
-        if (!id) {
-          throw new Error(`Cannot add location without ID in filename: ${location.relativePath}`);
-        }
-        if (this.idToLocation.has(id)) {
-          const existing = this.idToLocation.get(id);
-          throw new Error(`ID collision detected: ${id}
-  File 1: ${existing.relativePath}
-  File 2: ${location.relativePath}`);
-        }
-        const fullLocation = {
-          ...location,
-          id
-          // already ContentId from extractIdFromFilename
-        };
-        this.idToLocation.set(id, fullLocation);
-        this.pathToId.set(location.relativePath, id);
-        if (fullLocation.type === "entry" && fullLocation.collection) {
-          if (!this.byCollection.has(fullLocation.collection)) {
-            this.byCollection.set(fullLocation.collection, /* @__PURE__ */ new Set());
-          }
-          this.byCollection.get(fullLocation.collection).add(id);
-        }
-      }
-      /**
-       * Remove an entry or collection from the index by ID.
-       * Note: This only updates the in-memory index. The file must be deleted separately.
-       */
-      remove(id) {
-        const location = this.idToLocation.get(id);
-        if (!location)
-          return;
-        if (location.type === "entry" && location.collection) {
-          const idSet = this.byCollection.get(location.collection);
-          if (idSet) {
-            idSet.delete(id);
-            if (idSet.size === 0) {
-              this.byCollection.delete(location.collection);
-            }
-          }
-        }
-        this.idToLocation.delete(id);
-        this.pathToId.delete(location.relativePath);
-      }
-      /**
-       * Update the path for an existing ID (e.g., after file rename/move).
-       * This is used to keep the index in sync when files are renamed.
-       */
-      updatePath(id, newRelativePath) {
-        const location = this.idToLocation.get(id);
-        if (!location) {
-          throw new Error(`Cannot update path for unknown ID: ${id}`);
-        }
-        this.pathToId.delete(location.relativePath);
-        location.relativePath = newRelativePath;
-        if (location.type === "entry") {
-          const oldCollection = location.collection;
-          location.slug = extractSlugFromFilename(path6.basename(newRelativePath));
-          const physicalCollection = path6.dirname(newRelativePath);
-          location.collection = toLogicalCollectionPath(physicalCollection);
-          if (oldCollection !== location.collection) {
-            if (oldCollection) {
-              const oldSet = this.byCollection.get(oldCollection);
-              if (oldSet) {
-                oldSet.delete(id);
-                if (oldSet.size === 0) {
-                  this.byCollection.delete(oldCollection);
-                }
-              }
-            }
-            if (location.collection) {
-              if (!this.byCollection.has(location.collection)) {
-                this.byCollection.set(location.collection, /* @__PURE__ */ new Set());
-              }
-              this.byCollection.get(location.collection).add(id);
-            }
-          }
-        }
-        this.pathToId.set(newRelativePath, id);
-      }
-    };
-  }
-});
-
-// dist/utils/format.js
-var getFormatExtension;
-var init_format = __esm({
-  "dist/utils/format.js"() {
-    "use strict";
-    getFormatExtension = (format) => {
-      if (format === "md")
-        return ".md";
-      if (format === "mdx")
-        return ".mdx";
-      return ".json";
-    };
+};
+var DevStrategy = class extends DevClientSafeStrategy {
+  // Inherits client-safe methods from DevClientSafeStrategy
+  getWorkspaceRoot(sourceRoot) {
+    return path.resolve(sourceRoot ?? process.cwd(), ".canopy-dev");
   }
-});
-
-// dist/paths/normalize-server.js
-var init_normalize_server = __esm({
-  "dist/paths/normalize-server.js"() {
-    "use strict";
+  getContentRoot(sourceRoot) {
+    return path.resolve(sourceRoot ?? process.cwd(), "content");
   }
-});
-
-// dist/paths/resolve.js
-var init_resolve = __esm({
-  "dist/paths/resolve.js"() {
-    "use strict";
+  getContentBranchesRoot(sourceRoot) {
+    return path.join(this.getWorkspaceRoot(sourceRoot), "content-branches");
   }
-});
-
-// dist/paths/branch.js
-import path7 from "node:path";
-function sanitizeBranchName(branchName) {
-  const replaced = branchName.replace(/[^a-zA-Z0-9._-]/g, "-");
-  const squashed = replaced.replace(/-+/g, "-");
-  const trimmedDots = squashed.replace(/^\.+/, "").replace(/(?<!\.)\.+$/, "");
-  return trimmedDots || "branch";
-}
-function resolveBranchPath(options) {
-  if (options.branchName.includes("..")) {
-    throw new BranchPathError("Branch name cannot contain traversal segments");
-  }
-  const safeBranch = sanitizeBranchName(options.branchName);
-  const strategy = operatingStrategy(options.mode);
-  const baseRoot = resolveContentBranchesRoot(options.mode, options.basePathOverride);
-  const normalizedBase = path7.resolve(baseRoot);
-  const baseWithSep = normalizedBase.endsWith(path7.sep) ? normalizedBase : `${normalizedBase}${path7.sep}`;
-  const branchRoot = strategy.getContentBranchRoot(safeBranch, options.basePathOverride);
-  const withinBase = (target) => {
-    const resolved = path7.resolve(target);
-    return resolved === normalizedBase || resolved.startsWith(baseWithSep);
-  };
-  if (!withinBase(branchRoot)) {
-    throw new BranchPathError("Branch path resolves outside the base root");
+  getContentBranchRoot(branchName, sourceRoot) {
+    return path.resolve(this.getContentBranchesRoot(sourceRoot), branchName);
   }
-  return { branchRoot, baseRoot: normalizedBase, branchName: safeBranch };
-}
-var BranchPathError, resolveContentBranchesRoot;
-var init_branch = __esm({
-  "dist/paths/branch.js"() {
-    "use strict";
-    init_operating_mode();
-    BranchPathError = class extends Error {
-    };
-    resolveContentBranchesRoot = (mode, override) => {
-      return operatingStrategy(mode).getContentBranchesRoot(override);
-    };
+  getGitExcludePattern() {
+    return ".canopy-meta/";
   }
-});
-
-// dist/paths/index.js
-var init_paths = __esm({
-  "dist/paths/index.js"() {
-    "use strict";
-    init_normalize();
-    init_normalize_server();
-    init_validation2();
-    init_resolve();
-    init_branch();
-  }
-});
-
-// dist/content-store.js
-import fs5 from "node:fs/promises";
-import path8 from "node:path";
-import matter from "gray-matter";
-function getDefaultEntryType(entries) {
-  if (!entries || entries.length === 0)
-    return void 0;
-  return entries.find((e) => e.default) || entries[0];
-}
-function validateSlug(slug) {
-  if (slug.includes("/")) {
-    throw new ContentStoreError("Slugs cannot contain forward slashes. Use nested collections instead.");
+  getPermissionsFilePath(root) {
+    return path.join(root, this.getPermissionsFileName());
   }
-  if (slug.includes("\\")) {
-    throw new ContentStoreError("Slugs cannot contain backslashes. Use nested collections instead.");
+  getGroupsFilePath(root) {
+    return path.join(root, this.getGroupsFileName());
   }
-}
-var ContentStoreError, ContentStore;
-var init_content_store = __esm({
-  "dist/content-store.js"() {
-    "use strict";
-    init_atomic_write();
-    init_content_id_index();
-    init_id();
-    init_format();
-    init_paths();
-    ContentStoreError = class extends Error {
-    };
-    ContentStore = class {
-      constructor(root, flatSchema) {
-        this.indexLoaded = false;
-        this.root = path8.resolve(root);
-        this.schemaIndex = new Map(flatSchema.map((item) => [item.logicalPath, item]));
-        this._idIndex = new ContentIdIndex(this.root);
-      }
-      /**
-       * Get the ID index, ensuring it's loaded first.
-       * This getter automatically loads the index on first access.
-       */
-      async idIndex() {
-        if (!this.indexLoaded) {
-          await this._idIndex.buildFromFilenames("content");
-          this.indexLoaded = true;
-        }
-        return this._idIndex;
-      }
-      /**
-       * Get all schema items for iteration.
-       * Used internally by ReferenceResolver for path matching.
-       */
-      getSchemaItems() {
-        return this.schemaIndex.values();
-      }
-      assertSchemaItem(path16) {
-        const normalized = normalizeFilesystemPath(path16);
-        const item = this.schemaIndex.get(normalized);
-        if (!item) {
-          throw new ContentStoreError(`Unknown schema item: ${path16}`);
-        }
-        return item;
-      }
-      assertCollection(collectionPath) {
-        const item = this.assertSchemaItem(collectionPath);
-        if (item.type !== "collection") {
-          throw new ContentStoreError(`Path is not a collection: ${collectionPath}`);
-        }
-        return item;
-      }
-      /**
-       * Build absolute and relative paths with security validation.
-       * All entries use the unified filename pattern: {type}.{slug}.{id}.{ext}
-       *
-       * SECURITY BOUNDARY: This method prevents path traversal attacks by:
-       * 1. Validating that resolved paths stay within the content root
-       * 2. Checking slugs for malicious patterns (via validateSlug)
-       * 3. Using path.resolve to normalize paths before validation
-       *
-       * This validation is performed BEFORE file I/O in resolveDocumentPath(),
-       * ensuring permission checks happen before any file system access.
-       *
-       * @param options.existingId - Optional ID to use (for edits). If not provided, generates new ID.
-       * @param options.entryTypeName - For collections with multiple entry types, specify which one to use. Defaults to the default entry type.
-       */
-      async buildPaths(schemaItem, slug, options = {}) {
-        const rootWithSep = this.root.endsWith(path8.sep) ? this.root : `${this.root}${path8.sep}`;
-        if (schemaItem.type === "entry-type") {
-          const parentPath = schemaItem.parentPath || "";
-          const parentCollection = this.schemaIndex.get(parentPath);
-          if (!parentCollection || parentCollection.type !== "collection") {
-            throw new ContentStoreError(`Parent collection not found for entry type: ${schemaItem.name}`);
-          }
-          const effectiveSlug = slug || schemaItem.name;
-          return this.buildPaths(parentCollection, effectiveSlug, {
-            ...options,
-            entryTypeName: schemaItem.name
-          });
-        }
-        if (schemaItem.type === "collection") {
-          const safeSlug = slug.replace(/^\/+/, "");
-          if (!safeSlug) {
-            throw new ContentStoreError("Slug is required for collection entries");
-          }
-          validateSlug(safeSlug);
-          let entryTypeConfig;
-          if (options.entryTypeName) {
-            entryTypeConfig = schemaItem.entries?.find((e) => e.name === options.entryTypeName);
-            if (!entryTypeConfig) {
-              throw new ContentStoreError(`Entry type '${options.entryTypeName}' not found in collection`);
-            }
-          } else {
-            entryTypeConfig = getDefaultEntryType(schemaItem.entries);
-          }
-          const format = entryTypeConfig?.format || "json";
-          const ext = getFormatExtension(format);
-          const entryTypeName = entryTypeConfig?.name || "entry";
-          let collectionRoot = await resolveCollectionPath(this.root, schemaItem.logicalPath);
-          if (!collectionRoot) {
-            collectionRoot = path8.resolve(this.root, schemaItem.logicalPath);
-          }
-          if (!collectionRoot.startsWith(rootWithSep)) {
-            throw new ContentStoreError("Path traversal detected");
-          }
-          let id = options.existingId;
-          let existingFilename;
-          let existingEntryType;
-          if (!id) {
-            const entries = await fs5.readdir(collectionRoot, { withFileTypes: true }).catch(() => []);
-            const existingFile = entries.find((entry) => {
-              if (entry.isDirectory())
-                return false;
-              const fileEntryType = extractEntryTypeFromFilename(entry.name);
-              const existingSlug = extractSlugFromFilename(entry.name, fileEntryType || void 0);
-              return existingSlug === safeSlug;
-            });
-            if (existingFile) {
-              id = extractIdFromFilename(existingFile.name) || void 0;
-              existingFilename = existingFile.name;
-              existingEntryType = extractEntryTypeFromFilename(existingFile.name) || void 0;
-            }
-          }
-          const finalEntryTypeName = existingEntryType || entryTypeName;
-          let filename;
-          if (existingFilename && !id) {
-            filename = existingFilename;
-          } else {
-            if (!id) {
-              id = generateId();
-            }
-            filename = `${finalEntryTypeName}.${safeSlug}.${id}${ext}`;
-          }
-          const resolved = path8.resolve(collectionRoot, filename);
-          const collectionRootWithSep = collectionRoot.endsWith(path8.sep) ? collectionRoot : `${collectionRoot}${path8.sep}`;
-          if (!resolved.startsWith(collectionRootWithSep)) {
-            throw new ContentStoreError("Path traversal detected");
-          }
-          return {
-            absolutePath: resolved,
-            relativePath: path8.relative(this.root, resolved),
-            id
-          };
-        }
-        throw new ContentStoreError("Invalid schema item type");
-      }
-      /**
-       * Path resolution: resolves a URL path to a schema item
-       * - Try as collection + slug (last segment = slug)
-       */
-      resolvePath(pathSegments) {
-        if (pathSegments.length === 0) {
-          throw new ContentStoreError("Empty path");
-        }
-        const logicalPath = pathSegments.join("/");
-        const slug = pathSegments[pathSegments.length - 1];
-        const collectionPath = pathSegments.slice(0, -1).join("/");
-        const normalizedCollection = normalizeFilesystemPath(collectionPath);
-        const collection = this.schemaIndex.get(normalizedCollection);
-        if (collection?.type === "collection" && collection.entries) {
-          return {
-            schemaItem: collection,
-            slug
-          };
-        }
-        throw new ContentStoreError(`No schema item found for path: ${logicalPath}`);
-      }
-      async resolveDocumentPath(schemaPath, slug = "") {
-        const schemaItem = this.assertSchemaItem(schemaPath);
-        return await this.buildPaths(schemaItem, slug);
-      }
-      async read(collectionPath, slug = "", options = {}) {
-        const schemaItem = this.assertSchemaItem(collectionPath);
-        const { absolutePath, relativePath } = await this.buildPaths(schemaItem, slug);
-        const raw = await fs5.readFile(absolutePath, "utf8");
-        let doc;
-        let format;
-        let fields;
-        if (schemaItem.type === "entry-type") {
-          format = schemaItem.format;
-          fields = schemaItem.schema;
-        } else {
-          const defaultEntry = getDefaultEntryType(schemaItem.entries);
-          format = defaultEntry?.format || "json";
-          fields = defaultEntry?.schema || [];
-        }
-        if (format === "json") {
-          const data = JSON.parse(raw);
-          doc = {
-            collection: schemaItem.logicalPath,
-            collectionName: schemaItem.name,
-            format: "json",
-            data,
-            relativePath,
-            absolutePath
-          };
-        } else {
-          const parsed = matter(raw);
-          doc = {
-            collection: schemaItem.logicalPath,
-            collectionName: schemaItem.name,
-            format,
-            data: parsed.data ?? {},
-            body: parsed.content,
-            relativePath,
-            absolutePath
-          };
-        }
-        if (options.resolveReferences !== false) {
-          doc.data = await this.resolveReferencesInData(doc.data, fields);
-        }
-        return doc;
-      }
-      async write(collectionPath, slug = "", input, entryTypeName) {
-        const idIndex = await this.idIndex();
-        const schemaItem = this.assertSchemaItem(collectionPath);
-        let expectedFormat;
-        if (schemaItem.type === "entry-type") {
-          expectedFormat = schemaItem.format;
-        } else {
-          let entryTypeConfig;
-          if (entryTypeName) {
-            entryTypeConfig = schemaItem.entries?.find((e) => e.name === entryTypeName);
-            if (!entryTypeConfig) {
-              throw new ContentStoreError(`Entry type '${entryTypeName}' not found in collection`);
-            }
-          } else {
-            entryTypeConfig = getDefaultEntryType(schemaItem.entries);
-          }
-          expectedFormat = entryTypeConfig?.format || "json";
-        }
-        if (expectedFormat !== input.format) {
-          throw new ContentStoreError(`Format mismatch: expects ${expectedFormat}, got ${input.format}`);
-        }
-        const { absolutePath, relativePath, id } = await this.buildPaths(schemaItem, slug, {
-          entryTypeName
-        });
-        await fs5.mkdir(path8.dirname(absolutePath), { recursive: true });
-        if (input.format === "json") {
-          const json = JSON.stringify(input.data ?? {}, null, 2);
-          await atomicWriteFile(absolutePath, `${json}
-`);
-          if (id) {
-            const existing = idIndex.findById(id);
-            if (existing) {
-              if (existing.relativePath !== relativePath) {
-                idIndex.updatePath(existing.id, relativePath);
-              }
-            } else {
-              idIndex.add({
-                type: "entry",
-                relativePath,
-                collection: collectionPath,
-                slug: slug || void 0
-              });
-            }
-          }
-          return {
-            collection: schemaItem.logicalPath,
-            collectionName: schemaItem.name,
-            format: "json",
-            data: input.data ?? {},
-            relativePath,
-            absolutePath
-          };
-        }
-        const file = matter.stringify(input.body, input.data ?? {});
-        await atomicWriteFile(absolutePath, file);
-        if (id) {
-          const existing = idIndex.findById(id);
-          if (existing) {
-            if (existing.relativePath !== relativePath) {
-              idIndex.updatePath(existing.id, relativePath);
-            }
-          } else {
-            idIndex.add({
-              type: "entry",
-              relativePath,
-              collection: collectionPath,
-              slug: slug || void 0
-            });
-          }
-        }
-        return {
-          collection: schemaItem.logicalPath,
-          collectionName: schemaItem.name,
-          format: input.format,
-          data: input.data ?? {},
-          body: input.body,
-          relativePath,
-          absolutePath
-        };
-      }
-      /**
-       * Read an entry by its ID (UUID).
-       * Returns null if the ID doesn't exist or points to a collection.
-       */
-      async readById(id) {
-        const idIndex = await this.idIndex();
-        const location = idIndex.findById(id);
-        if (!location || location.type !== "entry")
-          return null;
-        return this.read(location.collection, location.slug);
-      }
-      /**
-       * Get the ID for an entry given its collection and slug.
-       * Returns null if no ID exists yet.
-       */
-      async getIdForEntry(collectionPath, slug) {
-        const idIndex = await this.idIndex();
-        const { relativePath } = await this.buildPaths(this.assertCollection(collectionPath), slug);
-        return idIndex.findByPath(relativePath);
-      }
-      /**
-       * Delete an entry and remove it from the index.
-       */
-      async delete(collectionPath, slug) {
-        const idIndex = await this.idIndex();
-        const collection = this.assertCollection(collectionPath);
-        const { absolutePath, relativePath } = await this.buildPaths(collection, slug);
-        const id = idIndex.findByPath(relativePath);
-        await fs5.unlink(absolutePath);
-        if (id) {
-          idIndex.remove(id);
-        }
-      }
-      /**
-       * Rename an entry by changing its slug (middle segment of filename).
-       * Entry filename pattern: {entryTypeName}.{slug}.{id}.{ext}
-       *
-       * @param collectionPath - Logical path to the collection
-       * @param currentSlug - Current slug of the entry
-       * @param newSlug - New slug (must be unique within collection)
-       * @returns Object with new logical path
-       * @throws ContentStoreError if entry doesn't exist, new slug conflicts, or validation fails
-       */
-      async renameEntry(collectionPath, currentSlug, newSlug) {
-        const idIndex = await this.idIndex();
-        const collection = this.assertCollection(collectionPath);
-        validateSlug(newSlug);
-        const safeNewSlug = newSlug.replace(/^\/+/, "");
-        if (!safeNewSlug) {
-          throw new ContentStoreError("New slug cannot be empty");
-        }
-        if (!/^[a-z0-9][a-z0-9-]*$/.test(safeNewSlug)) {
-          throw new ContentStoreError("Slug must start with a letter or number and contain only lowercase letters, numbers, and hyphens");
-        }
-        const { absolutePath: currentPath, relativePath: currentRelPath } = await this.buildPaths(collection, currentSlug);
-        try {
-          await fs5.access(currentPath);
-        } catch {
-          throw new ContentStoreError(`Entry not found: ${currentSlug}`);
-        }
-        if (currentSlug === safeNewSlug) {
-          return { newPath: `${collectionPath}/${currentSlug}` };
-        }
-        const currentFilename = path8.basename(currentPath);
-        const parts = currentFilename.split(".");
-        if (parts.length < 4) {
-          throw new ContentStoreError(`Invalid entry filename format: ${currentFilename}`);
-        }
-        const entryTypeName = parts[0];
-        const contentId = parts[parts.length - 2];
-        const ext = `.${parts[parts.length - 1]}`;
-        const newFilename = `${entryTypeName}.${safeNewSlug}.${contentId}${ext}`;
-        const parentDir = path8.dirname(currentPath);
-        const newPath = path8.join(parentDir, newFilename);
-        try {
-          const entries = await fs5.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}"`);
-            }
-          }
-        } catch (err) {
-          if (err instanceof ContentStoreError) {
-            throw err;
-          }
-        }
-        await fs5.rename(currentPath, newPath);
-        const newRelativePath = path8.relative(this.root, newPath);
-        const entryId = idIndex.findByPath(currentRelPath);
-        if (entryId) {
-          idIndex.updatePath(entryId, newRelativePath);
-        }
-        const newLogicalPath = `${collectionPath}/${safeNewSlug}`;
-        return { newPath: newLogicalPath };
-      }
-      /**
-       * List all entries in a collection.
-       * Returns array of entry metadata (relativePath, collection, slug).
-       * Returns empty array if the collection doesn't exist.
-       */
-      async listCollectionEntries(collectionPath) {
-        const idIndex = await this.idIndex();
-        const normalized = normalizeFilesystemPath(collectionPath);
-        let item = this.schemaIndex.get(normalized);
-        if (!item) {
-          for (const schemaItem of this.schemaIndex.values()) {
-            if (schemaItem.type === "collection") {
-              const lastSegment = schemaItem.logicalPath.split("/").pop();
-              if (lastSegment === collectionPath) {
-                item = schemaItem;
-                break;
-              }
-            }
-          }
-        }
-        if (!item || item.type !== "collection") {
-          return [];
-        }
-        const collection = item;
-        const baseEntries = idIndex.getEntriesInCollection(collection.logicalPath);
-        const entries = [];
-        for (const location of baseEntries) {
-          if (location.type === "entry" && location.slug) {
-            if (location.collection === collection.logicalPath || location.collection?.startsWith(collection.logicalPath + "/")) {
-              entries.push({
-                relativePath: location.relativePath,
-                collection: location.collection,
-                slug: location.slug
-              });
-            }
-          }
-        }
-        return entries;
-      }
-      /**
-       * Recursively resolve reference fields in data.
-       * This traverses objects, arrays, and blocks to find and resolve all reference fields.
-       */
-      async resolveReferencesInData(data, fields) {
-        const resolved = { ...data };
-        const idIndex = await this.idIndex();
-        for (const field of fields) {
-          const value = data[field.name];
-          if (field.type === "reference") {
-            if (typeof value === "string" && value) {
-              resolved[field.name] = await this.resolveSingleReference(value, idIndex);
-            } else if (field.list && Array.isArray(value)) {
-              resolved[field.name] = await Promise.all(value.map((id) => typeof id === "string" ? this.resolveSingleReference(id, idIndex) : null));
-            }
-          } else if (field.type === "object" && value) {
-            const objectField = field;
-            if (!objectField.fields)
-              continue;
-            if (objectField.list && Array.isArray(value)) {
-              resolved[field.name] = await Promise.all(value.map((item) => typeof item === "object" && item !== null ? this.resolveReferencesInData(item, objectField.fields) : item));
-            } else if (typeof value === "object") {
-              resolved[field.name] = await this.resolveReferencesInData(value, objectField.fields);
-            }
-          } else if (field.type === "block" && Array.isArray(value)) {
-            const blockField = field;
-            resolved[field.name] = await Promise.all(value.map(async (block) => {
-              const b = block;
-              if (!b || typeof b.value !== "object")
-                return block;
-              const template = blockField.templates.find((t) => t.name === b.template);
-              if (!template)
-                return block;
-              return {
-                ...b,
-                value: await this.resolveReferencesInData(b.value, template.fields)
-              };
-            }));
-          }
-        }
-        return resolved;
-      }
-      /**
-       * Resolve a single reference ID to full entry data.
-       * Returns null if the reference is invalid or missing.
-       * Includes id, slug, and collection fields for debugging.
-       */
-      async resolveSingleReference(id, idIndex) {
-        try {
-          const location = idIndex.findById(id);
-          if (!location || location.type !== "entry" || !location.collection || !location.slug) {
-            return null;
-          }
-          const doc = await this.read(location.collection, location.slug, {
-            resolveReferences: false
-          });
-          return {
-            id,
-            slug: location.slug,
-            collection: location.collection,
-            ...doc.data
-          };
-        } catch (error) {
-          console.error(`Failed to resolve reference ${id}:`, error);
-          return null;
-        }
-      }
-    };
-  }
-});
-
-// dist/schema/meta-loader.js
-import { promises as fs6 } from "fs";
-import { join as join2 } from "pathe";
-import { z as z6 } from "zod";
-import chokidar from "chokidar";
-function stripEmbeddedIdFromName(name) {
-  return extractSlugFromFilename(name);
-}
-async function scanForCollectionMeta(baseDir, relativePath = "") {
-  const collections = [];
-  try {
-    const entries = await fs6.readdir(baseDir, { withFileTypes: true });
-    for (const entry of entries) {
-      if (!entry.isDirectory())
-        continue;
-      const folderName = entry.name;
-      const logicalName = stripEmbeddedIdFromName(folderName);
-      const collectionContentId = extractIdFromFilename(folderName) ?? void 0;
-      const folderPath = relativePath ? `${relativePath}/${logicalName}` : logicalName;
-      const absolutePath = join2(baseDir, folderName);
-      const metaPath = join2(absolutePath, ".collection.json");
-      try {
-        await fs6.access(metaPath);
-        const content = await fs6.readFile(metaPath, "utf-8");
-        const parsed = JSON.parse(content);
-        const meta = collectionMetaSchema.parse(parsed);
-        collections.push({
-          ...meta,
-          path: folderPath,
-          // Path derived from folder name
-          contentId: collectionContentId
-        });
-        const nestedCollections = await scanForCollectionMeta(absolutePath, folderPath);
-        collections.push(...nestedCollections);
-      } catch (err) {
-        if (err.code !== "ENOENT") {
-          console.error(`Error loading ${metaPath}:`, err);
-          throw new Error(`Invalid .collection.json in ${folderPath}: ${err.message}`);
-        }
-        const nestedCollections = await scanForCollectionMeta(absolutePath, folderPath);
-        collections.push(...nestedCollections);
-      }
-    }
-    return collections;
-  } catch (err) {
-    if (err.code === "ENOENT") {
-      return [];
-    }
-    throw err;
-  }
-}
-async function loadCollectionMetaFiles(contentRoot) {
-  let root = null;
-  const rootMetaPath = join2(contentRoot, ".collection.json");
-  try {
-    await fs6.access(rootMetaPath);
-  } catch (err) {
-    if (err.code === "ENOENT") {
-    } else {
-      throw err;
-    }
-  }
-  try {
-    const content = await fs6.readFile(rootMetaPath, "utf-8");
-    const parsed = JSON.parse(content);
-    root = rootCollectionMetaSchema.parse(parsed);
-  } catch (err) {
-    const errno = err.code;
-    if (errno !== "ENOENT") {
-      throw new Error(`Invalid root .collection.json`);
-    }
-  }
-  const collections = await scanForCollectionMeta(contentRoot);
-  return { root, collections };
-}
-function resolveEntryTypes(entryTypes, entrySchemaRegistry, contextName) {
-  return entryTypes.map((entryType) => {
-    const resolvedSchema = entrySchemaRegistry[entryType.schema];
-    if (!resolvedSchema) {
-      throw new Error(`Schema reference "${entryType.schema}" in entry type "${entryType.name}" (${contextName}) not found in registry. Available schemas: ${Object.keys(entrySchemaRegistry).join(", ")}`);
-    }
+  getRemoteUrlConfig() {
     return {
-      name: entryType.name,
-      label: entryType.label,
-      format: entryType.format,
-      schema: resolvedSchema,
-      schemaRef: entryType.schema,
-      default: entryType.default,
-      maxItems: entryType.maxItems
+      shouldAutoInitLocal: true,
+      defaultRemotePath: ".canopy-dev/remote.git",
+      envVarName: "CANOPYCMS_REMOTE_URL"
     };
-  });
-}
-function resolveCollectionMeta(meta, entrySchemaRegistry, allCollections) {
-  const entries = meta.entries && meta.entries.length > 0 ? resolveEntryTypes(meta.entries, entrySchemaRegistry, `collection "${meta.name}"`) : void 0;
-  const nestedCollections = allCollections.filter((col) => {
-    return col.path.startsWith(`${meta.path}/`) && col.path.split("/").length === meta.path.split("/").length + 1;
-  });
-  const collections = nestedCollections.length > 0 ? nestedCollections.map((nestedMeta) => resolveCollectionMeta(nestedMeta, entrySchemaRegistry, allCollections)) : void 0;
-  return {
-    name: meta.name,
-    label: meta.label,
-    path: meta.path,
-    contentId: meta.contentId,
-    ...entries && { entries },
-    ...meta.order && { order: meta.order },
-    ...collections && { collections }
-  };
-}
-function resolveCollectionReferences(metaFiles, entrySchemaRegistry) {
-  const result = {};
-  if (metaFiles.root?.label) {
-    result.label = metaFiles.root.label;
-  }
-  if (metaFiles.root?.entries && metaFiles.root.entries.length > 0) {
-    result.entries = resolveEntryTypes(metaFiles.root.entries, entrySchemaRegistry, "root collection");
-  }
-  if (metaFiles.root?.order) {
-    result.order = metaFiles.root.order;
   }
-  const topLevelCollections = metaFiles.collections.filter((meta) => !meta.path.includes("/"));
-  if (topLevelCollections.length > 0) {
-    result.collections = topLevelCollections.map((meta) => resolveCollectionMeta(meta, entrySchemaRegistry, metaFiles.collections));
-  }
-  return result;
-}
-var entryTypeMetaSchema, collectionMetaSchema, rootCollectionMetaSchema;
-var init_meta_loader = __esm({
-  "dist/schema/meta-loader.js"() {
-    "use strict";
-    init_content_id_index();
-    entryTypeMetaSchema = z6.object({
-      name: z6.string().min(1),
-      format: z6.enum(["md", "mdx", "json"]),
-      schema: z6.string().min(1),
-      // Entry schema registry key (validated at resolution time)
-      label: z6.string().optional(),
-      default: z6.boolean().optional(),
-      maxItems: z6.number().int().positive().optional()
-    });
-    collectionMetaSchema = z6.object({
-      name: z6.string().min(1),
-      label: z6.string().optional(),
-      entries: z6.array(entryTypeMetaSchema).optional(),
-      order: z6.array(z6.string())
-      // Embedded IDs for ordering items (required)
-    }).refine((data) => data.entries && data.entries.length > 0, {
-      message: "Collection must have at least one entry type"
-    });
-    rootCollectionMetaSchema = z6.object({
-      label: z6.string().optional(),
-      entries: z6.array(entryTypeMetaSchema).optional(),
-      order: z6.array(z6.string()).optional()
-      // Embedded IDs for ordering items
-    });
-  }
-});
-
-// dist/schema/resolver.js
-async function resolveSchema(contentRoot, entrySchemaRegistry) {
-  const metaFiles = await loadCollectionMetaFiles(contentRoot);
-  const sources = [];
-  if (metaFiles.root) {
-    sources.push({
-      path: ".collection.json",
-      type: "root",
-      collections: []
-    });
-  }
-  for (const collection of metaFiles.collections) {
-    sources.push({
-      path: `${collection.path}/.collection.json`,
-      type: "collection",
-      collections: [collection.name]
-    });
-  }
-  const schema = resolveCollectionReferences(metaFiles, entrySchemaRegistry);
-  return { schema, sources };
-}
-function isValidSchema(schema) {
-  const hasEntries = !!(schema.entries && schema.entries.length > 0);
-  const hasCollections = !!(schema.collections && schema.collections.length > 0);
-  return hasEntries || hasCollections;
-}
-var init_resolver = __esm({
-  "dist/schema/resolver.js"() {
-    "use strict";
-    init_meta_loader();
-  }
-});
-
-// dist/branch-schema-cache.js
-import fs7 from "node:fs/promises";
-import path9 from "node:path";
-var SCHEMA_CACHE_VERSION, BranchSchemaCache;
-var init_branch_schema_cache = __esm({
-  "dist/branch-schema-cache.js"() {
-    "use strict";
-    init_resolver();
-    init_flatten();
-    SCHEMA_CACHE_VERSION = 2;
-    BranchSchemaCache = class {
-      constructor(mode) {
-        this.mode = mode;
-      }
-      /**
-       * Get schema for a branch (loads from cache or resolves fresh).
-       *
-       * @param branchRoot - Root directory of the branch (e.g., .canopy-prod-sim/content-branches/main)
-       * @param entrySchemaRegistry - Map of schema names to field definitions
-       * @param contentRootName - Name of content directory (e.g., "content") from config
-       * @returns Resolved schema tree and flattened schema
-       */
-      async getSchema(branchRoot, entrySchemaRegistry, contentRootName = "content") {
-        if (this.mode === "dev") {
-          if (!this.devModeCache) {
-            const contentRoot = path9.join(branchRoot, contentRootName);
-            const result = await resolveSchema(contentRoot, entrySchemaRegistry);
-            if (!isValidSchema(result.schema)) {
-              throw new Error(`No schema found in ${contentRoot}. Create .collection.json files with references to field schemas defined in your entry schema registry.`);
-            }
-            const flatSchema = flattenSchema(result.schema, contentRootName);
-            this.devModeCache = {
-              schema: result.schema,
-              flatSchema
-            };
-          }
-          return this.devModeCache;
-        }
-        return this.loadFromCacheOrResolve(branchRoot, entrySchemaRegistry, contentRootName);
-      }
-      /**
-       * Load schema from cache or resolve fresh if cache is missing or stale.
-       */
-      async loadFromCacheOrResolve(branchRoot, entrySchemaRegistry, contentRootName) {
-        const contentRoot = path9.join(branchRoot, contentRootName);
-        const cacheDir = path9.join(branchRoot, ".canopy-meta");
-        const cachePath = path9.join(cacheDir, "schema-cache.json");
-        const stalePath = path9.join(cacheDir, "schema-cache.stale");
-        let cacheData = null;
-        try {
-          const staleExists = await fs7.access(stalePath).then(() => true).catch(() => false);
-          if (!staleExists) {
-            const cacheContent = await fs7.readFile(cachePath, "utf-8");
-            cacheData = JSON.parse(cacheContent);
-          }
-        } catch {
-          cacheData = null;
-        }
-        if (cacheData && cacheData.version === SCHEMA_CACHE_VERSION) {
-          return { schema: cacheData.schema, flatSchema: cacheData.flatSchema };
-        }
-        const result = await resolveSchema(contentRoot, entrySchemaRegistry);
-        if (!isValidSchema(result.schema)) {
-          throw new Error(`No schema found in ${contentRoot}. Create .collection.json files with references to field schemas defined in your entry schema registry.`);
-        }
-        const flatSchema = flattenSchema(result.schema, contentRootName);
-        await fs7.mkdir(cacheDir, { recursive: true });
-        const newCache = {
-          version: SCHEMA_CACHE_VERSION,
-          schema: result.schema,
-          flatSchema,
-          cachedAt: (/* @__PURE__ */ new Date()).toISOString()
-        };
-        const tmpPath = path9.join(cacheDir, `schema-cache.tmp.${Date.now()}.${Math.random()}.json`);
-        await fs7.writeFile(tmpPath, JSON.stringify(newCache, null, 2), "utf-8");
-        await fs7.rename(tmpPath, cachePath);
-        try {
-          await fs7.unlink(stalePath);
-        } catch {
-        }
-        return { schema: result.schema, flatSchema };
-      }
-      /**
-       * Invalidate cache for a branch (creates .stale marker).
-       *
-       * @param branchRoot - Root directory of the branch
-       */
-      async invalidate(branchRoot) {
-        if (this.mode === "dev") {
-          this.devModeCache = void 0;
-          return;
-        }
-        const cacheDir = path9.join(branchRoot, ".canopy-meta");
-        const stalePath = path9.join(cacheDir, "schema-cache.stale");
-        await fs7.mkdir(cacheDir, { recursive: true });
-        await fs7.writeFile(stalePath, "", "utf-8");
-      }
-      /**
-       * Clear all caches (for testing).
-       * In dev mode, clears in-memory cache.
-       * In prod/prod-sim modes, this would need to traverse all branch directories.
-       */
-      async clearAll() {
-        if (this.mode === "dev") {
-          this.devModeCache = void 0;
-        }
-      }
-    };
-  }
-});
-
-// dist/ai/json-to-markdown.js
-function entryToMarkdown(entry, config) {
-  const parts = [];
-  parts.push("---");
-  if (entry.data.title) {
-    parts.push(`title: ${yamlValue(String(entry.data.title))}`);
-  }
-  parts.push(`slug: ${yamlValue(entry.slug)}`);
-  parts.push(`collection: ${yamlValue(entry.collection)}`);
-  parts.push(`type: ${yamlValue(entry.entryType)}`);
-  parts.push("---");
-  parts.push("");
-  const skipFields = /* @__PURE__ */ new Set();
-  if (entry.data.title)
-    skipFields.add("title");
-  if (entry.format === "md" || entry.format === "mdx") {
-    parts.push(...renderMarkdownEntry(entry, config, skipFields));
-  } else {
-    parts.push(...renderJsonEntry(entry, config, skipFields));
-  }
-  return parts.join("\n");
-}
-function renderMarkdownEntry(entry, config, skipFields) {
-  const parts = [];
-  const bodyFieldTypes = /* @__PURE__ */ new Set(["rich-text", "markdown", "mdx"]);
-  const metadataFields = entry.fields.filter((f) => !bodyFieldTypes.has(f.type) && !skipFields.has(f.name));
-  for (const field of metadataFields) {
-    const value = entry.data[field.name];
-    if (value === void 0 || value === null)
-      continue;
-    const transformed = applyFieldTransform(entry, field, value, config);
-    if (transformed !== void 0) {
-      parts.push(transformed);
-      parts.push("");
-      continue;
-    }
-    const label = field.label || field.name;
-    parts.push(`**${label}:** ${formatInlineValue(field, value)}`);
-  }
-  if (parts.length > 0) {
-    parts.push("");
-  }
-  if (entry.body) {
-    parts.push(entry.body.trim());
-    parts.push("");
-  }
-  return parts;
-}
-function renderJsonEntry(entry, config, skipFields) {
-  const parts = [];
-  for (const field of entry.fields) {
-    if (skipFields.has(field.name))
-      continue;
-    const value = entry.data[field.name];
-    if (value === void 0 || value === null)
-      continue;
-    const rendered = renderField(field, value, 2, entry, config);
-    if (rendered) {
-      parts.push(rendered);
-      parts.push("");
-    }
-  }
-  return parts;
-}
-function renderField(field, value, depth, entry, config) {
-  const transformed = applyFieldTransform(entry, field, value, config);
-  if (transformed !== void 0) {
-    return transformed;
-  }
-  const label = field.label || field.name;
-  const heading = "#".repeat(Math.min(depth, 6));
-  const descriptionLine = "description" in field && field.description ? `
-
-*${field.description}*` : "";
-  if (field.list && Array.isArray(value)) {
-    return renderListField(field, value, depth, label, heading, descriptionLine, entry, config);
-  }
-  switch (field.type) {
-    case "string":
-    case "number":
-    case "datetime":
-      return `${heading} ${label}${descriptionLine}
-
-${String(value)}`;
-    case "boolean":
-      return `${heading} ${label}${descriptionLine}
-
-${value ? "Yes" : "No"}`;
-    case "rich-text":
-    case "markdown":
-    case "mdx":
-      return `${heading} ${label}${descriptionLine}
-
-${String(value)}`;
-    case "image":
-      return `${heading} ${label}${descriptionLine}
-
-![${label}](${String(value)})`;
-    case "code":
-      return `${heading} ${label}${descriptionLine}
-
-\`\`\`
-${String(value)}
-\`\`\``;
-    case "select":
-      return renderSelectField(field, value, heading, label, descriptionLine);
-    case "reference":
-      return renderReferenceField(value, heading, label, descriptionLine);
-    case "object":
-      return renderObjectField(field, value, depth, heading, label, descriptionLine, entry, config);
-    case "block":
-      return renderBlockField(field, value, depth, heading, label, descriptionLine, entry, config);
-    default:
-      return `${heading} ${label}${descriptionLine}
-
-${String(value)}`;
-  }
-}
-function renderListField(field, values, depth, label, heading, descriptionLine, entry, config) {
-  if (values.length === 0)
-    return "";
-  const isComplex = field.type === "object" || field.type === "block";
-  if (isComplex) {
-    const items2 = values.map((item, i) => {
-      const itemLabel = `${label} ${i + 1}`;
-      const itemHeading = "#".repeat(Math.min(depth + 1, 6));
-      if (field.type === "object" && typeof item === "object" && item !== null) {
-        const objectField = field;
-        const subFields = objectField.fields.map((f) => {
-          const v = item[f.name];
-          if (v === void 0 || v === null)
-            return "";
-          return renderField(f, v, depth + 2, entry, config);
-        }).filter(Boolean);
-        return `${itemHeading} ${itemLabel}
-
-${subFields.join("\n\n")}`;
-      }
-      return `${itemHeading} ${itemLabel}
-
-${String(item)}`;
-    }).filter(Boolean);
-    return `${heading} ${label}${descriptionLine}
-
-${items2.join("\n\n")}`;
-  }
-  const items = values.map((v) => `- ${formatInlineValue(field, v)}`).join("\n");
-  return `${heading} ${label}${descriptionLine}
-
-${items}`;
-}
-function renderSelectField(field, value, heading, label, descriptionLine) {
-  if (Array.isArray(value)) {
-    return `${heading} ${label}${descriptionLine}
-
-${value.map((v) => resolveSelectLabel(field, v)).join(", ")}`;
-  }
-  return `${heading} ${label}${descriptionLine}
-
-${resolveSelectLabel(field, value)}`;
-}
-function resolveSelectLabel(field, value) {
-  const strValue = String(value);
-  for (const opt of field.options) {
-    if (typeof opt === "string") {
-      if (opt === strValue)
-        return opt;
-    } else {
-      if (opt.value === strValue)
-        return opt.label;
-    }
-  }
-  return strValue;
-}
-function renderReferenceField(value, heading, label, descriptionLine) {
-  if (Array.isArray(value)) {
-    const items = value.map((v) => `- ${formatReference(v)}`).join("\n");
-    return `${heading} ${label}${descriptionLine}
-
-${items}`;
-  }
-  return `${heading} ${label}${descriptionLine}
-
-${formatReference(value)}`;
-}
-function formatReference(value) {
-  if (typeof value === "object" && value !== null) {
-    const ref = value;
-    const display = ref.title || ref.name || ref.slug || ref.id;
-    if (display)
-      return String(display);
-  }
-  return String(value);
-}
-function renderObjectField(field, value, depth, heading, label, descriptionLine, entry, config) {
-  if (typeof value !== "object" || value === null) {
-    return `${heading} ${label}${descriptionLine}
-
-${String(value)}`;
-  }
-  const obj = value;
-  const subFields = field.fields.map((f) => {
-    const v = obj[f.name];
-    if (v === void 0 || v === null)
-      return "";
-    return renderField(f, v, depth + 1, entry, config);
-  }).filter(Boolean);
-  if (subFields.length === 0)
-    return "";
-  return `${heading} ${label}${descriptionLine}
-
-${subFields.join("\n\n")}`;
-}
-function renderBlockField(field, value, depth, heading, label, descriptionLine, entry, config) {
-  if (!Array.isArray(value))
-    return "";
-  const items = value.map((item) => {
-    if (typeof item !== "object" || item === null)
-      return "";
-    const blockItem = item;
-    const templateName = blockItem._type || blockItem.template;
-    if (!templateName)
-      return "";
-    const template = field.templates.find((t) => t.name === templateName);
-    if (!template)
-      return "";
-    const blockHeading = "#".repeat(Math.min(depth + 1, 6));
-    const blockLabel = template.label || template.name;
-    const blockFields = template.fields.map((f) => {
-      const v = blockItem[f.name] ?? blockItem.value?.[f.name];
-      if (v === void 0 || v === null)
-        return "";
-      return renderField(f, v, depth + 2, entry, config);
-    }).filter(Boolean);
-    if (blockFields.length === 0)
-      return "";
-    return `${blockHeading} ${blockLabel}
-
-${blockFields.join("\n\n")}`;
-  }).filter(Boolean);
-  if (items.length === 0)
-    return "";
-  return `${heading} ${label}${descriptionLine}
-
-${items.join("\n\n")}`;
-}
-function applyFieldTransform(entry, field, value, config) {
-  if (!config?.fieldTransforms)
-    return void 0;
-  const typeTransforms = config.fieldTransforms[entry.entryType];
-  if (!typeTransforms)
-    return void 0;
-  const fn = typeTransforms[field.name];
-  if (!fn)
-    return void 0;
-  return fn(value, field);
-}
-function formatInlineValue(field, value) {
-  if (field.type === "boolean")
-    return value ? "Yes" : "No";
-  if (field.type === "reference")
-    return formatReference(value);
-  return String(value);
-}
-function yamlValue(value) {
-  if (/[:#{}[\],&*?|>!%@`]/.test(value) || value.includes("\n")) {
-    return `"${value.replace(/"/g, '\\"')}"`;
-  }
-  return value;
-}
-var init_json_to_markdown = __esm({
-  "dist/ai/json-to-markdown.js"() {
-    "use strict";
-  }
-});
-
-// dist/ai/generate.js
-import path10 from "node:path";
-import { minimatch } from "minimatch";
-async function generateAIContent(options) {
-  const { store, flatSchema, contentRoot, config } = options;
-  const files = /* @__PURE__ */ new Map();
-  const collections = flatSchema.filter((item) => item.type === "collection");
-  const allEntries = [];
-  const manifestCollections = [];
-  const rootEntries = [];
-  for (const collection of collections) {
-    if (collection.logicalPath === contentRoot)
-      continue;
-    if (isCollectionExcluded(collection.logicalPath, contentRoot, config))
-      continue;
-    if (collection.parentPath && collection.parentPath !== contentRoot)
-      continue;
-    const collectionResult = await processCollection(store, collection, flatSchema, contentRoot, config);
-    allEntries.push(...collectionResult.entries);
-    for (const [filePath, content] of collectionResult.files) {
-      files.set(filePath, content);
-    }
-    manifestCollections.push(collectionResult.manifestCollection);
-  }
-  const rootCollection = collections.find((c) => c.logicalPath === contentRoot);
-  if (rootCollection?.entries) {
-    const rootResult = await processRootEntries(store, rootCollection, contentRoot, config);
-    allEntries.push(...rootResult.entries);
-    for (const [filePath, content] of rootResult.files) {
-      files.set(filePath, content);
-    }
-    rootEntries.push(...rootResult.manifestEntries);
-  }
-  const manifestBundles = [];
-  if (config?.bundles) {
-    for (const bundle of config.bundles) {
-      if (/[/\\]|\.\./.test(bundle.name)) {
-        throw new Error(`Invalid bundle name "${bundle.name}": must not contain slashes or ".."`);
-      }
-      const matchingEntries = allEntries.filter((entry) => matchesBundleFilter(entry, bundle.filter, contentRoot));
-      if (matchingEntries.length > 0) {
-        const bundleContent = matchingEntries.map((e) => entryToMarkdown(e, config)).join("\n---\n\n");
-        const bundlePath = `bundles/${bundle.name}.md`;
-        files.set(bundlePath, bundleContent);
-        manifestBundles.push({
-          name: bundle.name,
-          description: bundle.description,
-          file: bundlePath,
-          entryCount: matchingEntries.length
-        });
-      }
-    }
-  }
-  const manifest = {
-    generated: (/* @__PURE__ */ new Date()).toISOString(),
-    entries: rootEntries,
-    collections: manifestCollections,
-    bundles: manifestBundles
-  };
-  files.set("manifest.json", JSON.stringify(manifest, null, 2));
-  return { manifest, files };
-}
-async function processCollection(store, collection, flatSchema, contentRoot, config) {
-  const files = /* @__PURE__ */ new Map();
-  const entries = [];
-  const cleanPath = stripContentRoot(collection.logicalPath, contentRoot);
-  const manifestEntries = [];
-  const listed = await store.listCollectionEntries(collection.logicalPath);
-  const directEntries = listed.filter((e) => e.collection === collection.logicalPath);
-  for (const listEntry of directEntries) {
-    const entryTypeName = extractEntryTypeFromFilename(path10.basename(listEntry.relativePath));
-    if (!entryTypeName)
-      continue;
-    if (config?.exclude?.entryTypes?.includes(entryTypeName))
-      continue;
-    const entryTypeConfig = findEntryType(collection, entryTypeName);
-    if (!entryTypeConfig)
-      continue;
-    try {
-      const doc = await store.read(listEntry.collection, listEntry.slug, {
-        resolveReferences: false
-      });
-      const aiEntry = docToAIEntry(doc, listEntry.slug, entryTypeName, entryTypeConfig, cleanPath);
-      if (config?.exclude?.where?.(aiEntry))
-        continue;
-      entries.push(aiEntry);
-      const entryFilePath = `${cleanPath}/${listEntry.slug}.md`;
-      const entryMarkdown = entryToMarkdown(aiEntry, config);
-      files.set(entryFilePath, entryMarkdown);
-      manifestEntries.push({
-        slug: listEntry.slug,
-        title: aiEntry.data.title ? String(aiEntry.data.title) : void 0,
-        file: entryFilePath
-      });
-    } catch (err) {
-      console.warn(`AI content: skipping entry "${listEntry.slug}" in ${collection.logicalPath}:`, getErrorMessage(err));
-      continue;
-    }
-  }
-  const subcollections = flatSchema.filter((item) => item.type === "collection" && item.parentPath === collection.logicalPath);
-  const manifestSubcollections = [];
-  for (const sub of subcollections) {
-    if (isCollectionExcluded(sub.logicalPath, contentRoot, config))
-      continue;
-    const subResult = await processCollection(store, sub, flatSchema, contentRoot, config);
-    entries.push(...subResult.entries);
-    for (const [filePath, content] of subResult.files) {
-      files.set(filePath, content);
-    }
-    manifestSubcollections.push(subResult.manifestCollection);
-  }
-  if (entries.length > 0) {
-    const allContent = entries.map((e) => entryToMarkdown(e, config)).join("\n---\n\n");
-    const allPath = `${cleanPath}/all.md`;
-    files.set(allPath, allContent);
-  }
-  const manifestCollection = {
-    name: collection.name,
-    label: collection.label,
-    description: collection.description,
-    path: cleanPath,
-    allFile: entries.length > 0 ? `${cleanPath}/all.md` : void 0,
-    entryCount: entries.length,
-    entries: manifestEntries,
-    subcollections: manifestSubcollections.length > 0 ? manifestSubcollections : void 0
-  };
-  return { entries, files, manifestCollection };
-}
-async function processRootEntries(store, rootCollection, contentRoot, config) {
-  const files = /* @__PURE__ */ new Map();
-  const entries = [];
-  const manifestEntries = [];
-  const listed = await store.listCollectionEntries(rootCollection.logicalPath);
-  const directEntries = listed.filter((e) => e.collection === rootCollection.logicalPath);
-  for (const listEntry of directEntries) {
-    const entryTypeName = extractEntryTypeFromFilename(path10.basename(listEntry.relativePath));
-    if (!entryTypeName)
-      continue;
-    if (config?.exclude?.entryTypes?.includes(entryTypeName))
-      continue;
-    const entryTypeConfig = findEntryType(rootCollection, entryTypeName);
-    if (!entryTypeConfig)
-      continue;
-    try {
-      const doc = await store.read(listEntry.collection, listEntry.slug, {
-        resolveReferences: false
-      });
-      const aiEntry = docToAIEntry(doc, listEntry.slug, entryTypeName, entryTypeConfig, "");
-      if (config?.exclude?.where?.(aiEntry))
-        continue;
-      entries.push(aiEntry);
-      const entryFilePath = `${listEntry.slug}.md`;
-      const entryMarkdown = entryToMarkdown(aiEntry, config);
-      files.set(entryFilePath, entryMarkdown);
-      manifestEntries.push({
-        slug: listEntry.slug,
-        title: aiEntry.data.title ? String(aiEntry.data.title) : void 0,
-        file: entryFilePath
-      });
-    } catch (err) {
-      console.warn(`AI content: skipping root entry "${listEntry.slug}":`, getErrorMessage(err));
-      continue;
-    }
-  }
-  return { entries, files, manifestEntries };
-}
-function stripContentRoot(logicalPath, contentRoot) {
-  if (logicalPath.startsWith(contentRoot + "/")) {
-    return logicalPath.slice(contentRoot.length + 1);
-  }
-  return logicalPath;
-}
-function isCollectionExcluded(logicalPath, contentRoot, config) {
-  if (!config?.exclude?.collections)
+  requiresExistingRepo() {
     return false;
-  const cleanPath = stripContentRoot(logicalPath, contentRoot);
-  return config.exclude.collections.some((pattern) => (
-    // Match against clean path or full logical path
-    minimatch(cleanPath, pattern) || minimatch(logicalPath, pattern)
-  ));
-}
-function findEntryType(collection, entryTypeName) {
-  return collection.entries?.find((e) => e.name === entryTypeName);
-}
-function docToAIEntry(doc, slug, entryTypeName, entryTypeConfig, cleanCollectionPath) {
-  return {
-    slug,
-    collection: cleanCollectionPath,
-    collectionName: doc.collectionName,
-    entryType: entryTypeName,
-    format: doc.format,
-    data: doc.data,
-    body: doc.format !== "json" ? doc.body : void 0,
-    fields: entryTypeConfig.schema
-  };
-}
-function matchesBundleFilter(entry, filter, contentRoot) {
-  if (filter.collections) {
-    const matches = filter.collections.some((pattern) => {
-      const cleanPattern = stripContentRoot(pattern, contentRoot);
-      return entry.collection === cleanPattern || entry.collection === pattern || entry.collection.startsWith(cleanPattern + "/");
-    });
-    if (!matches)
-      return false;
   }
-  if (filter.entryTypes) {
-    if (!filter.entryTypes.includes(entry.entryType))
-      return false;
+  getSettingsBranchName(config) {
+    if (config.settingsBranch)
+      return config.settingsBranch;
+    const deploymentName = config.deploymentName ?? "local";
+    return `canopycms-settings-${deploymentName}`;
   }
-  if (filter.paths) {
-    const entryPath = entry.collection ? `${entry.collection}/${entry.slug}` : entry.slug;
-    const matches = filter.paths.some((pattern) => minimatch(entryPath, pattern));
-    if (!matches)
-      return false;
+  getSettingsRoot(sourceRoot) {
+    return path.join(this.getWorkspaceRoot(sourceRoot), "settings");
   }
-  if (filter.where) {
-    if (!filter.where(entry))
-      return false;
+  usesSeparateSettingsBranch() {
+    return true;
   }
-  return true;
-}
-var init_generate = __esm({
-  "dist/ai/generate.js"() {
-    "use strict";
-    init_content_id_index();
-    init_error();
-    init_json_to_markdown();
+  validateConfig(_config) {
   }
-});
-
-// dist/branch-registry.js
-import fs8 from "node:fs/promises";
-import path11 from "node:path";
-var REGISTRY_FILE, REGISTRY_STALE_FILE, REGISTRY_TEMP_FILE, REGISTRY_VERSION, BranchRegistry;
-var init_branch_registry = __esm({
-  "dist/branch-registry.js"() {
-    "use strict";
-    init_branch_metadata();
-    init_error();
-    REGISTRY_FILE = "branches.json";
-    REGISTRY_STALE_FILE = "branches.stale.json";
-    REGISTRY_TEMP_FILE = "branches.tmp.json";
-    REGISTRY_VERSION = 1;
-    BranchRegistry = class {
-      constructor(root) {
-        this.root = path11.resolve(root);
-        this.registryPath = path11.join(this.root, REGISTRY_FILE);
-        this.stalePath = path11.join(this.root, REGISTRY_STALE_FILE);
-        this.tempPath = path11.join(this.root, REGISTRY_TEMP_FILE);
-      }
-      /**
-       * Returns all branches. Uses cache if fresh, regenerates if stale.
-       */
-      async list() {
-        try {
-          const raw = await fs8.readFile(this.registryPath, "utf8");
-          const parsed = JSON.parse(raw);
-          if (!parsed.version || !Array.isArray(parsed.branches)) {
-            return await this.regenerate();
-          }
-          return parsed.branches;
-        } catch (err) {
-          if (isNotFoundError2(err)) {
-            return await this.regenerate();
-          }
-          throw err;
-        }
-      }
-      /**
-       * Returns a single branch by name. Uses cache if available.
-       */
-      async get(name) {
-        const branches = await this.list();
-        return branches.find((b) => b.branch.name === name);
-      }
-      /**
-       * Marks the cache as stale. Next list() call will regenerate.
-       * Uses atomic rename for safety.
-       */
-      async invalidate() {
-        try {
-          await fs8.rename(this.registryPath, this.stalePath);
-        } catch (err) {
-          if (!isNotFoundError2(err)) {
-            throw err;
-          }
-        }
-      }
-      /**
-       * Scans branch directories and rebuilds the cache.
-       * Concurrent calls are safe - all produce identical content.
-       */
-      async regenerate() {
-        const branches = await this.scanBranchDirectories();
-        const uniqueTempPath = `${this.tempPath}.${Date.now()}.${Math.random().toString(36).slice(2)}`;
-        await fs8.mkdir(this.root, { recursive: true });
-        const snapshot = {
-          version: REGISTRY_VERSION,
-          branches
-        };
-        await fs8.writeFile(uniqueTempPath, JSON.stringify(snapshot, null, 2) + "\n", "utf8");
-        try {
-          await fs8.rename(uniqueTempPath, this.registryPath);
-        } catch (err) {
-          await fs8.unlink(uniqueTempPath).catch(() => {
-          });
-          throw err;
-        }
-        await fs8.unlink(this.stalePath).catch(() => {
-        });
-        return branches;
-      }
-      /**
-       * Scans the root directory for branch subdirectories with valid branch.json files.
-       */
-      async scanBranchDirectories() {
-        const branches = [];
-        try {
-          const entries = await fs8.readdir(this.root, { withFileTypes: true });
-          for (const entry of entries) {
-            if (!entry.isDirectory() || entry.name.startsWith(".")) {
-              continue;
-            }
-            const branchRoot = path11.join(this.root, entry.name);
-            const meta = await BranchMetadataFileManager.loadOnly(branchRoot);
-            if (meta) {
-              branches.push({
-                branch: meta.branch,
-                branchRoot,
-                baseRoot: this.root
-              });
-            }
-          }
-        } catch (err) {
-          if (isNotFoundError2(err)) {
-            return [];
-          }
-          throw err;
-        }
-        return branches;
-      }
-    };
+  shouldCreateSettingsPR(_config) {
+    return false;
   }
-});
-
-// dist/branch-metadata.js
-import { randomUUID } from "node:crypto";
-import fs9 from "node:fs/promises";
-import path12 from "node:path";
-async function withFileLock(filePath, fn) {
-  while (fileLocks.has(filePath)) {
-    await fileLocks.get(filePath);
-  }
-  let resolve;
-  const lockPromise = new Promise((r) => {
-    resolve = r;
-  });
-  fileLocks.set(filePath, lockPromise);
-  try {
-    return await fn();
-  } finally {
-    fileLocks.delete(filePath);
-    resolve();
+};
+var strategyCache = /* @__PURE__ */ new Map();
+function operatingStrategy(mode) {
+  const cached = strategyCache.get(mode);
+  if (cached)
+    return cached;
+  let strategy;
+  switch (mode) {
+    case "prod":
+      strategy = new ProdStrategy();
+      break;
+    case "dev":
+      strategy = new DevStrategy();
+      break;
+    default: {
+      const _exhaustive = mode;
+      throw new Error(`Unknown operating mode: ${_exhaustive}`);
+    }
   }
+  strategyCache.set(mode, strategy);
+  return strategy;
 }
-var BRANCH_META_DIR, BRANCH_META_FILE, CURRENT_SCHEMA_VERSION, BranchMetadataConflictError, fileLocks, BranchMetadataFileManager, loadBranchContext;
-var init_branch_metadata = __esm({
-  "dist/branch-metadata.js"() {
-    "use strict";
-    init_branch_registry();
-    init_paths();
-    init_error();
-    BRANCH_META_DIR = ".canopy-meta";
-    BRANCH_META_FILE = "branch.json";
-    CURRENT_SCHEMA_VERSION = 1;
-    BranchMetadataConflictError = class extends Error {
-      constructor() {
-        super("Concurrent modification detected in branch metadata");
-        this.name = "BranchMetadataConflictError";
-      }
-    };
-    fileLocks = /* @__PURE__ */ new Map();
-    BranchMetadataFileManager = class _BranchMetadataFileManager {
-      constructor(branchRoot, baseRoot) {
-        this.branchRoot = path12.resolve(branchRoot);
-        this.filePath = path12.join(this.branchRoot, BRANCH_META_DIR, BRANCH_META_FILE);
-        this.baseRoot = baseRoot;
-      }
-      /**
-       * Load branch metadata without requiring baseRoot.
-       * Use this for read-only access (e.g., in registry scanning or loadBranchContext).
-       */
-      static async loadOnly(branchRoot) {
-        const filePath = path12.join(path12.resolve(branchRoot), BRANCH_META_DIR, BRANCH_META_FILE);
-        try {
-          const raw = await fs9.readFile(filePath, "utf8");
-          return JSON.parse(raw);
-        } catch (err) {
-          if (isNotFoundError2(err)) {
-            return null;
-          }
-          throw err;
-        }
-      }
-      /**
-       * Get a BranchMetadataFileManager instance configured for registry invalidation.
-       * Use this in API handlers to ensure registry cache is invalidated on updates.
-       */
-      static get(branchRoot, baseRoot) {
-        return new _BranchMetadataFileManager(branchRoot, baseRoot);
-      }
-      async load() {
-        try {
-          const raw = await fs9.readFile(this.filePath, "utf8");
-          const parsed = JSON.parse(raw);
-          const version = parsed.version ?? 0;
-          return { meta: parsed, version };
-        } catch (err) {
-          if (isNotFoundError2(err)) {
-            return { meta: null, version: null };
-          }
-          throw err;
-        }
-      }
-      /**
-       * Atomic write using temp-file + rename + post-write verification.
-       * Follows the same pattern as CommentStore for EFS/NFS safety.
-       */
-      async write(meta, expectedVersion) {
-        const newVersion = expectedVersion === null ? 1 : expectedVersion + 1;
-        const writeId = randomUUID();
-        const payload = {
-          ...meta,
-          schemaVersion: meta.schemaVersion ?? CURRENT_SCHEMA_VERSION,
-          version: newVersion,
-          writeId
-        };
-        await fs9.mkdir(path12.dirname(this.filePath), { recursive: true });
-        const content = JSON.stringify(payload, null, 2) + "\n";
-        if (expectedVersion === null) {
-          try {
-            await fs9.writeFile(this.filePath, content, { flag: "wx" });
-            return { version: newVersion, writeId };
-          } catch (err) {
-            if (isFileExistsError(err)) {
-              throw new BranchMetadataConflictError();
-            }
-            throw err;
-          }
-        }
-        const tempPath = `${this.filePath}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`;
-        await fs9.writeFile(tempPath, content, "utf-8");
-        try {
-          let currentVersion = null;
-          try {
-            const current = JSON.parse(await fs9.readFile(this.filePath, "utf-8"));
-            currentVersion = current.version ?? 0;
-          } catch {
-            currentVersion = null;
-          }
-          if (currentVersion !== expectedVersion) {
-            throw new BranchMetadataConflictError();
-          }
-          await fs9.rename(tempPath, this.filePath);
-          const afterWrite = JSON.parse(await fs9.readFile(this.filePath, "utf-8"));
-          if (afterWrite.writeId !== writeId) {
-            throw new BranchMetadataConflictError();
-          }
-        } catch (err) {
-          await fs9.unlink(tempPath).catch(() => {
-          });
-          throw err;
-        }
-        return { version: newVersion, writeId };
-      }
-      async withRetry(operation, maxAttempts = 5) {
-        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-          try {
-            return await operation();
-          } catch (err) {
-            if (err instanceof BranchMetadataConflictError && attempt < maxAttempts) {
-              const baseDelay = Math.min(10 * Math.pow(2, attempt - 1), 100);
-              const jitter = Math.random() * baseDelay;
-              await new Promise((resolve) => setTimeout(resolve, baseDelay + jitter));
-              continue;
-            }
-            throw err;
-          }
-        }
-        throw new Error("Unreachable");
-      }
-      async save(incoming) {
-        return withFileLock(this.filePath, () => this.withRetry(async () => {
-          const { meta: existing, version } = await this.load();
-          const now = (/* @__PURE__ */ new Date()).toISOString();
-          const defaults = {
-            name: "unknown",
-            status: "editing",
-            access: {},
-            createdBy: "unknown",
-            createdAt: now,
-            updatedAt: now
-          };
-          const merged = {
-            schemaVersion: CURRENT_SCHEMA_VERSION,
-            version: version ?? 0,
-            branch: {
-              ...defaults,
-              ...existing?.branch,
-              ...incoming.branch,
-              access: {
-                ...existing?.branch?.access,
-                ...incoming.branch?.access
-              },
-              // Immutable after creation
-              createdBy: existing?.branch.createdBy ?? incoming.branch?.createdBy ?? defaults.createdBy,
-              createdAt: existing?.branch.createdAt ?? defaults.createdAt
-            }
-          };
-          const written = await this.write(merged, version);
-          merged.version = written.version;
-          merged.writeId = written.writeId;
-          await this.invalidateRegistry();
-          return merged;
-        }));
-      }
-      /**
-       * Invalidates the registry cache so next list() call regenerates from branch.json files.
-       */
-      async invalidateRegistry() {
-        const registry = new BranchRegistry(this.baseRoot);
-        await registry.invalidate();
-      }
-    };
-    loadBranchContext = async (options) => {
-      const { branchRoot, baseRoot } = resolveBranchPath({
-        branchName: options.branchName,
-        mode: options.mode,
-        basePathOverride: options.basePathOverride
-      });
-      const meta = await BranchMetadataFileManager.loadOnly(branchRoot);
-      if (!meta) {
-        return null;
-      }
-      return {
-        branch: meta.branch,
-        branchRoot,
-        baseRoot
-      };
-    };
-  }
-});
 
-// dist/build-mode.js
-var isDeployedStatic, STATIC_DEPLOY_USER;
-var init_build_mode = __esm({
-  "dist/build-mode.js"() {
-    "use strict";
-    isDeployedStatic = (config) => {
-      return config.deployedAs === "static";
-    };
-    STATIC_DEPLOY_USER = Object.freeze({
-      type: "authenticated",
-      userId: "__static_deploy__",
-      groups: ["Admins"],
-      email: "static-deploy@canopycms",
-      name: "Static Deploy"
-    });
-  }
-});
+// dist/utils/fs.js
+import fs from "node:fs/promises";
 
-// dist/ai/resolve-branch.js
-async function resolveBranchRoot(config) {
-  if (config.mode === "dev" || isDeployedStatic(config)) {
-    return process.cwd();
-  }
-  const baseBranch = config.defaultBaseBranch ?? "main";
-  const context = await loadBranchContext({
-    branchName: baseBranch,
-    mode: config.mode
-  });
-  if (!context) {
-    throw new Error(`Could not load branch context for "${baseBranch}". Ensure the branch exists and has been initialized.`);
-  }
-  return context.branchRoot;
+// dist/utils/error.js
+function isNodeError(err) {
+  return err instanceof Error && "code" in err;
 }
-var init_resolve_branch = __esm({
-  "dist/ai/resolve-branch.js"() {
-    "use strict";
-    init_branch_metadata();
-    init_build_mode();
-  }
-});
-
-// dist/build/generate-ai-content.js
-import fs10 from "node:fs/promises";
-import path13 from "node:path";
-async function generateAIContentFiles(options) {
-  const { config, entrySchemaRegistry, outputDir, aiConfig: aiConfig2, _testFlatSchema } = options;
-  const contentRootName = config.contentRoot || "content";
-  const branchRoot = await resolveBranchRoot(config);
-  let flatSchema;
-  if (_testFlatSchema) {
-    flatSchema = _testFlatSchema;
-  } else {
-    const schemaCache = new BranchSchemaCache(config.mode);
-    const cached = await schemaCache.getSchema(branchRoot, entrySchemaRegistry, contentRootName);
-    flatSchema = cached.flatSchema;
-  }
-  const store = new ContentStore(branchRoot, flatSchema);
-  const result = await generateAIContent({
-    store,
-    flatSchema,
-    contentRoot: contentRootName,
-    config: aiConfig2
-  });
-  const absoluteOutputDir = path13.resolve(outputDir) + path13.sep;
-  let fileCount = 0;
-  for (const [filePath, content] of result.files) {
-    const absolutePath = path13.resolve(path13.join(absoluteOutputDir, filePath));
-    if (!absolutePath.startsWith(absoluteOutputDir)) {
-      throw new Error(`Path traversal detected in AI content output: ${filePath}`);
-    }
-    await fs10.mkdir(path13.dirname(absolutePath), { recursive: true });
-    await fs10.writeFile(absolutePath, content, "utf-8");
-    fileCount++;
-  }
-  return { fileCount, outputDir: absoluteOutputDir };
+function isNotFoundError(err) {
+  return isNodeError(err) && err.code === "ENOENT";
 }
-var init_generate_ai_content = __esm({
-  "dist/build/generate-ai-content.js"() {
-    "use strict";
-    init_content_store();
-    init_branch_schema_cache();
-    init_generate();
-    init_resolve_branch();
-  }
-});
 
-// dist/cli/generate-ai-content.js
-var generate_ai_content_exports = {};
-__export(generate_ai_content_exports, {
-  generateAIContentCLI: () => generateAIContentCLI
-});
-import path14 from "node:path";
-import { createJiti } from "jiti";
-async function generateAIContentCLI(options) {
-  const { projectDir, outputDir = "public/ai", configPath, appDir = "app" } = options;
-  console.log("\nCanopyCMS generate-ai-content\n");
-  const canopyConfigPath = path14.join(projectDir, "canopycms.config.ts");
-  let canopyConfigModule;
+// dist/utils/fs.js
+async function filePathExists(filePath) {
   try {
-    canopyConfigModule = await jiti.import(canopyConfigPath);
+    await fs.stat(filePath);
+    return true;
   } catch (err) {
-    console.error(`Could not load config from ${canopyConfigPath}`);
-    console.error(getErrorMessage(err));
-    process.exit(1);
-  }
-  const configExport = canopyConfigModule.default ?? canopyConfigModule.config ?? canopyConfigModule;
-  const serverConfig = typeof configExport === "object" && configExport !== null && "server" in configExport ? configExport.server : configExport;
-  const schemasPath = path14.join(projectDir, appDir, "schemas.ts");
-  let entrySchemaRegistry = {};
-  try {
-    const schemasModule = await jiti.import(schemasPath);
-    entrySchemaRegistry = schemasModule.entrySchemaRegistry ?? schemasModule;
-  } catch {
-    console.warn(`  No ${appDir}/schemas.ts found, using empty entry schema registry`);
-  }
-  let aiConfig2;
-  if (configPath) {
-    try {
-      const aiConfigModule = await jiti.import(path14.resolve(configPath));
-      aiConfig2 = aiConfigModule.aiContentConfig ?? aiConfigModule.default ?? aiConfigModule.config;
-    } catch (err) {
-      console.error(`Could not load AI config from ${configPath}`);
-      console.error(getErrorMessage(err));
-      process.exit(1);
-    }
+    if (isNotFoundError(err))
+      return false;
+    throw err;
   }
-  if (aiConfig2 !== void 0 && (typeof aiConfig2 !== "object" || aiConfig2 === null)) {
-    console.error("Invalid AI content config: expected an object.");
-    process.exit(1);
-  }
-  if (!serverConfig || typeof serverConfig !== "object" || !("mode" in serverConfig) || !("contentRoot" in serverConfig)) {
-    console.error("Invalid CanopyCMS config: expected an object with mode and contentRoot properties.");
-    console.error("Make sure canopycms.config.ts uses defineCanopyConfig().");
-    process.exit(1);
-  }
-  const resolvedOutput = path14.resolve(projectDir, outputDir);
-  console.log(`  Output: ${resolvedOutput}`);
-  console.log(`  Mode: ${serverConfig.mode ?? "dev"}`);
-  const result = await generateAIContentFiles({
-    config: serverConfig,
-    entrySchemaRegistry,
-    outputDir: resolvedOutput,
-    aiConfig: aiConfig2
-  });
-  console.log(`
-  Generated ${result.fileCount} files`);
-  console.log(`  Output: ${result.outputDir}
-`);
 }
-var jiti;
-var init_generate_ai_content2 = __esm({
-  "dist/cli/generate-ai-content.js"() {
-    "use strict";
-    init_generate_ai_content();
-    init_error();
-    jiti = createJiti(import.meta.url);
-  }
-});
 
 // dist/cli/init.js
-init_operating_mode();
-import fs11 from "node:fs/promises";
-import { realpathSync } from "node:fs";
-import path15 from "node:path";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
-import * as p from "@clack/prompts";
-async function fileExists(filePath) {
-  try {
-    await fs11.stat(filePath);
-    return true;
-  } catch {
-    return false;
-  }
-}
 async function writeFile(filePath, content, options) {
-  const relativePath = path15.relative(process.cwd(), filePath);
-  if (await fileExists(filePath)) {
+  const relativePath = path6.relative(process.cwd(), filePath);
+  if (await filePathExists(filePath)) {
     if (options.force) {
     } else if (options.nonInteractive) {
       p.log.warn(`skip: ${relativePath} (already exists)`);
@@ -3583,8 +1148,8 @@ async function writeFile(filePath, content, options) {
       }
     }
   }
-  await fs11.mkdir(path15.dirname(filePath), { recursive: true });
-  await fs11.writeFile(filePath, content, "utf-8");
+  await fs5.mkdir(path6.dirname(filePath), { recursive: true });
+  await fs5.writeFile(filePath, content, "utf-8");
   p.log.success(`created: ${relativePath}`);
   return true;
 }
@@ -3598,22 +1163,22 @@ async function init(options) {
   const writeOpts = { force, nonInteractive };
   const { canopyCmsConfig: canopyCmsConfig2, canopyContext: canopyContext2, schemasTemplate: schemasTemplate2, apiRoute: apiRoute2, editPage: editPage2, aiConfig: aiConfig2, aiRoute: aiRoute2 } = await Promise.resolve().then(() => (init_templates(), templates_exports));
   p.intro("CanopyCMS init");
-  await writeFile(path15.join(projectDir, "canopycms.config.ts"), await canopyCmsConfig2({ mode }), writeOpts);
-  await writeFile(path15.join(projectDir, appDir, "lib/canopy.ts"), await canopyContext2({ configImport: configImportPath(appDir, 1) }), writeOpts);
-  await writeFile(path15.join(projectDir, appDir, "schemas.ts"), await schemasTemplate2(), writeOpts);
-  await writeFile(path15.join(projectDir, appDir, "api/canopycms/[...canopycms]/route.ts"), await apiRoute2({
+  await writeFile(path6.join(projectDir, "canopycms.config.ts"), await canopyCmsConfig2({ mode }), writeOpts);
+  await writeFile(path6.join(projectDir, appDir, "lib/canopy.ts"), await canopyContext2({ configImport: configImportPath(appDir, 1) }), writeOpts);
+  await writeFile(path6.join(projectDir, appDir, "schemas.ts"), await schemasTemplate2(), writeOpts);
+  await writeFile(path6.join(projectDir, appDir, "api/canopycms/[...canopycms]/route.ts"), await apiRoute2({
     canopyImport: "../".repeat(3) + "lib/canopy"
   }), writeOpts);
-  await writeFile(path15.join(projectDir, appDir, "edit/page.tsx"), await editPage2({ configImport: configImportPath(appDir, 1) }), writeOpts);
+  await writeFile(path6.join(projectDir, appDir, "edit/page.tsx"), await editPage2({ configImport: configImportPath(appDir, 1) }), writeOpts);
   if (ai) {
-    await writeFile(path15.join(projectDir, appDir, "ai/config.ts"), await aiConfig2(), writeOpts);
-    await writeFile(path15.join(projectDir, appDir, "ai/[...path]/route.ts"), await aiRoute2({ configImport: configImportPath(appDir, 2) }), writeOpts);
-  }
-  const gitignorePath = path15.join(projectDir, ".gitignore");
-  if (await fileExists(gitignorePath)) {
-    const content = await fs11.readFile(gitignorePath, "utf-8");
-    if (!content.includes(".canopy-prod-sim")) {
-      await fs11.appendFile(gitignorePath, "\n# CanopyCMS\n.canopy-prod-sim/\n.canopy-dev/\n");
+    await writeFile(path6.join(projectDir, appDir, "ai/config.ts"), await aiConfig2(), writeOpts);
+    await writeFile(path6.join(projectDir, appDir, "ai/[...path]/route.ts"), await aiRoute2({ configImport: configImportPath(appDir, 2) }), writeOpts);
+  }
+  const gitignorePath = path6.join(projectDir, ".gitignore");
+  if (await filePathExists(gitignorePath)) {
+    const content = await fs5.readFile(gitignorePath, "utf-8");
+    if (!content.includes(".canopy-dev")) {
+      await fs5.appendFile(gitignorePath, "\n# CanopyCMS\n.canopy-dev/\n");
       p.log.success("updated: .gitignore");
     }
   }
@@ -3637,16 +1202,16 @@ async function initDeployAws(options) {
   const writeOpts = { force, nonInteractive };
   const { dockerfileCms: dockerfileCms2, githubWorkflowCms: githubWorkflowCms2 } = await Promise.resolve().then(() => (init_templates(), templates_exports));
   p.intro("CanopyCMS init-deploy aws");
-  await writeFile(path15.join(projectDir, "Dockerfile.cms"), await dockerfileCms2(), writeOpts);
-  await writeFile(path15.join(projectDir, ".github/workflows/deploy-cms.yml"), await githubWorkflowCms2(), writeOpts);
-  const nextConfigPath = path15.join(projectDir, "next.config.ts");
-  const nextConfigMjsPath = path15.join(projectDir, "next.config.mjs");
-  const configPath = await fileExists(nextConfigPath) ? nextConfigPath : await fileExists(nextConfigMjsPath) ? nextConfigMjsPath : null;
+  await writeFile(path6.join(projectDir, "Dockerfile.cms"), await dockerfileCms2(), writeOpts);
+  await writeFile(path6.join(projectDir, ".github/workflows/deploy-cms.yml"), await githubWorkflowCms2(), writeOpts);
+  const nextConfigPath = path6.join(projectDir, "next.config.ts");
+  const nextConfigMjsPath = path6.join(projectDir, "next.config.mjs");
+  const configPath = await filePathExists(nextConfigPath) ? nextConfigPath : await filePathExists(nextConfigMjsPath) ? nextConfigMjsPath : null;
   if (configPath) {
-    const content = await fs11.readFile(configPath, "utf-8");
+    const content = await fs5.readFile(configPath, "utf-8");
     if (!content.includes("CANOPY_BUILD")) {
       p.note([
-        `Add dual build support to ${path15.basename(configPath)}:`,
+        `Add dual build support to ${path6.basename(configPath)}:`,
         "",
         "  output: process.env.CANOPY_BUILD === 'cms' ? 'standalone' : 'export',"
       ].join("\n"), "Manual step");
@@ -3657,21 +1222,17 @@ async function initDeployAws(options) {
 }
 async function workerRunOnce(options) {
   const { getTaskQueueDir: getTaskQueueDir2 } = await Promise.resolve().then(() => (init_task_queue_config(), task_queue_config_exports));
-  const cfgPath = path15.join(options.projectDir, "canopycms.config.ts");
-  let mode = "prod-sim";
+  const cfgPath = path6.join(options.projectDir, "canopycms.config.ts");
+  let mode = "dev";
   try {
-    const configContent = await fs11.readFile(cfgPath, "utf-8");
+    const configContent = await fs5.readFile(cfgPath, "utf-8");
     if (/^\s*mode:\s*['"]prod['"]\s*[,}]/m.test(configContent)) {
       mode = "prod";
     }
   } catch {
   }
   const taskDir = getTaskQueueDir2({ mode });
-  if (!taskDir) {
-    console.log("Worker not needed in dev mode");
-    return;
-  }
-  const cachePath = process.env.CANOPY_AUTH_CACHE_PATH ?? path15.join(operatingStrategy(mode).getWorkspaceRoot(options.projectDir), ".cache");
+  const cachePath = process.env.CANOPY_AUTH_CACHE_PATH ?? path6.join(operatingStrategy(mode).getWorkspaceRoot(options.projectDir), ".cache");
   let refreshAuthCache;
   const authMode = process.env.CANOPY_AUTH_MODE || "dev";
   if (options.authPlugin?.createCacheRefresher) {
@@ -3707,170 +1268,6 @@ CanopyCMS worker run-once (mode: ${mode}, auth: ${authMode})
   }
   console.log("\nDone");
 }
-function parseFlags(args) {
-  const flags = {};
-  const positional = [];
-  for (let i = 0; i < args.length; i++) {
-    const arg = args[i];
-    if (arg.startsWith("--")) {
-      const key = arg.slice(2);
-      if (key === "force" || key === "non-interactive" || key === "no-ai") {
-        flags[key] = true;
-      } else if (i + 1 < args.length && !args[i + 1].startsWith("--")) {
-        flags[key] = args[++i];
-      }
-    } else {
-      positional.push(arg);
-    }
-  }
-  return { flags, positional };
-}
-async function main() {
-  const args = process.argv.slice(2);
-  const { flags, positional } = parseFlags(args);
-  const command = positional[0];
-  if (command === "init") {
-    const nonInteractive = flags["non-interactive"] === true;
-    const force = flags["force"] === true;
-    let mode;
-    if (flags["mode"] === "dev" || flags["mode"] === "prod-sim") {
-      mode = flags["mode"];
-    } else if (nonInteractive) {
-      mode = "dev";
-    } else {
-      const result = await p.select({
-        message: "Which operating mode?",
-        options: [
-          { value: "dev", label: "dev", hint: "Direct editing in current checkout" },
-          {
-            value: "prod-sim",
-            label: "prod-sim",
-            hint: "Simulates production with local branch clones"
-          }
-        ],
-        initialValue: "dev"
-      });
-      if (p.isCancel(result)) {
-        p.cancel("Init cancelled.");
-        process.exit(0);
-      }
-      mode = result;
-    }
-    let appDir;
-    if (typeof flags["app-dir"] === "string") {
-      appDir = flags["app-dir"];
-    } else if (nonInteractive) {
-      appDir = "app";
-    } else {
-      const result = await p.text({
-        message: "App directory?",
-        placeholder: "app",
-        defaultValue: "app"
-      });
-      if (p.isCancel(result)) {
-        p.cancel("Init cancelled.");
-        process.exit(0);
-      }
-      appDir = result;
-    }
-    let ai;
-    if (flags["no-ai"] === true) {
-      ai = false;
-    } else if (nonInteractive) {
-      ai = true;
-    } else {
-      const result = await p.confirm({
-        message: "Include AI content endpoint?",
-        initialValue: true
-      });
-      if (p.isCancel(result)) {
-        p.cancel("Init cancelled.");
-        process.exit(0);
-      }
-      ai = result;
-    }
-    await init({
-      mode,
-      appDir,
-      ai,
-      projectDir: process.cwd(),
-      force,
-      nonInteractive
-    });
-  } else if (command === "init-deploy") {
-    const cloud = positional[1];
-    if (cloud !== "aws") {
-      console.error("Usage: canopycms init-deploy aws");
-      console.error('Only "aws" is currently supported.');
-      process.exit(1);
-    }
-    await initDeployAws({
-      cloud: "aws",
-      projectDir: process.cwd(),
-      force: flags["force"] === true,
-      nonInteractive: flags["non-interactive"] === true
-    });
-  } else if (command === "worker") {
-    const subcommand = positional[1];
-    if (subcommand !== "run-once") {
-      console.error("Usage: canopycms worker run-once");
-      process.exit(1);
-    }
-    const authMode = process.env.CANOPY_AUTH_MODE || "dev";
-    let authPlugin;
-    try {
-      if (authMode === "clerk") {
-        const pkg = "canopycms-auth-clerk";
-        const { createClerkAuthPlugin } = await import(pkg);
-        authPlugin = createClerkAuthPlugin({});
-      } else if (authMode === "dev") {
-        const pkg = "canopycms-auth-dev";
-        const { createDevAuthPlugin } = await import(pkg);
-        authPlugin = createDevAuthPlugin();
-      }
-    } catch {
-      console.warn(`Could not load auth plugin for mode "${authMode}" \u2014 skipping cache refresh`);
-    }
-    await workerRunOnce({ projectDir: process.cwd(), authPlugin });
-  } else if (command === "generate-ai-content") {
-    const { generateAIContentCLI: generateAIContentCLI2 } = await Promise.resolve().then(() => (init_generate_ai_content2(), generate_ai_content_exports));
-    await generateAIContentCLI2({
-      projectDir: process.cwd(),
-      outputDir: typeof flags["output"] === "string" ? flags["output"] : void 0,
-      configPath: typeof flags["config"] === "string" ? flags["config"] : void 0,
-      appDir: typeof flags["app-dir"] === "string" ? flags["app-dir"] : void 0
-    });
-  } else {
-    console.log("CanopyCMS CLI");
-    console.log("");
-    console.log("Commands:");
-    console.log("  init                    Add CanopyCMS to a Next.js app");
-    console.log("    --mode <dev|prod-sim> Operating mode (default: dev)");
-    console.log("    --app-dir <path>      App directory (default: app)");
-    console.log("    --no-ai               Skip AI content endpoint generation");
-    console.log("    --force               Overwrite existing files without asking");
-    console.log("    --non-interactive     Use defaults, no prompts");
-    console.log("");
-    console.log("  init-deploy aws         Generate AWS deployment artifacts");
-    console.log("    --force               Overwrite existing files without asking");
-    console.log("    --non-interactive     Use defaults, no prompts");
-    console.log("");
-    console.log("  worker run-once         Process tasks, sync git, refresh auth cache");
-    console.log("  generate-ai-content     Generate static AI-ready content files");
-    console.log("    --output <dir>        Output directory (default: public/ai)");
-    console.log("    --config <path>       Path to AI content config file");
-    console.log("    --app-dir <path>      App directory (default: app)");
-    process.exit(0);
-  }
-}
-var __filename = fileURLToPath2(import.meta.url);
-var isDirectRun = realpathSync(process.argv[1]) === realpathSync(__filename);
-if (isDirectRun) {
-  main().catch((err) => {
-    console.error("Error:", err instanceof Error ? err.message : String(err));
-    process.exit(1);
-  });
-}
 export {
   init,
   initDeployAws,