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

package/README.md

@@ -75,7 +75,7 @@ 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
-`@astrale-os/sdk/testing` runs both checks in a test, on the first stage it builds for a sample
+`@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
 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/query/execution/bounds.d.ts

@@ -4,8 +4,10 @@
  */
 import type { ReadPlan } from '../handles/plan.js';
 import type { AnyQuery } from '../language/query.js';
-/** Each read of each stage, and each element of an `items.map`. */
+/** Each read of each step, and each element of an `items.map`. */
 export declare const MAXIMUM_READS = 32;
+/** Steps of one recipe: `steps(first, (earlier) => next, …)` takes two to this many. */
+export declare const MAXIMUM_STEPS = 8;
 /** Across a recipe's nested lists. */
 export declare const MAXIMUM_ROWS = 100000;
 /** A verb's bound: its list, plus one for `all` and `first(n, { more })`, fits a Kernel page. */

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

@@ -1,5 +1,7 @@
-/** Each read of each stage, and each element of an `items.map`. */
+/** Each read of each step, and each element of an `items.map`. */
 export const MAXIMUM_READS = 32;
+/** Steps of one recipe: `steps(first, (earlier) => next, …)` takes two to this many. */
+export const MAXIMUM_STEPS = 8;
 /** Across a recipe's nested lists. */
 export const MAXIMUM_ROWS = 100_000;
 /** A verb's bound: its list, plus one for `all` and `first(n, { more })`, fits a Kernel page. */

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

@@ -1,15 +1,22 @@
 /**
  * The Classes a recipe's relations cross, checked against what its Domain declares (S12, spec §
- * Details settled: "When S12 runs"). A relation that crosses a Class of a dependency needs `read`
- * and `traverse` on it in the Domain's requirements, or the read is a programming error, raised at
- * lowering before anything is sent, never answered as empty. It reads the document as written,
- * so an empty list the input gives refuses what any other list does. A requirement on a parent
- * covers its children, and an abstract Class with concrete children, each covered, is covered:
- * the check refuses only what no declaration serves.
+ * Details settled: "When S12 runs"). A relation that crosses a Class of a dependency other than the
+ * Kernel needs `read` and `traverse` on it in the Domain's requirements, or the read is a
+ * programming error, raised at lowering before anything is sent, never answered as empty. It reads
+ * the document as written, so an empty list the input gives refuses what any other list does. A
+ * requirement on a parent covers its children, and an abstract Class with concrete children, each
+ * covered, is covered: the check refuses only what no declaration serves.
  */
 import { Key } from '@astrale-os/kernel-dsl/v1/addressing';
 /** What a relation needs on each foreign Class it crosses. */
 const NEEDED = ['read', 'traverse'];
+/**
+ * The Kernel's origin. Its Classes need nothing, even when the Domain declares it a dependency, but
+ * the dependency Classes under an abstract one (`Identity`, `Node`) each do.
+ */
+const KERNEL = 'kernel.astrale.ai';
+/** The Kernel's abstract Edge Class. Every Edge Class is under it, though none names it a parent. */
+const EDGE = `${KERNEL}:class.Edge`;
 /**
  * The S12 refusal: a `TypeError`, the same for every input and every attempt, so a durable Step
  * fails at once on it.
@@ -27,7 +34,7 @@ export class UndeclaredCrossing extends TypeError {
 /** The S12 check of one Domain: its dependencies, and the operations it declares on their Classes. */
 export class Crossings {
     model;
-    /** Each direct dependency's origin, by the alias the Domain gives it. */
+    /** Each direct dependency's origin but the Kernel's, by the alias the Domain gives it. */
     #dependencies = new Map();
     /** The operations declared on each Class, by key. */
     #declared = new Map();
@@ -36,7 +43,8 @@ export class Crossings {
     constructor(model, domain, declared) {
         this.model = model;
         for (const [alias, dependency] of Object.entries(domain.dependencies))
-            this.#dependencies.set(dependency.origin, alias);
+            if (dependency.origin !== KERNEL)
+                this.#dependencies.set(dependency.origin, alias);
         for (const requirement of declared) {
             const key = Key.of(requirement.class);
             const operations = this.#declared.get(key) ?? new Set();
@@ -115,6 +123,12 @@ export class Crossings {
         return [...new Set(classes)];
     }
     #require(recipe, relation, c) {
+        if (c.ref.origin === KERNEL) {
+            if (c.abstract)
+                for (const child of this.#under(c))
+                    this.#require(recipe, relation, child);
+            return;
+        }
         const alias = this.#dependencies.get(c.ref.origin);
         if (alias === undefined)
             return;
@@ -127,14 +141,23 @@ export class Crossings {
     }
     /** What a Class lacks of `read` and `traverse`, declared on it or on a parent. */
     #missing(c) {
-        const declared = new Set([...this.model.satisfies(c)].flatMap((key) => [...(this.#declared.get(key) ?? [])]));
+        const declared = new Set([...this.#satisfies(c)].flatMap((key) => [...(this.#declared.get(key) ?? [])]));
         return NEEDED.filter((operation) => !declared.has(operation));
     }
     /** An abstract Class has concrete Classes under it, and the Domain may cross each. */
     #covered(c) {
-        const children = this.#concrete.filter((k) => this.model.satisfies(k).has(c.key));
+        const children = this.#under(c);
         return children.length > 0 && children.every((k) => this.#served(k));
     }
+    /** The concrete Classes under a Class, of the Domain and its dependencies. */
+    #under(c) {
+        return this.#concrete.filter((k) => this.#satisfies(k).has(c.key));
+    }
+    /** The keys a Class satisfies, the Kernel's `Edge` included for an Edge Class. */
+    #satisfies(c) {
+        const keys = this.model.satisfies(c);
+        return c.kind === 'edge' ? new Set([...keys, EDGE]) : keys;
+    }
     /** Whether a relation may cross a Class: the Domain's own, or a dependency's it declares. */
     #served(c) {
         return !this.#dependencies.has(c.ref.origin) || this.#missing(c).length === 0;

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

@@ -1,6 +1,6 @@
 /**
- * Run a v7 recipe (WP-S3): its stages in order, each one's reads together, at most 8 in flight,
- * each read at its own snapshot (the stand-in); then `output`. A stage's bounds (S11) are checked
+ * Run a v7 recipe (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';
@@ -28,6 +28,7 @@ export interface RecipeCallOptions {
 export type RecipeOptions<R, As extends string> = {
     readonly as: As;
 } & ('~page' extends keyof R ? RecipeCallOptions : {});
+type Step = (...parameters: readonly unknown[]) => unknown;
 /** One recipe call: its reads so far, against S11, and the Classes they cross, against S12. */
 export declare class Run {
     #private;
@@ -37,29 +38,43 @@ export declare class Run {
     readonly model: Model;
     constructor(client: RecipeClient, domain: Domain, recipe: string, declared?: readonly DeclaredClass[]);
     /**
-     * S11, before a stage sends: its reads, its verbs' bounds, its rows and each property `in` its
+     * 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>;
 }
+/** What `steps(…)` returned: its first record of facets, and the functions of the next ones. */
+interface StepsOf {
+    readonly first: unknown;
+    readonly next: readonly Step[];
+}
+/**
+ * The `steps` a recipe'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;
+/** 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. */
 type Shape = readonly (readonly [string, number | readonly number[] | undefined])[];
 /**
- * The reads of one stage, admitted (S11, S12): a single read, or each facet's in order and the
- * shape that puts their results back. A facet takes a name no `earlier` stage read: the merged
+ * The reads of one step, admitted (S11, S12): a single read, or each facet's in order and the
+ * shape that puts their results back. A facet takes a name no `earlier` step read: the merged
  * results keep one value per name.
  */
-export declare function planStage(run: Run, built: unknown, single: boolean, earlier?: Readonly<Record<string, unknown>>): {
+export declare function planStep(run: Run, built: unknown, single: boolean, earlier?: Readonly<Record<string, unknown>>): {
     readonly plans: readonly ReadPlan[];
     readonly shape?: Shape;
 };
 /**
- * Run a recipe for `input` against `domain`, the resolved Domain it was written for: its stages,
- * 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 declared errors. With the Class requirements
- * the Domain's build `declared`, each stage's relations are checked against them first (S12).
+ * 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
+ * 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>>;
 /**

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

@@ -7,13 +7,13 @@ 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, pastPage, rowsOf, wideIn } from './bounds.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';
 import { describeRefusals, isUnserved, refusalsOf } from './refusal.js';
 import { emptyResult, rootResult } from './rows.js';
 import { merge, split } from './split.js';
-/** Reads of one stage in flight at once. */
+/** Reads of one step in flight at once. */
 const IN_FLIGHT = 8;
 /** `QUERY_SNAPSHOT_STALE`: nothing was read, so the read is sent again at once, this many times. */
 const STALE_RESENDS = 3;
@@ -37,7 +37,7 @@ export class Run {
             declared === undefined ? undefined : new Crossings(this.model, domain, declared);
     }
     /**
-     * S11, before a stage sends: its reads, its verbs' bounds, its rows and each property `in` its
+     * 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) {
@@ -151,28 +151,72 @@ async function pooled(tasks, limit) {
     await Promise.all(Array.from({ length: Math.min(limit, tasks.length) }, worker));
     return results;
 }
+const stepped = new WeakMap();
 /**
- * The facets a stage returned, each a read, a list of reads (`items.map`) or nothing. One read is
- * a single stage's alone: each of several returns a record of facets.
+ * The `steps` a recipe'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) {
+    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
+                ? '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)}.`);
+        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])}.`);
+        const value = Object.freeze({});
+        stepped.set(value, Object.freeze({ first, next: Object.freeze(next) }));
+        return value;
+    };
+}
+/** A record of facets: a plain object, neither a read nor what `steps` returned. */
+function isFacets(value) {
+    if (typeof value !== 'object' || value === null || isRead(value) || stepped.has(value))
+        return false;
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}
+/** What a step was, for its refusal: `steps(…)` and a Promise are named with their fix. */
+function described(value) {
+    if (typeof value === 'object' && value !== null && stepped.has(value))
+        return 'steps(…), which only build returns';
+    if (value instanceof Promise)
+        return 'a Promise: build and its steps are not async';
+    return describe(value);
+}
+/** The steps `build` returned, or `undefined` for one read or one record of facets. */
+export function stepsOf(built) {
+    return typeof built === 'object' && built !== null ? stepped.get(built) : undefined;
+}
+/**
+ * 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) {
-    if (typeof built !== 'object' || built === null || Array.isArray(built) || isRead(built)) {
-        const expected = single ? 'a stage returns one read or' : 'each of several stages returns';
-        throw new TypeError(`Recipe ${recipe}: ${expected} a record of facets; got ${describe(built)}.`);
+    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)}.`);
     }
     return Object.entries(built);
 }
-/** A page is a recipe's single read: one stage that returns it. */
+/** A page is a recipe's single read: one step that returns it. */
 function refusePage(recipe, 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.`);
 }
 /**
- * The reads of one stage, admitted (S11, S12): a single read, or each facet's in order and the
- * shape that puts their results back. A facet takes a name no `earlier` stage read: the merged
+ * The reads of one step, admitted (S11, S12): a single read, or each facet's in order and the
+ * shape that puts their results back. A facet takes a name no `earlier` step read: the merged
  * results keep one value per name.
  */
-export function planStage(run, built, single, earlier = {}) {
+export function planStep(run, built, single, earlier = {}) {
     if (single && isRead(built)) {
         const plans = [planOf(built)];
         run.admit(plans);
@@ -181,7 +225,7 @@ export function planStage(run, built, single, earlier = {}) {
     const facets = facetsOf(run.recipe, built, single);
     for (const [name] of facets)
         if (Object.hasOwn(earlier, name))
-            throw new TypeError(`Recipe ${run.recipe}: an earlier stage read the facet ${name}; name this stage's facet otherwise.`);
+            throw new TypeError(`Recipe ${run.recipe}: an earlier step read the facet ${name}; name this step's facet otherwise.`);
     const plans = [];
     const shape = [];
     for (const [name, facet] of facets) {
@@ -196,9 +240,9 @@ export function planStage(run, built, single, earlier = {}) {
     run.admit(plans);
     return { plans, shape };
 }
-/** The results of one stage: a read's result, or a record of each facet's. */
-async function runStage(run, built, single, call, earlier) {
-    const { plans, shape } = planStage(run, built, single, earlier);
+/** The results of one step: a read's result, or a record of each facet's. */
+async function runStep(run, built, single, call, earlier) {
+    const { plans, shape } = planStep(run, built, single, earlier);
     if (shape === undefined) {
         const plan = plans[0];
         return run.read(plan, plan.verb === 'page' ? call : undefined);
@@ -229,30 +273,34 @@ function pageCall(recipe, call, max) {
     return { size: size ?? max, ...(after === undefined ? {} : { after }) };
 }
 /**
- * Run a recipe for `input` against `domain`, the resolved Domain it was written for: its stages,
- * 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 declared errors. With the Class requirements
- * the Domain's build `declared`, each stage's relations are checked against them first (S12).
+ * 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
+ * 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);
     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 d = handlesOf(domain);
-    const single = spec.stages.length === 1;
-    let results;
-    let merged = {};
-    for (const [index, stage] of spec.stages.entries()) {
-        const built = index === 0
-            ? stage(input, d)
-            : stage(Object.freeze({ ...merged }), input, d);
-        const page = single && isRead(built) && planOf(built).verb === 'page';
+    const built = spec.build(input, handlesOf(domain), stepsFor(recipe.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);
-        results = await runStage(run, built, single, options, merged);
-        merged = { ...merged, ...results };
+        answered = await runStep(run, built, true, options, {});
+    }
+    else {
+        pageCall(recipe.id, call, undefined);
+        let merged = {};
+        for (const step of [() => steps.first, ...steps.next]) {
+            const results = await runStep(run, step(Object.freeze({ ...merged })), false, {}, merged);
+            merged = { ...merged, ...results };
+        }
+        answered = Object.freeze(merged);
     }
-    const answered = single ? results : Object.freeze(merged);
     if (spec.output === undefined)
         return answered;
     return spec.output(answered, input, outputContext(recipe, run.model));

package/dist/application/query/handles/reads.js

@@ -2,7 +2,7 @@ var _a, _b, _c;
 import { QUERY } from '../language/query.js';
 import { HANDLE_MEMBERS, ROW_KEYS } from './model.js';
 import { RelationRead, RootRead } from './plan.js';
-import { and, atom, Condition, describe, foldedTo, folding, kept, orderKeys, propertyHandle, scope, targetCondition, targetLabel, whereOf, within, } from './terms.js';
+import { and, atom, Condition, describe, foldedTo, folding, isPathText, kept, orderKeys, propertyHandle, scope, targetCondition, targetLabel, whereOf, within, } from './terms.js';
 const defined = (fields) => Object.fromEntries(Object.entries(fields).filter(([, value]) => value !== undefined));
 const nonEmpty = (items) => items.length > 0 ? items : undefined;
 const keysOf = (classes) => classes.map((c) => c.key);
@@ -221,8 +221,8 @@ function pathCondition(context, paths) {
     if (paths.length === 0)
         return foldedTo(Condition.NEVER, atom(context, { op: 'path', paths: [] }));
     for (const path of paths)
-        if (typeof path !== 'string' || !path.startsWith('/'))
-            throw new TypeError(`A path starts with "/"; got ${describe(path)}.`);
+        if (!isPathText(path))
+            throw new TypeError(`A path starts with "/" or "@"; got ${describe(path)}.`);
     return atom(context, { op: 'path', paths });
 }
 /** The named to-one relation of a handle's Classes: on a union, one every Class names alike. */

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

@@ -89,7 +89,15 @@ export declare class CoreNode {
     readonly '~core': string;
     constructor(key: string, path: string);
 }
-/** The condition a list of targets gives: ids by `id`, paths and Core nodes by `path`. */
+/**
+ * Whether text is written as a NodePath: it starts with `/` (a Domain anchor) or `@` (a Node's id
+ * as its anchor). A NodeId holds neither, so the two never meet.
+ */
+export declare function isPathText(value: unknown): value is string;
+/**
+ * The condition a list of targets gives: ids by `id`, an `@<id>` path by its id, so a long list
+ * splits as ids do; any other path, and a Core node, by `path`.
+ */
 export declare function targetCondition(context: Context, targets: readonly unknown[]): Condition;
 /** A target as an error names it: its id or its path. */
 export declare function targetLabel(target: unknown): string;

package/dist/application/query/handles/terms.js

@@ -239,7 +239,19 @@ export class CoreNode {
         Object.freeze(this);
     }
 }
-/** The condition a list of targets gives: ids by `id`, paths and Core nodes by `path`. */
+/**
+ * Whether text is written as a NodePath: it starts with `/` (a Domain anchor) or `@` (a Node's id
+ * as its anchor). A NodeId holds neither, so the two never meet.
+ */
+export function isPathText(value) {
+    return typeof value === 'string' && (value.startsWith('/') || value.startsWith('@'));
+}
+/** A NodePath that is a Node's id and no step: `@<id>`, a NodeId being 1 to 255 of `A-Za-z0-9._-`. */
+const ID_PATH = /^@([A-Za-z0-9._-]{1,255})$/;
+/**
+ * The condition a list of targets gives: ids by `id`, an `@<id>` path by its id, so a long list
+ * splits as ids do; any other path, and a Core node, by `path`.
+ */
 export function targetCondition(context, targets) {
     if (targets.length === 0)
         return foldedTo(Condition.NEVER, atom(context, { op: 'id', ids: [] }));
@@ -248,8 +260,13 @@ export function targetCondition(context, targets) {
     for (const target of targets) {
         if (target instanceof CoreNode)
             paths.push(target.path);
-        else if (typeof target === 'string' && target.startsWith('/'))
-            paths.push(target);
+        else if (isPathText(target)) {
+            const id = ID_PATH.exec(target)?.[1];
+            if (id === undefined)
+                paths.push(target);
+            else
+                ids.push(id);
+        }
         else if (typeof target === 'string' && target.length > 0)
             ids.push(target);
         else

package/dist/application/query/recipe/define.d.ts

@@ -9,14 +9,13 @@ import type { Recipe, RecipeDefinitions } from './recipe.js';
 /** A recipe id: lowercase segments of letters, digits and hyphens, joined by dots. */
 export declare const RECIPE_ID: RegExp;
 export declare const MAXIMUM_RECIPE_ID = 128;
-type Stage = (...parameters: never[]) => unknown;
-/** What a recipe reads and answers: its stages, in order, and its `output`. */
+type Callback = (...parameters: never[]) => unknown;
+/** What a recipe reads and answers: its `build`, of `(input, d, steps)`, and its `output`. */
 export interface RecipeSpec {
-    /** The first stage receives `(input, d)`; each next one `(earlier, input, d)`. */
-    readonly stages: readonly Stage[];
-    readonly output?: Stage;
+    readonly build: Callback;
+    readonly output?: Callback;
 }
-/** The stages and the output of a v7 recipe; `undefined` for anything else. */
+/** The build and the output of a v7 recipe; `undefined` for anything else. */
 export declare function recipeSpecOf(recipe: unknown): RecipeSpec | undefined;
 /** A recipe of the Domain's namespace, a Query's or a Mutation's: its id, and its errors. */
 export type NamedRecipe = Pick<Recipe, 'id' | 'errors'>;

package/dist/application/query/recipe/define.js

@@ -4,12 +4,11 @@ import { defineQuery as defineV6Query } from '../legacy/v6/define.js';
 /** A recipe id: lowercase segments of letters, digits and hyphens, joined by dots. */
 export const RECIPE_ID = /^[a-z0-9-]+(?:\.[a-z0-9-]+)*$/u;
 export const MAXIMUM_RECIPE_ID = 128;
-const MAXIMUM_STAGES = 8;
 const FIELDS = new Set(['build', 'output', 'errors']);
 const specs = new WeakMap();
 /** The collections open while a build loads a Domain; no recipe is kept outside one. */
 const collections = new Set();
-/** The stages and the output of a v7 recipe; `undefined` for anything else. */
+/** The build and the output of a v7 recipe; `undefined` for anything else. */
 export function recipeSpecOf(recipe) {
     return typeof recipe === 'object' && recipe !== null ? specs.get(recipe) : undefined;
 }
@@ -22,8 +21,9 @@ function defineRecipe(id, spec) {
     const unknown = Reflect.ownKeys(fields).filter((key) => typeof key !== 'string' || !FIELDS.has(key));
     if (unknown.length > 0)
         throw new TypeError(`Recipe ${id} takes build, output and errors only; got ${unknown.map(String).join(', ')}: do that work in build or output.`);
-    const stages = stagesOf(id, fields.build);
-    const { output } = fields;
+    const { build, output } = fields;
+    if (typeof build !== 'function')
+        throw new TypeError(`Recipe ${id}'s build is a function of (input, d, steps) that returns a read, a record of facets, or steps(first, (earlier) => next, …); got ${describe(build)}.`);
     if (output !== undefined && typeof output !== 'function')
         throw new TypeError(`Recipe ${id}'s output is a function of (results, input, context); got ${describe(output)}.`);
     const errors = fields.errors ?? {};
@@ -31,19 +31,12 @@ function defineRecipe(id, spec) {
         throw new TypeError(`Recipe ${id}'s errors is a record of declared errors by UPPER_SNAKE code; got ${describe(errors)}.`);
     const recipe = Object.freeze({ id, errors: Object.freeze({ ...errors }) });
     collectRecipe(recipe);
-    specs.set(recipe, Object.freeze({ stages, ...(output !== undefined ? { output: output } : {}) }));
+    specs.set(recipe, Object.freeze({
+        build: build,
+        ...(output !== undefined ? { output: output } : {}),
+    }));
     return recipe;
 }
-function stagesOf(id, build) {
-    if (typeof build === 'function')
-        return Object.freeze([build]);
-    if (!Array.isArray(build) ||
-        build.length < 2 ||
-        build.length > MAXIMUM_STAGES ||
-        build.some((stage) => typeof stage !== 'function'))
-        throw new TypeError(`Recipe ${id}'s build is a function, or a list of 2 to ${MAXIMUM_STAGES} stage functions; got ${describe(build)}.`);
-    return Object.freeze([...build]);
-}
 /**
  * Keep the errors a recipe declares, a Query's or a Mutation's, and collect it into the
  * collections open: a Mutation recipe shares its Domain's recipe ids and error definitions.