includio-cms 0.16.0 → 0.18.0

package/dist/core/server/fields/populateEntry.d.ts

@@ -1,3 +1,11 @@
 import type { EntryData, PopulatedEntryData } from '../../../types/entries.js';
 import type { Field } from '../../../types/fields.js';
-export declare function populateEntryData(data: EntryData, fields: Field[], language: string, entryId?: string): Promise<PopulatedEntryData>;
+import type { PopulateCtx } from '../entries/operations/resolveEntry.js';
+/**
+ * Internal populate chain: relations → urls → media → richtext → custom → shop → typography orphans.
+ * Carries `ctx` (locale, status, depth, visited, populate config, current entryId) so every nested
+ * field resolver can cascade locale + recursion guards consistently.
+ *
+ * Not part of the public API. Userland uses `resolveEntry`/`resolveEntries`.
+ */
+export declare function _populate(data: EntryData, fields: Field[], ctx: PopulateCtx): Promise<PopulatedEntryData>;

package/dist/core/server/fields/populateEntry.js

@@ -5,11 +5,8 @@ import { resolveUrlFields } from './resolveUrlFields.js';
 import { resolveTypographyOrphans } from './resolveTypographyOrphans.js';
 import { getCMS } from '../../cms.js';
 import { resolveShopFields } from '../../../shop/server/populate.js';
-async function resolveCustomFields(data, fields) {
-    // Check if any custom fields exist before accessing CMS
-    const hasCustom = fields.some((f) => f.type === 'custom' ||
-        f.type === 'object' ||
-        f.type === 'blocks');
+async function resolveCustomFields(data, fields, ctx) {
+    const hasCustom = fields.some((f) => f.type === 'custom' || f.type === 'object' || f.type === 'blocks');
     if (!hasCustom)
         return data;
     let cms;
@@ -26,13 +23,14 @@ async function resolveCustomFields(data, fields) {
             case 'custom': {
                 const def = cms.customFields.get(field.fieldType);
                 if (def?.populateResolver && val != null) {
-                    result[field.slug] = await def.populateResolver(val, field);
+                    // Plugin populateResolver receives ctx as 3rd arg (breaking in 0.17.0; plugin API @experimental)
+                    result[field.slug] = await def.populateResolver(val, field, ctx);
                 }
                 break;
             }
             case 'object':
                 if (val && typeof val === 'object') {
-                    result[field.slug] = await resolveCustomFields(val, field.fields);
+                    result[field.slug] = await resolveCustomFields(val, field.fields, ctx);
                 }
                 break;
             case 'blocks':
@@ -40,7 +38,7 @@ async function resolveCustomFields(data, fields) {
                     result[field.slug] = await Promise.all(val.map(async (item) => {
                         const blockDef = field.of.find((d) => d.slug === item._slug);
                         if (blockDef) {
-                            return await resolveCustomFields(item, blockDef.fields);
+                            return await resolveCustomFields(item, blockDef.fields, ctx);
                         }
                         return item;
                     }));
@@ -50,14 +48,20 @@ async function resolveCustomFields(data, fields) {
     }
     return result;
 }
-export async function populateEntryData(data, fields, language, entryId) {
-    let populatedData = await resolveRelationFields(data, fields, language);
-    populatedData = await resolveUrlFields(populatedData, fields, language);
-    populatedData = await resolveMediaFields(populatedData, fields);
-    populatedData = await resolveRichtextLinks(populatedData, fields, language);
-    populatedData = (await resolveCustomFields(populatedData, fields));
-    populatedData = (await resolveShopFields(populatedData, fields, entryId));
-    // Typography orphan fix — enabled by default, opt-out via config
+/**
+ * Internal populate chain: relations → urls → media → richtext → custom → shop → typography orphans.
+ * Carries `ctx` (locale, status, depth, visited, populate config, current entryId) so every nested
+ * field resolver can cascade locale + recursion guards consistently.
+ *
+ * Not part of the public API. Userland uses `resolveEntry`/`resolveEntries`.
+ */
+export async function _populate(data, fields, ctx) {
+    let populated = await resolveRelationFields(data, fields, ctx);
+    populated = await resolveUrlFields(populated, fields, ctx);
+    populated = await resolveMediaFields(populated, fields);
+    populated = await resolveRichtextLinks(populated, fields, ctx);
+    populated = (await resolveCustomFields(populated, fields, ctx));
+    populated = (await resolveShopFields(populated, fields, ctx));
     let fixOrphans = true;
     try {
         fixOrphans = getCMS().typographyConfig.fixOrphans !== false;
@@ -66,7 +70,7 @@ export async function populateEntryData(data, fields, language, entryId) {
         // CMS not initialized — keep default
     }
     if (fixOrphans) {
-        populatedData = resolveTypographyOrphans(populatedData, fields);
+        populated = resolveTypographyOrphans(populated, fields);
     }
-    return populatedData;
+    return populated;
 }

package/dist/core/server/fields/resolveRelationFields.d.ts

@@ -1,3 +1,4 @@
 import type { EntryData, PopulatedEntryData } from '../../../types/entries.js';
 import type { Field } from '../../../types/fields.js';
-export declare function resolveRelationFields(data: EntryData, fields: Field[], language: string): Promise<PopulatedEntryData>;
+import type { PopulateCtx } from '../entries/operations/resolveEntry.js';
+export declare function resolveRelationFields(data: EntryData, fields: Field[], ctx: PopulateCtx): Promise<PopulatedEntryData>;

package/dist/core/server/fields/resolveRelationFields.js

@@ -1,53 +1,72 @@
 import { walkInlineBlockNodes, cloneDoc } from '../../../admin/components/tiptap/structured-content-utils.js';
-import z from 'zod';
-export async function resolveRelationFields(data, fields, language) {
+import { getCMS } from '../../cms.js';
+import { getFieldsFromConfig } from '../../fields/layoutUtils.js';
+import { getEntrySlugPath, getSlugFromEntryData, getEntryPath } from './slugResolver.js';
+function pickVersion(versions, status) {
+    const sorted = versions.slice().sort((a, b) => b.versionNumber - a.versionNumber);
+    const now = new Date();
+    switch (status) {
+        case 'published':
+            return sorted.find((v) => v.publishedAt != null && v.publishedAt <= now) ?? null;
+        case 'draft':
+            return sorted.find((v) => v.publishedAt == null) ?? null;
+        case 'scheduled':
+            return sorted.find((v) => v.publishedAt != null && v.publishedAt > now) ?? null;
+    }
+}
+export async function resolveRelationFields(data, fields, ctx) {
     const entriesIds = [];
+    const optedOutFields = new Set();
+    // Collect ids skipping fields opted out at top level (raw passthrough).
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const collectIds = (value, fields) => {
+    const collectIds = (value, fields, topLevel) => {
         for (const field of fields) {
             const val = value?.[field.slug];
             if (val == null)
                 continue;
+            if (topLevel && ctx.populate.fields?.[field.slug] === false) {
+                optedOutFields.add(field.slug);
+                continue;
+            }
             switch (field.type) {
                 case 'relation': {
                     if (field.multiple && Array.isArray(val)) {
-                        val.forEach((id) => {
-                            if (z.string().uuid().safeParse(id).success) {
+                        for (const id of val) {
+                            if (typeof id === 'string')
                                 entriesIds.push(id);
-                            }
-                        });
+                        }
                     }
                     else if (typeof val === 'string') {
-                        if (z.string().uuid().safeParse(val).success) {
-                            entriesIds.push(val);
-                        }
+                        entriesIds.push(val);
                     }
                     break;
                 }
                 case 'object':
-                    collectIds(val, field.fields);
+                    collectIds(val, field.fields, false);
                     break;
                 case 'blocks':
                     if (Array.isArray(val)) {
                         val.forEach((item) => {
                             const objectDef = field.of.find((objDef) => objDef.slug === item._slug);
                             if (objectDef) {
-                                collectIds(item, objectDef.fields);
+                                collectIds(item, objectDef.fields, false);
                             }
                         });
                     }
                     break;
                 case 'content': {
                     const cf = field;
-                    // Content is now a single doc, not Record<lang, doc>
-                    if (val && typeof val === 'object' && val.type === 'doc' && cf.inlineBlocks?.length) {
+                    if (val &&
+                        typeof val === 'object' &&
+                        val.type === 'doc' &&
+                        cf.inlineBlocks?.length) {
                         walkInlineBlockNodes(val, (node) => {
                             const bd = node.attrs?.blockData;
                             if (!bd || typeof bd !== 'object')
                                 return;
                             const def = cf.inlineBlocks.find((b) => b.slug === node.attrs?.blockType);
                             if (def)
-                                collectIds(bd, def.fields);
+                                collectIds(bd, def.fields, false);
                         });
                     }
                     break;
@@ -55,20 +74,97 @@ export async function resolveRelationFields(data, fields, language) {
             }
         }
     };
-    collectIds(data, fields);
+    collectIds(data, fields, true);
     if (entriesIds.length === 0)
         return data;
-    // Import getEntries dynamically to avoid circular dependency
-    const { getEntries } = await import('../entries/operations/get.js');
-    // Get fully populated entries
-    const entries = await getEntries({
-        ids: entriesIds,
-        language
-    });
-    const entriesMap = Object.fromEntries(entries.map((e) => [e._id, e]));
+    // Filter: don't fetch already-visited (cycle) or beyond maxDepth — those stay raw IDs
+    const overDepth = ctx.depth >= ctx.maxDepth;
+    const fetchableIds = overDepth
+        ? []
+        : [...new Set(entriesIds)].filter((id) => !ctx.visited.has(id));
+    const cms = getCMS();
+    // entriesMap: id → Entry (populated) | null (fetched but missing version/missing entry).
+    // Absent key = id was NOT fetched (cycle, max depth, top-level opt-out) → falls back to raw id.
+    const entriesMap = {};
+    if (fetchableIds.length > 0) {
+        const dbEntries = await cms.databaseAdapter.getEntries({ ids: fetchableIds });
+        const aliveDbEntries = dbEntries.filter((e) => e.archivedAt == null);
+        const aliveIds = new Set(aliveDbEntries.map((e) => e.id));
+        // Strict: missing entry / archived → null in nested
+        for (const id of fetchableIds) {
+            if (!aliveIds.has(id))
+                entriesMap[id] = null;
+        }
+        if (aliveDbEntries.length > 0) {
+            const versions = await cms.databaseAdapter.getEntryVersions({
+                entryIds: aliveDbEntries.map((e) => e.id),
+                lang: ctx.locale
+            });
+            const versionsByEntry = new Map();
+            for (const v of versions) {
+                const arr = versionsByEntry.get(v.entryId) ?? [];
+                arr.push(v);
+                versionsByEntry.set(v.entryId, arr);
+            }
+            // Lazy import to avoid static circular dep with populateEntry → resolveRelationFields
+            const { _populate } = await import('./populateEntry.js');
+            await Promise.all(aliveDbEntries.map(async (dbEntry) => {
+                const vs = versionsByEntry.get(dbEntry.id) ?? [];
+                const picked = pickVersion(vs, ctx.status);
+                if (!picked) {
+                    entriesMap[dbEntry.id] = null; // strict: missing version in locale → null
+                    return;
+                }
+                let config;
+                try {
+                    config = cms.getBySlug(dbEntry.slug);
+                }
+                catch {
+                    entriesMap[dbEntry.id] = null;
+                    return;
+                }
+                const nestedFields = getFieldsFromConfig(config);
+                const nestedCtx = {
+                    locale: ctx.locale,
+                    status: ctx.status,
+                    depth: ctx.depth + 1,
+                    maxDepth: ctx.maxDepth,
+                    visited: new Set([...ctx.visited, dbEntry.id]),
+                    populate: ctx.populate,
+                    entryId: dbEntry.id
+                };
+                try {
+                    const populated = await _populate(picked.data, nestedFields, nestedCtx);
+                    const slugPath = getEntrySlugPath(dbEntry.slug);
+                    const slugValue = getSlugFromEntryData(picked.data, slugPath, ctx.locale);
+                    const _url = slugValue ? getEntryPath(dbEntry.slug, slugValue) : undefined;
+                    entriesMap[dbEntry.id] = {
+                        _id: dbEntry.id,
+                        _slug: dbEntry.slug,
+                        _type: dbEntry.type,
+                        _publishedAt: picked.publishedAt,
+                        _url,
+                        ...(config.type === 'collection' && config.orderable
+                            ? { _sortOrder: dbEntry.sortOrder }
+                            : {}),
+                        ...populated
+                    };
+                }
+                catch (error) {
+                    console.error(`[CMS] Failed to populate nested entry ${dbEntry.id} (${dbEntry.slug}):`, error);
+                }
+            }));
+        }
+    }
+    const resolveRefId = (id) => {
+        // Has key (even if value is null) → use mapped value (Entry | null)
+        if (Object.prototype.hasOwnProperty.call(entriesMap, id))
+            return entriesMap[id];
+        // Not fetched (cycle, max depth, top-level opt-out) → raw ID
+        return id;
+    };
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const resolveValues = (value, fields) => {
-        // Start with a copy of all original data to preserve non-field properties
+    const resolveValues = (value, fields, topLevel) => {
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const result = { ...value };
         for (const field of fields) {
@@ -77,33 +173,43 @@ export async function resolveRelationFields(data, fields, language) {
                 result[field.slug] = val;
                 continue;
             }
+            // Per-field opt-out at top level → raw passthrough
+            if (topLevel && optedOutFields.has(field.slug)) {
+                result[field.slug] = val;
+                continue;
+            }
             switch (field.type) {
                 case 'relation': {
                     if (field.multiple && Array.isArray(val)) {
-                        result[field.slug] = val.map((id) => entriesMap[id] ?? null);
+                        result[field.slug] = val.map((id) => typeof id === 'string' ? resolveRefId(id) : id);
+                    }
+                    else if (typeof val === 'string') {
+                        result[field.slug] = resolveRefId(val);
                     }
                     else {
-                        result[field.slug] = entriesMap[val] ?? null;
+                        result[field.slug] = val;
                     }
                     break;
                 }
                 case 'object':
-                    result[field.slug] = resolveValues(val, field.fields);
+                    result[field.slug] = resolveValues(val, field.fields, false);
                     break;
                 case 'blocks':
                     // eslint-disable-next-line @typescript-eslint/no-explicit-any
                     result[field.slug] = val.map((item) => {
                         const objectDef = field.of.find((objDef) => objDef.slug === item._slug);
                         if (objectDef) {
-                            return resolveValues(item, objectDef.fields);
+                            return resolveValues(item, objectDef.fields, false);
                         }
                         return item;
                     });
                     break;
                 case 'content': {
                     const cf = field;
-                    // Content is now a single doc, not Record<lang, doc>
-                    if (val && typeof val === 'object' && val.type === 'doc' && cf.inlineBlocks?.length) {
+                    if (val &&
+                        typeof val === 'object' &&
+                        val.type === 'doc' &&
+                        cf.inlineBlocks?.length) {
                         const cloned = cloneDoc(val);
                         walkInlineBlockNodes(cloned, (node) => {
                             const bd = node.attrs?.blockData;
@@ -112,7 +218,7 @@ export async function resolveRelationFields(data, fields, language) {
                             const def = cf.inlineBlocks.find((b) => b.slug === node.attrs?.blockType);
                             if (!def)
                                 return;
-                            node.attrs.blockData = resolveValues(bd, def.fields);
+                            node.attrs.blockData = resolveValues(bd, def.fields, false);
                         });
                         result[field.slug] = cloned;
                     }
@@ -124,5 +230,5 @@ export async function resolveRelationFields(data, fields, language) {
         }
         return result;
     };
-    return resolveValues(data, fields);
+    return resolveValues(data, fields, true);
 }

package/dist/core/server/fields/resolveRichtextLinks.d.ts

@@ -1,3 +1,4 @@
 import type { EntryData, PopulatedEntryData } from '../../../types/entries.js';
 import type { Field } from '../../../types/fields.js';
-export declare function resolveRichtextLinks(data: EntryData, fields: Field[], language: string): Promise<PopulatedEntryData>;
+import type { PopulateCtx } from '../entries/operations/resolveEntry.js';
+export declare function resolveRichtextLinks(data: EntryData, fields: Field[], ctx: PopulateCtx): Promise<PopulatedEntryData>;

package/dist/core/server/fields/resolveRichtextLinks.js

@@ -34,7 +34,8 @@ function resolveContentDoc(doc, slugMap) {
     });
     return cloned;
 }
-export async function resolveRichtextLinks(data, fields, language) {
+export async function resolveRichtextLinks(data, fields, ctx) {
+    const language = ctx.locale;
     const entriesIds = [];
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const collectIds = (value, fields) => {

package/dist/core/server/fields/resolveUrlFields.d.ts

@@ -1,3 +1,4 @@
 import type { EntryData, PopulatedEntryData } from '../../../types/entries.js';
 import type { Field } from '../../../types/fields.js';
-export declare function resolveUrlFields(data: EntryData, fields: Field[], language?: string): Promise<PopulatedEntryData>;
+import type { PopulateCtx } from '../entries/operations/resolveEntry.js';
+export declare function resolveUrlFields(data: EntryData, fields: Field[], ctx: PopulateCtx): Promise<PopulatedEntryData>;

package/dist/core/server/fields/resolveUrlFields.js

@@ -1,6 +1,6 @@
 import { urlFieldDataSchema, urlFieldDataWithRelationSchema } from '../../../schemas/field/url.js';
 import { walkInlineBlockNodes, cloneDoc } from '../../../admin/components/tiptap/structured-content-utils.js';
-import { getDbEntries, getDbEntryVersions } from '../entries/operations/get.js';
+import { _getDbEntries, _getDbEntryVersions } from '../entries/operations/get.js';
 import { getEntrySlugPath, getSlugFromEntryData, getEntryPath } from './slugResolver.js';
 import { isExternalUrl, mergeRel } from '../../fields/urlUtils.js';
 const FLAT_KEY = '_flat';
@@ -34,7 +34,8 @@ function applyExternalAutoDetect(resolvedUrl, extras) {
         }
     }
 }
-export async function resolveUrlFields(data, fields, language) {
+export async function resolveUrlFields(data, fields, ctx) {
+    const language = ctx.locale;
     const entriesIds = [];
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const collectIds = (value, fields) => {
@@ -102,12 +103,12 @@ export async function resolveUrlFields(data, fields, language) {
     collectIds(data, fields);
     const slugMap = {};
     if (entriesIds.length > 0) {
-        // Use raw DB calls to avoid recursive populateEntryData → resolveUrlFields loop
-        const dbEntries = await getDbEntries({ ids: entriesIds });
+        // Use raw DB calls to avoid recursive _populate → resolveUrlFields loop
+        const dbEntries = await _getDbEntries({ ids: entriesIds });
         const entryIds = dbEntries.map((e) => e.id);
         if (entryIds.length > 0) {
             // Get published versions for the target language
-            const versions = await getDbEntryVersions({
+            const versions = await _getDbEntryVersions({
                 entryIds,
                 lang: language
             });

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

@@ -179,21 +179,21 @@ function generateAPI(config) {
     const filePath = join(cmsDir, 'api.ts');
     let code = `// This file is auto-generated. Do not edit directly.\n\n`;
     code += `
-	
+
 		import type { SingleEntryMap, SingleSlug, CollectionEntryMap, CollectionSlug, FormEntryMap, SiteLanguage } from './types';
-		import { getEntry, getEntries, countEntries, createFormSubmission } from 'includio-cms/sveltekit/server';
+		import { resolveEntry, resolveEntries, countEntries, createFormSubmission, type PopulateConfig } from 'includio-cms/sveltekit/server';
 
 	`;
     code += `
 
 		interface GetEntryOptions {
 			id?: string;
-			status?: 'draft' | 'published' | 'scheduled' | 'archived';
-			dataValues?: Record<string, unknown>;
+			status?: 'published' | 'draft' | 'scheduled';
+			populate?: PopulateConfig;
 		`;
     if (config.languages && config.languages.length > 0) {
         code += `
-			language?: SiteLanguage;
+			locale?: SiteLanguage;
 				`;
     }
     code += `
@@ -201,8 +201,11 @@ function generateAPI(config) {
 
 		interface GetEntriesOptions extends GetEntryOptions {
 			ids?: string[];
-			dataLike?: Record<string, unknown>;
-			dataILikeOr?: Record<string, unknown>;
+			filter?: {
+				dataValues?: Record<string, unknown>;
+				dataLike?: Record<string, unknown>;
+				dataILikeOr?: Record<string, unknown>;
+			};
 			orderBy?: { column: 'createdAt' | 'updatedAt' | 'sortOrder'; direction: 'asc' | 'desc' };
 			dataOrderBy?: { field: string; direction: 'asc' | 'desc' };
 			limit?: number;
@@ -213,25 +216,25 @@ function generateAPI(config) {
     code += `
 
 		export async function getSingleEntry<K extends SingleSlug>(slug: K, options: GetEntryOptions = {}): Promise<SingleEntryMap[K] | null> {
-			return (await getEntry({
-				slug,
+			return (await resolveEntry({
+				collection: slug,
 				...options
 			})) as unknown as SingleEntryMap[K] | null;
 		}
 
 		export async function getCollectionEntry<K extends CollectionSlug>(slug: K, options: GetEntryOptions = {}): Promise<CollectionEntryMap[K] | null> {
-			return (await getEntry({
-				slug,
+			return (await resolveEntry({
+				collection: slug,
 				...options
 			})) as unknown as CollectionEntryMap[K] | null;
 		}
 
 		export async function getCollectionEntries<K extends CollectionSlug>(slug: K, options: GetEntriesOptions = {}): Promise<CollectionEntryMap[K][]> {
-			return (await getEntries({ slug, ...options })) as unknown as CollectionEntryMap[K][];
+			return (await resolveEntries({ collection: slug, ...options })) as unknown as CollectionEntryMap[K][];
 		}
 
-		export async function countCollectionEntries<K extends CollectionSlug>(slug: K, options: Omit<GetEntriesOptions, 'limit' | 'offset' | 'orderBy'> = {}): Promise<number> {
-			return countEntries({ slug, ...options });
+		export async function countCollectionEntries<K extends CollectionSlug>(slug: K, options: Omit<GetEntriesOptions, 'limit' | 'offset' | 'orderBy' | 'populate'> = {}): Promise<number> {
+			return countEntries({ collection: slug, ...options });
 		}
 
 		${config.forms && config.forms.length > 0

package/dist/entity/index.js

@@ -1,6 +1,6 @@
 import { generateZodSchemaFromFields } from '../core/fields/fieldSchemaToTs.js';
 import { getFieldsFromConfig } from '../core/fields/layoutUtils.js';
-import { getRawEntries } from '../core/server/entries/operations/get.js';
+import { _getRawEntries as getRawEntries } from '../core/server/entries/operations/get.js';
 export function createEntityAPI(cms, opts) {
     const db = cms.databaseAdapter;
     const userId = opts?.userId ?? 'system';

package/dist/shop/server/populate.d.ts

@@ -1,4 +1,5 @@
 import type { Field } from '../../types/fields.js';
+import type { PopulateCtx } from '../../core/server/entries/operations/resolveEntry.js';
 export interface PopulatedShopField {
     /** Netto w PLN (number, ≤6dp). Od 0.15.2. */
     basePrice: number;
@@ -14,4 +15,4 @@ export interface PopulatedShopField {
         attributes: Record<string, string> | null;
     }>;
 }
-export declare function resolveShopFields(data: Record<string, unknown>, fields: Field[], entryId: string | undefined): Promise<Record<string, unknown>>;
+export declare function resolveShopFields(data: Record<string, unknown>, fields: Field[], ctx: PopulateCtx): Promise<Record<string, unknown>>;

package/dist/shop/server/populate.js

@@ -15,7 +15,8 @@ function toPopulated(row) {
         }))
     };
 }
-export async function resolveShopFields(data, fields, entryId) {
+export async function resolveShopFields(data, fields, ctx) {
+    const entryId = ctx.entryId;
     if (!entryId)
         return data;
     // Skip if shop is not configured

package/dist/sveltekit/server/index.d.ts

@@ -1,6 +1,6 @@
 export { includioCMS } from './handle.js';
 export { cmsLayoutLoad } from './layout.js';
-export { getEntry, getEntries, countEntries } from '../../core/server/entries/operations/get.js';
+export { resolveEntry, resolveEntries, countEntries, type ResolveEntryOptions, type ResolveEntriesOptions, type CountEntriesOptions, type PopulateConfig, type ResolveStatus } from '../../core/server/entries/operations/resolveEntry.js';
 export { createFormSubmission } from '../../core/server/forms/submissions/operations/create.js';
 export { parseFormDataForSubmission } from '../../core/server/forms/submissions/utils/parseMultipart.js';
 export { createConsentLog } from '../../core/server/consentLogs/operations/create.js';

package/dist/sveltekit/server/index.js

@@ -1,6 +1,6 @@
 export { includioCMS } from './handle.js';
 export { cmsLayoutLoad } from './layout.js';
-export { getEntry, getEntries, countEntries } from '../../core/server/entries/operations/get.js';
+export { resolveEntry, resolveEntries, countEntries } from '../../core/server/entries/operations/resolveEntry.js';
 export { createFormSubmission } from '../../core/server/forms/submissions/operations/create.js';
 export { parseFormDataForSubmission } from '../../core/server/forms/submissions/utils/parseMultipart.js';
 export { createConsentLog } from '../../core/server/consentLogs/operations/create.js';

package/dist/types/plugins.d.ts

@@ -2,6 +2,7 @@ import type { Component } from 'svelte';
 import type { z } from 'zod';
 import type { RawEntry } from './entries.js';
 import type { CustomField } from './fields.js';
+import type { PopulateCtx } from '../core/server/entries/operations/resolveEntry.js';
 export interface CustomFieldDefinition {
     /** Unique field type slug, e.g. 'photo-grid' */
     fieldType: string;
@@ -13,8 +14,11 @@ export interface CustomFieldDefinition {
     zodSchema: (field: CustomField, languages: string[]) => z.ZodType;
     /** TypeScript type string for codegen */
     tsType?: string;
-    /** Populate/resolve step for API output */
-    populateResolver?: (value: unknown, field: CustomField) => Promise<unknown>;
+    /**
+     * Populate/resolve step for API output.
+     * @experimental ctx (3rd arg) added in 0.17.0 — carries locale/status/depth/visited cascade.
+     */
+    populateResolver?: (value: unknown, field: CustomField, ctx: PopulateCtx) => Promise<unknown>;
 }
 export interface PluginConfig {
     slug: string;

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

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