canopycms 0.0.6 → 0.0.8

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

@@ -1,78 +1,2704 @@
-/**
- * CLI command: npx canopycms generate-ai-content
- *
- * Generates static AI-ready content files from CanopyCMS content.
- */
-import path from 'node:path';
-import { generateAIContentFiles } from '../build/generate-ai-content';
-import { getErrorMessage } from '../utils/error';
-export async function generateAIContentCLI(options) {
-    const { projectDir, outputDir = 'public/ai', configPath, appDir = 'app' } = options;
-    console.log('\nCanopyCMS generate-ai-content\n');
-    // Load adopter's canopycms config
-    const canopyConfigPath = path.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);
-    }
-    // Extract the server config (defineCanopyConfig returns { server, client })
-    const configExport = canopyConfigModule.default ?? canopyConfigModule.config ?? canopyConfigModule;
-    const serverConfig = typeof configExport === 'object' && configExport !== null && 'server' in configExport
-        ? configExport.server
-        : configExport;
-    // Load entry schema registry
-    const schemasPath = path.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`);
-    }
-    // Load AI config if specified
-    let aiConfig;
-    if (configPath) {
-        try {
-            const aiConfigModule = (await import(path.resolve(configPath)));
-            aiConfig = aiConfigModule.aiContentConfig ?? aiConfigModule.default ?? aiConfigModule.config;
-        }
-        catch (err) {
-            console.error(`Could not load AI config from ${configPath}`);
-            console.error(getErrorMessage(err));
-            process.exit(1);
-        }
-    }
-    // Validate AI config shape if provided
-    if (aiConfig !== undefined && (typeof aiConfig !== 'object' || aiConfig === null)) {
-        console.error('Invalid AI content config: expected an object.');
-        process.exit(1);
-    }
-    // Validate loaded config has required shape
-    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 = path.resolve(projectDir, outputDir);
-    console.log(`  Output: ${resolvedOutput}`);
-    console.log(`  Mode: ${serverConfig.mode ?? 'dev'}`);
-    const result = await generateAIContentFiles({
-        config: serverConfig,
-        entrySchemaRegistry: entrySchemaRegistry,
-        outputDir: resolvedOutput,
-        aiConfig: aiConfig,
+// dist/cli/generate-ai-content.js
+import path11 from "node:path";
+
+// dist/build/generate-ai-content.js
+import fs8 from "node:fs/promises";
+import path10 from "node:path";
+
+// dist/content-store.js
+import fs3 from "node:fs/promises";
+import path5 from "node:path";
+import matter from "gray-matter";
+
+// dist/utils/atomic-write.js
+import fs from "node:fs/promises";
+import path from "node:path";
+async function atomicWriteFile(filePath, content) {
+  const dir = path.dirname(filePath);
+  await fs.mkdir(dir, { recursive: true });
+  const tempPath = `${filePath}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`;
+  await fs.writeFile(tempPath, content, "utf-8");
+  try {
+    await fs.rename(tempPath, filePath);
+  } catch (err) {
+    await fs.unlink(tempPath).catch(() => {
     });
-    console.log(`\n  Generated ${result.fileCount} files`);
-    console.log(`  Output: ${result.outputDir}\n`);
+    throw err;
+  }
 }
-//# sourceMappingURL=generate-ai-content.js.map
+
+// dist/content-id-index.js
+import fs2 from "node:fs/promises";
+import path2 from "node:path";
+
+// dist/id.js
+import { generate } from "short-uuid";
+
+// dist/paths/normalize.js
+function normalizeFilesystemPath(path12) {
+  return path12.split(/[\\/]+/).filter(Boolean).join("/");
+}
+function hasTraversalSequence(path12) {
+  const normalized = normalizeFilesystemPath(path12);
+  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;
+}
+
+// dist/paths/validation.js
+var BASE58_PATTERN = "[123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz]";
+var CONTENT_ID_PATTERN = new RegExp(`^${BASE58_PATTERN}{12}$`);
+var PHYSICAL_SEGMENT_PATTERN = new RegExp(`\\.${BASE58_PATTERN}{12}(?:\\.[a-z]+)?$`);
+function isValidContentId(id) {
+  return CONTENT_ID_PATTERN.test(id);
+}
+
+// dist/id.js
+function generateId() {
+  const full = generate();
+  return full.substring(0, 12);
+}
+var isValidId = isValidContentId;
+
+// dist/utils/error.js
+function getErrorMessage(err) {
+  if (err instanceof Error) {
+    return err.message;
+  }
+  if (typeof err === "string") {
+    return err;
+  }
+  return String(err);
+}
+function isNodeError(err) {
+  return err instanceof Error && "code" in err;
+}
+function isNotFoundError(err) {
+  return isNodeError(err) && err.code === "ENOENT";
+}
+function isFileExistsError(err) {
+  return isNodeError(err) && err.code === "EEXIST";
+}
+
+// dist/content-id-index.js
+var EMPTY_LOGICAL_PATH = "";
+function toLogicalCollectionPath(physicalPath) {
+  if (physicalPath === ".")
+    return EMPTY_LOGICAL_PATH;
+  return physicalPath.split("/").map((seg) => extractSlugFromFilename(seg)).join("/");
+}
+var ContentIdIndex = class {
+  constructor(root) {
+    this.idToLocation = /* @__PURE__ */ new Map();
+    this.pathToId = /* @__PURE__ */ new Map();
+    this.byCollection = /* @__PURE__ */ new Map();
+    this.root = path2.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 = path2.join(this.root, relativePath);
+    try {
+      const entries = await fs2.readdir(absoluteDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.name.startsWith(".") || entry.name === "_ids_") {
+          continue;
+        }
+        const fullRelativePath = path2.join(relativePath, entry.name);
+        const 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 = path2.dirname(fullRelativePath);
+            const collectionPath = toLogicalCollectionPath(physicalCollection);
+            location.slug = slug;
+            location.collection = collectionPath;
+            if (!this.byCollection.has(collectionPath)) {
+              this.byCollection.set(collectionPath, /* @__PURE__ */ new Set());
+            }
+            this.byCollection.get(collectionPath).add(id);
+          }
+          this.idToLocation.set(id, location);
+          this.pathToId.set(fullRelativePath, id);
+        }
+        if (entry.isDirectory()) {
+          await this.scanDirectory(fullRelativePath);
+        }
+      }
+    } catch (err) {
+      if (err.code !== "ENOENT") {
+        throw err;
+      }
+    }
+  }
+  /**
+   * Forward lookup: ID → location (O(1))
+   */
+  findById(id) {
+    return this.idToLocation.get(id) || null;
+  }
+  /**
+   * Reverse lookup: path → ID (O(1))
+   */
+  findByPath(relativePath) {
+    return this.pathToId.get(relativePath) || null;
+  }
+  /**
+   * Get all ID locations in the index.
+   * Useful for validation and checking references.
+   */
+  getAllLocations() {
+    return Array.from(this.idToLocation.values());
+  }
+  /**
+   * Get all entries in a collection by collection path.
+   *
+   * Performance: O(1) + O(m) where m is the number of entries in the collection.
+   *
+   * @param collectionPath - The collection path (e.g., "content/posts")
+   * @returns Array of IdLocation objects for entries in the collection
+   */
+  getEntriesInCollection(collectionPath) {
+    const idSet = this.byCollection.get(collectionPath);
+    if (!idSet) {
+      return [];
+    }
+    const locations = [];
+    for (const id of idSet) {
+      const location = this.idToLocation.get(id);
+      if (location) {
+        locations.push(location);
+      }
+    }
+    return locations;
+  }
+  /**
+   * Add a new entry or collection to the index.
+   * Note: This only updates the in-memory index. The file with embedded ID
+   * must already exist on disk (created by ContentStore).
+   */
+  add(location) {
+    const id = extractIdFromFilename(path2.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(path2.basename(newRelativePath));
+      const physicalCollection = path2.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);
+  }
+};
+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 fs9 = await import("node:fs/promises");
+  const path12 = await import("node:path");
+  const segments = logicalPath.split("/").filter(Boolean);
+  let currentPath = root;
+  for (const segment of segments) {
+    try {
+      const entries = await fs9.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 = path12.join(currentPath, matchingDir.name);
+      } else {
+        return null;
+      }
+    } catch (err) {
+      if (isNotFoundError(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;
+}
+
+// dist/utils/format.js
+var getFormatExtension = (format) => {
+  if (format === "md")
+    return ".md";
+  if (format === "mdx")
+    return ".mdx";
+  return ".json";
+};
+
+// dist/paths/branch.js
+import path4 from "node:path";
+
+// dist/operating-mode/client-safe-strategy.js
+var 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;
+  }
+};
+var 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;
+  }
+};
+var 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/operating-mode/client-unsafe-strategy.js
+import path3 from "node:path";
+
+// dist/config/types.js
+var primitiveFieldTypes = [
+  "string",
+  "number",
+  "boolean",
+  "datetime",
+  "rich-text",
+  "markdown",
+  "mdx",
+  "image",
+  "code"
+];
+var fieldTypes = [
+  ...primitiveFieldTypes,
+  "select",
+  "reference",
+  "object",
+  "block"
+];
+
+// dist/config/schemas/config.js
+import { z as z4 } from "zod";
+
+// dist/config/schemas/collection.js
+import { z as z2 } from "zod";
+import { isAbsolute } from "pathe";
+
+// dist/config/schemas/field.js
+import { z } from "zod";
+var fieldBaseSchema = z.object({
+  name: z.string().min(1),
+  label: z.string().optional(),
+  description: z.string().optional(),
+  required: z.boolean().optional(),
+  list: z.boolean().optional()
+});
+var selectOptionSchema = z.union([
+  z.string(),
+  z.object({
+    label: z.string().min(1),
+    value: z.string().min(1)
+  })
+]);
+var referenceOptionSchema = z.union([
+  z.string(),
+  z.object({
+    label: z.string().min(1),
+    value: z.string().min(1)
+  })
+]);
+var primitiveFieldSchema = fieldBaseSchema.extend({
+  type: z.enum(primitiveFieldTypes)
+});
+var selectFieldSchema = fieldBaseSchema.extend({
+  type: z.literal("select"),
+  options: z.array(selectOptionSchema).min(1)
+});
+var 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()
+});
+var fieldHolder = [z.never()];
+var 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)
+});
+var blockFieldSchema = fieldBaseSchema.extend({
+  type: z.literal("block"),
+  templates: z.array(blockSchema).min(1)
+});
+var objectFieldSchema = fieldBaseSchema.extend({
+  type: z.literal("object"),
+  fields: z.array(z.lazy(() => fieldHolder[0])).min(1)
+});
+var 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());
+var knownFieldSchema = z.discriminatedUnion("type", [
+  primitiveFieldSchema,
+  selectFieldSchema,
+  referenceFieldSchema,
+  objectFieldSchema,
+  blockFieldSchema
+]);
+var fieldSchema = z.lazy(() => z.union([knownFieldSchema, customFieldSchema]));
+fieldHolder[0] = fieldSchema;
+
+// dist/config/schemas/collection.js
+var 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("/"));
+var 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()
+});
+var 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"
+}));
+var 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 = 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
+var defaultBranchAccessSchema = z4.enum(["allow", "deny"]).default("deny");
+var defaultPathAccessSchema = z4.enum(["allow", "deny"]).default("deny");
+var defaultBaseBranchSchema = z4.string().default("main");
+var defaultRemoteNameSchema = z4.string().default("origin");
+var defaultRemoteUrlSchema = z4.string().min(1);
+var gitBotAuthorNameSchema = z4.string().min(1);
+var gitBotAuthorEmailSchema = z4.string().email();
+var githubTokenEnvVarSchema = z4.string().default("GITHUB_BOT_TOKEN");
+var operatingModeSchema = z4.enum(["prod", "prod-sim", "dev"]).default("dev");
+var deployedAsSchema = z4.enum(["static", "server"]).default("server");
+var contentRootSchema = relativePathSchema.default("content");
+var sourceRootSchema = z4.string().min(1).optional();
+var deploymentNameSchema = z4.string().default("prod");
+var 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()
+});
+var 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()
+});
+var DEFAULT_PROD_WORKSPACE = "/mnt/efs/workspace";
+
+// dist/config/schemas/permissions.js
+import { z as z5 } from "zod";
+var permissionTargetSchema = z5.object({
+  allowedUsers: z5.array(z5.string()).optional(),
+  allowedGroups: z5.array(z5.string()).optional()
+});
+var pathPermissionSchema = z5.object({
+  path: z5.string().min(1),
+  read: permissionTargetSchema.optional(),
+  edit: permissionTargetSchema.optional(),
+  review: permissionTargetSchema.optional()
+});
+
+// dist/config/flatten.js
+import { join, normalize } from "pathe";
+
+// dist/paths/types.js
+var ROOT_COLLECTION_ID = "__rootcoll__";
+
+// dist/config/flatten.js
+var normalizePathValue = (val) => normalize(val).split("/").filter(Boolean).join("/");
+var 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/operating-mode/client-unsafe-strategy.js
+var ProdStrategy = class extends ProdClientSafeStrategy {
+  // All client-safe methods inherited automatically from ProdClientSafeStrategy:
+  // - mode, supportsBranching(), supportsStatusBadge(), supportsComments()
+  // - supportsPullRequests(), getPermissionsFileName(), getGroupsFileName()
+  // - shouldCommit(), shouldPush()
+  // Add client-unsafe methods (use Node.js APIs)
+  getWorkspaceRoot(_sourceRoot) {
+    return path3.resolve(process.env.CANOPYCMS_WORKSPACE_ROOT ?? DEFAULT_PROD_WORKSPACE);
+  }
+  getContentRoot(sourceRoot) {
+    return path3.resolve(sourceRoot ?? process.cwd(), "content");
+  }
+  getContentBranchesRoot(sourceRoot) {
+    return path3.join(this.getWorkspaceRoot(sourceRoot), "content-branches");
+  }
+  getContentBranchRoot(branchName, sourceRoot) {
+    return path3.resolve(this.getContentBranchesRoot(sourceRoot), branchName);
+  }
+  getGitExcludePattern() {
+    return ".canopy-meta/";
+  }
+  getPermissionsFilePath(root) {
+    return path3.join(root, this.getPermissionsFileName());
+  }
+  getGroupsFilePath(root) {
+    return path3.join(root, this.getGroupsFileName());
+  }
+  getRemoteUrlConfig() {
+    return {
+      shouldAutoInitLocal: false,
+      defaultRemotePath: "",
+      envVarName: "CANOPYCMS_REMOTE_URL",
+      autoDetectRemotePath: path3.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 path3.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;
+  }
+};
+var LocalProdSimStrategy = class extends LocalProdSimClientSafeStrategy {
+  // Inherits client-safe methods from LocalProdSimClientSafeStrategy
+  getWorkspaceRoot(sourceRoot) {
+    return path3.resolve(sourceRoot ?? process.cwd(), ".canopy-prod-sim");
+  }
+  getContentRoot(sourceRoot) {
+    return path3.resolve(sourceRoot ?? process.cwd(), "content");
+  }
+  getContentBranchesRoot(sourceRoot) {
+    return path3.join(this.getWorkspaceRoot(sourceRoot), "content-branches");
+  }
+  getContentBranchRoot(branchName, sourceRoot) {
+    return path3.resolve(this.getContentBranchesRoot(sourceRoot), branchName);
+  }
+  getGitExcludePattern() {
+    return ".canopy-meta/";
+  }
+  getPermissionsFilePath(root) {
+    return path3.join(root, this.getPermissionsFileName());
+  }
+  getGroupsFilePath(root) {
+    return path3.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 path3.join(this.getWorkspaceRoot(sourceRoot), "settings");
+  }
+  usesSeparateSettingsBranch() {
+    return true;
+  }
+  validateConfig(_config) {
+  }
+  shouldCreateSettingsPR(_config) {
+    return false;
+  }
+};
+var LocalSimpleStrategy = class extends LocalSimpleClientSafeStrategy {
+  // Inherits: supportsBranching() returns false, getPermissionsFileName() returns 'permissions.local.json'
+  getWorkspaceRoot(sourceRoot) {
+    return path3.resolve(sourceRoot ?? process.cwd(), ".canopy-dev");
+  }
+  getContentRoot(sourceRoot) {
+    return path3.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 path3.join(this.getWorkspaceRoot(root), "settings", "permissions.json");
+  }
+  getGroupsFilePath(root) {
+    return path3.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 path3.join(this.getWorkspaceRoot(sourceRoot), "settings");
+  }
+  usesSeparateSettingsBranch() {
+    return false;
+  }
+  validateConfig(_config) {
+  }
+  shouldCreateSettingsPR(_config) {
+    return false;
+  }
+};
+var strategyCache = /* @__PURE__ */ new Map();
+function operatingStrategy(mode) {
+  const cached = strategyCache.get(mode);
+  if (cached)
+    return cached;
+  let strategy;
+  switch (mode) {
+    case "prod":
+      strategy = new ProdStrategy();
+      break;
+    case "prod-sim":
+      strategy = new LocalProdSimStrategy();
+      break;
+    case "dev":
+      strategy = new LocalSimpleStrategy();
+      break;
+    default: {
+      const _exhaustive = mode;
+      throw new Error(`Unknown operating mode: ${_exhaustive}`);
+    }
+  }
+  strategyCache.set(mode, strategy);
+  return strategy;
+}
+
+// dist/paths/branch.js
+var BranchPathError = class extends Error {
+};
+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";
+}
+var resolveContentBranchesRoot = (mode, override) => {
+  return operatingStrategy(mode).getContentBranchesRoot(override);
+};
+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 = path4.resolve(baseRoot);
+  const baseWithSep = normalizedBase.endsWith(path4.sep) ? normalizedBase : `${normalizedBase}${path4.sep}`;
+  const branchRoot = strategy.getContentBranchRoot(safeBranch, options.basePathOverride);
+  const withinBase = (target) => {
+    const resolved = path4.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 };
+}
+
+// dist/content-store.js
+var ContentStoreError = class extends Error {
+};
+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 ContentStore = class {
+  constructor(root, flatSchema) {
+    this.indexLoaded = false;
+    this.root = path5.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(path12) {
+    const normalized = normalizeFilesystemPath(path12);
+    const item = this.schemaIndex.get(normalized);
+    if (!item) {
+      throw new ContentStoreError(`Unknown schema item: ${path12}`);
+    }
+    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(path5.sep) ? this.root : `${this.root}${path5.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 = path5.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 fs3.readdir(collectionRoot, { withFileTypes: true }).catch(() => []);
+        const existingFile = entries.find((entry) => {
+          if (entry.isDirectory())
+            return false;
+          const fileEntryType = extractEntryTypeFromFilename(entry.name);
+          const existingSlug = extractSlugFromFilename(entry.name, fileEntryType || void 0);
+          return existingSlug === safeSlug;
+        });
+        if (existingFile) {
+          id = extractIdFromFilename(existingFile.name) || void 0;
+          existingFilename = existingFile.name;
+          existingEntryType = extractEntryTypeFromFilename(existingFile.name) || void 0;
+        }
+      }
+      const finalEntryTypeName = existingEntryType || entryTypeName;
+      let filename;
+      if (existingFilename && !id) {
+        filename = existingFilename;
+      } else {
+        if (!id) {
+          id = generateId();
+        }
+        filename = `${finalEntryTypeName}.${safeSlug}.${id}${ext}`;
+      }
+      const resolved = path5.resolve(collectionRoot, filename);
+      const collectionRootWithSep = collectionRoot.endsWith(path5.sep) ? collectionRoot : `${collectionRoot}${path5.sep}`;
+      if (!resolved.startsWith(collectionRootWithSep)) {
+        throw new ContentStoreError("Path traversal detected");
+      }
+      return {
+        absolutePath: resolved,
+        relativePath: path5.relative(this.root, resolved),
+        id
+      };
+    }
+    throw new ContentStoreError("Invalid schema item type");
+  }
+  /**
+   * Path resolution: resolves a URL path to a schema item
+   * - Try as collection + slug (last segment = slug)
+   */
+  resolvePath(pathSegments) {
+    if (pathSegments.length === 0) {
+      throw new ContentStoreError("Empty path");
+    }
+    const logicalPath = pathSegments.join("/");
+    const slug = pathSegments[pathSegments.length - 1];
+    const collectionPath = pathSegments.slice(0, -1).join("/");
+    const normalizedCollection = normalizeFilesystemPath(collectionPath);
+    const collection = this.schemaIndex.get(normalizedCollection);
+    if (collection?.type === "collection" && collection.entries) {
+      return {
+        schemaItem: collection,
+        slug
+      };
+    }
+    throw new ContentStoreError(`No schema item found for path: ${logicalPath}`);
+  }
+  async resolveDocumentPath(schemaPath, slug = "") {
+    const schemaItem = this.assertSchemaItem(schemaPath);
+    return await this.buildPaths(schemaItem, slug);
+  }
+  async read(collectionPath, slug = "", options = {}) {
+    const schemaItem = this.assertSchemaItem(collectionPath);
+    const { absolutePath, relativePath } = await this.buildPaths(schemaItem, slug);
+    const raw = await fs3.readFile(absolutePath, "utf8");
+    let doc;
+    let format;
+    let fields;
+    if (schemaItem.type === "entry-type") {
+      format = schemaItem.format;
+      fields = schemaItem.schema;
+    } else {
+      const defaultEntry = getDefaultEntryType(schemaItem.entries);
+      format = defaultEntry?.format || "json";
+      fields = defaultEntry?.schema || [];
+    }
+    if (format === "json") {
+      const data = JSON.parse(raw);
+      doc = {
+        collection: schemaItem.logicalPath,
+        collectionName: schemaItem.name,
+        format: "json",
+        data,
+        relativePath,
+        absolutePath
+      };
+    } else {
+      const parsed = matter(raw);
+      doc = {
+        collection: schemaItem.logicalPath,
+        collectionName: schemaItem.name,
+        format,
+        data: parsed.data ?? {},
+        body: parsed.content,
+        relativePath,
+        absolutePath
+      };
+    }
+    if (options.resolveReferences !== false) {
+      doc.data = await this.resolveReferencesInData(doc.data, fields);
+    }
+    return doc;
+  }
+  async write(collectionPath, slug = "", input, entryTypeName) {
+    const idIndex = await this.idIndex();
+    const schemaItem = this.assertSchemaItem(collectionPath);
+    let expectedFormat;
+    if (schemaItem.type === "entry-type") {
+      expectedFormat = schemaItem.format;
+    } else {
+      let entryTypeConfig;
+      if (entryTypeName) {
+        entryTypeConfig = schemaItem.entries?.find((e) => e.name === entryTypeName);
+        if (!entryTypeConfig) {
+          throw new ContentStoreError(`Entry type '${entryTypeName}' not found in collection`);
+        }
+      } else {
+        entryTypeConfig = getDefaultEntryType(schemaItem.entries);
+      }
+      expectedFormat = entryTypeConfig?.format || "json";
+    }
+    if (expectedFormat !== input.format) {
+      throw new ContentStoreError(`Format mismatch: expects ${expectedFormat}, got ${input.format}`);
+    }
+    const { absolutePath, relativePath, id } = await this.buildPaths(schemaItem, slug, {
+      entryTypeName
+    });
+    await fs3.mkdir(path5.dirname(absolutePath), { recursive: true });
+    if (input.format === "json") {
+      const json = JSON.stringify(input.data ?? {}, null, 2);
+      await atomicWriteFile(absolutePath, `${json}
+`);
+      if (id) {
+        const existing = idIndex.findById(id);
+        if (existing) {
+          if (existing.relativePath !== relativePath) {
+            idIndex.updatePath(existing.id, relativePath);
+          }
+        } else {
+          idIndex.add({
+            type: "entry",
+            relativePath,
+            collection: collectionPath,
+            slug: slug || void 0
+          });
+        }
+      }
+      return {
+        collection: schemaItem.logicalPath,
+        collectionName: schemaItem.name,
+        format: "json",
+        data: input.data ?? {},
+        relativePath,
+        absolutePath
+      };
+    }
+    const file = matter.stringify(input.body, input.data ?? {});
+    await atomicWriteFile(absolutePath, file);
+    if (id) {
+      const existing = idIndex.findById(id);
+      if (existing) {
+        if (existing.relativePath !== relativePath) {
+          idIndex.updatePath(existing.id, relativePath);
+        }
+      } else {
+        idIndex.add({
+          type: "entry",
+          relativePath,
+          collection: collectionPath,
+          slug: slug || void 0
+        });
+      }
+    }
+    return {
+      collection: schemaItem.logicalPath,
+      collectionName: schemaItem.name,
+      format: input.format,
+      data: input.data ?? {},
+      body: input.body,
+      relativePath,
+      absolutePath
+    };
+  }
+  /**
+   * Read an entry by its ID (UUID).
+   * Returns null if the ID doesn't exist or points to a collection.
+   */
+  async readById(id) {
+    const idIndex = await this.idIndex();
+    const location = idIndex.findById(id);
+    if (!location || location.type !== "entry")
+      return null;
+    return this.read(location.collection, location.slug);
+  }
+  /**
+   * Get the ID for an entry given its collection and slug.
+   * Returns null if no ID exists yet.
+   */
+  async getIdForEntry(collectionPath, slug) {
+    const idIndex = await this.idIndex();
+    const { relativePath } = await this.buildPaths(this.assertCollection(collectionPath), slug);
+    return idIndex.findByPath(relativePath);
+  }
+  /**
+   * Delete an entry and remove it from the index.
+   */
+  async delete(collectionPath, slug) {
+    const idIndex = await this.idIndex();
+    const collection = this.assertCollection(collectionPath);
+    const { absolutePath, relativePath } = await this.buildPaths(collection, slug);
+    const id = idIndex.findByPath(relativePath);
+    await fs3.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 fs3.access(currentPath);
+    } catch {
+      throw new ContentStoreError(`Entry not found: ${currentSlug}`);
+    }
+    if (currentSlug === safeNewSlug) {
+      return { newPath: `${collectionPath}/${currentSlug}` };
+    }
+    const currentFilename = path5.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 = path5.dirname(currentPath);
+    const newPath = path5.join(parentDir, newFilename);
+    try {
+      const entries = await fs3.readdir(parentDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory())
+          continue;
+        const existingSlug = extractSlugFromFilename(entry.name, entryTypeName);
+        if (existingSlug === safeNewSlug) {
+          throw new ContentStoreError(`Entry with slug "${safeNewSlug}" already exists in collection "${collectionPath}"`);
+        }
+      }
+    } catch (err) {
+      if (err instanceof ContentStoreError) {
+        throw err;
+      }
+    }
+    await fs3.rename(currentPath, newPath);
+    const newRelativePath = path5.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/branch-schema-cache.js
+import fs5 from "node:fs/promises";
+import path6 from "node:path";
+
+// dist/schema/meta-loader.js
+import { promises as fs4 } from "fs";
+import { join as join2 } from "pathe";
+import { z as z6 } from "zod";
+import chokidar from "chokidar";
+var 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()
+});
+var 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"
+});
+var rootCollectionMetaSchema = z6.object({
+  label: z6.string().optional(),
+  entries: z6.array(entryTypeMetaSchema).optional(),
+  order: z6.array(z6.string()).optional()
+  // Embedded IDs for ordering items
+});
+function stripEmbeddedIdFromName(name) {
+  return extractSlugFromFilename(name);
+}
+async function scanForCollectionMeta(baseDir, relativePath = "") {
+  const collections = [];
+  try {
+    const entries = await fs4.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 fs4.access(metaPath);
+        const content = await fs4.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 fs4.access(rootMetaPath);
+  } catch (err) {
+    if (err.code === "ENOENT") {
+    } else {
+      throw err;
+    }
+  }
+  try {
+    const content = await fs4.readFile(rootMetaPath, "utf-8");
+    const parsed = JSON.parse(content);
+    root = rootCollectionMetaSchema.parse(parsed);
+  } catch (err) {
+    const errno = err.code;
+    if (errno !== "ENOENT") {
+      throw new Error(`Invalid root .collection.json`);
+    }
+  }
+  const collections = await scanForCollectionMeta(contentRoot);
+  return { root, collections };
+}
+function resolveEntryTypes(entryTypes, entrySchemaRegistry, contextName) {
+  return entryTypes.map((entryType) => {
+    const resolvedSchema = entrySchemaRegistry[entryType.schema];
+    if (!resolvedSchema) {
+      throw new Error(`Schema reference "${entryType.schema}" in entry type "${entryType.name}" (${contextName}) not found in registry. Available schemas: ${Object.keys(entrySchemaRegistry).join(", ")}`);
+    }
+    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;
+}
+
+// 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;
+}
+
+// dist/branch-schema-cache.js
+var SCHEMA_CACHE_VERSION = 2;
+var 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 = path6.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 = path6.join(branchRoot, contentRootName);
+    const cacheDir = path6.join(branchRoot, ".canopy-meta");
+    const cachePath = path6.join(cacheDir, "schema-cache.json");
+    const stalePath = path6.join(cacheDir, "schema-cache.stale");
+    let cacheData = null;
+    try {
+      const staleExists = await fs5.access(stalePath).then(() => true).catch(() => false);
+      if (!staleExists) {
+        const cacheContent = await fs5.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 fs5.mkdir(cacheDir, { recursive: true });
+    const newCache = {
+      version: SCHEMA_CACHE_VERSION,
+      schema: result.schema,
+      flatSchema,
+      cachedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const tmpPath = path6.join(cacheDir, `schema-cache.tmp.${Date.now()}.${Math.random()}.json`);
+    await fs5.writeFile(tmpPath, JSON.stringify(newCache, null, 2), "utf-8");
+    await fs5.rename(tmpPath, cachePath);
+    try {
+      await fs5.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 = path6.join(branchRoot, ".canopy-meta");
+    const stalePath = path6.join(cacheDir, "schema-cache.stale");
+    await fs5.mkdir(cacheDir, { recursive: true });
+    await fs5.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/generate.js
+import path7 from "node:path";
+import { minimatch } from "minimatch";
+
+// 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;
+}
+
+// dist/ai/generate.js
+async function generateAIContent(options) {
+  const { store, flatSchema, contentRoot, config } = options;
+  const files = /* @__PURE__ */ new Map();
+  const collections = flatSchema.filter((item) => item.type === "collection");
+  const allEntries = [];
+  const manifestCollections = [];
+  const rootEntries = [];
+  for (const collection of collections) {
+    if (collection.logicalPath === contentRoot)
+      continue;
+    if (isCollectionExcluded(collection.logicalPath, contentRoot, config))
+      continue;
+    if (collection.parentPath && collection.parentPath !== contentRoot)
+      continue;
+    const collectionResult = await processCollection(store, collection, flatSchema, contentRoot, config);
+    allEntries.push(...collectionResult.entries);
+    for (const [filePath, content] of collectionResult.files) {
+      files.set(filePath, content);
+    }
+    manifestCollections.push(collectionResult.manifestCollection);
+  }
+  const rootCollection = collections.find((c) => c.logicalPath === contentRoot);
+  if (rootCollection?.entries) {
+    const rootResult = await processRootEntries(store, rootCollection, contentRoot, config);
+    allEntries.push(...rootResult.entries);
+    for (const [filePath, content] of rootResult.files) {
+      files.set(filePath, content);
+    }
+    rootEntries.push(...rootResult.manifestEntries);
+  }
+  const manifestBundles = [];
+  if (config?.bundles) {
+    for (const bundle of config.bundles) {
+      if (/[/\\]|\.\./.test(bundle.name)) {
+        throw new Error(`Invalid bundle name "${bundle.name}": must not contain slashes or ".."`);
+      }
+      const matchingEntries = allEntries.filter((entry) => matchesBundleFilter(entry, bundle.filter, contentRoot));
+      if (matchingEntries.length > 0) {
+        const bundleContent = matchingEntries.map((e) => entryToMarkdown(e, config)).join("\n---\n\n");
+        const bundlePath = `bundles/${bundle.name}.md`;
+        files.set(bundlePath, bundleContent);
+        manifestBundles.push({
+          name: bundle.name,
+          description: bundle.description,
+          file: bundlePath,
+          entryCount: matchingEntries.length
+        });
+      }
+    }
+  }
+  const manifest = {
+    generated: (/* @__PURE__ */ new Date()).toISOString(),
+    entries: rootEntries,
+    collections: manifestCollections,
+    bundles: manifestBundles
+  };
+  files.set("manifest.json", JSON.stringify(manifest, null, 2));
+  return { manifest, files };
+}
+async function processCollection(store, collection, flatSchema, contentRoot, config) {
+  const files = /* @__PURE__ */ new Map();
+  const entries = [];
+  const cleanPath = stripContentRoot(collection.logicalPath, contentRoot);
+  const manifestEntries = [];
+  const listed = await store.listCollectionEntries(collection.logicalPath);
+  const directEntries = listed.filter((e) => e.collection === collection.logicalPath);
+  for (const listEntry of directEntries) {
+    const entryTypeName = extractEntryTypeFromFilename(path7.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(path7.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;
+}
+
+// dist/branch-metadata.js
+import { randomUUID } from "node:crypto";
+import fs7 from "node:fs/promises";
+import path9 from "node:path";
+
+// dist/branch-registry.js
+import fs6 from "node:fs/promises";
+import path8 from "node:path";
+var REGISTRY_FILE = "branches.json";
+var REGISTRY_STALE_FILE = "branches.stale.json";
+var REGISTRY_TEMP_FILE = "branches.tmp.json";
+var REGISTRY_VERSION = 1;
+var BranchRegistry = class {
+  constructor(root) {
+    this.root = path8.resolve(root);
+    this.registryPath = path8.join(this.root, REGISTRY_FILE);
+    this.stalePath = path8.join(this.root, REGISTRY_STALE_FILE);
+    this.tempPath = path8.join(this.root, REGISTRY_TEMP_FILE);
+  }
+  /**
+   * Returns all branches. Uses cache if fresh, regenerates if stale.
+   */
+  async list() {
+    try {
+      const raw = await fs6.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 (isNotFoundError(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 fs6.rename(this.registryPath, this.stalePath);
+    } catch (err) {
+      if (!isNotFoundError(err)) {
+        throw err;
+      }
+    }
+  }
+  /**
+   * Scans branch directories and rebuilds the cache.
+   * Concurrent calls are safe - all produce identical content.
+   */
+  async regenerate() {
+    const branches = await this.scanBranchDirectories();
+    const uniqueTempPath = `${this.tempPath}.${Date.now()}.${Math.random().toString(36).slice(2)}`;
+    await fs6.mkdir(this.root, { recursive: true });
+    const snapshot = {
+      version: REGISTRY_VERSION,
+      branches
+    };
+    await fs6.writeFile(uniqueTempPath, JSON.stringify(snapshot, null, 2) + "\n", "utf8");
+    try {
+      await fs6.rename(uniqueTempPath, this.registryPath);
+    } catch (err) {
+      await fs6.unlink(uniqueTempPath).catch(() => {
+      });
+      throw err;
+    }
+    await fs6.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 fs6.readdir(this.root, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory() || entry.name.startsWith(".")) {
+          continue;
+        }
+        const branchRoot = path8.join(this.root, entry.name);
+        const meta = await BranchMetadataFileManager.loadOnly(branchRoot);
+        if (meta) {
+          branches.push({
+            branch: meta.branch,
+            branchRoot,
+            baseRoot: this.root
+          });
+        }
+      }
+    } catch (err) {
+      if (isNotFoundError(err)) {
+        return [];
+      }
+      throw err;
+    }
+    return branches;
+  }
+};
+
+// dist/branch-metadata.js
+var BRANCH_META_DIR = ".canopy-meta";
+var BRANCH_META_FILE = "branch.json";
+var CURRENT_SCHEMA_VERSION = 1;
+var BranchMetadataConflictError = class extends Error {
+  constructor() {
+    super("Concurrent modification detected in branch metadata");
+    this.name = "BranchMetadataConflictError";
+  }
+};
+var fileLocks = /* @__PURE__ */ new Map();
+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 BranchMetadataFileManager = class _BranchMetadataFileManager {
+  constructor(branchRoot, baseRoot) {
+    this.branchRoot = path9.resolve(branchRoot);
+    this.filePath = path9.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 = path9.join(path9.resolve(branchRoot), BRANCH_META_DIR, BRANCH_META_FILE);
+    try {
+      const raw = await fs7.readFile(filePath, "utf8");
+      return JSON.parse(raw);
+    } catch (err) {
+      if (isNotFoundError(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 fs7.readFile(this.filePath, "utf8");
+      const parsed = JSON.parse(raw);
+      const version = parsed.version ?? 0;
+      return { meta: parsed, version };
+    } catch (err) {
+      if (isNotFoundError(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 fs7.mkdir(path9.dirname(this.filePath), { recursive: true });
+    const content = JSON.stringify(payload, null, 2) + "\n";
+    if (expectedVersion === null) {
+      try {
+        await fs7.writeFile(this.filePath, content, { flag: "wx" });
+        return { version: newVersion, writeId };
+      } catch (err) {
+        if (isFileExistsError(err)) {
+          throw new BranchMetadataConflictError();
+        }
+        throw err;
+      }
+    }
+    const tempPath = `${this.filePath}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`;
+    await fs7.writeFile(tempPath, content, "utf-8");
+    try {
+      let currentVersion = null;
+      try {
+        const current = JSON.parse(await fs7.readFile(this.filePath, "utf-8"));
+        currentVersion = current.version ?? 0;
+      } catch {
+        currentVersion = null;
+      }
+      if (currentVersion !== expectedVersion) {
+        throw new BranchMetadataConflictError();
+      }
+      await fs7.rename(tempPath, this.filePath);
+      const afterWrite = JSON.parse(await fs7.readFile(this.filePath, "utf-8"));
+      if (afterWrite.writeId !== writeId) {
+        throw new BranchMetadataConflictError();
+      }
+    } catch (err) {
+      await fs7.unlink(tempPath).catch(() => {
+      });
+      throw err;
+    }
+    return { version: newVersion, writeId };
+  }
+  async withRetry(operation, maxAttempts = 5) {
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      try {
+        return await operation();
+      } catch (err) {
+        if (err instanceof BranchMetadataConflictError && attempt < maxAttempts) {
+          const baseDelay = Math.min(10 * Math.pow(2, attempt - 1), 100);
+          const jitter = Math.random() * baseDelay;
+          await new Promise((resolve) => setTimeout(resolve, baseDelay + jitter));
+          continue;
+        }
+        throw err;
+      }
+    }
+    throw new Error("Unreachable");
+  }
+  async save(incoming) {
+    return withFileLock(this.filePath, () => this.withRetry(async () => {
+      const { meta: existing, version } = await this.load();
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const defaults = {
+        name: "unknown",
+        status: "editing",
+        access: {},
+        createdBy: "unknown",
+        createdAt: now,
+        updatedAt: now
+      };
+      const merged = {
+        schemaVersion: CURRENT_SCHEMA_VERSION,
+        version: version ?? 0,
+        branch: {
+          ...defaults,
+          ...existing?.branch,
+          ...incoming.branch,
+          access: {
+            ...existing?.branch?.access,
+            ...incoming.branch?.access
+          },
+          // Immutable after creation
+          createdBy: existing?.branch.createdBy ?? incoming.branch?.createdBy ?? defaults.createdBy,
+          createdAt: existing?.branch.createdAt ?? defaults.createdAt
+        }
+      };
+      const written = await this.write(merged, version);
+      merged.version = written.version;
+      merged.writeId = written.writeId;
+      await this.invalidateRegistry();
+      return merged;
+    }));
+  }
+  /**
+   * Invalidates the registry cache so next list() call regenerates from branch.json files.
+   */
+  async invalidateRegistry() {
+    const registry = new BranchRegistry(this.baseRoot);
+    await registry.invalidate();
+  }
+};
+var 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;
+}
+
+// dist/build/generate-ai-content.js
+async function generateAIContentFiles(options) {
+  const { config, entrySchemaRegistry, outputDir, aiConfig, _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: aiConfig
+  });
+  const absoluteOutputDir = path10.resolve(outputDir) + path10.sep;
+  let fileCount = 0;
+  for (const [filePath, content] of result.files) {
+    const absolutePath = path10.resolve(path10.join(absoluteOutputDir, filePath));
+    if (!absolutePath.startsWith(absoluteOutputDir)) {
+      throw new Error(`Path traversal detected in AI content output: ${filePath}`);
+    }
+    await fs8.mkdir(path10.dirname(absolutePath), { recursive: true });
+    await fs8.writeFile(absolutePath, content, "utf-8");
+    fileCount++;
+  }
+  return { fileCount, outputDir: absoluteOutputDir };
+}
+
+// dist/cli/generate-ai-content.js
+async function generateAIContentCLI(options) {
+  const { projectDir, outputDir = "public/ai", configPath, appDir = "app" } = options;
+  console.log("\nCanopyCMS generate-ai-content\n");
+  const canopyConfigPath = path11.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 = path11.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 aiConfig;
+  if (configPath) {
+    try {
+      const aiConfigModule = await import(path11.resolve(configPath));
+      aiConfig = 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 (aiConfig !== void 0 && (typeof aiConfig !== "object" || aiConfig === 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 = path11.resolve(projectDir, outputDir);
+  console.log(`  Output: ${resolvedOutput}`);
+  console.log(`  Mode: ${serverConfig.mode ?? "dev"}`);
+  const result = await generateAIContentFiles({
+    config: serverConfig,
+    entrySchemaRegistry,
+    outputDir: resolvedOutput,
+    aiConfig
+  });
+  console.log(`
+  Generated ${result.fileCount} files`);
+  console.log(`  Output: ${result.outputDir}
+`);
+}
+export {
+  generateAIContentCLI
+};