@lupinum/ginko-content 0.1.2 → 0.1.3

package/dist/runtime/query/unified.js

@@ -1,560 +1,30 @@
-import { compileQueryParams } from "../../core/query/filter";
-import { decorateLocalePathsWithFallbacks, localizePageResult } from "../../features/localization/results";
-import { normalizeContentPath, normalizeRouteMounts } from "../../features/localization/path";
-import { normalizeReferenceValue } from "../../core/references/resolve";
-import { collectTopLevelReferenceFields, collectTopLevelReferenceFieldsByTarget } from "../../core/references/schema";
-import { MAX_PUBLIC_QUERY_LIMIT, MAX_PUBLIC_QUERY_SKIP } from "./public-limits.js";
-const NAVIGATION_INTERNAL_FIELDS = [
-  "_id",
-  "_path",
-  "_file",
-  "_canonicalKey",
-  "_locale",
-  "_draft",
-  "navigation",
-  "title"
-];
-const LOCALIZED_DOC_INTERNAL_FIELDS = [
-  "_id",
-  "_path",
-  "_file",
-  "_canonicalKey",
-  "_locale",
-  "_resolvedLocale",
-  "_requestedLocale",
-  "_fallback",
-  "_availableLocales",
-  "_variantPaths",
-  "_requestedPath",
-  "_requestedRoute",
-  "_requestedRef",
-  "_extension"
-];
-export const navigationSelectFields = (fields = []) => [
-  .../* @__PURE__ */ new Set([...NAVIGATION_INTERNAL_FIELDS, ...fields])
-];
-const isNotFoundError = (error) => {
-  const statusCode = error?.statusCode ?? error?.response?.status;
-  return statusCode === 404;
-};
-const isQueryEnvelope = (response) => Boolean(response && typeof response === "object" && "result" in response);
-const unwrapResponse = (response) => {
-  if (!response) return null;
-  if (isQueryEnvelope(response)) {
-    const result = response.result;
-    return result ?? null;
-  }
-  return response;
-};
-const unwrapFindResponse = (response) => {
-  if (!response) {
-    return { result: [], total: 0, skip: 0, limit: 0, hasTotal: false };
-  }
-  if (isQueryEnvelope(response)) {
-    const result2 = Array.isArray(response.result) ? response.result : response.result ? [response.result] : [];
-    const hasTotal = typeof response.total === "number";
-    return {
-      result: result2,
-      total: hasTotal ? response.total : result2.length,
-      skip: typeof response.skip === "number" ? response.skip : 0,
-      limit: typeof response.limit === "number" ? response.limit : result2.length,
-      hasTotal
-    };
-  }
-  const result = Array.isArray(response) ? response : [response];
-  return { result, total: result.length, skip: 0, limit: result.length, hasTotal: false };
-};
-const unwrapCountResponse = (response) => {
-  if (typeof response === "number") {
-    return response;
-  }
-  if (isQueryEnvelope(response) && typeof response.result === "number") {
-    return response.result;
-  }
-  return null;
-};
-const decorate = (doc, collection, runtime, requestedLocale) => {
-  if (!doc) return null;
-  const collectionI18n = runtime?.collections?.[collection]?.i18n;
-  const collectionLocales = collectionI18n && typeof collectionI18n === "object" ? collectionI18n.locales : void 0;
-  const collectionDefault = collectionI18n && typeof collectionI18n === "object" ? collectionI18n.defaultLocale : void 0;
-  const locales = collectionLocales?.length ? collectionLocales : runtime?.locales?.length ? runtime.locales : [];
-  const defaultLocale = collectionDefault || runtime?.defaultLocale;
-  const routeMounts = normalizeRouteMounts(runtime?.collections?.[collection]?.route, locales, defaultLocale);
-  const hasLocaleConfig = Boolean(locales.length || defaultLocale);
-  const page = hasLocaleConfig ? doc : {
-    ...doc,
-    _locale: "",
-    _resolvedLocale: void 0,
-    _requestedLocale: void 0,
-    _variantPaths: void 0,
-    _availableLocales: []
-  };
-  const result = localizePageResult(page, hasLocaleConfig ? requestedLocale : void 0, defaultLocale, locales, routeMounts);
-  const fallbackLocale = doc._resolvedLocale || requestedLocale || defaultLocale;
-  result.localePaths = decorateLocalePathsWithFallbacks(result.localePaths, locales, fallbackLocale, defaultLocale, routeMounts);
-  return result;
-};
-const collectionRouteRoots = (collection, runtime) => {
-  const collectionConfig = runtime?.collections?.[collection];
-  const collectionI18n = collectionConfig?.i18n;
-  const collectionLocales = collectionI18n && typeof collectionI18n === "object" ? collectionI18n.locales : void 0;
-  const collectionDefault = collectionI18n && typeof collectionI18n === "object" ? collectionI18n.defaultLocale : void 0;
-  const locales = collectionLocales?.length ? collectionLocales : runtime?.locales?.length ? runtime.locales : [];
-  const defaultLocale = collectionDefault || runtime?.defaultLocale;
-  const routeMounts = normalizeRouteMounts(collectionConfig?.route, locales, defaultLocale);
-  return new Set(Object.values(routeMounts || {}).map((value) => normalizeContentPath(value)));
-};
-const isCollectionRouteRoot = (path, collection, runtime) => collectionRouteRoots(collection, runtime).has(normalizeContentPath(path));
-const isAncestorRoutePath = (path, childPath) => {
-  const normalized = normalizeContentPath(path);
-  const child = normalizeContentPath(childPath);
-  return normalized === "/" ? child !== "/" : child.startsWith(`${normalized}/`);
-};
-const isNavigationRootPath = (path, flat) => Boolean(flat[0]?.path && isAncestorRoutePath(path, flat[0].path));
-const collectionDefaultLocale = (collection, runtime) => {
-  const collectionI18n = runtime?.collections?.[collection]?.i18n;
-  const collectionDefault = collectionI18n && typeof collectionI18n === "object" ? collectionI18n.defaultLocale : void 0;
-  return collectionDefault || runtime?.defaultLocale;
-};
-const resolveFallback = (fallback, collection, runtime) => {
-  if (fallback !== "default") return fallback;
-  return collectionDefaultLocale(collection, runtime);
-};
-const explainResolution = (collection, requestedBy, normalizedBy, requestedLocale, requestedFallback, doc) => {
-  const resolvedLocale = doc?.resolved?.locale || doc?.locale;
-  return {
-    requested: {
-      collection,
-      by: requestedBy,
-      ...requestedLocale ? { locale: requestedLocale } : {},
-      ...requestedFallback !== void 0 ? { fallback: requestedFallback } : {}
-    },
-    normalized: {
-      by: normalizedBy
-    },
-    matched: {
-      found: Boolean(doc),
-      collection,
-      ...doc?.path ? { path: doc.path } : {},
-      ...doc?.canonicalPath ? { canonicalPath: doc.canonicalPath } : {},
-      ...doc?.ref ? { ref: doc.ref } : {},
-      ...resolvedLocale ? { locale: resolvedLocale } : {}
-    },
-    fallback: {
-      used: Boolean(requestedLocale && resolvedLocale && requestedLocale !== resolvedLocale),
-      ...requestedLocale && resolvedLocale && requestedLocale !== resolvedLocale ? { locale: resolvedLocale } : {}
-    }
-  };
-};
-const ensureCollectionName = (handle) => {
-  if (typeof handle === "string") return handle;
-  if (!handle || typeof handle !== "object" || typeof handle.name !== "string") {
-    throw new TypeError("query API: expected a string collection name or a collection handle from defineContentConfig({ collections }). Use useContentPage('docs') or config.collections.docs.");
-  }
-  return handle.name;
-};
-const isRecord = (value) => {
-  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-};
-const populateReferenceValue = async (context, target, value, locale, fallback) => {
-  if (typeof value !== "string" || !value) {
-    return null;
-  }
-  return one(context, target, {
-    by: { ref: value },
-    ...locale ? { locale } : {},
-    ...fallback !== void 0 ? { fallback } : {}
-  });
-};
-const wildcardReferenceTarget = "*";
-const collectReferenceFieldsByTarget = (source, sourceCollection, runtime) => {
-  if (typeof source !== "string") {
-    return collectTopLevelReferenceFieldsByTarget(source.schema);
-  }
-  return runtime?.collections?.[sourceCollection]?.references || {};
-};
-const invertReferenceFields = (references) => {
-  const fields = /* @__PURE__ */ new Map();
-  for (const [target, targetFields] of Object.entries(references)) {
-    for (const field of targetFields) {
-      const targets = fields.get(field) || [];
-      targets.push(target);
-      fields.set(field, targets);
-    }
-  }
-  return fields;
-};
-const createPopulateTargetMismatchError = (sourceCollection, field, expectedTargets, actualTarget) => new Error([
-  `Cannot populate "${sourceCollection}.${field}" from "${actualTarget}".`,
-  `Reference metadata declares "${sourceCollection}.${field}" points to ${expectedTargets.map((target) => `"${target}"`).join(" or ")}.`,
-  `Change populate.${field} to the declared target collection, or update ${sourceCollection}.schema relation metadata.`
-].join(" "));
-const validatePopulateSpec = (source, sourceCollection, runtime, populate) => {
-  if (!populate || !isRecord(populate)) {
-    return;
-  }
-  const references = collectReferenceFieldsByTarget(source, sourceCollection, runtime);
-  const fieldTargets = invertReferenceFields(references);
-  if (!fieldTargets.size) {
-    return;
-  }
-  for (const [field, target] of Object.entries(populate)) {
-    const declaredTargets = fieldTargets.get(field);
-    if (!declaredTargets?.length) {
-      continue;
-    }
-    const actualTarget = ensureCollectionName(target);
-    if (declaredTargets.includes(actualTarget) || declaredTargets.includes(wildcardReferenceTarget)) {
-      continue;
-    }
-    throw createPopulateTargetMismatchError(
-      sourceCollection,
-      field,
-      declaredTargets.filter((target2) => target2 !== wildcardReferenceTarget),
-      actualTarget
-    );
-  }
-};
-const populateDocument = async (context, doc, populate, locale, fallback) => {
-  if (!populate || !isRecord(populate)) {
-    return doc;
-  }
-  const populated = { ...doc };
-  await Promise.all(Object.entries(populate).map(async ([field, target]) => {
-    const value = doc[field];
-    if (Array.isArray(value)) {
-      const resolved = await Promise.all(value.map((item) => populateReferenceValue(context, target, item, locale, fallback)));
-      populated[field] = resolved.filter(Boolean);
-      return;
-    }
-    populated[field] = await populateReferenceValue(context, target, value, locale, fallback);
-  }));
-  return populated;
-};
-const selectWithPopulate = (select, populate) => {
-  if (!select) {
-    return void 0;
-  }
-  return [.../* @__PURE__ */ new Set([
-    ...select,
-    ...LOCALIZED_DOC_INTERNAL_FIELDS,
-    ...populate && isRecord(populate) ? Object.keys(populate) : []
-  ])];
-};
+import { resolveBacklinks } from "./backlinks.js";
+import { resolveNeighbors, resolveTree } from "./navigation.js";
+import { resolvePagination } from "./pagination.js";
+import { resolveVariants } from "./variants.js";
+import { resolveDocument, resolveDocumentOnly, resolveManyDocuments } from "./documents.js";
+export { navigationSelectFields } from "./navigation.js";
 export async function resolveOne(context, handle, options) {
-  const collection = ensureCollectionName(handle);
-  const runtime = context.runtime;
-  validatePopulateSpec(handle, collection, runtime, options.populate);
-  const by = options.by;
-  const fallback = resolveFallback(options.fallback, collection, runtime);
-  const params = compileQueryParams({
-    collection,
-    by,
-    locale: options.locale,
-    fallback,
-    select: selectWithPopulate(options.select, options.populate)
-  });
-  params.first = true;
-  let response;
-  try {
-    response = await context.transport("query", params);
-  } catch (error) {
-    if (isNotFoundError(error)) {
-      const explain2 = explainResolution(collection, options.by, by, options.locale, options.fallback, null);
-      return { doc: null, explain: explain2 };
-    }
-    throw error;
-  }
-  const unwrapped = unwrapResponse(response);
-  const doc = Array.isArray(unwrapped) ? unwrapped[0] ?? null : unwrapped ?? null;
-  const decorated = decorate(doc, collection, runtime, options.locale);
-  const populated = decorated ? await populateDocument(context, decorated, options.populate, options.locale, options.fallback) : null;
-  const explain = explainResolution(collection, options.by, by, options.locale, options.fallback, decorated);
-  return {
-    doc: populated,
-    explain
-  };
+  return resolveDocument(context, one, handle, options);
 }
 export async function one(context, handle, options) {
-  const result = await resolveOne(context, handle, options);
-  return result.doc;
+  return resolveDocumentOnly(context, handle, options);
 }
 export async function many(context, handle, options = {}) {
-  const collection = ensureCollectionName(handle);
-  const runtime = context.runtime;
-  validatePopulateSpec(handle, collection, runtime, options.populate);
-  const fallback = resolveFallback(options.fallback, collection, runtime);
-  const params = compileQueryParams({
-    collection,
-    where: options.where,
-    sort: options.sort,
-    limit: options.limit,
-    skip: options.skip,
-    locale: options.locale,
-    fallback,
-    select: selectWithPopulate(options.select, options.populate)
-  });
-  let response;
-  try {
-    response = await context.transport("query", params);
-  } catch (error) {
-    if (isNotFoundError(error)) return [];
-    throw error;
-  }
-  const unwrapped = unwrapResponse(response);
-  const list = Array.isArray(unwrapped) ? unwrapped : unwrapped ? [unwrapped] : [];
-  const decorated = list.map((doc) => decorate(doc, collection, runtime, options.locale)).filter((doc) => Boolean(doc));
-  const populated = await Promise.all(decorated.map((doc) => populateDocument(context, doc, options.populate, options.locale, options.fallback)));
-  return populated;
+  return resolveManyDocuments(context, one, handle, options);
 }
-const normalizePositiveInteger = (value, fallback) => {
-  const number = typeof value === "number" && Number.isFinite(value) ? Math.floor(value) : fallback;
-  return Math.max(1, number);
-};
 export async function paginate(context, handle, options) {
-  const collection = ensureCollectionName(handle);
-  const runtime = context.runtime;
-  validatePopulateSpec(handle, collection, runtime, options.populate);
-  const requestedPage = normalizePositiveInteger(options.page, 1);
-  const limit = Math.min(normalizePositiveInteger(options.limit, 10), MAX_PUBLIC_QUERY_LIMIT);
-  const skip = Math.min((requestedPage - 1) * limit, MAX_PUBLIC_QUERY_SKIP);
-  const page = Math.floor(skip / limit) + 1;
-  const fallback = resolveFallback(options.fallback, collection, runtime);
-  const params = compileQueryParams({
-    collection,
-    where: options.where,
-    sort: options.sort,
-    limit,
-    skip,
-    locale: options.locale,
-    fallback,
-    select: selectWithPopulate(options.select, options.populate)
-  });
-  const countParams = compileQueryParams({
-    collection,
-    where: options.where,
-    locale: options.locale,
-    fallback
-  });
-  countParams.count = true;
-  let response;
-  try {
-    response = await context.transport("query", params);
-  } catch (error) {
-    if (isNotFoundError(error)) {
-      return {
-        data: [],
-        page,
-        limit,
-        total: 0,
-        pageCount: 0,
-        hasNext: false,
-        hasPrev: page > 1,
-        nextPage: null,
-        prevPage: page > 1 ? page - 1 : null
-      };
-    }
-    throw error;
-  }
-  const envelope = unwrapFindResponse(response);
-  let total = envelope.total;
-  if (!envelope.hasTotal) {
-    const countResponse = await context.transport("query", countParams);
-    total = unwrapCountResponse(countResponse) ?? envelope.total;
-  }
-  const decorated = envelope.result.map((doc) => decorate(doc, collection, runtime, options.locale)).filter((doc) => Boolean(doc));
-  const populated = await Promise.all(decorated.map((doc) => populateDocument(context, doc, options.populate, options.locale, options.fallback)));
-  const pageCount = total > 0 ? Math.ceil(total / limit) : 0;
-  return {
-    data: populated,
-    page,
-    limit,
-    total,
-    pageCount,
-    hasNext: page < pageCount,
-    hasPrev: page > 1,
-    nextPage: page < pageCount ? page + 1 : null,
-    prevPage: page > 1 ? page - 1 : null
-  };
+  return resolvePagination(context, one, handle, options);
 }
-const backlinkSources = (value) => Array.isArray(value) ? [...value] : [value];
-const isBacklinkFieldMap = (value) => {
-  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-};
-const resolveExplicitBacklinkFields = (fields, sourceName) => {
-  if (Array.isArray(fields)) {
-    return fields.filter((field) => typeof field === "string" && field.length > 0);
-  }
-  if (!isBacklinkFieldMap(fields)) {
-    return [];
-  }
-  const sourceFields = fields?.[sourceName];
-  return Array.isArray(sourceFields) ? sourceFields.filter((field) => typeof field === "string" && field.length > 0) : [];
-};
-const inferBacklinkFields = (source, targetCollection, runtime) => {
-  if (typeof source === "string") {
-    const references = runtime?.collections?.[source]?.references;
-    return [
-      ...references?.[targetCollection] || [],
-      ...references?.["*"] || []
-    ];
-  }
-  return collectTopLevelReferenceFields(source.schema, targetCollection);
-};
-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
-  ].filter((value) => typeof value === "string" && value.length > 0).flatMap((value) => [value, normalizeReferenceValue(value)]).filter(Boolean);
-  return Array.from(new Set(values));
-};
-const backlinkWhere = (fields, candidates) => {
-  const clauses = fields.map((field) => ({
-    [field]: { $in: candidates }
-  }));
-  return clauses.length ? { $or: clauses } : void 0;
-};
-const createMissingBacklinkFieldsError = (sourceCollection, targetCollection) => new Error(
-  `Cannot infer backlink fields from "${sourceCollection}" to "${targetCollection}". Declare fields.relation('${targetCollection}') / fields.relations('${targetCollection}') in ${sourceCollection}.schema, or pass fields explicitly.`
-);
 export async function backlinks(context, targetHandle, options) {
-  const targetCollection = ensureCollectionName(targetHandle);
-  const target = await one(context, targetHandle, {
-    by: options.by,
-    ...options.locale ? { locale: options.locale } : {},
-    ...options.fallback !== void 0 ? { fallback: options.fallback } : {}
-  });
-  if (!target) {
-    return [];
-  }
-  const candidates = targetReferenceCandidates(target);
-  if (!candidates.length) {
-    return [];
-  }
-  const sources = backlinkSources(options.from);
-  const results = await Promise.all(sources.map(async (source) => {
-    const sourceName = ensureCollectionName(source);
-    const fields = [
-      .../* @__PURE__ */ new Set([
-        ...resolveExplicitBacklinkFields(options.fields, sourceName),
-        ...inferBacklinkFields(source, targetCollection, context.runtime)
-      ])
-    ];
-    if (!fields.length) {
-      throw createMissingBacklinkFieldsError(sourceName, targetCollection);
-    }
-    const where = backlinkWhere(fields, candidates);
-    if (!where) {
-      return [];
-    }
-    return await many(context, source, {
-      where,
-      sort: options.sort,
-      limit: options.limit,
-      skip: options.skip,
-      ...options.locale ? { locale: options.locale } : {},
-      ...options.fallback !== void 0 ? { fallback: options.fallback } : {},
-      select: options.select,
-      populate: options.populate
-    });
-  }));
-  return results.flat();
+  return resolveBacklinks(context, one, many, targetHandle, options);
 }
 export async function variants(context, handle, options) {
-  const collection = ensureCollectionName(handle);
-  const runtime = context.runtime;
-  const collectionI18n = runtime?.collections?.[collection]?.i18n;
-  const collectionLocales = collectionI18n && typeof collectionI18n === "object" ? collectionI18n.locales : void 0;
-  const collectionDefault = collectionI18n && typeof collectionI18n === "object" ? collectionI18n.defaultLocale : void 0;
-  const locales = collectionLocales?.length ? collectionLocales : runtime?.locales || [];
-  const defaultLocale = collectionDefault || runtime?.defaultLocale;
-  const requestedLocales = options.locales?.length ? options.locales : locales;
-  if (!requestedLocales.length) {
-    return [];
-  }
-  const seed = await one(context, handle, {
-    by: options.by,
-    locale: options.locale || defaultLocale,
-    fallback: true
-  });
-  if (!seed) return [];
-  const variantPaths = seed._variantPaths || {};
-  const sourceLocale = seed.locale || defaultLocale || "";
-  return requestedLocales.map((locale) => {
-    const variantPath = variantPaths[locale];
-    if (variantPath) {
-      return {
-        locale,
-        path: seed.localePaths?.[locale]?.path || variantPath,
-        translated: true
-      };
-    }
-    return {
-      locale,
-      path: seed.path,
-      translated: false,
-      fallback: sourceLocale
-    };
-  });
+  return resolveVariants(context, one, handle, options);
 }
 export async function tree(context, handle, options = {}) {
-  const collection = ensureCollectionName(handle);
-  const runtime = context.runtime;
-  const fallback = resolveFallback(options.fallback, collection, runtime);
-  const params = compileQueryParams({
-    collection,
-    where: options.where,
-    sort: options.sort,
-    locale: options.locale,
-    fallback,
-    select: navigationSelectFields(options.fields),
-    exact: options.fallback === void 0 ? false : void 0
-  });
-  const response = await context.transport("navigation", params);
-  const list = Array.isArray(response) ? response : Array.isArray(response?.result) ? response.result : [];
-  return list;
+  return resolveTree(context, handle, options);
 }
 export async function neighbors(context, handle, options) {
-  const collection = ensureCollectionName(handle);
-  const runtime = context.runtime;
-  const seed = await one(context, handle, {
-    by: options.by,
-    locale: options.locale,
-    fallback: options.fallback ?? true
-  });
-  if (!seed) return { prev: null, next: null };
-  const fullTree = await tree(context, handle, {
-    locale: options.locale,
-    fallback: options.fallback,
-    fields: options.fields
-  });
-  const flat = [];
-  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 (Array.isArray(n.children)) walk(n.children);
-    }
-  };
-  walk(fullTree);
-  const targetPath = seed.path;
-  const idx = flat.findIndex((entry) => entry.path === targetPath);
-  if (idx === -1 && (isCollectionRouteRoot(targetPath, collection, runtime) || isNavigationRootPath(targetPath, flat))) {
-    return {
-      prev: null,
-      next: flat[0]?.item ?? null
-    };
-  }
-  if (idx === -1) return { prev: null, next: null };
-  return {
-    prev: flat[idx - 1]?.item ?? null,
-    next: flat[idx + 1]?.item ?? null
-  };
+  return resolveNeighbors(context, one, tree, handle, options);
 }

package/dist/runtime/query/variants

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

package/dist/runtime/query/variants.d.ts

@@ -0,0 +1,11 @@
+import type { ParsedContent } from '../../types/content';
+import type { ContentCollectionHandle } from '../../types/config';
+import type { ContentVariant, LocalizedContentDocument, OneOptions, VariantsOptions } from '../../types/query';
+import type { ContentQueryContext } from './context';
+type OneResolver = <H extends ContentCollectionHandle | string>(context: ContentQueryContext, handle: H, options: OneOptions<H>) => Promise<LocalizedContentDocument<ParsedContent> | null>;
+export declare function resolveVariants<H extends ContentCollectionHandle | string>(context: ContentQueryContext, one: OneResolver, handle: H, options: VariantsOptions<H>): Promise<Array<ContentVariant<H extends {
+    __schema: {
+        _output: infer O;
+    };
+} ? O & ParsedContent : ParsedContent>>>;
+export {};

package/dist/runtime/query/variants.js

@@ -0,0 +1,36 @@
+import { ensureCollectionName } from "./handles.js";
+import { collectionDefaultLocale, collectionLocales } from "./locale-options.js";
+export async function resolveVariants(context, one, handle, options) {
+  const collection = ensureCollectionName(handle);
+  const runtime = context.runtime;
+  const locales = collectionLocales(collection, runtime);
+  const defaultLocale = collectionDefaultLocale(collection, runtime);
+  const requestedLocales = options.locales?.length ? options.locales : locales;
+  if (!requestedLocales.length) {
+    return [];
+  }
+  const seed = await one(context, handle, {
+    by: options.by,
+    locale: options.locale || defaultLocale,
+    fallback: true
+  });
+  if (!seed) return [];
+  const variantPaths = seed._variantPaths || {};
+  const sourceLocale = seed.locale || defaultLocale || "";
+  return requestedLocales.map((locale) => {
+    const variantPath = variantPaths[locale];
+    if (variantPath) {
+      return {
+        locale,
+        path: seed.localePaths[locale]?.path || variantPath,
+        translated: true
+      };
+    }
+    return {
+      locale,
+      path: seed.path,
+      translated: false,
+      fallback: sourceLocale
+    };
+  });
+}

package/dist/runtime/server/agent-http

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

package/dist/runtime/server/agent-http.d.ts

@@ -0,0 +1,7 @@
+import type { H3Event } from 'h3';
+export declare const appendResponseHeader: (event: H3Event, name: string, value: string) => void;
+export declare const addVaryHeader: (event: H3Event, value: string) => void;
+export declare const acceptsMarkdown: (event: H3Event) => boolean;
+export declare const setAgentMarkdownHeaders: (event: H3Event, options?: {
+    noindex?: boolean;
+}) => void;

package/dist/runtime/server/agent-http.js

@@ -0,0 +1,36 @@
+import { getHeader, setHeader } from "h3";
+export const appendResponseHeader = (event, name, value) => {
+  const current = event.node.res.getHeader(name);
+  const existing = Array.isArray(current) ? current.filter(Boolean).join(", ") : typeof current === "number" ? String(current) : typeof current === "string" ? current : "";
+  setHeader(event, name, existing ? `${existing}, ${value}` : value);
+};
+export const addVaryHeader = (event, value) => {
+  const current = event.node.res.getHeader("vary");
+  const entries = new Set(
+    (typeof current === "string" ? current : Array.isArray(current) ? current.join(",") : "").split(",").map((entry) => entry.trim().toLowerCase()).filter(Boolean)
+  );
+  entries.add(value.toLowerCase());
+  setHeader(event, "vary", Array.from(entries).join(", "));
+};
+const parseAcceptPart = (part) => {
+  const [type = "", ...params] = part.split(";").map((value) => value.trim());
+  const qParam = params.find((param) => param.toLowerCase().startsWith("q="));
+  const q = qParam ? Number(qParam.slice(2)) : 1;
+  return {
+    type: type.toLowerCase(),
+    q: Number.isFinite(q) ? q : 0
+  };
+};
+export const acceptsMarkdown = (event) => {
+  const accept = getHeader(event, "accept");
+  if (!accept) return false;
+  const entries = accept.split(",").map(parseAcceptPart).filter((entry) => entry.q > 0);
+  const markdownQ = entries.filter((entry) => entry.type === "text/markdown").reduce((max, entry) => Math.max(max, entry.q), 0);
+  if (!markdownQ) return false;
+  const htmlQ = entries.filter((entry) => entry.type === "text/html" || entry.type === "application/xhtml+xml").reduce((max, entry) => Math.max(max, entry.q), 0);
+  return markdownQ >= htmlQ;
+};
+export const setAgentMarkdownHeaders = (event, options = {}) => {
+  setHeader(event, "content-type", "text/markdown; charset=utf-8");
+  if (options.noindex) setHeader(event, "x-robots-tag", "noindex");
+};

package/dist/runtime/server/agent-markdown

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