@lupinum/ginko-content 0.1.5 → 0.2.0

package/dist/features/agent/agent-markdown.js

@@ -0,0 +1,138 @@
+export const isRecord = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+export const getMarkdownProp = (node, name) => {
+  const props = isRecord(node.props) ? node.props : {};
+  const value = props[name];
+  return typeof value === "string" ? value : "";
+};
+export const renderMarkdownChildren = (node, ctx) => ctx.renderChildren(node);
+export const blockquoteMarkdown = (value) => value.trim().split("\n").map((line) => line ? `> ${line}` : ">").join("\n");
+export const escapeMarkdownLinkLabel = (value) => value.replace(/\\/g, "\\\\").replace(/\[/g, "\\[").replace(/\]/g, "\\]");
+const escapeMarkdownLinkHref = (value) => value.replace(/\)/g, "%29").replace(/\s/g, "%20");
+const isSafeMarkdownHref = (href) => {
+  if (!href) return false;
+  if (href.startsWith("//")) return false;
+  if (href.startsWith("/") || href.startsWith("#") || href.startsWith("./") || href.startsWith("../")) return true;
+  return /^(https?:|mailto:|tel:)/i.test(href);
+};
+export const linkMarkdown = (label, href) => {
+  const resolvedLabel = label || href;
+  if (!href || !isSafeMarkdownHref(href)) return escapeMarkdownLinkLabel(resolvedLabel);
+  return `[${escapeMarkdownLinkLabel(resolvedLabel)}](${escapeMarkdownLinkHref(href)})`;
+};
+export const imageMarkdown = (alt, src) => {
+  if (!src || !isSafeMarkdownHref(src)) return escapeMarkdownLinkLabel(alt || src);
+  return `![${escapeMarkdownLinkLabel(alt)}](${escapeMarkdownLinkHref(src)})`;
+};
+export const jsonFenceMarkdown = (value) => `\`\`\`json
+${JSON.stringify(value, null, 2)}
+\`\`\``;
+const xmlNamePattern = /^[a-z][\w.:-]*$/i;
+const safeXmlName = (name) => xmlNamePattern.test(name) ? name : "component";
+const escapeXmlAttribute = (value) => value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+const isScalarXmlAttributeValue = (value) => typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+const shouldDropAgentProp = (name) => {
+  const normalized = name.trim();
+  const sensitive = normalized.toLowerCase();
+  return !normalized || normalized === "class" || normalized === "style" || normalized === "key" || normalized === "ref" || normalized.startsWith("v-") || normalized.startsWith("@") || normalized.startsWith("on") || normalized.startsWith("data-") || normalized.startsWith("aria-") || /token|secret|password|passwd|credential|authorization|apikey|api-key|clientsecret|client-secret|privatekey|private-key|accesskey|access-key/i.test(sensitive);
+};
+const normalizeAgentPropName = (name) => {
+  const normalized = name.trim();
+  if (normalized.startsWith(":")) return normalized.slice(1);
+  if (normalized.startsWith("v-bind:")) return normalized.slice("v-bind:".length);
+  return normalized;
+};
+const cleanAgentPropValue = (value) => {
+  if (value === void 0 || value === null || value === "") return void 0;
+  if (Array.isArray(value)) {
+    const clean = value.map((entry) => cleanAgentPropValue(entry)).filter((entry) => entry !== void 0);
+    return clean.length ? clean : void 0;
+  }
+  if (isRecord(value)) {
+    const clean = cleanPropsObject(value);
+    return Object.keys(clean).length ? clean : void 0;
+  }
+  return value;
+};
+export const cleanPropsObject = (props) => {
+  if (!isRecord(props)) return {};
+  const clean = {};
+  for (const [name, value] of Object.entries(props)) {
+    const normalizedName = normalizeAgentPropName(name);
+    const cleanedValue = cleanAgentPropValue(value);
+    if (shouldDropAgentProp(normalizedName) || cleanedValue === void 0) continue;
+    if (!(normalizedName in clean) || normalizedName === name.trim()) {
+      clean[normalizedName] = cleanedValue;
+    }
+  }
+  return clean;
+};
+export const xmlComponentMarkdown = (name, props = {}, children = "") => {
+  const tagName = safeXmlName(name);
+  const cleanProps = cleanPropsObject(props);
+  const attrs = [];
+  const complexProps = {};
+  for (const [key, value] of Object.entries(cleanProps)) {
+    if (!xmlNamePattern.test(key)) {
+      complexProps[key] = value;
+      continue;
+    }
+    if (isScalarXmlAttributeValue(value)) {
+      attrs.push(`${key}="${escapeXmlAttribute(String(value))}"`);
+      continue;
+    }
+    complexProps[key] = value;
+  }
+  const attrText = attrs.length ? ` ${attrs.join(" ")}` : "";
+  const bodyParts = [
+    Object.keys(complexProps).length ? jsonFenceMarkdown(complexProps) : "",
+    children.trim()
+  ].filter(Boolean);
+  if (!bodyParts.length) return `<${tagName}${attrText} />`;
+  return `<${tagName}${attrText}>
+${bodyParts.join("\n\n")}
+</${tagName}>`;
+};
+export const defineAgentMarkdownComponent = (component) => component;
+export const createAgentMarkdownRegistry = () => {
+  const serializers = /* @__PURE__ */ new Map();
+  const register = (name, serializer, options = {}) => {
+    const existing = serializers.get(name);
+    if (existing === serializer && !options.override) return;
+    if (existing && !options.override) {
+      throw new Error(
+        `Agent Markdown serializer "${name}" is already registered. Use { override: true } only when replacing an existing serializer intentionally.`
+      );
+    }
+    serializers.set(name, serializer);
+  };
+  const registerComponent = (name, component, options = {}) => register(name, component.render, options);
+  return {
+    register,
+    registerMany: (entries, options) => {
+      for (const [name, serializer] of Object.entries(entries)) register(name, serializer, options);
+    },
+    registerComponent,
+    registerComponents: (entries, options) => {
+      for (const [name, component] of Object.entries(entries)) registerComponent(name, component, options);
+    },
+    clear: () => serializers.clear(),
+    get: (name) => serializers.get(name)
+  };
+};
+export const resolveAgentMarkdownOptions = (collection) => {
+  if (!collection || collection.type === "data") return null;
+  const value = collection.agent?.markdown;
+  if (value === true) {
+    return {
+      includeInIndex: true,
+      includeInFull: true,
+      metadata: []
+    };
+  }
+  if (!value || !isRecord(value)) return null;
+  return {
+    includeInIndex: value.includeInIndex !== false,
+    includeInFull: value.includeInFull !== false,
+    metadata: Array.isArray(value.metadata) ? value.metadata.filter((field) => typeof field === "string" && field.length > 0) : []
+  };
+};

package/dist/features/agent/walker

@@ -0,0 +1 @@
+export * from './walker.js'

package/dist/features/agent/walker.d.ts

@@ -0,0 +1,10 @@
+import type { MarkdownRoot } from '../../types/content';
+import type { AgentMarkdownRenderContext } from './agent-markdown';
+/**
+ * The pure agent-markdown walker: serializes a parsed markdown body to agent
+ * markdown as a function of `(body, context)` alone. Every config- and
+ * registry-derived input arrives on {@link AgentMarkdownRenderContext}; the
+ * walker reads no module-global state, so identical inputs always produce
+ * identical output.
+ */
+export declare const renderAgentMarkdownBody: (body: MarkdownRoot | null | undefined, context: AgentMarkdownRenderContext) => string;

package/dist/features/agent/walker.js

@@ -0,0 +1,174 @@
+import { kebabCase, pascalCase } from "scule";
+import {
+  blockquoteMarkdown,
+  cleanPropsObject,
+  escapeMarkdownLinkLabel,
+  getMarkdownProp,
+  imageMarkdown,
+  isRecord,
+  jsonFenceMarkdown,
+  linkMarkdown,
+  xmlComponentMarkdown
+} from "./agent-markdown.js";
+import { agentRawPathForRoute, normalizeAgentRoutePath } from "./agent-paths.js";
+const textValue = (node) => {
+  if (node.type === "text") return node.value || "";
+  return (node.children || []).map((child) => textValue(child)).join("");
+};
+const renderChildren = (node, ctx) => (node.children || []).map((child) => renderNode(child, ctx)).join("").trim();
+const block = (value) => value.trim() ? `${value.trim()}
+
+` : "";
+const renderList = (node, ctx, ordered = false) => block((node.children || []).map((child, index) => {
+  const body = renderChildren(child, ctx).replace(/\n+/g, "\n  ").trim();
+  return `${ordered ? `${index + 1}.` : "-"} ${body}`;
+}).join("\n"));
+const renderTable = (node, ctx) => {
+  const rows = (node.children || []).flatMap(
+    (section) => section.tag === "thead" || section.tag === "tbody" ? section.children || [] : [section]
+  ).filter((row) => row.tag === "tr");
+  if (!rows.length) return "";
+  const cells = rows.map(
+    (row) => (row.children || []).filter((cell) => cell.tag === "th" || cell.tag === "td").map((cell) => renderChildren(cell, ctx).replace(/\|/g, "\\|").trim())
+  );
+  const width = Math.max(...cells.map((row) => row.length));
+  const normalized = cells.map((row) => [...row, ...Array.from({ length: width - row.length }, () => "")]);
+  const [head = [], ...bodyRows] = normalized;
+  return block([
+    `| ${head.join(" | ")} |`,
+    `| ${head.map(() => "---").join(" | ")} |`,
+    ...bodyRows.map((row) => `| ${row.join(" | ")} |`)
+  ].join("\n"));
+};
+const renderUnknownComponentOmission = (name, reason) => `> Component omitted: \`${name}\`.
+> ${reason || "This page contains an interactive or site-specific block that has no agent markdown serializer yet."}`;
+const renderUnknownComponent = (node, ctx) => {
+  const tag = node.tag || "component";
+  const props = cleanPropsObject(node.props);
+  const children = renderChildren(node, ctx);
+  if (children || Object.keys(props).length) {
+    return block(xmlComponentMarkdown(tag, props, children));
+  }
+  return block(renderUnknownComponentOmission(tag));
+};
+const serializerForTag = (tag, ctx) => {
+  const markdownTags = ctx.tagAliases || {};
+  const candidates = new Set([
+    tag,
+    pascalCase(tag),
+    kebabCase(tag),
+    markdownTags[tag],
+    markdownTags[pascalCase(tag)],
+    markdownTags[kebabCase(tag)]
+  ].filter((value) => Boolean(value)));
+  for (const candidate of candidates) {
+    const serializer = ctx.registry.get(candidate);
+    if (serializer) return serializer;
+  }
+};
+const isExternalHref = (href) => /^[a-z][a-z0-9+.-]*:/i.test(href) || href.startsWith("//");
+const prefixLocalizedHref = (path, locale, ctx) => {
+  const normalized = normalizeAgentRoutePath(path);
+  if (!locale || locale === ctx.defaultLocale) return normalized;
+  if (ctx.locales.some((candidate) => normalized === `/${candidate}` || normalized.startsWith(`/${candidate}/`))) return normalized;
+  return normalized === "/" ? `/${locale}` : `/${locale}${normalized}`;
+};
+const routeMarkdownPathForHref = (href, ctx) => {
+  const currentPath = ctx.path || "/";
+  const hash = href.match(/#.*$/)?.[0] || "";
+  const withoutHash = href.replace(/#.*$/, "");
+  if (!withoutHash) return href;
+  if (isExternalHref(withoutHash)) return href;
+  if (withoutHash.endsWith(".md")) return href;
+  const target = withoutHash.startsWith("/") ? prefixLocalizedHref(withoutHash, ctx.locale, ctx) : new URL(withoutHash, `https://agent.local${normalizeAgentRoutePath(currentPath)}`).pathname;
+  return `${agentRawPathForRoute(target)}${hash}`;
+};
+const renderNode = (node, ctx) => {
+  if (node.type === "text") return node.value || "";
+  const tag = node.tag || "";
+  const serializer = tag ? serializerForTag(tag, ctx) : void 0;
+  if (serializer) {
+    const nodeCtx = {
+      ...ctx,
+      prop: (name) => getMarkdownProp(node, name),
+      props: (target) => isRecord((target || node).props) ? (target || node).props : {},
+      cleanProps: (target) => cleanPropsObject((target || node).props),
+      children: (target) => renderChildren(target || node, nodeCtx)
+    };
+    const rendered = serializer(node, nodeCtx);
+    if (typeof rendered === "string") return block(rendered);
+  }
+  if (!tag) return renderChildren(node, ctx);
+  if (/^h[1-6]$/.test(tag)) {
+    const depth = Number(tag.slice(1));
+    return block(`${"#".repeat(Math.max(1, Math.min(6, depth)))} ${renderChildren(node, ctx)}`);
+  }
+  switch (tag) {
+    case "p":
+      return block(renderChildren(node, ctx));
+    case "blockquote":
+      return block(renderChildren(node, ctx).split("\n").map((line) => `> ${line}`).join("\n"));
+    case "strong":
+    case "b":
+      return `**${renderChildren(node, ctx)}**`;
+    case "em":
+    case "i":
+      return `_${renderChildren(node, ctx)}_`;
+    case "span":
+      return renderChildren(node, ctx);
+    case "code":
+      return `\`${node.value || textValue(node)}\``;
+    case "pre":
+      return block(`\`\`\`
+${textValue(node)}
+\`\`\``);
+    case "a": {
+      const href = typeof node.props?.href === "string" ? node.props.href : "";
+      const text = renderChildren(node, ctx) || href;
+      return href ? linkMarkdown(text, routeMarkdownPathForHref(href, ctx)) : text;
+    }
+    case "ul":
+      return renderList(node, ctx);
+    case "ol":
+      return renderList(node, ctx, true);
+    case "li":
+      return renderChildren(node, ctx);
+    case "hr":
+      return "---\n\n";
+    case "br":
+      return "\n";
+    case "img": {
+      const src = typeof node.props?.src === "string" ? node.props.src : "";
+      const alt = typeof node.props?.alt === "string" ? node.props.alt : "";
+      return src ? imageMarkdown(alt, src) : escapeMarkdownLinkLabel(alt);
+    }
+    case "table":
+      return renderTable(node, ctx);
+    case "thead":
+    case "tbody":
+    case "tr":
+    case "th":
+    case "td":
+      return renderChildren(node, ctx);
+    default:
+      return renderUnknownComponent(node, ctx);
+  }
+};
+export const renderAgentMarkdownBody = (body, context) => {
+  if (!body?.children?.length) return "";
+  const ctx = {
+    ...context,
+    prop: () => "",
+    props: (node) => node ? isRecord(node.props) ? node.props : {} : {},
+    cleanProps: (node) => cleanPropsObject(node?.props),
+    children: (node) => node ? renderChildren(node, ctx) : "",
+    renderChildren: (node) => renderChildren(node, ctx),
+    renderNode: (node) => renderNode(node, ctx),
+    blockquote: (value) => blockquoteMarkdown(value),
+    jsonFence: (value) => jsonFenceMarkdown(value),
+    link: (label, href) => linkMarkdown(label, href),
+    omitted: (name, reason) => renderUnknownComponentOmission(name, reason),
+    xmlComponent: (name, props, children) => xmlComponentMarkdown(name, props, children)
+  };
+  return body.children.map((node) => renderNode(node, ctx)).join("").trim();
+};

package/dist/features/collections/resolve.d.ts

@@ -6,7 +6,7 @@ export interface CollectionResolveRuntime extends RuntimeContentI18nInput {
     localeFallback?: Record<string, string[]>;
     translatedSlugs?: boolean;
 }
-export declare const resolveCollectionNavigationData: (_collection: string, _runtime: CollectionResolveRuntime, options: {
+export declare const resolveCollectionNavigationData: (collection: string, _runtime: CollectionResolveRuntime, options: {
     fields?: string[];
     locale?: string;
     canonical?: boolean;
@@ -31,7 +31,7 @@ export declare const resolveCollectionSearchSectionsData: (collection: string, r
     canonical?: boolean;
     activeLocale?: string;
 }) & {
-    loadPages: (extraFields: string[]) => Promise<Array<Pick<ParsedContent, "_path" | "title" | "description" | "body"> & Record<string, unknown>>>;
+    loadPages: (extraFields: string[]) => Promise<Array<Pick<ParsedContent, "path" | "title" | "description" | "body"> & Record<string, unknown>>>;
 }) => Promise<{
     id: string;
     title: string;

package/dist/features/collections/resolve.js

@@ -2,7 +2,8 @@ import { createCollectionSurroundings } from "../navigation/tree.js";
 import { createSearchSections } from "../search/sections.js";
 import { normalizeContentPath, resolveCollectionI18n, resolveRouteContent } from "../localization/path.js";
 import { createRouteMeta, localizePageResult, localizeSearchSections } from "../localization/results.js";
-export const resolveCollectionNavigationData = async (_collection, _runtime, options) => {
+import { sortLocalesCanonically } from "../../core/content/locale";
+export const resolveCollectionNavigationData = async (collection, _runtime, options) => {
   return await options.loadNavigation();
 };
 export const resolveCollectionItemSurroundingsData = async (collection, path, runtime, options) => {
@@ -37,14 +38,15 @@ export const resolveCollectionPageData = async (collection, routeOrPath, runtime
     return null;
   }
   if (options.canonical) {
-    const canonicalPath = normalizeContentPath(page._path || "/");
-    const resolvedLocale = page._resolvedLocale || page._locale || resolved.locale || defaultLocale || "";
-    const requestedLocale = page._requestedLocale || resolved.locale;
-    const fallback = Boolean(page._fallback || requestedLocale && resolvedLocale && requestedLocale !== resolvedLocale);
+    const resolution = page.resolved;
+    const unprefixedPath = normalizeContentPath(page.path || "/");
+    const resolvedLocale = resolution?.locale || page.locale || resolved.locale || defaultLocale || "";
+    const requestedLocale = resolution?.requestedLocale || resolved.locale;
+    const fallback = Boolean(resolution?.fallback || requestedLocale && resolvedLocale && requestedLocale !== resolvedLocale);
     return {
       ...page,
-      path: canonicalPath,
-      canonicalPath,
+      path: unprefixedPath,
+      unprefixedPath,
       locale: resolved.locale || resolvedLocale,
       defaultLocale: defaultLocale || "",
       variants: [],
@@ -54,14 +56,15 @@ export const resolveCollectionPageData = async (collection, routeOrPath, runtime
         ...requestedLocale ? { requestedLocale } : {},
         fallback,
         ...fallback ? { fallbackLocale: resolvedLocale } : {},
-        path: canonicalPath,
-        ...page._requestedPath ? { requestedPath: page._requestedPath } : {},
-        ...page._requestedRoute ? { requestedRoute: page._requestedRoute } : {},
-        ...page._requestedRef ? { requestedRef: page._requestedRef } : {},
-        availableLocales: page._availableLocales || Object.keys(page._variantPaths || {})
+        path: unprefixedPath,
+        ...resolution?.requestedPath ? { requestedPath: resolution.requestedPath } : {},
+        ...resolution?.requestedRoute ? { requestedRoute: resolution.requestedRoute } : {},
+        ...resolution?.requestedRef ? { requestedRef: resolution.requestedRef } : {},
+        availableLocales: resolution?.availableLocales || sortLocalesCanonically(Object.keys(resolution?.variantPaths || {}), { defaultLocale, locales }),
+        ...resolution?.resolvedRefs ? { resolvedRefs: resolution.resolvedRefs } : {}
       },
-      stem: canonicalPath.replace(/^\/+/, "") || "index",
-      extension: page._extension
+      stem: unprefixedPath.replace(/^\/+/, "") || "index",
+      extension: page.file?.extension
     };
   }
   return localizePageResult(page, resolved.locale, defaultLocale, locales);
@@ -71,6 +74,6 @@ export const resolveCollectionRouteMetaData = async (collection, runtime, option
   if (!page) {
     return null;
   }
-  const { defaultLocale } = resolveCollectionI18n(collection, runtime);
-  return createRouteMeta(page, page.locale, defaultLocale);
+  const { defaultLocale, locales } = resolveCollectionI18n(collection, runtime);
+  return createRouteMeta(page, page.locale, defaultLocale, locales);
 };

package/dist/features/localization/links.js

@@ -1,5 +1,5 @@
 import { localizePath } from "./path.js";
-const LOCALIZED_PROP_KEYS = /* @__PURE__ */ new Set(["href", "to", "path", "_path"]);
+const LOCALIZED_PROP_KEYS = /* @__PURE__ */ new Set(["href", "to", "path", "path"]);
 const LOCALIZED_BOUND_PREFIXES = [":", "v-bind:"];
 const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 const getBoundPropName = (key) => {

package/dist/features/localization/results.d.ts

@@ -2,9 +2,9 @@ import type { ContentNavigationItem, ParsedContent } from '../../types/content';
 import type { ContentLocaleEntry, ContentPageResult, ContentRouteMeta, LocalePathEntry } from '../../types/query';
 import type { SearchSection } from '../search/sections';
 import { type RouteMounts } from './path';
-export declare const createLocaleVariants: (variants: Record<string, string> | ContentLocaleEntry[] | undefined, defaultLocale?: string, routeMounts?: RouteMounts) => {
+export declare const createLocaleVariants: (variants: Record<string, string> | ContentLocaleEntry[] | undefined, defaultLocale?: string, locales?: string[], routeMounts?: RouteMounts) => {
     locale: string;
-    canonicalPath: string;
+    unprefixedPath: string;
     path: string;
 }[];
 /**
@@ -39,4 +39,4 @@ export declare const localizeSearchSections: (sections?: SearchSection[], locale
     level: number;
     content: string;
 }[];
-export declare const createRouteMeta: <T extends ParsedContent & Record<string, unknown>>(page: T, locale?: string, defaultLocale?: string, routeMounts?: RouteMounts) => ContentRouteMeta;
+export declare const createRouteMeta: <T extends ParsedContent & Record<string, unknown>>(page: T, locale?: string, defaultLocale?: string, locales?: string[], routeMounts?: RouteMounts) => ContentRouteMeta;

package/dist/features/localization/results.js

@@ -1,7 +1,8 @@
+import { sortLocalesCanonically } from "../../core/content/locale";
 import { localizeLinkProps } from "./links.js";
 import { getContentStem, localizePath, normalizeContentPath, projectContentPathToLocale } from "./path.js";
 const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-export const createLocaleVariants = (variants, defaultLocale, routeMounts) => {
+export const createLocaleVariants = (variants, defaultLocale, locales = [], routeMounts) => {
   if (!variants) {
     return [];
   }
@@ -10,9 +11,11 @@ export const createLocaleVariants = (variants, defaultLocale, routeMounts) => {
     locale,
     path
   }));
-  return entries.filter((entry) => entry.path).map((entry) => ({
+  const localeOrder = sortLocalesCanonically(entries.map((entry) => entry.locale), { defaultLocale, locales });
+  const rank = new Map(localeOrder.map((locale, index) => [locale, index]));
+  return entries.filter((entry) => entry.path).sort((left, right) => (rank.get(left.locale) ?? Number.MAX_SAFE_INTEGER) - (rank.get(right.locale) ?? Number.MAX_SAFE_INTEGER)).map((entry) => ({
     locale: entry.locale,
-    canonicalPath: normalizeContentPath(entry.path || "/"),
+    unprefixedPath: normalizeContentPath(entry.path || "/"),
     path: projectContentPathToLocale(entry.path || "/", entry.locale, defaultLocale, routeMounts)
   }));
 };
@@ -40,17 +43,18 @@ export const decorateLocalePathsWithFallbacks = (localePaths, configuredLocales,
   return result;
 };
 export const localizePageResult = (page, locale, defaultLocale, locales = [], routeMounts) => {
-  const canonicalPath = normalizeContentPath(page._path || "/");
-  const variants = createLocaleVariants(page._variantPaths, defaultLocale, routeMounts);
-  const path = projectContentPathToLocale(canonicalPath, locale || page._resolvedLocale || page._locale, defaultLocale, routeMounts);
-  const resolvedLocale = page._resolvedLocale || page._locale || locale || defaultLocale || "";
-  const requestedLocale = page._requestedLocale || locale;
-  const fallback = Boolean(page._fallback || requestedLocale && resolvedLocale && requestedLocale !== resolvedLocale);
+  const resolution = page.resolved;
+  const unprefixedPath = normalizeContentPath(page.path || "/");
+  const variants = createLocaleVariants(resolution?.variantPaths, defaultLocale, locales, routeMounts);
+  const path = projectContentPathToLocale(unprefixedPath, locale || resolution?.locale || page.locale, defaultLocale, routeMounts);
+  const resolvedLocale = resolution?.locale || page.locale || locale || defaultLocale || "";
+  const requestedLocale = resolution?.requestedLocale || locale;
+  const fallback = Boolean(resolution?.fallback || requestedLocale && resolvedLocale && requestedLocale !== resolvedLocale);
   const result = {
     ...page,
     path,
-    canonicalPath,
-    locale: locale || page._resolvedLocale || page._locale || defaultLocale || "",
+    unprefixedPath,
+    locale: locale || resolution?.locale || page.locale || defaultLocale || "",
     defaultLocale: defaultLocale || "",
     variants,
     localePaths: createLocalePaths(variants),
@@ -60,13 +64,14 @@ export const localizePageResult = (page, locale, defaultLocale, locales = [], ro
       fallback,
       ...fallback ? { fallbackLocale: resolvedLocale } : {},
       path,
-      ...page._requestedPath ? { requestedPath: page._requestedPath } : {},
-      ...page._requestedRoute ? { requestedRoute: page._requestedRoute } : {},
-      ...page._requestedRef ? { requestedRef: page._requestedRef } : {},
-      availableLocales: page._availableLocales || Object.keys(page._variantPaths || {})
+      ...resolution?.requestedPath ? { requestedPath: resolution.requestedPath } : {},
+      ...resolution?.requestedRoute ? { requestedRoute: resolution.requestedRoute } : {},
+      ...resolution?.requestedRef ? { requestedRef: resolution.requestedRef } : {},
+      availableLocales: resolution?.availableLocales || sortLocalesCanonically(Object.keys(resolution?.variantPaths || {}), { defaultLocale, locales }),
+      ...resolution?.resolvedRefs ? { resolvedRefs: resolution.resolvedRefs } : {}
     },
-    stem: getContentStem(canonicalPath, page._file),
-    extension: page._extension
+    stem: getContentStem(unprefixedPath, page.file?.path),
+    extension: page.file?.extension
   };
   const links = result.links;
   if (Array.isArray(links)) {
@@ -83,22 +88,21 @@ export const localizePageResult = (page, locale, defaultLocale, locales = [], ro
   return result;
 };
 const localizeNavigationItem = (item, locale, defaultLocale, locales = [], routeMounts) => {
-  const rawPath = typeof item._path === "string" ? item._path : typeof item.path === "string" ? item.path : void 0;
+  const rawPath = typeof item.unprefixedPath === "string" ? item.unprefixedPath : typeof item.path === "string" ? item.path : void 0;
   if (!rawPath) {
     return {
       ...item,
       children: item.children?.map((child) => localizeNavigationItem(child, locale, defaultLocale, locales, routeMounts))
     };
   }
-  const canonicalPath = normalizeContentPath(rawPath);
-  const localizedPath = projectContentPathToLocale(canonicalPath, locale, defaultLocale, routeMounts);
-  const file = typeof item._file === "string" ? item._file : void 0;
+  const unprefixedPath = normalizeContentPath(rawPath);
+  const localizedPath = projectContentPathToLocale(unprefixedPath, locale, defaultLocale, routeMounts);
+  const file = item.file?.path;
   return {
     ...item,
-    _path: canonicalPath,
     path: localizedPath,
-    canonicalPath,
-    stem: item.stem || getContentStem(canonicalPath, file),
+    unprefixedPath,
+    stem: item.stem || getContentStem(unprefixedPath, file),
     children: item.children?.map((child) => localizeNavigationItem(child, locale, defaultLocale, locales, routeMounts))
   };
 };
@@ -107,31 +111,31 @@ export const localizeSurround = (items = [], locale, defaultLocale, _locales = [
   if (!item) {
     return item;
   }
-  const canonicalPath = normalizeContentPath(String(item._path || item.path || "/"));
+  const unprefixedPath = normalizeContentPath(String(item.unprefixedPath || item.path || "/"));
   return {
     ...item,
-    _path: canonicalPath,
-    path: projectContentPathToLocale(canonicalPath, locale, defaultLocale, routeMounts),
-    canonicalPath,
-    stem: item.stem || getContentStem(canonicalPath, typeof item._file === "string" ? item._file : void 0)
+    path: projectContentPathToLocale(unprefixedPath, locale, defaultLocale, routeMounts),
+    unprefixedPath,
+    stem: item.stem || getContentStem(unprefixedPath, item.file?.path)
   };
 });
 export const localizeSearchSections = (sections = [], locale, defaultLocale, locales = []) => sections.map((section) => ({
   ...section,
   id: localizePath(section.id, locale, defaultLocale, locales) || section.id
 }));
-export const createRouteMeta = (page, locale, defaultLocale, routeMounts) => {
-  const canonicalPath = normalizeContentPath(page._path || "/");
-  const resolvedLocale = page._resolvedLocale || page._locale || locale || defaultLocale || "";
-  const requestedLocale = page._requestedLocale || locale;
-  const fallback = Boolean(page._fallback || requestedLocale && resolvedLocale && requestedLocale !== resolvedLocale);
-  const variants = createLocaleVariants(page._variantPaths, defaultLocale, routeMounts);
-  const path = projectContentPathToLocale(canonicalPath, locale || resolvedLocale, defaultLocale, routeMounts);
+export const createRouteMeta = (page, locale, defaultLocale, locales = [], routeMounts) => {
+  const resolution = page.resolved;
+  const unprefixedPath = normalizeContentPath(page.path || "/");
+  const resolvedLocale = resolution?.locale || page.locale || locale || defaultLocale || "";
+  const requestedLocale = resolution?.requestedLocale || locale;
+  const fallback = Boolean(resolution?.fallback || requestedLocale && resolvedLocale && requestedLocale !== resolvedLocale);
+  const variants = resolution?.variantPaths ? createLocaleVariants(resolution.variantPaths, defaultLocale, locales, routeMounts) : Array.isArray(page.variants) ? page.variants : [];
+  const path = projectContentPathToLocale(unprefixedPath, locale || resolvedLocale, defaultLocale, routeMounts);
   return {
     locale: locale || resolvedLocale,
     defaultLocale: defaultLocale || "",
     path,
-    canonicalPath,
+    unprefixedPath,
     variants,
     localePaths: createLocalePaths(variants),
     resolved: {
@@ -140,10 +144,11 @@ export const createRouteMeta = (page, locale, defaultLocale, routeMounts) => {
       fallback,
       ...fallback ? { fallbackLocale: resolvedLocale } : {},
       path,
-      ...page._requestedPath ? { requestedPath: page._requestedPath } : {},
-      ...page._requestedRoute ? { requestedRoute: page._requestedRoute } : {},
-      ...page._requestedRef ? { requestedRef: page._requestedRef } : {},
-      availableLocales: page._availableLocales || Object.keys(page._variantPaths || {})
+      ...resolution?.requestedPath ? { requestedPath: resolution.requestedPath } : {},
+      ...resolution?.requestedRoute ? { requestedRoute: resolution.requestedRoute } : {},
+      ...resolution?.requestedRef ? { requestedRef: resolution.requestedRef } : {},
+      availableLocales: resolution?.availableLocales || sortLocalesCanonically(Object.keys(resolution?.variantPaths || {}), { defaultLocale, locales }),
+      ...resolution?.resolvedRefs ? { resolvedRefs: resolution.resolvedRefs } : {}
     }
   };
 };

package/dist/features/localization/translated-slugs.js

@@ -1,12 +1,12 @@
 const TRANSLATED_SLUG_SEGMENT_RE = /^(\d+)\.(.+)$/;
 const getTranslatedSlugEntries = (document, locales = []) => {
-  const file = (document._file || "").replace(/^\/+/, "");
+  const file = (document.file?.path || "").replace(/^\/+/, "");
   const parts = file.split("/").filter(Boolean);
   const localizedParts = parts[0] && locales.includes(parts[0]) ? parts.slice(1) : parts;
   if (!localizedParts.length) {
     return [];
   }
-  const locale = document._locale || "";
+  const locale = document.locale || "";
   const directories = localizedParts.slice(0, -1);
   const basename = localizedParts[localizedParts.length - 1] || "";
   const entries = [];
@@ -15,7 +15,7 @@ const getTranslatedSlugEntries = (document, locales = []) => {
     const match = directory.match(TRANSLATED_SLUG_SEGMENT_RE);
     entries.push({
       locale,
-      file: document._file || document._id,
+      file: document.file?.path || document.id,
       parentKey,
       raw: directory,
       number: match?.[1],
@@ -27,7 +27,7 @@ const getTranslatedSlugEntries = (document, locales = []) => {
     const match = basename.match(TRANSLATED_SLUG_SEGMENT_RE);
     entries.push({
       locale,
-      file: document._file || document._id,
+      file: document.file?.path || document.id,
       parentKey,
       raw: basename,
       number: match?.[1],
@@ -49,7 +49,7 @@ export const collectTranslatedSlugValidationIssues = (contents, options) => {
     if (hasMissingPrefix) {
       issues.push({
         level: "warn",
-        file: document._file || document._id,
+        file: document.file?.path || document.id,
         reason: "translated slug mode expects numeric prefixes for localized route segments"
       });
     }