@lupinum/ginko-content 0.1.6 → 0.2.1

package/dist/features/navigation/build.d.ts

@@ -1,7 +1,7 @@
 /**
  * Build the navigation tree from a flat list of content metadata.
  *
- * The input is a flat list of content rows with `title`, `_path`, `_file`, and
+ * The input is a flat list of content rows with `title`, `path`, `file`, and
  * optional extra fields; the output is a `NavItem[]` tree where parent folders
  * are synthesized from path segments and `/.navigation.yml` config entries
  * can override titles and metadata per directory.
@@ -14,7 +14,7 @@
  *  - **`.navigation.yml`** — `configs['/guide']` can set `navigation: false`
  *    on a directory to hide the entire subtree from navigation; or
  *    override `title`/other fields.
- *  - **Natural sort** — siblings sort by `_file` (filename without the
+ *  - **Natural sort** — siblings sort by `file.path` (filename without the
  *    extension) via `Intl.Collator({ numeric: true })`, so `10-foo` comes
  *    after `2-foo`, not between `1-foo` and `20-foo`.
  *  - **Two-pass shaping** — we build a mutable canonical tree, then project it

package/dist/features/navigation/build.js

@@ -10,19 +10,18 @@ const pick = (keys) => (obj) => {
 };
 const isObject = (value) => Object.prototype.toString.call(value) === "[object Object]";
 const parentCanonicalKey = (content, depth) => {
-  const canonicalKey = content._canonicalKey;
+  const canonicalKey = content.canonicalKey;
   if (typeof canonicalKey !== "string" || !canonicalKey) {
     return void 0;
   }
   return canonicalKey.split("/").slice(0, depth + 1).join("/") || void 0;
 };
+const sortBasename = (item) => {
+  const path = item.file?.path;
+  return typeof path === "string" ? path.split(".").slice(0, -1).join(".") : "";
+};
 const sortCanonicalTree = (items) => {
-  items.forEach((item) => {
-    if (item._file) {
-      item._file = item._file.split(".").slice(0, -1).join(".");
-    }
-  });
-  const sorted = items.sort((left, right) => collator.compare(left._file || "", right._file || ""));
+  const sorted = items.sort((left, right) => collator.compare(sortBasename(left), sortBasename(right)));
   for (const item of sorted) {
     if (item.children?.length) {
       sortCanonicalTree(item.children);
@@ -40,26 +39,25 @@ export const buildCanonicalNavigation = (contents, configs, fields = []) => {
       ...navigationFields
     };
   };
-  const navigation = contents.sort((left, right) => left._path.localeCompare(right._path)).reduce((nav, content) => {
-    const parts = content._path.substring(1).split("/");
-    const idParts = content._id.split(":").slice(1);
+  const navigation = contents.sort((left, right) => left.path.localeCompare(right.path)).reduce((nav, content) => {
+    const parts = content.path.substring(1).split("/");
+    const idParts = content.id.split(":").slice(1);
     const isIndex = Boolean(idParts[idParts.length - 1]?.match(/([1-9][0-9]*\.)?index.md/g));
     const navItem = {
       title: content.title,
-      _path: content._path,
-      path: content._path,
-      _file: content._file,
-      _id: content._id,
-      _canonicalKey: content._canonicalKey,
-      _locale: content._locale,
-      _navigationKind: "page",
-      _navigationPath: content._path,
+      path: content.path,
+      file: content.file,
+      id: content.id,
+      canonicalKey: content.canonicalKey,
+      locale: content.locale,
+      navigationKind: "page",
+      navigationPath: content.path,
       children: [],
       ...pickNavigationFields(content),
-      ...content._draft ? { _draft: true } : {}
+      ...content.draft ? { draft: true } : {}
     };
     if (isIndex) {
-      const dirConfig = navItem._path ? configs[navItem._path] : void 0;
+      const dirConfig = navItem.path ? configs[navItem.path] : void 0;
       if (typeof dirConfig?.navigation !== "undefined" && !dirConfig.navigation) {
         return nav;
       }
@@ -82,14 +80,13 @@ export const buildCanonicalNavigation = (contents, configs, fields = []) => {
         const canonicalKey = parentCanonicalKey(content, index);
         parent = {
           title: generateTitle(part),
-          _path: currentPathPart,
           path: currentPathPart,
-          _file: content._file,
-          _navigationKind: "folder",
-          _navigationPath: currentPathPart,
+          file: content.file,
+          navigationKind: "folder",
+          navigationPath: currentPathPart,
           page: false,
-          ...canonicalKey ? { _canonicalKey: canonicalKey } : {},
-          ...content._locale ? { _locale: content._locale } : {},
+          ...canonicalKey ? { canonicalKey } : {},
+          ...content.locale ? { locale: content.locale } : {},
           children: [],
           ...config && pickNavigationFields(config)
         };

package/dist/features/navigation/canonical.d.ts

@@ -1,20 +1,19 @@
-import type { ContentNavigationItem, NavItem } from '../../types/content';
+import type { ContentFileMeta, ContentNavigationItem, NavItem } from '../../types/content';
 import { type RouteMounts } from '../localization/path';
 export type NavigationNodeKind = 'page' | 'folder';
 export interface CanonicalNavigationItem {
     title: string;
     path?: string;
-    _path?: string;
     stem?: string;
     page?: false;
-    _id?: string;
-    _canonicalKey?: string;
-    _locale?: string;
-    _fallback?: boolean;
-    _draft?: boolean;
-    _file?: string;
-    _navigationKind?: NavigationNodeKind;
-    _navigationPath?: string;
+    id?: string;
+    canonicalKey?: string;
+    locale?: string;
+    fallback?: boolean;
+    draft?: boolean;
+    file?: ContentFileMeta;
+    navigationKind?: NavigationNodeKind;
+    navigationPath?: string;
     _collectionRoot?: string;
     children?: CanonicalNavigationItem[];
     [key: string]: unknown;
@@ -26,7 +25,7 @@ export interface ProjectNavigationOptions {
     collection?: string;
     canonical?: boolean;
 }
-export declare const getNavigationIdentity: (node: Pick<CanonicalNavigationItem, "_canonicalKey" | "_path" | "_id">) => string | undefined;
+export declare const getNavigationIdentity: (node: Pick<CanonicalNavigationItem, "canonicalKey">) => string | undefined;
 export declare const mergeCanonicalNavigation: (primary?: CanonicalNavigationItem[], fallback?: CanonicalNavigationItem[]) => CanonicalNavigationItem[];
 export declare const markCollectionNavigationRoot: (navigation?: CanonicalNavigationItem[], collection?: string, options?: Pick<ProjectNavigationOptions, "routeMounts">) => CanonicalNavigationItem[];
 export declare const scopeNavigationTree: (navigation?: CanonicalNavigationItem[], collection?: string) => CanonicalNavigationItem[];

package/dist/features/navigation/canonical.js

@@ -1,14 +1,14 @@
 import { getContentStem, normalizeContentPath, projectContentPathToLocale } from "../localization/path.js";
 const isString = (value) => typeof value === "string" && value.length > 0;
 export const getNavigationIdentity = (node) => {
-  if (isString(node._canonicalKey)) {
-    return node._canonicalKey;
+  if (isString(node.canonicalKey)) {
+    return node.canonicalKey;
   }
   return void 0;
 };
 const cloneFallbackNode = (node) => ({
   ...node,
-  _fallback: true,
+  fallback: true,
   children: node.children?.map(cloneFallbackNode)
 });
 export const mergeCanonicalNavigation = (primary = [], fallback = []) => {
@@ -55,13 +55,13 @@ const normalizeRoutePath = (path) => {
   return normalizeContentPath(path);
 };
 const isFolderNode = (item) => {
-  if (item._navigationKind === "folder") {
+  if (item.navigationKind === "folder") {
     return true;
   }
-  if (item._navigationKind === "page") {
+  if (item.navigationKind === "page") {
     return false;
   }
-  return Boolean(item.children?.length && !item._id && !item._path && !item.path);
+  return Boolean(item.children?.length && !item.id && !item.path);
 };
 const matchesCollectionRootConfig = (collection, root, options) => {
   if (!root.children?.length) {
@@ -71,7 +71,7 @@ const matchesCollectionRootConfig = (collection, root, options) => {
   if (identity === collection || identity === `/${collection}`) {
     return true;
   }
-  const rootPath = normalizeRoutePath(root._path || root._navigationPath || root.path);
+  const rootPath = normalizeRoutePath(root.navigationPath || root.path);
   if (rootPath === "/" || rootPath === `/${collection}`) {
     return true;
   }
@@ -102,16 +102,22 @@ export const scopeNavigationTree = (navigation = [], collection) => {
 };
 const publicFields = (item) => {
   const {
-    children: _children,
-    path: _path,
-    _path: _canonicalPath,
-    stem: _stem,
-    _file,
-    _navigationKind,
-    _navigationPath,
+    children,
+    path,
+    stem,
+    file,
+    navigationKind,
+    navigationPath,
     _collectionRoot,
     ...fields
   } = item;
+  void children;
+  void path;
+  void stem;
+  void file;
+  void navigationKind;
+  void navigationPath;
+  void _collectionRoot;
   return fields;
 };
 const projectNavigationItem = (item, options) => {
@@ -119,7 +125,7 @@ const projectNavigationItem = (item, options) => {
   const hasChildren = Boolean(children?.length);
   const base = {
     ...publicFields(item),
-    _fallback: item._fallback === true
+    fallback: item.fallback === true
   };
   if (isFolderNode(item)) {
     return {
@@ -127,20 +133,19 @@ const projectNavigationItem = (item, options) => {
       ...hasChildren ? { children } : {}
     };
   }
-  const rawPath = item._path || item._navigationPath || item.path;
+  const rawPath = item.navigationPath || item.path;
   if (!rawPath) {
     return {
       ...base,
       ...hasChildren ? { children } : {}
     };
   }
-  const canonicalPath = normalizeContentPath(rawPath);
+  const unprefixedPath = normalizeContentPath(rawPath);
   return {
     ...base,
-    _path: canonicalPath,
-    path: options.canonical ? canonicalPath : projectContentPathToLocale(canonicalPath, options.locale || item._locale, options.defaultLocale, options.routeMounts),
-    canonicalPath,
-    stem: item.stem || getContentStem(canonicalPath, item._file),
+    path: options.canonical ? unprefixedPath : projectContentPathToLocale(unprefixedPath, options.locale || item.locale, options.defaultLocale, options.routeMounts),
+    unprefixedPath,
+    stem: item.stem || getContentStem(unprefixedPath, item.file?.path),
     ...hasChildren ? { children } : {}
   };
 };

package/dist/features/navigation/resolve.js

@@ -4,7 +4,7 @@ export const getNavigationItemPath = (item) => {
   if (!item || item.page === false) {
     return void 0;
   }
-  return stringValue(item.path) || stringValue(item._path);
+  return stringValue(item.path) || stringValue(item.path);
 };
 export const resolveNavigationItem = (item) => {
   const path = getNavigationItemPath(item);
@@ -15,16 +15,16 @@ const fieldMatches = (item, field, value) => {
   if (!candidate) {
     return false;
   }
-  if (field === "path" || field === "_path" || field === "canonicalPath") {
+  if (field === "path" || field === "unprefixedPath") {
     return normalizePath(candidate) === normalizePath(value);
   }
   return candidate === value;
 };
 export const matchesNavigationItem = (item, match) => {
   if (typeof match === "string") {
-    return fieldMatches(item, "path", match) || fieldMatches(item, "_path", match) || fieldMatches(item, "canonicalPath", match) || fieldMatches(item, "stem", match) || fieldMatches(item, "title", match);
+    return fieldMatches(item, "path", match) || fieldMatches(item, "unprefixedPath", match) || fieldMatches(item, "stem", match) || fieldMatches(item, "title", match);
   }
-  if (match.path && !(fieldMatches(item, "path", match.path) || fieldMatches(item, "_path", match.path) || fieldMatches(item, "canonicalPath", match.path))) {
+  if (match.path && !(fieldMatches(item, "path", match.path) || fieldMatches(item, "unprefixedPath", match.path))) {
     return false;
   }
   if (match.stem && !fieldMatches(item, "stem", match.stem)) {

package/dist/features/navigation/tree.js

@@ -1,10 +1,10 @@
 export function flattenCollectionNavigation(navigation = []) {
   return navigation.flatMap((item) => {
     const children = item.children ? flattenCollectionNavigation(item.children) : [];
-    if (!item._path && !item.path) {
+    if (!item.unprefixedPath && !item.path) {
       return children;
     }
-    if (item.page === false || children.length && children.find((child) => child._path === item._path)) {
+    if (item.page === false || children.length && children.find((child) => child.unprefixedPath === item.unprefixedPath)) {
       return children;
     }
     return [{ ...item, children: void 0 }, ...children];
@@ -16,7 +16,7 @@ export function createCollectionSurroundings(navigation = [], path, options = {}
   const items = flattenCollectionNavigation(navigation);
   const normalizedPath = path.endsWith("/") && path !== "/" ? path.slice(0, -1) : path;
   const index = items.findIndex((item) => {
-    const itemPath = typeof item.path === "string" ? item.path : item._path;
+    const itemPath = typeof item.path === "string" ? item.path : typeof item.unprefixedPath === "string" ? item.unprefixedPath : void 0;
     if (!itemPath) {
       return false;
     }

package/dist/{runtime → features}/query/backlinks.js

@@ -28,11 +28,9 @@ const inferBacklinkFields = (source, targetCollection, runtime) => {
 const targetReferenceCandidates = (doc) => {
   const values = [
     doc.ref,
-    doc.id,
-    doc._canonicalKey,
-    doc._path,
-    doc._path ? doc.path : void 0,
-    doc._path ? doc.canonicalPath : void 0
+    doc.canonicalKey,
+    doc.canonicalKey ? doc.path : void 0,
+    doc.canonicalKey ? doc.unprefixedPath : void 0
   ].filter((value) => typeof value === "string" && value.length > 0).flatMap((value) => [value, normalizeReferenceValue(value)]).filter(Boolean);
   return Array.from(new Set(values));
 };

package/dist/{runtime → features}/query/documents.js

@@ -21,7 +21,7 @@ const explainResolution = (collection, requestedBy, normalizedBy, requestedLocal
       found: Boolean(doc),
       collection,
       ...doc?.path ? { path: doc.path } : {},
-      ...doc?.canonicalPath ? { canonicalPath: doc.canonicalPath } : {},
+      ...doc?.unprefixedPath ? { unprefixedPath: doc.unprefixedPath } : {},
       ...doc?.ref ? { ref: doc.ref } : {},
       ...resolvedLocale ? { locale: resolvedLocale } : {}
     },

package/dist/{runtime → features}/query/localized-docs.d.ts

@@ -4,7 +4,7 @@ import type { RuntimeContentConfig } from './context';
 /**
  * Decorate a raw parsed document with route metadata and locale paths.
  *
- * `localizePageResult` already attaches `path`, `canonicalPath`, `locale`,
+ * `localizePageResult` already attaches `path`, `unprefixedPath`, `locale`,
  * `defaultLocale`, `variants`, and `localePaths`. This helper additionally
  * fills non-translated locales with fallback paths so app switchers can render
  * all configured languages without another query.

package/dist/{runtime → features}/query/localized-docs.js

@@ -20,14 +20,11 @@ export const decorateLocalizedDocument = (doc, collection, runtime, requestedLoc
   const { locales, defaultLocale, routeMounts, hasLocaleConfig } = collectionLocaleConfig(collection, runtime);
   const page = hasLocaleConfig ? doc : {
     ...doc,
-    _locale: "",
-    _resolvedLocale: void 0,
-    _requestedLocale: void 0,
-    _variantPaths: void 0,
-    _availableLocales: []
+    locale: "",
+    resolved: { availableLocales: [] }
   };
   const result = localizePageResult(page, hasLocaleConfig ? requestedLocale : void 0, defaultLocale, locales, routeMounts);
-  const fallbackLocale = doc._resolvedLocale || requestedLocale || defaultLocale;
+  const fallbackLocale = doc.resolved?.locale || requestedLocale || defaultLocale;
   result.localePaths = decorateLocalePathsWithFallbacks(result.localePaths, locales, fallbackLocale, defaultLocale, routeMounts);
   return result;
 };

package/dist/{runtime → features}/query/navigation.d.ts

@@ -4,7 +4,7 @@ import type { ContentTreeItem, LocalizedContentDocument, NeighborsOptions, Neigh
 import type { ContentQueryContext } from './context';
 export declare const navigationSelectFields: (fields?: ReadonlyArray<string> | undefined) => string[];
 type OneResolver = <H extends ContentCollectionHandle | string>(context: ContentQueryContext, handle: H, options: OneOptions<H>) => Promise<LocalizedContentDocument<ParsedContent> | null>;
-type TreeResolver = <H extends ContentCollectionHandle | string, Fields extends ReadonlyArray<string> | undefined = undefined>(context: ContentQueryContext, handle: H, options?: Omit<TreeOptions<H>, 'fields'> & {
+type TreeResolver = <H extends ContentCollectionHandle | string, Fields extends ReadonlyArray<string> | undefined = undefined>(context: ContentQueryContext, handle: H, options: Omit<TreeOptions<H>, 'fields'> & {
     fields?: Fields;
 }) => Promise<unknown[]>;
 export declare function resolveTree<H extends ContentCollectionHandle | string, Fields extends ReadonlyArray<string> | undefined = undefined>(context: ContentQueryContext, handle: H, options?: Omit<TreeOptions<H>, 'fields'> & {

package/dist/{runtime → features}/query/navigation.js

@@ -3,12 +3,12 @@ import { ensureCollectionName } from "./handles.js";
 import { isCollectionRouteRoot, isNavigationRootPath } from "./localized-docs.js";
 import { resolveFallback } from "./locale-options.js";
 const NAVIGATION_INTERNAL_FIELDS = [
-  "_id",
-  "_path",
-  "_file",
-  "_canonicalKey",
-  "_locale",
-  "_draft",
+  "id",
+  "path",
+  "file",
+  "canonicalKey",
+  "locale",
+  "draft",
   "navigation",
   "title"
 ];
@@ -50,8 +50,8 @@ export async function resolveNeighbors(context, one, tree, handle, options) {
   const walk = (nodes) => {
     for (const node of nodes) {
       const n = node;
-      if (n.path || n._path) {
-        flat.push({ path: n.path || n._path || "", item: node });
+      if (n.path) {
+        flat.push({ path: n.path || "", item: node });
       }
       if (Array.isArray(n.children)) walk(n.children);
     }

package/dist/{runtime → features}/query/populate.js

@@ -1,20 +1,12 @@
 import { collectTopLevelReferenceFieldsByTarget } from "../../core/references/schema";
 import { ensureCollectionName } from "./handles.js";
 const LOCALIZED_DOC_INTERNAL_FIELDS = [
-  "_id",
-  "_path",
-  "_file",
-  "_canonicalKey",
-  "_locale",
-  "_resolvedLocale",
-  "_requestedLocale",
-  "_fallback",
-  "_availableLocales",
-  "_variantPaths",
-  "_requestedPath",
-  "_requestedRoute",
-  "_requestedRef",
-  "_extension"
+  "id",
+  "path",
+  "file",
+  "canonicalKey",
+  "locale",
+  "resolved"
 ];
 const wildcardReferenceTarget = "*";
 const isRecord = (value) => {

package/dist/{runtime → features}/query/unified.d.ts

@@ -16,7 +16,7 @@
  */
 import type { ParsedContent } from '../../types/content';
 import type { ContentCollectionHandle } from '../../types/config';
-import type { BacklinkSource, BacklinksOptions, BacklinksResult, ContentTreeItem, DocumentFromHandle, ManyOptions, LocalizedDoc, NeighborsOptions, NeighborsResult, OneOptions, PopulateSpec, PopulateFromOptions, PopulatedDocument, PaginationOptions, PaginationResult, ResolveOneOptions, ResolveOneResult, TreeOptions, ContentVariant, VariantsOptions } from '../../types/query';
+import type { BacklinkSource, BacklinksOptions, BacklinksResult, ContentTreeItem, DocumentFromHandle, ManyOptions, LocalizedDoc, NeighborsOptions, NeighborsResult, OneOptions, OptionsArg, PopulateSpec, PopulateFromOptions, PopulatedDocument, PaginationOptions, PaginationResult, ResolveOneOptions, ResolveOneResult, TreeOptions, ContentVariant, VariantsOptions } from '../../types/query';
 import type { ContentQueryContext } from './context';
 export type { ContentQueryContext, ContentQueryEndpoint, RuntimeContentConfig } from './context';
 export { navigationSelectFields } from './navigation';
@@ -31,7 +31,7 @@ export declare function one<const H extends ContentCollectionHandle | string, O
 /**
  * Resolve a list of documents matching the filter. Always returns an array.
  */
-export declare function many<const H extends ContentCollectionHandle | string, O extends ManyOptions<H, PopulateSpec | undefined>>(context: ContentQueryContext, handle: H, options?: O): Promise<Array<LocalizedDoc<PopulatedDocument<DocumentFromHandle<H>, PopulateFromOptions<O>>>>>;
+export declare function many<const H extends ContentCollectionHandle | string, O extends ManyOptions<H, PopulateSpec | undefined>>(context: ContentQueryContext, handle: H, ...args: OptionsArg<H, O>): Promise<Array<LocalizedDoc<PopulatedDocument<DocumentFromHandle<H>, PopulateFromOptions<O>>>>>;
 /**
  * Resolve one page of documents and preserve the query envelope metadata.
  */
@@ -62,9 +62,9 @@ export declare function variants<H extends ContentCollectionHandle | string>(con
  * fallback locale's path). This matches legacy navigation semantics —
  * sidebars are inherently lossy when filtered too strictly.
  */
-export declare function tree<H extends ContentCollectionHandle | string, Fields extends ReadonlyArray<string> | undefined = undefined>(context: ContentQueryContext, handle: H, options?: Omit<TreeOptions<H>, 'fields'> & {
+export declare function tree<H extends ContentCollectionHandle | string, Fields extends ReadonlyArray<string> | undefined = undefined>(context: ContentQueryContext, handle: H, ...args: OptionsArg<H, Omit<TreeOptions<H>, 'fields'> & {
     fields?: Fields;
-}): Promise<ContentTreeItem<H extends {
+}>): Promise<ContentTreeItem<H extends {
     __schema: {
         _output: infer O;
     };

package/dist/{runtime → features}/query/unified.js

@@ -10,7 +10,8 @@ export async function resolveOne(context, handle, options) {
 export async function one(context, handle, options) {
   return resolveDocumentOnly(context, handle, options);
 }
-export async function many(context, handle, options = {}) {
+export async function many(context, handle, ...args) {
+  const options = args[0] ?? {};
   return resolveManyDocuments(context, one, handle, options);
 }
 export async function paginate(context, handle, options) {
@@ -22,7 +23,8 @@ export async function backlinks(context, targetHandle, options) {
 export async function variants(context, handle, options) {
   return resolveVariants(context, one, handle, options);
 }
-export async function tree(context, handle, options = {}) {
+export async function tree(context, handle, ...args) {
+  const options = args[0] ?? {};
   return resolveTree(context, handle, options);
 }
 export async function neighbors(context, handle, options) {

package/dist/{runtime → features}/query/variants.js

@@ -15,14 +15,14 @@ export async function resolveVariants(context, one, handle, options) {
     fallback: true
   });
   if (!seed) return [];
-  const variantPaths = seed._variantPaths || {};
+  const localePaths = seed.localePaths || {};
   const sourceLocale = seed.locale || defaultLocale || "";
   return requestedLocales.map((locale) => {
-    const variantPath = variantPaths[locale];
-    if (variantPath) {
+    const entry = localePaths[locale];
+    if (entry?.translated) {
       return {
         locale,
-        path: seed.localePaths[locale]?.path || variantPath,
+        path: entry.path,
         translated: true
       };
     }

package/dist/features/search/navigation.js

@@ -1,5 +1,5 @@
-const itemPath = (item) => item.path || item._path;
-const searchGroupId = (item, depth, index) => `content-search-group:${String(item._canonicalKey || item.stem || `${depth}:${index}`)}`;
+const itemPath = (item) => item.path || item.path;
+const searchGroupId = (item, depth, index) => `content-search-group:${String(item.canonicalKey || item.stem || `${depth}:${index}`)}`;
 export function createContentSearchNavigation(items = [], depth = 0) {
   return items.map((item, index) => {
     const children = item.children ? createContentSearchNavigation(item.children, depth + 1) : [];

package/dist/features/search/sections.d.ts

@@ -1,6 +1,6 @@
 import type { ParsedContent } from '../../types/content';
 import type { ContentCollectionSearchSectionsOptions, ContentSearchSection } from '../../types/query';
-type SearchablePage = Pick<ParsedContent, '_path' | 'title' | 'description' | 'body'> & Record<string, unknown>;
+type SearchablePage = Pick<ParsedContent, 'path' | 'title' | 'description' | 'body'> & Record<string, unknown>;
 /**
  * Backing option type for search-section generation.
  *

package/dist/features/search/sections.js

@@ -19,7 +19,7 @@ function splitPageIntoSections(page, {
   minLevel,
   maxLevel
 }) {
-  const path = page._path || "";
+  const path = page.path || "";
   const extraFieldsData = pick(extraFields, page);
   const body = page.body;
   const sections = [{

package/dist/features/sitemap/query.d.ts

@@ -1,10 +1,10 @@
 import type { ContentSitemapEntry } from '../../types/query';
 type ContentLikePage = {
-    _path?: string;
-    _collection?: string;
-    _canonicalKey?: string;
-    _locale?: string;
-    _draft?: boolean;
+    path?: string;
+    collection?: string;
+    canonicalKey?: string;
+    locale?: string;
+    draft?: boolean;
     sitemap?: unknown;
     body?: unknown;
     image?: unknown;

package/dist/features/sitemap/query.js

@@ -123,25 +123,25 @@ export async function queryCollectionsSitemapEntriesData(runtime, loaders, optio
     const collectionPages = await loaders.loadCollectionPages(collection);
     return collectionPages.map((page) => ({
       ...page,
-      _collection: page._collection || collection
+      collection: page.collection || collection
     }));
   }))).flat().filter((page) => {
     if (page.sitemap === false) {
       return false;
     }
-    return shouldIncludeDrafts || !page._draft;
+    return shouldIncludeDrafts || !page.draft;
   });
   const uniquePages = Array.from(new Map(
     pages.map((page) => [
-      `${page._collection || ""}:${page._canonicalKey || page._path || ""}`,
+      `${page.collection || ""}:${page.canonicalKey || page.path || ""}`,
       page
     ])
   ).values());
   const rawEntries = await Promise.all(uniquePages.map(async (page) => {
-    if (!page._path || !page._collection) {
+    if (!page.path || !page.collection) {
       return [];
     }
-    const meta = await loaders.loadRouteMeta(page._collection, page._path, page._locale);
+    const meta = await loaders.loadRouteMeta(page.collection, page.path, page.locale);
     if (!meta) {
       return [];
     }
@@ -149,7 +149,7 @@ export async function queryCollectionsSitemapEntriesData(runtime, loaders, optio
     const localizedVariants = variants.filter((variant) => variant.locale);
     const alternatives = localizedVariants.length > 1 ? buildAlternatives(siteUrl, meta.defaultLocale, localeToLanguage, variants) : void 0;
     return await Promise.all(variants.map(async (variant) => {
-      const variantPage = await loaders.loadPage(page._collection, variant.path, variant.locale);
+      const variantPage = await loaders.loadPage(page.collection, variant.path, variant.locale);
       const images = toPageSitemapImages(
         siteUrl,
         variantPage ? { ...page, ...variantPage } : page,