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

package/README.md

@@ -59,7 +59,7 @@ Install the URL printed by `astrale-domain deploy` on each intended instance.
 ## Handler authority and dependencies
 
 Handlers use Domain self authority for `kernel`, `graph`, Query V6 definitions, and a `mutate`
-given no options; a Query recipe, and a `mutate` given `{ as }`, name their authority on each call.
+given no options; a Query v7, and a `mutate` given `{ as }`, name their authority on each call.
 `dependencies.directory.caller.invoke(d => d.functions.lookup, input)` calls a direct declared
 dependency on behalf of the incoming caller Identity; `.self` calls it as the executing Domain.
 Explicit `caller` or `self` authority is also available on `kernel` and `graph`; the former
@@ -69,14 +69,14 @@ has no caller: its handler acts as the Domain alone, without the `caller` select
 
 ## Queries
 
-`defineQuery<Schema>()(id, { build, output?, errors? })` defines a Query recipe: typed handles over
+`defineQuery<Schema>()(id, { build, output?, errors? })` defines a Query: typed handles over
 the Domain (`d.Article.where((a) => a.state.eq('published')).first(50)`), reads bounded by
 their verbs, a pure `output` and declared errors. An Action calls
-`query(recipe, input, { as: 'executor' | 'caller' })`; a durable Workflow reads in
-`step.query(step, recipe, input, { as: 'executor' })`. Before anything is sent, the SDK checks the
-recipe's bounds and the requirements its relations need; `checkRecipe` from
+`query(query, input, { as: 'executor' | 'caller' })`; a durable Workflow reads in
+`step.query(step, query, input, { as: 'executor' })`. Before anything is sent, the SDK checks the
+Query's bounds and the requirements its relations need; `checkQuery` from
 `@astrale-os/sdk/testing` runs both checks in a test, on the first step it builds for a sample
-input. A recipe reads on a Host whose Kernel serves Query v7 and the Class of each row. Query V6
+input. A Query reads on a Host whose Kernel serves Query v7 and the Class of each row. Query V6
 definitions keep their meaning and are deprecated. See [the Query guide](docs/queries.md) and
 [Query V6 and the move to v7](docs/legacy/query-v6.md).
 

package/dist/application/action/authoring.d.ts

@@ -1,5 +1,5 @@
 export { defineAction } from './define.js';
 export type { Action, ActionDefinition } from './action.js';
-export type { ActionContext, ActionBinaryInput, ActionExecution, Caller, DomainGraphExecutor, DomainGraphExecutors, DomainKernelSessions, } from './context.js';
+export type { ActionContext, ActionBinaryInput, ActionExecution, Caller, DomainGraphExecutor, DomainGraphExecutors, DomainKernelSessions, DomainMutate, DomainQuery, } from './context.js';
 export type { ActionBinary, ActionOutputOf } from './output.js';
 export type { DeclaredErrorDefinition, DeclaredErrorFactory, DeclaredErrorFamily, DeclaredErrorOptions, DeclaredErrors, } from '../error/index.js';

package/dist/application/action/context.d.ts

@@ -6,8 +6,8 @@ import type { CallableInputOf, CallableInputModeOf, Domain, ResolvedFunction, Re
 import type { HandlerDependencies } from '../dependency/index.js';
 import type { DeclaredErrorFactory, DeclaredErrors, NoDeclaredErrors } from '../error/index.js';
 import type { IntegrationClients, Integrations } from '../integration/index.js';
-import type { Mutation, MutationExecutor, MutationInputOf, MutationOutputOf, MutationRecipe } from '../mutation/index.js';
-import type { InputOf, OutputOf, QueryDefinition, QueryExecutor, Recipe, RecipeOptions } from '../query/index.js';
+import type { Mutation, MutationExecutor, MutationInputOf, MutationOutputOf, DefinedMutation } from '../mutation/index.js';
+import type { InputOf, OutputOf, QueryDefinition, QueryExecutor, DefinedQuery, QueryOptions } from '../query/index.js';
 export type ResolvedCallable = ResolvedFunction | ResolvedMethod;
 /** Bearer-free caller evidence established before an Action or Workflow runs. */
 export interface AuthenticatedCaller {
@@ -38,7 +38,8 @@ export interface ActionExecution {
  * One admitted, single-consumer binary Function request body: the Core request body itself, so a
  * handler can hand it as it is to the Kernel's content upload without reading it first.
  */
-export type ActionBinaryInput = BinaryRequestBody;
+export interface ActionBinaryInput extends BinaryRequestBody {
+}
 type BinaryInputOf<Callable> = CallableInputModeOf<Callable> extends 'binary' ? {
     readonly body: ActionBinaryInput;
 } : {
@@ -56,20 +57,20 @@ export type AuthorityMode = 'caller' | 'self';
  */
 export type AuthorityName<Authority extends AuthorityMode = AuthorityMode> = Authority extends 'self' ? 'executor' : 'caller';
 /**
- * Reads under the authority `as` names. A recipe names it on every call; a V6 Query definition
+ * Reads under the authority `as` names. A Query v7 names it on every call; a V6 Query definition
  * reads as the executor.
  */
 export interface DomainQuery<DomainValue extends Domain = Domain, As extends AuthorityName = AuthorityName> {
-    <R extends Recipe>(recipe: R, input: InputOf<R>, options: RecipeOptions<R, As>): Promise<OutputOf<R>>;
+    <R extends DefinedQuery>(query: R, input: InputOf<R>, options: QueryOptions<R, As>): Promise<OutputOf<R>>;
     <Output>(query: QueryDefinition<DomainValue, void, Output>): Promise<Output>;
     <Input, Output>(query: QueryDefinition<DomainValue, Input, Output>, input: Input): Promise<Output>;
 }
 /**
- * Writes under the authority `as` names. A Mutation recipe names it on every call; a Mutation of
+ * Writes under the authority `as` names. A defined Mutation names it on every call; a Mutation of
  * the closure form may omit it, and writes as the executor.
  */
 export interface DomainMutate<DomainValue extends Domain = Domain, As extends AuthorityName = AuthorityName> {
-    <M extends MutationRecipe>(mutation: M, input: MutationInputOf<M>, options: {
+    <M extends DefinedMutation>(mutation: M, input: MutationInputOf<M>, options: {
         readonly as: As;
     }): Promise<MutationOutputOf<M>>;
     <Input, Output>(definition: Mutation<DomainValue, Input, Output>, input: Input, options: {
@@ -97,7 +98,7 @@ export interface DomainCapabilities<DomainValue extends Domain = Domain, Authori
     readonly dependencies: HandlerDependencies<DomainValue, Authority>;
     readonly kernel: DomainKernelSessions<Authority>;
     readonly graph: DomainGraphExecutors<DomainValue, Authority>;
-    /** A recipe under `as`; a V6 Query definition as the executor (`graph.self`). */
+    /** A Query v7 under `as`; a V6 Query definition as the executor (`graph.self`). */
     readonly query: DomainQuery<DomainValue, As>;
     /** A Mutation under `as`, or as the executor (`graph.self`). */
     readonly mutate: DomainMutate<DomainValue, As>;

package/dist/application/error/error.d.ts

@@ -10,7 +10,7 @@ export interface DeclaredErrorOptions<out Errors extends DeclaredErrors = Declar
 export type DeclaredErrorFactory<Errors extends DeclaredErrors> = <Code extends Extract<keyof Errors, string>>(code: Code, details: z.input<Errors[Code]['details']>) => Error;
 interface DeclaredErrorRecord {
     readonly definition: object;
-    /** The declaration as written: the object a Function re-declares a recipe's error with. */
+    /** The declaration as written: the object a Function re-declares a Query or Mutation error with. */
     readonly declaration: object;
     readonly code: string;
     readonly family: DeclaredErrorDefinition['family'];
@@ -20,19 +20,19 @@ interface DeclaredErrorRecord {
 /** Retain one implementation-local expected-error contract without publishing it in the Schema. */
 export declare function rememberDeclaredErrors(definition: object, input: unknown): void;
 /**
- * Retain a recipe's declared errors, as an implementation's are. A Function that declares one of
+ * Retain a Query or Mutation's declared errors, as an implementation's are. A Function that declares one of
  * its codes with the same definition object exposes that error to its own caller.
  */
-export declare function rememberRecipeErrors(recipe: object, id: string, input: unknown): void;
+export declare function rememberDefinedErrors(defined: object, id: string, input: unknown): void;
 /** Create a receiver-free factory closed over one admitted Action or Workflow definition. */
 export declare function declaredErrorFactory<Errors extends DeclaredErrors>(definition: object): DeclaredErrorFactory<Errors>;
 /**
  * Return admitted evidence only when the error belongs to the active implementation: raised by it,
- * or by a recipe whose code it declares with the same definition object.
+ * or by a Query or Mutation whose code it declares with the same definition object.
  */
 export declare function declaredErrorOf(input: unknown, definition: object): DeclaredErrorRecord | undefined;
-/** The code and the recipe id of a recipe's declared error, whichever Function it reaches. */
-export declare function recipeErrorOf(input: unknown): {
+/** The code and the id of a Query or Mutation's declared error, whichever Function it reaches. */
+export declare function definedErrorOf(input: unknown): {
     readonly code: string;
-    readonly recipe: string;
+    readonly id: string;
 } | undefined;

package/dist/application/error/error.js

@@ -5,8 +5,8 @@ const MAXIMUM_DETAILS_BYTES = 16 * 1024;
 const CODE_PATTERN = /^[A-Z][A-Z0-9_]{0,127}$/u;
 const declarations = new WeakMap();
 const errors = new WeakMap();
-/** Each recipe's id, by recipe: a recipe's errors cross into a Function that re-declares them. */
-const recipes = new WeakMap();
+/** The id of each Query or Mutation: their errors cross into a Function that re-declares them. */
+const definedIds = new WeakMap();
 class BusinessError extends Error {
     name = 'BusinessError';
     constructor(code) {
@@ -35,12 +35,12 @@ export function rememberDeclaredErrors(definition, input) {
     declarations.set(definition, accepted);
 }
 /**
- * Retain a recipe's declared errors, as an implementation's are. A Function that declares one of
+ * Retain a Query or Mutation's declared errors, as an implementation's are. A Function that declares one of
  * its codes with the same definition object exposes that error to its own caller.
  */
-export function rememberRecipeErrors(recipe, id, input) {
-    rememberDeclaredErrors(recipe, { errors: input });
-    recipes.set(recipe, id);
+export function rememberDefinedErrors(defined, id, input) {
+    rememberDeclaredErrors(defined, { errors: input });
+    definedIds.set(defined, id);
 }
 /** Create a receiver-free factory closed over one admitted Action or Workflow definition. */
 export function declaredErrorFactory(definition) {
@@ -81,7 +81,7 @@ export function declaredErrorFactory(definition) {
 }
 /**
  * Return admitted evidence only when the error belongs to the active implementation: raised by it,
- * or by a recipe whose code it declares with the same definition object.
+ * or by a Query or Mutation whose code it declares with the same definition object.
  */
 export function declaredErrorOf(input, definition) {
     if (!(input instanceof Error))
@@ -91,19 +91,19 @@ export function declaredErrorOf(input, definition) {
         return undefined;
     if (record.definition === definition)
         return record;
-    if (!recipes.has(record.definition))
+    if (!definedIds.has(record.definition))
         return undefined;
     return declarations.get(definition)?.get(record.code)?.declaration === record.declaration
         ? record
         : undefined;
 }
-/** The code and the recipe id of a recipe's declared error, whichever Function it reaches. */
-export function recipeErrorOf(input) {
+/** The code and the id of a Query or Mutation's declared error, whichever Function it reaches. */
+export function definedErrorOf(input) {
     const record = input instanceof Error ? errors.get(input) : undefined;
     if (record === undefined)
         return undefined;
-    const recipe = recipes.get(record.definition);
-    return recipe === undefined ? undefined : { code: record.code, recipe };
+    const id = definedIds.get(record.definition);
+    return id === undefined ? undefined : { code: record.code, id };
 }
 function isRecord(input) {
     return input !== null && typeof input === 'object' && !Array.isArray(input);

package/dist/application/error/index.d.ts

@@ -1,2 +1,2 @@
 export type { DeclaredErrorDefinition, DeclaredErrorFactory, DeclaredErrorFamily, DeclaredErrorOptions, DeclaredErrors, NoDeclaredErrors, } from './error.js';
-export { declaredErrorFactory, declaredErrorOf, recipeErrorOf, rememberDeclaredErrors, rememberRecipeErrors, } from './error.js';
+export { declaredErrorFactory, declaredErrorOf, definedErrorOf, rememberDeclaredErrors, rememberDefinedErrors, } from './error.js';

package/dist/application/error/index.js

@@ -1 +1 @@
-export { declaredErrorFactory, declaredErrorOf, recipeErrorOf, rememberDeclaredErrors, rememberRecipeErrors, } from './error.js';
+export { declaredErrorFactory, declaredErrorOf, definedErrorOf, rememberDeclaredErrors, rememberDefinedErrors, } from './error.js';

package/dist/application/mutation/authoring/builder.d.ts

@@ -10,10 +10,10 @@ import type { RichPropertyConditions, RichPropertyDelta, RichPropertyInput } fro
 import { type PreconditionNames } from './names.js';
 import { type EventOfTopology, type StatePropertyName, type StatePropertyTopology, type StateOfTopology, type StateTransitionInput } from './transition.js';
 /**
- * The builder a Mutation's `build` receives: of the recipe form over `Schema`
+ * The builder a Mutation's `build` receives: of a defined Mutation over `Schema`
  * (`RichMutationBuilder<Schema>`), or of the deprecated closure form (`RichMutationBuilder`).
  */
-export type RichMutationBuilder<Schema = never> = [Schema] extends [never] ? ClosureMutationBuilder : RecipeMutationBuilder<Schema>;
+export type RichMutationBuilder<Schema = never> = [Schema] extends [never] ? ClosureMutationBuilder : DefinedMutationBuilder<Schema>;
 /** A write names one Class: the handle of a union, `d.A.union(d.B)`, names none. */
 type OneClass<K, All = K> = K extends unknown ? [All] extends [K] ? unknown : '✗ a write names one Class, not a union' : never;
 /** A Node Class handle, `d.<Class>`, on which no method was called. */
@@ -27,41 +27,41 @@ interface HandleEdgeSelector<S, E extends string> {
     readonly class: EdgeClassHandle<S, E>;
 }
 /**
- * The builder a Mutation recipe's `build` receives (D31): each verb names its Class by its handle,
+ * The builder a defined Mutation's `build` receives (D31): each verb names its Class by its handle,
  * `d.<Class>`, and each guard takes a range. Each precondition verb (`expect.*`) takes `{ name }`
  * last: a refusal of the Mutation because that precondition fails carries the name as
  * `failure.precondition`. A name is unique in its Mutation.
  */
-export interface RecipeMutationBuilder<S> {
+export interface DefinedMutationBuilder<S> {
     readonly expect: {
         /** The Node exists, of this Class, and its Properties meet `props`. */
         node<K extends string>(input: {
             readonly node: ExistingEndpoint;
             readonly class: NodeClassHandle<S, K>;
             readonly props?: RichPropertyConditions<Cls<S, K>>;
-        }, options?: PreconditionOptions): RecipeMutationBuilder<S>;
+        }, options?: PreconditionOptions): DefinedMutationBuilder<S>;
         /** The Edge exists, its slug is `slug`, and its Properties meet `props`. */
         edge<E extends string>(input: HandleEdgeSelector<S, E> & {
             readonly slug?: EdgeSlug | null;
             readonly props?: RichPropertyConditions<Cls<S, E>>;
-        }, options?: PreconditionOptions): RecipeMutationBuilder<S>;
+        }, options?: PreconditionOptions): DefinedMutationBuilder<S>;
         /**
          * A guard (Mutation v4): no root of the range matches. A range is a Class handle after
          * `where`, `union` and `orderBy`, `d.<Class>.where(…)`, or a canonical v7 Query.
          */
-        none<K extends string>(range: GuardRange<S, K>, options?: PreconditionOptions): RecipeMutationBuilder<S>;
+        none<K extends string>(range: GuardRange<S, K>, options?: PreconditionOptions): DefinedMutationBuilder<S>;
         /** A guard (Mutation v4): a root of the range matches. */
-        exists<K extends string>(range: GuardRange<S, K>, options?: PreconditionOptions): RecipeMutationBuilder<S>;
+        exists<K extends string>(range: GuardRange<S, K>, options?: PreconditionOptions): DefinedMutationBuilder<S>;
         /**
          * A guard (Mutation v4): the number of the range's roots is `bounds`, or lies within
          * `{ atLeast?, atMost? }`, bounded at least once.
          */
-        count<K extends string>(range: GuardRange<S, K>, bounds: CountBounds, options?: PreconditionOptions): RecipeMutationBuilder<S>;
+        count<K extends string>(range: GuardRange<S, K>, bounds: CountBounds, options?: PreconditionOptions): DefinedMutationBuilder<S>;
         /**
          * A guard (Mutation v4): the range's roots, in its `orderBy`, are exactly these identities, in
          * the order a read of them returned them: a `NodeId` per Node, an `EdgeKey` per Edge.
          */
-        unchanged<K extends string>(range: GuardRange<S, K>, ids: readonly GuardIdentity[], options?: PreconditionOptions): RecipeMutationBuilder<S>;
+        unchanged<K extends string>(range: GuardRange<S, K>, ids: readonly GuardIdentity[], options?: PreconditionOptions): DefinedMutationBuilder<S>;
     };
     createNode<K extends string>(input: {
         readonly as: string;
@@ -91,8 +91,8 @@ export interface RecipeMutationBuilder<S> {
     }): this;
     deleteEdge<E extends string>(input: HandleEdgeSelector<S, E>): this;
 }
-/** The form of the Mutation a builder writes: a recipe's, or the deprecated closure form's. */
-export type BuilderForm = 'recipe' | 'closure';
+/** The form of the Mutation a builder writes: a defined Mutation's, or the deprecated closure form's. */
+export type BuilderForm = 'defined' | 'closure';
 /**
  * The SDK's builder over the core one, for both forms: a verb's Class is a Class handle
  * (`d.<Class>`) or, in the closure form only, the resolved Class, and only the closure form has a

package/dist/application/mutation/authoring/builder.js

@@ -59,7 +59,7 @@ export function richMutationBuilder(portable, names = preconditionNames(), form
             return rich;
         },
     };
-    const expectation = Object.freeze(form === 'recipe'
+    const expectation = Object.freeze(form === 'defined'
         ? guards
         : {
             ...guards,
@@ -149,8 +149,8 @@ export function richMutationBuilder(portable, names = preconditionNames(), form
 function writtenClass(selected, kind, form) {
     const cls = handleClass(selected);
     if (cls === undefined) {
-        if (form === 'recipe')
-            throw new TypeError('A Mutation recipe names each Class by its handle, `d.<Class>`.');
+        if (form === 'defined')
+            throw new TypeError('A defined Mutation names each Class by its handle, `d.<Class>`.');
         return selected;
     }
     if (kind === 'node' && cls.kind === 'edge')

package/dist/application/mutation/authoring/guard.d.ts

@@ -9,12 +9,12 @@ import type { MutationGuardInput } from '@astrale-os/kernel-core/graph/mutate';
 import type { NodeId } from '../../../platform/graph/node/index.js';
 import type { EdgeSet, NodeSet } from '../../query/handles/handles.js';
 import type { EdgeKey } from '../../query/handles/rows.js';
-import type { AnyQuery } from '../../query/language/query.js';
+import type { QueryDocument } from '../../query/language/query.js';
 /**
  * What a guard reads: a range, the Nodes or Edges of a Class handle `build` receives after
  * `where`, `union` and `orderBy`, or a canonical v7 Query.
  */
-export type GuardRange<S, K extends string> = NodeSet<S, K, {}, 'value', false> | EdgeSet<S, K, 'value', false> | AnyQuery;
+export type GuardRange<S, K extends string> = NodeSet<S, K, {}, 'value', false> | EdgeSet<S, K, 'value', false> | QueryDocument;
 /** How many roots a `count` guard admits: exactly `n`, or within bounds, bounded at least once. */
 export type CountBounds = number | {
     readonly atLeast?: number;

package/dist/application/mutation/authoring/index.d.ts

@@ -1,4 +1,4 @@
-export { richMutationBuilder, type BuilderForm, type RecipeMutationBuilder, type RichMutationBuilder, } from './builder.js';
+export { richMutationBuilder, type BuilderForm, type DefinedMutationBuilder, type RichMutationBuilder, } from './builder.js';
 export type { CreatedNode, ExistingEndpoint, MutationEndpoint } from './endpoint.js';
 export type { RichPropertyConditions, RichPropertyDelta, RichPropertyInput, RichPropertyName, } from './properties.js';
 export type { CountBounds, GuardIdentity, GuardRange, PreconditionOptions } from './guard.js';

package/dist/application/mutation/define.d.ts

@@ -1,26 +1,26 @@
 /**
- * `defineMutation<Schema>()`: one name for both forms. A string id first defines a Mutation recipe
+ * `defineMutation<Schema>()`: one name for both forms. A string id first defines a Mutation
  * (D31); a function first defines a Mutation of the closure form, deprecated, which stays in
- * `legacy/v6`. A recipe is inert: its id and the errors it declares are public, and what it
+ * `legacy/v6`. A defined Mutation is inert: its id and the errors it declares are public, and what it
  * writes is kept for the runtime.
  */
 import type { schema } from '../../platform/schema/index.js';
 import type { MutationProjector } from './legacy/v6/define.js';
-import type { MutationRecipeDefinitions } from './mutation.js';
+import type { DefinedMutationFactory } from './mutation.js';
 type Callback = (...parameters: never[]) => unknown;
-/** What a Mutation recipe writes and answers: its `build`, `output` and `reject`. */
-export interface MutationRecipeSpec {
+/** What a defined Mutation writes and answers: its `build`, `output` and `reject`. */
+export interface MutationSpec {
     /** Receives `(input, d, mutation)`. */
     readonly build: Callback;
     readonly output?: Callback;
     readonly reject?: Callback;
 }
-/** The `build`, `output` and `reject` of a Mutation recipe; `undefined` for anything else. */
-export declare function mutationRecipeSpecOf(recipe: unknown): MutationRecipeSpec | undefined;
+/** The `build`, `output` and `reject` of a defined Mutation; `undefined` for anything else. */
+export declare function mutationSpecOf(mutation: unknown): MutationSpec | undefined;
 /**
  * Define a Mutation: `defineMutation<Schema>()('issues.issue.open', { build, output?, reject?,
  * errors? })`. The closure form, `defineMutation<Schema>()((domain) => ({ id, build, project? }))`,
  * stays, deprecated.
  */
-export declare function defineMutation<Schema extends schema.DomainSchema>(): MutationRecipeDefinitions<Schema> & MutationProjector<Schema>;
+export declare function defineMutation<Schema extends schema.DomainSchema>(): DefinedMutationFactory<Schema> & MutationProjector<Schema>;
 export {};

package/dist/application/mutation/define.js

@@ -1,15 +1,15 @@
+import { collectDefinition, MAXIMUM_DEFINITION_ID, DEFINITION_ID } from '../query/defined/define.js';
 import { describe } from '../query/handles/terms.js';
-import { collectRecipe, MAXIMUM_RECIPE_ID, RECIPE_ID } from '../query/recipe/define.js';
 import { defineMutation as defineClosureMutation } from './legacy/v6/define.js';
 const FIELDS = new Set(['build', 'output', 'reject', 'errors']);
 const specs = new WeakMap();
-/** The `build`, `output` and `reject` of a Mutation recipe; `undefined` for anything else. */
-export function mutationRecipeSpecOf(recipe) {
-    return typeof recipe === 'object' && recipe !== null ? specs.get(recipe) : undefined;
+/** The `build`, `output` and `reject` of a defined Mutation; `undefined` for anything else. */
+export function mutationSpecOf(mutation) {
+    return typeof mutation === 'object' && mutation !== null ? specs.get(mutation) : undefined;
 }
-function defineMutationRecipe(id, spec) {
-    if (typeof id !== 'string' || id.length > MAXIMUM_RECIPE_ID || !RECIPE_ID.test(id))
-        throw new TypeError(`A Mutation id is lowercase segments of letters, digits and hyphens joined by dots, at most ${MAXIMUM_RECIPE_ID} characters ('issues.issue.open'); got ${describe(id)}.`);
+function defineV7Mutation(id, spec) {
+    if (typeof id !== 'string' || id.length > MAXIMUM_DEFINITION_ID || !DEFINITION_ID.test(id))
+        throw new TypeError(`A Mutation id is lowercase segments of letters, digits and hyphens joined by dots, at most ${MAXIMUM_DEFINITION_ID} characters ('issues.issue.open'); got ${describe(id)}.`);
     if (typeof spec !== 'object' || spec === null || Array.isArray(spec))
         throw new TypeError(`Mutation ${id} takes { build, output?, reject?, errors? }; got ${describe(spec)}.`);
     const fields = spec;
@@ -26,18 +26,18 @@ function defineMutationRecipe(id, spec) {
     const errors = fields.errors ?? {};
     if (typeof errors !== 'object' || errors === null || Array.isArray(errors))
         throw new TypeError(`Mutation ${id}'s errors is a record of declared errors by UPPER_SNAKE code; got ${describe(errors)}.`);
-    const recipe = Object.freeze({
+    const mutation = Object.freeze({
         kind: 'mutation',
         id,
         errors: Object.freeze({ ...errors }),
     });
-    collectRecipe(recipe);
-    specs.set(recipe, Object.freeze({
+    collectDefinition(mutation);
+    specs.set(mutation, Object.freeze({
         build: build,
         ...(output === undefined ? {} : { output: output }),
         ...(reject === undefined ? {} : { reject: reject }),
     }));
-    return recipe;
+    return mutation;
 }
 /**
  * Define a Mutation: `defineMutation<Schema>()('issues.issue.open', { build, output?, reject?,
@@ -47,6 +47,6 @@ function defineMutationRecipe(id, spec) {
 export function defineMutation() {
     const closure = defineClosureMutation();
     return ((first, spec) => typeof first === 'string'
-        ? defineMutationRecipe(first, spec)
+        ? defineV7Mutation(first, spec)
         : closure(first));
 }

package/dist/application/mutation/execution/execute.d.ts

@@ -1,9 +1,9 @@
 import { type MutationAST as MutationASTValue, type MutationResult } from '@astrale-os/kernel-core/graph/mutate';
 import type { GraphMutationOptions } from '../../../platform/client/index.js';
 import type { Domain } from '../../../platform/schema/index.js';
-import type { Mutation, MutationRecipe } from '../mutation.js';
+import type { Mutation, DefinedMutation } from '../mutation.js';
 /** Exact caller-scoped canonical document capability required by Mutation execution. */
 export type MutationClient = Readonly<{
     mutate(ast: MutationASTValue, options?: GraphMutationOptions): Promise<MutationResult>;
 }>;
-export declare function executeMutation<DomainValue extends Domain, Input, Output>(client: MutationClient, domain: DomainValue, definition: Mutation<DomainValue, Input, Output> | MutationRecipe<string, Input, Output>, input: Input): Promise<Output>;
+export declare function executeMutation<DomainValue extends Domain, Input, Output>(client: MutationClient, domain: DomainValue, definition: Mutation<DomainValue, Input, Output> | DefinedMutation<string, Input, Output>, input: Input): Promise<Output>;

package/dist/application/mutation/execution/execute.js

@@ -1,9 +1,9 @@
 import { MutationAST, } from '@astrale-os/kernel-core/graph/mutate';
-import { outputContext } from '../../query/execution/recipe.js';
+import { outputContext } from '../../query/execution/run.js';
 import { handlesOf } from '../../query/handles/build.js';
 import { modelOf } from '../../query/handles/model.js';
 import { preconditionNames, richMutationBuilder } from '../authoring/index.js';
-import { mutationRecipeSpecOf } from '../define.js';
+import { mutationSpecOf } from '../define.js';
 import { mutationFailure } from '../failure.js';
 import { realizeMutation } from '../legacy/v6/define.js';
 import { projectMutation } from './projection.js';
@@ -11,15 +11,15 @@ export async function executeMutation(client, domain, definition, input) {
     if (client === null || typeof client !== 'object' || typeof client.mutate !== 'function') {
         throw new TypeError('Mutation execution requires a Client mutate capability.');
     }
-    const spec = mutationRecipeSpecOf(definition);
+    const spec = mutationSpecOf(definition);
     const operation = spec === undefined
         ? closureOperation(definition, domain)
-        : recipeOperation(definition, spec, domain);
+        : definedOperation(definition, spec, domain);
     const names = preconditionNames();
     let ast;
     try {
-        // `build` receives the handles a recipe's does, for the Classes it names and the ranges its
-        // guards take.
+        // `build` receives the same handles as a Query's `build`, for the Classes it names and the
+        // ranges its guards take.
         const d = lazyHandles(domain);
         // What `build` returns reaches the core builder, which refuses a promise or a value.
         ast = MutationAST.build((builder) => operation.build(input, richMutationBuilder(builder, names, operation.form), d));
@@ -45,17 +45,17 @@ function closureOperation(mutation, domain) {
             : { reject: (failure) => definition.reject(failure) }),
     };
 }
-function recipeOperation(recipe, spec, domain) {
+function definedOperation(mutation, spec, domain) {
     const { build, output, reject } = spec;
     return {
-        form: 'recipe',
+        form: 'defined',
         build: (input, builder, d) => {
             const written = build(input, d, builder);
             if (isPromiseLike(written)) {
                 // Refused before any write is sent: a write after its first await fails, and is observed.
                 ;
                 written.then(undefined, () => undefined);
-                throw new TypeError(`Mutation ${recipe.id}'s build is synchronous: it writes the Mutation, and awaits nothing.`);
+                throw new TypeError(`Mutation ${mutation.id}'s build is synchronous: it writes the Mutation, and awaits nothing.`);
             }
             return written;
         },
@@ -63,7 +63,7 @@ function recipeOperation(recipe, spec, domain) {
         ...(reject === undefined
             ? {}
             : {
-                reject: (failure, input) => reject(failure, input, outputContext(recipe, modelOf(domain))),
+                reject: (failure, input) => reject(failure, input, outputContext(mutation, modelOf(domain))),
             }),
     };
 }

package/dist/application/mutation/execution/executor.d.ts

@@ -2,8 +2,8 @@ import type { Domain, schema } from '../../../platform/schema/index.js';
 import type { Mutation } from '../mutation.js';
 import type { MutationClient } from './execute.js';
 /**
- * Invocation-bound executor for Mutations of the closure form. A Mutation recipe names its
- * authority on each call, `mutate(recipe, input, { as })`, so it is refused here.
+ * Invocation-bound executor for Mutations of the closure form. A defined Mutation names its
+ * authority on each call, `mutate(mutation, input, { as })`, so it is refused here.
  */
 export interface MutationExecutor<DomainValue extends Domain = Domain> {
     <Input, Output>(definition: Mutation<DomainValue, Input, Output>, input: Input): Promise<Output>;

package/dist/application/mutation/execution/executor.js

@@ -1,10 +1,10 @@
-import { mutationRecipeSpecOf } from '../define.js';
+import { mutationSpecOf } from '../define.js';
 import { executeMutation } from './execute.js';
 /** Private Runtime binding to one Client and the exact loaded root Domain. */
 export function bindMutation(client, domain) {
     const executable = domain;
     const execute = async (definition, input) => {
-        if (mutationRecipeSpecOf(definition) !== undefined)
+        if (mutationSpecOf(definition) !== undefined)
             throw new TypeError(`Mutation ${definition.id} is called with mutate(mutation, input, { as: 'executor' | 'caller' }).`);
         return executeMutation(client, executable, definition, input);
     };

package/dist/application/mutation/index.d.ts

@@ -1,8 +1,8 @@
 export { defineMutation } from './define.js';
 export { executeMutation, type MutationClient, type MutationExecutor } from './execution/index.js';
 export type { MutationFailure } from './failure.js';
-export type { Mutation, MutationDefinition, MutationInputOf, MutationOutputOf, MutationRecipe, MutationRecipeDefinitions, } from './mutation.js';
-export type { ClosureMutationBuilder, CountBounds, CreatedNode, EdgeSelector, ExistingEndpoint, GuardIdentity, GuardRange, MutationEndpoint, PreconditionOptions, QueryPrecondition, RecipeMutationBuilder, RichMutationBuilder, RichPropertyConditions, RichPropertyDelta, RichPropertyInput, RichPropertyName, } from './authoring/index.js';
+export type { Mutation, MutationDefinition, MutationInputOf, MutationOutputOf, DefinedMutation, DefinedMutationFactory, } from './mutation.js';
+export type { ClosureMutationBuilder, CountBounds, CreatedNode, EdgeSelector, ExistingEndpoint, GuardIdentity, GuardRange, MutationEndpoint, PreconditionOptions, QueryPrecondition, DefinedMutationBuilder, RichMutationBuilder, RichPropertyConditions, RichPropertyDelta, RichPropertyInput, RichPropertyName, } from './authoring/index.js';
 /**
  * Canonical low-level Mutation documents remain available as the explicit escape hatch, listed one
  * by one as the SDK has exported them, so a newer Kernel's Mutation internals never reach it.

package/dist/application/mutation/legacy/v6/define.d.ts

@@ -6,7 +6,7 @@ type ResolvedDomainOf<Schema extends schema.DomainSchema> = Extract<schema.Domai
 type AuthoringDomainOf<Schema extends schema.DomainSchema> = ResolvedDomainOf<Schema>;
 export interface MutationProjector<Schema extends schema.DomainSchema> {
     /**
-     * @deprecated The closure form: define the Mutation as a recipe,
+     * @deprecated The closure form: define the Mutation from a string id,
      * `defineMutation<Schema>()(id, { build(input, d, mutation), output?, reject?, errors? })`. A
      * Mutation of this form called without `as` writes as the executor.
      */

package/dist/application/mutation/legacy/v6/mutation.d.ts

@@ -17,7 +17,7 @@ export interface Mutation<DomainValue extends Domain = Domain, Input = unknown,
 }
 /**
  * Canonical admitted operation produced by realizing one Mutation of the closure form. `build`
- * receives the handles `D` a recipe's `build` does, for the ranges its guards take.
+ * receives the same handles `D` as a Query's `build`, for the ranges its guards take.
  */
 export interface MutationDefinition<Input, Output = MutationResult, D = unknown> {
     readonly id: string;

package/dist/application/mutation/mutation.d.ts

@@ -1,35 +1,35 @@
 import type { MutationResult } from '@astrale-os/kernel-core/graph/mutate';
+import type { Errors, OutputContext } from '../query/defined/query.js';
 import type { Handles } from '../query/handles/handles.js';
-import type { Errors, OutputContext } from '../query/recipe/recipe.js';
-import type { RecipeMutationBuilder } from './authoring/builder.js';
+import type { DefinedMutationBuilder } from './authoring/builder.js';
 import type { MutationFailure } from './failure.js';
 import type { Mutation, MutationDefinition } from './legacy/v6/mutation.js';
 export type { Mutation, MutationDefinition } from './legacy/v6/mutation.js';
 /**
- * A Mutation of the recipe form (D31): inert, its id and the errors its `reject` may raise are
- * public, and what it writes is kept for the runtime. A call names its authority,
- * `mutate(recipe, input, { as: 'executor' | 'caller' })`.
+ * A Mutation defined from a string id (D31): inert, its id and the errors its `reject` may raise
+ * are public, and what it writes is kept for the runtime. A call names its authority,
+ * `mutate(mutation, input, { as: 'executor' | 'caller' })`.
  */
-export interface MutationRecipe<Id extends string = string, Input = unknown, Output = unknown, E extends Errors = Errors> {
+export interface DefinedMutation<Id extends string = string, Input = unknown, Output = unknown, E extends Errors = Errors> {
     readonly kind: 'mutation';
     readonly id: Id;
     readonly errors: E;
     readonly '~input'?: Input;
     readonly '~output'?: Output;
 }
-/** `defineMutation<Schema>()`'s recipe form: a string id first. */
-export interface MutationRecipeDefinitions<S> {
+/** `defineMutation<Schema>()` given a string id first. */
+export interface DefinedMutationFactory<S> {
     /**
      * `build` writes the Mutation with the builder, naming each Class by its handle, `d.<Class>`;
      * `output` maps the committed result, `reject` an expected refusal, and may raise a declared
      * error through `context.error`, which a Function that calls the Mutation re-declares.
      */
     <const Id extends string, Input, Output = MutationResult, E extends Errors = {}>(id: Id, spec: {
-        readonly build: (input: Input, d: Handles<S>, mutation: RecipeMutationBuilder<S>) => undefined;
+        readonly build: (input: Input, d: Handles<S>, mutation: DefinedMutationBuilder<S>) => undefined;
         readonly output?: (result: MutationResult, input: Input) => Output;
         readonly reject?: (failure: MutationFailure, input: Input, context: OutputContext<S, E>) => NoInfer<Output>;
         readonly errors?: E;
-    }): MutationRecipe<Id, Input, Output, E>;
+    }): DefinedMutation<Id, Input, Output, E>;
 }
-export type MutationInputOf<Value> = Value extends MutationRecipe<string, infer Input, infer _Output, Errors> ? Input : Value extends Mutation<infer _Domain, infer Input, infer _Output> ? Input : Value extends MutationDefinition<infer Input, infer _Output> ? Input : never;
-export type MutationOutputOf<Value> = Value extends MutationRecipe<string, infer _Input, infer Output, Errors> ? Output : Value extends Mutation<infer _Domain, infer _Input, infer Output> ? Output : Value extends MutationDefinition<infer _Input, infer Output> ? Output : never;
+export type MutationInputOf<Value> = Value extends DefinedMutation<string, infer Input, infer _Output, Errors> ? Input : Value extends Mutation<infer _Domain, infer Input, infer _Output> ? Input : Value extends MutationDefinition<infer Input, infer _Output> ? Input : never;
+export type MutationOutputOf<Value> = Value extends DefinedMutation<string, infer _Input, infer Output, Errors> ? Output : Value extends Mutation<infer _Domain, infer _Input, infer Output> ? Output : Value extends MutationDefinition<infer _Input, infer Output> ? Output : never;

package/dist/application/query/composite/builder.js

@@ -12,7 +12,7 @@ export function createQueryComposition() {
             requireOpen(open);
             requireLocalId(id, ids);
             if (definition?.kind !== 'query')
-                invalid('Composite leaves must be single Query recipes.');
+                invalid('Composite leaves must be single Queries.');
             requireLocalReferences(input, token);
             return createPlan(token, Object.freeze({
                 kind: 'leaf',