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

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/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/deployment/build/build.d.ts

@@ -7,12 +7,19 @@ export interface Build<Schema extends schema.DomainSchema = schema.DomainSchema,
     readonly schema: BuildSchema<Schema>;
     readonly runtime: RuntimeValue;
     readonly callables: readonly Key.Callable[];
-    readonly requirements: release.Requirements;
+    readonly requirements: BuildRequirements;
     readonly routes: routes.Plan;
     readonly frontend?: FrontendCompilation;
     /** What the release manifest shows of the application: its icon. */
     readonly presentation?: BuildPresentation;
 }
+/**
+ * What a build requires of the Instance. The SDK declares capabilities in the legacy shape only
+ * (`functions`, `classes`, `authority`, `core`), never roles or scopes.
+ */
+export interface BuildRequirements extends release.Requirements {
+    readonly capabilities: release.LegacyCapabilityRequirements;
+}
 export interface BuildPresentation {
     /** One self-contained inline SVG. */
     readonly icon?: string;

package/dist/deployment/build/material.js

@@ -58,6 +58,9 @@ export function restoreBuild(input, runtime) {
     }
     const registry = bindRuntime(domain, runtime, input.callables);
     const requirements = admitRequirements(input.requirements);
+    // A build declares its capabilities in the legacy shape only: never roles or scopes.
+    if ('roles' in requirements.capabilities || 'scopes' in requirements.capabilities)
+        invalid();
     validateRequirements(decoded.root, decoded.closure, requirements);
     const plan = admitRoutePlan(input.routes, domain);
     const compiled = deepFreeze(input.schema.compiled);

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;

package/dist/execution/invocation/capabilities/bind.js

@@ -1,9 +1,9 @@
-import { mutationRecipeSpecOf } from '../../../application/mutation/define.js';
+import { mutationSpecOf } from '../../../application/mutation/define.js';
 import { executeMutation } from '../../../application/mutation/execution/execute.js';
 import { bindMutation } from '../../../application/mutation/execution/executor.js';
+import { querySpecOf } from '../../../application/query/defined/define.js';
 import { bindQuery } from '../../../application/query/execution/executor.js';
-import { runQueryRecipe } from '../../../application/query/execution/recipe.js';
-import { recipeSpecOf } from '../../../application/query/recipe/define.js';
+import { runQuery } from '../../../application/query/execution/run.js';
 import { bindDependencies } from '../dependency/index.js';
 export function bindCapabilities(domain, sessions, declared) {
     const graph = bindGraph(sessions, domain);
@@ -13,17 +13,17 @@ export function bindCapabilities(domain, sessions, declared) {
         dependencies: bindDependencies(domain, sessions),
         graph,
         query: async (definition, input, options) => {
-            if (mutationRecipeSpecOf(definition) !== undefined)
+            if (mutationSpecOf(definition) !== undefined)
                 throw new TypeError(`Mutation ${definition.id} writes: call it with mutate, not query.`);
-            if (recipeSpecOf(definition) === undefined)
+            if (querySpecOf(definition) === undefined)
                 return graphUnder(options).query(definition, input);
             if (options === undefined)
-                throw new TypeError(`Recipe ${definition.id} is called with { as: 'executor' | 'caller' }.`);
+                throw new TypeError(`Query ${definition.id} is called with { as: 'executor' | 'caller' }.`);
             const { size, after } = options;
-            return runQueryRecipe(sessions[authorityOf(sessions, options)], domain, definition, input, { ...(size === undefined ? {} : { size }), ...(after === undefined ? {} : { after }) }, declared);
+            return runQuery(sessions[authorityOf(sessions, options)], domain, definition, input, { ...(size === undefined ? {} : { size }), ...(after === undefined ? {} : { after }) }, declared);
         },
         mutate: async (definition, input, options) => {
-            if (mutationRecipeSpecOf(definition) === undefined)
+            if (mutationSpecOf(definition) === undefined)
                 return graphUnder(options).mutate(definition, input);
             if (options === undefined)
                 throw new TypeError(`Mutation ${definition.id} is called with { as: 'executor' | 'caller' }.`);

package/dist/execution/invocation/dispatch/action.js

@@ -1,5 +1,5 @@
 import { declaredErrorFactory, declaredErrorOf } from '../../../application/error/index.js';
-import { protocolError, reportUndeclaredRecipeError } from '../result/index.js';
+import { protocolError, reportUndeclaredDefinedError } from '../result/index.js';
 export async function action(selected, context) {
     const complete = Object.freeze({
         ...context,
@@ -11,7 +11,7 @@ export async function action(selected, context) {
     catch (cause) {
         const declared = declaredErrorOf(cause, selected.definition);
         if (declared === undefined) {
-            reportUndeclaredRecipeError(cause, selected.address);
+            reportUndeclaredDefinedError(cause, selected.address);
             throw cause;
         }
         throw protocolError(declared.family, declared.message, {

package/dist/execution/invocation/dispatch/workflow.js

@@ -1,5 +1,5 @@
 import { declaredErrorFactory, declaredErrorOf } from '../../../application/error/index.js';
-import { protocolError, reportUndeclaredRecipeError } from '../result/index.js';
+import { protocolError, reportUndeclaredDefinedError } from '../result/index.js';
 export async function workflow(selected, context, runner) {
     const complete = Object.freeze({
         ...context,
@@ -11,7 +11,7 @@ export async function workflow(selected, context, runner) {
     catch (cause) {
         const declared = declaredErrorOf(cause, selected.definition);
         if (declared === undefined) {
-            reportUndeclaredRecipeError(cause, selected.address);
+            reportUndeclaredDefinedError(cause, selected.address);
             throw cause;
         }
         throw protocolError(declared.family, declared.message, {

package/dist/execution/invocation/result/index.d.ts

@@ -1,5 +1,5 @@
 export { inputError, InvocationDefect, projectError, protocolError } from './errors.js';
 export type { InvocationDefectCode } from './errors.js';
 export { project } from './project.js';
-export { reportUndeclaredRecipeError } from './recipe.js';
+export { reportUndeclaredDefinedError } from './undeclared.js';
 export { validateInput, validateOutput } from './validate.js';

package/dist/execution/invocation/result/index.js

@@ -1,4 +1,4 @@
 export { inputError, InvocationDefect, projectError, protocolError } from './errors.js';
 export { project } from './project.js';
-export { reportUndeclaredRecipeError } from './recipe.js';
+export { reportUndeclaredDefinedError } from './undeclared.js';
 export { validateInput, validateOutput } from './validate.js';

package/dist/execution/invocation/result/undeclared.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Log a Query or Mutation's declared error that reaches a Function which does not re-declare it,
+ * before the Server redacts it as an internal error: its code, the id of the Query or Mutation and
+ * the Function, never its details, which a read as the executor may fill with what the caller may
+ * not read.
+ */
+export declare function reportUndeclaredDefinedError(cause: unknown, address: string): void;

package/dist/execution/invocation/result/undeclared.js

@@ -0,0 +1,18 @@
+import { definedErrorOf } from '../../../application/error/index.js';
+/**
+ * Log a Query or Mutation's declared error that reaches a Function which does not re-declare it,
+ * before the Server redacts it as an internal error: its code, the id of the Query or Mutation and
+ * the Function, never its details, which a read as the executor may fill with what the caller may
+ * not read.
+ */
+export function reportUndeclaredDefinedError(cause, address) {
+    const raised = definedErrorOf(cause);
+    if (raised === undefined)
+        return;
+    // oxlint-disable-next-line no-console
+    console.error('[sdk] Query or Mutation error not re-declared by its Function', {
+        code: raised.code,
+        id: raised.id,
+        function: address,
+    });
+}