includio-cms 0.16.0 → 0.19.0

package/dist/components/ui/dropdown-menu/dropdown-menu-radio-group.svelte.d.ts

@@ -1,4 +1,4 @@
 import { DropdownMenu as DropdownMenuPrimitive } from "bits-ui";
-declare const DropdownMenuRadioGroup: import("svelte").Component<DropdownMenuPrimitive.RadioGroupProps, {}, "value" | "ref">;
+declare const DropdownMenuRadioGroup: import("svelte").Component<DropdownMenuPrimitive.RadioGroupProps, {}, "ref" | "value">;
 type DropdownMenuRadioGroup = ReturnType<typeof DropdownMenuRadioGroup>;
 export default DropdownMenuRadioGroup;

package/dist/components/ui/input/input.svelte.d.ts

@@ -8,6 +8,6 @@ type Props = WithElementRef<Omit<HTMLInputAttributes, "type"> & ({
     type?: InputType;
     files?: undefined;
 })>;
-declare const Input: import("svelte").Component<Props, {}, "files" | "value" | "ref">;
+declare const Input: import("svelte").Component<Props, {}, "files" | "ref" | "value">;
 type Input = ReturnType<typeof Input>;
 export default Input;

package/dist/components/ui/input-group/input-group-input.svelte.d.ts

@@ -6,6 +6,6 @@ declare const InputGroupInput: import("svelte").Component<(Omit<import("svelte/e
     files?: undefined;
 })) & {
     ref?: HTMLElement | null | undefined;
-}, {}, "value" | "ref">;
+}, {}, "ref" | "value">;
 type InputGroupInput = ReturnType<typeof InputGroupInput>;
 export default InputGroupInput;

package/dist/components/ui/input-group/input-group-textarea.svelte.d.ts

@@ -1,3 +1,3 @@
-declare const InputGroupTextarea: import("svelte").Component<Omit<import("../../../utils.js").WithElementRef<import("svelte/elements").HTMLTextareaAttributes>, "children">, {}, "value" | "ref">;
+declare const InputGroupTextarea: import("svelte").Component<Omit<import("../../../utils.js").WithElementRef<import("svelte/elements").HTMLTextareaAttributes>, "children">, {}, "ref" | "value">;
 type InputGroupTextarea = ReturnType<typeof InputGroupTextarea>;
 export default InputGroupTextarea;

package/dist/components/ui/radio-group/radio-group.svelte.d.ts

@@ -1,4 +1,4 @@
 import { RadioGroup as RadioGroupPrimitive } from "bits-ui";
-declare const RadioGroup: import("svelte").Component<RadioGroupPrimitive.RootProps, {}, "value" | "ref">;
+declare const RadioGroup: import("svelte").Component<RadioGroupPrimitive.RootProps, {}, "ref" | "value">;
 type RadioGroup = ReturnType<typeof RadioGroup>;
 export default RadioGroup;

package/dist/components/ui/sidebar/sidebar-input.svelte.d.ts

@@ -6,6 +6,6 @@ declare const SidebarInput: import("svelte").Component<(Omit<import("svelte/elem
     files?: undefined;
 })) & {
     ref?: HTMLElement | null | undefined;
-}, {}, "value" | "ref">;
+}, {}, "ref" | "value">;
 type SidebarInput = ReturnType<typeof SidebarInput>;
 export default SidebarInput;

package/dist/components/ui/tabs/tabs.svelte.d.ts

@@ -1,4 +1,4 @@
 import { Tabs as TabsPrimitive } from "bits-ui";
-declare const Tabs: import("svelte").Component<TabsPrimitive.RootProps, {}, "value" | "ref">;
+declare const Tabs: import("svelte").Component<TabsPrimitive.RootProps, {}, "ref" | "value">;
 type Tabs = ReturnType<typeof Tabs>;
 export default Tabs;

package/dist/components/ui/textarea/textarea.svelte.d.ts

@@ -1,5 +1,5 @@
 import { type WithElementRef } from "../../../utils.js";
 import type { HTMLTextareaAttributes } from "svelte/elements";
-declare const Textarea: import("svelte").Component<Omit<WithElementRef<HTMLTextareaAttributes>, "children">, {}, "value" | "ref">;
+declare const Textarea: import("svelte").Component<Omit<WithElementRef<HTMLTextareaAttributes>, "children">, {}, "ref" | "value">;
 type Textarea = ReturnType<typeof Textarea>;
 export default Textarea;

package/dist/components/ui/toggle-group/toggle-group-item.svelte.d.ts

@@ -1,6 +1,6 @@
 import { ToggleGroup as ToggleGroupPrimitive } from "bits-ui";
 import { type ToggleVariants } from "../toggle/index.js";
 type $$ComponentProps = ToggleGroupPrimitive.ItemProps & ToggleVariants;
-declare const ToggleGroupItem: import("svelte").Component<$$ComponentProps, {}, "value" | "ref">;
+declare const ToggleGroupItem: import("svelte").Component<$$ComponentProps, {}, "ref" | "value">;
 type ToggleGroupItem = ReturnType<typeof ToggleGroupItem>;
 export default ToggleGroupItem;

package/dist/components/ui/toggle-group/toggle-group.svelte.d.ts

@@ -3,6 +3,6 @@ export declare function setToggleGroupCtx(props: ToggleVariants): void;
 export declare function getToggleGroupCtx(): ToggleVariants;
 import { ToggleGroup as ToggleGroupPrimitive } from "bits-ui";
 type $$ComponentProps = ToggleGroupPrimitive.RootProps & ToggleVariants;
-declare const ToggleGroup: import("svelte").Component<$$ComponentProps, {}, "value" | "ref">;
+declare const ToggleGroup: import("svelte").Component<$$ComponentProps, {}, "ref" | "value">;
 type ToggleGroup = ReturnType<typeof ToggleGroup>;
 export default ToggleGroup;

package/dist/core/server/entries/operations/create.js

@@ -2,7 +2,7 @@ import { requireAuth } from '../../../../admin/remote/middleware/auth.js';
 import { getCMS } from '../../../cms.js';
 import { entryTypes } from '../../../../types/entries.js';
 import z from 'zod';
-import { getDbEntryOrThrow } from './get.js';
+import { _getDbEntryOrThrow as getDbEntryOrThrow } from './get.js';
 import { generateZodSchemaFromFields } from '../../../fields/fieldSchemaToTs.js';
 import { getFieldsFromConfig } from '../../../fields/layoutUtils.js';
 export const createEntrySchema = z.object({

package/dist/core/server/entries/operations/get.d.ts

@@ -1,16 +1,16 @@
-import type { DbEntry, DbEntryVersion, Entry, GetDbEntriesOptions, GetDbEntryOptions, GetDbEntryVersionOptions, GetDbEntryVersionsOptions, GetEntriesOptions, GetEntryOptions, GetRawEntriesOptions, getRawEntryOptions, RawEntry } from '../../../../types/entries.js';
-export declare const getDbEntries: (options: GetDbEntriesOptions) => Promise<DbEntry[]>;
-export declare const countDbEntries: (options: Omit<GetDbEntriesOptions, "limit" | "offset" | "orderBy">) => Promise<number>;
-export declare const getDbEntry: (options: GetDbEntryOptions) => Promise<DbEntry | null>;
-export declare const getDbEntryOrThrow: (options: GetDbEntryOptions) => Promise<DbEntry>;
-export declare const countRawEntries: (options: Omit<GetRawEntriesOptions, "limit" | "offset" | "orderBy">) => Promise<number>;
-export declare const getRawEntries: (options: GetRawEntriesOptions) => Promise<RawEntry[]>;
-export declare const getRawEntry: (options: getRawEntryOptions) => Promise<RawEntry | null>;
-export declare const getRawEntryOrThrow: (options: getRawEntryOptions) => Promise<RawEntry>;
-export declare const getEntries: (options?: GetEntriesOptions) => Promise<Entry[]>;
-export declare const countEntries: (options: Omit<GetEntriesOptions, "limit" | "offset" | "orderBy">) => Promise<number>;
-export declare const getEntry: (options?: GetEntryOptions) => Promise<Entry | null>;
-export declare const getEntryOrThrow: (options?: GetEntryOptions) => Promise<Entry>;
+import type { DbEntry, DbEntryVersion, Entry, GetDbEntriesOptions, GetDbEntryOptions, GetDbEntryVersionOptions, GetDbEntryVersionsOptions, GetRawEntriesOptions, getRawEntryOptions, RawEntry } from '../../../../types/entries.js';
+export declare const _getDbEntries: (options: GetDbEntriesOptions) => Promise<DbEntry[]>;
+export declare const _countDbEntries: (options: Omit<GetDbEntriesOptions, "limit" | "offset" | "orderBy">) => Promise<number>;
+export declare const _getDbEntry: (options: GetDbEntryOptions) => Promise<DbEntry | null>;
+export declare const _getDbEntryOrThrow: (options: GetDbEntryOptions) => Promise<DbEntry>;
+export declare const _countRawEntries: (options: Omit<GetRawEntriesOptions, "limit" | "offset" | "orderBy">) => Promise<number>;
+export declare const _getRawEntries: (options: GetRawEntriesOptions) => Promise<RawEntry[]>;
+export declare const _getRawEntry: (options: getRawEntryOptions) => Promise<RawEntry | null>;
+export declare const _getRawEntryOrThrow: (options: getRawEntryOptions) => Promise<RawEntry>;
+/**
+ * Admin helper: returns dropdown labels for collection entries.
+ * Not part of the public resolver API — admin UI use only.
+ */
 export declare const getEntryLabels: (options: {
     slug: string;
     ids?: string[];
@@ -22,9 +22,13 @@ export declare const getEntryLabels: (options: {
     label: string;
     total: number;
 }[]>;
-export declare const getDbEntryVersions: (options: GetDbEntryVersionsOptions) => Promise<DbEntryVersion[]>;
-export declare const getDbEntryVersion: (options: GetDbEntryVersionOptions) => Promise<DbEntryVersion | null>;
-export declare const getDbEntryVersionOrThrow: (options: GetDbEntryVersionOptions) => Promise<DbEntryVersion>;
+export declare const _getDbEntryVersions: (options: GetDbEntryVersionsOptions) => Promise<DbEntryVersion[]>;
+export declare const _getDbEntryVersion: (options: GetDbEntryVersionOptions) => Promise<DbEntryVersion | null>;
+export declare const _getDbEntryVersionOrThrow: (options: GetDbEntryVersionOptions) => Promise<DbEntryVersion>;
+/**
+ * Admin helper: fetches a specific version of an entry by version id and populates it.
+ * Used by version-history admin UI; not part of public resolver API.
+ */
 export declare const getEntryVersion: (options: {
     id: string;
     language: string;

package/dist/core/server/entries/operations/get.js

@@ -1,15 +1,14 @@
 import { getCMS } from '../../../cms.js';
 import { getAtPath } from '../../../../admin/utils/objectPath.js';
-import { populateEntryData } from '../../fields/populateEntry.js';
 import { getFieldsFromConfig } from '../../../fields/layoutUtils.js';
 import { getEntrySlugPath, getSlugFromEntryData, getEntryPath } from '../../fields/slugResolver.js';
-export const getDbEntries = async (options) => {
+export const _getDbEntries = async (options) => {
     return getCMS().databaseAdapter.getEntries(options);
 };
-export const countDbEntries = async (options) => {
+export const _countDbEntries = async (options) => {
     return getCMS().databaseAdapter.countEntries(options);
 };
-export const getDbEntry = async (options) => {
+export const _getDbEntry = async (options) => {
     const { id, ...rest } = options;
     const [entry] = await getCMS().databaseAdapter.getEntries({
         ...rest,
@@ -17,15 +16,15 @@ export const getDbEntry = async (options) => {
     });
     return entry || null;
 };
-export const getDbEntryOrThrow = async (options) => {
-    const entry = await getDbEntry(options);
+export const _getDbEntryOrThrow = async (options) => {
+    const entry = await _getDbEntry(options);
     if (!entry) {
         throw new Error('Entry not found');
     }
     return entry;
 };
-export const countRawEntries = async (options) => {
-    return countDbEntries(options);
+export const _countRawEntries = async (options) => {
+    return _countDbEntries(options);
 };
 /** Helper: group versions by lang into per-lang published/scheduled/draft maps */
 function buildPerLangVersionMaps(versions) {
@@ -33,7 +32,6 @@ function buildPerLangVersionMaps(versions) {
     const publishedVersions = {};
     const scheduledVersions = {};
     const draftVersions = {};
-    // Group versions by lang
     const byLang = new Map();
     for (const v of versions) {
         const arr = byLang.get(v.lang) || [];
@@ -42,11 +40,8 @@ function buildPerLangVersionMaps(versions) {
     }
     for (const [lang, langVersions] of byLang) {
         const sorted = langVersions.sort((a, b) => b.versionNumber - a.versionNumber);
-        // Find latest published (publishedAt <= now)
         const published = sorted.find((v) => v.publishedAt != null && v.publishedAt <= now) || null;
-        // Find scheduled (publishedAt > now)
         const scheduled = sorted.find((v) => v.publishedAt != null && v.publishedAt > now) || null;
-        // Draft = latest version without publishedAt, or latest version newer than published
         const draft = sorted.find((v) => v.publishedAt == null) || null;
         publishedVersions[lang] = published;
         scheduledVersions[lang] = scheduled;
@@ -54,8 +49,8 @@ function buildPerLangVersionMaps(versions) {
     }
     return { publishedVersions, scheduledVersions, draftVersions };
 }
-export const getRawEntries = async (options) => {
-    const dbEntries = await getDbEntries(options);
+export const _getRawEntries = async (options) => {
+    const dbEntries = await _getDbEntries(options);
     const entries = await Promise.all(dbEntries.map(async (entry) => {
         try {
             const versions = await getCMS().databaseAdapter.getEntryVersions({
@@ -78,203 +73,31 @@ export const getRawEntries = async (options) => {
     }));
     return entries.filter((e) => e !== null);
 };
-export const getRawEntry = async (options) => {
-    const [entry] = await getRawEntries({
+export const _getRawEntry = async (options) => {
+    const [entry] = await _getRawEntries({
         ...options,
         ids: options.id ? [options.id] : undefined,
         includeArchived: options.includeArchived
     });
     return entry || null;
 };
-export const getRawEntryOrThrow = async (options) => {
-    const entry = await getRawEntry(options);
-    if (!entry) {
-        throw new Error('Entry not found');
-    }
-    return entry;
-};
-export const getEntries = async (options = {}) => {
-    const cms = getCMS();
-    const language = options.language || cms.languages[0];
-    const status = options.status || 'published';
-    // Fast path: DB-level pagination when limit/offset provided and adapter supports it
-    if (options.limit != null && cms.databaseAdapter.getPaginatedEntries) {
-        const rows = await cms.databaseAdapter.getPaginatedEntries({
-            slug: options.slug,
-            ids: options.ids,
-            language,
-            status,
-            dataValues: options.dataValues,
-            dataLike: options.dataLike,
-            dataILikeOr: options.dataILikeOr,
-            orderBy: options.orderBy,
-            dataOrderBy: options.dataOrderBy,
-            limit: options.limit,
-            offset: options.offset ?? 0
-        });
-        const entries = await Promise.all(rows.map(async ({ entry, version }) => {
-            try {
-                const config = cms.getBySlug(entry.slug);
-                const fields = getFieldsFromConfig(config);
-                const populatedData = await populateEntryData(version.data, fields, language, entry.id);
-                const slugPath = getEntrySlugPath(entry.slug);
-                const slug = getSlugFromEntryData(version.data, slugPath, language);
-                const _url = slug ? getEntryPath(entry.slug, slug) : undefined;
-                const result = {
-                    _id: entry.id,
-                    _slug: entry.slug,
-                    _type: entry.type,
-                    _publishedAt: version.publishedAt,
-                    _url,
-                    ...populatedData
-                };
-                if (config.type === 'collection' && config.orderable) {
-                    result._sortOrder = entry.sortOrder;
-                }
-                return result;
-            }
-            catch (error) {
-                console.error(`[CMS] Failed to populate entry ${entry.id} (${entry.slug}):`, error);
-                return null;
-            }
-        }));
-        return entries.filter((e) => e !== null);
-    }
-    // Slow path: in-memory pagination (backward compat)
-    const ids = options.ids;
-    const slug = options.slug;
-    const dataValues = options.dataValues;
-    const dataLike = options.dataLike;
-    const dataILikeOr = options.dataILikeOr;
-    const dbEntries = await cms.databaseAdapter.getEntries({
-        ids,
-        slug,
-        orderBy: options.orderBy
-    });
-    if (dbEntries.length === 0) {
-        return [];
-    }
-    const filteredEntries = status === 'archived'
-        ? dbEntries.filter((e) => e.archivedAt != null)
-        : dbEntries.filter((e) => e.archivedAt == null);
-    if (filteredEntries.length === 0) {
-        return [];
-    }
-    const entriesMap = new Map(filteredEntries.map((entry) => [entry.id, entry]));
-    const entryIds = filteredEntries.map((entry) => entry.id);
-    const allVersions = await cms.databaseAdapter.getEntryVersions({
-        entryIds,
-        lang: language,
-        dataValues,
-        dataLike,
-        dataILikeOr
-    });
-    const now = new Date();
-    const versionEntries = [];
-    const versionsByEntry = new Map();
-    for (const v of allVersions) {
-        const arr = versionsByEntry.get(v.entryId) || [];
-        arr.push(v);
-        versionsByEntry.set(v.entryId, arr);
-    }
-    for (const [entryId, versions] of versionsByEntry) {
-        const dbEntry = entriesMap.get(entryId);
-        if (!dbEntry)
-            continue;
-        const sorted = versions.sort((a, b) => b.versionNumber - a.versionNumber);
-        let picked = null;
-        switch (status) {
-            case 'published':
-                picked = sorted.find((v) => v.publishedAt != null && v.publishedAt <= now) || null;
-                break;
-            case 'scheduled':
-                picked = sorted.find((v) => v.publishedAt != null && v.publishedAt > now) || null;
-                break;
-            case 'draft':
-                picked = sorted.find((v) => v.publishedAt == null) || null;
-                break;
-            case 'archived':
-                picked = sorted[0] || null;
-                break;
-        }
-        if (picked) {
-            versionEntries.push({ version: picked, dbEntry });
-        }
-    }
-    const entryOrder = new Map(filteredEntries.map((e, i) => [e.id, i]));
-    versionEntries.sort((a, b) => (entryOrder.get(a.dbEntry.id) ?? 0) - (entryOrder.get(b.dbEntry.id) ?? 0));
-    const entries = await Promise.all(versionEntries.map(async ({ version, dbEntry }) => {
-        try {
-            const config = cms.getBySlug(dbEntry.slug);
-            const fields = getFieldsFromConfig(config);
-            const populatedData = await populateEntryData(version.data, fields, language, dbEntry.id);
-            const slugPath = getEntrySlugPath(dbEntry.slug);
-            const slug = getSlugFromEntryData(version.data, slugPath, language);
-            const _url = slug ? getEntryPath(dbEntry.slug, slug) : undefined;
-            const result = {
-                _id: dbEntry.id,
-                _slug: dbEntry.slug,
-                _type: dbEntry.type,
-                _publishedAt: version.publishedAt,
-                _url,
-                ...populatedData
-            };
-            if (config.type === 'collection' && config.orderable) {
-                result._sortOrder = dbEntry.sortOrder;
-            }
-            return result;
-        }
-        catch (error) {
-            console.error(`[CMS] Failed to populate entry ${dbEntry.id} (${dbEntry.slug}):`, error);
-            return null;
-        }
-    }));
-    let results = entries.filter((e) => e !== null);
-    if (options.offset)
-        results = results.slice(options.offset);
-    if (options.limit)
-        results = results.slice(0, options.limit);
-    return results;
-};
-export const countEntries = async (options) => {
-    const cms = getCMS();
-    const language = options.language || cms.languages[0];
-    const status = options.status || 'published';
-    if (cms.databaseAdapter.countPaginatedEntries) {
-        return cms.databaseAdapter.countPaginatedEntries({
-            slug: options.slug,
-            ids: options.ids,
-            language,
-            status,
-            dataValues: options.dataValues,
-            dataLike: options.dataLike,
-            dataILikeOr: options.dataILikeOr
-        });
-    }
-    // Fallback: use old getEntries without limit/offset (counts all)
-    const entries = await getEntries({ ...options });
-    return entries.length;
-};
-export const getEntry = async (options = {}) => {
-    const [entry] = await getEntries({
-        ...options,
-        ids: options.id ? [options.id] : undefined
-    });
-    return entry || null;
-};
-export const getEntryOrThrow = async (options = {}) => {
-    const entry = await getEntry(options);
+export const _getRawEntryOrThrow = async (options) => {
+    const entry = await _getRawEntry(options);
     if (!entry) {
         throw new Error('Entry not found');
     }
     return entry;
 };
+/**
+ * Admin helper: returns dropdown labels for collection entries.
+ * Not part of the public resolver API — admin UI use only.
+ */
 export const getEntryLabels = async (options) => {
     const cms = getCMS();
     const config = cms.getBySlug(options.slug);
     if (!config || config.type !== 'collection')
         return [];
-    const dbEntries = await getDbEntries({
+    const dbEntries = await _getDbEntries({
         slug: options.slug,
         ids: options.ids
     });
@@ -282,7 +105,6 @@ export const getEntryLabels = async (options) => {
         return [];
     const entryIds = dbEntries.map((e) => e.id);
     const language = cms.languages[0];
-    // Get versions for default language
     const allVersions = await cms.databaseAdapter.getEntryVersions({
         entryIds,
         lang: language
@@ -290,13 +112,12 @@ export const getEntryLabels = async (options) => {
     const now = new Date();
     const statusFilter = options.status ?? 'all';
     const entryAdminTitle = config.entryAdminTitle;
-    let results = dbEntries.map((entry) => {
+    let results = dbEntries
+        .map((entry) => {
         const entryVersions = allVersions.filter((v) => v.entryId === entry.id);
         const sorted = entryVersions.sort((a, b) => b.versionNumber - a.versionNumber);
-        // Determine status from versions
         const publishedVersion = sorted.find((v) => v.publishedAt != null && v.publishedAt <= now) || null;
         const hasPublished = publishedVersion != null;
-        // Filter by status
         if (statusFilter === 'published' && !hasPublished)
             return null;
         if (statusFilter === 'draft' && hasPublished)
@@ -310,50 +131,60 @@ export const getEntryLabels = async (options) => {
             }
         }
         return { id: entry.id, label };
-    }).filter((r) => r != null);
-    // Post-query search filtering (case-insensitive includes)
+    })
+        .filter((r) => r != null);
     if (options.search) {
         const searchLower = options.search.toLowerCase();
         results = results.filter((r) => r.label.toLowerCase().includes(searchLower));
     }
     const total = results.length;
-    // Apply limit
     if (options.limit && options.limit > 0) {
         results = results.slice(0, options.limit);
     }
     return results.map((r) => ({ ...r, total }));
 };
-export const getDbEntryVersions = async (options) => {
+export const _getDbEntryVersions = async (options) => {
     return getCMS().databaseAdapter.getEntryVersions(options);
 };
-export const getDbEntryVersion = async (options) => {
-    const [version] = await getDbEntryVersions({
+export const _getDbEntryVersion = async (options) => {
+    const [version] = await _getDbEntryVersions({
         ...options,
         ids: options.id ? [options.id] : undefined
     });
     return version || null;
 };
-export const getDbEntryVersionOrThrow = async (options) => {
-    const version = await getDbEntryVersion(options);
+export const _getDbEntryVersionOrThrow = async (options) => {
+    const version = await _getDbEntryVersion(options);
     if (!version) {
         throw new Error('Entry version not found');
     }
     return version;
 };
+/**
+ * Admin helper: fetches a specific version of an entry by version id and populates it.
+ * Used by version-history admin UI; not part of public resolver API.
+ */
 export const getEntryVersion = async (options) => {
     const language = options.language || getCMS().languages[0];
-    const dbEntryVersion = await getDbEntryVersion({ id: options.id });
-    if (!dbEntryVersion) {
+    const dbEntryVersion = await _getDbEntryVersion({ id: options.id });
+    if (!dbEntryVersion)
         return null;
-    }
-    const dbEntry = await getDbEntry({ id: dbEntryVersion.entryId });
-    if (!dbEntry) {
+    const dbEntry = await _getDbEntry({ id: dbEntryVersion.entryId });
+    if (!dbEntry)
         return null;
-    }
     try {
         const config = getCMS().getBySlug(dbEntry.slug);
         const fields = getFieldsFromConfig(config);
-        const populatedData = await populateEntryData(dbEntryVersion.data, fields, language, dbEntry.id);
+        const { _populate } = await import('../../fields/populateEntry.js');
+        const populatedData = await _populate(dbEntryVersion.data, fields, {
+            locale: language,
+            status: 'published',
+            depth: 0,
+            maxDepth: 5,
+            visited: new Set([dbEntry.id]),
+            populate: {},
+            entryId: dbEntry.id
+        });
         const slugPath = getEntrySlugPath(dbEntry.slug);
         const entrySlug = getSlugFromEntryData(dbEntryVersion.data, slugPath, language);
         const _url = entrySlug ? getEntryPath(dbEntry.slug, entrySlug) : undefined;

package/dist/core/server/entries/operations/resolveEntry.d.ts

@@ -0,0 +1,94 @@
+import type { Entry } from '../../../../types/entries.js';
+/**
+ * Status filter for `resolveEntry`/`resolveEntries`/`countEntries`.
+ * - `published` (default): newest version with `publishedAt <= now`
+ * - `draft`: newest version without `publishedAt`
+ * - `scheduled`: newest version with `publishedAt > now` (use case: countdown to launch)
+ *
+ * `archived` is intentionally excluded from public API (admin uses internal `_getRawEntries`).
+ * @public
+ */
+export type ResolveStatus = 'published' | 'draft' | 'scheduled';
+/**
+ * Recursion + per-field opt-out config for relation population.
+ * @public
+ */
+export type PopulateConfig = {
+    /** Hard cap on relation depth. Default 5. Use `0` to keep all relations as raw IDs. */
+    maxDepth?: number;
+    /** Per-field opt-out. `{ author: false }` keeps `author` as raw ID instead of populated Entry. */
+    fields?: Record<string, false>;
+};
+/**
+ * Internal context passed through the populate chain.
+ * Carries locale/status cascade, recursion guards, and the current entry id (for shop populate).
+ */
+export interface PopulateCtx {
+    locale: string;
+    status: ResolveStatus;
+    depth: number;
+    maxDepth: number;
+    visited: Set<string>;
+    populate: PopulateConfig;
+    entryId: string;
+}
+/** @public */
+export interface ResolveEntryOptions {
+    id?: string;
+    collection?: string;
+    locale?: string;
+    status?: ResolveStatus;
+    populate?: PopulateConfig;
+}
+/** @public */
+export interface ResolveEntriesOptions {
+    collection: string;
+    locale?: string;
+    status?: ResolveStatus;
+    ids?: string[];
+    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;
+    offset?: number;
+    populate?: PopulateConfig;
+}
+/** @public */
+export type CountEntriesOptions = Omit<ResolveEntriesOptions, 'limit' | 'offset' | 'populate' | 'orderBy' | 'dataOrderBy'>;
+/**
+ * Fetch a single populated Entry.
+ *
+ * - At least one of `id` or `collection` must be provided.
+ * - `locale` defaults to `cms.languages[0]`. Strict — returns `null` when no version exists in the requested locale.
+ * - `status` defaults to `'published'`. See {@link ResolveStatus}.
+ * - `populate` controls relation depth + per-field opt-out. See {@link PopulateConfig}.
+ *
+ * @public
+ */
+export declare function resolveEntry(opts: ResolveEntryOptions): Promise<Entry | null>;
+/**
+ * Fetch a list of populated Entries from a collection (or singleton with multiple instances).
+ *
+ * - `collection` is required.
+ * - `locale` strict (excludes entries without a version in requested locale).
+ * - `filter.{dataValues, dataLike, dataILikeOr}` map onto adapter `getEntryVersions` filters.
+ * - `limit`/`offset` applied after status pick.
+ *
+ * @public
+ */
+export declare function resolveEntries(opts: ResolveEntriesOptions): Promise<Entry[]>;
+/**
+ * Count entries matching the same filters as `resolveEntries`, without populating.
+ * @public
+ */
+export declare function countEntries(opts: CountEntriesOptions): Promise<number>;