canopycms 0.0.55 → 0.0.56

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

@@ -9,11 +9,11 @@ var __export = (target, all) => {
 };
 
 // dist/paths/normalize.js
-function normalizeFilesystemPath(path17) {
-  return path17.split(/[\\/]+/).filter(Boolean).join("/");
+function normalizeFilesystemPath(path18) {
+  return path18.split(/[\\/]+/).filter(Boolean).join("/");
 }
-function hasTraversalSequence(path17) {
-  const normalized = normalizeFilesystemPath(path17);
+function hasTraversalSequence(path18) {
+  const normalized = normalizeFilesystemPath(path18);
   return normalized.includes("..");
 }
 function createLogicalPath(...segments) {
@@ -23,14 +23,14 @@ function createLogicalPath(...segments) {
   }
   return normalized;
 }
-function trimSlashes(path17) {
+function trimSlashes(path18) {
   let start = 0;
-  let end = path17.length;
-  while (start < end && path17[start] === "/")
+  let end = path18.length;
+  while (start < end && path18[start] === "/")
     start++;
-  while (end > start && path17[end - 1] === "/")
+  while (end > start && path18[end - 1] === "/")
     end--;
-  return path17.slice(start, end);
+  return path18.slice(start, end);
 }
 var init_normalize = __esm({
   "dist/paths/normalize.js"() {
@@ -319,7 +319,7 @@ var init_config = __esm({
     gitBotAuthorNameSchema = z4.string().min(1);
     gitBotAuthorEmailSchema = z4.string().email();
     githubTokenEnvVarSchema = z4.string().default("GITHUB_BOT_TOKEN");
-    operatingModeSchema = z4.enum(["prod", "dev"]).default("dev");
+    operatingModeSchema = z4.enum(["prod", "dev"]);
     deployedAsSchema = z4.enum(["static", "server"]).default("server");
     contentRootSchema = relativePathSchema.default("content");
     sourceRootSchema = z4.string().min(1).optional();
@@ -357,8 +357,9 @@ var init_config = __esm({
       gitBotAuthorName: gitBotAuthorNameSchema,
       gitBotAuthorEmail: gitBotAuthorEmailSchema,
       githubTokenEnvVar: githubTokenEnvVarSchema.optional(),
+      // Required by design (follow-up to SEC-C1): a prod deploy that omits `mode` must fail
+      // validation loudly rather than silently running header-trusting dev auth semantics.
       mode: operatingModeSchema,
-      // Has .default(), so not optional in output type
       deployedAs: deployedAsSchema,
       // Has .default('server'), so always present after validation
       settingsBranch: z4.string().optional(),
@@ -702,12 +703,12 @@ var init_operating_mode = __esm({
 });
 
 // dist/cli/generate-ai-content.js
-import path16 from "node:path";
+import path17 from "node:path";
 import { createJiti } from "jiti";
 
 // dist/build/generate-ai-content.js
-import fs14 from "node:fs/promises";
-import path15 from "node:path";
+import fs15 from "node:fs/promises";
+import path16 from "node:path";
 
 // dist/content-store.js
 import fs6 from "node:fs/promises";
@@ -736,16 +737,16 @@ async function atomicWriteFile(filePath, content) {
 var locks = /* @__PURE__ */ new Map();
 async function withLock(key, fn) {
   const prev = locks.get(key) ?? Promise.resolve();
-  let resolve;
+  let resolve2;
   const next = new Promise((r) => {
-    resolve = r;
+    resolve2 = r;
   });
   locks.set(key, next);
   await prev;
   try {
     return await fn();
   } finally {
-    resolve();
+    resolve2();
     if (locks.get(key) === next)
       locks.delete(key);
   }
@@ -1076,13 +1077,13 @@ function extractIdFromFilename(filename) {
   return null;
 }
 async function resolveCollectionPath(root, logicalPath) {
-  const fs15 = await import("node:fs/promises");
-  const path17 = await import("node:path");
+  const fs16 = await import("node:fs/promises");
+  const path18 = await import("node:path");
   const segments = logicalPath.split("/").filter(Boolean);
   let currentPath = root;
   for (const segment of segments) {
     try {
-      const entries = await fs15.readdir(currentPath, { withFileTypes: true });
+      const entries = await fs16.readdir(currentPath, { withFileTypes: true });
       const matchingDir = entries.find((entry) => {
         if (!entry.isDirectory())
           return false;
@@ -1090,7 +1091,7 @@ async function resolveCollectionPath(root, logicalPath) {
         return logicalName === segment.toLowerCase();
       });
       if (matchingDir) {
-        currentPath = path17.join(currentPath, matchingDir.name);
+        currentPath = path18.join(currentPath, matchingDir.name);
       } else {
         return null;
       }
@@ -1342,6 +1343,25 @@ var asRecord = (value) => value && typeof value === "object" && !Array.isArray(v
 // dist/paths/index.js
 init_normalize();
 
+// dist/paths/normalize-server.js
+import { sep, resolve, relative } from "node:path";
+function validateAndNormalizePath(root, target) {
+  const resolvedRoot = resolve(root);
+  const withSep = resolvedRoot.endsWith(sep) ? resolvedRoot : `${resolvedRoot}${sep}`;
+  const resolvedTarget = resolve(target);
+  if (!resolvedTarget.startsWith(withSep) && resolvedTarget !== resolvedRoot) {
+    return {
+      valid: false,
+      error: "Path traversal detected"
+    };
+  }
+  const relativePath = relative(resolvedRoot, resolvedTarget).split(sep).join("/");
+  return {
+    valid: true,
+    normalizedPath: relativePath
+  };
+}
+
 // dist/paths/branch.js
 init_operating_mode();
 import fs5 from "node:fs/promises";
@@ -1556,11 +1576,11 @@ var ContentStore = class {
   getSchemaItems() {
     return this.schemaIndex.values();
   }
-  assertSchemaItem(path17) {
-    const normalized = normalizeFilesystemPath(path17);
+  assertSchemaItem(path18) {
+    const normalized = normalizeFilesystemPath(path18);
     const item = this.schemaIndex.get(normalized);
     if (!item) {
-      throw new ContentStoreError(`Unknown schema item: ${path17}`, "NO_SCHEMA_ITEM");
+      throw new ContentStoreError(`Unknown schema item: ${path18}`, "NO_SCHEMA_ITEM");
     }
     return item;
   }
@@ -1800,7 +1820,7 @@ var ContentStore = class {
       }
       if (existingId && !await filePathExists(absolutePath)) {
         const actualRelPath = await this.findEntryPathById(path7.dirname(absolutePath), existingId);
-        const indexedRelPath = (await this.idIndex()).findById(existingId)?.relativePath ?? null;
+        const indexedRelPath = this._idIndex.findById(existingId)?.relativePath ?? null;
         if (actualRelPath !== null && actualRelPath !== indexedRelPath) {
           throw new ContentConflictError();
         }
@@ -3033,8 +3053,8 @@ function computeEntryUrl(collection, slug, contentRoot) {
   if (slug && slug !== "index") {
     segments.push(slug);
   }
-  const path17 = segments.length > 0 ? `/${segments.join("/")}` : "/";
-  return path17.toLowerCase();
+  const path18 = segments.length > 0 ? `/${segments.join("/")}` : "/";
+  return path18.toLowerCase();
 }
 
 // dist/entry-link-resolver.js
@@ -3638,7 +3658,7 @@ var BranchMetadataFileManager = class _BranchMetadataFileManager {
         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));
+          await new Promise((resolve2) => setTimeout(resolve2, baseDelay + jitter));
           continue;
         }
         throw err;
@@ -3861,8 +3881,8 @@ var GitManager = class _GitManager {
         }
         let hasCommits = false;
         try {
-          const log5 = await sourceGit.log(["-1"]);
-          hasCommits = log5.total > 0;
+          const log6 = await sourceGit.log(["-1"]);
+          hasCommits = log6.total > 0;
         } catch {
           hasCommits = false;
         }
@@ -4578,6 +4598,384 @@ async function resolveBranchRoot(config) {
   return context.branchRoot;
 }
 
+// dist/content-listing.js
+import fs14 from "node:fs/promises";
+import path15 from "node:path";
+import matter2 from "gray-matter";
+import { parse as yamlParse2 } from "yaml";
+var log5 = createDebugLogger({ prefix: "ContentListing" });
+var normalizePath = (root, target) => {
+  const result = validateAndNormalizePath(root, target);
+  if (!result.valid) {
+    throw new ContentStoreError(result.error || "Path traversal detected", "VALIDATION");
+  }
+  return result.normalizedPath;
+};
+var readEntryData = async (filePath, format, bodyFieldName = "body") => {
+  try {
+    const raw = await fs14.readFile(filePath, "utf8");
+    if (format === "json") {
+      return asRecord(JSON.parse(raw));
+    }
+    if (format === "yaml") {
+      return asRecord(yamlParse2(raw));
+    }
+    const parsed = matter2(raw);
+    const data = parsed.data ?? {};
+    if (parsed.content) {
+      data[bodyFieldName] = parsed.content;
+    }
+    return data;
+  } catch (err) {
+    if (isNotFoundError(err))
+      return {};
+    log5.warn("readEntryData", `Failed to read entry data from ${filePath}: ${getErrorMessage(err)}`);
+    return {};
+  }
+};
+var parseTypedFilename = (filename, entryTypes) => {
+  const lastDot = filename.lastIndexOf(".");
+  if (lastDot === -1)
+    return null;
+  const nameWithoutExt = filename.slice(0, lastDot);
+  const parts = nameWithoutExt.split(".");
+  if (parts.length >= 3) {
+    const potentialType = parts[0];
+    const matchingType = entryTypes.find((e) => e.name === potentialType);
+    if (matchingType) {
+      const id = parts[parts.length - 1];
+      if (!isValidId(id))
+        return null;
+      const slug = parts.slice(1, -1).join(".").toLowerCase();
+      return {
+        type: potentialType,
+        slug,
+        id
+      };
+    }
+  }
+  return null;
+};
+async function listEntries(branchRoot, flatSchema, contentRootName, options) {
+  const rootPath = options?.rootPath ?? contentRootName;
+  const extract = options?.extract;
+  const filter = options?.filter;
+  const customSort = options?.sort;
+  const collections = flatSchema.filter((item) => item.type === "collection" && item.entries !== void 0 && (item.logicalPath === rootPath || item.logicalPath.startsWith(`${rootPath}/`)));
+  const collectionResults = await Promise.all(collections.map(async (collection) => {
+    const entries = await listCollectionEntries(branchRoot, collection);
+    return entries.map((entry) => ({ entry, collection }));
+  }));
+  const contentPrefix = contentRootName ? `${contentRootName}/` : "";
+  const items = [];
+  for (const results of collectionResults) {
+    for (const { entry, collection } of results) {
+      const pathWithoutRoot = entry.logicalPath.startsWith(contentPrefix) ? entry.logicalPath.slice(contentPrefix.length) : entry.logicalPath;
+      const pathSegments = pathWithoutRoot.split("/").filter(Boolean);
+      const urlSegments = entry.slug === "index" ? pathSegments.slice(0, -1) : pathSegments;
+      const urlPath = urlSegments.length > 0 ? `/${urlSegments.join("/")}`.toLowerCase() : "/";
+      const raw = entry.data;
+      const meta = {
+        entryPath: entry.logicalPath,
+        entryType: entry.entryType,
+        format: entry.format
+      };
+      const data = extract ? extract(raw, meta) : raw;
+      const item = {
+        pathSegments,
+        urlPath,
+        slug: entry.slug,
+        entryPath: entry.logicalPath,
+        entryId: entry.contentId,
+        collectionId: collection.contentId,
+        collectionPath: entry.collectionPath,
+        entryType: entry.entryType,
+        format: entry.format,
+        data,
+        schema: collection.entries?.find((e) => e.name === entry.entryType)?.schema
+      };
+      if (filter && !filter(item))
+        continue;
+      items.push(item);
+    }
+  }
+  if (customSort) {
+    items.sort(customSort);
+  } else {
+    items.sort((a, b) => a.entryPath.localeCompare(b.entryPath));
+  }
+  return items;
+}
+var listCollectionEntries = async (root, collection) => {
+  if (collection.type !== "collection" || !collection.entries) {
+    return [];
+  }
+  const entryTypes = collection.entries;
+  const extToTypes = /* @__PURE__ */ new Map();
+  for (const entryType of entryTypes) {
+    const ext = getFormatExtension(entryType.format);
+    const existing = extToTypes.get(ext) || [];
+    existing.push(entryType);
+    extToTypes.set(ext, existing);
+  }
+  const validExts = Array.from(extToTypes.keys());
+  const collectionRoot = await resolveCollectionPath(root, collection.logicalPath);
+  if (!collectionRoot) {
+    return [];
+  }
+  normalizePath(root, collectionRoot);
+  let dirents;
+  try {
+    dirents = await fs14.readdir(collectionRoot, { withFileTypes: true });
+  } catch (err) {
+    if (isNotFoundError(err))
+      return [];
+    throw err;
+  }
+  const files = dirents.filter((d) => d.isFile() && validExts.some((ext) => d.name.endsWith(ext)) && d.name !== ".collection.json").sort((a, b) => a.name.localeCompare(b.name));
+  const entries = await Promise.all(files.map(async (file) => {
+    const absolutePath = path15.join(collectionRoot, file.name);
+    const relativePath = normalizePath(root, absolutePath);
+    const parsed = parseTypedFilename(file.name, entryTypes);
+    if (!parsed) {
+      log5.warn("listCollectionEntries", `Skipping file with unrecognized filename format: ${file.name} (expected {type}.{slug}.{id}.{ext} with a known entry type and valid 12-char Base58 ID)`);
+      return null;
+    }
+    const { type: entryTypeName, slug, id: contentId } = parsed;
+    const entryType = entryTypes.find((e) => e.name === entryTypeName);
+    const format = entryType?.format || "json";
+    const bodyField = entryType?.schema ? findBodyFieldName(entryType.schema) : "body";
+    const [stats, data] = await Promise.all([
+      fs14.stat(absolutePath),
+      readEntryData(absolutePath, format, bodyField)
+    ]);
+    const item = {
+      logicalPath: `${collection.logicalPath}/${slug}`,
+      contentId,
+      slug,
+      collectionPath: collection.logicalPath,
+      collectionName: collection.name,
+      format,
+      entryType: entryTypeName,
+      physicalPath: relativePath,
+      data,
+      updatedAt: stats.mtime.toISOString()
+    };
+    return item;
+  }));
+  return entries.filter((e) => e !== null);
+};
+
+// dist/validation/entry-validator.js
+init_config2();
+
+// dist/validation/field-traversal.js
+function isPlainRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function resolveBlockItem(blockField, item) {
+  const templateName = typeof item.template === "string" ? item.template : typeof item._type === "string" ? item._type : void 0;
+  if (!templateName)
+    return void 0;
+  const template = blockField.templates?.find((t) => t.name === templateName);
+  if (!template?.fields)
+    return void 0;
+  const data = isPlainRecord(item.value) ? item.value : item;
+  return { fields: template.fields, data };
+}
+
+// dist/validation/entry-validator.js
+var KNOWN_FIELD_TYPES = new Set(fieldTypes);
+var STRING_FIELD_TYPES = /* @__PURE__ */ new Set(["string", "rich-text", "markdown", "mdx", "image", "code"]);
+function isPlainRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function referenceValueId(value) {
+  if (typeof value === "string")
+    return value;
+  if (isPlainRecord2(value) && typeof value.id === "string")
+    return value.id;
+  return void 0;
+}
+var selectOptionValues = (field) => (field.options ?? []).map((opt) => typeof opt === "string" ? opt : opt.value);
+function validateScalar(field, value, path18) {
+  switch (field.type) {
+    case "number":
+      if (typeof value !== "number" || !Number.isFinite(value)) {
+        return [{ fieldPath: path18, message: "Expected a number" }];
+      }
+      return [];
+    case "boolean":
+      if (typeof value !== "boolean") {
+        return [{ fieldPath: path18, message: "Expected true or false" }];
+      }
+      return [];
+    case "datetime":
+      if (typeof value !== "string" || value !== "" && Number.isNaN(Date.parse(value))) {
+        return [{ fieldPath: path18, message: "Expected a valid date/time string" }];
+      }
+      return [];
+    case "select": {
+      if (typeof value !== "string") {
+        return [{ fieldPath: path18, message: "Expected a selection" }];
+      }
+      const options = selectOptionValues(field);
+      if (value !== "" && !options.includes(value)) {
+        return [{ fieldPath: path18, message: `Must be one of: ${options.join(", ")}` }];
+      }
+      return [];
+    }
+    case "reference":
+      if (referenceValueId(value) === void 0) {
+        return [{ fieldPath: path18, message: "Expected a reference id" }];
+      }
+      return [];
+    default:
+      if (STRING_FIELD_TYPES.has(field.type)) {
+        if (typeof value !== "string") {
+          return [{ fieldPath: path18, message: "Expected text" }];
+        }
+      }
+      return [];
+  }
+}
+function isEmptyForRequired(field, value) {
+  if (value === void 0 || value === null)
+    return true;
+  if (Array.isArray(value))
+    return value.length === 0;
+  if (typeof value === "string") {
+    return value.trim() === "";
+  }
+  return false;
+}
+function validateEntryData(fields, data, pathPrefix = "") {
+  const errors = [];
+  for (const field of fields) {
+    if (field.type === "group") {
+      errors.push(...validateEntryData(field.fields, data, pathPrefix));
+      continue;
+    }
+    const path18 = pathPrefix ? `${pathPrefix}.${field.name}` : field.name;
+    const value = data[field.name];
+    const isRequired = "required" in field && field.required === true;
+    if (isRequired && isEmptyForRequired(field, value)) {
+      const message = Array.isArray(value) ? "At least one item is required" : "This field is required";
+      errors.push({ fieldPath: path18, message });
+      continue;
+    }
+    if (value === void 0 || value === null)
+      continue;
+    if (field.type === "block") {
+      const blockField = field;
+      if (!Array.isArray(value)) {
+        errors.push({ fieldPath: path18, message: "Expected a list of blocks" });
+        continue;
+      }
+      value.forEach((item, index) => {
+        const itemPath = `${path18}[${index}]`;
+        if (!isPlainRecord2(item)) {
+          errors.push({ fieldPath: itemPath, message: "Expected a block object" });
+          return;
+        }
+        const resolved = resolveBlockItem(blockField, item);
+        if (!resolved) {
+          const template = typeof item.template === "string" ? item.template : void 0;
+          errors.push({
+            fieldPath: itemPath,
+            message: template ? `Unknown block template "${template}"` : "Missing block template"
+          });
+          return;
+        }
+        errors.push(...validateEntryData(resolved.fields, resolved.data, itemPath));
+      });
+      continue;
+    }
+    if (field.type === "object") {
+      const objectField = field;
+      if (objectField.list) {
+        if (!Array.isArray(value)) {
+          errors.push({ fieldPath: path18, message: "Expected a list of items" });
+          continue;
+        }
+        value.forEach((item, index) => {
+          const itemPath = `${path18}[${index}]`;
+          if (!isPlainRecord2(item)) {
+            errors.push({ fieldPath: itemPath, message: "Expected an object" });
+            return;
+          }
+          if (objectField.fields) {
+            errors.push(...validateEntryData(objectField.fields, item, itemPath));
+          }
+        });
+      } else if (!isPlainRecord2(value)) {
+        errors.push({ fieldPath: path18, message: "Expected an object" });
+      } else if (objectField.fields) {
+        errors.push(...validateEntryData(objectField.fields, value, path18));
+      }
+      continue;
+    }
+    if ("list" in field && field.list) {
+      if (!Array.isArray(value)) {
+        errors.push({ fieldPath: path18, message: "Expected a list of values" });
+        continue;
+      }
+      value.forEach((item, index) => {
+        errors.push(...validateScalar(field, item, `${path18}[${index}]`));
+      });
+      continue;
+    }
+    if (Array.isArray(value) && KNOWN_FIELD_TYPES.has(field.type)) {
+      errors.push({ fieldPath: path18, message: "Expected a single value, not a list" });
+      continue;
+    }
+    errors.push(...validateScalar(field, value, path18));
+  }
+  return errors;
+}
+
+// dist/static/index.js
+function normalizeDatesDeep(value) {
+  if (value instanceof Date)
+    return value.toISOString();
+  if (Array.isArray(value))
+    return value.map(normalizeDatesDeep);
+  if (value && typeof value === "object") {
+    const result = {};
+    for (const [key, v] of Object.entries(value)) {
+      result[key] = normalizeDatesDeep(v);
+    }
+    return result;
+  }
+  return value;
+}
+function findInvalidEntries(items) {
+  const invalid = [];
+  for (const item of items) {
+    if (!item.schema)
+      continue;
+    const data = normalizeDatesDeep(item.data);
+    const errors = validateEntryData(item.schema, data);
+    if (errors.length > 0) {
+      invalid.push({ entryPath: item.entryPath, errors });
+    }
+  }
+  return invalid;
+}
+function assertBuildEntriesValid(items, phaseLabel) {
+  const invalid = findInvalidEntries(items);
+  if (invalid.length === 0)
+    return;
+  const lines = invalid.map(({ entryPath, errors }) => {
+    const [first, ...rest] = errors;
+    const summary = rest.length > 0 ? `${first.fieldPath}: ${first.message} (+${rest.length} more)` : `${first.fieldPath}: ${first.message}`;
+    return `  - ${entryPath} \u2014 ${summary}`;
+  });
+  throw new Error(`CanopyCMS static build: found ${invalid.length} schema-invalid ${invalid.length === 1 ? "entry" : "entries"} during ${phaseLabel}:
+${lines.join("\n")}
+These are likely abandoned create-scaffolds (empty entries left behind when a create was started but never finished). Finish editing the entry (fill in its required fields) or delete the abandoned draft, then rebuild.`);
+}
+
 // dist/build/generate-ai-content.js
 async function generateAIContentFiles(options) {
   const { config, entrySchemaRegistry, outputDir, aiConfig, _testFlatSchema } = options;
@@ -4591,6 +4989,8 @@ async function generateAIContentFiles(options) {
     const cached = await schemaCache.getSchema(branchRoot, entrySchemaRegistry, contentRootName);
     flatSchema = cached.flatSchema;
   }
+  const entriesForValidation = await listEntries(branchRoot, flatSchema, contentRootName);
+  assertBuildEntriesValid(entriesForValidation, "AI content generation");
   const store = new ContentStore(branchRoot, flatSchema);
   const result = await generateAIContent({
     store,
@@ -4599,15 +4999,15 @@ async function generateAIContentFiles(options) {
     config: aiConfig,
     entryLinkUrl: config.entryLinkUrl
   });
-  const absoluteOutputDir = path15.resolve(outputDir) + path15.sep;
+  const absoluteOutputDir = path16.resolve(outputDir) + path16.sep;
   let fileCount = 0;
   for (const [filePath, content] of result.files) {
-    const absolutePath = path15.resolve(path15.join(absoluteOutputDir, filePath));
+    const absolutePath = path16.resolve(path16.join(absoluteOutputDir, filePath));
     if (!absolutePath.startsWith(absoluteOutputDir)) {
       throw new Error(`Path traversal detected in AI content output: ${filePath}`);
     }
-    await fs14.mkdir(path15.dirname(absolutePath), { recursive: true });
-    await fs14.writeFile(absolutePath, content, "utf-8");
+    await fs15.mkdir(path16.dirname(absolutePath), { recursive: true });
+    await fs15.writeFile(absolutePath, content, "utf-8");
     fileCount++;
   }
   return { fileCount, outputDir: absoluteOutputDir };
@@ -4618,7 +5018,7 @@ var jiti = createJiti(import.meta.url);
 async function generateAIContentCLI(options) {
   const { projectDir, outputDir = "public/ai", configPath, appDir = "app" } = options;
   console.log("\nCanopyCMS generate-ai-content\n");
-  const canopyConfigPath = path16.join(projectDir, "canopycms.config.ts");
+  const canopyConfigPath = path17.join(projectDir, "canopycms.config.ts");
   let canopyConfigModule;
   try {
     canopyConfigModule = await jiti.import(canopyConfigPath);
@@ -4629,7 +5029,7 @@ async function generateAIContentCLI(options) {
   }
   const configExport = canopyConfigModule.default ?? canopyConfigModule.config ?? canopyConfigModule;
   const serverConfig = typeof configExport === "object" && configExport !== null && "server" in configExport ? configExport.server : configExport;
-  const schemasPath = path16.join(projectDir, appDir, "schemas.ts");
+  const schemasPath = path17.join(projectDir, appDir, "schemas.ts");
   let entrySchemaRegistry = {};
   try {
     const schemasModule = await jiti.import(schemasPath);
@@ -4640,7 +5040,7 @@ async function generateAIContentCLI(options) {
   let aiConfig;
   if (configPath) {
     try {
-      const aiConfigModule = await jiti.import(path16.resolve(configPath));
+      const aiConfigModule = await jiti.import(path17.resolve(configPath));
       aiConfig = aiConfigModule.aiContentConfig ?? aiConfigModule.default ?? aiConfigModule.config;
     } catch (err) {
       console.error(`Could not load AI config from ${configPath}`);
@@ -4657,7 +5057,7 @@ async function generateAIContentCLI(options) {
     console.error("Make sure canopycms.config.ts uses defineCanopyConfig().");
     process.exit(1);
   }
-  const resolvedOutput = path16.resolve(projectDir, outputDir);
+  const resolvedOutput = path17.resolve(projectDir, outputDir);
   console.log(`  Output: ${resolvedOutput}`);
   console.log(`  Mode: ${serverConfig.mode ?? "dev"}`);
   const result = await generateAIContentFiles({

package/dist/cli/init.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../src/cli/init.ts"],"names":[],"mappings":"AAKA,OAAO,EAAkC,KAAK,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAIhF,MAAM,MAAM,YAAY,GAAG,OAAO,GAAG,KAAK,CAAA;AAE1C,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,KAAK,CAAA;IACX,MAAM,EAAE,MAAM,CAAA;IACd,UAAU,EAAE,MAAM,CAAA;IAClB,KAAK,EAAE,OAAO,CAAA;IACd,cAAc,EAAE,OAAO,CAAA;IACvB,EAAE,EAAE,OAAO,CAAA;IACX,4CAA4C;IAC5C,YAAY,CAAC,EAAE,YAAY,CAAA;IAC3B,kDAAkD;IAClD,WAAW,CAAC,EAAE,OAAO,CAAA;CACtB;AAED,UAAU,iBAAiB;IACzB,KAAK,EAAE,KAAK,CAAA;IACZ,UAAU,EAAE,MAAM,CAAA;IAClB,KAAK,EAAE,OAAO,CAAA;IACd,cAAc,EAAE,OAAO,CAAA;CACxB;AA+CD;;;GAGG;AACH,wBAAsB,IAAI,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CA8I9D;AAED;;;GAGG;AACH,wBAAsB,aAAa,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,CA2C7E;AAmED;;;GAGG;AACH,wBAAsB,aAAa,CAAC,OAAO,EAAE;IAC3C,UAAU,EAAE,MAAM,CAAA;IAClB,UAAU,CAAC,EAAE,UAAU,CAAA;CACxB,GAAG,OAAO,CAAC,IAAI,CAAC,CA8EhB"}
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../src/cli/init.ts"],"names":[],"mappings":"AAKA,OAAO,EAAkC,KAAK,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAIhF,MAAM,MAAM,YAAY,GAAG,OAAO,GAAG,KAAK,CAAA;AAE1C,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,KAAK,CAAA;IACX,MAAM,EAAE,MAAM,CAAA;IACd,UAAU,EAAE,MAAM,CAAA;IAClB,KAAK,EAAE,OAAO,CAAA;IACd,cAAc,EAAE,OAAO,CAAA;IACvB,EAAE,EAAE,OAAO,CAAA;IACX,4CAA4C;IAC5C,YAAY,CAAC,EAAE,YAAY,CAAA;IAC3B,kDAAkD;IAClD,WAAW,CAAC,EAAE,OAAO,CAAA;CACtB;AAED,UAAU,iBAAiB;IACzB,KAAK,EAAE,KAAK,CAAA;IACZ,UAAU,EAAE,MAAM,CAAA;IAClB,KAAK,EAAE,OAAO,CAAA;IACd,cAAc,EAAE,OAAO,CAAA;CACxB;AA+CD;;;GAGG;AACH,wBAAsB,IAAI,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CA8I9D;AAED;;;GAGG;AACH,wBAAsB,aAAa,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,CA2C7E;AAwED;;;GAGG;AACH,wBAAsB,aAAa,CAAC,OAAO,EAAE;IAC3C,UAAU,EAAE,MAAM,CAAA;IAClB,UAAU,CAAC,EAAE,UAAU,CAAA;CACxB,GAAG,OAAO,CAAC,IAAI,CAAC,CAuFhB"}