content-query 0.1.0 → 0.3.0

package/dist/query.d.mts

@@ -1,45 +1,44 @@
-import { a as RelationalWhere, c as Fields, d as Scalar, f as ScalarField, g as Expression, h as Where, i as RelationalQueryResult, l as Ordered, m as SelectionResult, n as RelationalQueries, o as Adjacent, p as Selection, r as RelationalQueryOptions, s as Field, t as RelationalCountOptions } from "./relational-types-DLniKi5S.mjs";
-
+import { a as RelationalWhere, c as Fields, d as Scalar, f as ScalarField, g as Expression, h as Where, i as RelationalQueryResult, l as Ordered, m as SelectionResult, n as RelationalQueries, o as Adjacent, p as Selection, r as RelationalQueryOptions, s as Field, t as RelationalCountOptions } from "./relational-types-B45zM34W.mjs";
 //#region src/query/operators.d.ts
 /** Matches a scalar using strict value/date equality. */
-declare function eq<Value>(field: ScalarField<Value>, value: NoInfer<Value>): Expression;
+export declare function eq<Value>(field: ScalarField<Value>, value: NoInfer<Value>): Expression;
 /** Negates scalar equality. */
-declare function ne<Value>(field: ScalarField<Value>, value: NoInfer<Value>): Expression;
+export declare function ne<Value>(field: ScalarField<Value>, value: NoInfer<Value>): Expression;
 /** Matches values greater than the supplied scalar. */
-declare function gt<Value>(field: Field<Value> & Ordered<Value>, value: NoInfer<NonNullable<Value>>): Expression;
+export declare function gt<Value>(field: Field<Value> & Ordered<Value>, value: NoInfer<NonNullable<Value>>): Expression;
 /** Matches values greater than or equal to the supplied scalar. */
-declare function gte<Value>(field: Field<Value> & Ordered<Value>, value: NoInfer<NonNullable<Value>>): Expression;
+export declare function gte<Value>(field: Field<Value> & Ordered<Value>, value: NoInfer<NonNullable<Value>>): Expression;
 /** Matches values less than the supplied scalar. */
-declare function lt<Value>(field: Field<Value> & Ordered<Value>, value: NoInfer<NonNullable<Value>>): Expression;
+export declare function lt<Value>(field: Field<Value> & Ordered<Value>, value: NoInfer<NonNullable<Value>>): Expression;
 /** Matches values less than or equal to the supplied scalar. */
-declare function lte<Value>(field: Field<Value> & Ordered<Value>, value: NoInfer<NonNullable<Value>>): Expression;
+export declare function lte<Value>(field: Field<Value> & Ordered<Value>, value: NoInfer<NonNullable<Value>>): Expression;
 /** Matches one of a list of scalar choices. */
-declare function inArray<Value>(field: ScalarField<Value>, values: readonly NoInfer<Value>[]): Expression;
+export declare function inArray<Value>(field: ScalarField<Value>, values: readonly NoInfer<Value>[]): Expression;
 /** Matches none of a list of scalar choices. */
-declare function notInArray<Value>(field: ScalarField<Value>, values: readonly NoInfer<Value>[]): Expression;
+export declare function notInArray<Value>(field: ScalarField<Value>, values: readonly NoInfer<Value>[]): Expression;
 /** Matches a literal substring, without SQL wildcard interpretation. */
-declare function contains<Value>(field: Field<Value> & (NonNullable<Value> extends string ? unknown : never), value: string): Expression;
+export declare function contains<Value>(field: Field<Value> & (NonNullable<Value> extends string ? unknown : never), value: string): Expression;
 /** Matches a literal string prefix. */
-declare function startsWith<Value>(field: Field<Value> & (NonNullable<Value> extends string ? unknown : never), value: string): Expression;
+export declare function startsWith<Value>(field: Field<Value> & (NonNullable<Value> extends string ? unknown : never), value: string): Expression;
 /** Matches a literal string suffix. */
-declare function endsWith<Value>(field: Field<Value> & (NonNullable<Value> extends string ? unknown : never), value: string): Expression;
+export declare function endsWith<Value>(field: Field<Value> & (NonNullable<Value> extends string ? unknown : never), value: string): Expression;
 /** Tests scalar membership in an array, ignoring holes. */
-declare function arrayContains<Value extends Scalar>(field: Field<readonly Value[] | null | undefined>, value: NoInfer<Value>): Expression;
+export declare function arrayContains<Value extends Scalar>(field: Field<readonly Value[] | null | undefined>, value: NoInfer<Value>): Expression;
 /** Tests whether any candidate belongs to an existing scalar array. */
-declare function arrayContainsAny<Value extends Scalar>(field: Field<readonly Value[] | null | undefined>, values: readonly NoInfer<Value>[]): Expression;
+export declare function arrayContainsAny<Value extends Scalar>(field: Field<readonly Value[] | null | undefined>, values: readonly NoInfer<Value>[]): Expression;
 /** Tests whether every candidate belongs to an existing scalar array. */
-declare function arrayContainsAll<Value extends Scalar>(field: Field<readonly Value[] | null | undefined>, values: readonly NoInfer<Value>[]): Expression;
+export declare function arrayContainsAll<Value extends Scalar>(field: Field<readonly Value[] | null | undefined>, values: readonly NoInfer<Value>[]): Expression;
 /** Checks explicit null independently from undefined and absence. */
-declare function isNull<Value>(field: Field<Value>): Expression;
+export declare function isNull<Value>(field: Field<Value>): Expression;
 /** Checks undefined, including a missing property. */
-declare function isUndefined<Value>(field: Field<Value>): Expression;
+export declare function isUndefined<Value>(field: Field<Value>): Expression;
 /** Checks own-property absence before projection. */
-declare function isMissing<Value>(field: Field<Value>): Expression;
+export declare function isMissing<Value>(field: Field<Value>): Expression;
 /** Requires all child predicates; an empty conjunction is true. */
-declare function and(...expressions: Expression[]): Expression;
+export declare function and(...expressions: Expression[]): Expression;
 /** Requires any child predicate; an empty disjunction is false. */
-declare function or(...expressions: Expression[]): Expression;
+export declare function or(...expressions: Expression[]): Expression;
 /** Negates a predicate's boolean result. */
-declare function not(expression: Expression): Expression;
+export declare function not(expression: Expression): Expression;
 //#endregion
-export { type Adjacent, type RelationalCountOptions as CountOptions, type Expression, type Field, type Fields, type RelationalQueryOptions as QueryOptions, type RelationalQueryOptions, type RelationalQueries, type RelationalQueryResult, type RelationalWhere, type Selection, type SelectionResult, type Where, and, arrayContains, arrayContainsAll, arrayContainsAny, contains, endsWith, eq, gt, gte, inArray, isMissing, isNull, isUndefined, lt, lte, ne, not, notInArray, or, startsWith };
+export type { Adjacent, RelationalCountOptions as CountOptions, Expression, Field, Fields, RelationalQueryOptions as QueryOptions, RelationalQueryOptions, RelationalQueries, RelationalQueryResult, RelationalWhere, Selection, SelectionResult, Where };

package/dist/query.mjs

@@ -1,2 +1 @@
-import { _ as not, a as contains, b as startsWith, c as gt, d as isMissing, f as isNull, g as ne, h as lte, i as arrayContainsAny, l as gte, m as lt, n as arrayContains, o as endsWith, p as isUndefined, r as arrayContainsAll, s as eq, t as and, u as inArray, v as notInArray, y as or } from "./operators-BQpLfJlx.mjs";
-export { and, arrayContains, arrayContainsAll, arrayContainsAny, contains, endsWith, eq, gt, gte, inArray, isMissing, isNull, isUndefined, lt, lte, ne, not, notInArray, or, startsWith };
+export { t as and, n as arrayContains, r as arrayContainsAll, i as arrayContainsAny, a as contains, o as endsWith, s as eq, c as gt, l as gte, u as inArray, d as isMissing, f as isNull, p as isUndefined, m as lt, h as lte, g as ne, _ as not, v as notInArray, y as or, b as startsWith } from "./operators-UqWUhKQJ.mjs";

package/dist/{relational-types-DLniKi5S.d.mts → relational-types-B45zM34W.d.mts}

@@ -1,5 +1,4 @@
-import { a as Relationship, i as QueryData, n as CollectionRegistry, o as RelationshipsOf } from "./types-BPh2cBPs.mjs";
-
+import { c as Relationship, i as CollectionRegistry, l as RelationshipsOf, o as PayloadsOf, s as QueryData } from "./types-BC8gVJ6u.mjs";
 //#region src/query/plan.d.ts
 type PredicateOperator = "eq" | "ne" | "gt" | "gte" | "lt" | "lte" | "in-array" | "not-in-array" | "contains" | "starts-with" | "ends-with" | "like" | "ilike" | "array-contains" | "array-contains-any" | "array-contains-all" | "array-contained" | "is-null" | "is-undefined" | "is-missing";
 type Expression = {
@@ -31,9 +30,21 @@ type QueryPlan = {
   offset?: number;
   with: Readonly<Record<string, QueryPlan>>;
   adjacent?: true | QueryPlan;
+  /** Payloads to attach under `_payloads` after filtering, ordering, and pagination. */
+  payloads?: Readonly<Record<string, PlanPayload>>;
+};
+/** One requested payload; variant keys are empty for payloads without variants. */
+type PlanPayload = {
+  variant: Readonly<Record<string, string>>;
+};
+/** Describes a payload that queries may request, without its resolver or schema. */
+type PayloadDescriptor = {
+  variants: readonly string[];
 };
 type QueryRegistry = Record<string, {
   relationships: Record<string, Relationship>;
+  /** Payload names available to queries; omitted when the collection has none. */
+  payloads?: Record<string, PayloadDescriptor>;
 }>;
 //#endregion
 //#region src/query/types.d.ts
@@ -43,11 +54,11 @@ type Field$1<Value> = {
   readonly name: string;
   readonly [fieldType]: Value;
 };
-type Fields<Data> = { readonly [Name in keyof Data]-?: Field$1<Data[Name]> };
+type Fields<Data> = { readonly [Name in keyof Data]-?: Field$1<Data[Name]>; };
 type Scalar = string | number | bigint | boolean | Date | null | undefined;
 type ScalarField<Value> = Field$1<Value> & ([Value] extends [Scalar] ? unknown : never);
 type Ordered<Value> = NonNullable<Value> extends string ? unknown : NonNullable<Value> extends number ? unknown : NonNullable<Value> extends bigint ? unknown : NonNullable<Value> extends Date ? unknown : never;
-type SortKey<Data> = { [Name in keyof Data]-?: Ordered<Data[Name]> extends never ? NonNullable<Data[Name]> extends boolean ? Name : never : Name }[keyof Data] & string;
+type SortKey<Data> = { [Name in keyof Data]-?: Ordered<Data[Name]> extends never ? NonNullable<Data[Name]> extends boolean ? Name : never : Name; }[keyof Data] & string;
 type QueryInfo<Result = unknown, Selected extends boolean = boolean, Filtered extends boolean = boolean> = {
   readonly [queryType]: {
     result: Result;
@@ -55,7 +66,13 @@ type QueryInfo<Result = unknown, Selected extends boolean = boolean, Filtered ex
     filtered: Filtered;
   };
 };
-type Simplify$1<Value> = { [Key in keyof Value]: Value[Key] };
+type Simplify$1<Value> = { [Key in keyof Value]: Value[Key]; };
+/** Adds one requested payload to a result's `_payloads`, keeping earlier requests. */
+type WithPayload<Result, Key extends PropertyKey, Value> = Omit<Result, "_payloads"> & {
+  _payloads: Simplify$1<(Result extends {
+    _payloads: infer Existing;
+  } ? Existing : {}) & { [Name in Key]: Value; }>;
+};
 type ResultOf<Configured> = Configured extends QueryInfo<infer Result> ? Result : never;
 type FilteredOf<Configured> = Configured extends QueryInfo<unknown, boolean, infer Filtered> ? Filtered : false;
 type RelationOf<Registry extends CollectionRegistry, Name extends keyof Registry, Key extends keyof RelationshipsOf<Registry[Name]>> = RelationshipsOf<Registry[Name]>[Key] & Relationship;
@@ -64,15 +81,17 @@ type RelatedName$1<Registry extends CollectionRegistry, Relation extends Relatio
 type RelationshipResult<Definition, Relation extends Relationship, Result, Filtered extends boolean = false> = Relation["type"] extends "many" ? Result[] : Result | (Filtered extends true ? null : Relation["referenceSide"] extends "from" ? Relation["from"] extends keyof QueryData<Definition> ? null extends QueryData<Definition>[Relation["from"]] ? null : undefined extends QueryData<Definition>[Relation["from"]] ? null : never : null : null);
 type RelationValue<Definition, Relation extends Relationship, Configured> = RelationshipResult<Definition, Relation, ResultOf<Configured>, FilteredOf<Configured>>;
 type Query<Registry extends CollectionRegistry, Name extends keyof Registry & string, Result = {}, Selected extends boolean = false, Many extends boolean = true, Root extends boolean = true, Filtered extends boolean = false, AllowAdjacent extends boolean = true, Pagination extends boolean = true> = QueryInfo<Result, Selected, Filtered> & {
-  select<const Keys extends readonly [keyof QueryData<Registry[Name]> & string, ...(keyof QueryData<Registry[Name]> & string)[]]>(...keys: Keys): Query<Registry, Name, { [Key in Exclude<keyof Result, keyof QueryData<Registry[Name]>> | Keys[number]]: Key extends Keys[number] ? QueryData<Registry[Name]>[Key & keyof QueryData<Registry[Name]>] : Key extends keyof Result ? Result[Key] : never }, true, Many, Root, Filtered, AllowAdjacent, Pagination>;
+  select<const Keys extends readonly [keyof QueryData<Registry[Name]> & string, ...(keyof QueryData<Registry[Name]> & string)[]]>(...keys: Keys): Query<Registry, Name, { [Key in Exclude<keyof Result, keyof QueryData<Registry[Name]>> | Keys[number]]: Key extends Keys[number] ? QueryData<Registry[Name]>[Key & keyof QueryData<Registry[Name]>] : Key extends keyof Result ? Result[Key] : never; }, true, Many, Root, Filtered, AllowAdjacent, Pagination>;
   where(configure: (fields: Fields<QueryData<Registry[Name]>>) => Expression): Query<Registry, Name, Result, Selected, Many, Root, true, AllowAdjacent, Pagination>;
-  with<Key extends keyof RelationshipsOf<Registry[Name]> & string, Configured extends QueryInfo<unknown, true>>(name: Key, configure: (query: Query<Registry, RelatedName$1<Registry, RelationOf<Registry, Name, Key>>, {}, false, RelationOf<Registry, Name, Key>["type"] extends "many" ? true : false, false, false, AllowAdjacent>) => Configured): Query<Registry, Name, Result & { [Property in Key]: RelationValue<Registry[Name], RelationOf<Registry, Name, Key>, Configured> }, true, Many, Root, Filtered, AllowAdjacent, Pagination>;
+  with<Key extends keyof RelationshipsOf<Registry[Name]> & string, Configured extends QueryInfo<unknown, true>>(name: Key, configure: (query: Query<Registry, RelatedName$1<Registry, RelationOf<Registry, Name, Key>>, {}, false, RelationOf<Registry, Name, Key>["type"] extends "many" ? true : false, false, false, AllowAdjacent>) => Configured): Query<Registry, Name, Result & { [Property in Key]: RelationValue<Registry[Name], RelationOf<Registry, Name, Key>, Configured>; }, true, Many, Root, Filtered, AllowAdjacent, Pagination>;
 } & (Many extends true ? {
   orderBy(field: SortKey<QueryData<Registry[Name]>>, direction?: "asc" | "desc"): Query<Registry, Name, Result, Selected, Many, Root, Filtered, AllowAdjacent, Pagination>;
 } : {}) & (Many extends true ? Pagination extends true ? {
   limit(value: number): Query<Registry, Name, Result, Selected, Many, Root, Filtered, AllowAdjacent, Pagination>;
   offset(value: number): Query<Registry, Name, Result, Selected, Many, Root, Filtered, AllowAdjacent, Pagination>;
 } : {} : {}) & (AllowAdjacent extends true ? {
+  /** Attaches a payload under `_payloads` after filtering, ordering, and pagination. */
+  withPayload<Key extends keyof PayloadsOf<Registry[Name]> & string>(name: Key): Query<Registry, Name, WithPayload<Result, Key, PayloadsOf<Registry[Name]>[Key]>, Selected, Many, Root, Filtered, AllowAdjacent, Pagination>;
   selectAdjacent(): Query<Registry, Name, Result & {
     _adjacent: Adjacent<{
       id: string;
@@ -89,7 +108,10 @@ type Query<Registry extends CollectionRegistry, Name extends keyof Registry & st
   execute: Selected extends true ? () => Promise<Simplify$1<Result>[]> : never;
   then: Selected extends true ? Promise<Simplify$1<Result>[]>["then"] : never;
   first: Selected extends true ? () => Promise<Simplify$1<Result> | undefined> : never;
-  count(): Promise<number>;
+  /** Counts matching entries; unavailable once payloads are requested. */
+  count: [Result] extends [never] ? () => Promise<number> : [Result] extends [{
+    _payloads: unknown;
+  }] ? never : () => Promise<number>;
 } : {});
 type Adjacent<Entry> = {
   previous: Entry | null;
@@ -120,7 +142,7 @@ type FieldFilter$1<Value> = PresenceFilter & (NonNullable<Value> extends readonl
   hasSome?: readonly Item[];
   hasEvery?: readonly Item[];
 } : {} : [Value] extends [Scalar] ? ScalarFilter<Value> : {});
-type Where<Data> = { [Name in keyof Data]?: [Data[Name]] extends [Scalar] ? Data[Name] | FieldFilter$1<Data[Name]> : FieldFilter$1<Data[Name]> } & {
+type Where<Data> = { [Name in keyof Data]?: [Data[Name]] extends [Scalar] ? Data[Name] | FieldFilter$1<Data[Name]> : FieldFilter$1<Data[Name]>; } & {
   AND?: Where<Data> | readonly Where<Data>[];
   OR?: readonly Where<Data>[];
   NOT?: Where<Data> | readonly Where<Data>[];
@@ -137,7 +159,7 @@ type QueryOptions<Registry extends CollectionRegistry, Name extends keyof Regist
   select: Selection<Registry, Name, AllowAdjacent>;
 };
 type AdjacentOptions<Registry extends CollectionRegistry, Name extends keyof Registry & string> = Omit<QueryOptions<Registry, Name, true, false>, "limit" | "offset">;
-type Selection<Registry extends CollectionRegistry, Name extends keyof Registry & string, AllowAdjacent extends boolean = true> = { [Field in keyof QueryData<Registry[Name]>]?: boolean } & { [Key in keyof RelationshipsOf<Registry[Name]>]?: QueryOptions<Registry, RelatedName$1<Registry, RelationOf<Registry, Name, Key>>, RelationOf<Registry, Name, Key>["type"] extends "many" ? true : false, AllowAdjacent> | false } & (AllowAdjacent extends true ? {
+type Selection<Registry extends CollectionRegistry, Name extends keyof Registry & string, AllowAdjacent extends boolean = true> = { [Field in keyof QueryData<Registry[Name]>]?: boolean; } & { [Key in keyof RelationshipsOf<Registry[Name]>]?: QueryOptions<Registry, RelatedName$1<Registry, RelationOf<Registry, Name, Key>>, RelationOf<Registry, Name, Key>["type"] extends "many" ? true : false, AllowAdjacent> | false; } & (AllowAdjacent extends true ? {
   _adjacent?: true | AdjacentOptions<Registry, Name>;
 } : {});
 type ObjectRelationValue<Registry extends CollectionRegistry, Name extends keyof Registry & string, Key extends keyof RelationshipsOf<Registry[Name]>, Options> = Options extends {
@@ -147,13 +169,13 @@ type SelectionResult<Registry extends CollectionRegistry, Name extends keyof Reg
   id: string;
 }> : Projection[Key] extends {
   select: infer Neighbors;
-} ? Adjacent<SelectionResult<Registry, Name, Neighbors>> : never : Key extends keyof RelationshipsOf<Registry[Name]> ? ObjectRelationValue<Registry, Name, Key, Projection[Key]> : Key extends keyof QueryData<Registry[Name]> ? QueryData<Registry[Name]>[Key] : never };
-type CheckedField<Value, Filter> = Filter extends Scalar ? Filter : { [Operator in keyof Filter]: Operator extends keyof FieldFilter$1<Value> ? Operator extends "not" ? CheckedField<Value, Filter[Operator]> : Filter[Operator] : never };
-type CheckedWhereList$1<Data, Filters extends readonly unknown[]> = { [Index in keyof Filters]: CheckedWhere$1<Data, Filters[Index]> };
-type CheckedWhere$1<Data, Filter> = Filter extends ((...arguments_: never[]) => unknown) ? Filter : { [Key in keyof Filter]: Key extends "AND" | "OR" | "NOT" ? Filter[Key] extends readonly unknown[] ? CheckedWhereList$1<Data, Filter[Key]> : CheckedWhere$1<Data, Filter[Key]> : Key extends keyof Data ? CheckedField<Data[Key], Filter[Key]> : never };
-type CheckedSelection<Registry extends CollectionRegistry, Name extends keyof Registry & string, Projection, AllowAdjacent extends boolean> = { [Key in keyof Projection]: Key extends "_adjacent" ? AllowAdjacent extends true ? Projection[Key] extends true ? true : CheckedOptions<Registry, Name, Projection[Key], true, false, false> : never : Key extends keyof RelationshipsOf<Registry[Name]> ? Projection[Key] extends false ? false : CheckedOptions<Registry, RelatedName$1<Registry, RelationOf<Registry, Name, Key>>, Projection[Key], RelationOf<Registry, Name, Key>["type"] extends "many" ? true : false, AllowAdjacent> : Key extends keyof QueryData<Registry[Name]> ? Projection[Key] : never };
+} ? Adjacent<SelectionResult<Registry, Name, Neighbors>> : never : Key extends keyof RelationshipsOf<Registry[Name]> ? ObjectRelationValue<Registry, Name, Key, Projection[Key]> : Key extends keyof QueryData<Registry[Name]> ? QueryData<Registry[Name]>[Key] : never; };
+type CheckedField<Value, Filter> = Filter extends Scalar ? Filter : { [Operator in keyof Filter]: Operator extends keyof FieldFilter$1<Value> ? Operator extends "not" ? CheckedField<Value, Filter[Operator]> : Filter[Operator] : never; };
+type CheckedWhereList$1<Data, Filters extends readonly unknown[]> = { [Index in keyof Filters]: CheckedWhere$1<Data, Filters[Index]>; };
+type CheckedWhere$1<Data, Filter> = Filter extends ((...arguments_: never[]) => unknown) ? Filter : { [Key in keyof Filter]: Key extends "AND" | "OR" | "NOT" ? Filter[Key] extends readonly unknown[] ? CheckedWhereList$1<Data, Filter[Key]> : CheckedWhere$1<Data, Filter[Key]> : Key extends keyof Data ? CheckedField<Data[Key], Filter[Key]> : never; };
+type CheckedSelection<Registry extends CollectionRegistry, Name extends keyof Registry & string, Projection, AllowAdjacent extends boolean> = { [Key in keyof Projection]: Key extends "_adjacent" ? AllowAdjacent extends true ? Projection[Key] extends true ? true : CheckedOptions<Registry, Name, Projection[Key], true, false, false> : never : Key extends keyof RelationshipsOf<Registry[Name]> ? Projection[Key] extends false ? false : CheckedOptions<Registry, RelatedName$1<Registry, RelationOf<Registry, Name, Key>>, Projection[Key], RelationOf<Registry, Name, Key>["type"] extends "many" ? true : false, AllowAdjacent> : Key extends keyof QueryData<Registry[Name]> ? Projection[Key] : never; };
 /** Rejects extra properties throughout inferred options, including recursive neighbor projections. */
-type CheckedOptions<Registry extends CollectionRegistry, Name extends keyof Registry & string, Options, Many extends boolean = true, AllowAdjacent extends boolean = true, Pagination extends boolean = true> = { [Key in keyof Options]: Key extends "select" ? CheckedSelection<Registry, Name, Options[Key], AllowAdjacent> : Key extends "where" ? CheckedWhere$1<QueryData<Registry[Name]>, Options[Key]> : Key extends "limit" | "offset" ? Pagination extends true ? Many extends true ? Options[Key] : never : never : Key extends keyof ObjectScope<Registry, Name, Many> ? Options[Key] : never };
+type CheckedOptions<Registry extends CollectionRegistry, Name extends keyof Registry & string, Options, Many extends boolean = true, AllowAdjacent extends boolean = true, Pagination extends boolean = true> = { [Key in keyof Options]: Key extends "select" ? CheckedSelection<Registry, Name, Options[Key], AllowAdjacent> : Key extends "where" ? CheckedWhere$1<QueryData<Registry[Name]>, Options[Key]> : Key extends "limit" | "offset" ? Pagination extends true ? Many extends true ? Options[Key] : never : never : Key extends keyof ObjectScope<Registry, Name, Many> ? Options[Key] : never; };
 //#endregion
 //#region src/query/relational-types.d.ts
 type RelatedName<Registry extends CollectionRegistry, Name extends keyof Registry, Key extends keyof RelationshipsOf<Registry[Name]>> = (RelationshipsOf<Registry[Name]>[Key] & Relationship)["collection"] & keyof Registry & string;
@@ -193,17 +215,19 @@ type FieldFilter<Value> = {
   arrayContained?: readonly Item[];
 } : {} : {});
 /** Object predicates over prepared fields and existential filters over related entries. */
-type RelationalWhere<Registry extends CollectionRegistry, Name extends keyof Registry & string> = { [Key in keyof QueryData<Registry[Name]>]?: Condition<QueryData<Registry[Name]>[Key]> } & { [Key in keyof RelationshipsOf<Registry[Name]>]?: boolean | RelationalWhere<Registry, RelatedName<Registry, Name, Key>> } & {
+type RelationalWhere<Registry extends CollectionRegistry, Name extends keyof Registry & string> = { [Key in keyof QueryData<Registry[Name]>]?: Condition<QueryData<Registry[Name]>[Key]>; } & { [Key in keyof RelationshipsOf<Registry[Name]>]?: boolean | RelationalWhere<Registry, RelatedName<Registry, Name, Key>>; } & {
   AND?: RelationalWhere<Registry, Name> | readonly RelationalWhere<Registry, Name>[];
   OR?: readonly RelationalWhere<Registry, Name>[];
   NOT?: RelationalWhere<Registry, Name> | readonly RelationalWhere<Registry, Name>[];
   RAW?: (fields: Fields<QueryData<Registry[Name]>>) => Expression;
 };
+/** Payloads to attach under `_payloads`; payloads set to false are omitted. */
+type PayloadOptions<Registry extends CollectionRegistry, Name extends keyof Registry & string> = { [Key in keyof PayloadsOf<Registry[Name]>]?: boolean; };
 /** Collection-scoped metadata queries with Drizzle-style columns, relationships, and filters. */
 type RelationalQueryOptions<Registry extends CollectionRegistry, Name extends keyof Registry & string, Many extends boolean = true, AllowAdjacent extends boolean = true, Pagination extends boolean = true> = {
   columns?: Partial<Record<keyof QueryData<Registry[Name]>, boolean>>;
   where?: RelationalWhere<Registry, Name>;
-  with?: { [Key in keyof RelationshipsOf<Registry[Name]>]?: boolean | RelationalQueryOptions<Registry, RelatedName<Registry, Name, Key>, IsMany<Registry, Name, Key>, AllowAdjacent> };
+  with?: { [Key in keyof RelationshipsOf<Registry[Name]>]?: boolean | RelationalQueryOptions<Registry, RelatedName<Registry, Name, Key>, IsMany<Registry, Name, Key>, AllowAdjacent>; };
 } & (Many extends true ? {
   orderBy?: OrderBy<QueryData<Registry[Name]>>;
 } : {}) & (Many extends true ? (Pagination extends true ? {
@@ -211,15 +235,16 @@ type RelationalQueryOptions<Registry extends CollectionRegistry, Name extends ke
   offset?: number;
 } : {}) : {}) & (AllowAdjacent extends true ? {
   adjacent?: true | RelationalQueryOptions<Registry, Name, true, false, false>;
+  payloads?: PayloadOptions<Registry, Name>;
 } : {});
 /** Options accepted by the root count helper, whose result ignores sorting and pagination. */
 type RelationalCountOptions<Registry extends CollectionRegistry, Name extends keyof Registry & string> = Pick<RelationalQueryOptions<Registry, Name>, "where" | "orderBy" | "offset" | "limit">;
 type ColumnResult<Data, Options> = Options extends {
   columns: infer Columns;
-} ? keyof Columns extends never ? {} : true extends Columns[keyof Columns] ? { -readonly [Key in keyof Columns as Columns[Key] extends false | undefined ? never : Key]-?: Key extends keyof Data ? Data[Key] : never } : Omit<Data, { [Key in keyof Columns]: Columns[Key] extends false ? Key : never }[keyof Columns]> : Data;
+} ? keyof Columns extends never ? {} : true extends Columns[keyof Columns] ? { -readonly [Key in keyof Columns as Columns[Key] extends false | undefined ? never : Key]-?: Key extends keyof Data ? Data[Key] : never; } : Omit<Data, { [Key in keyof Columns]: Columns[Key] extends false ? Key : never; }[keyof Columns]> : Data;
 type IncludedResult<Registry extends CollectionRegistry, Name extends keyof Registry & string, Options> = Options extends {
   with: infer Related;
-} ? { -readonly [Key in keyof Related as Related[Key] extends false | undefined ? never : Key]-?: Key extends keyof RelationshipsOf<Registry[Name]> ? RelationshipResult<Registry[Name], RelationshipsOf<Registry[Name]>[Key] & Relationship, RelationalQueryResult<Registry, RelatedName<Registry, Name, Key>, Related[Key] extends true ? {} : Related[Key]>, "where" extends keyof Related[Key] ? true : false> : never } : {};
+} ? { -readonly [Key in keyof Related as Related[Key] extends false | undefined ? never : Key]-?: Key extends keyof RelationshipsOf<Registry[Name]> ? RelationshipResult<Registry[Name], RelationshipsOf<Registry[Name]>[Key] & Relationship, RelationalQueryResult<Registry, RelatedName<Registry, Name, Key>, Related[Key] extends true ? {} : Related[Key]>, "where" extends keyof Related[Key] ? true : false> : never; } : {};
 type AdjacentResult<Registry extends CollectionRegistry, Name extends keyof Registry & string, Options> = Options extends {
   adjacent: infer Neighbors;
 } ? {
@@ -227,19 +252,27 @@ type AdjacentResult<Registry extends CollectionRegistry, Name extends keyof Regi
     id: string;
   }> : Adjacent<RelationalQueryResult<Registry, Name, Neighbors>>;
 } : {};
-type Simplify<Value> = { [Key in keyof Value]: Value[Key] };
+type Simplify<Value> = { [Key in keyof Value]: Value[Key]; };
+type RequestedPayloads<Payloads, Requested> = { -readonly [Key in keyof Requested as Requested[Key] extends false | undefined ? never : Key]-?: Key extends keyof Payloads ? Payloads[Key] : never; };
+type PayloadResult<Registry extends CollectionRegistry, Name extends keyof Registry & string, Options> = Options extends {
+  payloads: infer Requested;
+} ? keyof RequestedPayloads<PayloadsOf<Registry[Name]>, Requested> extends never ? {} : {
+  _payloads: Simplify<RequestedPayloads<PayloadsOf<Registry[Name]>, Requested>>;
+} : {};
 /** Infers selected columns and relationships, preserving optional metadata in default projections. */
-type RelationalQueryResult<Registry extends CollectionRegistry, Name extends keyof Registry & string, Options> = Options extends unknown ? Simplify<ColumnResult<QueryData<Registry[Name]>, Options> & IncludedResult<Registry, Name, Options> & AdjacentResult<Registry, Name, Options>> : never;
-type CheckedConditions<Value, Filters extends readonly unknown[]> = { [Index in keyof Filters]: CheckedCondition<Value, Filters[Index]> };
-type CheckedCondition<Value, Filter> = Filter extends Scalar ? Filter : { [Key in keyof Filter]: Key extends "AND" | "OR" ? Filter[Key] extends readonly unknown[] ? CheckedConditions<Value, Filter[Key]> : never : Key extends "NOT" ? CheckedCondition<Value, Filter[Key]> : Key extends keyof FieldFilter<Value> ? Filter[Key] : never };
-type CheckedWhereList<Registry extends CollectionRegistry, Name extends keyof Registry & string, Filters extends readonly unknown[]> = { [Index in keyof Filters]: CheckedWhere<Registry, Name, Filters[Index]> };
-type CheckedWhere<Registry extends CollectionRegistry, Name extends keyof Registry & string, Filter> = { [Key in keyof Filter]: Key extends "AND" | "OR" | "NOT" ? Filter[Key] extends readonly unknown[] ? CheckedWhereList<Registry, Name, Filter[Key]> : CheckedWhere<Registry, Name, Filter[Key]> : Key extends "RAW" ? Filter[Key] : Key extends keyof RelationshipsOf<Registry[Name]> ? Filter[Key] extends boolean ? Filter[Key] : CheckedWhere<Registry, RelatedName<Registry, Name, Key>, Filter[Key]> : Key extends keyof QueryData<Registry[Name]> ? CheckedCondition<QueryData<Registry[Name]>[Key], Filter[Key]> : never };
+type RelationalQueryResult<Registry extends CollectionRegistry, Name extends keyof Registry & string, Options> = Options extends unknown ? Simplify<ColumnResult<QueryData<Registry[Name]>, Options> & IncludedResult<Registry, Name, Options> & AdjacentResult<Registry, Name, Options> & PayloadResult<Registry, Name, Options>> : never;
+type CheckedConditions<Value, Filters extends readonly unknown[]> = { [Index in keyof Filters]: CheckedCondition<Value, Filters[Index]>; };
+type CheckedCondition<Value, Filter> = Filter extends Scalar ? Filter : { [Key in keyof Filter]: Key extends "AND" | "OR" ? Filter[Key] extends readonly unknown[] ? CheckedConditions<Value, Filter[Key]> : never : Key extends "NOT" ? CheckedCondition<Value, Filter[Key]> : Key extends keyof FieldFilter<Value> ? Filter[Key] : never; };
+type CheckedWhereList<Registry extends CollectionRegistry, Name extends keyof Registry & string, Filters extends readonly unknown[]> = { [Index in keyof Filters]: CheckedWhere<Registry, Name, Filters[Index]>; };
+type CheckedWhere<Registry extends CollectionRegistry, Name extends keyof Registry & string, Filter> = { [Key in keyof Filter]: Key extends "AND" | "OR" | "NOT" ? Filter[Key] extends readonly unknown[] ? CheckedWhereList<Registry, Name, Filter[Key]> : CheckedWhere<Registry, Name, Filter[Key]> : Key extends "RAW" ? Filter[Key] : Key extends keyof RelationshipsOf<Registry[Name]> ? Filter[Key] extends boolean ? Filter[Key] : CheckedWhere<Registry, RelatedName<Registry, Name, Key>, Filter[Key]> : Key extends keyof QueryData<Registry[Name]> ? CheckedCondition<QueryData<Registry[Name]>[Key], Filter[Key]> : never; };
 /** Rejects unknown options recursively, including options supplied through inferred variables. */
-type CheckedRelationalOptions<Registry extends CollectionRegistry, Name extends keyof Registry & string, Options, Many extends boolean = true, AllowAdjacent extends boolean = true, Pagination extends boolean = true> = { [Key in keyof Options]: Key extends "columns" ? { [Column in keyof Options[Key]]: Column extends keyof QueryData<Registry[Name]> ? Options[Key][Column] : never } : Key extends "where" ? CheckedWhere<Registry, Name, Options[Key]> : Key extends "with" ? { [Related in keyof Options[Key]]: Related extends keyof RelationshipsOf<Registry[Name]> ? Options[Key][Related] extends boolean ? Options[Key][Related] : CheckedRelationalOptions<Registry, RelatedName<Registry, Name, Related>, Options[Key][Related], IsMany<Registry, Name, Related>, AllowAdjacent> : never } : Key extends "adjacent" ? AllowAdjacent extends true ? Options[Key] extends true ? true : CheckedRelationalOptions<Registry, Name, Options[Key], true, false, false> : never : Key extends "orderBy" ? Key extends keyof RelationalQueryOptions<Registry, Name, Many, AllowAdjacent, Pagination> ? { [Field in keyof Options[Key]]: Field extends keyof OrderBy<QueryData<Registry[Name]>> ? Options[Key][Field] : never } : never : Key extends keyof RelationalQueryOptions<Registry, Name, Many, AllowAdjacent, Pagination> ? Options[Key] : never };
+type CheckedRelationalOptions<Registry extends CollectionRegistry, Name extends keyof Registry & string, Options, Many extends boolean = true, AllowAdjacent extends boolean = true, Pagination extends boolean = true> = { [Key in keyof Options]: Key extends "columns" ? { [Column in keyof Options[Key]]: Column extends keyof QueryData<Registry[Name]> ? Options[Key][Column] : never; } : Key extends "where" ? CheckedWhere<Registry, Name, Options[Key]> : Key extends "with" ? { [Related in keyof Options[Key]]: Related extends keyof RelationshipsOf<Registry[Name]> ? Options[Key][Related] extends boolean ? Options[Key][Related] : CheckedRelationalOptions<Registry, RelatedName<Registry, Name, Related>, Options[Key][Related], IsMany<Registry, Name, Related>, AllowAdjacent> : never; } : Key extends "adjacent" ? AllowAdjacent extends true ? Options[Key] extends true ? true : CheckedRelationalOptions<Registry, Name, Options[Key], true, false, false> : never : Key extends "payloads" ? AllowAdjacent extends true ? { [Payload in keyof Options[Key]]: Payload extends keyof PayloadsOf<Registry[Name]> ? Options[Key][Payload] : never; } : never : Key extends "orderBy" ? Key extends keyof RelationalQueryOptions<Registry, Name, Many, AllowAdjacent, Pagination> ? { [Field in keyof Options[Key]]: Field extends keyof OrderBy<QueryData<Registry[Name]>> ? Options[Key][Field] : never; } : never : Key extends keyof RelationalQueryOptions<Registry, Name, Many, AllowAdjacent, Pagination> ? Options[Key] : never; };
 /** Typed per-collection query entry points that never expose source configuration at runtime. */
 type RelationalQueries<Registry extends CollectionRegistry> = string extends keyof Registry ? {} : { readonly [Name in keyof Registry & string]: {
-  /** Returns matching metadata rows and requested relationships. */findMany<const Options extends RelationalQueryOptions<Registry, Name> = {}>(options?: Options & CheckedRelationalOptions<Registry, Name, NoInfer<Options>>): Promise<RelationalQueryResult<Registry, Name, Options>[]>; /** Returns the first matching entry, or undefined when none matches. */
+  /** Returns matching metadata rows and requested relationships. */
+  findMany<const Options extends RelationalQueryOptions<Registry, Name> = {}>(options?: Options & CheckedRelationalOptions<Registry, Name, NoInfer<Options>>): Promise<RelationalQueryResult<Registry, Name, Options>[]>;
+  /** Returns the first matching entry, or undefined when none matches. */
   findFirst<const Options extends RelationalQueryOptions<Registry, Name> = {}>(options?: Options & CheckedRelationalOptions<Registry, Name, NoInfer<Options>>): Promise<RelationalQueryResult<Registry, Name, Options> | undefined>;
-} };
+}; };
 //#endregion
 export { QueryPlan as _, RelationalWhere as a, Fields as c, Scalar as d, ScalarField as f, Expression as g, Where as h, RelationalQueryResult as i, Ordered as l, SelectionResult as m, RelationalQueries as n, Adjacent as o, Selection as p, RelationalQueryOptions as r, Field$1 as s, RelationalCountOptions as t, Query as u, QueryRegistry as v };

package/dist/{chunk-CJs4Fogs.mjs → rolldown-runtime-Bg1v5YCA.mjs}

@@ -6,7 +6,7 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod, mod.exports), cb = null), mod.exports);
 var __exportAll = (all, no_symbols) => {
 	let target = {};
 	for (var name in all) __defProp(target, name, {
@@ -26,7 +26,7 @@ var __copyProps = (to, from, except, desc) => {
 	}
 	return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
 	value: mod,
 	enumerable: true
 }) : target, mod));

package/dist/runtime.d.mts

@@ -1,3 +1,3 @@
-import { n as ContentRenderResult, t as ContentHeading } from "./types-DcvHRmxO.mjs";
-import { a as ContentError, i as ContentDiagnostic, o as ContentErrorCode, t as Content } from "./content-Crag1Uch.mjs";
+import { a as ContentDiagnostic, o as ContentError, s as ContentErrorCode, t as Content } from "./content-lwPxE9Yu.mjs";
+import { n as ContentRenderResult, t as ContentHeading } from "./types-Dh-Sydyw.mjs";
 export { type Content, type ContentDiagnostic, ContentError, type ContentErrorCode, type ContentHeading, type ContentRenderResult };

package/dist/runtime.mjs

@@ -1,6 +1,5 @@
-import { t as ContentError } from "./errors-C8lWyiy2.mjs";
-import { t as assertServerOnly } from "./server-only-CIE-FHx0.mjs";
+//#endregion
+export { t as ContentError } from "./errors-C2iuBM0G.mjs";
+import { t as assertServerOnly } from "./server-only-CIJUlyL-.mjs";
 //#region src/runtime.ts
 assertServerOnly();
-//#endregion
-export { ContentError };

package/dist/{schema-CnCbMosm.mjs → schema-C5Str-E8.mjs}

@@ -1,4 +1,4 @@
-import { n as __exportAll } from "./chunk-CJs4Fogs.mjs";
+import { n as __exportAll } from "./rolldown-runtime-Bg1v5YCA.mjs";
 import { array, bigint, boolean, coerce, date, enum as enum$1, literal, number, object, record, string, union, unknown } from "zod";
 //#region src/schema/builders.ts
 var builders_exports = /* @__PURE__ */ __exportAll({

package/dist/schema.d.mts

@@ -1,7 +1,5 @@
 import { array, bigint, boolean, coerce, date, enum as enum$1, literal, number, object, record, string, union, unknown } from "zod";
 import { StandardSchemaV1 } from "@standard-schema/spec";
-
-//#region src/schema/builders.d.ts
 declare namespace builders_d_exports {
   export { array, bigint, boolean, coerce, date, enum$1 as enum, output as infer, input, literal, number, object, output, record, string, union, unknown };
 }

package/dist/schema.mjs

@@ -1,2 +1 @@
-import { t as builders_exports } from "./schema-CnCbMosm.mjs";
-export { builders_exports as schema };
+export { t as schema } from "./schema-C5Str-E8.mjs";

package/dist/{types-BPh2cBPs.d.mts → types-BC8gVJ6u.d.mts}

@@ -1,12 +1,15 @@
-import { a as Loader } from "./types-hmDOw87q.mjs";
+import { o as Loader } from "./types-FmUJ3cH1.mjs";
+import { n as ContentRenderResult } from "./types-Dh-Sydyw.mjs";
 import { StandardSchemaV1 } from "@standard-schema/spec";
-
 //#region src/collection/types.d.ts
+declare const builtinPayloadsType: unique symbol;
 type Schema = StandardSchemaV1;
 type SchemaOutput<Value> = Value extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<Value> : Record<string, unknown>;
 type ComputedContext<Data, Source = unknown> = {
-  /** The collection's key in the configured registry. */collection: string;
-  id: string; /** Loader-provided source metadata, detached from stored entries for this resolver. */
+  /** The collection's key in the configured registry. */
+  collection: string;
+  id: string;
+  /** Loader-provided source metadata, detached from stored entries for this resolver. */
   source?: Source extends object ? Readonly<Source> : Source;
   data: Readonly<Data>;
   readBody(this: void): Promise<string | undefined>;
@@ -37,12 +40,30 @@ type ComputedData<Definition> = Definition extends {
   computed: infer Computed;
 } ? { [Name in keyof Computed]: Computed[Name] extends {
   schema: infer ResultSchema;
-} ? SchemaOutput<ResultSchema> : never } : {};
+} ? SchemaOutput<ResultSchema> : never; } : {};
 type QueryData<Definition> = {
   id: string;
 } & EntryData<Definition> & ComputedData<Definition>;
 type RelationshipsOf<Definition> = Definition extends {
   relationships: infer Relationships;
 } ? Relationships : {};
+/**
+ * Payloads that Markdown sources, `glob()`, and custom loaders provide for every entry.
+ * Built-in names start with an underscore, so they never collide with custom payloads.
+ */
+type BuiltinPayloads = {
+  /** The retained raw body, or undefined when the entry has none or retention is disabled. */
+  _body: string | undefined;
+  /** HTML and headings; entries without a rendering path reject with `not-renderable`. */
+  _rendered: ContentRenderResult;
+};
+/** Type-only marker recording which built-in payloads a defined collection carries. */
+type BuiltinPayloadMarker<Available extends keyof BuiltinPayloads> = {
+  readonly [builtinPayloadsType]?: Available;
+};
+/** Payload names and value types that queries can request for a collection definition. */
+type PayloadsOf<Definition> = Definition extends {
+  readonly [builtinPayloadsType]?: infer Available;
+} ? Pick<BuiltinPayloads, Available & keyof BuiltinPayloads> : BuiltinPayloads;
 //#endregion
-export { Relationship as a, SchemaOutput as c, QueryData as i, CollectionRegistry as n, RelationshipsOf as o, ComputedContext as r, Schema as s, CollectionDefinition as t };
+export { ComputedContext as a, Relationship as c, SchemaOutput as d, CollectionRegistry as i, RelationshipsOf as l, BuiltinPayloads as n, PayloadsOf as o, CollectionDefinition as r, QueryData as s, BuiltinPayloadMarker as t, Schema as u };

package/dist/{types-hmDOw87q.d.mts → types-FmUJ3cH1.d.mts}

@@ -1,10 +1,11 @@
-import { r as RenderedContent } from "./types-DcvHRmxO.mjs";
-
+import { r as RenderedContent } from "./types-Dh-Sydyw.mjs";
 //#region src/shared/types.d.ts
 type MaybePromise<Value> = Value | Promise<Value>;
 //#endregion
 //#region src/loaders/types.d.ts
 declare const loaderSourceType: unique symbol;
+declare const recordLoaderType: unique symbol;
+declare const bodyLoaderType: unique symbol;
 /** A stored content record, following Astro's build-time DataEntry contract. */
 type DataEntry<Data extends Record<string, unknown> = Record<string, unknown>, Source = unknown> = {
   id: string;
@@ -15,7 +16,8 @@ type DataEntry<Data extends Record<string, unknown> = Record<string, unknown>, S
   digest?: string | number;
   deferredRender?: boolean;
   assetImports?: string[];
-  imageImports?: (string | number)[][]; /** Optional ContentQuery metadata; Astro stores do not retain this extension. */
+  imageImports?: (string | number)[][];
+  /** Optional ContentQuery metadata; Astro stores do not retain this extension. */
   source?: Source;
 };
 /** Source metadata supplied by loaders of individual local files. */
@@ -103,7 +105,8 @@ type LoaderContext<in Source = unknown> = {
   meta: MetaStore;
   config: LoaderConfig;
   logger: LoaderLogger;
-  watcher?: LoaderWatcher; /** ContentQuery extension: cancellation for this load attempt. */
+  watcher?: LoaderWatcher;
+  /** ContentQuery extension: cancellation for this load attempt. */
   signal?: AbortSignal;
   parseData<Data extends Record<string, unknown>>(options: {
     id: string;
@@ -118,7 +121,8 @@ type LoaderContext<in Source = unknown> = {
 };
 /** An Astro-compatible, named build-time content loader. */
 type Loader<out Source = unknown> = {
-  /** Type-only marker preserving metadata inference without changing Astro's load signature. */readonly [loaderSourceType]?: Source;
+  /** Type-only marker preserving metadata inference without changing Astro's load signature. */
+  readonly [loaderSourceType]?: Source;
   name: string;
   schema?: unknown;
   createSchema?(): MaybePromise<{
@@ -127,9 +131,22 @@ type Loader<out Source = unknown> = {
   }>;
   load(context: LoaderContext<Source>): Promise<void>;
 };
+/** A loader whose entries are data records without bodies or rendered output, such as `file()`. */
+type RecordLoader<Source = unknown> = Loader<Source> & {
+  /** Type-only marker: entries never carry built-in `_body` or `_rendered` payloads. */
+  readonly [recordLoaderType]: true;
+};
+/**
+ * A loader whose entries carry raw bodies but never rendered output, such as a loader for a
+ * format that the host application compiles itself.
+ */
+type BodyLoader<Source = unknown> = Loader<Source> & {
+  /** Type-only marker: entries offer the built-in `_body` payload but never `_rendered`. */
+  readonly [bodyLoaderType]: true;
+};
 /** Infers the source metadata a typed loader supplies to computed resolvers. */
 type LoaderSource<Value> = Value extends {
   readonly [loaderSourceType]?: infer Source;
 } ? Source : unknown;
 //#endregion
-export { Loader as a, LoaderLogger as c, MetaStore as d, MaybePromise as f, FileSource as i, LoaderSource as l, DataStore as n, LoaderConfig as o, FileEntrySource as r, LoaderContext as s, DataEntry as t, LoaderWatcher as u };
+export { FileSource as a, LoaderContext as c, LoaderWatcher as d, MetaStore as f, FileEntrySource as i, LoaderLogger as l, MaybePromise as m, DataEntry as n, Loader as o, RecordLoader as p, DataStore as r, LoaderConfig as s, BodyLoader as t, LoaderSource as u };

package/dist/{validation-BvvjSUFc.mjs → validation-D_XdE1pF.mjs}

@@ -1,5 +1,5 @@
-import { n as contentError, t as ContentError } from "./errors-C8lWyiy2.mjs";
-import { i as detach } from "./values-B7lo_2_x.mjs";
+import { n as contentError, t as ContentError } from "./errors-C2iuBM0G.mjs";
+import { i as detach } from "./values-BbTV4QT-.mjs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 //#region src/loaders/descriptor.ts