content-query 0.3.0 → 0.4.0

package/dist/loaders.d.mts

@@ -1,5 +1,4 @@
-import { a as FileSource, c as LoaderContext, d as LoaderWatcher, f as MetaStore, i as FileEntrySource, l as LoaderLogger, n as DataEntry, o as Loader, p as RecordLoader, r as DataStore, s as LoaderConfig, t as BodyLoader, u as LoaderSource } from "./types-FmUJ3cH1.mjs";
-import { n as GlobOptions, t as FileOptions } from "./descriptor-BUPT2J7X.mjs";
+import { a as DataStore, c as Loader, d as LoaderLogger, f as LoaderSource, h as RecordLoader, i as DataEntry, l as LoaderConfig, m as MetaStore, n as GlobOptions, o as FileEntrySource, p as LoaderWatcher, r as BodyLoader, s as FileSource, t as FileOptions, u as LoaderContext } from "./descriptor-bcPa6XLk.mjs";
 //#region src/loaders/file.d.ts
 /** Declares a multi-entry data file with typed source paths and record keys, plus an optional parser. */
 export declare function file(filename: string, options?: FileOptions): RecordLoader<FileEntrySource>;

package/dist/loaders.mjs

@@ -1,85 +1,6 @@
-import { o as builtinPath, s as builtinSymbol } from "./validation-D_XdE1pF.mjs";
-import { i as groupDiagnostics, n as contentError, r as describeCause, t as ContentError } from "./errors-C2iuBM0G.mjs";
-import { a as populateStore, i as recordData, n as coerceIdentity, r as parseData, t as glob } from "./glob-Bv0dpvCQ.mjs";
+import { t as glob } from "./glob-BXJuwy_p.mjs";
 import { t as assertServerOnly } from "./server-only-CIJUlyL-.mjs";
-import { readFile } from "node:fs/promises";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-//#region src/loaders/file.ts
-/** Declares a multi-entry data file with typed source paths and record keys, plus an optional parser. */
-function file(filename, options = {}) {
-	if (typeof filename !== "string" || !filename) throw new TypeError("file() requires a filename.");
-	const descriptor = {
-		kind: "file",
-		filename,
-		options
-	};
-	return {
-		[builtinSymbol]: descriptor,
-		name: "content-query/file",
-		async load(context) {
-			const entries = await loadFile(descriptor, fileURLToPath(context.config.root), context.signal ?? new AbortController().signal);
-			await populateStore(context, entries);
-		}
-	};
-}
-/** Captures a complete multi-entry data source without applying collection validation. */
-async function loadFile(descriptor, root, signal) {
-	const resolved = builtinPath(descriptor, root);
-	let parsed;
-	try {
-		const text = await readFile(resolved, {
-			encoding: "utf8",
-			signal
-		});
-		parsed = descriptor.options.parser ? await descriptor.options.parser(text) : parseData(text, resolved);
-	} catch (cause) {
-		signal.throwIfAborted();
-		throw contentError(cause, {
-			code: "source-error",
-			source: resolved,
-			message: `Could not load "${descriptor.filename}": ${describeCause(cause)}`,
-			cause
-		});
-	}
-	const array = Array.isArray(parsed);
-	if (!array && (!parsed || typeof parsed !== "object")) throw new ContentError({
-		code: "source-error",
-		source: resolved,
-		message: `"${descriptor.filename}" must parse to an array or keyed record.`
-	});
-	const diagnostics = [];
-	const entries = Object.entries(parsed).flatMap(([key, value]) => {
-		if (!array && key === "$schema" && typeof value === "string") return [];
-		const source = `${resolved}#${key}`;
-		try {
-			const data = recordData(value);
-			const identity = array ? data.id ?? data.slug : key;
-			if (identity == null || coerceIdentity(identity) === "") throw new Error("Array entries require a nonempty id or slug.");
-			const { id: _transportId, ...metadata } = data;
-			return [{
-				id: coerceIdentity(identity),
-				data: metadata,
-				source: array ? source : `${resolved}#${coerceIdentity(identity)}`,
-				sourceData: {
-					filePath: path.relative(root, resolved).split(path.sep).join("/"),
-					key
-				}
-			}];
-		} catch (cause) {
-			diagnostics.push({
-				code: "source-error",
-				source,
-				message: `Invalid entry "${key}" in "${descriptor.filename}": ${describeCause(cause)}`,
-				cause
-			});
-			return [];
-		}
-	});
-	if (diagnostics.length) throw groupDiagnostics(diagnostics);
-	return entries;
-}
-//#endregion
+import { t as file } from "./file-DSOcdFj0.mjs";
 //#region src/loaders.ts
 assertServerOnly();
 //#endregion

package/dist/next.d.mts

@@ -1,4 +1,4 @@
-import { t as BuildContentOptions } from "./build-jKnjDjQE.mjs";
+import { t as BuildContentOptions } from "./build-DL1GzmRy.mjs";
 import { NextConfig } from "next";
 //#region src/integrations/next/plugin.d.ts
 /** Content locations for Next.js; the adapter chooses generated storage and the watch lifecycle. */

package/dist/next.mjs

@@ -1,5 +1,5 @@
-import { c as contentDeclarations, i as resolveConfigPath, t as buildAtRoot } from "./build-CI4s0oFP.mjs";
-import { n as serializeContentError } from "./diagnostics-Cu94mZhl.mjs";
+import { c as contentDeclarations, i as resolveConfigPath, t as buildAtRoot } from "./build-CcqIpkes.mjs";
+import { n as serializeContentError } from "./diagnostics-DmUZtrJ6.mjs";
 import path from "node:path";
 import { randomUUID } from "node:crypto";
 import { mkdirSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync } from "node:fs";

package/dist/{operators-UqWUhKQJ.mjs → operators-Cwy8Kx4o.mjs}

@@ -1,4 +1,4 @@
-import { a as invalidQuery } from "./errors-C2iuBM0G.mjs";
+import { a as invalidQuery } from "./errors-Bfd0R4_P.mjs";
 import { c as isScalar, i as detach } from "./values-BbTV4QT-.mjs";
 //#region src/query/operators.ts
 /** Builds a checked, backend-independent predicate instead of a per-entry callback. */
@@ -78,6 +78,89 @@ function startsWith(field, value) {
 function endsWith(field, value) {
 	return predicate("ends-with", field, value);
 }
+/**
+* Matches a SQL-style pattern: `%` matches any run of characters and `_` matches one character.
+* A backslash escapes a wildcard. Matching is case-sensitive.
+*/
+function like(field, pattern) {
+	return predicate("like", field, pattern);
+}
+/** Matches a SQL-style pattern like {@link like}, ignoring case. */
+function ilike(field, pattern) {
+	return predicate("ilike", field, pattern);
+}
+/** Negates {@link like}; entries without a matching string, including absent values, match. */
+function notLike(field, pattern) {
+	return not(like(field, pattern));
+}
+/** Negates {@link ilike}; entries without a matching string, including absent values, match. */
+function notIlike(field, pattern) {
+	return not(ilike(field, pattern));
+}
+/** Tests whether every item of an existing scalar array belongs to the candidates. */
+function arrayContained(field, values) {
+	return predicate("array-contained", field, values);
+}
+/**
+* Matches entries with at least one related entry. With a filter, a related entry must also match
+* it, for example `has(fields.author, (author) => eq(author.name, "Ada"))`. Wrap the result in
+* {@link not} to match entries without such a related entry.
+*
+* @param relation - A relationship from the `where()` callback's fields.
+* @param filter - Optional filter over the related entry's fields and relationships.
+* @returns An expression that the query resolves against the relationship's target collection.
+*/
+function has(relation, filter) {
+	if (!relation || typeof relation.name !== "string" || !relation.name) invalidQuery("has() requires a relationship from the where() fields.");
+	if (filter !== void 0 && typeof filter !== "function") invalidQuery("has() filters must be callbacks over the related entry's fields.");
+	const expression = filter === void 0 ? and() : filter(fieldProxy());
+	validateExpression(expression);
+	return {
+		kind: "has",
+		field: relation.name,
+		expression
+	};
+}
+/** Creates the field and relationship accessors passed to filter callbacks. */
+function fieldProxy() {
+	return new Proxy(Object.create(null), { get: (_target, name) => ({ name }) });
+}
+/**
+* Resolves fluent `has()` filters against a scope's declared relationships, producing portable
+* `relation` expressions that both runtime backends evaluate.
+*
+* @param registry - The query registry with each collection's relationships.
+* @param collection - The collection the expression filters.
+* @param expression - A validated expression that may contain `has()` filters.
+* @returns The expression with every `has()` filter resolved.
+*/
+function resolveRelations(registry, collection, expression) {
+	switch (expression.kind) {
+		case "has": {
+			const relationships = registry[collection]?.relationships ?? {};
+			const relation = Object.hasOwn(relationships, expression.field) ? relationships[expression.field] : void 0;
+			if (!relation) invalidQuery(`Unknown relationship "${expression.field}" in has().`);
+			return {
+				kind: "relation",
+				collection,
+				field: expression.field,
+				target: relation.collection,
+				expression: resolveRelations(registry, relation.collection, expression.expression)
+			};
+		}
+		case "relation": return {
+			...expression,
+			expression: resolveRelations(registry, expression.target, expression.expression)
+		};
+		case "and":
+		case "or":
+		case "not": return {
+			...expression,
+			expressions: expression.expressions.map((child) => resolveRelations(registry, collection, child))
+		};
+		default: return expression;
+	}
+}
 /** Tests scalar membership in an array, ignoring holes. */
 function arrayContains(field, value) {
 	return predicate("array-contains", field, value);
@@ -160,6 +243,9 @@ function validateExpression(expression) {
 			expression.target
 		].some((name) => typeof name !== "string" || !name)) invalidQuery("Relationship filters require registered collection and relationship names.");
 		validateExpression(expression.expression);
+	} else if (expression.kind === "has") {
+		if (typeof expression.field !== "string" || !expression.field) invalidQuery("has() requires a relationship from the where() fields.");
+		validateExpression(expression.expression);
 	} else if ([
 		"and",
 		"or",
@@ -170,4 +256,4 @@ function validateExpression(expression) {
 	} else invalidQuery("Invalid expression structure.");
 }
 //#endregion
-export { not as _, contains as a, startsWith as b, gt as c, isMissing as d, isNull as f, ne as g, lte as h, arrayContainsAny as i, gte as l, lt as m, arrayContains as n, endsWith as o, isUndefined as p, arrayContainsAll as r, eq as s, and as t, inArray as u, notInArray as v, validateExpression as x, or as y };
+export { notIlike as C, resolveRelations as D, or as E, startsWith as O, not as S, notLike as T, isUndefined as _, arrayContainsAny as a, lte as b, eq as c, gte as d, has as f, isNull as g, isMissing as h, arrayContainsAll as i, validateExpression as k, fieldProxy as l, inArray as m, arrayContained as n, contains as o, ilike as p, arrayContains as r, endsWith as s, and as t, gt as u, like as v, notInArray as w, ne as x, lt as y };

package/dist/query-style-eXENQJ0O.d.mts

@@ -0,0 +1,22 @@
+//#region src/runtime/query-style.d.ts
+/** Query APIs an application can allow through `queryStyle` in content-query.config. */
+type QueryStyle = "fluent" | "relational";
+/**
+ * Root `content` members that start each query style. Every other query API hangs off these
+ * members, so gating them gates payloads, relationships, and adjacency as well.
+ */
+declare const queryStyleMembers: {
+  readonly fluent: readonly ["from"];
+  readonly relational: readonly ["query", "count"];
+};
+/** A root `content` member that belongs to exactly one query style. */
+type QueryStyleMember = (typeof queryStyleMembers)[QueryStyle][number];
+/** Root members that start a query in the given style. */
+type MembersOf<Style extends QueryStyle> = (typeof queryStyleMembers)[Style][number];
+/**
+ * Describes a disabled root member in the type error itself, for example:
+ * `content.from is unavailable because content-query.config sets queryStyle to "relational".`
+ */
+type QueryStyleDisabled<Member extends QueryStyleMember, Style extends QueryStyle> = `content.${Member} is unavailable because content-query.config sets queryStyle to "${Style}".`;
+//#endregion
+export { QueryStyleMember as i, QueryStyle as n, QueryStyleDisabled as r, MembersOf as t };

package/dist/query.d.mts

@@ -1,4 +1,4 @@
-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";
+import { _ as Where, a as RelationalWhere, c as Fields, d as QueryFields, f as RelationField, g as SelectionResult, h as Selection, i as RelationalQueryResult, l as Ordered, m as ScalarField, n as RelationalQueries, o as Adjacent, p as Scalar, r as RelationalQueryOptions, s as Field, t as RelationalCountOptions, v as Expression } from "./relational-types-C8xJtLG5.mjs";
 //#region src/query/operators.d.ts
 /** Matches a scalar using strict value/date equality. */
 export declare function eq<Value>(field: ScalarField<Value>, value: NoInfer<Value>): Expression;
@@ -22,6 +22,29 @@ export declare function contains<Value>(field: Field<Value> & (NonNullable<Value
 export declare function startsWith<Value>(field: Field<Value> & (NonNullable<Value> extends string ? unknown : never), value: string): Expression;
 /** Matches a literal string suffix. */
 export declare function endsWith<Value>(field: Field<Value> & (NonNullable<Value> extends string ? unknown : never), value: string): Expression;
+/**
+ * Matches a SQL-style pattern: `%` matches any run of characters and `_` matches one character.
+ * A backslash escapes a wildcard. Matching is case-sensitive.
+ */
+export declare function like<Value>(field: Field<Value> & (NonNullable<Value> extends string ? unknown : never), pattern: string): Expression;
+/** Matches a SQL-style pattern like {@link like}, ignoring case. */
+export declare function ilike<Value>(field: Field<Value> & (NonNullable<Value> extends string ? unknown : never), pattern: string): Expression;
+/** Negates {@link like}; entries without a matching string, including absent values, match. */
+export declare function notLike<Value>(field: Field<Value> & (NonNullable<Value> extends string ? unknown : never), pattern: string): Expression;
+/** Negates {@link ilike}; entries without a matching string, including absent values, match. */
+export declare function notIlike<Value>(field: Field<Value> & (NonNullable<Value> extends string ? unknown : never), pattern: string): Expression;
+/** Tests whether every item of an existing scalar array belongs to the candidates. */
+export declare function arrayContained<Value extends Scalar>(field: Field<readonly Value[] | null | undefined>, values: readonly NoInfer<Value>[]): Expression;
+/**
+ * Matches entries with at least one related entry. With a filter, a related entry must also match
+ * it, for example `has(fields.author, (author) => eq(author.name, "Ada"))`. Wrap the result in
+ * {@link not} to match entries without such a related entry.
+ *
+ * @param relation - A relationship from the `where()` callback's fields.
+ * @param filter - Optional filter over the related entry's fields and relationships.
+ * @returns An expression that the query resolves against the relationship's target collection.
+ */
+export declare function has<TargetFields>(relation: RelationField<TargetFields>, filter?: (fields: TargetFields) => Expression): Expression;
 /** Tests scalar membership in an array, ignoring holes. */
 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. */
@@ -41,4 +64,4 @@ export declare function or(...expressions: Expression[]): Expression;
 /** Negates a predicate's boolean result. */
 export declare function not(expression: Expression): Expression;
 //#endregion
-export type { Adjacent, RelationalCountOptions as CountOptions, Expression, Field, Fields, RelationalQueryOptions as QueryOptions, RelationalQueryOptions, RelationalQueries, RelationalQueryResult, RelationalWhere, Selection, SelectionResult, Where };
+export type { Adjacent, RelationalCountOptions as CountOptions, Expression, Field, Fields, QueryFields, RelationalQueryOptions as QueryOptions, RelationalQueryOptions, RelationField, RelationalQueries, RelationalQueryResult, RelationalWhere, Selection, SelectionResult, Where };

package/dist/query.mjs

@@ -1 +1 @@
-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";
+export { t as and, n as arrayContained, r as arrayContains, i as arrayContainsAll, a as arrayContainsAny, o as contains, s as endsWith, c as eq, u as gt, d as gte, f as has, p as ilike, m as inArray, h as isMissing, g as isNull, _ as isUndefined, v as like, y as lt, b as lte, x as ne, S as not, C as notIlike, w as notInArray, T as notLike, E as or, O as startsWith } from "./operators-Cwy8Kx4o.mjs";

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

@@ -1,4 +1,4 @@
-import { c as Relationship, i as CollectionRegistry, l as RelationshipsOf, o as PayloadsOf, s as QueryData } from "./types-BC8gVJ6u.mjs";
+import { S as VariantOf, _ as RelationshipsOf, g as Relationship, h as QueryData, i as CollectionRegistry, m as PayloadsOf } from "./types-DbFfF6JE.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 = {
@@ -12,15 +12,20 @@ type Expression = {
   field: string;
   target: string;
   expression: Expression;
+} |
+/** A fluent `has()` filter that query builders resolve into a `relation` expression. */
+{
+  kind: "has";
+  field: string;
+  expression: Expression;
 } | {
   kind: "and" | "or" | "not";
   expressions: readonly Expression[];
 };
 type QueryPlan = {
   collection: string;
+  /** Explicitly selected fields; scopes never include unselected fields, including `id`. */
   select?: readonly string[];
-  allFields?: boolean;
-  exclude?: readonly string[];
   filters: readonly Expression[];
   order: readonly {
     field: string;
@@ -29,10 +34,19 @@ type QueryPlan = {
   limit?: number;
   offset?: number;
   with: Readonly<Record<string, QueryPlan>>;
-  adjacent?: true | QueryPlan;
+  adjacent?: AdjacentPlan;
   /** Payloads to attach under `_payloads` after filtering, ordering, and pagination. */
   payloads?: Readonly<Record<string, PlanPayload>>;
 };
+/**
+ * Selects previous and next entries. `results` finds neighbors within the scope's own filtered and
+ * ordered entries, or a parent's related entries, and `plan` holds only their selection;
+ * `collection` finds neighbors in an independent sibling scope described by `plan`.
+ */
+type AdjacentPlan = {
+  scope: "results" | "collection";
+  plan: QueryPlan;
+};
 /** One requested payload; variant keys are empty for payloads without variants. */
 type PlanPayload = {
   variant: Readonly<Record<string, string>>;
@@ -46,15 +60,29 @@ type QueryRegistry = Record<string, {
   /** Payload names available to queries; omitted when the collection has none. */
   payloads?: Record<string, PayloadDescriptor>;
 }>;
+/** Explains the explicit-selection rule wherever a scope returns rows without selecting data. */
+declare const NO_SELECTION_MESSAGE: "Select fields, relationships, payloads, or adjacent entries before running this query.";
 //#endregion
 //#region src/query/types.d.ts
 declare const queryType: unique symbol;
+/** Running an unselected query reports the explicit-selection rule as its required `this` type. */
+type UnselectedTerminal = (this: typeof NO_SELECTION_MESSAGE, ...arguments_: readonly unknown[]) => never;
+/** A `then` that cannot resolve a value, so awaiting an unselected query fails to compile. */
+type UnselectedThen = (selectBeforeAwaiting: typeof NO_SELECTION_MESSAGE) => never;
 declare const fieldType: unique symbol;
 type Field$1<Value> = {
   readonly name: string;
   readonly [fieldType]: Value;
 };
 type Fields<Data> = { readonly [Name in keyof Data]-?: Field$1<Data[Name]>; };
+declare const relationTarget: unique symbol;
+/** A relationship in a fluent `where()` callback, filtered with `has()`. */
+type RelationField<TargetFields> = {
+  readonly name: string;
+  readonly [relationTarget]: TargetFields;
+};
+/** Fields and relationships available to a fluent `where()` callback. */
+type QueryFields<Registry extends CollectionRegistry, Name extends keyof Registry & string> = Fields<QueryData<Registry[Name]>> & { readonly [Key in keyof RelationshipsOf<Registry[Name]> & string]-?: RelationField<QueryFields<Registry, RelatedName$1<Registry, RelationOf<Registry, Name, Key>>>>; };
 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;
@@ -82,7 +110,7 @@ type RelationshipResult<Definition, Relation extends Relationship, Result, Filte
 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>;
-  where(configure: (fields: Fields<QueryData<Registry[Name]>>) => Expression): Query<Registry, Name, Result, Selected, Many, Root, true, AllowAdjacent, Pagination>;
+  where(configure: (fields: QueryFields<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>;
 } & (Many extends true ? {
   orderBy(field: SortKey<QueryData<Registry[Name]>>, direction?: "asc" | "desc"): Query<Registry, Name, Result, Selected, Many, Root, Filtered, AllowAdjacent, Pagination>;
@@ -91,11 +119,10 @@ type Query<Registry extends CollectionRegistry, Name extends keyof Registry & st
   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;
-    }>;
+  withPayload<Key extends keyof PayloadsOf<Registry[Name]> & string>(name: Key, ...variant: keyof VariantOf<Registry[Name], Key> extends never ? [] : [variant: Readonly<VariantOf<Registry[Name], Key>>]): Query<Registry, Name, WithPayload<Result, Key, PayloadsOf<Registry[Name]>[Key]>, true, Many, Root, Filtered, AllowAdjacent, Pagination>;
+  /** Selects neighbor fields within this scope's filtered and ordered results. */
+  selectAdjacent<const Keys extends readonly [keyof QueryData<Registry[Name]> & string, ...(keyof QueryData<Registry[Name]> & string)[]]>(...fields: Keys): Query<Registry, Name, Result & {
+    _adjacent: Adjacent<{ [Key in Keys[number]]: QueryData<Registry[Name]>[Key & keyof QueryData<Registry[Name]>]; }>;
   }, true, Many, Root, Filtered, AllowAdjacent, Pagination>;
   selectAdjacent<Configured extends QueryInfo<unknown, true>>(configure: (siblings: Query<Registry, Name, {}, false, true, false, false, false, false>) => Configured): Query<Registry, Name, Result & {
     _adjacent: Adjacent<ResultOf<Configured>>;
@@ -104,11 +131,11 @@ type Query<Registry extends CollectionRegistry, Name extends keyof Registry & st
     _adjacent: Adjacent<SelectionResult<Registry, Name, Options["select"]>>;
   }, true, Many, Root, Filtered, AllowAdjacent, Pagination>;
 } : {}) & (Root extends true ? {
-  all: Selected extends true ? () => Promise<Simplify$1<Result>[]> : never;
-  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;
-  /** Counts matching entries; unavailable once payloads are requested. */
+  all: Selected extends true ? () => Promise<Simplify$1<Result>[]> : UnselectedTerminal;
+  execute: Selected extends true ? () => Promise<Simplify$1<Result>[]> : UnselectedTerminal;
+  then: Selected extends true ? Promise<Simplify$1<Result>[]>["then"] : UnselectedThen;
+  first: Selected extends true ? () => Promise<Simplify$1<Result> | undefined> : UnselectedTerminal;
+  /** Counts matching entries without a selection; unavailable once payloads are requested. */
   count: [Result] extends [never] ? () => Promise<number> : [Result] extends [{
     _payloads: unknown;
   }] ? never : () => Promise<number>;
@@ -149,7 +176,7 @@ type Where<Data> = { [Name in keyof Data]?: [Data[Name]] extends [Scalar] ? Data
 };
 type OrderBy<Data> = Partial<Record<SortKey<Data>, "asc" | "desc">>;
 type ObjectScope<Registry extends CollectionRegistry, Name extends keyof Registry & string, Many extends boolean> = {
-  where?: Where<QueryData<Registry[Name]>> | ((fields: Fields<QueryData<Registry[Name]>>) => Expression);
+  where?: Where<QueryData<Registry[Name]>> | ((fields: QueryFields<Registry, Name>) => Expression);
 } & (Many extends true ? {
   orderBy?: OrderBy<QueryData<Registry[Name]>> | readonly OrderBy<QueryData<Registry[Name]>>[];
   limit?: number;
@@ -160,20 +187,27 @@ type QueryOptions<Registry extends CollectionRegistry, Name extends keyof Regist
 };
 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 ? {
-  _adjacent?: true | AdjacentOptions<Registry, Name>;
+  _adjacent?: {
+    scope: "results";
+    select: Selection<Registry, Name, false>;
+  } | (AdjacentOptions<Registry, Name> & {
+    scope?: "collection";
+  });
 } : {});
 type ObjectRelationValue<Registry extends CollectionRegistry, Name extends keyof Registry & string, Key extends keyof RelationshipsOf<Registry[Name]>, Options> = Options extends {
   select: infer Projection;
 } ? RelationValue<Registry[Name], RelationOf<Registry, Name, Key>, QueryInfo<SelectionResult<Registry, RelatedName$1<Registry, RelationOf<Registry, Name, Key>>, Projection>, true, "where" extends keyof Options ? true : false>> : never;
-type SelectionResult<Registry extends CollectionRegistry, Name extends keyof Registry & string, Projection> = { -readonly [Key in keyof Projection as Projection[Key] extends false | undefined ? never : Key]-?: Key extends "_adjacent" ? Projection[Key] extends true ? Adjacent<{
-  id: string;
-}> : Projection[Key] extends {
+type SelectionResult<Registry extends CollectionRegistry, Name extends keyof Registry & string, Projection> = { -readonly [Key in keyof Projection as Projection[Key] extends false | undefined ? never : Key]-?: Key extends "_adjacent" ? 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; };
+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 {
+  scope: "results";
+} ? { [Option in keyof Projection[Key]]: Option extends "scope" ? "results" : Option extends "select" ? CheckedSelection<Registry, Name, Projection[Key][Option], false> : never; } : CheckedOptions<Registry, Name, Omit<Projection[Key], "scope">, true, false, false> & {
+  scope?: "collection";
+} : 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; };
 //#endregion
@@ -221,36 +255,69 @@ type RelationalWhere<Registry extends CollectionRegistry, Name extends keyof Reg
   NOT?: RelationalWhere<Registry, Name> | readonly RelationalWhere<Registry, Name>[];
   RAW?: (fields: Fields<QueryData<Registry[Name]>>) => Expression;
 };
+/** Requests one payload: `true` without variants, or a record giving every variant key. */
+type PayloadRequest<Variant> = keyof Variant extends never ? true : Readonly<Variant>;
 /** 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 PayloadOptions<Registry extends CollectionRegistry, Name extends keyof Registry & string> = { [Key in keyof PayloadsOf<Registry[Name]>]?: false | PayloadRequest<VariantOf<Registry[Name], Key>>; };
+/** Rejects variant keys a payload does not declare, including through inferred variables. */
+type CheckedPayloadRequest<Request, Variant> = Request extends boolean ? Request : { [Key in keyof Request]: Key extends keyof Variant ? string : never; };
+/**
+ * Collection-scoped metadata queries with Drizzle-style columns, relationships, and filters.
+ * Nothing is selected implicitly, not even `id`: list fields in `columns`, include relationships
+ * with nested options, request payloads, or select adjacency.
+ */
 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>>;
+  /** Fields to include, each set to `true`. Omitted fields are never returned. */
+  columns?: Partial<Record<keyof QueryData<Registry[Name]>, true>>;
   where?: RelationalWhere<Registry, Name>;
-  with?: { [Key in keyof RelationshipsOf<Registry[Name]>]?: boolean | RelationalQueryOptions<Registry, RelatedName<Registry, Name, Key>, IsMany<Registry, Name, Key>, AllowAdjacent>; };
+  /** Related entries to include; each selects its own data. `false` omits a relationship. */
+  with?: { [Key in keyof RelationshipsOf<Registry[Name]>]?: false | 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 ? {
   limit?: number;
   offset?: number;
 } : {}) : {}) & (AllowAdjacent extends true ? {
-  adjacent?: true | RelationalQueryOptions<Registry, Name, true, false, false>;
+  /**
+   * Previous and next entries, which select their own data. `scope: "results"` finds
+   * neighbors within these results; other options describe an independent sibling scope.
+   */
+  adjacent?: ({
+    scope: "results";
+  } & Pick<RelationalQueryOptions<Registry, Name, true, false, false>, "columns" | "with">) | ({
+    scope?: "collection";
+  } & 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;
+} ? { -readonly [Key in keyof Columns as Columns[Key] extends true ? Key : never]-?: Key extends keyof Data ? Data[Key] : never; } : {};
+/** Keys whose option values request something, as opposed to `false` or `undefined`. */
+type Requested<Map> = keyof { [Key in keyof Map as Map[Key] extends false | undefined ? never : Key]: unknown; };
+/** Whether options select fields, include relationships, request payloads, or select adjacency. */
+type SelectsData<Options> = (Options extends {
+  columns: infer Columns;
+} ? Requested<Columns> : never) | (Options extends {
+  with: infer Related;
+} ? Requested<Related> : never) | (Options extends {
+  payloads: infer Payloads;
+} ? Requested<Payloads> : never) | (Options extends {
+  adjacent: infer Neighbors;
+} ? Neighbors extends false | undefined ? never : "adjacent" : never) extends never ? false : true;
+/**
+ * Requires a row-returning scope to request data. An unselected scope must supply an impossible
+ * property named after the rule, so the compiler error states it.
+ */
+type SelectionRequired<Options> = SelectsData<Options> extends true ? unknown : { [Rule in typeof NO_SELECTION_MESSAGE]: never; };
 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]>, "where" extends keyof Related[Key] ? true : false> : never; } : {};
 type AdjacentResult<Registry extends CollectionRegistry, Name extends keyof Registry & string, Options> = Options extends {
   adjacent: infer Neighbors;
 } ? {
-  _adjacent: Neighbors extends true ? Adjacent<{
-    id: string;
-  }> : Adjacent<RelationalQueryResult<Registry, Name, Neighbors>>;
+  _adjacent: Adjacent<RelationalQueryResult<Registry, Name, Neighbors>>;
 } : {};
 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; };
@@ -259,20 +326,28 @@ type PayloadResult<Registry extends CollectionRegistry, Name extends keyof Regis
 } ? 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. */
+/** Infers exactly the selected columns, relationships, adjacency, and payloads. */
 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 "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; };
+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 false | undefined ? Options[Key][Related] : CheckedRelationalOptions<Registry, RelatedName<Registry, Name, Related>, Options[Key][Related], IsMany<Registry, Name, Related>, AllowAdjacent> & SelectionRequired<Options[Key][Related]> : never; } : Key extends "adjacent" ? AllowAdjacent extends true ? CheckedRelationalOptions<Registry, Name, Omit<Options[Key], "scope">, true, false, false> & SelectionRequired<Options[Key]> & (Options[Key] extends {
+  scope: "results";
+} ? {
+  scope: "results";
+  where?: never;
+  orderBy?: never;
+} : {
+  scope?: "collection";
+}) : never : Key extends "payloads" ? AllowAdjacent extends true ? { [Payload in keyof Options[Key]]: Payload extends keyof PayloadsOf<Registry[Name]> ? CheckedPayloadRequest<Options[Key][Payload], VariantOf<Registry[Name], 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. */
-  findFirst<const Options extends RelationalQueryOptions<Registry, Name> = {}>(options?: Options & CheckedRelationalOptions<Registry, Name, NoInfer<Options>>): Promise<RelationalQueryResult<Registry, Name, Options> | undefined>;
+  /** Returns matching rows with exactly the selected data. Options must select something. */
+  findMany<const Options extends RelationalQueryOptions<Registry, Name>>(options: Options & CheckedRelationalOptions<Registry, Name, NoInfer<Options>> & SelectionRequired<NoInfer<Options>>): Promise<RelationalQueryResult<Registry, Name, Options>[]>;
+  /** Returns the first matching row, or undefined when none matches. */
+  findFirst<const Options extends RelationalQueryOptions<Registry, Name>>(options: Options & CheckedRelationalOptions<Registry, Name, NoInfer<Options>> & SelectionRequired<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 };
+export { Where as _, RelationalWhere as a, QueryRegistry as b, Fields as c, QueryFields as d, RelationField as f, SelectionResult as g, Selection as h, RelationalQueryResult as i, Ordered as l, ScalarField as m, RelationalQueries as n, Adjacent as o, Scalar as p, RelationalQueryOptions as r, Field$1 as s, RelationalCountOptions as t, Query as u, Expression as v, QueryPlan as y };

package/dist/runtime.d.mts

@@ -1,3 +1,4 @@
-import { a as ContentDiagnostic, o as ContentError, s as ContentErrorCode, t as Content } from "./content-lwPxE9Yu.mjs";
+import { a as ContentDiagnostic, o as ContentError, s as ContentErrorCode, t as Content } from "./content-CwTKqRs9.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 };
+import { n as QueryStyle, r as QueryStyleDisabled } from "./query-style-eXENQJ0O.mjs";
+export { type Content, type ContentDiagnostic, ContentError, type ContentErrorCode, type ContentHeading, type ContentRenderResult, type QueryStyle, type QueryStyleDisabled };

package/dist/runtime.mjs

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