canopycms 0.3.3 → 0.5.0

package/dist/reference-resolver.d.ts

@@ -1,10 +1,26 @@
+import type { ReferenceOptionSort } from './config/index.js';
 import type { ContentStore } from './content-store.js';
 import type { ContentIdIndex } from './content-id-index.js';
 import { type LogicalPath } from './paths/index.js';
+import { type SeoFieldLocation } from './static/seo.js';
 export interface ReferenceOption {
     id: string;
     label: string;
     collection: string;
+    /**
+     * Present when the target is `noindex` at `config.seo`'s location, so a page that lists only
+     * indexed entries won't show it. `fieldLabel` is the editor label of the target's own noindex
+     * field, so the picker can name the setting in the words the editor sees on that entry.
+     */
+    noindex?: {
+        fieldLabel: string;
+    };
+}
+export interface LoadReferenceOptionsSettings {
+    /** Where entries keep their SEO fields: `CanopyConfig.seo`. */
+    seo?: SeoFieldLocation;
+    /** Default `'label'`. */
+    sort?: ReferenceOptionSort;
 }
 /**
  * Loads the options a reference field's picker offers. Resolving a stored reference to its
@@ -24,6 +40,7 @@ export declare class ReferenceResolver {
      *   logical path (`entryLogicalPath`) before it is read. Returning false skips the entry entirely --
      *   no file I/O, no label, no option -- so a caller who can't read a path never
      *   triggers a read for content they won't be allowed to see anyway.
+     * @param settings - The SEO location the `noindex` marker reads, and the option order.
      */
-    loadReferenceOptions(collections?: LogicalPath[], displayField?: string, search?: string, entryTypes?: string[], canAccess?: (logicalPath: LogicalPath) => boolean): Promise<ReferenceOption[]>;
+    loadReferenceOptions(collections?: LogicalPath[], displayField?: string, search?: string, entryTypes?: string[], canAccess?: (logicalPath: LogicalPath) => boolean, settings?: LoadReferenceOptionsSettings): Promise<ReferenceOption[]>;
 }

package/dist/reference-resolver.js

@@ -1,6 +1,8 @@
 import nodePath from 'node:path';
 import { extractSlugFromFilename, extractEntryTypeFromFilename } from './content-id-index.js';
-import { entryLogicalPath } from './paths/index.js';
+import { sortByOrder } from './content-listing.js';
+import { entryLogicalPath, } from './paths/index.js';
+import { DEFAULT_SEO_FIELD_NAMES, isNoindexEntry } from './static/seo.js';
 /**
  * Loads the options a reference field's picker offers. Resolving a stored reference to its
  * target is `ContentStore`'s job (`read()`, `resolveReferenceTarget`).
@@ -20,9 +22,13 @@ export class ReferenceResolver {
      *   logical path (`entryLogicalPath`) before it is read. Returning false skips the entry entirely --
      *   no file I/O, no label, no option -- so a caller who can't read a path never
      *   triggers a read for content they won't be allowed to see anyway.
+     * @param settings - The SEO location the `noindex` marker reads, and the option order.
      */
-    async loadReferenceOptions(collections, displayField = 'title', search, entryTypes, canAccess) {
-        const options = [];
+    async loadReferenceOptions(collections, displayField = 'title', search, entryTypes, canAccess, settings = {}) {
+        const loaded = [];
+        const sort = settings.sort ?? 'label';
+        const sortField = typeof sort === 'object' ? sort.field : undefined;
+        const noindexLabels = new NoindexFieldLabels(this.store.getSchemaItems(), settings.seo);
         let candidates;
         if (collections && collections.length > 0) {
             const results = await Promise.all(collections.map((col) => this.store.getCollectionEntryPaths(col)));
@@ -60,10 +66,15 @@ export class ReferenceResolver {
                 if (search && !label.toLowerCase().includes(search.toLowerCase())) {
                     continue;
                 }
-                options.push({
-                    id,
-                    label,
-                    collection: location.collection,
+                const option = { id, label, collection: location.collection };
+                if (isNoindexEntry(doc.data, settings.seo)) {
+                    const entryType = extractEntryTypeFromFilename(filename) ?? '';
+                    option.noindex = { fieldLabel: noindexLabels.get(location.collection, entryType) };
+                }
+                loaded.push({
+                    option,
+                    contentId: id,
+                    sortValue: sortField === undefined ? undefined : sortValueAt(doc.data, sortField),
                 });
             }
             catch (error) {
@@ -75,6 +86,162 @@ export class ReferenceResolver {
                 continue;
             }
         }
-        return options.sort((a, b) => a.label.localeCompare(b.label));
+        if (sort === 'collection')
+            return sortByCollection(loaded, this.store.getSchemaItems());
+        if (typeof sort === 'object')
+            return sortByField(loaded, sort.direction ?? 'asc');
+        return loaded.map((l) => l.option).sort(byLabel);
+    }
+}
+const byLabel = (a, b) => a.label.localeCompare(b.label);
+/**
+ * The value at a dotted path, read through own properties only so a path like `__proto__`
+ * reads nothing. A non-blank string, a finite number or a valid date counts as a value; a date
+ * becomes its ISO string, since md/mdx frontmatter parses an unquoted `YYYY-MM-DD` as a `Date`.
+ */
+function sortValueAt(data, path) {
+    let current = data;
+    for (const segment of path.split('.')) {
+        if (typeof current !== 'object' || current === null || Array.isArray(current))
+            return undefined;
+        if (!Object.prototype.hasOwnProperty.call(current, segment))
+            return undefined;
+        current = current[segment];
+    }
+    if (typeof current === 'number')
+        return Number.isFinite(current) ? current : undefined;
+    if (typeof current === 'string')
+        return current.trim() || undefined;
+    if (current instanceof Date) {
+        return Number.isNaN(current.getTime()) ? undefined : current.toISOString();
+    }
+    return undefined;
+}
+/**
+ * Numbers before strings, so a field typed differently across entry types still sorts in one
+ * consistent order; numbers compare numerically, strings as plain text, which orders ISO dates.
+ */
+function compareValues(a, b) {
+    if (typeof a === 'number' && typeof b === 'number')
+        return a - b;
+    if (typeof a === 'number')
+        return -1;
+    if (typeof b === 'number')
+        return 1;
+    return a < b ? -1 : a > b ? 1 : 0;
+}
+/**
+ * Entries with no value go first under `desc` and last under `asc`: newest-first then puts an
+ * entry whose date is not yet stamped at the top, where an editor queueing it looks.
+ */
+function sortByField(loaded, direction) {
+    const sign = direction === 'desc' ? -1 : 1;
+    return loaded
+        .sort((a, b) => {
+        if (a.sortValue === undefined || b.sortValue === undefined) {
+            if (a.sortValue !== b.sortValue) {
+                const aMissingFirst = direction === 'desc';
+                return (a.sortValue === undefined) === aMissingFirst ? -1 : 1;
+            }
+        }
+        else {
+            const byValue = compareValues(a.sortValue, b.sortValue) * sign;
+            if (byValue !== 0)
+                return byValue;
+        }
+        return byLabel(a.option, b.option);
+    })
+        .map((l) => l.option);
+}
+/**
+ * One group per collection in content-tree order: a collection, then each subcollection in its
+ * parent's `order`. Within a group, options follow the collection's own `order`, then label.
+ */
+function sortByCollection(loaded, schemaItems) {
+    const collections = [...schemaItems].filter((item) => item.type === 'collection');
+    const byPath = new Map(collections.map((c) => [c.logicalPath, c]));
+    const children = new Map();
+    const roots = [];
+    for (const collection of collections) {
+        const parent = collection.parentPath;
+        if (parent === undefined || !byPath.has(parent)) {
+            roots.push(collection);
+        }
+        else {
+            children.set(parent, [...(children.get(parent) ?? []), collection]);
+        }
+    }
+    const treeOrder = [];
+    const visit = (siblings, order) => {
+        for (const collection of sortByOrder([...siblings], order, (c) => c.name)) {
+            treeOrder.push(collection);
+            visit(children.get(collection.logicalPath) ?? [], collection.order);
+        }
+    };
+    visit(roots, undefined);
+    const groups = new Map();
+    for (const item of loaded) {
+        const path = item.option.collection;
+        groups.set(path, [...(groups.get(path) ?? []), item]);
+    }
+    const result = [];
+    const appendGroup = (path, order) => {
+        const group = groups.get(path);
+        if (!group)
+            return;
+        groups.delete(path);
+        result.push(...sortByOrder(group, order, (l) => l.option.label).map((l) => l.option));
+    };
+    for (const collection of treeOrder)
+        appendGroup(collection.logicalPath, collection.order);
+    // A collection missing from the schema still gets a group, after the known ones.
+    for (const path of [...groups.keys()].sort())
+        appendGroup(path, undefined);
+    return result;
+}
+/**
+ * The editor label of each entry type's noindex field, found where `seo` says the flag lives:
+ * a top-level field (inline groups are transparent), or a field inside the object named by
+ * `seo.group`. Falls back to the field's name when the schema has no such field.
+ */
+class NoindexFieldLabels {
+    constructor(schemaItems, seo) {
+        this.seo = seo;
+        this.cache = new Map();
+        this.entryTypes = [...schemaItems].filter((item) => item.type === 'entry-type');
+        this.fieldName = seo?.fields?.noindex || DEFAULT_SEO_FIELD_NAMES.noindex;
+    }
+    get(collection, entryType) {
+        const key = `${collection}\0${entryType}`;
+        const cached = this.cache.get(key);
+        if (cached !== undefined)
+            return cached;
+        const schema = this.entryTypes.find((item) => item.parentPath === collection && item.name === entryType)?.schema;
+        const label = (schema && this.findLabel(schema)) ?? this.fieldName;
+        this.cache.set(key, label);
+        return label;
+    }
+    findLabel(schema) {
+        let fields = schema;
+        if (this.seo?.group) {
+            const group = findField(schema, this.seo.group);
+            fields = group?.type === 'object' ? group.fields : undefined;
+        }
+        const field = fields && findField(fields, this.fieldName);
+        return field ? (field.label ?? field.name) : undefined;
+    }
+}
+/** A field by data name, looking through inline groups, which store no key of their own. */
+function findField(fields, name) {
+    for (const field of fields) {
+        if (field.type === 'group') {
+            const inner = findField(field.fields, name);
+            if (inner)
+                return inner;
+        }
+        else if (field.name === name) {
+            return field;
+        }
     }
+    return undefined;
 }

package/dist/schema/schema-store.d.ts

@@ -164,14 +164,14 @@ declare const updateEntryTypeInputSchema: z.ZodObject<{
     default?: boolean | undefined;
     format?: "mdx" | "md" | "json" | "yaml" | undefined;
     label?: string | undefined;
-    schema?: string | undefined;
     maxItems?: number | undefined;
+    schema?: string | undefined;
 }, {
     default?: boolean | undefined;
     format?: "mdx" | "md" | "json" | "yaml" | undefined;
     label?: string | undefined;
-    schema?: string | undefined;
     maxItems?: number | undefined;
+    schema?: string | undefined;
 }>;
 /**
  * Thrown when a schema mutation cannot proceed because the per-branch

package/dist/static/index.d.ts

@@ -101,11 +101,13 @@ type StaticBuildContext = Pick<CanopyBuildContext, 'listEntries'> & Partial<Pick
  * when you actually mean to — omission should be a decision, not an oversight.
  *
  * `noindex` is NOT applied here: an entry that must not be advertised must still be built. Apply
- * `isNoindexEntry` at the advertising surface (as `generateContentSitemap` does).
+ * `isNoindexEntry` at the advertising surface (as `generateContentSitemap` does), at the SEO
+ * location in `CanopyConfig.seo`.
  *
  * @example
- * const entries = await collectRoutableEntries(await getCanopyForBuild())
- * const published = entries.filter((e) => !isNoindexEntry(e.data))
+ * const ctx = await getCanopyForBuild()
+ * const entries = await collectRoutableEntries(ctx)
+ * const published = entries.filter((e) => !isNoindexEntry(e.data, ctx.services.config.seo))
  */
 export declare function collectRoutableEntries<T = Record<string, unknown>>(ctx: StaticBuildContext, options?: CollectRoutableEntriesOptions<T>): Promise<RoutableEntry<T>[]>;
 /**
@@ -206,7 +208,9 @@ export declare function warnUnsafeMarkdown(items: readonly BuildScanItem[], phas
  *
  * Fails the build rather than silently skipping the offending entry: a page that silently
  * disappears from a static build is a worse failure mode than a red build. Lists every
- * offending entry so one build catches every abandoned scaffold, not just the first.
+ * offending entry so one build catches every abandoned scaffold, not just the first. An
+ * over-`maxItems` list gets its own line per list, with the fix; the abandoned-scaffold advice
+ * appears only when some entry has another kind of error.
  */
 export declare function assertBuildEntriesValid(items: readonly BuildScanItem[], phaseLabel: string): void;
 /**

package/dist/static/index.js

@@ -68,11 +68,13 @@ async function enumerateRoutableEntries(ctx, rootPath, phaseLabel, resolveRefere
  * when you actually mean to — omission should be a decision, not an oversight.
  *
  * `noindex` is NOT applied here: an entry that must not be advertised must still be built. Apply
- * `isNoindexEntry` at the advertising surface (as `generateContentSitemap` does).
+ * `isNoindexEntry` at the advertising surface (as `generateContentSitemap` does), at the SEO
+ * location in `CanopyConfig.seo`.
  *
  * @example
- * const entries = await collectRoutableEntries(await getCanopyForBuild())
- * const published = entries.filter((e) => !isNoindexEntry(e.data))
+ * const ctx = await getCanopyForBuild()
+ * const entries = await collectRoutableEntries(ctx)
+ * const published = entries.filter((e) => !isNoindexEntry(e.data, ctx.services.config.seo))
  */
 export async function collectRoutableEntries(ctx, options = {}) {
     const entries = await enumerateRoutableEntries(ctx, options.rootPath, 'routable entry enumeration', options.resolveReferences);
@@ -283,22 +285,45 @@ export function warnUnsafeMarkdown(items, phaseLabel, siteAllow) {
  *
  * Fails the build rather than silently skipping the offending entry: a page that silently
  * disappears from a static build is a worse failure mode than a red build. Lists every
- * offending entry so one build catches every abandoned scaffold, not just the first.
+ * offending entry so one build catches every abandoned scaffold, not just the first. An
+ * over-`maxItems` list gets its own line per list, with the fix; the abandoned-scaffold advice
+ * appears only when some entry has another kind of error.
  */
 export 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} — ${summary}`;
-    });
+    const lines = [];
+    let hasOverCap = false;
+    let hasOrdinary = false;
+    for (const { entryPath, errors } of invalid) {
+        const ordinary = errors.filter((e) => e.maxItems === undefined);
+        if (ordinary.length > 0) {
+            hasOrdinary = true;
+            const [first, ...rest] = ordinary;
+            const summary = rest.length > 0
+                ? `${first.fieldPath}: ${first.message} (+${rest.length} more)`
+                : `${first.fieldPath}: ${first.message}`;
+            lines.push(`  - ${entryPath} — ${summary}`);
+        }
+        for (const { fieldPath, maxItems } of errors) {
+            if (maxItems === undefined)
+                continue;
+            hasOverCap = true;
+            lines.push(`  - ${entryPath} — ${fieldPath}: ${maxItems.count} items, but maxItems is ${maxItems.cap}`);
+        }
+    }
+    const advice = [];
+    if (hasOverCap) {
+        advice.push(`A list over its maxItems: open the entry in the editor and remove a pick from that list (or remove items) until it holds at most maxItems, then rebuild. ` +
+            `This usually happens when two branches each add one item to the same list and are merged one after the other.`);
+    }
+    if (hasOrdinary) {
+        advice.push(`${hasOverCap ? 'The other errors are' : '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.`);
+    }
     throw new Error(`CanopyCMS static build: found ${invalid.length} schema-invalid ${invalid.length === 1 ? 'entry' : 'entries'} during ${phaseLabel}:\n${lines.join('\n')}\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.`);
+        advice.join('\n'));
 }
 /**
  * Find every `urlPath` claimed by two or more entries.

package/dist/static/seo.d.ts

@@ -72,14 +72,16 @@ export type SeoFieldLocation = Pick<ExtractSeoFieldsOptions, 'fields' | 'group'>
  */
 export declare function extractSeoFields(entryData: unknown, opts?: ExtractSeoFieldsOptions): SeoFields;
 /**
- * THE `noindex` predicate. Every surface that suppresses an entry must route through this one
- * function rather than re-deriving the flag:
+ * THE `noindex` predicate. Every surface that reads the flag routes through this one function,
+ * with `opts` taken from `CanopyConfig.seo` (canopycms-next's free helpers take it as an
+ * argument instead), rather than re-deriving it:
  *
  * - the page's own `robots: { index: false }` (canopycms-next's `entryToMetadata`),
- * - exclusion from the sitemap (canopycms-next's `generateContentSitemap`), and
- * - exclusion from AI content (`ai/generate.ts`, unless `exclude.noindex: false`).
+ * - exclusion from the sitemap (canopycms-next's `generateContentSitemap`),
+ * - exclusion from AI content (`ai/generate.ts`, unless `exclude.noindex: false`), and
+ * - the marker on a reference picker's option (`ReferenceResolver.loadReferenceOptions`).
  *
- * Those surfaces shipping from one predicate is the point. Derived separately, a `noindex` entry
+ * One predicate at one configured location is the point. Derived separately, a `noindex` entry
  * stays advertised in one surface while correctly absent from another, and nothing warns.
  *
  * NOT applied to enumeration: `noindex` means "don't advertise this", not "don't build this".

package/dist/static/seo.js

@@ -75,7 +75,12 @@ const asTwitterCard = (value) => {
  * rather than throwing.
  */
 export function extractSeoFields(entryData, opts = {}) {
-    const names = { ...DEFAULT_SEO_FIELD_NAMES, ...opts.fields };
+    const names = { ...DEFAULT_SEO_FIELD_NAMES };
+    // Only a real name overrides: `{ noindex: undefined }` (an unset env var, say) keeps the default.
+    for (const [key, name] of Object.entries(opts.fields ?? {})) {
+        if (typeof name === 'string' && name !== '')
+            names[key] = name;
+    }
     const entry = asRecord(entryData);
     const source = opts.group ? asRecord(entry?.[opts.group]) : entry;
     return {
@@ -89,14 +94,16 @@ export function extractSeoFields(entryData, opts = {}) {
     };
 }
 /**
- * THE `noindex` predicate. Every surface that suppresses an entry must route through this one
- * function rather than re-deriving the flag:
+ * THE `noindex` predicate. Every surface that reads the flag routes through this one function,
+ * with `opts` taken from `CanopyConfig.seo` (canopycms-next's free helpers take it as an
+ * argument instead), rather than re-deriving it:
  *
  * - the page's own `robots: { index: false }` (canopycms-next's `entryToMetadata`),
- * - exclusion from the sitemap (canopycms-next's `generateContentSitemap`), and
- * - exclusion from AI content (`ai/generate.ts`, unless `exclude.noindex: false`).
+ * - exclusion from the sitemap (canopycms-next's `generateContentSitemap`),
+ * - exclusion from AI content (`ai/generate.ts`, unless `exclude.noindex: false`), and
+ * - the marker on a reference picker's option (`ReferenceResolver.loadReferenceOptions`).
  *
- * Those surfaces shipping from one predicate is the point. Derived separately, a `noindex` entry
+ * One predicate at one configured location is the point. Derived separately, a `noindex` entry
  * stays advertised in one surface while correctly absent from another, and nothing warns.
  *
  * NOT applied to enumeration: `noindex` means "don't advertise this", not "don't build this".

package/dist/utils/body-field.d.ts

@@ -1,4 +1,4 @@
-import type { FieldConfig } from '../config/index.js';
+import type { ContentFormat, FieldConfig } from '../config/index.js';
 /**
  * Count top-level fields marked `isBody: true`. Does NOT recurse into objects — `isBody` maps
  * to the file's markdown content, which exists only at the top level.
@@ -6,6 +6,14 @@ import type { FieldConfig } from '../config/index.js';
 export declare function countBodyFields(fields: readonly FieldConfig[]): number;
 /** Name of the `isBody: true` field, or `'body'`; maps the file's markdown onto a data field. */
 export declare function findBodyFieldName(fields: readonly FieldConfig[]): string;
+/** Name of the `isBody: true` field, or `undefined`: no `'body'` fallback. */
+export declare function findExplicitBodyFieldName(fields: readonly FieldConfig[]): string | undefined;
+/**
+ * The data a link-only reference (one without `includeBody: true`) carries for its target. A
+ * json/yaml entry's `isBody` field is its prose, so it is left out, as an md/mdx target's body
+ * is. Only an explicit `isBody` counts: a field merely named `body` is ordinary data.
+ */
+export declare function linkOnlyReferenceData(data: Record<string, unknown>, format: ContentFormat, fields: readonly FieldConfig[] | undefined): Record<string, unknown>;
 /**
  * Find an isBody field whose NAME is reserved by reference resolution.
  *

package/dist/utils/body-field.js

@@ -1,4 +1,5 @@
 import { flattenGroupFields } from './flatten-group-fields.js';
+import { isDataOnlyFormat } from './format.js';
 const BODY_FIELD_TYPES = new Set(['markdown', 'mdx']);
 /**
  * Count top-level fields marked `isBody: true`. Does NOT recurse into objects — `isBody` maps
@@ -14,11 +15,27 @@ export function countBodyFields(fields) {
 }
 /** Name of the `isBody: true` field, or `'body'`; maps the file's markdown onto a data field. */
 export function findBodyFieldName(fields) {
+    return findExplicitBodyFieldName(fields) ?? 'body';
+}
+/** Name of the `isBody: true` field, or `undefined`: no `'body'` fallback. */
+export function findExplicitBodyFieldName(fields) {
     for (const field of flattenGroupFields(fields)) {
         if ('isBody' in field && field.isBody)
             return field.name;
     }
-    return 'body';
+    return undefined;
+}
+/**
+ * The data a link-only reference (one without `includeBody: true`) carries for its target. A
+ * json/yaml entry's `isBody` field is its prose, so it is left out, as an md/mdx target's body
+ * is. Only an explicit `isBody` counts: a field merely named `body` is ordinary data.
+ */
+export function linkOnlyReferenceData(data, format, fields) {
+    const bodyFieldName = isDataOnlyFormat(format) && fields ? findExplicitBodyFieldName(fields) : undefined;
+    if (bodyFieldName === undefined || !(bodyFieldName in data))
+        return data;
+    const { [bodyFieldName]: _body, ...rest } = data;
+    return rest;
 }
 /**
  * Find an isBody field whose NAME is reserved by reference resolution.

package/dist/validation/entry-validator.d.ts

@@ -20,6 +20,11 @@ import type { ContentFormat, EntrySchema } from '../config/index.js';
 export interface EntryFieldError {
     fieldPath: string;
     message: string;
+    /** Set on an over-cap list's error, so a caller can say how to fix it. */
+    maxItems?: {
+        count: number;
+        cap: number;
+    };
 }
 /**
  * Merge an md/mdx body string into the data record under the schema's body

package/dist/validation/entry-validator.js

@@ -173,6 +173,18 @@ export function validateEntryData(fields, data, pathPrefix = '', options = {}) {
         }
         if (value === undefined || value === null)
             continue;
+        // No `continue`: the items inside an over-cap list are still checked and reported.
+        if (Array.isArray(value) &&
+            'maxItems' in field &&
+            typeof field.maxItems === 'number' &&
+            value.length > field.maxItems) {
+            const cap = field.maxItems;
+            errors.push({
+                fieldPath: path,
+                message: `At most ${cap} ${cap === 1 ? 'item' : 'items'}; this list has ${value.length}`,
+                maxItems: { count: value.length, cap },
+            });
+        }
         if (field.type === 'block') {
             const blockField = field;
             if (!Array.isArray(value)) {

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const CANOPYCMS_VERSION = "0.3.3";
+export declare const CANOPYCMS_VERSION = "0.5.0";

package/dist/version.js

@@ -1,3 +1,3 @@
 // Generated by scripts/bump-version.mjs, its only writer. The package builds with plain
 // tsc (rootDir: src), so src/ cannot import ../package.json; version.test.ts keeps the two equal.
-export const CANOPYCMS_VERSION = '0.3.3';
+export const CANOPYCMS_VERSION = '0.5.0';

package/package.json

@@ -1,7 +1,7 @@
 {
   "//": "@codemirror/language, @lezer/highlight: workaround — @mdxeditor/editor uses cm6-theme-basic-light which peer-requires these but mdxeditor doesn't declare them as dependencies",
   "name": "canopycms",
-  "version": "0.3.3",
+  "version": "0.5.0",
   "description": "CanopyCMS core package: schema-driven content, branch-aware editing, and editor UI for Next.js.",
   "license": "MIT",
   "repository": {