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

package/dist/platform/schema/kernel.d.ts

@@ -17,6 +17,8 @@ export interface KernelDomain extends schema.DomainOf<CoreKernelSchema> {
 export interface KernelSchema extends DefinedSchema<CoreKernelSchema['origin'], KernelDomain> {
 }
 export declare const KernelSchema: KernelSchema;
-export declare const K: schema.ResolvedDomainOf<KernelSchema>;
-export type Kernel = typeof K;
+/** The Kernel Domain, resolved: the SDK-owned name of `K`'s type. */
+export interface Kernel extends schema.ResolvedDomainOf<KernelSchema> {
+}
+export declare const K: Kernel;
 export {};

package/dist/testing/index.d.ts

@@ -12,5 +12,5 @@ export { isTests, tests } from './tests.js';
 export type { Tests, TestsInput } from './tests.js';
 export { createTestWorkflowEngine } from './durable/index.js';
 export type { TestExecution, TestJournalEntry, TestStartOptions, TestStepCapabilities, TestWorkflowEngine, TestWorkflowEngineOptions, } from './durable/index.js';
-export { checkRecipe } from './recipe.js';
-export type { CheckRecipeOptions } from './recipe.js';
+export { checkQuery } from './query.js';
+export type { CheckQueryOptions } from './query.js';

package/dist/testing/index.js

@@ -7,4 +7,4 @@ export { loadDataset, loadDatasets } from './load.js';
 export { dataset, isDatasetReference } from './reference.js';
 export { isTests, tests } from './tests.js';
 export { createTestWorkflowEngine } from './durable/index.js';
-export { checkRecipe } from './recipe.js';
+export { checkQuery } from './query.js';

package/dist/testing/{recipe.d.ts → query.d.ts}

@@ -1,17 +1,17 @@
 import type { DomainDefinitionIdentity } from '../application/domain.js';
-import type { InputOf, Recipe } from '../application/query/recipe/recipe.js';
+import type { InputOf, DefinedQuery } from '../application/query/defined/query.js';
 import type { schema } from '../platform/schema/index.js';
-export interface CheckRecipeOptions {
+export interface CheckQueryOptions {
     /**
-     * The Domain the recipe reads: its definition, whose requirements S12 checks a relation
+     * The Domain the Query reads: its definition, whose requirements S12 checks a relation
      * against, or its Schema alone, which holds no requirements, so S12 is not checked.
      */
     readonly domain: DomainDefinitionIdentity | schema.DomainSchema;
 }
 /**
- * Build a recipe for `sampleInput` and lower its first step, as a call would, without a Kernel:
+ * Build a Query for `sampleInput` and lower its first step, as a call would, without a Kernel:
  * it throws what the call would raise before sending, a bound past S11 (`QueryError` `TOO_MANY` or
  * `INPUT_INVALID`), a relation across a Class the Domain's definition does not declare (S12), or a
  * step that does not build.
  */
-export declare function checkRecipe<R extends Recipe>(recipe: R, sampleInput: InputOf<R>, options: CheckRecipeOptions): void;
+export declare function checkQuery<R extends DefinedQuery>(query: R, sampleInput: InputOf<R>, options: CheckQueryOptions): void;

package/dist/testing/{recipe.js → query.js}

@@ -1,31 +1,31 @@
 import { isDomainDefinition } from '../application/define.js';
-import { planStep, Run, stepsFor, stepsOf } from '../application/query/execution/recipe.js';
+import { querySpecOf } from '../application/query/defined/define.js';
+import { planStep, Run, stepsFor, stepsOf } from '../application/query/execution/run.js';
 import { handlesOf } from '../application/query/handles/build.js';
 import { describe } from '../application/query/handles/terms.js';
-import { recipeSpecOf } from '../application/query/recipe/define.js';
 import { schema as schemaApi } from '../platform/schema/index.js';
 /** Never reached: a check sends nothing. */
 const NO_KERNEL = Object.freeze({
-    query: () => Promise.reject(new Error('checkRecipe sends no read.')),
+    query: () => Promise.reject(new Error('checkQuery sends no read.')),
 });
 /**
- * Build a recipe for `sampleInput` and lower its first step, as a call would, without a Kernel:
+ * Build a Query for `sampleInput` and lower its first step, as a call would, without a Kernel:
  * it throws what the call would raise before sending, a bound past S11 (`QueryError` `TOO_MANY` or
  * `INPUT_INVALID`), a relation across a Class the Domain's definition does not declare (S12), or a
  * step that does not build.
  */
-export function checkRecipe(recipe, sampleInput, options) {
-    const spec = recipeSpecOf(recipe);
+export function checkQuery(query, sampleInput, options) {
+    const spec = querySpecOf(query);
     if (spec === undefined)
-        throw new TypeError(`Not a v7 recipe: define one with defineQuery<Schema>()(id, { build }); got ${describe(recipe)}.`);
+        throw new TypeError(`Not a Query v7: define one with defineQuery<Schema>()(id, { build }); got ${describe(query)}.`);
     const definition = isDomainDefinition(options?.domain) ? options.domain : undefined;
     const domain = schemaApi.resolve(definition?.schema ?? options?.domain);
     // A definition types its requirements as written; the check reads any.
     const requirements = definition?.requirements;
     const declared = definition === undefined ? undefined : (requirements?.classes ?? []);
-    const run = new Run(NO_KERNEL, domain, recipe.id, declared);
+    const run = new Run(NO_KERNEL, domain, query.id, declared);
     const build = spec.build;
-    const built = build(sampleInput, handlesOf(domain), stepsFor(recipe.id));
+    const built = build(sampleInput, handlesOf(domain), stepsFor(query.id));
     const steps = stepsOf(built);
     if (steps === undefined)
         planStep(run, built, true);

package/dist/tooling/cli/orchestrate.js

@@ -1,6 +1,6 @@
 import { existsSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
-import { admitRecipes, collectRecipes, } from '../../application/query/recipe/define.js';
+import { admitDefinitions, collectDefinitions, } from '../../application/query/defined/define.js';
 import { admitRuntime, compile, resolveRuntime } from '../../deployment/index.js';
 import { packageDomain } from '../packaging/index.js';
 import { runAdapterCommand } from './adapter-command.js';
@@ -61,9 +61,10 @@ export async function run(argv) {
         error(`No astrale.config.ts found in ${projectDir}.`);
         return 1;
     }
-    // The recipes loading this project and its runtime define: the ones the build checks together.
-    const recipes = [];
-    const project = await collectRecipes(recipes, () => loadProject(configPath));
+    // The Queries and Mutations loading this project and its runtime define: the ones the build
+    // checks together.
+    const queries = [];
+    const project = await collectDefinitions(queries, () => loadProject(configPath));
     if (parsed.command === 'list')
         return list(parsed, project, projectDir);
     if (parsed.command === 'adapter') {
@@ -104,9 +105,9 @@ export async function run(argv) {
         });
     }
     const build = compile(project.domain);
-    const resolved = await collectRecipes(recipes, () => resolveRuntime(runtimeEntrypoint(project), (path) => importModule(resolve(dirname(configPath), path))));
+    const resolved = await collectDefinitions(queries, () => resolveRuntime(runtimeEntrypoint(project), (path) => importModule(resolve(dirname(configPath), path))));
     admitRuntime({ runtime: build.runtime }, resolved);
-    admitRecipes(recipes);
+    admitDefinitions(queries);
     if (parsed.command === 'diff') {
         const lifecycle = deploymentLifecycle('Diff interrupted.');
         try {

package/dist/tooling/linter/adapters/typescript/{recipe-definitions.d.ts → definition-calls.d.ts}

@@ -1,17 +1,17 @@
 import ts from 'typescript';
 import type { SourceFile } from './index.js';
-/** The modules each recipe factory is exported from. */
-declare const RECIPE_MODULES: {
+/** The modules each definition factory is exported from. */
+declare const FACTORY_MODULES: {
     readonly defineQuery: Set<string>;
     readonly defineMutation: Set<string>;
 };
-/** The factories that define recipes: Query recipes, and Mutation recipes (D31). */
-export type RecipeFactory = keyof typeof RECIPE_MODULES;
+/** The factories that define from an id: Queries v7, and Mutations (D31). */
+export type DefinitionFactory = keyof typeof FACTORY_MODULES;
 /**
- * A recipe: `defineQuery<Schema>()` applied to an id and a spec `{ build, output? }`, or
+ * A definition from an id: `defineQuery<Schema>()` applied to an id and a spec `{ build, output? }`, or
  * `defineMutation<Schema>()` applied to an id and a spec `{ build, output?, reject? }`.
  */
-export interface RecipeDefinition {
+export interface DefinitionCall {
     /** The application `(id, spec)`. */
     readonly call: ts.CallExpression;
     /** The factory, `defineQuery<Schema>()`, applied directly or through the const it is bound to. */
@@ -19,16 +19,16 @@ export interface RecipeDefinition {
     readonly origin: 'resolved' | 'ambiguous';
 }
 /**
- * The recipes a file defines with `name`. A recipe applies `defineQuery<Schema>()` (or
+ * The definitions a file makes with `name` from an id. Each applies `defineQuery<Schema>()` (or
  * `defineMutation<Schema>()`) to two values, its id and its spec, where a V6 Query (or a Mutation
  * of the closure form) applies it to one Domain projector. A const bound to the factory is followed
  * to its applications in the same file.
  */
-export declare function recipeDefinitions(file: SourceFile, name?: RecipeFactory): readonly RecipeDefinition[];
+export declare function definitionCalls(file: SourceFile, name?: DefinitionFactory): readonly DefinitionCall[];
 /**
- * Whether a `defineQuery<Schema>()` (or `defineMutation<Schema>()`) call makes recipes: applied to
+ * Whether a `defineQuery<Schema>()` (or `defineMutation<Schema>()`) call defines from an id: applied to
  * an id and a spec, or bound to a const that no application in the file passes one Domain
  * projector.
  */
-export declare function isRecipeFactory(file: SourceFile, factory: ts.CallExpression): boolean;
+export declare function isDefinitionFactory(file: SourceFile, factory: ts.CallExpression): boolean;
 export {};

package/dist/tooling/linter/adapters/typescript/{recipe-definitions.js → definition-calls.js}

@@ -1,18 +1,18 @@
 import ts from 'typescript';
 import { resolveImportedSymbol, unwrap, visit } from './syntax.js';
-/** The modules each recipe factory is exported from. */
-const RECIPE_MODULES = {
+/** The modules each definition factory is exported from. */
+const FACTORY_MODULES = {
     defineQuery: new Set(['@astrale-os/sdk', '@astrale-os/sdk/query']),
     defineMutation: new Set(['@astrale-os/sdk', '@astrale-os/sdk/mutation']),
 };
 /**
- * The recipes a file defines with `name`. A recipe applies `defineQuery<Schema>()` (or
+ * The definitions a file makes with `name` from an id. Each applies `defineQuery<Schema>()` (or
  * `defineMutation<Schema>()`) to two values, its id and its spec, where a V6 Query (or a Mutation
  * of the closure form) applies it to one Domain projector. A const bound to the factory is followed
  * to its applications in the same file.
  */
-export function recipeDefinitions(file, name = 'defineQuery') {
-    const recipes = [];
+export function definitionCalls(file, name = 'defineQuery') {
+    const definitions = [];
     visit(file.source, (node) => {
         if (!ts.isCallExpression(node) || node.arguments.length !== 2)
             return;
@@ -20,16 +20,16 @@ export function recipeDefinitions(file, name = 'defineQuery') {
         const factory = ts.isCallExpression(callee) ? callee : boundFactory(file, callee);
         const origin = factory && factoryOrigin(file, factory, name);
         if (factory && origin)
-            recipes.push({ call: node, factory, origin });
+            definitions.push({ call: node, factory, origin });
     });
-    return recipes;
+    return definitions;
 }
 /**
- * Whether a `defineQuery<Schema>()` (or `defineMutation<Schema>()`) call makes recipes: applied to
+ * Whether a `defineQuery<Schema>()` (or `defineMutation<Schema>()`) call defines from an id: applied to
  * an id and a spec, or bound to a const that no application in the file passes one Domain
  * projector.
  */
-export function isRecipeFactory(file, factory) {
+export function isDefinitionFactory(file, factory) {
     const parent = factory.parent;
     if (ts.isCallExpression(parent) && unwrap(parent.expression) === factory)
         return parent.arguments.length === 2;
@@ -51,7 +51,7 @@ function factoryOrigin(file, factory, name) {
         return undefined;
     if (symbol.kind === 'ambiguous')
         return 'ambiguous';
-    return RECIPE_MODULES[name].has(symbol.module) ? 'resolved' : undefined;
+    return FACTORY_MODULES[name].has(symbol.module) ? 'resolved' : undefined;
 }
 /** The factory a top-level const binds, when the callee names one. */
 function boundFactory(file, callee) {

package/dist/tooling/linter/adapters/typescript/index.d.ts

@@ -5,7 +5,7 @@ export { bindingContains, importedSymbol, isLocallyDeclared, resolveImportedSymb
 export { assertSingleTypeUniverse } from './type-universe.js';
 export { observeQueryDefinitions } from './query-observation.js';
 export { queryCollectionKind } from './query-collection-type.js';
-export { isRecipeFactory, recipeDefinitions, type RecipeDefinition, type RecipeFactory, } from './recipe-definitions.js';
+export { isDefinitionFactory, definitionCalls, type DefinitionCall, type DefinitionFactory, } from './definition-calls.js';
 export { declarationOf, expressionType, type ExpressionType } from './type-analysis.js';
 export { collectSuppressionDirectives } from './suppression-directives.js';
 import type ts from 'typescript';

package/dist/tooling/linter/adapters/typescript/index.js

@@ -5,6 +5,6 @@ export { bindingContains, importedSymbol, isLocallyDeclared, resolveImportedSymb
 export { assertSingleTypeUniverse } from './type-universe.js';
 export { observeQueryDefinitions } from './query-observation.js';
 export { queryCollectionKind } from './query-collection-type.js';
-export { isRecipeFactory, recipeDefinitions, } from './recipe-definitions.js';
+export { isDefinitionFactory, definitionCalls, } from './definition-calls.js';
 export { declarationOf, expressionType } from './type-analysis.js';
 export { collectSuppressionDirectives } from './suppression-directives.js';

package/dist/tooling/linter/adapters/typescript/query-observation.js

@@ -1,6 +1,6 @@
 import ts from 'typescript';
 import { ambiguous, known, unknown, } from '../../analysis/query/index.js';
-import { recipeDefinitions } from './recipe-definitions.js';
+import { definitionCalls } from './definition-calls.js';
 import { location, resolveImportedSymbol, unwrap, visit } from './syntax.js';
 const SDK_MODULES = new Set(['@astrale-os/sdk', '@astrale-os/sdk/query']);
 const QUERY_MODULES = new Set([
@@ -14,9 +14,9 @@ export function observeQueryDefinitions(project) {
         .flatMap(observeFile));
 }
 function observeFile(file) {
-    const recipes = recipeDefinitions(file);
-    const applications = new Set(recipes.map(({ call }) => call));
-    const observations = recipes.map((recipe) => recipeObservation(file, recipe));
+    const definitions = definitionCalls(file);
+    const applications = new Set(definitions.map(({ call }) => call));
+    const observations = definitions.map((definition) => definitionObservation(file, definition));
     visit(file.source, (node) => {
         if (!ts.isCallExpression(node) || applications.has(node))
             return;
@@ -79,10 +79,10 @@ function observeFile(file) {
     return observations;
 }
 /**
- * A v7 recipe is one single definition: its build returns reads built from the Domain's handles,
+ * A Query v7 is one single definition: its build returns reads built from the Domain's handles,
  * which lower to canonical Query JSON by construction, and it has no projection callback.
  */
-function recipeObservation(file, { call, factory, origin }) {
+function definitionObservation(file, { call, factory, origin }) {
     const subjectId = `${file.path}#${call.getStart(file.source)}`;
     const sourceLocation = location(file, call);
     if (origin === 'ambiguous')

package/dist/tooling/linter/implementations/source/definitions.d.ts

@@ -0,0 +1,2 @@
+import type { SourceRuleVerifier } from './verifier.js';
+export declare const definitionRules: readonly SourceRuleVerifier[];

package/dist/tooling/linter/implementations/source/{recipes.js → definitions.js}

@@ -1,37 +1,37 @@
 import ts from 'typescript';
-import { declarationOf, expressionType, isLocallyDeclared, recipeDefinitions, unwrap, visit, } from '../../adapters/typescript/index.js';
+import { declarationOf, expressionType, isLocallyDeclared, definitionCalls, unwrap, visit, } from '../../adapters/typescript/index.js';
 import { production, propertyExpression, returnedExpressions, violation } from './shared.js';
-/** Rows of bound product past which a recipe is flagged: a tenth of what one call may read. */
+/** Rows of bound product past which a Query is flagged: a tenth of what one call may read. */
 const ROWS = 10_000;
-export const recipeRules = [
+export const definitionRules = [
     {
-        id: 'QRY-RECIPE-CLOCK',
-        ruleRevision: '9a5fd016eb166ca70830a30ca43cbf9796ccea5687c6e81a20b75e1775b82cb4',
+        id: 'QRY-CLOCK',
+        ruleRevision: '776cea7dd21460547625a1e6b7a74fcd80956bd7f4cfbdc6641e6458661095ee',
         evaluate(project) {
-            return recipesOf(project).flatMap(({ file, recipe }) => clockEvidence(file, recipe));
+            return definitionsOf(project).flatMap(({ file, definition }) => clockEvidence(file, definition));
         },
     },
     {
-        id: 'QRY-RECIPE-ROWS',
-        ruleRevision: 'a2fbec742bc0c4a1e48acbb150b81f1dbafc81e291a47a2e2b16f60f89cc385d',
+        id: 'QRY-ROWS',
+        ruleRevision: '2b470871ff394e42f19b7fc1ddcfcd4e853ced9e65412e3dfe0d0c66e9caf4a2',
         evaluate(project) {
-            return recipesOf(project).flatMap(({ file, recipe }) => rowsEvidence(project, file, recipe));
+            return definitionsOf(project).flatMap(({ file, definition }) => rowsEvidence(project, file, definition));
         },
     },
     {
-        id: 'QRY-RECIPE-FALSY',
-        ruleRevision: '972ad5ec32f46731a2652ae0328d486ed107c0c359a6c42d1d613b773b0ff478',
+        id: 'QRY-FALSY',
+        ruleRevision: '3041a35ba8209331f3c64d8aada93f6b7a8194802a23927f29d919a1e7354719',
         evaluate(project) {
-            return recipesOf(project).flatMap(({ file, recipe }) => falsyFilterEvidence(project, file, recipe));
+            return definitionsOf(project).flatMap(({ file, definition }) => falsyFilterEvidence(project, file, definition));
         },
     },
 ];
-function recipesOf(project) {
-    return production(project, 'queries').flatMap((file) => recipeDefinitions(file)
+function definitionsOf(project) {
+    return production(project, 'queries').flatMap((file) => definitionCalls(file)
         .filter(({ origin }) => origin === 'resolved')
-        .map((recipe) => ({ file, recipe })));
+        .map((definition) => ({ file, definition })));
 }
-/** A recipe's spec as written: its id, and its `build` and `output` written inline. */
+/** A Query's spec as written: its id, and its `build` and `output` written inline. */
 function specOf(file, { call }) {
     const id = unwrap(call.arguments[0]);
     const spec = unwrap(call.arguments[1]);
@@ -57,8 +57,8 @@ const CLOCKS = [
     ['process', 'uptime'],
 ];
 /** Each clock read in `build` and `output`, their callbacks included: they all run in the call. */
-function clockEvidence(file, recipe) {
-    const { name, build, output } = specOf(file, recipe);
+function clockEvidence(file, definition) {
+    const { name, build, output } = specOf(file, definition);
     const evidence = [];
     const fields = [
         ...(build === undefined ? [] : [{ field: 'build', fn: build }]),
@@ -69,7 +69,7 @@ function clockEvidence(file, recipe) {
             const read = clockRead(node);
             if (read === undefined)
                 return;
-            evidence.push(violation(file, node, `Recipe ${name}'s ${field} reads the clock (${read}): no write moves time, so nothing would refresh the read. Take now in the recipe's input.`));
+            evidence.push(violation(file, node, `Query ${name}'s ${field} reads the clock (${read}): no write moves time, so nothing would refresh the read. Take now in the Query's input.`));
         });
     }
     return evidence;
@@ -105,12 +105,12 @@ function isGlobal(expression, path) {
     return ts.isIdentifier(current) && current.text === path[0] && !isLocallyDeclared(current);
 }
 /**
- * A recipe whose bounds multiply past `ROWS`, counted as a call counts them (S11): each verb's
+ * A Query whose bounds multiply past `ROWS`, counted as a call counts them (S11): each verb's
  * rows, `find` 2, `first(n)` n, `all` and `page` max + 1, times one plus what each row carries.
- * A bound that is not a constant counts nothing, so the count is the least the recipe may read.
+ * A bound that is not a constant counts nothing, so the count is the least the Query may read.
  */
-function rowsEvidence(project, file, recipe) {
-    const { name, build } = specOf(file, recipe);
+function rowsEvidence(project, file, definition) {
+    const { name, build } = specOf(file, definition);
     const handles = boundNames(build?.parameters[1]?.name);
     if (build === undefined || handles.size === 0)
         return [];
@@ -126,7 +126,7 @@ function rowsEvidence(project, file, recipe) {
     if (rows <= ROWS)
         return [];
     return [
-        violation(file, recipe.call, `Recipe ${name} reads up to ${rows.toLocaleString('en-US')} rows, the product of its bounds, past ${ROWS.toLocaleString('en-US')}: lower a bound, or split the read.`),
+        violation(file, definition.call, `Query ${name} reads up to ${rows.toLocaleString('en-US')} rows, the product of its bounds, past ${ROWS.toLocaleString('en-US')}: lower a bound, or split the read.`),
     ];
 }
 /**
@@ -288,8 +288,8 @@ const COMBINATIONS = new Set(['and', 'or']);
  * number: the entry is then `false`, `0` or `undefined`, which is skipped, so the comparison is
  * dropped.
  */
-function falsyFilterEvidence(project, file, recipe) {
-    const { name, build } = specOf(file, recipe);
+function falsyFilterEvidence(project, file, definition) {
+    const { name, build } = specOf(file, definition);
     const evidence = [];
     if (build !== undefined)
         visit(build, (node) => {
@@ -306,7 +306,7 @@ function falsyFilterEvidence(project, file, recipe) {
                     const explicit = admitted === 'number'
                         ? `${value} !== undefined && ${value} !== 0 && …`
                         : `${value} ? ….eq(true) : undefined`;
-                    evidence.push(violation(file, entry, `Recipe ${name} drops the condition on ${value} when ${value} is false or 0: the ${skipped.call} entry is then falsy, and ${skipped.call} skips it. To compare whenever ${value} is set, write ${value} !== undefined && …; if false or 0 means no filter, write that explicitly: ${explicit}.`));
+                    evidence.push(violation(file, entry, `Query ${name} drops the condition on ${value} when ${value} is false or 0: the ${skipped.call} entry is then falsy, and ${skipped.call} skips it. To compare whenever ${value} is set, write ${value} !== undefined && …; if false or 0 means no filter, write that explicitly: ${explicit}.`));
                 }
         });
     return evidence;

package/dist/tooling/linter/implementations/source/global.js

@@ -1,5 +1,5 @@
 import ts from 'typescript';
-import { RECIPE_ID } from '../../../../application/query/recipe/define.js';
+import { DEFINITION_ID } from '../../../../application/query/defined/define.js';
 import { importedSymbol, resolveImportedSymbol, resolveProjectImport, unwrap, visit, } from '../../adapters/typescript/index.js';
 import { DSL_MODULES, SDK_MODULES, ambiguity, definitionOriginAmbiguity, definitionObjects, isDeepPackageImport, isForeignDomain, isLocallyBoundIdentifier, packageRoot, production, propertyExpression, violation, } from './shared.js';
 const CANONICAL_TYPES = new Set([
@@ -530,15 +530,17 @@ export const globalRules = [
                                     ts.isNoSubstitutionTemplateLiteral(idExpression))
                                 ? idExpression.text
                                 : undefined;
-                            // A v7 recipe id is the one `defineQuery` admits; any other keeps the stable form.
-                            const form = candidate.id ? RECIPE_ID : STABLE_DEFINITION_ID;
+                            // A Query v7 or defined Mutation id is the one `defineQuery` admits; any other keeps the stable form.
+                            const form = candidate.id ? DEFINITION_ID : STABLE_DEFINITION_ID;
                             if (!idExpression || !id || !form.test(id)) {
                                 evidence.push(violation(file, idExpression ?? call, `${definition.name}${member ? `.${member}` : ''} ID must be a stable semantic literal.`));
                                 continue;
                             }
-                            // An id is unique in its layer; Query and Mutation recipes also share one namespace,
-                            // the one the runtime admits them in.
-                            const scopes = candidate.id ? [definition.layer, 'recipe'] : [definition.layer];
+                            // An id is unique in its layer; Queries and Mutations defined from an id also share one
+                            // namespace, the one the runtime admits them in.
+                            const scopes = candidate.id
+                                ? [definition.layer, 'Query or Mutation']
+                                : [definition.layer];
                             const duplicated = scopes.find((scope) => owners.has(`${scope}\0${id}`));
                             if (duplicated) {
                                 evidence.push(violation(file, idExpression, `${duplicated} definition ID ${id} is duplicated; first declared in ${owners.get(`${duplicated}\0${id}`).file.path}.`));

package/dist/tooling/linter/implementations/source/mutations.js

@@ -540,7 +540,7 @@ function mutationBuilderScopes(file) {
             continue;
         }
         for (const [imported, local] of sourceImport.bindings) {
-            if (imported === 'RichMutationBuilder' || imported === 'RecipeMutationBuilder')
+            if (imported === 'RichMutationBuilder' || imported === 'DefinedMutationBuilder')
                 richBuilderTypes.add(local);
         }
     }
@@ -663,7 +663,7 @@ function classOperationForBuilder(operation) {
     }
 }
 function dependencyClassTarget(expression, handles) {
-    // A recipe names a dependency's Class by its handle, `d.<alias>.<Class>`.
+    // A defined Mutation names a dependency's Class by its handle, `d.<alias>.<Class>`.
     const path = handlePath(expression, handles);
     if (path !== undefined) {
         return path.length === 2 && !OWN_HANDLES.has(path[0])
@@ -721,7 +721,7 @@ function handleParameters(file) {
     return parameters;
 }
 /**
- * The handle a recipe's expression names, as its path from `d`: `d.Item` and a destructured
+ * The handle a defined Mutation's expression names, as its path from `d`: `d.Item` and a destructured
  * `{ Item }` are `['Item']`, `d.directory.Person` is `['directory', 'Person']`. Undefined for an
  * expression that does not start from the handles, or not statically.
  */
@@ -775,7 +775,7 @@ function bindingPath(binding, handles, seen) {
         ? path
         : undefined;
 }
-/** The builder a Mutation's `build` receives: second in the closure form, third in a recipe. */
+/** The builder a Mutation's `build` receives: second in the closure form, third in a defined Mutation. */
 function builderParameter(definition, build) {
     return build.parameters[definition.id === undefined ? 1 : 2];
 }
@@ -1317,7 +1317,7 @@ function selectedClassNames(expression, handles, seen = new Set()) {
         const whenFalse = selectedClassNames(value.whenFalse, handles, seen);
         return whenTrue && whenFalse ? new Set([...whenTrue, ...whenFalse]) : undefined;
     }
-    // A recipe names its Class by its handle: the last segment of its path from `d`.
+    // A defined Mutation names its Class by its handle: the last segment of its path from `d`.
     const path = handlePath(value, handles);
     if (path !== undefined)
         return path.length > 0 ? new Set([path.at(-1)]) : undefined;

package/dist/tooling/linter/implementations/source/shared.d.ts

@@ -7,7 +7,7 @@ export interface DefinitionObject {
     readonly call: ts.CallExpression;
     readonly object?: ts.ObjectLiteralExpression;
     readonly projector?: ts.FunctionLikeDeclaration;
-    /** A recipe's id, its first argument: a recipe, Query or Mutation, has no Domain projector. */
+    /** A definition's id, its first argument: a Query v7 or a defined Mutation has no Domain projector. */
     readonly id?: ts.Expression;
     readonly origin: 'resolved' | 'ambiguous';
 }
@@ -23,7 +23,7 @@ export declare function memberCalls(file: SourceFile, importedName: string, memb
 export declare function definitionObjects(file: SourceFile, importedName: string, member?: string, modules?: Set<string>, argumentIndex?: number): DefinitionObject[];
 export declare function definitionOriginAmbiguity(file: SourceFile, definition: DefinitionObject, name: string): SourceRuleEvidence | undefined;
 /**
- * Prove the clean curried Domain projector shape for Query and Mutation definitions. A recipe,
+ * Prove the clean curried Domain projector shape for Query and Mutation definitions. A definition from an id,
  * `defineQuery<typeof Schema>()(id, { build })` or `defineMutation<typeof Schema>()(id, { build })`,
  * has no projector to prove.
  */

package/dist/tooling/linter/implementations/source/shared.js

@@ -1,5 +1,5 @@
 import ts from 'typescript';
-import { bindingContains, importedSymbol, isRecipeFactory, location, objectProperty, propertyChain, recipeDefinitions, resolveImportedSymbol, resolveProjectImport, staticText, unwrap, visit, } from '../../adapters/typescript/index.js';
+import { bindingContains, importedSymbol, isDefinitionFactory, location, objectProperty, propertyChain, definitionCalls, resolveImportedSymbol, resolveProjectImport, staticText, unwrap, visit, } from '../../adapters/typescript/index.js';
 export const SDK_MODULES = new Set([
     '@astrale-os/sdk',
     '@astrale-os/sdk/action',
@@ -59,10 +59,10 @@ export function memberCalls(file, importedName, member, modules = SDK_MODULES) {
 }
 export function definitionObjects(file, importedName, member, modules = SDK_MODULES, argumentIndex = 0) {
     if (!member && DOMAIN_BOUND_DEFINITIONS.has(importedName)) {
-        const recipes = importedName === 'defineQuery' || importedName === 'defineMutation'
-            ? recipeDefinitions(file, importedName)
+        const definitions = importedName === 'defineQuery' || importedName === 'defineMutation'
+            ? definitionCalls(file, importedName)
             : [];
-        const applications = new Set(recipes.map(({ call }) => call));
+        const applications = new Set(definitions.map(({ call }) => call));
         return [
             ...curriedCalls(file, importedName, modules)
                 .filter(({ call }) => !applications.has(call))
@@ -75,7 +75,7 @@ export function definitionObjects(file, importedName, member, modules = SDK_MODU
                     object: projector && returnedObject(projector),
                 };
             }),
-            ...recipes.map(({ call, origin }) => ({
+            ...definitions.map(({ call, origin }) => ({
                 call,
                 origin,
                 id: call.arguments[0],
@@ -122,7 +122,7 @@ export function definitionOriginAmbiguity(file, definition, name) {
         : undefined;
 }
 /**
- * Prove the clean curried Domain projector shape for Query and Mutation definitions. A recipe,
+ * Prove the clean curried Domain projector shape for Query and Mutation definitions. A definition from an id,
  * `defineQuery<typeof Schema>()(id, { build })` or `defineMutation<typeof Schema>()(id, { build })`,
  * has no projector to prove.
  */
@@ -132,7 +132,7 @@ export function domainProjectorEvidence(file, importedName, label) {
         if (candidate.origin === 'ambiguous')
             continue;
         if ((importedName === 'defineQuery' || importedName === 'defineMutation') &&
-            isRecipeFactory(file, candidate.call))
+            isDefinitionFactory(file, candidate.call))
             continue;
         const application = candidate.call.parent;
         if (candidate.call.arguments.length !== 0 ||

package/dist/tooling/linter/implementations/source/verifiers.js

@@ -1,4 +1,5 @@
 import { actionRules } from './actions.js';
+import { definitionRules } from './definitions.js';
 import { dependencyRules } from './dependencies.js';
 import { globalRules } from './global.js';
 import { integrationRules } from './integrations.js';
@@ -6,7 +7,6 @@ import { mutationRules } from './mutations.js';
 import { policyEdgeRules } from './policy-edges.js';
 import { providerRules } from './providers.js';
 import { queryRules } from './queries.js';
-import { recipeRules } from './recipes.js';
 import { pureRuleRules } from './rules.js';
 import { schemaRules } from './schema.js';
 import { stateRules } from './states.js';
@@ -22,7 +22,7 @@ export const sourceRuleVerifiers = Object.freeze([
     ...stateRules,
     ...pureRuleRules,
     ...queryRules,
-    ...recipeRules,
+    ...definitionRules,
     ...mutationRules,
     ...workflowRules,
     ...dependencyRules,