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

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

@@ -1,5 +1,5 @@
 /**
- * Typed handles over a Domain (spec § Recipes: the read layer): what a recipe's `build` receives,
+ * Typed handles over a Domain (spec § Queries: the read layer): what a Query's `build` receives,
  * and the reads it returns. Handles are interfaces with lazy members; the per-Class parts
  * (Properties, named relations, rows) are mapped types computed once per Class key (D5).
  */
@@ -11,7 +11,7 @@ import type { Cond, Conditions, HandleMembers, IsCond, Ordering, PropOf, PropsOf
 import type { Cls, Dom, KeyOf, LayoutOf, OriginOf, PropNamesOf, Satisfies, Single, Untyped, ValueOfEntry } from './domain.js';
 import type { Far, RelationsOf, SourceKeys, SourceRole, TargetKeys, TargetRole, ViaCheck, ViaOptions } from './relations.js';
 import type { Count, EdgeRootRef, EdgeRootRow, EdgeValues, Page, Ref, Row, RowKeys, WithheldEdgeRow, WithheldRow } from './rows.js';
-/** A read: what a verb returns, an opaque description the recipe runs, typed by its answer `T`. */
+/** A read: what a verb returns, an opaque description the Query runs, typed by its answer `T`. */
 export interface Read<out T> {
     readonly '~read': T;
 }
@@ -19,7 +19,7 @@ export interface Read<out T> {
 export interface RelationRead<out T> extends Read<T> {
     readonly '~relation': true;
 }
-/** One page of a root: only as a recipe's single read (D22). */
+/** One page of a root: only as a Query's single read (D22). */
 export interface PageRead<out T> {
     readonly '~page': T;
 }
@@ -39,21 +39,23 @@ type Answers<X> = {
  * at that name.
  */
 type WithCheck<S, K, W, X> = {
-    readonly [P in keyof X as P extends PropNamesOf<Cls<S, K>> | RowKeys | keyof W | `$${string}` ? P : X[P] extends RelationRead<unknown> ? never : P]: P extends PropNamesOf<Cls<S, K>> | RowKeys | keyof W | `$${string}` ? `✗ "${P & string}" is already a row key of this Class: give the .with another name` : `✗ "${P & string}" reads another root: read it as a facet of the recipe`;
+    readonly [P in keyof X as P extends PropNamesOf<Cls<S, K>> | RowKeys | keyof W | `$${string}` ? P : X[P] extends RelationRead<unknown> ? never : P]: P extends PropNamesOf<Cls<S, K>> | RowKeys | keyof W | `$${string}` ? `✗ "${P & string}" is already a row key of this Class: give the .with another name` : `✗ "${P & string}" reads another root: read it as a facet of the Query`;
 };
 type RowOf<S, K, W, M extends Rendering, H extends boolean> = ((M extends 'reference' ? Ref<S, K> : Row<S, K>) & W) | (H extends true ? WithheldRow<S, K> : never);
 /** The id of a Node, its path, or a Core node of the Domain. */
-export type Target = NodeId | NodePath | CoreNode<string>;
+export type Target = NodeId | NodePath | CoreNodeHandle<string>;
 /** A Core node of the Domain (`d.core.<node>`). */
-export interface CoreNode<Key extends string> {
+export interface CoreNodeHandle<Key extends string> {
     readonly '~core': Key;
 }
-interface IdProp {
+/** The `id` of a Node handle: its identity, matched by id, path or Core node. */
+export interface IdProp {
     eq(id: Target): Cond;
     /** Any length. */
     in(ids: readonly Target[]): Cond;
 }
-interface PathProp {
+/** The `path` of a Node handle. */
+export interface PathProp {
     eq(path: NodePath): Cond;
     in(paths: readonly NodePath[]): Cond;
 }
@@ -137,7 +139,7 @@ export interface NodeSet<S, K extends string, W, M extends Rendering, H extends
         readonly rows: readonly RowOf<S, K, W, M, H>[];
         readonly more: boolean;
     }>;
-    /** Only as a recipe's single read: the call sets the size, up to `max`, and continues it. */
+    /** Only as a Query's single read: the call sets the size, up to `max`, and continues it. */
     page(options: {
         readonly max: number;
     }): PageRead<RowOf<S, K, W, M, H>>;
@@ -233,10 +235,10 @@ type ClassHandles<S, Classes> = {
 type CoreHandles<Core> = Core extends {
     readonly nodes: infer Nodes;
 } ? {
-    readonly [N in keyof Nodes]: CoreNode<KeyOf<Nodes[N]>>;
+    readonly [N in keyof Nodes]: CoreNodeHandle<KeyOf<Nodes[N]>>;
 } : never;
 /** The escape hatch: one canonical document, its rows typed `unknown` (D23). */
-interface DocumentRead<S> {
+export interface DocumentRead<S> {
     document(query: Extract<SizedQuery<S>, {
         readonly list: unknown;
     }>): Read<readonly unknown[]>;
@@ -248,7 +250,7 @@ interface DocumentRead<S> {
     }>): Read<Count>;
 }
 /**
- * The handles a recipe's `build` receives (S1): the Domain's own Classes, each dependency under
+ * The handles a Query's `build` receives (S1): the Domain's own Classes, each dependency under
  * its alias, the Kernel's Classes under `d.kernel`, the Domain's Core nodes under `d.core`, and
  * `d.origin`. A Class the Domain neither declares nor depends on has no handle.
  */

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

@@ -1,11 +1,11 @@
 /**
- * What a read lowers to: its canonical v7 document, and the plan the recipe runtime answers it
+ * What a read lowers to: its canonical v7 document, and the plan the Query runtime answers it
  * by (WP-S3): the verb, its bound, and for each pattern the Classes its rows may be, how they
  * render and the relations they carry. A read whose condition can match nothing is `empty`: it
  * has no document, and the runtime answers it without sending. When the input folds a condition
  * (an empty list), the read keeps its document as written: the one S12 checks.
  */
-import type { AnyQuery } from '../language/query.js';
+import type { QueryDocument } from '../language/query.js';
 import type { Scope } from './terms.js';
 /** The verbs of a root read; `document` is the escape hatch (D23). */
 export type Verb = 'get' | 'find' | 'first' | 'firstN' | 'firstMore' | 'page' | 'all' | 'exists' | 'count' | 'document';
@@ -34,16 +34,17 @@ export interface BranchPlan extends Pattern {
     readonly bound?: number;
     /** Its condition matches nothing: it is not sent, and every parent gets the empty answer. */
     readonly empty: boolean;
-    /** Each row carries `$edge` (`.withEdge()`). */
-    readonly edge: boolean;
+    /** Each row carries `$edge` (`.withEdge()`): the Edge's Class, and its values when selected. */
+    readonly edge?: Rendering;
 }
 export interface NodeRootPlan extends Pattern {
     readonly kind: 'nodes';
 }
-/** One end of an Edge root: its role on the rows, and the Classes it accepts. */
+/** One end of an Edge root: its role on the rows, the Classes it accepts, how it is answered. */
 export interface EndPlan {
     readonly role: string;
     readonly classes: readonly string[];
+    readonly select: Rendering;
 }
 export interface EdgeRootPlan {
     readonly kind: 'edges';
@@ -61,9 +62,9 @@ export interface ReadPlan {
     /** Its condition matches nothing: answered without sending. */
     readonly empty: boolean;
     /** Absent when `empty`. */
-    readonly document?: AnyQuery;
+    readonly document?: QueryDocument;
     /** The document as written, when the input folds it: as no empty list folds it. */
-    readonly written?: AnyQuery;
+    readonly written?: QueryDocument;
     /** Absent for `document`, whose rows are unknown. */
     readonly root?: NodeRootPlan | EdgeRootPlan;
     /** The id or path `get`, `find` or `exists` was given, as `NOT_FOUND` names it. */
@@ -91,9 +92,9 @@ export declare class RelationRead {
     /** The handle it was read from: a `.with` takes only its own handle's relations. */
     scope: Scope, lower: (key: string, name: string) => LoweredBranch);
 }
-/** Whether a value is a read a recipe runs (a root read). */
+/** Whether a value is a read a Query runs (a root read). */
 export declare function isRead(value: unknown): value is RootRead;
 /** The plan of a root read. */
 export declare function planOf(read: unknown): ReadPlan;
 /** The canonical document of a root read; an `empty` read has none. */
-export declare function lower(read: unknown): AnyQuery | undefined;
+export declare function lower(read: unknown): QueryDocument | undefined;

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

@@ -18,7 +18,7 @@ export class RelationRead {
         Object.freeze(this);
     }
 }
-/** Whether a value is a read a recipe runs (a root read). */
+/** Whether a value is a read a Query runs (a root read). */
 export function isRead(value) {
     return value instanceof RootRead;
 }

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

@@ -280,7 +280,7 @@ function withsOf(value, handleScope, taken, earlier) {
             throw new TypeError(`"${name}" is already a row key of this Class: give the .with another name.`);
         const read = entry instanceof Exists ? entry.read : entry;
         if (read instanceof RootRead)
-            throw new TypeError(`"${name}" reads another root: read it as a facet of the recipe.`);
+            throw new TypeError(`"${name}" reads another root: read it as a facet of the Query.`);
         if (!(read instanceof RelationRead))
             throw new TypeError(`"${name}" is not a relation read: end the relation with a verb (find, first, all, count, exists).`);
         if (read.scope !== handleScope)
@@ -445,7 +445,7 @@ export class Relation {
                 verb,
                 ...(bound === undefined ? {} : { bound }),
                 empty: sent === undefined,
-                edge: s.selectEdge,
+                ...(s.selectEdge ? { edge: 'value' } : {}),
                 classes: keysOf(s.far),
                 select: s.select,
                 withheld: s.withheld,
@@ -780,8 +780,8 @@ export class EdgeSet {
             classes: [edge.key],
             select: this.#s.select,
             withheld: this.#s.withheld,
-            source: { role: source.role, classes: keysOf(model.far(source)) },
-            target: { role: target.role, classes: keysOf(model.far(target)) },
+            source: { role: source.role, classes: keysOf(model.far(source)), select: this.#s.select },
+            target: { role: target.role, classes: keysOf(model.far(target)), select: this.#s.select },
         };
     }
     #list(verb, limit, bound) {

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

@@ -38,7 +38,7 @@ export type WithheldRow<S, K> = K extends unknown ? {
     readonly $withheld: readonly PropNamesOf<Cls<S, K>>[];
 } : never;
 /**
- * An Edge's identity: its Class and both ends. An object type, not an interface: a recipe's
+ * An Edge's identity: its Class and both ends. An object type, not an interface: a Query's
  * exported declaration then spells it out.
  */
 type EdgeIdentity<E> = {

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

@@ -3,11 +3,14 @@ export { executeQuery, type QueryClient, type QueryExecutor } from './execution/
 export { QueryPaginationError, QueryValueMismatchError, type QueryFailure, type QueryPaginationErrorCode, } from './failure.js';
 export type { CompositeQueryDefinition, QueryDefinition, QueryInputOf, QueryOutputOf, QueryPagination, } from './query.js';
 export type { CompositeQuery, ProjectedCompositeQuery, QueryComposition, QueryPlan, QueryPlanInput, QueryPlanOutput, QueryPlanValue, RawCompositeQuery, } from './composite/index.js';
-export { defineQuery } from './recipe/define.js';
-export { edgeKey, type Count, type EdgeKey, type EdgeRow, type Page, type Ref, type Row, } from './handles/rows.js';
-export type { Handles } from './handles/handles.js';
-export type { InputOf, OutputOf, Recipe } from './recipe/recipe.js';
+export { defineQuery } from './defined/define.js';
+export { edgeKey, type Count, type EdgeKey, type EdgeRow, type Page, type EdgeRootRef, type EdgeRootRow, type Ref, type Row, type WithheldEdgeRow, type WithheldRow, } from './handles/rows.js';
+export type { CoreNodeHandle, DocumentRead, EdgeHandle, EdgeRootHandle, EdgeSet, Handles, IdProp, NodeHandle, NodeMethods, NodeSet, PageRead, PathProp, Read, RelationRead, RelSet, } from './handles/handles.js';
+export type { BooleanProp, Cond, EnumProp, IsCond, JsonProp, NumberProp, OpenProp, OrderKey, PropsOf, SetProp, TextProp, Unordered, } from './handles/conditions.js';
+export type { DefinedQuery, InputOf, OutputOf, Stepped, Steps } from './defined/query.js';
+export type { QueryDocument } from './language/query.js';
+export type { QueryRequestOptions } from './execution/client.js';
 export { isQueryError, QueryError, type QueryErrorCode, type QueryErrorDetails, } from './execution/error.js';
-export { runQueryRecipe, type RecipeCallOptions, type RecipeClient, type RecipeOptions, type RecipeQueryOptions, } from './execution/recipe.js';
+export { runQuery, type QueryOptions, type QueryPageOptions } from './execution/run.js';
 export { defineCollectionQuery, queryResult, type CollectionQueryDefinition, type CollectionQuerySpec, type CollectionValue, type CompleteQueryProjectionContext, type PaginatedQuery, type ProjectedQuery, type QueryAstOf, type QueryPages, type QueryProjectionContext, type RawQuery, type SingleQuery, type SingleQueryDefinition, } from './legacy/v6/index.js';
 export * from './legacy/v6/kernel.js';

package/dist/application/query/index.js

@@ -1,11 +1,11 @@
 export { defineCompositeQuery, realizeQuery } from './define.js';
 export { executeQuery } from './execution/index.js';
 export { QueryPaginationError, QueryValueMismatchError, } from './failure.js';
-// Query v7: recipes. `defineQuery` defines a recipe from a string id, and a V6 Query from a function.
-export { defineQuery } from './recipe/define.js';
+// Query v7. `defineQuery` defines a Query v7 from a string id, and a V6 Query from a function.
+export { defineQuery } from './defined/define.js';
 export { edgeKey, } from './handles/rows.js';
 export { isQueryError, QueryError, } from './execution/error.js';
-export { runQueryRecipe, } from './execution/recipe.js';
+export { runQuery } from './execution/run.js';
 // Query V6.
 export { defineCollectionQuery, queryResult, } from './legacy/v6/index.js';
 export * from './legacy/v6/kernel.js';

package/dist/application/query/language/index.d.ts

@@ -1,2 +1,2 @@
 /** The Query v7 language: the static type of a Query's canonical JSON, over one Domain. */
-export { QUERY, type AnyQuery, type Query, type QueryBounds, type QueryBranch, type QueryClassKey, type QueryCondition, type QueryDomainOf, type QueryEdgeClassKey, type QueryNodeClassKey, type QueryOperatorOf, type QueryOrderKey, type QueryPropertyKey, type QueryPropertyValue, type QueryPropertyValues, type QueryRange, type QueryRendering, type QueryRoot, type QueryTraversal, type Refused, type SizedList, type SizedQuery, type TraversalDirection, type UnsizedList, } from './query.js';
+export { QUERY, type QueryDocument, type Query, type QueryBounds, type QueryBranch, type QueryClassKey, type QueryCondition, type QueryDomainOf, type QueryEdgeClassKey, type QueryNodeClassKey, type QueryOperatorOf, type QueryOrderKey, type QueryPropertyKey, type QueryPropertyValue, type QueryPropertyValues, type QueryRange, type QueryRendering, type QueryRoot, type QueryTraversal, type Refused, type SizedList, type SizedQuery, type TraversalDirection, type UnsizedList, } from './query.js';

package/dist/application/query/language/query.d.ts

@@ -4,8 +4,8 @@
  *
  * `Query<Schema>` is the static type of the canonical JSON (`"query": "astrale.query/7"`). Every
  * name is a key of the Domain (its own Classes, its direct dependencies' and the Kernel's), every
- * condition one its key's value kind admits, every value of its key's type. A recipe's reads lower
- * to it; an LLM, a tool or a person writes it; tsc checks it at the leaf that is wrong.
+ * condition one its key's value kind admits, every value of its key's type. A defined Query's reads
+ * lower to it; an LLM, a tool or a person writes it; tsc checks it at the leaf that is wrong.
  *
  * It neither wraps nor re-exports the Kernel's builders (`where`, `key`, `property`, `ref`): the
  * SDK owns its language surface; the Kernel's wire decoder is the one judge of a document.
@@ -77,7 +77,7 @@ export type QueryPropertyValues<Source> = QueryDomainOf<Source> extends infer D
  * `text` or an `instant` (an annotation of its schema), an array a `set` or a `json` (its
  * `uniqueItems`), the portable `Value` any kind. tsc admits what any of them admits, so it never
  * refuses a condition the Kernel answers; the Kernel's decoder refuses the rest (law L4). A value
- * of unknown type (a Query over any Domain, `AnyQuery`) admits every kind.
+ * of unknown type (a Query over any Domain, `QueryDocument`) admits every kind.
  */
 type KindsOf<V> = unknown extends V ? keyof Admits : V extends boolean ? 'boolean' : V extends number ? 'number' : V extends string ? string extends V ? 'text' | 'instant' : 'enum' : V extends readonly unknown[] ? 'set' | 'json' : V extends null ? never : 'json';
 /** The operators each value kind admits; `key` orders a list (page § Atoms et value kinds). */
@@ -309,7 +309,7 @@ type QueryOver<D extends Domain, L extends Size> = D extends Domain ? {
 } : never;
 /** A Query of the Domain, as its canonical JSON: the root fold names its family. */
 export type Query<Source> = QueryOver<QueryDomainOf<Source>, UnsizedList>;
-/** A Query whose every list is sized by `limit`: the Query a recipe reads (W1). */
+/** A Query whose every list is sized by `limit`: the document a defined Query reads (W1). */
 export type SizedQuery<Source> = QueryOver<QueryDomainOf<Source>, SizedList>;
 /** The parts of a Query, for authors who build one piece by piece. */
 export type QueryCondition<Source> = Where<QueryDomainOf<Source>>;
@@ -319,5 +319,5 @@ export type QueryBranch<Source> = Branch<QueryDomainOf<Source>, UnsizedList>;
 export type QueryRoot<Source> = Root<QueryDomainOf<Source>, UnsizedList>;
 export type QueryRange<Source> = Range<QueryDomainOf<Source>>;
 /** Any v7 Query, of any Domain: what code that does not know the Domain handles. */
-export type AnyQuery = Query<Domain>;
+export type QueryDocument = Query<Domain>;
 export {};

package/dist/application/query/legacy/v6/collection/union.d.ts

@@ -1,5 +1,5 @@
-import type { QueryAST } from '@astrale-os/kernel-core/graph/query';
 import type { AnyResolvedClass } from '@astrale-os/kernel-dsl/v1';
+import { QueryAST } from '@astrale-os/kernel-core/graph/query';
 import type { Edge } from '../../../../../platform/graph/edge/index.js';
 import type { Node } from '../../../../../platform/graph/node/index.js';
 import type { Domain } from '../../../../../platform/schema/index.js';

package/dist/application/query/legacy/v6/collection/union.js

@@ -1,5 +1,5 @@
 import { definedClass } from '@astrale-os/kernel-client/graph';
-import { Query, QueryAST as QueryDocument } from '@astrale-os/kernel-core/graph/query';
+import { Query, QueryAST } from '@astrale-os/kernel-core/graph/query';
 import { QueryCompositionError } from '../../../composite/errors.js';
 import { collectionIdentityOf } from './identity.js';
 import { COLLECTION_QUERY_LIMITS } from './limits.js';
@@ -31,8 +31,8 @@ export function compileCollectionUnion(domain, definitions, outputPath) {
         name,
         specification: realizeMember(definition, domain, outputPath, name),
     }));
-    if (realized.length > QueryDocument.limits.sourceTerms) {
-        limit(`${pathOf(outputPath)} has ${realized.length} collection members; maximum is ${QueryDocument.limits.sourceTerms}.`);
+    if (realized.length > QueryAST.limits.sourceTerms) {
+        limit(`${pathOf(outputPath)} has ${realized.length} collection members; maximum is ${QueryAST.limits.sourceTerms}.`);
     }
     const ids = new Map();
     const classes = new Map();

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

@@ -28,7 +28,7 @@ export interface SingleQueryProjector<Schema extends schema.DomainSchema> {
 export interface CollectionQueryProjector<Schema extends schema.DomainSchema> {
     <Class extends AnyResolvedClass>(project: (domain: ResolvedDomainOf<Schema>) => CollectionQuerySpec<Class>): CollectionQueryDefinition<ResolvedDomainOf<Schema>, Class>;
 }
-/** Define one inert single Query recipe projected from its exact loaded Domain. */
+/** Define one inert single Query projected from its exact loaded Domain. */
 export declare function defineQuery<Schema extends schema.DomainSchema>(): SingleQueryProjector<Schema>;
 /** Define one reusable complete polymorphic Class-extent Query. */
 export declare function defineCollectionQuery<Schema extends schema.DomainSchema>(): CollectionQueryProjector<Schema>;

package/dist/application/query/legacy/v6/define.js

@@ -1,5 +1,5 @@
 import { Query } from '@astrale-os/kernel-core/graph/query';
-import { definitionBase, recipe } from '../../definition.js';
+import { definitionBase, inertQuery } from '../../definition.js';
 import { requireUniqueCollectionValues } from './collection/identity.js';
 import { COLLECTION_QUERY_LIMITS } from './collection/limits.js';
 import { realizeCollectionQuery, registerCollectionQuery, } from './collection/metadata.js';
@@ -7,9 +7,9 @@ import { definedValues } from './conformance.js';
 import { queryResult } from './single/index.js';
 const DEFAULT_PAGE_SIZE = 256;
 const MAXIMUM_PAGES = 1_024;
-/** Define one inert single Query recipe projected from its exact loaded Domain. */
+/** Define one inert single Query projected from its exact loaded Domain. */
 export function defineQuery() {
-    return ((project) => recipe('query', project));
+    return ((project) => inertQuery('query', project));
 }
 /** Define one reusable complete polymorphic Class-extent Query. */
 export function defineCollectionQuery() {

package/dist/application/query/legacy/v6/execution/execute.d.ts

@@ -4,13 +4,15 @@ import type { Domain } from '../../../../../platform/schema/index.js';
 import type { QueryDefinition } from '../../../query.js';
 import type { CollectionDefinitionRecord } from '../collection/union.js';
 import type { SingleQuery } from '../single/index.js';
-export interface QueryClient {
+import type { QueryPageExecutor } from '../single/pagination.js';
+/** The client a V6 Query reads through, page by page. Every `QueryClient` serves it. */
+export interface QueryV6Client {
     query<Ast extends QueryAST>(ast: Ast, options: {
         readonly page: QueryPageRequest;
     }): Promise<QueryResponse<QueryResultFor<Ast>>>;
 }
 /** The client's V6 reads, each value checked against this client's Domain. */
-export declare function conformingClient(client: QueryClient, domain: Domain): QueryClient['query'];
-export declare function runCollectionUnion(execute: QueryClient['query'], domain: Domain, definitions: CollectionDefinitionRecord, outputPath: readonly string[]): Promise<Readonly<Record<string, readonly unknown[]>>>;
+export declare function conformingClient(client: QueryV6Client, domain: Domain): QueryPageExecutor;
+export declare function runCollectionUnion(execute: QueryPageExecutor, domain: Domain, definitions: CollectionDefinitionRecord, outputPath: readonly string[]): Promise<Readonly<Record<string, readonly unknown[]>>>;
 export declare function realizeSingle<DomainValue extends Domain>(definition: QueryDefinition<Domain, unknown, unknown>, domain: DomainValue): SingleQuery<unknown, unknown>;
-export declare function runSingle(execute: QueryClient['query'], definition: SingleQuery<unknown, unknown>, input: unknown): Promise<unknown>;
+export declare function runSingle(execute: QueryPageExecutor, definition: SingleQuery<unknown, unknown>, input: unknown): Promise<unknown>;

package/dist/application/query/legacy/v6/index.d.ts

@@ -1,4 +1,4 @@
-/** Query V6: the names `@astrale-os/sdk/query` exports for V6 recipes and their results. */
+/** Query V6: the names `@astrale-os/sdk/query` exports for V6 Queries and their results. */
 export { defineCollectionQuery, defineQuery } from './define.js';
 export type { CollectionQuerySpec } from './collection/metadata.js';
 export type { CollectionQueryDefinition, CollectionValue, QueryAstOf, SingleQueryDefinition, } from '../../query.js';

package/dist/application/query/legacy/v6/index.js

@@ -1,3 +1,3 @@
-/** Query V6: the names `@astrale-os/sdk/query` exports for V6 recipes and their results. */
+/** Query V6: the names `@astrale-os/sdk/query` exports for V6 Queries and their results. */
 export { defineCollectionQuery, defineQuery } from './define.js';
 export { queryResult } from './single/index.js';

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

@@ -24,7 +24,7 @@ export interface QueryLifecycle<Input, Output> {
 export interface QueryPagination {
     readonly maximumPages: number;
 }
-/** Inert Domain-bound Query recipe. Its projector is retained privately by the SDK. */
+/** Inert Domain-bound Query definition. Its projector is retained privately by the SDK. */
 export interface QueryDefinition<DomainValue extends Domain = Domain, Input = unknown, Output = QueryResult> {
     readonly kind: 'query' | 'composite-query';
     readonly [QUERY_DOMAIN]: (domain: DomainValue) => DomainValue;
@@ -35,14 +35,14 @@ export interface SingleQueryDefinition<DomainValue extends Domain = Domain, Inpu
     readonly kind: 'query';
 }
 export type CollectionValue<Class extends AnyResolvedClass> = Class extends ResolvedClass<'node'> ? Node : Class extends ResolvedClass<'edge'> ? Edge : never;
-/** Closed complete-Class Query recipe admitted for explicit physical union planning. */
+/** Closed complete-Class Query definition admitted for explicit physical union planning. */
 export interface CollectionQueryDefinition<DomainValue extends Domain = Domain, Class extends AnyResolvedClass = AnyResolvedClass> extends SingleQueryDefinition<DomainValue, void, readonly CollectionValue<Class>[]> {
     readonly [COLLECTION_QUERY_CLASS]: Class;
 }
 export interface CompositeQueryDefinition<DomainValue extends Domain = Domain, Input = unknown, Output = unknown> extends QueryDefinition<DomainValue, Input, Output> {
     readonly kind: 'composite-query';
 }
-/** Canonical admitted operation produced by realizing one Query recipe. */
+/** Canonical admitted operation produced by realizing one Query definition. */
 export type RealizedQuery<Input, Output = QueryResult, Ast extends QueryAST = QueryAST> = SingleQuery<Input, Output, Ast> | CompositeQuery<Input, unknown, Output, Domain>;
 export type QueryInputOf<Value> = Value extends QueryDefinition<infer _Domain, infer Input, infer _Output> ? Input : Value extends QueryLifecycle<infer Input, infer _Output> ? Input : never;
 export type QueryOutputOf<Value> = Value extends QueryDefinition<infer _Domain, infer _Input, infer Output> ? Output : Value extends QueryLifecycle<infer _Input, infer Output> ? Output : never;

package/dist/application/routes/admission.d.ts

@@ -1,5 +1,5 @@
 import type { release } from '@astrale-os/kernel-protocol';
 import type { RuntimeRegistry } from '../runtime/index.js';
 import type { Routes } from './collection.js';
-/** Lower recipe identities to canonical callable keys after Runtime admission. */
+/** Lower definition identities to canonical callable keys after Runtime admission. */
 export declare function admit(input: Routes | undefined, registry: RuntimeRegistry): readonly release.HttpRouteDeclaration[];

package/dist/application/routes/admission.js

@@ -1,5 +1,5 @@
 import { isRoutes } from './collection.js';
-/** Lower recipe identities to canonical callable keys after Runtime admission. */
+/** Lower definition identities to canonical callable keys after Runtime admission. */
 export function admit(input, registry) {
     if (input === undefined)
         return Object.freeze([]);
@@ -8,7 +8,7 @@ export function admit(input, registry) {
     return Object.freeze(input.entries.map(({ target, ...declaration }) => {
         const implementation = registry.implementations.find(({ definition }) => definition === target);
         if (implementation === undefined) {
-            throw new TypeError(`Route ${declaration.name} targets a recipe outside the Runtime.`);
+            throw new TypeError(`Route ${declaration.name} targets a definition outside the Runtime.`);
         }
         return Object.freeze({ ...declaration, callable: implementation.callable.key });
     }));

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

@@ -2,8 +2,9 @@ import type { Route, RouteInput, RouteTarget } from './route.js';
 export { admit } from './admission.js';
 export { isRoute, isRoutes, routes, type Routes } from './collection.js';
 export type { Route, RouteInput, RouteTarget } from './route.js';
-type Recipe = RouteTarget & {
+/** An Action or Workflow definition: what a route targets. */
+type Callable = RouteTarget & {
     readonly run: (...input: never[]) => unknown;
 };
 /** Define one HTTP route without exposing DSL Function or Method topology. */
-export declare function route<const Target extends Recipe>(target: Target, input: RouteInput): Route<Target>;
+export declare function route<const Target extends Callable>(target: Target, input: RouteInput): Route<Target>;

package/dist/application/routes/route.d.ts

@@ -4,7 +4,7 @@ export interface RouteTarget {
     readonly address: string;
 }
 export type RouteInput = Omit<release.HttpRouteDeclaration, 'callable'>;
-/** One provider-neutral HTTP route targeting an admitted Action or Workflow recipe. */
+/** One provider-neutral HTTP route targeting an admitted Action or Workflow definition. */
 export interface Route<Target extends RouteTarget = RouteTarget> extends RouteInput {
     readonly target: Target;
 }

package/dist/application/runtime/declarations.d.ts

@@ -6,22 +6,22 @@ import type { WorkflowAddress, WorkflowDefinition } from '../workflow/index.js';
 import type { RuntimeInitialization, RuntimeInitializer } from './initialize.js';
 import type { RuntimeIntegrations } from './integrations.js';
 import type { Runtime } from './runtime.js';
-/** Retain each recipe's exact contract without repeating the owning Schema in every tuple slot. */
-type RuntimeFunctionSignature<Recipe> = Recipe extends ActionDefinition<infer Schema, infer Address, infer Definitions, infer Errors> ? readonly [
+/** Retain each Function's exact contract without repeating the owning Schema in every tuple slot. */
+type RuntimeFunctionSignature<Callable> = Callable extends ActionDefinition<infer Schema, infer Address, infer Definitions, infer Errors> ? readonly [
     'action',
     Address,
     Definitions,
     Errors,
     {
-        [Key in keyof Recipe as Exclude<Key, keyof ActionDefinition<Schema, Address, Definitions, Errors>>]: Recipe[Key];
+        [Key in keyof Callable as Exclude<Key, keyof ActionDefinition<Schema, Address, Definitions, Errors>>]: Callable[Key];
     }
-] : Recipe extends WorkflowDefinition<infer Schema, infer Address, infer Definitions, infer Errors> ? readonly [
+] : Callable extends WorkflowDefinition<infer Schema, infer Address, infer Definitions, infer Errors> ? readonly [
     'workflow',
     Address,
     Definitions,
     Errors,
     {
-        [Key in keyof Recipe as Exclude<Key, keyof WorkflowDefinition<Schema, Address, Definitions, Errors>>]: Recipe[Key];
+        [Key in keyof Callable as Exclude<Key, keyof WorkflowDefinition<Schema, Address, Definitions, Errors>>]: Callable[Key];
     }
 ] : never;
 export type RuntimeFunctionSignatures<Functions extends readonly unknown[]> = {
@@ -37,7 +37,7 @@ type RuntimeFunction<Schema extends schema.DomainSchema, Signature> = Signature
 type RuntimeFunctions<Schema extends schema.DomainSchema, Signatures extends readonly unknown[]> = {
     [Index in keyof Signatures]: RuntimeFunction<Schema, Signatures[Index]>;
 };
-/** A portable inferred Runtime keeps its Schema once while retaining the exact recipe tuple. */
+/** A portable inferred Runtime keeps its Schema once while retaining the exact Function tuple. */
 export interface AuthoredRuntime<Schema extends schema.DomainSchema, Integrations extends RuntimeIntegrations, Initialize extends RuntimeInitializer<never, RuntimeInitialization, Schema>, Signatures extends readonly unknown[]> extends Runtime<Schema, Integrations, Initialize, RuntimeFunctions<Schema, Signatures>> {
 }
 export {};

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

@@ -11,11 +11,11 @@ type AnyRuntimeInitializer<Schema extends schema.DomainSchema> = RuntimeInitiali
 type Same<Left, Right> = [Left] extends [Right] ? ([Right] extends [Left] ? true : false) : false;
 type ActionSchema<Value> = Value extends ActionDefinition<infer Schema, infer _Address, infer _Services> ? Schema : never;
 type WorkflowSchema<Value> = Value extends WorkflowDefinition<infer Schema, infer _Address, infer _Services> ? Schema : never;
-type RecipeIntegrations<Value> = Value extends ActionDefinition<infer _Schema, infer _Address, infer Definitions> ? Definitions : Value extends WorkflowDefinition<infer _Schema, infer _Address, infer Definitions> ? Definitions : never;
-type AdmitsRecipeSchema<Schema extends schema.DomainSchema, Functions extends readonly unknown[]> = [Functions[number]] extends [never] ? unknown : Same<ActionSchema<Functions[number]> | WorkflowSchema<Functions[number]>, Schema> extends true ? unknown : never;
+type FunctionIntegrations<Value> = Value extends ActionDefinition<infer _Schema, infer _Address, infer Definitions> ? Definitions : Value extends WorkflowDefinition<infer _Schema, infer _Address, infer Definitions> ? Definitions : never;
+type AdmitsFunctionSchema<Schema extends schema.DomainSchema, Functions extends readonly unknown[]> = [Functions[number]] extends [never] ? unknown : Same<ActionSchema<Functions[number]> | WorkflowSchema<Functions[number]>, Schema> extends true ? unknown : never;
 type InitializationOf<Initialize extends RuntimeInitializerValue> = Awaited<ReturnType<Initialize>>;
-type AdmitsRecipeIntegrations<Definitions extends RuntimeIntegrations, Recipe> = RecipeIntegrations<Recipe> extends infer Required extends RuntimeIntegrations ? Exclude<keyof Required, keyof Definitions> extends never ? Required extends Pick<Definitions, Extract<keyof Required, keyof Definitions>> ? true : false : false : false;
-type AdmitsIntegrations<Definitions extends RuntimeIntegrations, Functions extends readonly unknown[]> = [Functions[number]] extends [never] ? unknown : false extends AdmitsRecipeIntegrations<Definitions, Functions[number]> ? never : unknown;
+type AdmitsFunctionIntegrations<Definitions extends RuntimeIntegrations, Callable> = FunctionIntegrations<Callable> extends infer Required extends RuntimeIntegrations ? Exclude<keyof Required, keyof Definitions> extends never ? Required extends Pick<Definitions, Extract<keyof Required, keyof Definitions>> ? true : false : false : false;
+type AdmitsIntegrations<Definitions extends RuntimeIntegrations, Functions extends readonly unknown[]> = [Functions[number]] extends [never] ? unknown : false extends AdmitsFunctionIntegrations<Definitions, Functions[number]> ? never : unknown;
 type AdmitsProviders<Integrations extends RuntimeIntegrations, Initialize extends RuntimeInitializerValue> = Same<InitializationOf<Initialize>['providers'], Providers<Integrations>> extends true ? unknown : never;
 export interface RuntimeInput<Integrations extends RuntimeIntegrations, Initialize extends RuntimeInitializerValue, Functions extends readonly unknown[]> {
     readonly integrations: Integrations;
@@ -23,6 +23,6 @@ export interface RuntimeInput<Integrations extends RuntimeIntegrations, Initiali
     readonly functions: Functions;
 }
 /** Define one inert Runtime declaration; realization requires an exact loaded DSL Domain. */
-export declare function defineRuntime<Schema extends schema.DomainSchema>(): <const Integrations extends RuntimeIntegrations, Initialize extends AnyRuntimeInitializer<Schema>, const Functions extends readonly unknown[]>(input: RuntimeInput<Integrations, Initialize, Functions> & AdmitsRecipeSchema<Schema, Functions> & AdmitsIntegrations<Integrations, Functions> & AdmitsProviders<Integrations, Initialize>) => AuthoredRuntime<Schema, Integrations, Initialize, RuntimeFunctionSignatures<Functions>>;
+export declare function defineRuntime<Schema extends schema.DomainSchema>(): <const Integrations extends RuntimeIntegrations, Initialize extends AnyRuntimeInitializer<Schema>, const Functions extends readonly unknown[]>(input: RuntimeInput<Integrations, Initialize, Functions> & AdmitsFunctionSchema<Schema, Functions> & AdmitsIntegrations<Integrations, Functions> & AdmitsProviders<Integrations, Initialize>) => AuthoredRuntime<Schema, Integrations, Initialize, RuntimeFunctionSignatures<Functions>>;
 export declare function isRuntime(input: unknown): input is Runtime;
 export {};

package/dist/application/workflow/durable.d.ts

@@ -6,8 +6,8 @@ import type { DomainCapabilities, DomainKernelSessions, DomainMutate } from '../
 import type { HandlerDependencies } from '../dependency/index.js';
 import type { DeclaredErrorFactory, DeclaredErrors, NoDeclaredErrors } from '../error/index.js';
 import type { Integrations, ReplayableIntegrationClients } from '../integration/index.js';
-import type { Mutation, MutationInputOf, MutationOutputOf, MutationRecipe } from '../mutation/index.js';
-import type { InputOf, OutputOf, QueryDefinition, Recipe, RecipeOptions } from '../query/index.js';
+import type { Mutation, MutationInputOf, MutationOutputOf, DefinedMutation } from '../mutation/index.js';
+import type { InputOf, OutputOf, QueryDefinition, DefinedQuery, QueryOptions } from '../query/index.js';
 /** A callable whose Schema declares `execution: { durable: true }`. */
 export interface DurableCallable {
     readonly execution: {
@@ -99,8 +99,8 @@ export interface DurableStepDeclaration {
 /**
  * A Step's id alone, under the deployment's retry budget and Step timeout, or a declaration of its
  * own. A Step that spends its budget, or that the Kernel refuses for good, throws an error
- * `exhausted` recognizes. A Step whose recipe read fails throws its `QueryError`, not retried
- * unless the Kernel refused the read; a recipe that crosses a dependency's Class its Domain does
+ * `exhausted` recognizes. A Step whose Query read fails throws its `QueryError`, not retried
+ * unless the Kernel refused the read; a Query that crosses a dependency's Class its Domain does
  * not require throws its `TypeError`, not retried. Uncaught, each ends the Execution `failed`
  * with code `STEP_EXHAUSTED`.
  */
@@ -114,19 +114,19 @@ export interface DurableStep<DomainValue extends Domain = Domain, Definitions ex
     run<Output>(step: DurableStepId, execute: (authority: DurableStepAuthority<DomainValue, Definitions>) => Output | Promise<Output>): Promise<Output>;
     /**
      * One journaled Query. A replay returns the result of its first run, so a later Step that depends
-     * on it resends the same request whenever it is retried. A recipe reads as the executor; its
+     * on it resends the same request whenever it is retried. A Query v7 reads as the executor; its
      * `QueryError`, or the `TypeError` of a dependency's Class its Domain does not require, is
      * journaled as the Step's failure, is not retried, and a replay throws it again. A read the
      * Kernel refused is a failed attempt instead, as any Kernel refusal.
      */
-    query<R extends Recipe>(step: DurableStepId, recipe: R, input: InputOf<R>, options: RecipeOptions<R, 'executor'>): Promise<OutputOf<R>>;
+    query<R extends DefinedQuery>(step: DurableStepId, query: R, input: InputOf<R>, options: QueryOptions<R, 'executor'>): Promise<OutputOf<R>>;
     query<Output>(step: DurableStepId, query: QueryDefinition<DomainValue, void, Output>): Promise<Output>;
     query<Input, Output>(step: DurableStepId, query: QueryDefinition<DomainValue, Input, Output>, input: Input): Promise<Output>;
     /**
      * One journaled Mutation, as the executor. A Step replayed after its commit receives the result
      * of that commit from the Kernel's receipt instead of writing again.
      */
-    mutate<M extends MutationRecipe>(step: DurableStepId, mutation: M, input: MutationInputOf<M>, options: {
+    mutate<M extends DefinedMutation>(step: DurableStepId, mutation: M, input: MutationInputOf<M>, options: {
         readonly as: 'executor';
     }): Promise<MutationOutputOf<M>>;
     mutate<Input, Output>(step: DurableStepId, mutation: Mutation<DomainValue, Input, Output>, input: Input): Promise<Output>;
@@ -147,10 +147,10 @@ export interface DurableParallelStep<out Output> {
 /** The Steps one `step.parallel` declares, with the arguments of `step.run`, `query` and `mutate`. */
 export interface DurableParallelSteps<DomainValue extends Domain = Domain, Definitions extends Integrations = Readonly<Record<never, never>>> {
     run<Output>(step: DurableStepId, execute: (authority: DurableStepAuthority<DomainValue, Definitions>) => Output | Promise<Output>): DurableParallelStep<Output>;
-    query<R extends Recipe>(step: DurableStepId, recipe: R, input: InputOf<R>, options: RecipeOptions<R, 'executor'>): DurableParallelStep<OutputOf<R>>;
+    query<R extends DefinedQuery>(step: DurableStepId, query: R, input: InputOf<R>, options: QueryOptions<R, 'executor'>): DurableParallelStep<OutputOf<R>>;
     query<Output>(step: DurableStepId, query: QueryDefinition<DomainValue, void, Output>): DurableParallelStep<Output>;
     query<Input, Output>(step: DurableStepId, query: QueryDefinition<DomainValue, Input, Output>, input: Input): DurableParallelStep<Output>;
-    mutate<M extends MutationRecipe>(step: DurableStepId, mutation: M, input: MutationInputOf<M>, options: {
+    mutate<M extends DefinedMutation>(step: DurableStepId, mutation: M, input: MutationInputOf<M>, options: {
         readonly as: 'executor';
     }): DurableParallelStep<MutationOutputOf<M>>;
     mutate<Input, Output>(step: DurableStepId, mutation: Mutation<DomainValue, Input, Output>, input: Input): DurableParallelStep<Output>;

package/dist/execution/invocation/capabilities/bind.d.ts

@@ -5,7 +5,7 @@ import type { Domain } from '../../../platform/schema/index.js';
 import type { InvocationSessions } from '../admission/index.js';
 /**
  * Bind what code acting under `sessions` holds: self-default Kernel and graph, and dependency
- * invokers per authority. An Action and a durable Step receive these same capabilities. A recipe's
+ * invokers per authority. An Action and a durable Step receive these same capabilities. A Query's
  * reads are checked against the Class requirements the Domain's build `declared` (S12).
  */
 export declare function bindCapabilities(domain: Domain, sessions: Readonly<Record<'caller' | 'self', BoundClientSession>>, declared?: readonly DeclaredClass[]): DomainCapabilities;