includio-cms 0.6.0 → 0.6.2

package/dist/core/fields/layoutUtils.js

@@ -5,7 +5,8 @@ export function getFieldsFromConfig(config) {
 export function hasLayout(config) {
     return !!config.layout;
 }
-/** Collect all field slugs referenced in layout nodes (depth-first order) */
+/** Collect all field paths referenced in layout nodes (depth-first order).
+ *  Supports both plain slugs ('title') and dot-notation ('hero.title'). */
 export function collectFieldSlugs(nodes) {
     const slugs = [];
     for (const node of nodes) {
@@ -18,28 +19,133 @@ export function collectFieldSlugs(nodes) {
     }
     return slugs;
 }
+/**
+ * Resolve a field definition by dot-notation path.
+ * E.g. 'companyInfo.contact.email' navigates: fields → companyInfo → fields → contact → fields → email
+ */
+export function resolveFieldByPath(fields, path) {
+    const parts = path.split('.');
+    let current = fields;
+    for (let i = 0; i < parts.length; i++) {
+        const field = current.find((f) => f.slug === parts[i]);
+        if (!field)
+            return undefined;
+        if (i === parts.length - 1)
+            return field;
+        if (field.type !== 'object' || !('fields' in field))
+            return undefined;
+        current = field.fields;
+    }
+    return undefined;
+}
+/**
+ * Collect all leaf field paths from field definitions (recursively flattens objects).
+ * E.g. an object 'hero' with fields 'title','image' → ['hero.title', 'hero.image']
+ * Non-object fields at top level → ['slug']
+ */
+export function collectAllLeafPaths(fields, prefix = '') {
+    const paths = [];
+    for (const f of fields) {
+        const fullPath = prefix ? `${prefix}.${f.slug}` : f.slug;
+        if (f.type === 'object' && 'fields' in f) {
+            paths.push(...collectAllLeafPaths(f.fields, fullPath));
+        }
+        else {
+            paths.push(fullPath);
+        }
+    }
+    return paths;
+}
+/**
+ * Expand a layout field reference into leaf paths.
+ * - 'title' (non-object) → ['title']
+ * - 'hero' (object with fields) → ['hero.title', 'hero.image', ...]
+ * - 'hero.title' (dot-notation to leaf) → ['hero.title']
+ */
+function expandToLeafPaths(ref, fields) {
+    const resolved = resolveFieldByPath(fields, ref);
+    if (!resolved)
+        return [ref]; // unresolved — let validation catch it
+    if (resolved.type === 'object' && 'fields' in resolved) {
+        return collectAllLeafPaths(resolved.fields, ref);
+    }
+    return [ref];
+}
+/**
+ * Identify top-level object slugs where ALL leaf fields are individually
+ * distributed across layout nodes (via dot-notation).
+ * These objects should suppress their own wrapper rendering.
+ */
+export function getDistributedObjectSlugs(nodes, fields) {
+    const refs = collectFieldSlugs(nodes);
+    const distributed = new Set();
+    for (const f of fields) {
+        if (f.type !== 'object' || !('fields' in f))
+            continue;
+        // Check: is this object referenced as a whole?
+        if (refs.includes(f.slug))
+            continue;
+        // Get all leaf paths for this object
+        const leafPaths = collectAllLeafPaths(f.fields, f.slug);
+        if (leafPaths.length === 0)
+            continue;
+        // Check if ALL leaf paths are covered by layout refs
+        const allCovered = leafPaths.every((lp) => refs.includes(lp));
+        if (allCovered)
+            distributed.add(f.slug);
+    }
+    return distributed;
+}
+/**
+ * Build SuperForm-compatible path for a dot-notation field reference.
+ * 'hero.title' → 'hero.data.title'
+ * 'hero.contact.email' → 'hero.data.contact.data.email'
+ * 'title' → 'title' (no change for top-level)
+ */
+export function buildFormPath(dotPath) {
+    const parts = dotPath.split('.');
+    if (parts.length <= 1)
+        return dotPath;
+    const result = [parts[0]];
+    for (let i = 1; i < parts.length; i++) {
+        result.push('data', parts[i]);
+    }
+    return result.join('.');
+}
 /** Count columns expected by a ratio string */
 function columnCount(ratio) {
     return ratio.split(' ').length;
 }
-/** Validate layout against fields — returns errors or empty array */
+/** Validate layout against fields — returns errors or empty array.
+ *  Supports dot-notation paths (e.g. 'hero.title'). */
 export function validateLayout(nodes, fields) {
     const errors = [];
-    const fieldSlugs = new Set(fields.map((f) => f.slug));
+    const topLevelSlugs = new Set(fields.map((f) => f.slug));
     const referencedSlugs = collectFieldSlugs(nodes);
-    // Check for missing fields
+    // Check for missing fields — support both top-level slugs and dot-notation
     for (const slug of referencedSlugs) {
-        if (!fieldSlugs.has(slug)) {
-            errors.push({ type: 'missing_field', message: `Field "${slug}" not found in fields[]` });
+        if (slug.includes('.')) {
+            // Dot-notation: resolve through field tree
+            if (!resolveFieldByPath(fields, slug)) {
+                errors.push({ type: 'missing_field', message: `Field "${slug}" not found in fields[]` });
+            }
+        }
+        else {
+            if (!topLevelSlugs.has(slug)) {
+                errors.push({ type: 'missing_field', message: `Field "${slug}" not found in fields[]` });
+            }
         }
     }
-    // Check for duplicates
-    const seen = new Set();
-    for (const slug of referencedSlugs) {
-        if (seen.has(slug)) {
-            errors.push({ type: 'duplicate_field', message: `Field "${slug}" referenced multiple times` });
+    // Check for duplicates (expand to leaf paths for overlap detection)
+    const seenLeaves = new Set();
+    for (const ref of referencedSlugs) {
+        const leaves = expandToLeafPaths(ref, fields);
+        for (const leaf of leaves) {
+            if (seenLeaves.has(leaf)) {
+                errors.push({ type: 'duplicate_field', message: `Field "${leaf}" referenced multiple times` });
+            }
+            seenLeaves.add(leaf);
         }
-        seen.add(slug);
     }
     // Check depth + columns
     function walk(nodeList, depth) {
@@ -72,7 +178,8 @@ export function resolveLayout(layout, fields) {
         return layout;
     return expandPreset(layout, fields);
 }
-/** Resolve layout + append orphan fields in a trailing section */
+/** Resolve layout + append orphan fields in a trailing section.
+ *  Orphan detection works at leaf level — dot-notation refs count as covering their leaves. */
 export function resolveLayoutWithOrphans(config) {
     if (!config.layout) {
         // No layout — single section with all fields
@@ -85,16 +192,37 @@ export function resolveLayoutWithOrphans(config) {
         ];
     }
     const nodes = resolveLayout(config.layout, config.fields);
-    const referenced = new Set(collectFieldSlugs(nodes));
-    const orphans = config.fields.filter((f) => !referenced.has(f.slug)).map((f) => f.slug);
-    if (orphans.length === 0)
+    const refs = collectFieldSlugs(nodes);
+    // Expand all refs to leaf paths for coverage checking
+    const coveredLeaves = new Set();
+    for (const ref of refs) {
+        for (const leaf of expandToLeafPaths(ref, config.fields)) {
+            coveredLeaves.add(leaf);
+        }
+    }
+    // Find orphan top-level fields (not covered at all)
+    const allLeaves = collectAllLeafPaths(config.fields);
+    const orphanTopSlugs = [];
+    for (const f of config.fields) {
+        if (f.type === 'object' && 'fields' in f) {
+            const objectLeaves = collectAllLeafPaths(f.fields, f.slug);
+            const anyCovered = objectLeaves.some((lp) => coveredLeaves.has(lp));
+            if (!anyCovered)
+                orphanTopSlugs.push(f.slug);
+        }
+        else {
+            if (!coveredLeaves.has(f.slug))
+                orphanTopSlugs.push(f.slug);
+        }
+    }
+    if (orphanTopSlugs.length === 0)
         return nodes;
     return [
         ...nodes,
         {
             type: 'section',
             label: { en: 'Other', pl: 'Pozostałe' },
-            fields: orphans
+            fields: orphanTopSlugs
         }
     ];
 }

package/dist/core/server/generator/generator.js

@@ -31,7 +31,8 @@ function generateTypesStringForRecords(type, records) {
 		export type ${recordTypeString}EntryMap = {
 			${records
         .map((single) => {
-        return `${single.slug}: ${toPascalCase(single.slug)}`;
+        const key = single.slug.includes('-') ? `'${single.slug}'` : single.slug;
+        return `${key}: ${toPascalCase(single.slug)}`;
     })
         .join(';\n')}
 		}
@@ -58,7 +59,8 @@ function generateTypesStringForForms(records) {
 		export type ${recordTypeString}EntryMap = {
 			${records
         .map((single) => {
-        return `${single.slug}: ${toPascalCase(single.slug)}`;
+        const key = single.slug.includes('-') ? `'${single.slug}'` : single.slug;
+        return `${key}: ${toPascalCase(single.slug)}`;
     })
         .join(';\n')}
 		}
@@ -94,10 +96,10 @@ function generateAPI(config) {
 	`;
     code += `
 
-		interface GetEntryQueryOptions<T extends { data: Record<string, unknown> }> {
+		interface GetEntryQueryOptions {
 			id?: string;
 			status?: 'draft' | 'published' | 'scheduled' | 'archived';
-			dataValues?: Partial<T['data']>;
+			dataValues?: Record<string, unknown>;
 		}
 
 		interface GetEntryOptions {
@@ -118,7 +120,7 @@ function generateAPI(config) {
 		`;
     code += `
 
-		export async function getSingleEntry<K extends SingleSlug>(slug: K, data: GetEntryQueryOptions<SingleEntryMap[K]>, options: GetEntryOptions): Promise<SingleEntryMap[K] | null> {
+		export async function getSingleEntry<K extends SingleSlug>(slug: K, data: GetEntryQueryOptions, options: GetEntryOptions): Promise<SingleEntryMap[K] | null> {
 			return (await getEntry({
 			  ...data,
 				slug,
@@ -126,7 +128,7 @@ function generateAPI(config) {
 			})) as unknown as SingleEntryMap[K] | null;
 		}
 
-		export async function getCollectionEntry<K extends CollectionSlug>(slug: K, data: GetEntryQueryOptions<CollectionEntryMap[K]>, options: GetEntryOptions): Promise<CollectionEntryMap[K] | null> {
+		export async function getCollectionEntry<K extends CollectionSlug>(slug: K, data: GetEntryQueryOptions, options: GetEntryOptions): Promise<CollectionEntryMap[K] | null> {
 			return (await getEntry({
 			  ...data,
 				slug,
@@ -134,7 +136,15 @@ function generateAPI(config) {
 			})) as unknown as CollectionEntryMap[K] | null;
 		}
 
-		export async function getCollectionEntries<K extends CollectionSlug>(slug: K, options: GetEntryOptions): Promise<CollectionEntryMap[K][]> {
+		interface GetEntriesQueryOptions {
+			ids?: string[];
+			status?: 'draft' | 'published' | 'scheduled' | 'archived';
+			dataValues?: Record<string, unknown>;
+			dataLike?: Record<string, unknown>;
+			orderBy?: { column: 'createdAt' | 'updatedAt' | 'sortOrder'; direction: 'asc' | 'desc' };
+		}
+
+		export async function getCollectionEntries<K extends CollectionSlug>(slug: K, options: GetEntryOptions & GetEntriesQueryOptions = {}): Promise<CollectionEntryMap[K][]> {
 			return (await getEntries({ slug, ...options })) as unknown as CollectionEntryMap[K][];
 		}
 
@@ -162,8 +172,9 @@ function generateSchemas(config) {
 		import { z } from 'zod';
 	`;
     config.forms?.map((form) => {
+        const varName = toPascalCase(form.slug);
         code += `
-			export const ${form.slug}FormSchema = ${generateZodSchemaStringFromFormFieldsAsString(form.fields)} \n
+			export const ${varName}FormSchema = ${generateZodSchemaStringFromFormFieldsAsString(form.fields)} \n
 		`;
     });
     writeFileSync(filePath, code);
@@ -177,13 +188,13 @@ function generateRemote(config) {
     code += `import { command } from '$app/server';\n`;
     code += `import { submitForm } from './api';\n`;
     const schemaImports = config.forms
-        .map((form) => `${form.slug}FormSchema`)
+        .map((form) => `${toPascalCase(form.slug)}FormSchema`)
         .join(', ');
     code += `import { ${schemaImports} } from './schemas';\n\n`;
     config.forms.forEach((form) => {
         const pascalSlug = toPascalCase(form.slug);
         code += `export const submit${pascalSlug}Command = command(\n`;
-        code += `\t${form.slug}FormSchema,\n`;
+        code += `\t${pascalSlug}FormSchema,\n`;
         code += `\tasync (data) => {\n`;
         code += `\t\tawait submitForm('${form.slug}', data);\n`;
         code += `\t}\n`;

package/dist/entity/index.d.ts

@@ -0,0 +1,26 @@
+import type { CMS } from '../core/cms.js';
+import type { DbEntry, DbEntryVersion, EntryData } from '../types/entries.js';
+interface EntityAPIOptions {
+    userId?: string;
+}
+interface CreateOptions {
+    skipValidation?: boolean;
+    sortOrder?: number;
+}
+export declare function createEntityAPI(cms: CMS, opts?: EntityAPIOptions): {
+    create(slug: string, data?: EntryData, options?: CreateOptions): Promise<DbEntry>;
+    update(entryId: string, data: EntryData, options?: {
+        skipValidation?: boolean;
+    }): Promise<DbEntryVersion>;
+    publish(entryId: string): Promise<void>;
+    unpublish(entryId: string): Promise<void>;
+    archive(entryId: string): Promise<void>;
+    unarchive(entryId: string): Promise<void>;
+    delete(entryId: string): Promise<void>;
+    list(slug: string, options?: {
+        includeArchived?: boolean;
+        onlyArchived?: boolean;
+    }): Promise<import("../types/entries.js").RawEntry[]>;
+    createAndPublish(slug: string, data: EntryData, options?: CreateOptions): Promise<DbEntry>;
+};
+export {};

package/dist/entity/index.js

@@ -0,0 +1,113 @@
+import { generateZodSchemaFromFields } from '../core/fields/fieldSchemaToTs.js';
+import { getFieldsFromConfig } from '../core/fields/layoutUtils.js';
+import { getRawEntries } from '../core/server/entries/operations/get.js';
+export function createEntityAPI(cms, opts) {
+    const db = cms.databaseAdapter;
+    const userId = opts?.userId ?? 'system';
+    function validate(slug, data) {
+        const config = cms.getBySlug(slug);
+        const schema = generateZodSchemaFromFields(getFieldsFromConfig(config), cms.languages);
+        const result = schema.safeParse(data);
+        if (!result.success) {
+            throw Error('Invalid data: ' + JSON.stringify(result.error.flatten()));
+        }
+        return result.data;
+    }
+    return {
+        async create(slug, data, options) {
+            const config = cms.getBySlug(slug);
+            const type = config.type === 'collection' ? 'collection' : 'singleton';
+            const entry = await db.createEntry({
+                slug,
+                type,
+                sortOrder: options?.sortOrder ?? null
+            });
+            const entryData = data ?? {};
+            const validatedData = data && !options?.skipValidation ? validate(slug, entryData) : entryData;
+            await db.createEntryVersion({
+                entryId: entry.id,
+                data: validatedData,
+                createdBy: userId
+            });
+            return entry;
+        },
+        async update(entryId, data, options) {
+            const entries = await db.getEntries({ ids: [entryId] });
+            const entry = entries[0];
+            if (!entry)
+                throw Error('Entry not found');
+            const validatedData = !options?.skipValidation ? validate(entry.slug, data) : data;
+            const versions = await db.getEntryVersions({ entryIds: [entryId] });
+            const sorted = versions.sort((a, b) => b.versionNumber - a.versionNumber);
+            const latestDraft = sorted.find((v) => v.id !== entry.publishedVersionId);
+            if (latestDraft) {
+                if (JSON.stringify(latestDraft.data) === JSON.stringify(validatedData)) {
+                    return latestDraft;
+                }
+                return db.updateEntryVersion({
+                    id: latestDraft.id,
+                    data: { data: validatedData, createdAt: new Date() }
+                });
+            }
+            return db.createEntryVersion({
+                entryId,
+                data: validatedData,
+                createdBy: userId
+            });
+        },
+        async publish(entryId) {
+            const versions = await db.getEntryVersions({ entryIds: [entryId] });
+            const entries = await db.getEntries({ ids: [entryId] });
+            const entry = entries[0];
+            if (!entry)
+                throw Error('Entry not found');
+            const draft = versions
+                .filter((v) => v.id !== entry.publishedVersionId)
+                .sort((a, b) => b.versionNumber - a.versionNumber)[0];
+            if (!draft)
+                throw Error('No draft to publish');
+            await db.updateEntry({
+                id: entryId,
+                data: {
+                    publishedVersionId: draft.id,
+                    publishedAt: new Date(),
+                    publishedBy: userId,
+                    archivedAt: null
+                }
+            });
+        },
+        async unpublish(entryId) {
+            await db.updateEntry({
+                id: entryId,
+                data: {
+                    publishedVersionId: null,
+                    publishedAt: null,
+                    publishedBy: null
+                }
+            });
+        },
+        async archive(entryId) {
+            await db.updateEntry({
+                id: entryId,
+                data: { archivedAt: new Date() }
+            });
+        },
+        async unarchive(entryId) {
+            await db.updateEntry({
+                id: entryId,
+                data: { archivedAt: null }
+            });
+        },
+        async delete(entryId) {
+            await db.deleteEntry({ id: entryId });
+        },
+        async list(slug, options) {
+            return getRawEntries({ slug, ...options });
+        },
+        async createAndPublish(slug, data, options) {
+            const entry = await this.create(slug, data, options);
+            await this.publish(entry.id);
+            return entry;
+        }
+    };
+}

package/dist/paraglide/messages/_index.d.ts

@@ -1,3 +1,36 @@
-export * from "./hello_world.js";
-export * from "./login_hello.js";
-export * from "./login_please_login.js";
+export function hello_world(inputs: {
+    name: NonNullable<unknown>;
+}, options?: {
+    locale?: "en" | "pl";
+}): string;
+/**
+* This function has been compiled by [Paraglide JS](https://inlang.com/m/gerre34r).
+*
+* - Changing this function will be over-written by the next build.
+*
+* - If you want to change the translations, you can either edit the source files e.g. `en.json`, or
+* use another inlang app like [Fink](https://inlang.com/m/tdozzpar) or the [VSCode extension Sherlock](https://inlang.com/m/r7kp499g).
+*
+* @param {{}} inputs
+* @param {{ locale?: "en" | "pl" }} options
+* @returns {string}
+*/
+declare function login_hello(inputs?: {}, options?: {
+    locale?: "en" | "pl";
+}): string;
+/**
+* This function has been compiled by [Paraglide JS](https://inlang.com/m/gerre34r).
+*
+* - Changing this function will be over-written by the next build.
+*
+* - If you want to change the translations, you can either edit the source files e.g. `en.json`, or
+* use another inlang app like [Fink](https://inlang.com/m/tdozzpar) or the [VSCode extension Sherlock](https://inlang.com/m/r7kp499g).
+*
+* @param {{}} inputs
+* @param {{ locale?: "en" | "pl" }} options
+* @returns {string}
+*/
+declare function login_please_login(inputs?: {}, options?: {
+    locale?: "en" | "pl";
+}): string;
+export { login_hello as login.hello, login_please_login as login.please_login };

package/dist/paraglide/messages/_index.js

@@ -1,4 +1,72 @@
 /* eslint-disable */
-export * from './hello_world.js'
-export * from './login_hello.js'
-export * from './login_please_login.js'
+import { getLocale, trackMessageCall, experimentalMiddlewareLocaleSplitting, isServer } from "../runtime.js"
+import * as en from "./en.js"
+import * as pl from "./pl.js"
+/**
+* This function has been compiled by [Paraglide JS](https://inlang.com/m/gerre34r).
+*
+* - Changing this function will be over-written by the next build.
+*
+* - If you want to change the translations, you can either edit the source files e.g. `en.json`, or
+* use another inlang app like [Fink](https://inlang.com/m/tdozzpar) or the [VSCode extension Sherlock](https://inlang.com/m/r7kp499g).
+* 
+* @param {{ name: NonNullable<unknown> }} inputs
+* @param {{ locale?: "en" | "pl" }} options
+* @returns {string}
+*/
+/* @__NO_SIDE_EFFECTS__ */
+export const hello_world = (inputs, options = {}) => {
+	if (experimentalMiddlewareLocaleSplitting && isServer === false) {
+		return /** @type {any} */ (globalThis).__paraglide_ssr.hello_world(inputs) 
+	}
+	const locale = options.locale ?? getLocale()
+	trackMessageCall("hello_world", locale)
+	if (locale === "en") return en.hello_world(inputs)
+	return pl.hello_world(inputs)
+};
+/**
+* This function has been compiled by [Paraglide JS](https://inlang.com/m/gerre34r).
+*
+* - Changing this function will be over-written by the next build.
+*
+* - If you want to change the translations, you can either edit the source files e.g. `en.json`, or
+* use another inlang app like [Fink](https://inlang.com/m/tdozzpar) or the [VSCode extension Sherlock](https://inlang.com/m/r7kp499g).
+* 
+* @param {{}} inputs
+* @param {{ locale?: "en" | "pl" }} options
+* @returns {string}
+*/
+/* @__NO_SIDE_EFFECTS__ */
+const login_hello = (inputs = {}, options = {}) => {
+	if (experimentalMiddlewareLocaleSplitting && isServer === false) {
+		return /** @type {any} */ (globalThis).__paraglide_ssr.login_hello(inputs) 
+	}
+	const locale = options.locale ?? getLocale()
+	trackMessageCall("login_hello", locale)
+	if (locale === "en") return en.login_hello(inputs)
+	return pl.login_hello(inputs)
+};
+export { login_hello as "login.hello" }
+/**
+* This function has been compiled by [Paraglide JS](https://inlang.com/m/gerre34r).
+*
+* - Changing this function will be over-written by the next build.
+*
+* - If you want to change the translations, you can either edit the source files e.g. `en.json`, or
+* use another inlang app like [Fink](https://inlang.com/m/tdozzpar) or the [VSCode extension Sherlock](https://inlang.com/m/r7kp499g).
+* 
+* @param {{}} inputs
+* @param {{ locale?: "en" | "pl" }} options
+* @returns {string}
+*/
+/* @__NO_SIDE_EFFECTS__ */
+const login_please_login = (inputs = {}, options = {}) => {
+	if (experimentalMiddlewareLocaleSplitting && isServer === false) {
+		return /** @type {any} */ (globalThis).__paraglide_ssr.login_please_login(inputs) 
+	}
+	const locale = options.locale ?? getLocale()
+	trackMessageCall("login_please_login", locale)
+	if (locale === "en") return en.login_please_login(inputs)
+	return pl.login_please_login(inputs)
+};
+export { login_please_login as "login.please_login" }

package/dist/paraglide/messages/en.d.ts

@@ -0,0 +1,5 @@
+export const hello_world: (inputs: {
+    name: NonNullable<unknown>;
+}) => string;
+export const login_hello: (inputs: {}) => string;
+export const login_please_login: (inputs: {}) => string;

package/dist/paraglide/messages/en.js

@@ -0,0 +1,14 @@
+/* eslint-disable */
+
+
+export const hello_world = /** @type {(inputs: { name: NonNullable<unknown> }) => string} */ (i) => {
+	return `Hello, ${i.name} from en!`
+};
+
+export const login_hello = /** @type {(inputs: {}) => string} */ () => {
+	return `Welcome back`
+};
+
+export const login_please_login = /** @type {(inputs: {}) => string} */ () => {
+	return `Login to your account`
+};

package/dist/paraglide/messages/pl.d.ts

@@ -0,0 +1,5 @@
+export const hello_world: (inputs: {
+    name: NonNullable<unknown>;
+}) => string;
+export const login_hello: (inputs: {}) => string;
+export const login_please_login: (inputs: {}) => string;

package/dist/paraglide/messages/pl.js

@@ -0,0 +1,14 @@
+/* eslint-disable */
+
+
+export const hello_world = /** @type {(inputs: { name: NonNullable<unknown> }) => string} */ (i) => {
+	return `Hello, ${i.name} from pl!`
+};
+
+export const login_hello = /** @type {(inputs: {}) => string} */ () => {
+	return `Witaj ponownie`
+};
+
+export const login_please_login = /** @type {(inputs: {}) => string} */ () => {
+	return `Zaloguj się na swoje konto`
+};

package/dist/types/layout.d.ts

@@ -17,6 +17,10 @@ interface LayoutNodeBase {
 export interface SectionNode extends LayoutNodeBase {
     type: 'section';
     label: Localized;
+    /**
+     * Field references — supports top-level slugs and dot-notation for object fields.
+     * @example ['title', 'hero.subtitle', 'companyInfo.contact.email']
+     */
     fields?: string[];
     children?: LayoutNode[];
 }
@@ -28,6 +32,10 @@ export interface ColumnsNode extends LayoutNodeBase {
 export interface CardNode extends LayoutNodeBase {
     type: 'card';
     label: Localized;
+    /**
+     * Field references — supports top-level slugs and dot-notation for object fields.
+     * @example ['companyInfo.name', 'companyInfo.motto'] — fields from different objects in one card
+     */
     fields?: string[];
     children?: LayoutNode[];
     autoGrid?: boolean;

package/dist/updates/0.6.0/index.d.ts

@@ -0,0 +1,2 @@
+import type { CmsUpdate } from '../index.js';
+export declare const update: CmsUpdate;

package/dist/updates/0.6.0/index.js

@@ -0,0 +1,20 @@
+export const update = {
+    version: '0.6.0',
+    date: '2026-03-10',
+    description: 'Entity module, collection filters, layout dot-notation, peerDeps migration',
+    features: [
+        'Entity module — programmatic CRUD API for entries (`getEntity`)',
+        'CLI `install-peers` command for automatic peer dependency installation',
+        'Collection data filters — filter entries by select/radio field values in toolbar',
+        'Layout dot-notation — distribute object fields across layout nodes'
+    ],
+    fixes: [
+        'AI Claude: lazy client init, no crash without API key',
+        'Codegen: quote hyphenated slugs, PascalCase form schemas, improved query types',
+        'TipTap: inline block content field lang fix + placeholder UX',
+        'Zod schema: skip lang wrapper for non-localized content field'
+    ],
+    breakingChanges: [
+        'Runtime dependencies moved to peerDependencies — run `pnpm includio install-peers` after upgrade'
+    ]
+};

package/dist/updates/0.6.1/index.d.ts

@@ -0,0 +1,2 @@
+import type { CmsUpdate } from '../index.js';
+export declare const update: CmsUpdate;

package/dist/updates/0.6.1/index.js

@@ -0,0 +1,9 @@
+export const update = {
+    version: '0.6.1',
+    date: '2026-03-10',
+    description: 'Maintenance release — update definitions, changelog, roadmap',
+    features: [],
+    fixes: [],
+    breakingChanges: [],
+    notes: 'No functional changes'
+};

package/dist/updates/0.6.2/index.d.ts

@@ -0,0 +1,2 @@
+import type { CmsUpdate } from '../index.js';
+export declare const update: CmsUpdate;