content-query 0.2.0 → 0.4.0

package/dist/{content-N1gYshjg.mjs → content-BXrgP7nL.mjs}

@@ -1,7 +1,7 @@
-import { a as invalidQuery, n as contentError, t as ContentError } from "./errors-C2iuBM0G.mjs";
+import { a as invalidQuery, n as contentError, o as payloadIdentity, t as ContentError } from "./errors-Bfd0R4_P.mjs";
 import { a as detachSelection, c as isScalar, i as detach, n as compareStrings, s as equal, t as compare } from "./values-BbTV4QT-.mjs";
 import { t as assertServerOnly } from "./server-only-CIJUlyL-.mjs";
-import { _ as not, t as and, x as validateExpression, y as or } from "./operators-UqWUhKQJ.mjs";
+import { D as resolveRelations, E as or, S as not, k as validateExpression, l as fieldProxy, t as and } from "./operators-Cwy8Kx4o.mjs";
 //#region src/artifacts/types.ts
 const CODEC_VERSION = "devalue-6.0.2";
 //#endregion
@@ -144,6 +144,18 @@ function isRelationship(value) {
 	].includes(String(value.referenceSide));
 }
 //#endregion
+//#region src/runtime/revision.ts
+/**
+* Serializes a variant combination with sorted keys, so preparation, artifacts, and query plans
+* agree on one identity. A payload without variants uses `{}`.
+*
+* @param variant - The variant combination.
+* @returns The canonical variant key.
+*/
+function variantKey(variant) {
+	return JSON.stringify(Object.fromEntries(Object.keys(variant).sort().map((key) => [key, variant[key]])));
+}
+//#endregion
 //#region src/shared/concurrency.ts
 /**
 * Maps items through an asynchronous callback with at most `limit` callbacks in flight.
@@ -235,9 +247,17 @@ function emptyPlan(collection) {
 		with: {}
 	};
 }
-/** Treats explicitly selected relationships and adjacency as row projections too. */
+/** Explains the explicit-selection rule wherever a scope returns rows without selecting data. */
+const NO_SELECTION_MESSAGE = "Select fields, relationships, payloads, or adjacent entries before running this query.";
+/**
+* Checks whether a row-returning scope explicitly requests data. Nothing is implicit, not even
+* `id`: a scope must select fields, include a relationship, request a payload, or select adjacency.
+*
+* @param plan - The scope to check; `undefined` when a callback returned no builder.
+* @returns `true` when the scope requests at least one kind of data.
+*/
 function hasSelection(plan) {
-	return !!plan && (plan.select !== void 0 || !!plan.allFields || !!plan.adjacent || Object.keys(plan.with).length > 0);
+	return !!plan && (!!plan.select?.length || !!plan.adjacent || Object.keys(plan.with).length > 0 || Object.keys(plan.payloads ?? {}).length > 0);
 }
 //#endregion
 //#region src/query/relational.ts
@@ -314,9 +334,9 @@ function relationalWhere(registry, collection, where) {
 		expressions.push(field === "OR" ? or(...children) : field === "NOT" ? and(...children.map(not)) : and(...children));
 	} else if (field === "RAW") {
 		if (typeof condition !== "function") invalidQuery("RAW requires a structured-expression callback.");
-		const expression = condition(new Proxy(Object.create(null), { get: (_target, name) => ({ name }) }));
+		const expression = condition(fieldProxy());
 		validateExpression(expression);
-		expressions.push(expression);
+		expressions.push(resolveRelations(registry, collection, expression));
 	} else if (Object.hasOwn(registry[collection].relationships, field)) {
 		const relation = registry[collection].relationships[field];
 		const expression = {
@@ -350,18 +370,11 @@ function relationalPlan(registry, collection, options = {}, many = true, allowAd
 	if (Object.keys(options).some((key) => !allowed.includes(key))) invalidQuery("Unknown relational query option or unsupported scope option.");
 	const plan = emptyPlan(collection);
 	if (options.where !== void 0) plan.filters = [relationalWhere(registry, collection, options.where)];
-	if (options.columns === void 0) plan.allFields = true;
-	else {
+	if (options.columns !== void 0) {
 		record$1(options.columns, "columns");
 		const columns = options.columns;
-		if (Object.values(columns).some((value) => typeof value !== "boolean")) invalidQuery("Column selection requires boolean values.");
-		const names = checkedFields(registry, collection, Object.keys(columns));
-		const included = names.filter((name) => columns[name] === true);
-		if (included.length || !names.length) plan.select = included;
-		else {
-			plan.allFields = true;
-			plan.exclude = names;
-		}
+		if (Object.values(columns).some((value) => value !== true)) invalidQuery("Columns list the fields to include with `true`; omit fields you do not need.");
+		plan.select = checkedFields(registry, collection, Object.keys(columns));
 	}
 	if (options.with !== void 0) {
 		record$1(options.with, "with");
@@ -370,7 +383,8 @@ function relationalPlan(registry, collection, options = {}, many = true, allowAd
 			const relation = Object.hasOwn(registry[collection].relationships, name) && registry[collection].relationships[name];
 			if (!relation) invalidQuery(`Unknown relationship "${name}".`);
 			if (selected === false || selected === void 0) continue;
-			related[name] = relationalPlan(registry, relation.collection, selected === true ? {} : selected, relation.type === "many", allowAdjacent);
+			if (selected === true) invalidQuery(`Relationship "${name}" requires nested options that select data, such as { columns: { id: true } }.`);
+			related[name] = selectedPlan(relationalPlan(registry, relation.collection, selected, relation.type === "many", allowAdjacent));
 		}
 		plan.with = related;
 	}
@@ -385,7 +399,37 @@ function relationalPlan(registry, collection, options = {}, many = true, allowAd
 		const payloads = checkedPayloads(registry, collection, options.payloads);
 		if (payloads) plan.payloads = payloads;
 	}
-	if (options.adjacent !== void 0) plan.adjacent = options.adjacent === true ? true : relationalPlan(registry, collection, options.adjacent, true, false, false);
+	if (options.adjacent !== void 0) plan.adjacent = relationalAdjacent(registry, collection, options.adjacent);
+	return plan;
+}
+/**
+* Compiles relational `adjacent` options. `{ scope: "results", columns, with }` selects neighbors
+* within the current results; other options describe an independent sibling scope.
+*
+* @param registry - The query registry.
+* @param collection - The collection whose neighbors are selected.
+* @param adjacent - The `adjacent` option value.
+* @returns The adjacency plan, which always selects explicit data.
+*/
+function relationalAdjacent(registry, collection, adjacent) {
+	if (adjacent === true) invalidQuery("Adjacent entries select their own data, such as { scope: \"results\", columns: { id: true } }.");
+	record$1(adjacent, "adjacent");
+	const { scope, ...options } = adjacent;
+	if (scope !== void 0 && scope !== "results" && scope !== "collection") invalidQuery("Adjacent scope must be \"results\" or \"collection\".");
+	if (scope === "results" && Object.keys(options).some((key) => key !== "columns" && key !== "with")) invalidQuery("Results-scope neighbors only select data; they share the query's filters and order.");
+	return {
+		scope: scope === "results" ? "results" : "collection",
+		plan: selectedPlan(relationalPlan(registry, collection, options, true, false, false))
+	};
+}
+/**
+* Rejects a row-returning scope that requests no data.
+*
+* @param plan - A root, relationship, or sibling scope.
+* @returns The same plan when it selects fields, relationships, payloads, or adjacency.
+*/
+function selectedPlan(plan) {
+	if (!hasSelection(plan)) invalidQuery(NO_SELECTION_MESSAGE);
 	return plan;
 }
 /** Creates stable, live collection queries in a dedicated, prototype-free namespace. */
@@ -396,8 +440,8 @@ function createQueryNamespace(registry, run) {
 		let cached = queries.get(name);
 		if (!cached) {
 			cached = {
-				findMany: (options) => run(relationalPlan(registry(), name, options), "all"),
-				findFirst: (options) => run(relationalPlan(registry(), name, options), "first")
+				findMany: (options) => run(selectedPlan(relationalPlan(registry(), name, options)), "all"),
+				findFirst: (options) => run(selectedPlan(relationalPlan(registry(), name, options)), "first")
 			};
 			queries.set(name, cached);
 		}
@@ -492,6 +536,27 @@ function objectWhere(where) {
 	return detach(expression);
 }
 /** Compiles explicit object options into the backend-independent fluent query contract. */
+/**
+* Compiles an object-form `_adjacent` selection. `{ scope: "results", select }` selects neighbors
+* within the current results; other options describe an independent sibling scope.
+*
+* @param registry - The query registry.
+* @param collection - The collection whose neighbors are selected.
+* @param selection - The `_adjacent` value from an object selection.
+* @returns The adjacency plan, which always selects explicit data.
+*/
+function objectAdjacent(registry, collection, selection) {
+	record(selection, "_adjacent");
+	const { scope, ...options } = selection;
+	if (scope !== void 0 && scope !== "results" && scope !== "collection") invalidQuery("Adjacent scope must be \"results\" or \"collection\".");
+	if (scope === "results" && Object.keys(options).some((key) => key !== "select")) invalidQuery("Results-scope neighbors only select data; they share the query's filters and order.");
+	const plan = objectPlan(registry, collection, options, true, false, false);
+	if (!hasSelection(plan)) invalidQuery("Adjacent entries require explicit selection.");
+	return {
+		scope: scope === "results" ? "results" : "collection",
+		plan
+	};
+}
 function objectPlan(registry, collection, options, many = true, allowAdjacent = true, pagination = true) {
 	if (!Object.hasOwn(registry, collection)) invalidQuery(`Unknown collection "${collection}".`);
 	record(options, "Query");
@@ -504,9 +569,9 @@ function objectPlan(registry, collection, options, many = true, allowAdjacent =
 	if (Object.keys(options).some((key) => !allowed.includes(key))) invalidQuery("Unknown query option or pagination in an adjacency scope.");
 	let plan = emptyPlan(collection);
 	if (options.where !== void 0) {
-		const expression = typeof options.where === "function" ? options.where(new Proxy(Object.create(null), { get: (_target, name) => ({ name }) })) : objectWhere(options.where);
+		const expression = typeof options.where === "function" ? options.where(fieldProxy()) : objectWhere(options.where);
 		validateExpression(expression);
-		plan.filters = [detach(expression)];
+		plan.filters = [detach(resolveRelations(registry, collection, expression))];
 	}
 	if (options.orderBy !== void 0) for (const order of Array.isArray(options.orderBy) ? options.orderBy : [options.orderBy]) {
 		record(order, "orderBy");
@@ -522,8 +587,7 @@ function objectPlan(registry, collection, options, many = true, allowAdjacent =
 		const related = Object.create(null);
 		for (const [name, selection] of selected) if (name === "_adjacent") {
 			if (!allowAdjacent) invalidQuery("Adjacency cannot be selected recursively.");
-			plan.adjacent = selection === true ? true : objectPlan(registry, collection, selection, true, false, false);
-			if (plan.adjacent !== true && !plan.adjacent.select) invalidQuery("Adjacent entries require explicit selection.");
+			plan.adjacent = objectAdjacent(registry, collection, selection);
 		} else if (Object.hasOwn(registry[collection].relationships, name)) {
 			const relation = registry[collection].relationships[name];
 			const nested = objectPlan(registry, relation.collection, selection, relation.type === "many", allowAdjacent);
@@ -558,17 +622,13 @@ function createBuilder(registry, run, plan, many = true, root = true, scopeToken
 		[scopeSymbol]: scopeToken,
 		select(...fields) {
 			if (plan.select || fields.length === 0) invalidQuery("select() requires distinct prepared fields and can be called once per scope.");
-			return branch({
-				select: checkedFields(registry, plan.collection, fields),
-				allFields: void 0,
-				exclude: void 0
-			});
+			return branch({ select: checkedFields(registry, plan.collection, fields) });
 		},
 		where(configure) {
 			if (typeof configure !== "function") invalidQuery("where() requires a configuration callback.");
-			const expression = configure(new Proxy(Object.create(null), { get: (_target, name) => ({ name }) }));
+			const expression = configure(fieldProxy());
 			validateExpression(expression);
-			return branch({ filters: [...plan.filters, detach(expression)] });
+			return branch({ filters: [...plan.filters, detach(resolveRelations(registry, plan.collection, expression))] });
 		},
 		orderBy(field, direction = "asc") {
 			return branch({ order: checkedOrder(plan, field, direction, many) });
@@ -598,39 +658,75 @@ function createBuilder(registry, run, plan, many = true, root = true, scopeToken
 				[name]: checkedPayload(registry, plan.collection, name, variant)
 			} });
 		},
-		selectAdjacent(configure) {
+		/**
+		* Selects previous and next entries. Field names select neighbors within this scope's results;
+		* a callback or options object describes an independent sibling scope.
+		*/
+		selectAdjacent(...arguments_) {
 			if (!allowAdjacent || plan.adjacent !== void 0) invalidQuery("Adjacency cannot be repeated or selected recursively.");
-			if (configure === void 0) return branch({ adjacent: true });
+			const [configure] = arguments_;
+			if (configure === void 0 || typeof configure === "string") {
+				if (!arguments_.length || arguments_.some((field) => typeof field !== "string")) invalidQuery("selectAdjacent() requires neighbor fields, such as selectAdjacent(\"id\"), or a sibling query.");
+				const selection = {
+					...emptyPlan(plan.collection),
+					select: checkedFields(registry, plan.collection, arguments_)
+				};
+				return branch({ adjacent: {
+					scope: "results",
+					plan: selection
+				} });
+			}
 			if (typeof configure !== "function") {
 				const adjacent = objectPlan(registry, plan.collection, configure, true, false, false);
-				if (!adjacent.select) invalidQuery("Adjacent entries require explicit selection.");
-				return branch({ adjacent });
+				if (!hasSelection(adjacent)) invalidQuery("Adjacent entries require explicit selection.");
+				return branch({ adjacent: {
+					scope: "collection",
+					plan: adjacent
+				} });
 			}
 			const nestedScope = {};
 			const configured = configure(createBuilder(registry, run, emptyPlan(plan.collection), true, false, nestedScope, false, false));
 			const adjacent = configured && typeof configured === "object" && planSymbol in configured ? configured[planSymbol] : void 0;
 			if (!hasSelection(adjacent) || !(scopeSymbol in configured) || configured[scopeSymbol] !== nestedScope) invalidQuery("selectAdjacent() must return its explicitly selected sibling query.");
-			return branch({ adjacent });
+			return branch({ adjacent: {
+				scope: "collection",
+				plan: adjacent
+			} });
 		},
 		all() {
-			if (!root) invalidQuery("Nested builders have no terminal methods.");
-			return run(plan, "all");
+			return rows("all");
 		},
 		/** Executes a selected root query, matching direct await behavior. */
 		execute() {
-			if (!root) invalidQuery("Nested builders have no terminal methods.");
-			return run(plan, "all");
+			return rows("all");
 		},
 		first() {
-			if (!root) invalidQuery("Nested builders have no terminal methods.");
-			return run(plan, "first");
+			return rows("first");
 		},
+		/** Counts matching entries; counting returns no rows, so it needs no selection. */
 		count() {
 			if (!root) invalidQuery("Nested builders have no terminal methods.");
 			return run(plan, "count");
 		}
 	};
-	if (root && hasSelection(plan)) Object.defineProperty(builder, "then", { value: (fulfilled, rejected) => run(plan, "all").then(fulfilled, rejected) });
+	if (root) Object.defineProperty(builder, "then", { value: (fulfilled, rejected) => {
+		let result;
+		try {
+			result = rows("all");
+		} catch (cause) {
+			result = Promise.reject(cause);
+		}
+		return result.then(fulfilled, rejected);
+	} });
+	/**
+	* Runs a row-returning terminal. Awaiting an unselected root rejects rather than resolving to the
+	* builder, so a missing selection fails loudly in JavaScript as well as in TypeScript.
+	*/
+	function rows(terminal) {
+		if (!root) invalidQuery("Nested builders have no terminal methods.");
+		if (!hasSelection(plan)) invalidQuery(NO_SELECTION_MESSAGE);
+		return run(plan, terminal);
+	}
 	/** Checks pagination before creating an independent branch. */
 	function pagination(key, value) {
 		if (!allowPagination || plan[key] !== void 0) invalidQuery("Pagination requires a nonnegative safe integer, one call per clause, and a many-valued scope.");
@@ -639,20 +735,20 @@ function createBuilder(registry, run, plan, many = true, root = true, scopeToken
 	return builder;
 }
 //#endregion
-//#region src/query/select.ts
-/** Defers collection validation until from(), preserving the immutable selection across reuse. */
-function createSelect(registry, run, fields) {
-	const selected = [...fields];
-	return { 
-	/** Binds the current registry and prepares a reusable root query. */
-from(collection) {
-		const current = registry();
-		if (!Object.hasOwn(current, collection)) invalidQuery(`Unknown collection "${collection}".`);
-		const plan = emptyPlan(collection);
-		if (selected.length) plan.select = checkedFields(current, collection, selected);
-		else plan.allFields = true;
-		return createBuilder(current, run, plan);
-	} };
+//#region src/query/from.ts
+/**
+* Starts a fluent root query over one collection. The builder selects nothing until `select()`,
+* `with()`, `withPayload()`, or `selectAdjacent()` requests data; `count()` needs no selection.
+*
+* @param registry - Reads the current query registry, so development builders bind the latest one.
+* @param run - Executes a plan against one pinned revision.
+* @param collection - The collection to query.
+* @returns An immutable, reusable root builder.
+*/
+function createFrom(registry, run, collection) {
+	const current = registry();
+	if (typeof collection !== "string" || !Object.hasOwn(current, collection)) invalidQuery(`Unknown collection "${String(collection)}".`);
+	return createBuilder(current, run, emptyPlan(collection));
 }
 //#endregion
 //#region src/query/normalize.ts
@@ -667,7 +763,10 @@ function normalizePlan(plan) {
 		...plan.select === void 0 && Object.keys(plan.with).length ? { select: [] } : {},
 		filters: plan.filters.flatMap(conjunction),
 		with: Object.fromEntries(Object.entries(plan.with).map(([name, nested]) => [name, normalizePlan(nested)])),
-		...plan.adjacent && plan.adjacent !== true ? { adjacent: normalizePlan(plan.adjacent) } : {}
+		...plan.adjacent ? { adjacent: {
+			scope: plan.adjacent.scope,
+			plan: normalizePlan(plan.adjacent.plan)
+		} } : {}
 	};
 }
 //#endregion
@@ -698,6 +797,7 @@ function matches(record, expression, revision, collection) {
 		if (!revision || !relation || relation.collection !== expression.target) invalidQuery("Relationship filter no longer matches the prepared collection scope.");
 		return (revision.relations.get(relationKey(expression.collection, expression.field))?.get(record.id) ?? []).some((candidate) => matches(candidate, expression.expression, revision, expression.target));
 	}
+	if (expression.kind === "has") invalidQuery("has() filters must be passed to a query's where() before execution.");
 	if (expression.kind !== "predicate") return false;
 	const actual = Object.hasOwn(record, expression.field) ? record[expression.field] : void 0;
 	const expected = expression.value;
@@ -788,19 +888,17 @@ function pageRecords(records, plan, revision, preserveOrder = false) {
 }
 /** Builds a sibling index once per scope, before pagination and within the pinned revision. */
 function neighborScope(plan, records, preserveOrder, scopes, revision) {
-	const selection = plan.adjacent;
-	const siblingPlan = selection === true ? {
+	const { scope: neighborsScope, plan: selection } = plan.adjacent;
+	const siblingPlan = neighborsScope === "results" ? {
 		...plan,
-		select: ["id"],
-		allFields: void 0,
-		exclude: void 0,
-		with: {},
+		select: selection.select,
+		with: selection.with,
 		adjacent: void 0,
 		payloads: void 0,
 		limit: void 0,
 		offset: void 0
 	} : selection;
-	const key = selection === true ? plan : siblingPlan;
+	const key = neighborsScope === "results" ? plan : siblingPlan;
 	let candidates = scopes.get(key);
 	if (!candidates) {
 		candidates = /* @__PURE__ */ new WeakMap();
@@ -808,7 +906,7 @@ function neighborScope(plan, records, preserveOrder, scopes, revision) {
 	}
 	let scope = candidates.get(records);
 	if (!scope) {
-		const ordered = pageRecords([...new Map(records.map((entry) => [entry.id, entry])).values()], siblingPlan, revision, selection === true && preserveOrder);
+		const ordered = pageRecords([...new Map(records.map((entry) => [entry.id, entry])).values()], siblingPlan, revision, neighborsScope === "results" && preserveOrder);
 		scope = {
 			plan: siblingPlan,
 			records: ordered,
@@ -823,9 +921,8 @@ function neighborScope(plan, records, preserveOrder, scopes, revision) {
 * Requested payloads are recorded for the caller to load after projection.
 */
 function project(record, plan, revision, scopes, scopeRecords, requests, preserveScopeOrder = false) {
-	if (!plan.select && !plan.allFields && !plan.adjacent) invalidQuery("Row-returning queries require select().");
-	const fields = plan.allFields ? Object.keys(record).filter((field) => !plan.exclude?.includes(field)) : plan.select ?? [];
-	const result = detachSelection(record, fields);
+	if (!hasSelection(plan)) invalidQuery(NO_SELECTION_MESSAGE);
+	const result = detachSelection(record, plan.select ?? []);
 	for (const [name, nested] of Object.entries(plan.with)) {
 		const relation = revision.registry[plan.collection].relationships[name];
 		if (!relation || relation.collection !== nested.collection || relation.type === "one" && (nested.limit !== void 0 || nested.offset !== void 0 || nested.order.length > 0)) invalidQuery(`Relationship "${name}" no longer matches the prepared query scope.`);
@@ -840,7 +937,7 @@ function project(record, plan, revision, scopes, scopeRecords, requests, preserv
 		});
 	}
 	if (plan.adjacent) {
-		const candidates = plan.adjacent === true ? scopeRecords : revision.collections[plan.collection].records;
+		const candidates = plan.adjacent.scope === "results" ? scopeRecords : revision.collections[plan.collection].records;
 		const scope = neighborScope(plan, candidates, preserveScopeOrder, scopes, revision);
 		const index = scope.positions.get(record.id);
 		const previous = index === void 0 ? void 0 : scope.records[index - 1];
@@ -869,12 +966,50 @@ async function executeQuery(revision, plan, terminal, requests = []) {
 		if (plan.payloads) invalidQuery("Counts cannot request payloads.");
 		return queryCandidates(collection.records, plan).filter((record) => plan.filters.every((expression) => matches(record, expression, revision, plan.collection))).length;
 	}
-	if (!plan.select && !plan.allFields && !plan.adjacent) invalidQuery("Row-returning queries require select().");
+	if (!hasSelection(plan)) invalidQuery(NO_SELECTION_MESSAGE);
 	const records = pageRecords(queryCandidates(collection.records, plan), plan, revision);
 	const scopes = /* @__PURE__ */ new WeakMap();
 	return terminal === "first" ? records[0] ? project(records[0], plan, revision, scopes, collection.records, requests) : void 0 : records.map((record) => project(record, plan, revision, scopes, collection.records, requests));
 }
 //#endregion
+//#region src/runtime/query-style.ts
+/**
+* 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.
+*/
+const queryStyleMembers = {
+	fluent: ["from"],
+	relational: ["query", "count"]
+};
+/**
+* Checks whether a configured or manifest value names a supported query style.
+*
+* @param value - The untrusted `queryStyle` value.
+* @returns `true` for `"fluent"` or `"relational"`.
+*/
+function isQueryStyle(value) {
+	return value === "fluent" || value === "relational";
+}
+/**
+* Finds the style that owns a root member.
+*
+* @param member - A gated root `content` member.
+* @returns The style whose queries start at that member.
+*/
+function styleOfMember(member) {
+	return queryStyleMembers.fluent.includes(member) ? "fluent" : "relational";
+}
+/**
+* Formats the runtime message that matches {@link QueryStyleDisabled}.
+*
+* @param member - The disabled root member.
+* @param style - The only style the configuration allows.
+* @returns The error message.
+*/
+function queryStyleDisabledMessage(member, style) {
+	return `content.${member} is unavailable because content-query.config sets queryStyle to "${style}".`;
+}
+//#endregion
 //#region src/runtime/content.ts
 assertServerOnly();
 /** Maximum payload loads in flight for one query. */
@@ -951,11 +1086,48 @@ async function renderedPayload(revision, collection, id) {
 	}
 	return rendered;
 }
+/** Lazily loads one custom payload variant once per revision, retrying after failures. */
+function loadCustom(revision, collection, id, name, variant) {
+	const entries = revision.collections[collection].payloads?.get(name);
+	if (!entries) invalidQuery(`Payload "${name}" no longer matches the prepared collection.`);
+	const load = entries.get(id)?.get(variantKey(variant));
+	if (!load) return Promise.reject(new ContentError({
+		code: "variant-not-found",
+		operation: "query",
+		collection,
+		id,
+		payload: name,
+		variant,
+		message: `Entry "${id}" has no ${payloadIdentity(name, variant)} payload.`
+	}));
+	const key = JSON.stringify([
+		collection,
+		id,
+		name,
+		variantKey(variant)
+	]);
+	let loaded = revision.payloadCache.get(key);
+	if (!loaded) {
+		loaded = Promise.resolve().then(load).catch((cause) => {
+			revision.payloadCache.delete(key);
+			throw contentError(cause, {
+				code: "artifact-error",
+				collection,
+				id,
+				payload: name,
+				variant,
+				message: `Could not load the prepared ${payloadIdentity(name, variant)} payload.`
+			});
+		});
+		revision.payloadCache.set(key, loaded);
+	}
+	return loaded;
+}
 /** Loads one requested payload value from the pinned revision. */
-async function loadPayload(revision, collection, id, name) {
+async function loadPayload(revision, collection, id, name, variant) {
 	if (name === "_body") return (await loadBuiltin(revision, collection, id)).body;
 	if (name === "_rendered") return renderedPayload(revision, collection, id);
-	invalidQuery(`Payload "${name}" no longer matches the prepared collection.`);
+	return loadCustom(revision, collection, id, name, variant);
 }
 /**
 * Loads every requested payload with bounded concurrency, then attaches detached copies under
@@ -974,13 +1146,14 @@ async function attachPayloads(revision, requests) {
 		if (!loads.has(key)) loads.set(key, {
 			collection: request.collection,
 			id: request.id,
-			name
+			name,
+			variant: request.payloads[name].variant
 		});
 	}
 	const keys = [...loads.keys()];
 	const values = await mapConcurrent(keys, PAYLOAD_CONCURRENCY, (key) => {
-		const { collection, id, name } = loads.get(key);
-		return loadPayload(revision, collection, id, name);
+		const { collection, id, name, variant } = loads.get(key);
+		return loadPayload(revision, collection, id, name, variant);
 	});
 	const loaded = new Map(keys.map((key, index) => [key, values[index]]));
 	for (const request of requests) request.target._payloads = Object.fromEntries(Object.keys(request.payloads).map((name) => [name, detach(loaded.get(JSON.stringify([
@@ -990,7 +1163,13 @@ async function attachPayloads(revision, requests) {
 		request.payloads[name]
 	])))]));
 }
-/** Creates the initialized runtime without importing source configuration or schemas. */
+/**
+* Creates the initialized runtime without importing source configuration or schemas.
+*
+* @param state - Mutable session or artifact state; each query reads its current revision.
+* @returns The `content` API. Root members outside the current revision's `queryStyle` throw an
+* `invalid-query` ContentError when accessed or called.
+*/
 function createRuntime(state) {
 	/** Pins query execution and payload loading to exactly the same revision and executor. */
 	const run = (plan, terminal) => pinned(state, async (revision) => {
@@ -1002,12 +1181,23 @@ function createRuntime(state) {
 	});
 	/** Reads the current registry without capturing a development revision in either API. */
 	const registry = () => state.registry ?? state.revision?.registry ?? {};
+	/** Rejects a root member that the current revision's configured query style disables. */
+	function allow(member) {
+		const style = state.revision?.queryStyle;
+		if (style && styleOfMember(member) !== style) invalidQuery(queryStyleDisabledMessage(member, style));
+	}
+	const queries = createQueryNamespace(registry, run);
 	return {
-		select(...fields) {
-			return createSelect(registry, run, fields);
+		from(collection) {
+			allow("from");
+			return createFrom(registry, run, collection);
+		},
+		get query() {
+			allow("query");
+			return queries;
 		},
-		query: createQueryNamespace(registry, run),
 		count(collection, options = {}) {
+			allow("count");
 			return run(relationalPlan(registry(), collection, options), "count");
 		}
 	};
@@ -1025,4 +1215,4 @@ function createLiveRuntime(initial) {
 	};
 }
 //#endregion
-export { CODEC_VERSION as a, prepareRelationships as i, createRuntime as n, isRelationship as r, createLiveRuntime as t };
+export { isRelationship as a, variantKey as i, createRuntime as n, prepareRelationships as o, isQueryStyle as r, CODEC_VERSION as s, createLiveRuntime as t };