canopycms 0.0.7 → 0.0.8

package/dist/cli/init.js

@@ -1,385 +1,3856 @@
 #!/usr/bin/env node
-import fs from 'node:fs/promises';
-import { realpathSync } from 'node:fs';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import * as p from '@clack/prompts';
-import { operatingStrategy } from '../operating-mode';
-async function fileExists(filePath) {
-    try {
-        await fs.stat(filePath);
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in 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({
+  "dist/config/types.js"() {
+    "use strict";
+    primitiveFieldTypes = [
+      "string",
+      "number",
+      "boolean",
+      "datetime",
+      "rich-text",
+      "markdown",
+      "mdx",
+      "image",
+      "code"
+    ];
+    fieldTypes = [
+      ...primitiveFieldTypes,
+      "select",
+      "reference",
+      "object",
+      "block"
+    ];
+  }
+});
+
+// dist/config/schemas/field.js
+import { z } from "zod";
+var fieldBaseSchema, selectOptionSchema, referenceOptionSchema, primitiveFieldSchema, selectFieldSchema, referenceFieldSchema, fieldHolder, blockSchema, blockFieldSchema, objectFieldSchema, customFieldSchema, knownFieldSchema, fieldSchema;
+var init_field = __esm({
+  "dist/config/schemas/field.js"() {
+    "use strict";
+    init_types();
+    fieldBaseSchema = z.object({
+      name: z.string().min(1),
+      label: z.string().optional(),
+      description: z.string().optional(),
+      required: z.boolean().optional(),
+      list: z.boolean().optional()
+    });
+    selectOptionSchema = z.union([
+      z.string(),
+      z.object({
+        label: z.string().min(1),
+        value: z.string().min(1)
+      })
+    ]);
+    referenceOptionSchema = z.union([
+      z.string(),
+      z.object({
+        label: z.string().min(1),
+        value: z.string().min(1)
+      })
+    ]);
+    primitiveFieldSchema = fieldBaseSchema.extend({
+      type: z.enum(primitiveFieldTypes)
+    });
+    selectFieldSchema = fieldBaseSchema.extend({
+      type: z.literal("select"),
+      options: z.array(selectOptionSchema).min(1)
+    });
+    referenceFieldSchema = fieldBaseSchema.extend({
+      type: z.literal("reference"),
+      collections: z.array(z.string().min(1)).min(1),
+      displayField: z.string().min(1).optional(),
+      options: z.array(referenceOptionSchema).optional()
+    });
+    fieldHolder = [z.never()];
+    blockSchema = z.object({
+      name: z.string().min(1),
+      label: z.string().optional(),
+      description: z.string().optional(),
+      fields: z.array(z.lazy(() => fieldHolder[0])).min(1)
+    });
+    blockFieldSchema = fieldBaseSchema.extend({
+      type: z.literal("block"),
+      templates: z.array(blockSchema).min(1)
+    });
+    objectFieldSchema = fieldBaseSchema.extend({
+      type: z.literal("object"),
+      fields: z.array(z.lazy(() => fieldHolder[0])).min(1)
+    });
+    customFieldSchema = z.lazy(() => fieldBaseSchema.extend({
+      type: z.string().min(1).refine((val) => !fieldTypes.includes(val), {
+        message: "Custom field types must not conflict with built-in types"
+      })
+    }).passthrough());
+    knownFieldSchema = z.discriminatedUnion("type", [
+      primitiveFieldSchema,
+      selectFieldSchema,
+      referenceFieldSchema,
+      objectFieldSchema,
+      blockFieldSchema
+    ]);
+    fieldSchema = z.lazy(() => z.union([knownFieldSchema, customFieldSchema]));
+    fieldHolder[0] = fieldSchema;
+  }
+});
+
+// dist/config/schemas/collection.js
+import { z as z2 } from "zod";
+import { isAbsolute } from "pathe";
+var relativePathSchema, entryTypeSchema, collectionSchema, rootCollectionSchema;
+var init_collection = __esm({
+  "dist/config/schemas/collection.js"() {
+    "use strict";
+    init_field();
+    relativePathSchema = z2.string().min(1).refine((val) => !isAbsolute(val), { message: "Path must be relative" }).refine((val) => !val.split(/[\\/]+/).includes(".."), {
+      message: 'Path must not contain ".."'
+    }).transform((val) => val.split(/[\\/]+/).filter(Boolean).join("/"));
+    entryTypeSchema = z2.object({
+      name: z2.string().min(1),
+      format: z2.enum(["md", "mdx", "json"]),
+      schema: z2.array(z2.lazy(() => fieldSchema)).min(1),
+      label: z2.string().optional(),
+      description: z2.string().optional(),
+      default: z2.boolean().optional(),
+      maxItems: z2.number().int().positive().optional()
+    });
+    collectionSchema = z2.lazy(() => z2.object({
+      name: z2.string().min(1),
+      path: relativePathSchema,
+      label: z2.string().optional(),
+      description: z2.string().optional(),
+      entries: z2.array(entryTypeSchema).optional(),
+      collections: z2.array(collectionSchema).optional(),
+      order: z2.array(z2.string()).optional()
+      // Embedded IDs for ordering items
+    }).refine((data) => data.entries || data.collections, {
+      message: "Collection must have entries or collections"
+    }));
+    rootCollectionSchema = z2.object({
+      entries: z2.array(entryTypeSchema).optional(),
+      collections: z2.array(collectionSchema).optional(),
+      order: z2.array(z2.string()).optional()
+      // Embedded IDs for ordering items
+    });
+  }
+});
+
+// dist/config/schemas/media.js
+import { z as z3 } from "zod";
+var mediaSchema;
+var init_media = __esm({
+  "dist/config/schemas/media.js"() {
+    "use strict";
+    mediaSchema = z3.union([
+      z3.object({
+        adapter: z3.literal("local"),
+        publicBaseUrl: z3.string().url().optional()
+      }),
+      z3.object({
+        adapter: z3.literal("s3"),
+        bucket: z3.string().min(1),
+        region: z3.string().min(1),
+        publicBaseUrl: z3.string().url().optional()
+      }),
+      z3.object({
+        adapter: z3.literal("lfs"),
+        publicBaseUrl: z3.string().url().optional()
+      }),
+      z3.object({
+        adapter: z3.string().min(1),
+        publicBaseUrl: z3.string().url().optional()
+      })
+    ]);
+  }
+});
+
+// dist/config/schemas/config.js
+import { z as z4 } from "zod";
+var defaultBranchAccessSchema, defaultPathAccessSchema, defaultBaseBranchSchema, defaultRemoteNameSchema, defaultRemoteUrlSchema, gitBotAuthorNameSchema, gitBotAuthorEmailSchema, githubTokenEnvVarSchema, operatingModeSchema, deployedAsSchema, contentRootSchema, sourceRootSchema, deploymentNameSchema, editorConfigSchema, CanopyConfigSchema, DEFAULT_PROD_WORKSPACE;
+var init_config = __esm({
+  "dist/config/schemas/config.js"() {
+    "use strict";
+    init_collection();
+    init_media();
+    defaultBranchAccessSchema = z4.enum(["allow", "deny"]).default("deny");
+    defaultPathAccessSchema = z4.enum(["allow", "deny"]).default("deny");
+    defaultBaseBranchSchema = z4.string().default("main");
+    defaultRemoteNameSchema = z4.string().default("origin");
+    defaultRemoteUrlSchema = z4.string().min(1);
+    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");
+    deployedAsSchema = z4.enum(["static", "server"]).default("server");
+    contentRootSchema = relativePathSchema.default("content");
+    sourceRootSchema = z4.string().min(1).optional();
+    deploymentNameSchema = z4.string().default("prod");
+    editorConfigSchema = z4.object({
+      title: z4.string().optional(),
+      subtitle: z4.string().optional(),
+      theme: z4.unknown().optional(),
+      previewBase: z4.record(z4.string()).optional(),
+      // UI handler functions (runtime only, don't serialize)
+      onAccountClick: z4.function().returns(z4.void()).optional(),
+      onLogoutClick: z4.function().returns(z4.void()).optional(),
+      // Optional: custom account component (e.g., Clerk's UserButton)
+      AccountComponent: z4.custom().optional()
+    });
+    CanopyConfigSchema = z4.object({
+      schema: rootCollectionSchema.optional(),
+      media: mediaSchema.optional(),
+      defaultBranchAccess: defaultBranchAccessSchema.optional(),
+      defaultPathAccess: defaultPathAccessSchema.optional(),
+      defaultBaseBranch: defaultBaseBranchSchema.optional(),
+      defaultRemoteName: defaultRemoteNameSchema.optional(),
+      defaultRemoteUrl: defaultRemoteUrlSchema.optional(),
+      gitBotAuthorName: gitBotAuthorNameSchema,
+      gitBotAuthorEmail: gitBotAuthorEmailSchema,
+      githubTokenEnvVar: githubTokenEnvVarSchema.optional(),
+      mode: operatingModeSchema,
+      // Has .default(), so not optional in output type
+      deployedAs: deployedAsSchema,
+      // Has .default('server'), so always present after validation
+      settingsBranch: z4.string().optional(),
+      autoCreateSettingsPR: z4.boolean().optional(),
+      deploymentName: deploymentNameSchema.optional(),
+      contentRoot: contentRootSchema.default("content"),
+      sourceRoot: sourceRootSchema.optional(),
+      editor: editorConfigSchema.optional(),
+      authPlugin: z4.custom().optional()
+    });
+    DEFAULT_PROD_WORKSPACE = "/mnt/efs/workspace";
+  }
+});
+
+// dist/config/schemas/permissions.js
+import { z as z5 } from "zod";
+var permissionTargetSchema, pathPermissionSchema;
+var init_permissions = __esm({
+  "dist/config/schemas/permissions.js"() {
+    "use strict";
+    permissionTargetSchema = z5.object({
+      allowedUsers: z5.array(z5.string()).optional(),
+      allowedGroups: z5.array(z5.string()).optional()
+    });
+    pathPermissionSchema = z5.object({
+      path: z5.string().min(1),
+      read: permissionTargetSchema.optional(),
+      edit: permissionTargetSchema.optional(),
+      review: permissionTargetSchema.optional()
+    });
+  }
+});
+
+// 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";
+  }
+});
+
+// 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;
+    };
+  }
+});
+
+// dist/config/validation.js
+var init_validation = __esm({
+  "dist/config/validation.js"() {
+    "use strict";
+    init_config();
+    init_flatten();
+  }
+});
+
+// dist/config/helpers.js
+var init_helpers = __esm({
+  "dist/config/helpers.js"() {
+    "use strict";
+    init_validation();
+  }
+});
+
+// dist/config/index.js
+var init_config2 = __esm({
+  "dist/config/index.js"() {
+    "use strict";
+    init_types();
+    init_config();
+    init_field();
+    init_collection();
+    init_permissions();
+    init_media();
+    init_flatten();
+    init_validation();
+    init_helpers();
+  }
+});
+
+// dist/config.js
+var init_config3 = __esm({
+  "dist/config.js"() {
+    "use strict";
+    init_config2();
+  }
+});
+
+// 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}`);
     }
-    catch {
+  }
+  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, {
+  aiConfig: () => aiConfig,
+  aiRoute: () => aiRoute,
+  apiRoute: () => apiRoute,
+  canopyCmsConfig: () => canopyCmsConfig,
+  canopyContext: () => canopyContext,
+  dockerfileCms: () => dockerfileCms,
+  editPage: () => editPage,
+  githubWorkflowCms: () => githubWorkflowCms,
+  schemasTemplate: () => schemasTemplate
+});
+import fs 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");
+}
+async function canopyCmsConfig(options) {
+  const template = await readTemplate("canopycms.config.ts.template");
+  return template.replace("{{MODE}}", options.mode);
+}
+async function canopyContext(options) {
+  const template = await readTemplate("canopy.ts.template");
+  return template.replace("{{CONFIG_IMPORT}}", options.configImport);
+}
+async function schemasTemplate() {
+  return readTemplate("schemas.ts.template");
+}
+async function apiRoute(options) {
+  const template = await readTemplate("route.ts.template");
+  return template.replace("{{CANOPY_IMPORT}}", options.canopyImport);
+}
+async function editPage(options) {
+  const template = await readTemplate("edit-page.tsx.template");
+  return template.replace("{{CONFIG_IMPORT}}", options.configImport);
+}
+async function aiConfig() {
+  return readTemplate("ai-config.ts.template");
+}
+async function aiRoute(options) {
+  const template = await readTemplate("ai-route.ts.template");
+  return template.replace("{{CONFIG_IMPORT}}", options.configImport);
+}
+async function dockerfileCms() {
+  return readTemplate("Dockerfile.cms.template");
+}
+async function githubWorkflowCms() {
+  return readTemplate("deploy-cms.yml.template");
+}
+var __dirname, TEMPLATES_DIR;
+var init_templates = __esm({
+  "dist/cli/templates.js"() {
+    "use strict";
+    __dirname = path2.dirname(fileURLToPath(import.meta.url));
+    TEMPLATES_DIR = path2.join(__dirname, "template-files");
+  }
+});
+
+// dist/worker/task-queue-config.js
+var task_queue_config_exports = {};
+__export(task_queue_config_exports, {
+  getTaskQueueDir: () => getTaskQueueDir
+});
+import path3 from "node:path";
+function getTaskQueueDir(config) {
+  switch (config.mode) {
+    case "prod": {
+      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 null;
+  }
 }
-/**
- * Write a file, prompting for overwrite confirmation if it already exists.
- * Returns true if the file was written, false if skipped.
- */
-async function writeFile(filePath, content, options) {
-    const relativePath = path.relative(process.cwd(), filePath);
-    if (await fileExists(filePath)) {
-        if (options.force) {
-            // --force: overwrite without asking
-        }
-        else if (options.nonInteractive) {
-            p.log.warn(`skip: ${relativePath} (already exists)`);
-            return false;
-        }
-        else {
-            const overwrite = await p.confirm({
-                message: `${relativePath} already exists. Overwrite?`,
-                initialValue: false,
-            });
-            if (p.isCancel(overwrite) || !overwrite) {
-                p.log.warn(`skip: ${relativePath}`);
-                return false;
-            }
+var init_task_queue_config = __esm({
+  "dist/worker/task-queue-config.js"() {
+    "use strict";
+    init_config3();
+  }
+});
+
+// dist/utils/debug.js
+function createDebugLogger(options) {
+  return new DebugLogger(options);
+}
+var LOG_LEVELS, DebugLogger, testLogger;
+var init_debug = __esm({
+  "dist/utils/debug.js"() {
+    "use strict";
+    LOG_LEVELS = {
+      DEBUG: 0,
+      INFO: 1,
+      WARN: 2,
+      ERROR: 3
+    };
+    DebugLogger = class {
+      constructor(options = {}) {
+        this.timers = /* @__PURE__ */ new Map();
+        this.options = options;
+      }
+      shouldLog(level) {
+        const enabled = this.options.enabled ?? process.env.CANOPYCMS_DEBUG === "true";
+        if (!enabled)
+          return false;
+        const minLevel = this.options.minLevel ?? "DEBUG";
+        return LOG_LEVELS[level] >= LOG_LEVELS[minLevel];
+      }
+      formatMessage(level, category, message) {
+        const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+        const prefix = this.options.prefix ?? "CanopyCMS";
+        return `[${timestamp}] [${prefix}:${category}] [${level}] ${message}`;
+      }
+      debug(category, message, data) {
+        if (this.shouldLog("DEBUG")) {
+          console.log(this.formatMessage("DEBUG", category, message), data ?? "");
+        }
+      }
+      info(category, message, data) {
+        if (this.shouldLog("INFO")) {
+          console.log(this.formatMessage("INFO", category, message), data ?? "");
+        }
+      }
+      warn(category, message, data) {
+        if (this.shouldLog("WARN")) {
+          console.warn(this.formatMessage("WARN", category, message), data ?? "");
+        }
+      }
+      error(category, message, data) {
+        const msg = this.formatMessage("ERROR", category, message);
+        if (this.shouldLog("ERROR")) {
+          console.error(msg, data ?? "");
+        }
+        const throwOnError = this.options.throwOnError ?? false;
+        if (throwOnError) {
+          const errorMsg = data ? `${message}: ${JSON.stringify(data)}` : message;
+          throw new Error(errorMsg);
+        }
+      }
+      /**
+       * Start timing an operation
+       */
+      time(label) {
+        this.timers.set(label, Date.now());
+      }
+      /**
+       * End timing an operation and log the duration
+       */
+      timeEnd(category, label) {
+        const start = this.timers.get(label);
+        if (start === void 0) {
+          this.warn(category, `Timer '${label}' does not exist`);
+          return;
+        }
+        const duration = Date.now() - start;
+        this.timers.delete(label);
+        this.debug(category, `${label} completed`, { durationMs: duration });
+        return duration;
+      }
+      /**
+       * Wrap an async function with automatic timing
+       */
+      async timed(category, label, fn) {
+        this.time(label);
+        try {
+          return await fn();
+        } finally {
+          this.timeEnd(category, label);
         }
+      }
+    };
+    testLogger = createDebugLogger({
+      enabled: process.env.E2E_DEBUG === "true",
+      prefix: "E2E",
+      throwOnError: false
+    });
+  }
+});
+
+// dist/utils/atomic-write.js
+import fs2 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 });
+  const tempPath = `${filePath}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`;
+  await fs2.writeFile(tempPath, content, "utf-8");
+  try {
+    await fs2.rename(tempPath, filePath);
+  } catch (err) {
+    await fs2.unlink(tempPath).catch(() => {
+    });
+    throw err;
+  }
+}
+var init_atomic_write = __esm({
+  "dist/utils/atomic-write.js"() {
+    "use strict";
+  }
+});
+
+// dist/task-queue/task-queue.js
+import fs3 from "node:fs/promises";
+import path5 from "node:path";
+import crypto from "node:crypto";
+function isNotFoundError(err) {
+  return err instanceof Error && "code" in err && err.code === "ENOENT";
+}
+async function enqueueTask(taskDir, task, logger = nullLogger) {
+  const id = crypto.randomUUID();
+  const pendingDir = path5.join(taskDir, "pending");
+  const queuedTask = {
+    id,
+    action: task.action,
+    payload: task.payload,
+    status: "pending",
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    retryCount: 0,
+    maxRetries: task.maxRetries ?? DEFAULT_MAX_RETRIES
+  };
+  const filePath = path5.join(pendingDir, `${id}.json`);
+  await atomicWriteFile(filePath, JSON.stringify(queuedTask, null, 2));
+  logger.debug("Enqueued task", { id, action: task.action });
+  return id;
+}
+async function dequeueTask(taskDir, logger = nullLogger) {
+  const pendingDir = path5.join(taskDir, "pending");
+  const processingDir = path5.join(taskDir, "processing");
+  let files;
+  try {
+    files = await fs3.readdir(pendingDir);
+  } catch {
+    return null;
+  }
+  const jsonFiles = files.filter((f) => f.endsWith(".json"));
+  if (jsonFiles.length === 0)
+    return null;
+  const now = Date.now();
+  const tasks = [];
+  for (const fileName2 of jsonFiles) {
+    try {
+      const content = await fs3.readFile(path5.join(pendingDir, fileName2), "utf-8");
+      const task2 = parseTaskJson(content);
+      if (!task2) {
+        await moveToCorrupt(taskDir, pendingDir, fileName2, "Invalid JSON", logger);
+        continue;
+      }
+      if (task2.retryAfter && new Date(task2.retryAfter).getTime() > now) {
+        continue;
+      }
+      tasks.push({ fileName: fileName2, task: task2 });
+    } catch (err) {
+      if (isNotFoundError(err))
+        continue;
+      throw err;
     }
-    await fs.mkdir(path.dirname(filePath), { recursive: true });
-    await fs.writeFile(filePath, content, 'utf-8');
-    p.log.success(`created: ${relativePath}`);
-    return true;
+  }
+  if (tasks.length === 0)
+    return null;
+  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(() => {
+    });
+    logger.debug("Skipped already-finished task", { id: task.id });
+    return null;
+  }
+  const sourcePath = path5.join(pendingDir, fileName);
+  const destPath = path5.join(processingDir, fileName);
+  try {
+    task.status = "processing";
+    await atomicWriteFile(destPath, JSON.stringify(task, null, 2));
+    await fs3.unlink(sourcePath);
+    logger.debug("Dequeued task", { id: task.id, action: task.action });
+    return task;
+  } catch (err) {
+    if (isNotFoundError(err))
+      return null;
+    throw err;
+  }
 }
-/**
- * Compute the relative path from a file inside appDir to the project root.
- * e.g. appDir="app" depth=1 → "../", appDir="src/app" depth=2 → "../../"
- */
-function configImportPath(appDir, subdirs) {
-    const appDepth = appDir.split('/').filter(Boolean).length;
-    const totalDepth = appDepth + subdirs;
-    return '../'.repeat(totalDepth) + 'canopycms.config';
-}
-/**
- * Framework integration: generates the files needed to add CanopyCMS
- * editing to a Next.js app. Cloud-agnostic.
- */
-export async function init(options) {
-    const { projectDir, mode, appDir, ai, force, nonInteractive } = options;
-    const writeOpts = { force, nonInteractive };
-    const { canopyCmsConfig, canopyContext, schemasTemplate, apiRoute, editPage, aiConfig, aiRoute } = await import('./templates');
-    p.intro('CanopyCMS init');
-    // Generate files
-    await writeFile(path.join(projectDir, 'canopycms.config.ts'), await canopyCmsConfig({ mode }), writeOpts);
-    await writeFile(path.join(projectDir, appDir, 'lib/canopy.ts'), await canopyContext({ configImport: configImportPath(appDir, 1) }), writeOpts);
-    await writeFile(path.join(projectDir, appDir, 'schemas.ts'), await schemasTemplate(), writeOpts);
-    await writeFile(path.join(projectDir, appDir, 'api/canopycms/[...canopycms]/route.ts'), await apiRoute({
-        canopyImport: '../'.repeat(3) + 'lib/canopy',
-    }), writeOpts);
-    await writeFile(path.join(projectDir, appDir, 'edit/page.tsx'), await editPage({ configImport: configImportPath(appDir, 1) }), writeOpts);
-    if (ai) {
-        await writeFile(path.join(projectDir, appDir, 'ai/config.ts'), await aiConfig(), writeOpts);
-        await writeFile(path.join(projectDir, appDir, 'ai/[...path]/route.ts'), await aiRoute({ configImport: configImportPath(appDir, 2) }), writeOpts);
-    }
-    // Update .gitignore
-    const gitignorePath = path.join(projectDir, '.gitignore');
-    if (await fileExists(gitignorePath)) {
-        const content = await fs.readFile(gitignorePath, 'utf-8');
-        if (!content.includes('.canopy-prod-sim')) {
-            await fs.appendFile(gitignorePath, '\n# CanopyCMS\n.canopy-prod-sim/\n.canopy-dev/\n');
-            p.log.success('updated: .gitignore');
-        }
-    }
-    p.note([
-        '1. Install dependencies:',
-        `   npm install canopycms canopycms-next canopycms-auth-clerk canopycms-auth-dev`,
-        '',
-        '2. Wrap your Next.js config:',
-        "   import { withCanopy } from 'canopycms-next'",
-        '   export default withCanopy({ /* your config */ })',
-        '',
-        '3. Customize ' + appDir + '/schemas.ts with your content schema',
-        '',
-        '4. Run: npm run dev',
-        '5. Visit: http://localhost:3000/edit',
-    ].join('\n'), 'Next steps');
-    p.outro('Done!');
-}
-/**
- * Cloud deployment artifacts: generates AWS-specific files
- * (Dockerfile, CI workflow).
- */
-export async function initDeployAws(options) {
-    const { projectDir, force, nonInteractive } = options;
-    const writeOpts = { force, nonInteractive };
-    const { dockerfileCms, githubWorkflowCms } = await import('./templates');
-    p.intro('CanopyCMS init-deploy aws');
-    await writeFile(path.join(projectDir, 'Dockerfile.cms'), await dockerfileCms(), writeOpts);
-    await writeFile(path.join(projectDir, '.github/workflows/deploy-cms.yml'), await githubWorkflowCms(), writeOpts);
-    // Check if next.config already has CANOPY_BUILD support
-    const nextConfigPath = path.join(projectDir, 'next.config.ts');
-    const nextConfigMjsPath = path.join(projectDir, 'next.config.mjs');
-    const configPath = (await fileExists(nextConfigPath))
-        ? nextConfigPath
-        : (await fileExists(nextConfigMjsPath))
-            ? nextConfigMjsPath
-            : null;
-    if (configPath) {
-        const content = await fs.readFile(configPath, 'utf-8');
-        if (!content.includes('CANOPY_BUILD')) {
-            p.note([
-                `Add dual build support to ${path.basename(configPath)}:`,
-                '',
-                "  output: process.env.CANOPY_BUILD === 'cms' ? 'standalone' : 'export',",
-            ].join('\n'), 'Manual step');
-        }
-    }
-    p.note('CDK constructs are available via the canopycms-cdk package.\nSee the deployment plan for CDK stack setup.', 'AWS deployment');
-    p.outro('Done!');
-}
-/**
- * Worker run-once: process pending tasks, sync git, refresh auth cache, then exit.
- * Used in prod-sim to trigger worker operations without a persistent daemon.
- */
-export async function workerRunOnce(options) {
-    // Dynamic import to avoid loading worker deps when not needed
-    const { getTaskQueueDir } = await import('../worker/task-queue-config');
-    // Determine workspace and mode from config
-    const cfgPath = path.join(options.projectDir, 'canopycms.config.ts');
-    let mode = 'prod-sim';
+async function completeTask(taskDir, taskId, result, logger = nullLogger) {
+  const processingPath = path5.join(taskDir, "processing", `${taskId}.json`);
+  const completedDir = path5.join(taskDir, "completed");
+  const completedPath = path5.join(completedDir, `${taskId}.json`);
+  let task;
+  try {
+    const content = await fs3.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(() => {
+      });
+      return;
+    }
+    task = parsed;
+  } catch (err) {
+    if (isNotFoundError(err))
+      return;
+    throw err;
+  }
+  task.status = "completed";
+  task.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+  task.result = result;
+  await atomicWriteFile(completedPath, JSON.stringify(task, null, 2));
+  await fs3.unlink(processingPath).catch(() => {
+  });
+  logger.debug("Completed task", { id: taskId });
+}
+async function failTask(taskDir, taskId, error, logger = nullLogger) {
+  const processingPath = path5.join(taskDir, "processing", `${taskId}.json`);
+  const failedDir = path5.join(taskDir, "failed");
+  const failedPath = path5.join(failedDir, `${taskId}.json`);
+  let task;
+  try {
+    const content = await fs3.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(() => {
+      });
+      return;
+    }
+    task = parsed;
+  } catch (err) {
+    if (isNotFoundError(err))
+      return;
+    throw err;
+  }
+  task.status = "failed";
+  task.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+  task.error = error;
+  await atomicWriteFile(failedPath, JSON.stringify(task, null, 2));
+  await fs3.unlink(processingPath).catch(() => {
+  });
+  logger.debug("Failed task", { id: taskId, error });
+}
+async function retryTask(taskDir, taskId, error, logger = nullLogger) {
+  const processingPath = path5.join(taskDir, "processing", `${taskId}.json`);
+  const pendingDir = path5.join(taskDir, "pending");
+  const pendingPath = path5.join(pendingDir, `${taskId}.json`);
+  let task;
+  try {
+    const content = await fs3.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(() => {
+      });
+      return;
+    }
+    task = parsed;
+  } catch (err) {
+    if (isNotFoundError(err))
+      return;
+    throw err;
+  }
+  const retryCount = (task.retryCount ?? 0) + 1;
+  const backoffMs = Math.min(5e3 * Math.pow(2, retryCount - 1), 6e4);
+  task.status = "pending";
+  task.retryCount = retryCount;
+  task.retryAfter = new Date(Date.now() + backoffMs).toISOString();
+  task.error = error;
+  await atomicWriteFile(pendingPath, JSON.stringify(task, null, 2));
+  await fs3.unlink(processingPath).catch(() => {
+  });
+  logger.debug("Retrying task", { id: taskId, retryCount, backoffMs });
+}
+async function recoverOrphanedTasks(taskDir, maxAgeMs = 5 * 6e4, logger = nullLogger) {
+  const processingDir = path5.join(taskDir, "processing");
+  const pendingDir = path5.join(taskDir, "pending");
+  let files;
+  try {
+    files = await fs3.readdir(processingDir);
+  } catch {
+    return 0;
+  }
+  const now = Date.now();
+  let recovered = 0;
+  for (const fileName of files.filter((f) => f.endsWith(".json"))) {
+    const filePath = path5.join(processingDir, fileName);
     try {
-        const configContent = await fs.readFile(cfgPath, 'utf-8');
-        // Match the mode property in the config object, not in comments or strings
-        if (/^\s*mode:\s*['"]prod['"]\s*[,}]/m.test(configContent)) {
-            mode = 'prod';
-        }
-    }
-    catch {
-        // Default to prod-sim
-    }
-    const taskDir = getTaskQueueDir({ mode });
-    if (!taskDir) {
-        console.log('Worker not needed in dev mode');
-        return;
-    }
-    // For prod-sim without GitHub, just refresh auth cache
-    const cachePath = process.env.CANOPY_AUTH_CACHE_PATH ??
-        path.join(operatingStrategy(mode).getWorkspaceRoot(options.projectDir), '.cache');
-    let refreshAuthCache;
-    const authMode = process.env.CANOPY_AUTH_MODE || 'dev';
-    if (options.authPlugin?.createCacheRefresher) {
-        const refresher = options.authPlugin.createCacheRefresher(cachePath);
-        if (refresher) {
-            refreshAuthCache = async () => {
-                const result = await refresher();
-                console.log(`  ${result.userCount} users, ${result.groupCount} groups`);
-            };
+      const stat = await fs3.stat(filePath);
+      if (now - stat.mtimeMs >= maxAgeMs) {
+        const content = await fs3.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(() => {
+          });
+          logger.debug("Cleaned up orphaned task (already finished)", {
+            id: task.id
+          });
+          continue;
+        }
+        task.status = "pending";
+        await atomicWriteFile(path5.join(pendingDir, fileName), JSON.stringify(task, null, 2));
+        await fs3.unlink(filePath);
+        logger.debug("Recovered orphaned task", {
+          id: task.id,
+          action: task.action
+        });
+        recovered++;
+      }
+    } catch (err) {
+      if (isNotFoundError(err))
+        continue;
+      logger.debug("Failed to recover task", { fileName });
     }
-    console.log(`\nCanopyCMS worker run-once (mode: ${mode}, auth: ${authMode})\n`);
-    // Refresh auth cache
-    if (refreshAuthCache) {
-        console.log('Refreshing auth cache...');
-        await refreshAuthCache();
-        console.log('Auth cache refreshed');
+  }
+  return recovered;
+}
+async function cleanupOldTasks(taskDir, maxAgeMs = 30 * 24 * 60 * 6e4, logger = nullLogger) {
+  const now = Date.now();
+  let cleaned = 0;
+  for (const subdir of ["completed", "failed"]) {
+    const dir = path5.join(taskDir, subdir);
+    let files;
+    try {
+      files = await fs3.readdir(dir);
+    } catch {
+      continue;
     }
-    // Process task queue (if any pending tasks)
-    const { dequeueTask, completeTask } = await import('../worker/task-queue');
-    let taskCount = 0;
-    let task;
-    while ((task = await dequeueTask(taskDir)) !== null) {
-        console.log(`Processing task: ${task.action} (${task.id})`);
-        // In prod-sim without GitHub, just mark tasks as completed
-        // A real worker would execute the GitHub operations
-        console.warn(`  WARNING: Task skipped — GitHub operations require the full worker daemon`);
-        await completeTask(taskDir, task.id, { skipped: true });
-        taskCount++;
+    for (const fileName of files.filter((f) => f.endsWith(".json"))) {
+      try {
+        const filePath = path5.join(dir, fileName);
+        const stat = await fs3.stat(filePath);
+        if (now - stat.mtimeMs >= maxAgeMs) {
+          await fs3.unlink(filePath);
+          cleaned++;
+        }
+      } catch {
+      }
     }
-    if (taskCount > 0) {
-        console.log(`Processed ${taskCount} task(s)`);
+  }
+  if (cleaned > 0) {
+    logger.debug("Cleaned up old tasks", { cleaned });
+  }
+  return cleaned;
+}
+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");
+      return parseTaskJson(content);
+    } catch {
+      continue;
     }
-    else {
-        console.log('No pending tasks');
+  }
+  return null;
+}
+async function listTasks(taskDir, status, limit = 100) {
+  const dir = path5.join(taskDir, status);
+  let files;
+  try {
+    files = await fs3.readdir(dir);
+  } catch {
+    return [];
+  }
+  const tasks = [];
+  for (const fileName of files.filter((f) => f.endsWith(".json"))) {
+    if (tasks.length >= limit)
+      break;
+    try {
+      const content = await fs3.readFile(path5.join(dir, fileName), "utf-8");
+      const task = parseTaskJson(content);
+      if (task)
+        tasks.push(task);
+    } catch {
+      continue;
     }
-    console.log('\nDone');
+  }
+  tasks.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+  return tasks;
 }
-/** Parse CLI flags from argv, returning values and remaining positional args. */
-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);
-            // Boolean flags
-            if (key === 'force' || key === 'non-interactive' || key === 'no-ai') {
-                flags[key] = true;
+async function getQueueStats(taskDir) {
+  const stats = {
+    pending: 0,
+    processing: 0,
+    completed: 0,
+    failed: 0,
+    corrupt: 0
+  };
+  for (const status of ["pending", "processing", "completed", "failed", "corrupt"]) {
+    const dir = path5.join(taskDir, status);
+    try {
+      const files = await fs3.readdir(dir);
+      stats[status] = files.filter((f) => f.endsWith(".json")).length;
+    } catch {
+    }
+  }
+  return stats;
+}
+function parseTaskJson(content) {
+  try {
+    const parsed = JSON.parse(content);
+    if (typeof parsed.id !== "string" || typeof parsed.action !== "string") {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+async function taskExistsIn(taskDir, taskId, subdirs) {
+  for (const subdir of subdirs) {
+    try {
+      await fs3.stat(path5.join(taskDir, subdir, `${taskId}.json`));
+      return true;
+    } catch {
+    }
+  }
+  return false;
+}
+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));
+    logger.debug("Moved corrupt task file", { fileName, reason });
+  } catch {
+    await fs3.unlink(path5.join(sourceDir, fileName)).catch(() => {
+    });
+  }
+}
+var DEFAULT_MAX_RETRIES, nullLogger;
+var init_task_queue = __esm({
+  "dist/task-queue/task-queue.js"() {
+    "use strict";
+    init_atomic_write();
+    DEFAULT_MAX_RETRIES = 3;
+    nullLogger = { debug: () => {
+    } };
+  }
+});
+
+// dist/task-queue/index.js
+var init_task_queue2 = __esm({
+  "dist/task-queue/index.js"() {
+    "use strict";
+    init_task_queue();
+  }
+});
+
+// dist/worker/task-queue.js
+var task_queue_exports = {};
+__export(task_queue_exports, {
+  cleanupOldTasks: () => cleanupOldTasks,
+  cmsTaskQueueLogger: () => cmsTaskQueueLogger,
+  completeTask: () => completeTask,
+  dequeueTask: () => dequeueTask,
+  enqueueTask: () => enqueueTask,
+  failTask: () => failTask,
+  getQueueStats: () => getQueueStats,
+  getTask: () => getTask,
+  getTaskResult: () => getTask,
+  listTasks: () => listTasks,
+  recoverOrphanedTasks: () => recoverOrphanedTasks,
+  retryTask: () => retryTask
+});
+var debugLogger, cmsTaskQueueLogger;
+var init_task_queue3 = __esm({
+  "dist/worker/task-queue.js"() {
+    "use strict";
+    init_debug();
+    init_task_queue2();
+    debugLogger = createDebugLogger({ prefix: "TaskQueue" });
+    cmsTaskQueueLogger = {
+      debug(message, data) {
+        debugLogger.debug("task", message, data);
+      }
+    };
+  }
+});
+
+// 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/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/utils/error.js
+function getErrorMessage(err) {
+  if (err instanceof Error) {
+    return err.message;
+  }
+  if (typeof err === "string") {
+    return err;
+  }
+  return String(err);
+}
+function isNodeError(err) {
+  return err instanceof Error && "code" in err;
+}
+function 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";
+  }
+});
+
+// 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;
+  }
+  const parts = filename.split(".");
+  if (parts.length >= 3) {
+    const candidate = parts[parts.length - 2];
+    if (isValidId(candidate))
+      return candidate;
+  }
+  if (parts.length === 2) {
+    const candidate = parts[parts.length - 1];
+    if (isValidId(candidate))
+      return candidate;
+  }
+  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;
+    }
+  }
+  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];
+    }
+  }
+  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(".");
+    }
+  }
+  if (parts.length === 2) {
+    const possibleId = parts[parts.length - 1];
+    if (isValidId(possibleId)) {
+      return parts[0];
+    }
+  }
+  if (parts.length > 1) {
+    return parts.slice(0, -1).join(".");
+  }
+  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;
             }
-            else if (i + 1 < args.length && !args[i + 1].startsWith('--')) {
-                flags[key] = args[++i];
+            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;
+          }
         }
-        else {
-            positional.push(arg);
+      }
+      /**
+       * 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 [];
         }
-    }
-    return { flags, positional };
+        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";
+    };
+  }
+});
+
+// dist/paths/normalize-server.js
+var init_normalize_server = __esm({
+  "dist/paths/normalize-server.js"() {
+    "use strict";
+  }
+});
+
+// dist/paths/resolve.js
+var init_resolve = __esm({
+  "dist/paths/resolve.js"() {
+    "use strict";
+  }
+});
+
+// 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";
 }
-// CLI entrypoint
-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',
+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");
+  }
+  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);
+    };
+  }
+});
+
+// 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.");
+  }
+  if (slug.includes("\\")) {
+    throw new ContentStoreError("Slugs cannot contain backslashes. Use nested collections instead.");
+  }
+}
+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 (p.isCancel(result)) {
-                p.cancel('Init cancelled.');
-                process.exit(0);
+            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();
             }
-            mode = result;
+            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
+          };
         }
-        let appDir;
-        if (typeof flags['app-dir'] === 'string') {
-            appDir = flags['app-dir'];
+        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");
         }
-        else if (nonInteractive) {
-            appDir = 'app';
+        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
+          };
         }
-        else {
-            const result = await p.text({
-                message: 'App directory?',
-                placeholder: 'app',
-                defaultValue: 'app',
-            });
-            if (p.isCancel(result)) {
-                p.cancel('Init cancelled.');
-                process.exit(0);
+        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`);
             }
-            appDir = result;
+          } else {
+            entryTypeConfig = getDefaultEntryType(schemaItem.entries);
+          }
+          expectedFormat = entryTypeConfig?.format || "json";
         }
-        let ai;
-        if (flags['no-ai'] === true) {
-            ai = false;
+        if (expectedFormat !== input.format) {
+          throw new ContentStoreError(`Format mismatch: expects ${expectedFormat}, got ${input.format}`);
         }
-        else if (nonInteractive) {
-            ai = true;
+        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
+          };
         }
-        else {
-            const result = await p.confirm({
-                message: 'Include AI content endpoint?',
-                initialValue: true,
+        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
             });
-            if (p.isCancel(result)) {
-                p.cancel('Init cancelled.');
-                process.exit(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}"`);
             }
-            ai = result;
-        }
-        await init({
-            mode,
-            appDir,
-            ai,
-            projectDir: process.cwd(),
-            force,
-            nonInteractive,
+          }
+        } 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`);
     }
-    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,
+  }
+  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(", ")}`);
+    }
+    return {
+      name: entryType.name,
+      label: entryType.label,
+      format: entryType.format,
+      schema: resolvedSchema,
+      schemaRef: entryType.schema,
+      default: entryType.default,
+      maxItems: entryType.maxItems
+    };
+  });
+}
+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
         });
+      }
     }
-    else if (command === 'worker') {
-        const subcommand = positional[1];
-        if (subcommand !== 'run-once') {
-            console.error('Usage: canopycms worker run-once');
-            process.exit(1);
+  }
+  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)
+    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;
+  }
+  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;
+  }
+  if (filter.where) {
+    if (!filter.where(entry))
+      return false;
+  }
+  return true;
+}
+var init_generate = __esm({
+  "dist/ai/generate.js"() {
+    "use strict";
+    init_content_id_index();
+    init_error();
+    init_json_to_markdown();
+  }
+});
+
+// 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;
+          }
         }
-        // Resolve auth plugin from the adopter's installed packages.
-        // Uses variable-based import() so TypeScript doesn't resolve against canopycms's own deps.
-        const authMode = process.env.CANOPY_AUTH_MODE || 'dev';
-        let authPlugin;
+      }
+      /**
+       * 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 {
-            if (authMode === 'clerk') {
-                const pkg = 'canopycms-auth-clerk';
-                const { createClerkAuthPlugin } = await import(pkg);
-                authPlugin = createClerkAuthPlugin({});
+          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
+              });
             }
-            else if (authMode === 'dev') {
-                const pkg = 'canopycms-auth-dev';
-                const { createDevAuthPlugin } = await import(pkg);
-                authPlugin = createDevAuthPlugin();
+          }
+        } catch (err) {
+          if (isNotFoundError2(err)) {
+            return [];
+          }
+          throw err;
+        }
+        return branches;
+      }
+    };
+  }
+});
+
+// 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 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;
+          }
         }
-        catch {
-            console.warn(`Could not load auth plugin for mode "${authMode}" — skipping cache refresh`);
+        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;
         }
-        await workerRunOnce({ projectDir: process.cwd(), authPlugin });
+        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/ai/resolve-branch.js
+async function resolveBranchRoot(config) {
+  if (config.mode === "dev") {
+    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;
+}
+var init_resolve_branch = __esm({
+  "dist/ai/resolve-branch.js"() {
+    "use strict";
+    init_branch_metadata();
+  }
+});
+
+// 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}`);
     }
-    else if (command === 'generate-ai-content') {
-        const { generateAIContentCLI } = await import('./generate-ai-content');
-        await generateAIContentCLI({
-            projectDir: process.cwd(),
-            outputDir: typeof flags['output'] === 'string' ? flags['output'] : undefined,
-            configPath: typeof flags['config'] === 'string' ? flags['config'] : undefined,
-            appDir: typeof flags['app-dir'] === 'string' ? flags['app-dir'] : undefined,
-        });
+    await fs10.mkdir(path13.dirname(absolutePath), { recursive: true });
+    await fs10.writeFile(absolutePath, content, "utf-8");
+    fileCount++;
+  }
+  return { fileCount, outputDir: absoluteOutputDir };
+}
+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";
+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;
+  try {
+    canopyConfigModule = await import(canopyConfigPath);
+  } 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 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 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 (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 init_generate_ai_content2 = __esm({
+  "dist/cli/generate-ai-content.js"() {
+    "use strict";
+    init_generate_ai_content();
+    init_error();
+  }
+});
+
+// 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)) {
+    if (options.force) {
+    } else if (options.nonInteractive) {
+      p.log.warn(`skip: ${relativePath} (already exists)`);
+      return false;
+    } else {
+      const overwrite = await p.confirm({
+        message: `${relativePath} already exists. Overwrite?`,
+        initialValue: false
+      });
+      if (p.isCancel(overwrite) || !overwrite) {
+        p.log.warn(`skip: ${relativePath}`);
+        return false;
+      }
+    }
+  }
+  await fs11.mkdir(path15.dirname(filePath), { recursive: true });
+  await fs11.writeFile(filePath, content, "utf-8");
+  p.log.success(`created: ${relativePath}`);
+  return true;
+}
+function configImportPath(appDir, subdirs) {
+  const appDepth = appDir.split("/").filter(Boolean).length;
+  const totalDepth = appDepth + subdirs;
+  return "../".repeat(totalDepth) + "canopycms.config";
+}
+async function init(options) {
+  const { projectDir, mode, appDir, ai, force, nonInteractive } = 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({
+    canopyImport: "../".repeat(3) + "lib/canopy"
+  }), writeOpts);
+  await writeFile(path15.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");
+      p.log.success("updated: .gitignore");
+    }
+  }
+  p.note([
+    "1. Install dependencies:",
+    `   npm install canopycms canopycms-next canopycms-auth-clerk canopycms-auth-dev`,
+    "",
+    "2. Wrap your Next.js config:",
+    "   import { withCanopy } from 'canopycms-next'",
+    "   export default withCanopy({ /* your config */ })",
+    "",
+    "3. Customize " + appDir + "/schemas.ts with your content schema",
+    "",
+    "4. Run: npm run dev",
+    "5. Visit: http://localhost:3000/edit"
+  ].join("\n"), "Next steps");
+  p.outro("Done!");
+}
+async function initDeployAws(options) {
+  const { projectDir, force, nonInteractive } = 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;
+  if (configPath) {
+    const content = await fs11.readFile(configPath, "utf-8");
+    if (!content.includes("CANOPY_BUILD")) {
+      p.note([
+        `Add dual build support to ${path15.basename(configPath)}:`,
+        "",
+        "  output: process.env.CANOPY_BUILD === 'cms' ? 'standalone' : 'export',"
+      ].join("\n"), "Manual step");
+    }
+  }
+  p.note("CDK constructs are available via the canopycms-cdk package.\nSee the deployment plan for CDK stack setup.", "AWS deployment");
+  p.outro("Done!");
+}
+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";
+  try {
+    const configContent = await fs11.readFile(cfgPath, "utf-8");
+    if (/^\s*mode:\s*['"]prod['"]\s*[,}]/m.test(configContent)) {
+      mode = "prod";
     }
-    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)');
+  } 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");
+  let refreshAuthCache;
+  const authMode = process.env.CANOPY_AUTH_MODE || "dev";
+  if (options.authPlugin?.createCacheRefresher) {
+    const refresher = options.authPlugin.createCacheRefresher(cachePath);
+    if (refresher) {
+      refreshAuthCache = async () => {
+        const result = await refresher();
+        console.log(`  ${result.userCount} users, ${result.groupCount} groups`);
+      };
+    }
+  }
+  console.log(`
+CanopyCMS worker run-once (mode: ${mode}, auth: ${authMode})
+`);
+  if (refreshAuthCache) {
+    console.log("Refreshing auth cache...");
+    await refreshAuthCache();
+    console.log("Auth cache refreshed");
+  }
+  const { dequeueTask: dequeueTask2, completeTask: completeTask2 } = await Promise.resolve().then(() => (init_task_queue3(), task_queue_exports));
+  let taskCount = 0;
+  let task;
+  while ((task = await dequeueTask2(taskDir)) !== null) {
+    console.log(`Processing task: ${task.action} (${task.id})`);
+    console.warn(`  WARNING: Task skipped \u2014 GitHub operations require the full worker daemon`);
+    await completeTask2(taskDir, task.id, { skipped: true });
+    taskCount++;
+  }
+  if (taskCount > 0) {
+    console.log(`Processed ${taskCount} task(s)`);
+  } else {
+    console.log("No pending tasks");
+  }
+  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);
+  }
 }
-// Only run when executed directly as a CLI, not when imported in tests.
-// Use realpathSync to resolve symlinks — npx creates a symlink in node_modules/.bin/
-// that won't match import.meta.url's resolved real path.
-const __filename = fileURLToPath(import.meta.url);
-const isDirectRun = realpathSync(process.argv[1]) === realpathSync(__filename);
+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);
-    });
+  main().catch((err) => {
+    console.error("Error:", err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  });
 }
-//# sourceMappingURL=init.js.map
+export {
+  init,
+  initDeployAws,
+  workerRunOnce
+};