@lupinum/ginko-content 0.1.2 → 0.1.3

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

@@ -4,14 +4,51 @@ import { normalizeContentQueryParams } from "../../core/query/params";
 import { normalizeI18nConfig, resolveRuntimeCollectionI18nConfig } from "../../features/localization/config";
 import { normalizeReferenceValue } from "../../core/references/resolve";
 import { getContentRuntimeConfig } from "./runtime-config.js";
+import { createContentProviderError } from "../../public/provider-errors";
+const isObject = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+const isProviderFindResponse = (response) => isObject(response) && Array.isArray(response.result) && typeof response.skip === "number" && typeof response.limit === "number" && typeof response.total === "number";
 export const normalizeProviderQueryResult = (response) => {
-  if (Array.isArray(response)) {
+  if (isProviderFindResponse(response)) {
+    return response.result;
+  }
+  return [];
+};
+const isProviderFindOneResponse = (response) => isObject(response) && "result" in response && Object.keys(response).length === 1;
+const isProviderCountResponse = (response) => isObject(response) && typeof response.result === "number" && Object.keys(response).length === 1;
+const hasListEnvelopeKeys = (response) => ["skip", "limit", "total"].some((key) => key in response);
+const describeProviderResponse = (response) => {
+  if (Array.isArray(response)) return "array";
+  if (response === null) return "null";
+  return typeof response;
+};
+const invalidProviderQueryResult = (params, message, response, providerName) => {
+  throw createContentProviderError("provider_result_invalid", message, {
+    collection: params.collection,
+    provider: providerName,
+    mode: params.count ? "count" : params.first ? "first" : "many",
+    responseType: describeProviderResponse(response)
+  });
+};
+export const normalizeProviderQueryResponse = (params, response, providerName) => {
+  if (params.count) {
+    if (isProviderCountResponse(response)) {
+      return response;
+    }
+    return invalidProviderQueryResult(params, "Provider count queries must return a count envelope: { result: number }.", response, providerName);
+  }
+  if (params.first) {
+    if (isProviderFindOneResponse(response)) {
+      return response;
+    }
+    return invalidProviderQueryResult(params, "Provider first queries must return a find-one envelope: { result: item | undefined }.", response, providerName);
+  }
+  if (isProviderFindResponse(response)) {
     return response;
   }
-  if (response && typeof response === "object" && "result" in response) {
-    return Array.isArray(response.result) ? response.result : [];
+  if (isObject(response) && hasListEnvelopeKeys(response)) {
+    return invalidProviderQueryResult(params, "Provider list query envelopes must include array result, skip, limit, and total.", response, providerName);
   }
-  return [];
+  return invalidProviderQueryResult(params, "Provider list queries must return a list envelope: { result: item[], skip, limit, total }.", response, providerName);
 };
 const identityMatchesDocument = (document, identity) => {
   const normalizedIdentity = normalizeReferenceValue(identity);
@@ -45,13 +82,16 @@ export const resolveProviderContentVariants = async (event, identity, options) =
   const documents = localesToQuery.length ? (await Promise.all(
     localesToQuery.map(
       async (locale) => normalizeProviderQueryResult(
-        await provider.query(event, {
+        normalizeProviderQueryResponse({
+          ...baseQuery,
+          resolveLocale: { locale, exact: true }
+        }, await provider.query(event, {
           ...baseQuery,
           resolveLocale: { locale, exact: true }
-        })
+        }), provider.name)
       )
     )
-  )).flat() : normalizeProviderQueryResult(await provider.query(event, baseQuery));
+  )).flat() : normalizeProviderQueryResult(normalizeProviderQueryResponse(baseQuery, await provider.query(event, baseQuery), provider.name));
   const matched = documents.find((document) => identityMatchesDocument(document, normalizedReference));
   const canonicalKey = matched?._canonicalKey;
   if (!canonicalKey) {
@@ -84,7 +124,9 @@ export const resolveProviderContentVariants = async (event, identity, options) =
 export const createServerProviderQueryFetch = (event) => {
   return async (query) => {
     const { getContentProvider } = await import("./providers/index.js");
-    return await (await getContentProvider(event)).query(event, query.params());
+    const provider = await getContentProvider(event);
+    const response = await provider.query(event, query.params());
+    return normalizeProviderQueryResponse(query.params(), response, provider.name);
   };
 };
 const getServerCollectionI18n = (collection) => {

package/dist/runtime/server/provider-result.d.ts

@@ -1,10 +1,27 @@
 import type { H3Event } from 'h3';
-import type { ContentProvider, ContentProviderResult, MaybeContentProviderResult } from '../../public/provider';
+import type { ContentQueryResponse } from '../../types/api';
+import type { NavItem, ParsedContent } from '../../types/content';
+import type { ContentCollectionItemSurroundingsOptions, ContentCollectionNavigationOptions, ContentCollectionPageOptions, ContentCollectionRouteMetaOptions, ContentCollectionSearchSectionsOptions, ContentPageResult, ContentQueryBuilderParams, ContentRouteMeta, ContentSearchSection, ContentSitemapEntry } from '../../types/query';
+import type { QueryCollectionsSitemapEntriesOptions } from '../../features/sitemap/query';
+import type { ContentProvider, ContentProviderResult, ContentProviderSiteDataRequest, ContentProviderSiteDataResponse, MaybeContentProviderResult } from '../../public/provider';
+import type { ContentProviderSearchRequest, ContentSearchResult } from '../../types/search';
 export declare const isContentProviderResult: <T = unknown>(value: unknown) => value is ContentProviderResult<T>;
 export declare const unwrapContentProviderResult: <T>(event: H3Event, result: MaybeContentProviderResult<T>) => T;
+export interface RuntimeContentProvider extends Omit<ContentProvider, 'query' | 'navigationQuery' | 'navigation' | 'surroundings' | 'searchSections' | 'search' | 'siteData' | 'page' | 'routeMeta' | 'sitemapEntries'> {
+    query: <T = ParsedContent>(event: H3Event, query: ContentQueryBuilderParams) => Promise<ContentQueryResponse<T>>;
+    navigationQuery?: (event: H3Event, query: ContentQueryBuilderParams) => Promise<NavItem[]>;
+    navigation?: (event: H3Event, collection: string, options?: string[] | ContentCollectionNavigationOptions) => Promise<NavItem[]>;
+    surroundings?: (event: H3Event, collection: string, path: string, options?: ContentCollectionItemSurroundingsOptions) => Promise<Array<NavItem | null>>;
+    searchSections?: (event: H3Event, collection: string, options?: ContentCollectionSearchSectionsOptions) => Promise<ContentSearchSection[]>;
+    search?: (event: H3Event, request: ContentProviderSearchRequest) => Promise<ContentSearchResult[]>;
+    siteData?: <T = unknown>(event: H3Event, request: ContentProviderSiteDataRequest) => Promise<ContentProviderSiteDataResponse<T>>;
+    page?: <T = ParsedContent>(event: H3Event, collection: string, routeOrPath?: string, options?: ContentCollectionPageOptions) => Promise<ContentPageResult<T> | null>;
+    routeMeta?: (event: H3Event, collection: string, routeOrPath?: string, options?: ContentCollectionRouteMetaOptions) => Promise<ContentRouteMeta | null>;
+    sitemapEntries?: (event: H3Event, options?: QueryCollectionsSitemapEntriesOptions) => Promise<ContentSitemapEntry[]>;
+}
 /**
  * External providers may return `{ data, cache }` from any provider method.
  * Runtime consumers should continue receiving the historical raw data shape,
  * while the request-local cache collector records the cache hint.
  */
-export declare const wrapContentProviderCacheResults: (event: H3Event, provider: ContentProvider) => ContentProvider;
+export declare const wrapContentProviderCacheResults: (event: H3Event, provider: ContentProvider) => RuntimeContentProvider;

package/dist/runtime/server/providers/filesystem.js

@@ -9,6 +9,7 @@ import {
   queryFilesystemCollectionSearchSections
 } from "../collection-helpers.js";
 import { queryFilesystemCollectionsSitemapEntries } from "../sitemap.js";
+import { createContentProviderError } from "../../../public/provider-errors";
 export const filesystemProvider = {
   name: "filesystem",
   capabilities: {
@@ -33,7 +34,9 @@ export const filesystemProvider = {
   },
   query: (event, query) => {
     if (containsStandaloneRegexOptions(query.where)) {
-      throw new TypeError("Query operator $options requires $regex.");
+      throw createContentProviderError("unsupported_query_shape", "Query operator $options requires $regex.", {
+        operator: "$options"
+      });
     }
     return executeFilesystemContentQuery(event, query);
   },

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

@@ -1,3 +1,5 @@
 import type { H3Event } from 'h3';
 import type { ContentProvider } from '../../../public/provider';
-export declare const getContentProvider: (event?: H3Event) => Promise<ContentProvider>;
+import { type RuntimeContentProvider } from '../provider-result';
+export declare function getContentProvider(): Promise<ContentProvider>;
+export declare function getContentProvider(event: H3Event): Promise<RuntimeContentProvider>;

package/dist/runtime/server/providers/index.js

@@ -160,7 +160,7 @@ const validateContentProvider = (providerName, provider) => {
   }
   return provider;
 };
-export const getContentProvider = async (event) => {
+export async function getContentProvider(event) {
   const runtime = event ? useRuntimeConfig(event) : useRuntimeConfig();
   const eventContent = event?.context?.contentRuntime;
   const provider = eventContent?.provider || runtime.content?.provider || runtime.public?.content?.provider || "filesystem";
@@ -187,4 +187,4 @@ export const getContentProvider = async (event) => {
     }
   }
   throw createContentProviderError("unknown_provider", `Unknown content provider: ${provider}`, { provider });
-};
+}

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

@@ -11,6 +11,7 @@ import {
 import { getContentProvider } from "./providers/index.js";
 import { createContentProviderError } from "../../public/provider-errors";
 import { getContentRuntimeConfig } from "./runtime-config.js";
+import { normalizeProviderQueryResponse } from "./provider-query.js";
 export const createServerContentQueryContext = async (event) => {
   const provider = await getContentProvider(event);
   return {
@@ -24,7 +25,7 @@ export const createServerContentQueryContext = async (event) => {
         }
         return await provider.navigationQuery(event, params);
       }
-      return await provider.query(event, params);
+      return normalizeProviderQueryResponse(params, await provider.query(event, params), provider.name);
     }
   };
 };

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

@@ -1,4 +1,5 @@
 import { type H3Event } from 'h3';
+import type { ContentQueryResponse } from '../../types/api';
 import type { ContentQueryBuilderParams } from '../../types/query';
-export declare const executeFilesystemContentQuery: <T = unknown>(event: H3Event, inputQuery: ContentQueryBuilderParams) => Promise<T | T[]>;
-export declare const executeContentQuery: <T = unknown>(event: H3Event, inputQuery: ContentQueryBuilderParams) => Promise<T | T[]>;
+export declare const executeFilesystemContentQuery: <T = unknown>(event: H3Event, inputQuery: ContentQueryBuilderParams) => Promise<ContentQueryResponse<T>>;
+export declare const executeContentQuery: <T = unknown>(event: H3Event, inputQuery: ContentQueryBuilderParams) => Promise<ContentQueryResponse<T>>;

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

@@ -72,13 +72,15 @@ const normalizePublicQuery = (event, query, config) => {
     includeDraftFilter: false
   });
   if (enforceProductionVisibility) {
+    const where = Array.isArray(normalized.where) ? normalized.where : normalized.where ? [normalized.where] : [];
     normalized.where = [
-      ...normalized.where || [],
+      ...where,
       { _draft: { $ne: true } },
       { _partial: { $ne: true } }
     ];
   }
-  normalized.where = (normalized.where || []).map((condition) => compileWhere(condition)).filter((condition) => Boolean(condition));
+  const normalizedWhere = Array.isArray(normalized.where) ? normalized.where : normalized.where ? [normalized.where] : [];
+  normalized.where = normalizedWhere.map((condition) => compileWhere(condition)).filter((condition) => Boolean(condition));
   const unsupported = findUnsupportedQueryOperator(normalized.where);
   if (unsupported) {
     throw createContentProviderError("unsupported_query_operator", `Unsupported query operator: ${unsupported}`, {
@@ -106,7 +108,7 @@ export const executeFilesystemContentQuery = async (event, inputQuery) => {
     collections: config.collections
   });
   if (plan.mode === "count") {
-    return response.result;
+    return response;
   }
   const requestedLocale = plan.resolveVariant?.locale || plan.resolveLocale?.locale;
   if (plan.mode === "first") {
@@ -114,8 +116,14 @@ export const executeFilesystemContentQuery = async (event, inputQuery) => {
     if (!content) {
       notFound(query, plan.resolveVariant ? "Could not find document for the given route variant." : void 0);
     }
-    return await withResolvedRefs(event, content, requestedLocale);
+    return {
+      result: await withResolvedRefs(event, content, requestedLocale)
+    };
   }
-  return await withResolvedRefsList(event, Array.isArray(response.result) ? response.result : [], requestedLocale);
+  const listResponse = response;
+  return {
+    ...listResponse,
+    result: await withResolvedRefsList(event, Array.isArray(response.result) ? response.result : [], requestedLocale)
+  };
 };
 export const executeContentQuery = executeFilesystemContentQuery;

package/dist/runtime/server/search.js

@@ -14,7 +14,7 @@ const isRouteBackedSearchCollection = (config) => {
   return config.type === "page" || hasRouteMount(config.route) || config.sitemap === true;
 };
 export const resolveSearchCollections = (runtimeContent, collectionsOverride) => {
-  const configuredCollections = collectionsOverride || (runtimeContent.search && runtimeContent.search !== false ? runtimeContent.search.collections : void 0);
+  const configuredCollections = collectionsOverride || (runtimeContent.search ? runtimeContent.search.collections : void 0);
   if (configuredCollections?.length) {
     return unique(configuredCollections);
   }

package/dist/runtime/server/sitemap-provider.js

@@ -1,4 +1,43 @@
 import { createContentProviderError } from "../../public/provider-errors";
+const isObject = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+const describeShape = (value) => {
+  if (Array.isArray(value)) return "array";
+  if (value === null) return "null";
+  return typeof value;
+};
+const assertSitemapEntry = (entry, index, provider) => {
+  if (!isObject(entry) || typeof entry.loc !== "string" || !entry.loc.trim()) {
+    throw createContentProviderError("provider_result_invalid", `${provider} returned an invalid sitemap entry.`, {
+      provider,
+      operation: "sitemap entries",
+      index,
+      field: "loc",
+      actual: describeShape(entry)
+    });
+  }
+  if (entry.alternatives !== void 0 && (!Array.isArray(entry.alternatives) || entry.alternatives.some(
+    (alternative) => !isObject(alternative) || typeof alternative.hreflang !== "string" || typeof alternative.href !== "string"
+  ))) {
+    throw createContentProviderError("provider_result_invalid", `${provider} returned invalid sitemap alternatives.`, {
+      provider,
+      operation: "sitemap entries",
+      index,
+      field: "alternatives",
+      actual: describeShape(entry.alternatives)
+    });
+  }
+};
+const assertSitemapEntries = (value, provider) => {
+  if (!Array.isArray(value)) {
+    throw createContentProviderError("provider_result_invalid", `${provider} returned invalid sitemap entries.`, {
+      provider,
+      operation: "sitemap entries",
+      actual: describeShape(value)
+    });
+  }
+  value.forEach((entry, index) => assertSitemapEntry(entry, index, provider));
+  return value;
+};
 export async function queryCollectionsSitemapEntries(event, options = {}) {
   const { getContentProvider } = await import("./providers/index.js");
   const provider = await getContentProvider(event);
@@ -7,5 +46,5 @@ export async function queryCollectionsSitemapEntries(event, options = {}) {
       provider: provider.name
     });
   }
-  return await provider.sitemapEntries(event, options);
+  return assertSitemapEntries(await provider.sitemapEntries(event, options), provider.name);
 }

package/dist/runtime/server/sitemap.js

@@ -18,12 +18,13 @@ const sitemapPageFields = [
 ];
 export async function queryFilesystemCollectionsSitemapEntries(event, options = {}) {
   const runtimeConfig = useRuntimeConfig(event);
+  const sitemapRuntime = runtimeConfig;
   const requestUrl = event?.node?.req ? getRequestURL(event) : null;
   return await queryCollectionsSitemapEntriesData({
     collections: contentConfig().collections,
     defaultLocale: contentConfig().defaultLocale,
-    runtimeSiteUrl: runtimeConfig.public.siteUrl,
-    localeConfigs: runtimeConfig.public.i18n?.locales || [],
+    runtimeSiteUrl: sitemapRuntime.public.content?.siteUrl || sitemapRuntime.public.siteUrl,
+    localeConfigs: sitemapRuntime.public.i18n?.locales || [],
     requestSiteUrl: requestUrl ? `${requestUrl.protocol}//${requestUrl.host}` : void 0
   }, {
     loadCollectionPages: async (collection) => {

package/dist/runtime/transformers/component-resolver.js

@@ -20,8 +20,9 @@ export default defineTransformer({
     if (import.meta.server) {
       return content;
     }
+    const transformerOptions = typeof options === "object" && options !== null ? options : {};
     const _components = await resolveContentComponents(content.body, {
-      ...options?.tags || {},
+      ...transformerOptions.tags || {},
       ...content._components || {}
     });
     content._components = _components;

package/dist/runtime/utils/content-components.d.ts

@@ -1,9 +1,4 @@
 import type { AsyncComponentLoader } from 'vue';
-declare module '#build/content-components' {
-    const globalComponents: string[];
-    const localComponents: string[];
-    const localComponentLoaders: Record<string, AsyncComponentLoader>;
-}
 export declare const globalComponents: string[];
 export declare const localComponents: string[];
 export declare const localComponentLoaders: Record<string, AsyncComponentLoader>;

package/dist/storage/content.d.ts

@@ -1,14 +1,7 @@
 import type { H3Event } from 'h3';
 import type { ParsedContent } from '../types/content';
-import type { ContentCollectionMap, ContentLocaleEntry, ContentQueryBuilderParams, ContentQueryRequest, CollectionQueryBuilder, ResolveContentReferenceOptions } from '../types/query';
-export declare const createServerQueryFetch: <T = ParsedContent>(event: H3Event) => (query: ContentQueryRequest) => Promise<import("../types/api").ContentQueryCountResponse | {
-    result: T | T[] | undefined;
-} | {
-    result: T | T[] | undefined;
-    skip: number;
-    limit: number;
-    total: number;
-}>;
+import type { ContentCollectionMap, ContentLocaleEntry, ContentQueryBuilderParams, ContentQueryFetcher, CollectionQueryBuilder, ResolveContentReferenceOptions } from '../types/query';
+export declare const createServerQueryFetch: <T = ParsedContent>(event: H3Event) => ContentQueryFetcher<T>;
 /**
  * Resolve an authored content reference value to a concrete document.
  *

package/dist/storage/references.d.ts

@@ -3,11 +3,4 @@ import type { ContentQueryBuilderParams } from '../types/query';
 import type { ContentQueryResponse } from '../types/api';
 export declare const withResolvedRefs: <T>(event: H3Event, content: T, requestedLocale?: string) => Promise<T>;
 export declare const withResolvedRefsList: <T>(event: H3Event, items: T[], requestedLocale?: string) => Promise<T[]>;
-export declare const withResolvedRefsQueryResponse: <T>(event: H3Event, response: ContentQueryResponse<T>, params: ContentQueryBuilderParams) => Promise<import("../types/api").ContentQueryCountResponse | {
-    result: T | T[] | undefined;
-} | {
-    result: T | T[] | undefined;
-    skip: number;
-    limit: number;
-    total: number;
-}>;
+export declare const withResolvedRefsQueryResponse: <T>(event: H3Event, response: ContentQueryResponse<T>, params: ContentQueryBuilderParams) => Promise<ContentQueryResponse<T>>;

package/dist/storage/references.js

@@ -66,13 +66,18 @@ export const withResolvedRefsQueryResponse = async (event, response, params) =>
   }
   const requestedLocale = params.resolveLocale?.locale;
   if (params.first) {
+    const firstResponse = response;
     return {
-      ...response,
-      result: await withResolvedRefs(event, response.result, requestedLocale)
+      ...firstResponse,
+      result: await withResolvedRefs(event, firstResponse.result, requestedLocale)
     };
   }
+  if (!Array.isArray(response.result)) {
+    return response;
+  }
+  const listResponse = response;
   return {
-    ...response,
-    result: Array.isArray(response.result) ? await withResolvedRefsList(event, response.result, requestedLocale) : response.result
+    ...listResponse,
+    result: await withResolvedRefsList(event, listResponse.result, requestedLocale)
   };
 };

package/dist/testing/provider-contract.js

@@ -1,7 +1,6 @@
 import { expect, test } from "vitest";
 import { contentProviderResultMarker } from "../public/provider";
-import { getContentCacheHint } from "../runtime/server/cache-hints";
-import { createAuthorDependencyProviderFixture, createFixtureContentProvider, createProviderFixtureEvent } from "./provider-fixture.js";
+import { createAuthorDependencyProviderFixture, createFixtureContentProvider, createProviderFixtureEvent, getProviderFixtureCacheHint } from "./provider-fixture.js";
 const defaultCollectNavPaths = (items) => items.flatMap((item) => [
   item._path,
   ...defaultCollectNavPaths(item.children || [])
@@ -137,7 +136,7 @@ export const runSaasProviderFixtureContractSuite = ({
     const provider = await loadProvider();
     const event = createEvent();
     await provider.page?.(event, "posts", "/de/magazin/mehrsprachiges-onboarding");
-    expect(getContentCacheHint(event)).toMatchObject({
+    expect(getProviderFixtureCacheHint(event)).toMatchObject({
       tags: expect.arrayContaining([
         "entry:posts:posts.onboarding",
         "entry:authors:emily",
@@ -149,7 +148,7 @@ export const runSaasProviderFixtureContractSuite = ({
     if (provider.siteData) {
       const siteDataEvent = createEvent();
       await provider.siteData(siteDataEvent, { key: "settings", locale: "de" });
-      expect(getContentCacheHint(siteDataEvent)).toMatchObject({
+      expect(getProviderFixtureCacheHint(siteDataEvent)).toMatchObject({
         tags: ["site-data:settings:de"]
       });
     }

package/dist/testing/provider-fixture.d.ts

@@ -1,4 +1,4 @@
-import { type ContentProvider } from '../public/provider';
+import { type ContentCacheHint, type ContentProvider } from '../public/provider';
 import type { H3Event } from 'h3';
 import type { ParsedContent } from '../types/content';
 import { type ContentGraph } from '../core/content/graph';
@@ -55,6 +55,8 @@ export interface ProviderFixtureEventOptions {
     params?: Record<string, string>;
     context?: Record<string, unknown>;
 }
+export declare const collectProviderFixtureCacheHint: (event: H3Event, hint: ContentCacheHint | false | undefined) => void;
+export declare const getProviderFixtureCacheHint: (event: H3Event) => ContentCacheHint | false | undefined;
 export declare const createProviderFixtureDocument: (input: Partial<ParsedContent> & Record<string, unknown>) => ParsedContent;
 export declare const createProviderFixture: (input: ProviderFixtureInput) => ProviderFixture;
 export declare const createProviderFixtureEvent: (options?: ProviderFixtureEventOptions) => H3Event;

package/dist/testing/provider-fixture.js

@@ -3,19 +3,18 @@ import { buildContentGraph } from "../core/content/graph";
 import { executeQueryPlan } from "../core/query/execute";
 import { lowerQueryPlan } from "../core/query/lower";
 import { findUnsupportedQueryOperator, SUPPORTED_QUERY_OPERATORS } from "../core/query/operators";
+import { mergeContentCacheHints } from "../core/cache-hints";
 import { normalizeRouteMounts, projectContentPathToLocale } from "../features/localization/path";
 import { createRouteMeta, localizePageResult } from "../features/localization/results";
 import { createContentProviderError } from "../public/provider-errors";
-import { collectContentCacheHint } from "../runtime/server/cache-hints";
 const trimSlashes = (value) => value.replace(/^\/+|\/+$/g, "");
+const isObject = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
 const unwrapResponseResult = (response) => {
-  if (response && typeof response === "object" && response[contentProviderResultMarker] === true) {
+  if (isObject(response) && response[contentProviderResultMarker] === true) {
     return unwrapResponseResult(response.data);
   }
-  if (response && typeof response === "object" && "result" in response) {
-    return response.result;
-  }
-  return response;
+  const envelope = response;
+  return envelope.result;
 };
 const normalizeQueryResult = (value) => {
   if (Array.isArray(value)) return value;
@@ -72,6 +71,19 @@ const referenceEntryTags = (fixture, doc) => {
   }));
   return Array.from(new Set(collectStringValues(doc).map((value) => knownRefs.get(value)).filter((tag) => typeof tag === "string")));
 };
+const getProviderFixtureRuntimeContext = (event) => {
+  const context = event.context ||= {};
+  context.__contentRuntime ||= {};
+  return context.__contentRuntime;
+};
+export const collectProviderFixtureCacheHint = (event, hint) => {
+  if (typeof hint === "undefined") {
+    return;
+  }
+  const runtime = getProviderFixtureRuntimeContext(event);
+  runtime.cacheHint = mergeContentCacheHints(runtime.cacheHint, hint);
+};
+export const getProviderFixtureCacheHint = (event) => getProviderFixtureRuntimeContext(event).cacheHint;
 const createCacheHintForDocument = (fixture, doc, path) => {
   const collection = doc._collection || "content";
   return {
@@ -224,7 +236,7 @@ export const createFixtureContentProvider = (fixture, name = fixture.providerNam
         operator: unsupported
       });
     }
-    collectContentCacheHint(event, {
+    collectProviderFixtureCacheHint(event, {
       tags: params.collection ? [collectionTag(params.collection)] : []
     });
     return executeQueryPlan(
@@ -258,7 +270,7 @@ export const createFixtureContentProvider = (fixture, name = fixture.providerNam
     query,
     navigationQuery: async (event, params) => {
       const docs = await docsForNavigation(event, params);
-      collectContentCacheHint(event, {
+      collectProviderFixtureCacheHint(event, {
         tags: [
           ...params.collection ? [collectionTag(params.collection)] : [],
           ...params.resolveLocale?.locale ? [`nav:${params.collection || "all"}:${params.resolveLocale.locale}`] : []
@@ -277,7 +289,7 @@ export const createFixtureContentProvider = (fixture, name = fixture.providerNam
       assertCollection(collection);
       const fields = Array.isArray(options) ? options : options.fields || [];
       const locale = typeof options === "object" && !Array.isArray(options) ? options.locale : void 0;
-      collectContentCacheHint(event, {
+      collectProviderFixtureCacheHint(event, {
         tags: [`nav:${collection}:${locale || fixture.defaultLocale}`, collectionTag(collection)]
       });
       const docs = await docsForNavigation(event, {
@@ -318,7 +330,7 @@ export const createFixtureContentProvider = (fixture, name = fixture.providerNam
     },
     searchSections: async (event, collection, options = {}) => {
       assertCollection(collection);
-      collectContentCacheHint(event, {
+      collectProviderFixtureCacheHint(event, {
         tags: [`search:${options.locale || fixture.defaultLocale}`, collectionTag(collection)]
       });
       const docs = await docsForNavigation(event, {
@@ -335,7 +347,8 @@ export const createFixtureContentProvider = (fixture, name = fixture.providerNam
         id: localizePath(fixture, collection, doc._path || "/", options.locale || doc._locale),
         title: doc.title || "",
         titles: [doc.title || ""],
-        content: String(doc.description || doc.title || "")
+        content: String(doc.description || doc.title || ""),
+        level: 1
       }));
     },
     search: async (_event, request) => {
@@ -350,7 +363,7 @@ export const createFixtureContentProvider = (fixture, name = fixture.providerNam
       }));
     },
     siteData: async (event, request) => {
-      collectContentCacheHint(event, {
+      collectProviderFixtureCacheHint(event, {
         tags: [`site-data:${request.key}:${request.locale || fixture.defaultLocale}`]
       });
       return {
@@ -389,7 +402,7 @@ export const createFixtureContentProvider = (fixture, name = fixture.providerNam
         routeMountsFor(fixture, collection)
       );
       const hint = createCacheHintForDocument(fixture, doc, page.path);
-      collectContentCacheHint(event, hint);
+      collectProviderFixtureCacheHint(event, hint);
       recordRouteDependencies(cache, page.path, hint.tags || []);
       return page;
     },
@@ -398,7 +411,7 @@ export const createFixtureContentProvider = (fixture, name = fixture.providerNam
       return page ? createRouteMeta(page, options.locale || page.locale, fixture.defaultLocale, routeMountsFor(fixture, collection)) : null;
     },
     sitemapEntries: async (event, options = {}) => {
-      collectContentCacheHint(event, { tags: ["sitemap"] });
+      collectProviderFixtureCacheHint(event, { tags: ["sitemap"] });
       const explicitInclude = Boolean(options.include?.length);
       const include = explicitInclude ? options.include : Object.keys(fixture.collections);
       const entries = [];