@astrale-os/sdk 0.6.0-beta.43 → 0.6.0-beta.45

package/dist/application/query/execution/rows.d.ts

@@ -20,12 +20,12 @@ interface Item {
     readonly target?: Item;
     readonly branches: Readonly<Record<string, unknown>>;
 }
-/** What renders one answer: the recipe it errs for, the Domain's Classes, the answer's facts. */
+/** What renders one answer: the Query it errs for, the Domain's Classes, the answer's facts. */
 export declare class Renderer {
     #private;
-    readonly recipe: string;
+    readonly query: string;
     readonly model: Model;
-    constructor(recipe: string, model: Model, answer: QueryListAnswer<unknown, unknown>);
+    constructor(query: string, model: Model, answer: QueryListAnswer<unknown, unknown>);
     /** A Node row, or `undefined` when the reader may not read it and the read does not keep it. */
     node(item: Item, pattern: Pattern): Json | undefined;
     /** An Edge root row: its identity, its values and both ends by role. */
@@ -36,7 +36,7 @@ export declare class Renderer {
     rootOne(item: Item, root: NodeRootPlan | EdgeRootPlan): Json;
 }
 /** The answer of a root read with nothing to read: its verb's empty answer. */
-export declare function emptyResult(recipe: string, plan: ReadPlan): unknown;
+export declare function emptyResult(query: string, plan: ReadPlan): unknown;
 /** A root read's result from its answer, by its verb. */
-export declare function rootResult(recipe: string, model: Model, plan: ReadPlan, answer: unknown): unknown;
+export declare function rootResult(query: string, model: Model, plan: ReadPlan, answer: unknown): unknown;
 export {};

package/dist/application/query/execution/rows.js

@@ -1,15 +1,16 @@
 import { factKey, factsOf } from '../answer/facts.js';
+import { QueryValueMismatchError } from '../failure.js';
 import { ROW_KEYS } from '../handles/model.js';
 import { QueryError } from './error.js';
 const NO_TAKEN = new Set();
 const freeze = (value) => Object.freeze(value);
-/** What renders one answer: the recipe it errs for, the Domain's Classes, the answer's facts. */
+/** What renders one answer: the Query it errs for, the Domain's Classes, the answer's facts. */
 export class Renderer {
-    recipe;
+    query;
     model;
     #facts;
-    constructor(recipe, model, answer) {
-        this.recipe = recipe;
+    constructor(query, model, answer) {
+        this.query = query;
         this.model = model;
         this.#facts = factsOf(answer);
     }
@@ -22,7 +23,7 @@ export class Renderer {
     }
     #class(item) {
         if (item.class === undefined)
-            throw new QueryError('UNSUPPORTED', this.recipe, { feature: 'classes' });
+            throw new QueryError('UNSUPPORTED', this.query, { feature: 'classes' });
         return item.class;
     }
     /**
@@ -46,11 +47,19 @@ export class Renderer {
         return (candidates.find((c) => candidates.every((o) => this.model.satisfies(c).has(o.key))) ??
             candidates[0]);
     }
-    /** The values of a fact by the layout of a Class: flat names, then groups (F6). */
+    /**
+     * The values of a fact by the layout of a Class: flat names, then groups (F6). The row types a
+     * required value as present, so a fact without one breaks the Domain as a value that does not
+     * match its Property does.
+     */
     #values(fact, c, taken) {
         if (c === undefined)
             return {};
         const values = (this.#fact(fact)?.values ?? {});
+        for (const property of c.properties) {
+            if (property.definition.required && values[property.key] === undefined)
+                throw new QueryValueMismatchError(`${factKey(fact)} has no value for ${property.key}, which its Property requires in this Domain`);
+        }
         const { flat, groups } = this.model.layout(c, taken);
         const row = {};
         for (const [name, key] of flat)
@@ -83,12 +92,15 @@ export class Renderer {
             Object.assign(row, this.#values(id, layout, ROW_KEYS));
         for (const branch of pattern.branches)
             row[branch.key] = this.#relation(item, branch);
-        if ('edge' in pattern && pattern.edge && item.edge !== undefined)
-            row.$edge = this.#edgeValues(item.edge);
+        const edge = pattern.edge;
+        if (edge !== undefined && item.edge !== undefined)
+            row.$edge = this.#edgeValues(item.edge, edge);
         return freeze(row);
     }
-    /** What `.withEdge()` adds: the Edge's Class and values, or the names it withholds. */
-    #edgeValues(edge) {
+    /** What `.withEdge()` adds: the Edge's Class, and its values or the names it withholds. */
+    #edgeValues(edge, select) {
+        if (select === 'reference')
+            return freeze({ $class: edge.class });
         const c = this.#known(edge.class);
         if (this.#withheld(edge))
             return freeze({ $class: edge.class, $withheld: this.#names(c) });
@@ -116,14 +128,13 @@ export class Renderer {
         const row = { ...identity };
         if (plan.select === 'value')
             Object.assign(row, this.#values(key, c, roles));
-        const end = (rendered, classes) => {
+        const end = (rendered, { classes, select }) => {
             if (rendered === undefined)
                 return undefined;
-            const pattern = { classes, select: plan.select, withheld: true, branches: [] };
-            return this.node(rendered, pattern);
+            return this.node(rendered, { classes, select, withheld: true, branches: [] });
         };
-        row[plan.source.role] = end(item.source, plan.source.classes);
-        row[plan.target.role] = end(item.target, plan.target.classes);
+        row[plan.source.role] = end(item.source, plan.source);
+        row[plan.target.role] = end(item.target, plan.target);
         return freeze(row);
     }
     /** A relation's answer for one parent, by its verb. */
@@ -154,7 +165,7 @@ export class Renderer {
                 return items[0] === undefined ? undefined : this.node(items[0], plan);
             case 'all':
                 if (items.length > plan.bound)
-                    throw new QueryError('TOO_MANY', this.recipe, { limit: 'max', bound: plan.bound });
+                    throw new QueryError('TOO_MANY', this.query, { limit: 'max', bound: plan.bound });
                 return this.#rows(items, plan);
             default:
                 return this.#rows(items, plan);
@@ -176,12 +187,12 @@ export class Renderer {
         }
     }
     #integrity(at, found) {
-        return new QueryError('INTEGRITY', this.recipe, { ...at, found });
+        return new QueryError('INTEGRITY', this.query, { ...at, found });
     }
     /** The one row `get` or `find` gives: one the reader may not read is an error, since it exists. */
     #one(item, pattern) {
         if (this.#withheld(item.fact))
-            throw new QueryError('NOT_READABLE', this.recipe, { class: this.#class(item), id: item.fact });
+            throw new QueryError('NOT_READABLE', this.query, { class: this.#class(item), id: item.fact });
         return this.node(item, pattern);
     }
     #rows(items, pattern) {
@@ -195,7 +206,7 @@ export class Renderer {
     rootOne(item, root) {
         if (this.#withheld(item.fact)) {
             const fact = item.fact;
-            throw new QueryError('NOT_READABLE', this.recipe, {
+            throw new QueryError('NOT_READABLE', this.query, {
                 class: typeof fact === 'string' ? this.#class(item) : fact.class,
                 id: fact,
             });
@@ -208,10 +219,10 @@ function classLabel(plan) {
     return plan.root?.classes.join(' | ') ?? '';
 }
 /** The answer of a root read with nothing to read: its verb's empty answer. */
-export function emptyResult(recipe, plan) {
+export function emptyResult(query, plan) {
     switch (plan.verb) {
         case 'get':
-            throw new QueryError('NOT_FOUND', recipe, {
+            throw new QueryError('NOT_FOUND', query, {
                 class: classLabel(plan),
                 ...(plan.target === undefined ? {} : { target: plan.target }),
             });
@@ -231,24 +242,24 @@ export function emptyResult(recipe, plan) {
     }
 }
 /** A root read's result from its answer, by its verb. */
-export function rootResult(recipe, model, plan, answer) {
+export function rootResult(query, model, plan, answer) {
     const json = answer;
     if ('exists' in json)
         return json.exists === true;
     if ('count' in json)
         return freeze({ count: json.count, more: json.more === true });
     const listAnswer = answer;
-    const renderer = new Renderer(recipe, model, listAnswer);
+    const renderer = new Renderer(query, model, listAnswer);
     const { items, complete, cursor } = listAnswer.list;
     const root = plan.root ?? documentRoot(plan);
     switch (plan.verb) {
         case 'get':
         case 'find': {
             if (items.length > 1)
-                throw new QueryError('INTEGRITY', recipe, { relation: classLabel(plan), found: 2 });
+                throw new QueryError('INTEGRITY', query, { relation: classLabel(plan), found: 2 });
             const [item] = items;
             if (item === undefined)
-                return emptyResult(recipe, plan);
+                return emptyResult(query, plan);
             return renderer.rootOne(item, root);
         }
         case 'first':
@@ -264,7 +275,7 @@ export function rootResult(recipe, model, plan, answer) {
             });
         case 'all':
             if (items.length > plan.bound)
-                throw new QueryError('TOO_MANY', recipe, { limit: 'max', bound: plan.bound });
+                throw new QueryError('TOO_MANY', query, { limit: 'max', bound: plan.bound });
             return renderer.rootRows(items, root);
         default:
             return renderer.rootRows(items, root);
@@ -282,7 +293,7 @@ function documentRoot(plan) {
         relation: b.name,
         verb: b.mode === 'count' ? 'count' : 'firstN',
         empty: false,
-        edge: b.selectEdge !== undefined,
+        edge: b.selectEdge,
         classes: [],
         select: b.select === 'value' ? 'value' : 'reference',
         withheld: false,
@@ -297,12 +308,13 @@ function documentRoot(plan) {
             branches: branches(list),
         };
     const select = (list.select ?? {});
+    const rendering = (side) => (select[side] === 'value' ? 'value' : 'reference');
     return {
         kind: 'edges',
         classes: [],
-        select: select.edge === 'value' ? 'value' : 'reference',
+        select: rendering('edge'),
         withheld: false,
-        source: { role: 'source', classes: [] },
-        target: { role: 'target', classes: [] },
+        source: { role: 'source', classes: [], select: rendering('source') },
+        target: { role: 'target', classes: [], select: rendering('target') },
     };
 }

package/dist/application/query/execution/{recipe.d.ts → run.d.ts}

@@ -1,49 +1,39 @@
 /**
- * Run a v7 recipe (WP-S3): its steps in order, each one's reads together, at most 8 in flight,
+ * Run a Query v7 (WP-S3): its steps in order, each one's reads together, at most 8 in flight,
  * each read at its own snapshot (the stand-in); then `output`. A step's bounds (S11) are checked
  * before it sends anything, and every Kernel refusal of a read is a `QueryError`.
  */
 import type { Domain } from '../../../platform/schema/index.js';
+import type { Errors, InputOf, OutputContext, OutputOf, DefinedQuery } from '../defined/query.js';
 import type { ReadPlan } from '../handles/plan.js';
-import type { AnyQuery } from '../language/query.js';
-import type { Errors, InputOf, OutputContext, OutputOf, Recipe } from '../recipe/recipe.js';
+import type { QueryClient } from './client.js';
 import { type Model } from '../handles/model.js';
 import { type DeclaredClass } from './crossings.js';
-/** What a recipe sends a read with: the cursor a page continues. */
-export interface RecipeQueryOptions {
-    readonly paging?: {
-        readonly after: string;
-    };
-}
-/** The client a recipe reads through: one v7 document per request. */
-export interface RecipeClient {
-    query(document: AnyQuery, options: RecipeQueryOptions): Promise<unknown>;
-}
-/** A page recipe's call: its size, from 1 to its `max` (by default), and the cursor it continues. */
-export interface RecipeCallOptions {
+/** A page Query's call: its size, from 1 to its `max` (by default), and the cursor it continues. */
+export interface QueryPageOptions {
     readonly size?: number;
     readonly after?: string;
 }
-/** A recipe call's options: the authority it reads under, and a page recipe's size and cursor. */
-export type RecipeOptions<R, As extends string> = {
+/** A Query call's options: the authority it reads under, and a page Query's size and cursor. */
+export type QueryOptions<R, As extends string> = {
     readonly as: As;
-} & ('~page' extends keyof R ? RecipeCallOptions : {});
+} & ('~page' extends keyof R ? QueryPageOptions : {});
 type Step = (...parameters: readonly unknown[]) => unknown;
-/** One recipe call: its reads so far, against S11, and the Classes they cross, against S12. */
+/** One Query call: its reads so far, against S11, and the Classes they cross, against S12. */
 export declare class Run {
     #private;
-    readonly client: RecipeClient;
+    readonly client: QueryClient;
     readonly domain: Domain;
-    readonly recipe: string;
+    readonly query: string;
     readonly model: Model;
-    constructor(client: RecipeClient, domain: Domain, recipe: string, declared?: readonly DeclaredClass[]);
+    constructor(client: QueryClient, domain: Domain, query: string, declared?: readonly DeclaredClass[]);
     /**
      * S11, before a step sends: its reads, its verbs' bounds, its rows and each property `in` its
      * documents write. Then S12: each foreign Class its relations cross.
      */
     admit(plans: readonly ReadPlan[]): void;
     /** One read's result: its verb's empty answer, or its documents' answers merged and rendered. */
-    read(plan: ReadPlan, paging?: RecipeCallOptions): Promise<unknown>;
+    read(plan: ReadPlan, paging?: QueryPageOptions): Promise<unknown>;
 }
 /** What `steps(…)` returned: its first record of facets, and the functions of the next ones. */
 interface StepsOf {
@@ -51,11 +41,11 @@ interface StepsOf {
     readonly next: readonly Step[];
 }
 /**
- * The `steps` a recipe's `build` receives: two to eight steps, the first a record of facets and
+ * The `steps` a Query's `build` receives: two to eight steps, the first a record of facets and
  * each next one a function of the merged results before it. It reads nothing: what it returns is
  * read when `build` returns it.
  */
-export declare function stepsFor(recipe: string): (...steps: readonly unknown[]) => object;
+export declare function stepsFor(query: string): (...steps: readonly unknown[]) => object;
 /** The steps `build` returned, or `undefined` for one read or one record of facets. */
 export declare function stepsOf(built: unknown): StepsOf | undefined;
 /** Where each facet's results go: one read's index, a list of them, or nothing. */
@@ -70,16 +60,16 @@ export declare function planStep(run: Run, built: unknown, single: boolean, earl
     readonly shape?: Shape;
 };
 /**
- * Run a recipe for `input` against `domain`, the resolved Domain it was written for: what `build`
- * returns, each of its steps in order, then its `output`. A page recipe takes its call's `size`
- * and `after`. A read the Kernel refuses raises a `QueryError`; `output` raises the recipe's
+ * Run a Query for `input` against `domain`, the resolved Domain it was written for: what `build`
+ * returns, each of its steps in order, then its `output`. A page Query takes its call's `size`
+ * and `after`. A read the Kernel refuses raises a `QueryError`; `output` raises the Query's
  * declared errors. With the Class requirements
  * the Domain's build `declared`, each step's relations are checked against them first (S12).
  */
-export declare function runQueryRecipe<R extends Recipe>(client: RecipeClient, domain: Domain, recipe: R, input: InputOf<R>, call?: RecipeCallOptions, declared?: readonly DeclaredClass[]): Promise<OutputOf<R>>;
+export declare function runQuery<R extends DefinedQuery>(client: QueryClient, domain: Domain, query: R, input: InputOf<R>, call?: QueryPageOptions, declared?: readonly DeclaredClass[]): Promise<OutputOf<R>>;
 /**
- * The context a recipe's `output`, or a Mutation recipe's `reject`, receives: its declared errors,
+ * The context a Query's `output`, or a defined Mutation's `reject`, receives: its declared errors,
  * and `is`, which narrows a row by Class.
  */
-export declare function outputContext(recipe: object, model: Model): OutputContext<unknown, Errors>;
+export declare function outputContext(query: object, model: Model): OutputContext<unknown, Errors>;
 export {};

package/dist/application/query/execution/{recipe.js → run.js}

@@ -2,11 +2,11 @@ import * as errors from '@astrale-os/kernel-protocol/errors';
 import { isSnapshotStale, ResponseError, retryAfterOf } from '../../../platform/client/index.js';
 import { declaredErrorFactory } from '../../error/error.js';
 import { requireAnswerConformance } from '../answer/conformance.js';
+import { querySpecOf } from '../defined/define.js';
 import { handlesOf } from '../handles/build.js';
 import { modelOf } from '../handles/model.js';
 import { isRead, planOf } from '../handles/plan.js';
 import { describe } from '../handles/terms.js';
-import { recipeSpecOf } from '../recipe/define.js';
 import { MAXIMUM_BOUND, MAXIMUM_READS, MAXIMUM_ROWS, MAXIMUM_STEPS, pastPage, rowsOf, wideIn, } from './bounds.js';
 import { Crossings } from './crossings.js';
 import { QueryError } from './error.js';
@@ -19,19 +19,19 @@ const IN_FLIGHT = 8;
 const STALE_RESENDS = 3;
 /** A refusal's protocol code by name, for one that gives no reason. */
 const CODE_NAMES = new Map(Object.entries(errors.CODES).map(([name, code]) => [code, name]));
-/** One recipe call: its reads so far, against S11, and the Classes they cross, against S12. */
+/** One Query call: its reads so far, against S11, and the Classes they cross, against S12. */
 export class Run {
     client;
     domain;
-    recipe;
+    query;
     #reads = 0;
     #rows = 0;
     model;
     #crossings;
-    constructor(client, domain, recipe, declared) {
+    constructor(client, domain, query, declared) {
         this.client = client;
         this.domain = domain;
-        this.recipe = recipe;
+        this.query = query;
         this.model = modelOf(domain);
         this.#crossings =
             declared === undefined ? undefined : new Crossings(this.model, domain, declared);
@@ -43,28 +43,28 @@ export class Run {
     admit(plans) {
         this.#reads += plans.length;
         if (this.#reads > MAXIMUM_READS)
-            throw new QueryError('TOO_MANY', this.recipe, { limit: 'reads', bound: MAXIMUM_READS });
+            throw new QueryError('TOO_MANY', this.query, { limit: 'reads', bound: MAXIMUM_READS });
         if (plans.some(pastPage))
-            throw new QueryError('TOO_MANY', this.recipe, { limit: 'rows', bound: MAXIMUM_BOUND });
+            throw new QueryError('TOO_MANY', this.query, { limit: 'rows', bound: MAXIMUM_BOUND });
         this.#rows += plans.reduce((total, plan) => total + rowsOf(plan), 0);
         if (this.#rows > MAXIMUM_ROWS)
-            throw new QueryError('TOO_MANY', this.recipe, { limit: 'rows', bound: MAXIMUM_ROWS });
+            throw new QueryError('TOO_MANY', this.query, { limit: 'rows', bound: MAXIMUM_ROWS });
         for (const plan of plans) {
             const path = plan.document === undefined ? undefined : wideIn(plan.document);
             // Into the request `{ document, paging }`, as the Kernel's refusals point.
             if (path !== undefined)
-                throw new QueryError('INPUT_INVALID', this.recipe, {
+                throw new QueryError('INPUT_INVALID', this.query, {
                     limit: 'in',
                     path: `/document${path}`,
                 });
         }
         for (const plan of plans)
-            this.#crossings?.check(this.recipe, plan);
+            this.#crossings?.check(this.query, plan);
     }
     /** One read's result: its verb's empty answer, or its documents' answers merged and rendered. */
     async read(plan, paging) {
         if (plan.empty)
-            return emptyResult(this.recipe, plan);
+            return emptyResult(this.query, plan);
         let document = plan.document;
         if (plan.verb === 'page' && paging?.size !== undefined)
             document = withLimit(document, paging.size);
@@ -78,7 +78,7 @@ export class Run {
                 requireAnswerConformance(this.domain, answer);
             answers.push(answer);
         }
-        return rootResult(this.recipe, this.model, plan, merge(document, answers));
+        return rootResult(this.query, this.model, plan, merge(document, answers));
     }
     async #send(document, after) {
         const paging = after === undefined ? {} : { paging: { after } };
@@ -105,25 +105,25 @@ export class Run {
         const details = (error.reason?.details ?? {});
         const cause = { cause: error };
         if (isSnapshotStale(error))
-            return new QueryError('REFUSED', this.recipe, { kernelCode, retryable: true }, cause);
+            return new QueryError('REFUSED', this.query, { kernelCode, retryable: true }, cause);
         const refusals = refusalsOf(error);
         if (refusals !== undefined) {
             const path = refusals[0]?.path ?? (typeof details.path === 'string' ? details.path : undefined);
-            return new QueryError('INPUT_INVALID', this.recipe, {
+            return new QueryError('INPUT_INVALID', this.query, {
                 kernelCode,
                 ...(typeof details.phase === 'string' ? { phase: details.phase } : {}),
                 ...(path === undefined ? {} : { path }),
             }, { ...cause, ...(refusals.length === 0 ? {} : { reason: describeRefusals(refusals) }) });
         }
         if (kernelCode === 'QUERY_EXPECTATION_MISMATCH')
-            return new QueryError('OUTDATED', this.recipe, { kernelCode: 'QUERY_EXPECTATION_MISMATCH' }, cause);
+            return new QueryError('OUTDATED', this.query, { kernelCode: 'QUERY_EXPECTATION_MISMATCH' }, cause);
         // A Kernel that predates v7 refuses its request at the Function's input.
         if (isUnserved(error))
-            return new QueryError('UNSUPPORTED', this.recipe, { feature: 'v7' }, cause);
+            return new QueryError('UNSUPPORTED', this.query, { feature: 'v7' }, cause);
         // Only a trusted backend answers v7 (a maintenance session's refusal says when to retry).
         if (kernelCode === 'QUERY_BACKEND_CONTRACT')
-            return new QueryError('UNSUPPORTED', this.recipe, { feature: 'v7' }, cause);
-        return new QueryError('REFUSED', this.recipe, { kernelCode, retryable: false }, cause);
+            return new QueryError('UNSUPPORTED', this.query, { feature: 'v7' }, cause);
+        return new QueryError('REFUSED', this.query, { kernelCode, retryable: false }, cause);
     }
 }
 /** A page document of `size` rows. */
@@ -153,22 +153,22 @@ async function pooled(tasks, limit) {
 }
 const stepped = new WeakMap();
 /**
- * The `steps` a recipe's `build` receives: two to eight steps, the first a record of facets and
+ * The `steps` a Query's `build` receives: two to eight steps, the first a record of facets and
  * each next one a function of the merged results before it. It reads nothing: what it returns is
  * read when `build` returns it.
  */
-export function stepsFor(recipe) {
+export function stepsFor(query) {
     return (...steps) => {
         if (steps.length < 2 || steps.length > MAXIMUM_STEPS)
-            throw new TypeError(`Recipe ${recipe}: steps takes 2 to ${MAXIMUM_STEPS} steps; got ${steps.length}. ${steps.length < 2
+            throw new TypeError(`Query ${query}: steps takes 2 to ${MAXIMUM_STEPS} steps; got ${steps.length}. ${steps.length < 2
                 ? 'Reads that wait for none are what build returns: one read, or a record of facets.'
                 : 'Read the facets that wait for the same results in one step.'}`);
         const [first, ...next] = steps;
         if (!isFacets(first))
-            throw new TypeError(`Recipe ${recipe}: the first step is a record of facets; got ${described(first)}.`);
+            throw new TypeError(`Query ${query}: the first step is a record of facets; got ${described(first)}.`);
         const position = next.findIndex((step) => typeof step !== 'function');
         if (position !== -1)
-            throw new TypeError(`Recipe ${recipe}: each step after the first is a function of the results before it; step ${position + 2} is ${describe(next[position])}.`);
+            throw new TypeError(`Query ${query}: each step after the first is a function of the results before it; step ${position + 2} is ${describe(next[position])}.`);
         const value = Object.freeze({});
         stepped.set(value, Object.freeze({ first, next: Object.freeze(next) }));
         return value;
@@ -197,19 +197,19 @@ export function stepsOf(built) {
  * The facets a step returned, each a read, a list of reads (`items.map`) or nothing. One read is
  * `build`'s alone, without steps: each step returns a record of facets.
  */
-function facetsOf(recipe, built, single) {
+function facetsOf(query, built, single) {
     if (!isFacets(built)) {
         const expected = single
             ? 'build returns one read, a record of facets, or steps(…)'
             : 'each step returns a record of facets';
-        throw new TypeError(`Recipe ${recipe}: ${expected}; got ${described(built)}.`);
+        throw new TypeError(`Query ${query}: ${expected}; got ${described(built)}.`);
     }
     return Object.entries(built);
 }
-/** A page is a recipe's single read: one step that returns it. */
-function refusePage(recipe, plan) {
+/** A page is a Query's single read: one step that returns it. */
+function refusePage(query, plan) {
     if (plan.verb === 'page')
-        throw new TypeError(`Recipe ${recipe}: a page is a recipe's single read (D22); read the others with first or all.`);
+        throw new TypeError(`Query ${query}: a page is a Query's single read (D22); read the others with first or all.`);
 }
 /**
  * The reads of one step, admitted (S11, S12): a single read, or each facet's in order and the
@@ -222,10 +222,10 @@ export function planStep(run, built, single, earlier = {}) {
         run.admit(plans);
         return { plans };
     }
-    const facets = facetsOf(run.recipe, built, single);
+    const facets = facetsOf(run.query, built, single);
     for (const [name] of facets)
         if (Object.hasOwn(earlier, name))
-            throw new TypeError(`Recipe ${run.recipe}: an earlier step read the facet ${name}; name this step's facet otherwise.`);
+            throw new TypeError(`Query ${run.query}: an earlier step read the facet ${name}; name this step's facet otherwise.`);
     const plans = [];
     const shape = [];
     for (const [name, facet] of facets) {
@@ -236,7 +236,7 @@ export function planStep(run, built, single, earlier = {}) {
         else
             shape.push([name, plans.push(planOf(facet)) - 1]);
     }
-    plans.forEach((plan) => refusePage(run.recipe, plan));
+    plans.forEach((plan) => refusePage(run.query, plan));
     run.admit(plans);
     return { plans, shape };
 }
@@ -259,41 +259,41 @@ async function runStep(run, built, single, call, earlier) {
     return Object.freeze(record);
 }
 /** The size and cursor of a page call, checked against the page's `max`. */
-function pageCall(recipe, call, max) {
+function pageCall(query, call, max) {
     const { size, after } = call;
     if (max === undefined) {
         if (size !== undefined || after !== undefined)
-            throw new TypeError(`Recipe ${recipe} is not a page: size and after continue a page recipe.`);
+            throw new TypeError(`Query ${query} is not a page: size and after continue a page Query.`);
         return {};
     }
     if (size !== undefined && (!Number.isInteger(size) || size < 1 || size > max))
-        throw new TypeError(`Recipe ${recipe}: size is a whole number from 1 to the page's max, ${max}; got ${describe(size)}.`);
+        throw new TypeError(`Query ${query}: size is a whole number from 1 to the page's max, ${max}; got ${describe(size)}.`);
     if (after !== undefined && (typeof after !== 'string' || after.length === 0))
-        throw new TypeError(`Recipe ${recipe}: after is the cursor a page returned as next.`);
+        throw new TypeError(`Query ${query}: after is the cursor a page returned as next.`);
     return { size: size ?? max, ...(after === undefined ? {} : { after }) };
 }
 /**
- * Run a recipe for `input` against `domain`, the resolved Domain it was written for: what `build`
- * returns, each of its steps in order, then its `output`. A page recipe takes its call's `size`
- * and `after`. A read the Kernel refuses raises a `QueryError`; `output` raises the recipe's
+ * Run a Query for `input` against `domain`, the resolved Domain it was written for: what `build`
+ * returns, each of its steps in order, then its `output`. A page Query takes its call's `size`
+ * and `after`. A read the Kernel refuses raises a `QueryError`; `output` raises the Query's
  * declared errors. With the Class requirements
  * the Domain's build `declared`, each step's relations are checked against them first (S12).
  */
-export async function runQueryRecipe(client, domain, recipe, input, call = {}, declared) {
-    const spec = recipeSpecOf(recipe);
+export async function runQuery(client, domain, query, input, call = {}, declared) {
+    const spec = querySpecOf(query);
     if (spec === undefined)
-        throw new TypeError(`Not a v7 recipe: define one with defineQuery<Schema>()(id, { build }); got ${describe(recipe)}.`);
-    const run = new Run(client, domain, recipe.id, declared);
-    const built = spec.build(input, handlesOf(domain), stepsFor(recipe.id));
+        throw new TypeError(`Not a Query v7: define one with defineQuery<Schema>()(id, { build }); got ${describe(query)}.`);
+    const run = new Run(client, domain, query.id, declared);
+    const built = spec.build(input, handlesOf(domain), stepsFor(query.id));
     const steps = stepsOf(built);
     let answered;
     if (steps === undefined) {
         const page = isRead(built) && planOf(built).verb === 'page';
-        const options = pageCall(recipe.id, call, page ? planOf(built).bound : undefined);
+        const options = pageCall(query.id, call, page ? planOf(built).bound : undefined);
         answered = await runStep(run, built, true, options, {});
     }
     else {
-        pageCall(recipe.id, call, undefined);
+        pageCall(query.id, call, undefined);
         let merged = {};
         for (const step of [() => steps.first, ...steps.next]) {
             const results = await runStep(run, step(Object.freeze({ ...merged })), false, {}, merged);
@@ -303,15 +303,15 @@ export async function runQueryRecipe(client, domain, recipe, input, call = {}, d
     }
     if (spec.output === undefined)
         return answered;
-    return spec.output(answered, input, outputContext(recipe, run.model));
+    return spec.output(answered, input, outputContext(query, run.model));
 }
 /**
- * The context a recipe's `output`, or a Mutation recipe's `reject`, receives: its declared errors,
+ * The context a Query's `output`, or a defined Mutation's `reject`, receives: its declared errors,
  * and `is`, which narrows a row by Class.
  */
-export function outputContext(recipe, model) {
+export function outputContext(query, model) {
     return {
-        error: declaredErrorFactory(recipe),
+        error: declaredErrorFactory(query),
         is: (row, cls) => {
             try {
                 return model.satisfies(model.classOf(row.$class)).has(cls);

package/dist/application/query/execution/split.d.ts

@@ -1,5 +1,5 @@
 import type { QueryCountAnswer, QueryExistsAnswer, QueryListAnswer } from '../answer/answer.js';
-import type { AnyQuery } from '../language/query.js';
+import type { QueryDocument } from '../language/query.js';
 /** The Kernel's set members per v7 document: ids and value-set points, guards included. */
 export declare const MAXIMUM_MEMBERS = 32768;
 type ListAnswer = QueryListAnswer<unknown, unknown>;
@@ -15,10 +15,10 @@ export declare function membersOf(value: unknown): number;
  * an ordered read can merge. A document whose members lie elsewhere is sent whole, and the Kernel
  * names the limit.
  */
-export declare function split(document: AnyQuery, values: boolean): readonly AnyQuery[];
+export declare function split(document: QueryDocument, values: boolean): readonly QueryDocument[];
 /**
  * The answers of a split read as one: a list merged in the document's order and cut to its limit,
  * `exists` if any slice has one, a count summed up to its bound.
  */
-export declare function merge(document: AnyQuery, answers: readonly Answer[]): Answer;
+export declare function merge(document: QueryDocument, answers: readonly Answer[]): Answer;
 export {};

package/dist/application/query/execution/split.js

@@ -1,5 +1,5 @@
 /**
- * Long id lists (spec § Recipes: the contract, § Semantics): a document past the Kernel's set
+ * Long id lists (spec § Queries: the contract, § Semantics): a document past the Kernel's set
  * members is sent as several, its root id list split, and their answers merged back in the
  * Kernel's order and cut to the read's limit. Only a Node root's id list splits, and only for a
  * read that is not a page: a page's cursor continues one document.

package/dist/application/query/handles/build.d.ts

@@ -1,5 +1,5 @@
 /**
- * The handles a recipe's `build` receives (S1), built once per resolved Domain: its own Classes,
+ * The handles a Query's `build` receives (S1), built once per resolved Domain: its own Classes,
  * each dependency under its alias, the Kernel's Classes under `kernel`, its Core nodes under
  * `core`, `origin`, and `document`, the escape hatch (D23). The fixed names win over a Class or
  * an alias of the same name.

package/dist/application/query/handles/domain.d.ts

@@ -1,5 +1,5 @@
 /**
- * The Domain a recipe reads, indexed once per Schema (spike designs D1, D3 and D10).
+ * The Domain a Query reads, indexed once per Schema (spike designs D1, D3 and D10).
  *
  * Every generic is keyed by the Schema type `S` and Class keys, never by resolved Classes:
  * instantiations are cached per (Schema, key), and messages print the key. The Domain is indexed