@lupinum/ginko-content 0.1.0

package/dist/runtime/server/api/revalidate.js

@@ -0,0 +1,156 @@
+import { createError, defineEventHandler, getHeader, readRawBody } from "h3";
+import { getContentCacheAdapter } from "../cache-adapter.js";
+import { getContentProvider } from "../providers/index.js";
+import { getContentRuntimeConfig } from "../runtime-config.js";
+import { clearSearchRecordsCache } from "../search.js";
+const normalizePath = (path) => {
+  const normalized = path.startsWith("/") ? path : `/${path}`;
+  return normalized.replace(/\/{2,}/g, "/");
+};
+const normalizeStringList = (value, normalize = (value2) => value2) => Array.isArray(value) ? Array.from(new Set(value.filter((entry) => typeof entry === "string" && entry.trim()).map((entry) => normalize(entry.trim())))) : void 0;
+const SIGNATURE_TOLERANCE_MS = 5 * 60 * 1e3;
+async function hmacSha256Hex(secret, value) {
+  const encoder = new TextEncoder();
+  const key = await globalThis.crypto.subtle.importKey(
+    "raw",
+    encoder.encode(secret),
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  const signature = await globalThis.crypto.subtle.sign("HMAC", key, encoder.encode(value));
+  return Array.from(new Uint8Array(signature)).map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function constantTimeEqual(left, right) {
+  const leftBytes = new TextEncoder().encode(left);
+  const rightBytes = new TextEncoder().encode(right);
+  let difference = leftBytes.length ^ rightBytes.length;
+  const length = Math.max(leftBytes.length, rightBytes.length);
+  for (let index = 0; index < length; index++) {
+    difference |= (leftBytes[index] ?? 0) ^ (rightBytes[index] ?? 0);
+  }
+  return difference === 0;
+}
+async function verifySignature(event, token, rawBody) {
+  const timestampHeader = getHeader(event, "x-ginko-signature-timestamp");
+  const signatureHeader = getHeader(event, "x-ginko-signature");
+  const eventId = getHeader(event, "x-ginko-revalidation-event");
+  if (!timestampHeader || !signatureHeader || !eventId) {
+    throw createError({
+      statusCode: 401,
+      statusMessage: "missing_revalidation_signature",
+      message: "Signed content revalidation requires signature, timestamp, and event headers."
+    });
+  }
+  const timestamp = Number(timestampHeader);
+  if (!Number.isFinite(timestamp) || Math.abs(Date.now() - timestamp) > SIGNATURE_TOLERANCE_MS) {
+    throw createError({
+      statusCode: 401,
+      statusMessage: "stale_revalidation_signature",
+      message: "Content revalidation signature timestamp is outside the accepted window."
+    });
+  }
+  const expected = `sha256=${await hmacSha256Hex(token, `${timestampHeader}.${eventId}.${rawBody}`)}`;
+  if (!constantTimeEqual(signatureHeader, expected)) {
+    throw createError({
+      statusCode: 401,
+      statusMessage: "invalid_revalidation_signature",
+      message: "Invalid content revalidation signature."
+    });
+  }
+}
+function hasSignatureHeaders(event) {
+  return Boolean(
+    getHeader(event, "x-ginko-signature-timestamp") || getHeader(event, "x-ginko-signature") || getHeader(event, "x-ginko-revalidation-event")
+  );
+}
+function verifyUnsignedToken(event, token) {
+  const headerToken = getHeader(event, "x-ginko-revalidate-token");
+  const bearerToken = getHeader(event, "authorization")?.replace(/^Bearer\s+/i, "");
+  if (headerToken !== token && bearerToken !== token) {
+    throw createError({
+      statusCode: 401,
+      statusMessage: "invalid_revalidation_token",
+      message: "Invalid content revalidation token."
+    });
+  }
+}
+function parseJsonBody(bodyText) {
+  try {
+    return JSON.parse(bodyText);
+  } catch {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "invalid_revalidation_body",
+      message: "Content revalidation body must be valid JSON."
+    });
+  }
+}
+export default defineEventHandler(async (event) => {
+  const revalidateConfig = getContentRuntimeConfig().content?.revalidate;
+  const token = revalidateConfig && revalidateConfig !== false ? revalidateConfig.token : void 0;
+  const allowUnsigned = revalidateConfig && revalidateConfig !== false ? revalidateConfig.allowUnsigned === true : false;
+  if (!token) {
+    throw createError({
+      statusCode: 404,
+      statusMessage: "revalidation_disabled",
+      message: "Content revalidation is disabled."
+    });
+  }
+  const rawBody = await readRawBody(event).catch(() => void 0);
+  const bodyText = typeof rawBody === "string" ? rawBody : rawBody?.toString();
+  if (!bodyText) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "missing_revalidation_body",
+      message: "Content revalidation requires a JSON body."
+    });
+  }
+  if (hasSignatureHeaders(event)) {
+    await verifySignature(event, token, bodyText);
+  } else if (allowUnsigned) {
+    verifyUnsignedToken(event, token);
+  } else {
+    throw createError({
+      statusCode: 401,
+      statusMessage: "missing_revalidation_signature",
+      message: "Signed content revalidation requires signature, timestamp, and event headers."
+    });
+  }
+  const body = parseJsonBody(bodyText);
+  const input = {
+    tags: normalizeStringList(body?.tags),
+    paths: normalizeStringList(body?.paths, normalizePath)
+  };
+  if (!input.tags?.length && !input.paths?.length) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "missing_revalidation_target",
+      message: "Provide at least one cache tag or path to revalidate."
+    });
+  }
+  const provider = await getContentProvider(event);
+  const adapter = await getContentCacheAdapter();
+  let handled = false;
+  if (typeof provider.invalidate === "function") {
+    await provider.invalidate(event, input);
+    handled = true;
+  }
+  if (adapter) {
+    await adapter.invalidate(input);
+    handled = true;
+  }
+  if (!handled) {
+    throw createError({
+      statusCode: 501,
+      statusMessage: "revalidation_not_supported",
+      message: "The active content provider/cache adapter does not support revalidation."
+    });
+  }
+  clearSearchRecordsCache();
+  return {
+    ok: true,
+    tags: input.tags || [],
+    paths: input.paths || []
+  };
+});

package/dist/runtime/server/api/search

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

package/dist/runtime/server/api/search-index

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

package/dist/runtime/server/api/search-index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<import("../../../types").ContentSearchIndexRecord[]>>;
+export default _default;

package/dist/runtime/server/api/search-index.js

@@ -0,0 +1,20 @@
+import { defineEventHandler, getQuery } from "h3";
+import { useRuntimeConfig } from "nitropack/runtime";
+import { buildSearchIndex } from "../search.js";
+export default defineEventHandler(async (event) => {
+  const runtimeConfig = useRuntimeConfig(event);
+  const searchConfig = runtimeConfig.content.search;
+  if (searchConfig === false) {
+    return [];
+  }
+  const query = getQuery(event);
+  const locale = typeof query.locale === "string" ? query.locale : void 0;
+  return await buildSearchIndex(event, {
+    collections: searchConfig.collections,
+    ignoredTags: searchConfig.ignoredTags || [],
+    extraFields: searchConfig.extraFields || [],
+    filterQuery: searchConfig.filterQuery,
+    locale,
+    allLocales: !locale
+  });
+});

package/dist/runtime/server/api/search.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<import("..").MaybeContentProviderResult<import("../../../types").ContentSearchResult[]>>>;
+export default _default;

package/dist/runtime/server/api/search.js

@@ -0,0 +1,40 @@
+import { defineEventHandler, getQuery, getRequestURL } from "h3";
+import { useRuntimeConfig } from "nitropack/runtime";
+import { buildSearchIndex, searchRecords } from "../search.js";
+import { getContentProvider } from "../providers/index.js";
+import { createContentProviderError } from "../../../public/provider-errors";
+export default defineEventHandler(async (event) => {
+  const runtimeConfig = useRuntimeConfig(event);
+  const searchConfig = runtimeConfig.content.search;
+  if (searchConfig === false) {
+    return [];
+  }
+  const query = getQuery(event);
+  const rawUrl = event.node.req.originalUrl || event.node.req.url;
+  const requestUrl = rawUrl ? new URL(rawUrl, "http://content.local") : getRequestURL(event);
+  const rawTerm = typeof query.q === "string" ? query.q : requestUrl.searchParams.get("q");
+  const term = typeof rawTerm === "string" ? rawTerm.slice(0, 200) : "";
+  const locale = typeof query.locale === "string" ? query.locale : void 0;
+  if (searchConfig.engine === "cms") {
+    const provider = await getContentProvider(event);
+    if (typeof provider.search !== "function") {
+      throw createContentProviderError("unsupported_provider_search", `${provider.name} does not support provider-backed search`, {
+        provider: provider.name
+      });
+    }
+    return await provider.search(event, {
+      term,
+      locale,
+      collections: searchConfig.collections
+    });
+  }
+  const records = await buildSearchIndex(event, {
+    collections: searchConfig.collections,
+    ignoredTags: searchConfig.ignoredTags || [],
+    extraFields: searchConfig.extraFields || [],
+    filterQuery: searchConfig.filterQuery,
+    locale,
+    allLocales: !locale
+  });
+  return searchRecords(records, term, locale, searchConfig.minisearch);
+});

package/dist/runtime/server/api/site-data

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

package/dist/runtime/server/api/site-data.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<import("..").MaybeContentProviderResult<import("../../../public/provider").ContentProviderSiteDataResponse<unknown>>>>;
+export default _default;

package/dist/runtime/server/api/site-data.js

@@ -0,0 +1,22 @@
+import { createError, defineEventHandler, getQuery } from "h3";
+import { getContentProvider } from "../providers/index.js";
+import { createContentProviderError } from "../../../public/provider-errors";
+export default defineEventHandler(async (event) => {
+  const query = getQuery(event);
+  const key = typeof query.key === "string" ? query.key.trim() : "";
+  const locale = typeof query.locale === "string" ? query.locale : void 0;
+  if (!key) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "missing_site_data_key",
+      message: "A site-data key is required."
+    });
+  }
+  const provider = await getContentProvider(event);
+  if (typeof provider.siteData !== "function") {
+    throw createContentProviderError("unsupported_provider_site_data", `${provider.name} does not support site data.`, {
+      provider: provider.name
+    });
+  }
+  return await provider.siteData(event, { key, locale });
+});

package/dist/runtime/server/api/sitemap

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

package/dist/runtime/server/api/sitemap.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<import("../../../types").ContentSitemapEntry[]>>;
+export default _default;

package/dist/runtime/server/api/sitemap.js

@@ -0,0 +1,11 @@
+import { defineEventHandler, getQuery } from "h3";
+import { useRuntimeConfig } from "nitropack/runtime";
+import { queryCollectionsSitemapEntries } from "../sitemap-provider.js";
+export default defineEventHandler(async (event) => {
+  const query = getQuery(event);
+  const runtimeSitemap = useRuntimeConfig(event).public.content?.sitemap;
+  const include = typeof query.include === "string" ? query.include.split(",").map((item) => item.trim()).filter(Boolean) : runtimeSitemap?.include;
+  const exclude = typeof query.exclude === "string" ? query.exclude.split(",").map((item) => item.trim()).filter(Boolean) : runtimeSitemap?.exclude;
+  const includeDrafts = typeof query.includeDrafts === "string" ? query.includeDrafts === "true" : runtimeSitemap?.includeDrafts;
+  return await queryCollectionsSitemapEntries(event, { include, exclude, includeDrafts });
+});

package/dist/runtime/server/cache-adapter

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

package/dist/runtime/server/cache-adapter.d.ts

@@ -0,0 +1,2 @@
+import type { ContentCacheAdapter } from '../../public/provider';
+export declare const getContentCacheAdapter: () => Promise<ContentCacheAdapter | undefined>;

package/dist/runtime/server/cache-adapter.js

@@ -0,0 +1,11 @@
+import { loadContentCacheAdapter } from "#content/virtual/cache-adapter";
+export const getContentCacheAdapter = async () => {
+  const adapter = await loadContentCacheAdapter();
+  if (!adapter) {
+    return void 0;
+  }
+  if (typeof adapter.name !== "string" || typeof adapter.apply !== "function" || typeof adapter.invalidate !== "function") {
+    throw new TypeError("Invalid content cache adapter. Expected { name, apply, invalidate }.");
+  }
+  return adapter;
+};

package/dist/runtime/server/cache-adapters

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

package/dist/runtime/server/cache-adapters.d.ts

@@ -0,0 +1,9 @@
+import type { ContentCacheAdapter, ContentCacheHint } from '../../public/provider';
+export declare const noopContentCache: () => ContentCacheAdapter;
+export interface VercelContentCacheOptions {
+    origin: string;
+    bypassToken: string;
+    fetch?: typeof globalThis.fetch;
+}
+export declare const vercelContentCache: (options: VercelContentCacheOptions) => ContentCacheAdapter;
+export declare const contentCacheHeaders: (hint: ContentCacheHint) => Headers;

package/dist/runtime/server/cache-adapters.js

@@ -0,0 +1,50 @@
+export const noopContentCache = () => ({
+  name: "noop",
+  apply: () => {
+  },
+  invalidate: async () => {
+  }
+});
+export const vercelContentCache = (options) => {
+  const origin = options.origin.replace(/\/$/, "");
+  const fetchImpl = options.fetch || globalThis.fetch;
+  return {
+    name: "vercel",
+    apply: () => {
+    },
+    invalidate: async (input) => {
+      const paths = Array.from(new Set((input.paths || []).filter((path) => typeof path === "string" && path.trim()).map((path) => path.startsWith("/") ? path : `/${path}`)));
+      if (!paths.length && input.tags?.length) {
+        throw new Error("Vercel ISR revalidation requires explicit paths; tag-only invalidation must be resolved before calling the adapter.");
+      }
+      await Promise.all(paths.map(async (path) => {
+        const response = await fetchImpl(`${origin}${path}`, {
+          method: "HEAD",
+          headers: {
+            "x-prerender-revalidate": options.bypassToken
+          }
+        });
+        if (!response.ok) {
+          throw new Error(`Failed to revalidate Vercel ISR path "${path}": ${response.status} ${response.statusText}`.trim());
+        }
+      }));
+    }
+  };
+};
+export const contentCacheHeaders = (hint) => {
+  const headers = new Headers();
+  if (typeof hint.maxAge === "number") {
+    const directives = [`max-age=${hint.maxAge}`];
+    if (typeof hint.swr === "number") {
+      directives.push(`stale-while-revalidate=${hint.swr}`);
+    }
+    headers.set("Cache-Control", directives.join(", "));
+  }
+  if (hint.etag) {
+    headers.set("ETag", hint.etag);
+  }
+  if (hint.lastModified) {
+    headers.set("Last-Modified", hint.lastModified.toUTCString());
+  }
+  return headers;
+};

package/dist/runtime/server/cache-hints

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

package/dist/runtime/server/cache-hints.d.ts

@@ -0,0 +1,5 @@
+import type { H3Event } from 'h3';
+import type { ContentCacheHint, ContentCacheHintInput } from '../../public/provider';
+export declare const collectContentCacheHint: (event: H3Event, hint: ContentCacheHintInput | undefined) => void;
+export declare const getContentCacheHint: (event: H3Event) => ContentCacheHint | false | undefined;
+export declare const clearContentCacheHint: (event: H3Event) => void;

package/dist/runtime/server/cache-hints.js

@@ -0,0 +1,17 @@
+import { mergeContentCacheHints } from "../../core/cache-hints";
+import { getContentRuntimeContext } from "../../integrations/nitro/context";
+import { isPreview } from "../../integrations/nitro/preview";
+export const collectContentCacheHint = (event, hint) => {
+  if (typeof hint === "undefined") {
+    return;
+  }
+  const runtime = getContentRuntimeContext(event);
+  runtime.cacheHint = isPreview(event) ? false : mergeContentCacheHints(runtime.cacheHint, hint);
+};
+export const getContentCacheHint = (event) => {
+  const runtime = getContentRuntimeContext(event);
+  return isPreview(event) ? false : runtime.cacheHint;
+};
+export const clearContentCacheHint = (event) => {
+  getContentRuntimeContext(event).cacheHint = void 0;
+};

package/dist/runtime/server/collection-helpers

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

package/dist/runtime/server/collection-helpers.d.ts

@@ -0,0 +1,13 @@
+import type { H3Event } from 'h3';
+import type { ParsedContent } from '../../types/content';
+import type { ContentCollectionItemSurroundingsOptions, ContentCollectionNavigationOptions, ContentCollectionPageOptions, ContentCollectionRouteMetaOptions, ContentCollectionSearchSectionsOptions, ContentPageResult, ContentSearchSection } from '../../types/query';
+export declare function queryFilesystemCollectionNavigation(event: H3Event, collection: string, fieldsOrOptions?: string[] | ContentCollectionNavigationOptions): Promise<any[]>;
+export declare function queryFilesystemCollectionItemSurroundings(event: H3Event, collection: string, path: string, opts?: ContentCollectionItemSurroundingsOptions): Promise<(import("../../types").NavItem | null)[]>;
+export declare function queryFilesystemCollectionSearchSections(event: H3Event, collection: string, opts?: ContentCollectionSearchSectionsOptions): Promise<ContentSearchSection[]>;
+export declare function queryFilesystemCollectionPage<T = ParsedContent>(event: H3Event, collection: string, routeOrPath?: string, options?: ContentCollectionPageOptions): Promise<ContentPageResult<T> | null>;
+export declare function queryFilesystemCollectionRouteMeta(event: H3Event, collection: string, routeOrPath?: string, options?: ContentCollectionRouteMetaOptions): Promise<import("../../types").ContentRouteMeta | null>;
+export declare const queryCollectionNavigation: typeof queryFilesystemCollectionNavigation;
+export declare const queryCollectionItemSurroundings: typeof queryFilesystemCollectionItemSurroundings;
+export declare const queryCollectionSearchSections: typeof queryFilesystemCollectionSearchSections;
+export declare const queryCollectionPage: typeof queryFilesystemCollectionPage;
+export declare const queryCollectionRouteMeta: typeof queryFilesystemCollectionRouteMeta;

package/dist/runtime/server/collection-helpers.js

@@ -0,0 +1,99 @@
+import { resolveCollectionItemSurroundingsData, resolveCollectionNavigationData, resolveCollectionPageData, resolveCollectionRouteMetaData, resolveCollectionSearchSectionsData } from "../../features/collections/resolve";
+import { resolveContentNavigation } from "./navigation-query.js";
+import { executeFilesystemContentQuery } from "./query-executor.js";
+import { serverQueryCollection } from "./storage.js";
+import { contentConfig } from "./storage-access.js";
+const isNotFoundError = (error) => {
+  return error?.statusCode === 404;
+};
+const searchPageFields = (fields = []) => [
+  "_path",
+  "title",
+  "description",
+  "body",
+  ...fields
+];
+const mergeFilterQuery = (filterQuery, locale) => {
+  const localeFilter = locale ? { _locale: locale } : void 0;
+  if (filterQuery && localeFilter) {
+    return { $and: [filterQuery, localeFilter] };
+  }
+  return filterQuery || localeFilter;
+};
+export async function queryFilesystemCollectionNavigation(event, collection, fieldsOrOptions = []) {
+  const options = Array.isArray(fieldsOrOptions) ? { fields: fieldsOrOptions } : fieldsOrOptions;
+  const locale = options.locale;
+  return await resolveCollectionNavigationData(collection, contentConfig(), {
+    ...options,
+    loadNavigation: () => resolveContentNavigation(event, {
+      collection,
+      ...options.fields?.length ? { navigationFields: options.fields } : {},
+      ...typeof options.canonical === "boolean" ? { canonical: options.canonical } : {},
+      ...locale ? { resolveLocale: { locale, fallback: true } } : {}
+    })
+  });
+}
+export async function queryFilesystemCollectionItemSurroundings(event, collection, path, opts = {}) {
+  return await resolveCollectionItemSurroundingsData(collection, path, contentConfig(), {
+    ...opts,
+    loadNavigation: (options) => queryFilesystemCollectionNavigation(event, collection, options)
+  });
+}
+export async function queryFilesystemCollectionSearchSections(event, collection, opts = {}) {
+  return await resolveCollectionSearchSectionsData(collection, contentConfig(), {
+    ...opts,
+    loadPages: async (extraFields) => {
+      const query = serverQueryCollection(event, collection).select(...searchPageFields(extraFields));
+      const filterQuery = mergeFilterQuery(opts.filterQuery, opts.locale);
+      if (filterQuery) {
+        return await query.where(filterQuery).all();
+      }
+      return await query.all();
+    }
+  });
+}
+export async function queryFilesystemCollectionPage(event, collection, routeOrPath = "/", options = {}) {
+  return await resolveCollectionPageData(collection, routeOrPath, contentConfig(), {
+    ...options,
+    loadVariantPage: async (input) => {
+      try {
+        return await executeFilesystemContentQuery(event, {
+          collection,
+          first: true,
+          resolveVariant: {
+            path: input.path,
+            locale: input.locale,
+            fallback: input.fallback
+          }
+        });
+      } catch (error) {
+        if (isNotFoundError(error)) {
+          return null;
+        }
+        throw error;
+      }
+    },
+    loadPathPage: async (path) => {
+      try {
+        return await serverQueryCollection(event, collection).where("_path", "=", path).first();
+      } catch (error) {
+        if (isNotFoundError(error)) {
+          return null;
+        }
+        throw error;
+      }
+    }
+  });
+}
+export async function queryFilesystemCollectionRouteMeta(event, collection, routeOrPath = "/", options = {}) {
+  return await resolveCollectionRouteMetaData(collection, contentConfig(), {
+    routeOrPath,
+    ...options,
+    loadPage: (path, loadOptions) => queryFilesystemCollectionPage(event, collection, path, loadOptions)
+  });
+}
+export const queryCollectionNavigation = queryFilesystemCollectionNavigation;
+export const queryCollectionItemSurroundings = queryFilesystemCollectionItemSurroundings;
+export const queryCollectionSearchSections = queryFilesystemCollectionSearchSections;
+export const queryCollectionPage = queryFilesystemCollectionPage;
+export const queryCollectionRouteMeta = queryFilesystemCollectionRouteMeta;

package/dist/runtime/server/index

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

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

@@ -0,0 +1,9 @@
+export { one, many, paginate, backlinks, resolveOne, variants, tree, neighbors, createServerContentQueryContext } from './query-api';
+export { getCollectionPath } from '../query/routes';
+export { queryCollectionsSitemapEntries } from './sitemap-provider';
+export { contentCacheHeaders, noopContentCache, vercelContentCache, type VercelContentCacheOptions } from './cache-adapters';
+export { clearContentCacheHint, collectContentCacheHint, getContentCacheHint } from './cache-hints';
+export { createContentProviderError } from '../../public/provider-errors';
+export { withContentCache } from '../../public/provider';
+export type { ContentCacheAdapter, ContentCacheHint, ContentCacheHintInput, ContentCacheInvalidateInput, ContentProvider, ContentProviderCapabilities, ContentProviderResult, MaybeContentProviderResult } from '../../public/provider';
+export type { ContentProviderErrorCode } from '../../public/provider-errors';

package/dist/runtime/server/index.js

@@ -0,0 +1,15 @@
+export { one, many, paginate, backlinks, resolveOne, variants, tree, neighbors, createServerContentQueryContext } from "./query-api.js";
+export { getCollectionPath } from "../query/routes.js";
+export { queryCollectionsSitemapEntries } from "./sitemap-provider.js";
+export {
+  contentCacheHeaders,
+  noopContentCache,
+  vercelContentCache
+} from "./cache-adapters.js";
+export {
+  clearContentCacheHint,
+  collectContentCacheHint,
+  getContentCacheHint
+} from "./cache-hints.js";
+export { createContentProviderError } from "../../public/provider-errors";
+export { withContentCache } from "../../public/provider";

package/dist/runtime/server/manifest

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

package/dist/runtime/server/manifest.d.ts

@@ -0,0 +1 @@
+export * from '../../storage/manifest';

package/dist/runtime/server/manifest.js

@@ -0,0 +1 @@
+export * from "../../storage/manifest";

package/dist/runtime/server/navigation

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

package/dist/runtime/server/navigation-query

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

package/dist/runtime/server/navigation-query.d.ts

@@ -0,0 +1,4 @@
+import type { H3Event } from 'h3';
+import type { NavItem } from '../../types/content';
+import type { ContentQueryBuilderParams } from '../../types/query';
+export declare function resolveContentNavigation(event: H3Event, inputQuery?: ContentQueryBuilderParams): Promise<NavItem[]>;

package/dist/runtime/server/navigation-query.js

@@ -0,0 +1,80 @@
+import { resolveContentNavigationData } from "../../features/navigation/query";
+import { buildCanonicalNavigation } from "../../features/navigation/build";
+import { markCollectionNavigationRoot, projectNavigationTree } from "../../features/navigation/canonical";
+import { normalizeRouteMounts } from "../../features/localization/path";
+import { getContentRuntimeConfig } from "./runtime-config.js";
+import { isPreview } from "./preview.js";
+import { cacheStorage } from "./storage-access.js";
+import { createServerContentQuery } from "./storage.js";
+import { resolveLocaleChain } from "./manifest.js";
+export async function resolveContentNavigation(event, inputQuery = {}) {
+  const runtimeConfig = getContentRuntimeConfig();
+  const requestedFields = [
+    ...Array.isArray(inputQuery.only) ? inputQuery.only.map(String) : [],
+    ...Array.isArray(inputQuery.navigationFields) ? inputQuery.navigationFields : []
+  ];
+  const sourceQuery = { ...inputQuery };
+  if ("canonical" in sourceQuery) {
+    delete sourceQuery.canonical;
+  }
+  if ("navigationFields" in sourceQuery) {
+    delete sourceQuery.navigationFields;
+  }
+  if ("only" in sourceQuery) {
+    delete sourceQuery.only;
+  }
+  if ("resolveLocale" in sourceQuery) {
+    delete sourceQuery.resolveLocale;
+  }
+  return await resolveContentNavigationData({
+    defaultLocale: runtimeConfig.content.defaultLocale,
+    localeFallback: runtimeConfig.content.localeFallback,
+    navigation: runtimeConfig.public.content.navigation,
+    cacheEnabled: true,
+    isPreview: isPreview(event)
+  }, {
+    query: inputQuery,
+    readCache: async () => {
+      const cached = await cacheStorage(event).getItem("_nav.json");
+      return cached;
+    },
+    loadLocaleNavigation: async (locale) => {
+      let contentsQuery = createServerContentQuery(event, sourceQuery).where("_partial", "=", false).where("_type", "=", "markdown").where("navigation", "!=", false);
+      if (locale) {
+        contentsQuery = contentsQuery.where("_locale", "=", locale);
+      }
+      let dirConfigsQuery = createServerContentQuery(event).where("_navigation", "=", true).where("_partial", "=", true);
+      if (locale) {
+        dirConfigsQuery = dirConfigsQuery.where("_locale", "=", locale);
+      }
+      const contents = await contentsQuery.all();
+      const dirConfigs = await dirConfigsQuery.all();
+      const configs = dirConfigs.reduce((accumulator, config) => {
+        accumulator[config._path || "/"] = {
+          ...config,
+          ...config.body
+        };
+        return accumulator;
+      }, {});
+      const configuredFields = runtimeConfig.public.content.navigation === false ? [] : runtimeConfig.public.content.navigation.fields;
+      return buildCanonicalNavigation(contents, configs, [.../* @__PURE__ */ new Set([...configuredFields, ...requestedFields])]);
+    },
+    resolveLocaleChain,
+    localizeNavigation: async (items, locale, _fallback = [], collection, canonical) => {
+      const collectionI18n = collection ? runtimeConfig.content.collections?.[collection]?.i18n : void 0;
+      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 : runtimeConfig.content.locales;
+      const defaultLocale = collectionDefault || runtimeConfig.content.defaultLocale;
+      const routeMounts = collection ? normalizeRouteMounts(runtimeConfig.content.collections?.[collection]?.route, locales, defaultLocale) : void 0;
+      const navigation = markCollectionNavigationRoot(items, collection, { routeMounts });
+      return projectNavigationTree(navigation, {
+        locale,
+        defaultLocale,
+        routeMounts,
+        collection,
+        canonical
+      });
+    }
+  });
+}