@lupinum/ginko-content 0.1.5 → 0.2.0

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

@@ -1,15 +1,15 @@
 import type { H3Event } from 'h3';
 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 { ContentCollectionItemSurroundingsOptions, ContentCollectionNavigationOptions, ContentCollectionPageOptions, ContentCollectionRouteMetaOptions, ContentCollectionSearchSectionsOptions, ContentPageResult, 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 { ContentProvider, ContentProviderNavigationOptions, ContentProviderQuery, 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[]>;
+    query: <T = ParsedContent>(event: H3Event, query: ContentProviderQuery) => Promise<ContentQueryResponse<T>>;
+    navigationQuery?: (event: H3Event, query: ContentProviderQuery, options?: ContentProviderNavigationOptions) => 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[]>;

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

@@ -1,4 +1,4 @@
-import { containsStandaloneRegexOptions, SUPPORTED_QUERY_OPERATORS } from "../../../core/query/operators";
+import { SUPPORTED_QUERY_OPERATORS } from "../../../core/query/operators";
 import { executeFilesystemContentQuery } from "../query-executor.js";
 import { resolveContentNavigation } from "../navigation-query.js";
 import {
@@ -9,7 +9,6 @@ import {
   queryFilesystemCollectionSearchSections
 } from "../collection-helpers.js";
 import { queryFilesystemCollectionsSitemapEntries } from "../sitemap.js";
-import { createContentProviderError } from "../../../public/provider-errors";
 export const filesystemProvider = {
   name: "filesystem",
   capabilities: {
@@ -32,15 +31,8 @@ export const filesystemProvider = {
       count: true
     }
   },
-  query: (event, query) => {
-    if (containsStandaloneRegexOptions(query.where)) {
-      throw createContentProviderError("unsupported_query_shape", "Query operator $options requires $regex.", {
-        operator: "$options"
-      });
-    }
-    return executeFilesystemContentQuery(event, query);
-  },
-  navigationQuery: (event, query) => resolveContentNavigation(event, query),
+  query: (event, query) => executeFilesystemContentQuery(event, query.plan),
+  navigationQuery: (event, query, options) => resolveContentNavigation(event, query, options),
   navigation: (event, collection, options) => queryFilesystemCollectionNavigation(event, collection, options),
   surroundings: (event, collection, path, options) => queryFilesystemCollectionItemSurroundings(event, collection, path, options),
   searchSections: (event, collection, options) => queryFilesystemCollectionSearchSections(event, collection, options),

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

@@ -1,5 +1,22 @@
 import type { H3Event } from 'h3';
-import type { ContentProvider } from '../../../public/provider';
+import { type ContentProvider, type ContentProviderQuery } from '../../../public/provider';
+import type { FilterExpr } from '../../../core/query/plan';
 import { type RuntimeContentProvider } from '../provider-result';
+/**
+ * Derive the operator vocabulary a plan actually exercises by walking its
+ * `FilterExpr` tree (CS-5 trap 3). Only `compare` nodes carry operators; we
+ * recurse through `and`/`or`/`not` to reach every one. Operators are reported
+ * in the builder's `$`-prefixed vocabulary so they compare directly against
+ * `capabilities.query.operators`.
+ */
+export declare const collectPlanFilterOperators: (filter: FilterExpr, operators?: Set<string>) => Set<string>;
+/**
+ * Dev-mode guard: the provider wire is JSON-pure by contract (CS-5). A stray
+ * `RegExp`/`Date` in `plan.filter` would corrupt any provider that serializes
+ * the query, so we fail fast in dev instead of shipping a silently mangled
+ * wire. No-op in production (the walk is not free).
+ */
+export declare const assertJsonPureProviderQuery: (provider: ContentProvider, query: ContentProviderQuery) => void;
+export declare const enforceProviderCapabilities: (provider: ContentProvider) => ContentProvider;
 export declare function getContentProvider(): Promise<ContentProvider>;
 export declare function getContentProvider(event: H3Event): Promise<RuntimeContentProvider>;

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

@@ -1,5 +1,6 @@
 import { useRuntimeConfig } from "nitropack/runtime";
 import { loadExternalContentProvider } from "#content/virtual/providers";
+import { PROVIDER_QUERY_VERSION } from "../../../public/provider";
 import { createContentProviderError } from "../../../public/provider-errors";
 import { wrapContentProviderCacheResults } from "../provider-result.js";
 const isObject = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
@@ -24,43 +25,91 @@ const assertProviderField = (providerName, condition, field) => {
 const assertProviderMethod = (providerName, provider, method) => {
   assertProviderField(providerName, typeof provider[method] === "function", method);
 };
-const findProviderUnsupportedOperator = (value, supportedOperators) => {
-  if (!value || typeof value !== "object") return void 0;
+export const collectPlanFilterOperators = (filter, operators = /* @__PURE__ */ new Set()) => {
+  switch (filter.type) {
+    case "true":
+      break;
+    case "compare":
+      operators.add(`$${filter.operator}`);
+      break;
+    case "and":
+    case "or":
+      for (const clause of filter.clauses) {
+        collectPlanFilterOperators(clause, operators);
+      }
+      break;
+    case "not":
+      collectPlanFilterOperators(filter.clause, operators);
+      break;
+    default:
+      throw new TypeError(`Unknown query filter node: ${filter.type}`);
+  }
+  return operators;
+};
+const findNonJsonValue = (value, path) => {
+  if (value === null || value === void 0) return void 0;
+  const kind = typeof value;
+  if (kind === "string" || kind === "number" || kind === "boolean") return void 0;
+  if (kind === "function" || kind === "bigint" || kind === "symbol") return path;
   if (Array.isArray(value)) {
-    for (const child of value) {
-      const unsupported = findProviderUnsupportedOperator(child, supportedOperators);
-      if (unsupported) return unsupported;
+    for (let index = 0; index < value.length; index += 1) {
+      const offender = findNonJsonValue(value[index], `${path}[${index}]`);
+      if (offender) return offender;
     }
     return void 0;
   }
-  for (const [key, child] of Object.entries(value)) {
-    if (key.startsWith("$") && !supportedOperators.has(key)) return key;
-    const unsupported = findProviderUnsupportedOperator(child, supportedOperators);
-    if (unsupported) return unsupported;
+  if (kind === "object") {
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null) return path;
+    for (const [key, child] of Object.entries(value)) {
+      const offender = findNonJsonValue(child, `${path}.${key}`);
+      if (offender) return offender;
+    }
+    return void 0;
+  }
+  return path;
+};
+export const assertJsonPureProviderQuery = (provider, query) => {
+  if (!import.meta.dev) return;
+  const offender = findNonJsonValue(query, "query");
+  if (offender) {
+    throw createContentProviderError("provider_query_not_json_pure", `${provider.name} received a non-JSON-pure query at ${offender}. Provider queries must survive JSON.parse(JSON.stringify(query)).`, {
+      provider: provider.name,
+      field: offender
+    });
   }
 };
 const assertProviderQuerySupported = (provider, query) => {
-  const capabilities = provider.capabilities.query;
-  const unsupportedOperator = findProviderUnsupportedOperator(query.where, new Set(capabilities.operators));
-  if (unsupportedOperator) {
-    throw createContentProviderError("unsupported_query_operator", `${provider.name} does not support query operator: ${unsupportedOperator}`, {
+  if (query.v !== PROVIDER_QUERY_VERSION) {
+    throw createContentProviderError("unsupported_query_shape", `${provider.name} received unsupported provider query version: ${String(query.v)}.`, {
       provider: provider.name,
-      operator: unsupportedOperator
+      field: "v"
     });
   }
-  if (!capabilities.limit && query.limit !== void 0) {
+  const capabilities = provider.capabilities.query;
+  const supported = new Set(capabilities.operators);
+  const usedOperators = collectPlanFilterOperators(query.plan.filter);
+  for (const operator of usedOperators) {
+    if (!supported.has(operator)) {
+      throw createContentProviderError("unsupported_query_operator", `${provider.name} does not support query operator: ${operator}`, {
+        provider: provider.name,
+        operator
+      });
+    }
+  }
+  if (!capabilities.limit && query.plan.limit !== void 0) {
     throw createContentProviderError("unsupported_query_shape", `${provider.name} does not support query limits.`, {
       provider: provider.name,
       field: "limit"
     });
   }
-  if (!capabilities.skip && query.skip !== void 0) {
+  if (!capabilities.skip && query.plan.skip > 0) {
     throw createContentProviderError("unsupported_query_shape", `${provider.name} does not support query offsets.`, {
       provider: provider.name,
       field: "skip"
     });
   }
-  if (!capabilities.count && query.count === true) {
+  if (!capabilities.count && query.plan.mode === "count") {
     throw createContentProviderError("unsupported_query_shape", `${provider.name} does not support count queries.`, {
       provider: provider.name,
       field: "count"
@@ -75,15 +124,18 @@ const assertProviderOperationSupported = (provider, supported, operation) => {
     });
   }
 };
-const enforceProviderCapabilities = (provider) => ({
+export const enforceProviderCapabilities = (provider) => ({
   ...provider,
   query: async (event, query) => {
+    assertJsonPureProviderQuery(provider, query);
     assertProviderQuerySupported(provider, query);
     return await provider.query(event, query);
   },
-  navigationQuery: provider.navigationQuery ? async (...args) => {
+  navigationQuery: provider.navigationQuery ? async (event, query, options) => {
     assertProviderOperationSupported(provider, provider.capabilities.navigation, "navigation");
-    return await provider.navigationQuery(...args);
+    assertJsonPureProviderQuery(provider, query);
+    assertProviderQuerySupported(provider, query);
+    return await provider.navigationQuery(event, query, options);
   } : void 0,
   navigation: provider.navigation ? async (...args) => {
     assertProviderOperationSupported(provider, provider.capabilities.navigation, "navigation");

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

@@ -1,12 +1,12 @@
 import type { H3Event } from 'h3';
 import type { ParsedContent } from '../../types/content';
 import type { ContentCollectionHandle } from '../../types/config';
-import type { BacklinksOptions, BacklinksResult, BacklinkSource, ContentVariant, ContentTreeItem, DocumentFromHandle, ManyOptions, LocalizedDoc, NeighborsOptions, NeighborsResult, OneOptions, PopulateSpec, PopulateFromOptions, PopulatedDocument, PaginationOptions, PaginationResult, ResolveOneOptions, ResolveOneResult, TreeOptions, VariantsOptions } from '../../types/query';
-import { type ContentQueryContext } from '../query/unified';
+import type { BacklinksOptions, BacklinksResult, BacklinkSource, ContentVariant, ContentTreeItem, DocumentFromHandle, ManyOptions, LocalizedDoc, NeighborsOptions, NeighborsResult, OneOptions, OptionsArg, PopulateSpec, PopulateFromOptions, PopulatedDocument, PaginationOptions, PaginationResult, ResolveOneOptions, ResolveOneResult, TreeOptions, VariantsOptions } from '../../types/query';
+import { type ContentQueryContext } from '../../features/query/unified';
 export declare const createServerContentQueryContext: (event: H3Event) => Promise<ContentQueryContext>;
 export declare function resolveOne<const H extends ContentCollectionHandle | string, O extends ResolveOneOptions<H, PopulateSpec | undefined>>(event: H3Event, handle: H, options: O): Promise<ResolveOneResult<PopulatedDocument<DocumentFromHandle<H>, PopulateFromOptions<O>>>>;
 export declare function one<const H extends ContentCollectionHandle | string, O extends OneOptions<H, PopulateSpec | undefined>>(event: H3Event, handle: H, options: O): Promise<LocalizedDoc<PopulatedDocument<DocumentFromHandle<H>, PopulateFromOptions<O>>> | null>;
-export declare function many<const H extends ContentCollectionHandle | string, O extends ManyOptions<H, PopulateSpec | undefined>>(event: H3Event, handle: H, options?: O): Promise<Array<LocalizedDoc<PopulatedDocument<DocumentFromHandle<H>, PopulateFromOptions<O>>>>>;
+export declare function many<const H extends ContentCollectionHandle | string, O extends ManyOptions<H, PopulateSpec | undefined>>(event: H3Event, handle: H, ...args: OptionsArg<H, O>): Promise<Array<LocalizedDoc<PopulatedDocument<DocumentFromHandle<H>, PopulateFromOptions<O>>>>>;
 export declare function paginate<const H extends ContentCollectionHandle | string, O extends PaginationOptions<H, PopulateSpec | undefined>>(event: H3Event, handle: H, options: O): Promise<PaginationResult<PopulatedDocument<DocumentFromHandle<H>, PopulateFromOptions<O>>>>;
 export declare function backlinks<const Target extends ContentCollectionHandle | string, const Source extends BacklinkSource | ReadonlyArray<BacklinkSource>, P extends PopulateSpec | undefined = undefined>(event: H3Event, handle: Target, options: BacklinksOptions<Target, Source, P>): Promise<BacklinksResult<Source, P>>;
 export declare function variants<H extends ContentCollectionHandle | string>(event: H3Event, handle: H, options: VariantsOptions<H>): Promise<Array<ContentVariant<H extends {
@@ -14,9 +14,9 @@ export declare function variants<H extends ContentCollectionHandle | string>(eve
         _output: infer O;
     };
 } ? O & ParsedContent : ParsedContent>>>;
-export declare function tree<H extends ContentCollectionHandle | string, Fields extends ReadonlyArray<string> | undefined = undefined>(event: H3Event, handle: H, options?: Omit<TreeOptions<H>, 'fields'> & {
+export declare function tree<H extends ContentCollectionHandle | string, Fields extends ReadonlyArray<string> | undefined = undefined>(event: H3Event, handle: H, ...args: OptionsArg<H, Omit<TreeOptions<H>, 'fields'> & {
     fields?: Fields;
-}): Promise<ContentTreeItem<H extends {
+}>): Promise<ContentTreeItem<H extends {
     __schema: {
         _output: infer O;
     };

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

@@ -7,11 +7,11 @@ import {
   resolveOne as resolveOneWithContext,
   tree as treeWithContext,
   variants as variantsWithContext
-} from "../query/unified.js";
+} from "../../features/query/unified";
 import { getContentProvider } from "./providers/index.js";
 import { createContentProviderError } from "../../public/provider-errors";
 import { getContentRuntimeConfig } from "./runtime-config.js";
-import { normalizeProviderQueryResponse } from "./provider-query.js";
+import { createProviderNavigationQuery, createProviderQuery, normalizeProviderQueryResponse } from "./provider-query.js";
 export const createServerContentQueryContext = async (event) => {
   const provider = await getContentProvider(event);
   return {
@@ -23,9 +23,10 @@ export const createServerContentQueryContext = async (event) => {
             provider: provider.name
           });
         }
-        return await provider.navigationQuery(event, params);
+        const { query, options } = createProviderNavigationQuery(params);
+        return await provider.navigationQuery(event, query, options);
       }
-      return normalizeProviderQueryResponse(params, await provider.query(event, params), provider.name);
+      return normalizeProviderQueryResponse(params, await provider.query(event, createProviderQuery(params)), provider.name);
     }
   };
 };
@@ -35,7 +36,8 @@ export async function resolveOne(event, handle, options) {
 export async function one(event, handle, options) {
   return await oneWithContext(await createServerContentQueryContext(event), handle, options);
 }
-export async function many(event, handle, options = {}) {
+export async function many(event, handle, ...args) {
+  const options = args[0] ?? {};
   return await manyWithContext(await createServerContentQueryContext(event), handle, options);
 }
 export async function paginate(event, handle, options) {
@@ -47,7 +49,8 @@ export async function backlinks(event, handle, options) {
 export async function variants(event, handle, options) {
   return await variantsWithContext(await createServerContentQueryContext(event), handle, options);
 }
-export async function tree(event, handle, options = {}) {
+export async function tree(event, handle, ...args) {
+  const options = args[0] ?? {};
   return await treeWithContext(await createServerContentQueryContext(event), handle, options);
 }
 export async function neighbors(event, handle, options) {

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

@@ -1,5 +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<ContentQueryResponse<T>>;
-export declare const executeContentQuery: <T = unknown>(event: H3Event, inputQuery: ContentQueryBuilderParams) => Promise<ContentQueryResponse<T>>;
+import type { ContentQueryPlan } from '../../core/query/plan';
+export declare const executeFilesystemContentQuery: <T = unknown>(event: H3Event, inputPlan: ContentQueryPlan) => Promise<ContentQueryResponse<T>>;
+export declare const executeContentQuery: <T = unknown>(event: H3Event, inputPlan: ContentQueryPlan) => Promise<ContentQueryResponse<T>>;

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

@@ -1,34 +1,30 @@
 import { createError } from "h3";
-import { lowerQueryPlan } from "../../core/query/lower";
+import { isPlanRegex } from "../../core/query/plan";
 import { executeQueryPlan } from "../../core/query/execute";
 import { ContentError } from "../../core/errors";
-import { normalizeContentQueryParams } from "../../core/query/params";
-import { compileWhere } from "../../core/query/filter";
-import { containsStandaloneRegexOptions, findUnsupportedQueryOperator } from "../../core/query/operators";
 import { withResolvedRefs, withResolvedRefsList } from "../../storage/references";
 import { getContentGraph } from "../../storage/graph";
 import { getContentRuntimeConfig } from "./runtime-config.js";
 import { isPreview } from "../../integrations/nitro/preview";
-import { createContentProviderError } from "../../public/provider-errors";
-import { MAX_PUBLIC_QUERY_LIMIT, MAX_PUBLIC_QUERY_SKIP } from "../query/public-limits.js";
-const notFound = (query, description = "Could not find document for the given query.") => {
+import { MAX_PUBLIC_QUERY_LIMIT, MAX_PUBLIC_QUERY_SKIP } from "../../features/query/public-limits";
+const notFound = (plan, description = "Could not find document for the given query.") => {
   throw createError({
     statusMessage: "Document not found!",
     statusCode: 404,
     data: {
       description,
-      query
+      query: plan
     }
   });
 };
 const statusForContentError = {
   INVALID_REF_VALUE: 422
 };
-const toHttpError = (error, query) => createError({
+const toHttpError = (error, plan) => createError({
   statusCode: statusForContentError[error.code] ?? 500,
   statusMessage: error.code,
   message: error.message,
-  data: { code: error.code, context: error.context, query }
+  data: { code: error.code, context: error.context, query: plan }
 });
 const badQuery = (message) => {
   throw createError({
@@ -37,71 +33,59 @@ const badQuery = (message) => {
     message
   });
 };
-const containsPublicRegex = (value) => {
-  if (value instanceof RegExp) {
-    return true;
+const planFilterContainsRegex = (filter) => {
+  switch (filter.type) {
+    case "true":
+      return false;
+    case "compare":
+      return filter.operator === "regex" || isPlanRegex(filter.value);
+    case "and":
+    case "or":
+      return filter.clauses.some(planFilterContainsRegex);
+    case "not":
+      return planFilterContainsRegex(filter.clause);
+    default:
+      throw new TypeError(`Unknown query filter node: ${filter.type}`);
   }
-  if (!value || typeof value !== "object") {
-    return false;
-  }
-  if (Array.isArray(value)) {
-    return value.some(containsPublicRegex);
-  }
-  const record = value;
-  return Object.entries(record).some(([key, child]) => key === "$regex" || containsPublicRegex(child));
 };
-const normalizePublicQuery = (event, query, config) => {
-  if (!query.collection) {
+const andPlanFilters = (base, ...extra) => {
+  const clauses = [base, ...extra].filter((clause) => clause.type !== "true");
+  if (!clauses.length) return { type: "true" };
+  if (clauses.length === 1) return clauses[0];
+  return { type: "and", clauses };
+};
+const applyFilesystemQueryPolicy = (event, plan) => {
+  if (!plan.collection) {
     badQuery("Public content queries must target a collection.");
   }
-  if (containsPublicRegex(query.where)) {
+  if (planFilterContainsRegex(plan.filter)) {
     badQuery("Public content queries do not accept RegExp filters.");
   }
-  if (containsStandaloneRegexOptions(query.where)) {
-    badQuery("Query operator $options requires $regex.");
-  }
   const enforceProductionVisibility = !import.meta.dev && !isPreview(event);
-  const normalized = normalizeContentQueryParams({
-    ...query,
-    limit: typeof query.limit === "number" ? Math.max(0, Math.min(query.limit, MAX_PUBLIC_QUERY_LIMIT)) : query.limit,
-    skip: typeof query.skip === "number" ? Math.max(0, Math.min(query.skip, MAX_PUBLIC_QUERY_SKIP)) : query.skip
-  }, {
-    collectionI18n: query.collection ? config.collections?.[query.collection]?.i18n : void 0,
-    defaultLocale: config.defaultLocale,
-    localeFallback: config.localeFallback,
-    includeDraftFilter: false
-  });
-  if (enforceProductionVisibility) {
-    const where = Array.isArray(normalized.where) ? normalized.where : normalized.where ? [normalized.where] : [];
-    normalized.where = [
-      ...where,
-      { _draft: { $ne: true } },
-      { _partial: { $ne: true } }
-    ];
-  }
-  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}`, {
-      operator: unsupported
-    });
-  }
-  return normalized;
+  const filter = enforceProductionVisibility ? andPlanFilters(
+    plan.filter,
+    { type: "compare", field: "draft", operator: "ne", value: true },
+    { type: "compare", field: "partial", operator: "ne", value: true }
+  ) : plan.filter;
+  return {
+    ...plan,
+    filter,
+    limit: typeof plan.limit === "number" ? Math.max(0, Math.min(plan.limit, MAX_PUBLIC_QUERY_LIMIT)) : plan.limit,
+    skip: Math.max(0, Math.min(plan.skip, MAX_PUBLIC_QUERY_SKIP))
+  };
 };
-export const executeFilesystemContentQuery = async (event, inputQuery) => {
+export const executeFilesystemContentQuery = async (event, inputPlan) => {
   const config = getContentRuntimeConfig().content || {};
-  const query = normalizePublicQuery(event, inputQuery, config);
+  const plan = applyFilesystemQueryPolicy(event, inputPlan);
   let graph;
   try {
     graph = await getContentGraph(event);
   } catch (cause) {
     if (cause instanceof ContentError) {
-      throw toHttpError(cause, query);
+      throw toHttpError(cause, plan);
     }
     throw cause;
   }
-  const plan = lowerQueryPlan(query);
   const response = executeQueryPlan(graph, plan, {
     defaultLocale: config.defaultLocale,
     localeFallback: config.localeFallback,
@@ -114,7 +98,7 @@ export const executeFilesystemContentQuery = async (event, inputQuery) => {
   if (plan.mode === "first") {
     const content = response.result;
     if (!content) {
-      notFound(query, plan.resolveVariant ? "Could not find document for the given route variant." : void 0);
+      notFound(plan, plan.resolveVariant ? "Could not find document for the given route variant." : void 0);
     }
     return {
       result: await withResolvedRefs(event, content, requestedLocale)

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

@@ -3,7 +3,7 @@ import type { ParsedContent } from '../../types/content';
 import type { ContentQueryBuilderWhere } from '../../types/query';
 import type { ContentSearchIndexRecord } from '../../types/search';
 export { searchRecords } from '../shared/search';
-type SearchablePage = Pick<ParsedContent, '_path' | '_locale' | 'title' | 'description' | 'body'> & Record<string, unknown>;
+type SearchablePage = Pick<ParsedContent, 'path' | 'locale' | 'title' | 'description' | 'body'> & Record<string, unknown>;
 type RuntimeSearchConfig = {
     search?: {
         collections?: string[];

package/dist/runtime/server/search.js

@@ -39,7 +39,7 @@ const rememberSearchRecords = (cacheKey, records) => {
   }
 };
 const mergeSearchFilter = (filterQuery, locale) => {
-  const localeFilter = locale ? { _locale: locale } : void 0;
+  const localeFilter = locale ? { locale } : void 0;
   if (filterQuery && localeFilter) {
     return { $and: [filterQuery, localeFilter] };
   }
@@ -50,7 +50,7 @@ export async function serverSearchContent(event, filterQuery, locale, collection
   const collections = resolveSearchCollections(runtimeConfig.content, collectionsOverride);
   const results = await Promise.all(collections.map(async (collection) => {
     const loadPages = async (queryLocale) => {
-      const query = serverQueryCollection(event, collection).select("_path", "_locale", "title", "description", "body");
+      const query = serverQueryCollection(event, collection).select("path", "locale", "title", "description", "body");
       const mergedFilter = mergeSearchFilter(filterQuery, queryLocale);
       if (mergedFilter) {
         return await query.where(mergedFilter).find();
@@ -84,7 +84,7 @@ const toSearchRecord = (section) => {
     content: section.content,
     headings: section.titles,
     anchor: anchor || void 0,
-    locale: typeof section._locale === "string" ? section._locale : void 0
+    locale: typeof section.locale === "string" ? section.locale : void 0
   };
 };
 const buildProviderSearchSections = async (event, collections, provider, opts) => {
@@ -92,7 +92,7 @@ const buildProviderSearchSections = async (event, collections, provider, opts) =
   const sections = await Promise.all(collections.map(async (collection) => {
     const loadCollectionLocale = async (locale) => (await provider.searchSections(event, collection, {
       ignoredTags: opts.ignoredTags || [],
-      extraFields: unique(["_locale", ...opts.extraFields || []]),
+      extraFields: unique(["locale", ...opts.extraFields || []]),
       filterQuery: opts.filterQuery,
       locale
     })).map((section) => ({

package/dist/runtime/server/sitemap.js

@@ -6,11 +6,11 @@ import { serverQueryCollection } from "./storage.js";
 import { contentConfig } from "./storage-access.js";
 import { resolveCollectionI18n } from "../../features/localization/path";
 const sitemapPageFields = [
-  "_path",
-  "_file",
-  "_locale",
-  "_draft",
-  "_canonicalKey",
+  "path",
+  "file",
+  "locale",
+  "draft",
+  "canonicalKey",
   "sitemap",
   "image",
   "seo",

package/dist/runtime/server/storage-access.d.ts

@@ -1 +1,4 @@
-export { cacheParsedStorage, cacheStorage, contentConfig, contentIgnorePredicate, getContentsIds, resolveStorageId, sourceStorage } from '../../integrations/nitro/storage';
+import type { H3Event } from 'h3';
+import { cacheParsedStorage, cacheStorage, contentConfig, contentIgnorePredicate, getSourceContentIds, resolveStorageId, sourceStorage } from '../../integrations/nitro/storage';
+export declare const getContentsIds: (event: H3Event, prefix?: string) => Promise<string[]>;
+export { cacheParsedStorage, cacheStorage, contentConfig, contentIgnorePredicate, getSourceContentIds, resolveStorageId, sourceStorage };

package/dist/runtime/server/storage-access.js

@@ -1,9 +1,34 @@
-export {
+import { splitInlineLocaleVariantId } from "../../core/content/locale";
+import {
   cacheParsedStorage,
   cacheStorage,
   contentConfig,
   contentIgnorePredicate,
-  getContentsIds,
+  getContentsIds as getStorageContentsIds,
+  getSourceContentIds,
   resolveStorageId,
   sourceStorage
 } from "../../integrations/nitro/storage";
+import { getProcessDocuments, usesProcessSnapshot } from "../../storage/snapshot-runtime";
+export const getContentsIds = async (event, prefix) => {
+  if (!usesProcessSnapshot) {
+    return getStorageContentsIds(event, prefix);
+  }
+  const ids = /* @__PURE__ */ new Set();
+  for (const document of await getProcessDocuments(event)) {
+    const { sourceId } = splitInlineLocaleVariantId(document.id);
+    if (!prefix || sourceId.startsWith(prefix)) {
+      ids.add(sourceId);
+    }
+  }
+  return [...ids];
+};
+export {
+  cacheParsedStorage,
+  cacheStorage,
+  contentConfig,
+  contentIgnorePredicate,
+  getSourceContentIds,
+  resolveStorageId,
+  sourceStorage
+};

package/dist/runtime/transformers/component-resolver.d.ts

@@ -6,5 +6,5 @@ export declare function loadComponents(node: ParsedContent['body'] | {
     props?: Record<string, unknown>;
     children?: Array<ParsedContent['body']>;
 } | null, tags: Record<string, string>): [string, unknown][];
-declare const _default: import("../../types").ContentTransformer;
+declare const _default: import("../../types/content").ContentTransformer;
 export default _default;

package/dist/storage/content.d.ts

@@ -1,5 +1,5 @@
 import type { H3Event } from 'h3';
-import type { ParsedContent } from '../types/content';
+import type { ContentDocumentResolution, ParsedContent } from '../types/content';
 import type { ContentCollectionMap, ContentLocaleEntry, ContentQueryBuilderParams, ContentQueryFetcher, CollectionQueryBuilder, ResolveContentReferenceOptions } from '../types/query';
 export declare const createServerQueryFetch: <T = ParsedContent>(event: H3Event) => ContentQueryFetcher<T>;
 /**
@@ -19,11 +19,7 @@ export declare const createServerQueryFetch: <T = ParsedContent>(event: H3Event)
  * ```
  */
 export declare const resolveContentReference: <T = ParsedContent>(event: H3Event, reference: string, options?: ResolveContentReferenceOptions) => Promise<(T & {
-    _requestedLocale?: string;
-    _resolvedLocale?: string;
-    _fallback?: boolean;
-    _availableLocales?: string[];
-    _variantPaths?: Record<string, string>;
+    resolved?: ContentDocumentResolution;
 }) | null>;
 export declare const createServerContentQuery: <T = ParsedContent>(event: H3Event, query?: string | ContentQueryBuilderParams, ...pathParts: string[]) => import("../types/query").ContentQueryBuilder<T>;
 export declare function serverQueryCollection<K extends keyof ContentCollectionMap & string>(event: H3Event, collection: K): CollectionQueryBuilder<ContentCollectionMap[K]>;