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

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

@@ -1,34 +1,7 @@
-import type { QueryAST } from '@astrale-os/kernel-core/graph/query';
-import type { AnyResolvedClass } from '@astrale-os/kernel-dsl/v1';
 import type { Domain, schema } from '../../platform/schema/index.js';
 import type { ProjectedCompositeQuery, QueryComposition, QueryPlan, QueryPlanOutput, RawCompositeQuery } from './composite/index.js';
-import type { CompositeQueryDefinition, CollectionQueryDefinition, QueryDefinition, RealizedQuery, SingleQueryDefinition } from './query.js';
-import type { PaginatedQuery, ProjectedQuery, RawQuery, SingleQuery } from './single/index.js';
-import { type CollectionQuerySpec } from './collection/metadata.js';
-type AuthoredRaw<Input, Ast extends QueryAST> = Omit<RawQuery<Input, Ast>, 'kind' | 'page'> & {
-    readonly page?: {
-        readonly size: number;
-    };
-};
-type AuthoredProjected<Input, Output, Ast extends QueryAST> = Omit<ProjectedQuery<Input, Output, Ast>, 'kind' | 'page'> & {
-    readonly page?: {
-        readonly size: number;
-    };
-};
-type AuthoredPaginated<Input, Output, Ast extends QueryAST> = Omit<PaginatedQuery<Input, Output, Ast>, 'kind' | 'page'> & {
-    readonly page?: {
-        readonly size: number;
-    };
-};
-type ResolvedDomainOf<Schema extends schema.DomainSchema> = Extract<schema.DomainOf<Schema>, Domain>;
-interface SingleQueryProjector<Schema extends schema.DomainSchema> {
-    <Input, Ast extends QueryAST>(project: (domain: ResolvedDomainOf<Schema>) => AuthoredRaw<Input, Ast>): SingleQueryDefinition<ResolvedDomainOf<Schema>, Input, RawQuery<Input, Ast> extends SingleQuery<Input, infer Output> ? Output : never>;
-    <Input, Output, Ast extends QueryAST>(project: (domain: ResolvedDomainOf<Schema>) => AuthoredProjected<Input, Output, Ast>): SingleQueryDefinition<ResolvedDomainOf<Schema>, Input, Output>;
-    <Input, Output, Ast extends QueryAST>(project: (domain: ResolvedDomainOf<Schema>) => AuthoredPaginated<Input, Output, Ast>): SingleQueryDefinition<ResolvedDomainOf<Schema>, Input, Output>;
-}
-interface CollectionQueryProjector<Schema extends schema.DomainSchema> {
-    <Class extends AnyResolvedClass>(project: (domain: ResolvedDomainOf<Schema>) => CollectionQuerySpec<Class>): CollectionQueryDefinition<ResolvedDomainOf<Schema>, Class>;
-}
+import type { ResolvedDomainOf } from './definition.js';
+import type { CompositeQueryDefinition, QueryDefinition, RealizedQuery } from './query.js';
 type AuthoredInferredComposite<Input, Composed, Plan extends QueryPlan<unknown>, Output, DomainValue extends Domain> = Omit<ProjectedCompositeQuery<Input, Composed, Output, DomainValue>, 'kind' | 'compose' | 'project'> & {
     compose(builder: QueryComposition<DomainValue>, input: Input): Plan;
     project(value: QueryPlanOutput<Plan>, input: Input): Output;
@@ -38,10 +11,6 @@ interface CompositeQueryProjector<Schema extends schema.DomainSchema> {
     <Input, Output>(project: (domain: ResolvedDomainOf<Schema>) => Omit<RawCompositeQuery<Input, Output, ResolvedDomainOf<Schema>>, 'kind'>): CompositeQueryDefinition<ResolvedDomainOf<Schema>, Input, Output>;
     <Input, Composed, Output, Plan extends QueryPlan<Composed> = QueryPlan<Composed>>(project: (domain: ResolvedDomainOf<Schema>) => AuthoredInferredComposite<Input, Composed, Plan, Output, ResolvedDomainOf<Schema>>): CompositeQueryDefinition<ResolvedDomainOf<Schema>, Input, Output>;
 }
-/** Define one inert single Query recipe 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>;
 /** Define one inert composite Query recipe projected from its exact loaded Domain. */
 export declare function defineCompositeQuery<Schema extends schema.DomainSchema>(): CompositeQueryProjector<Schema>;
 export declare function realizeQuery<DomainValue extends Domain, Input, Output>(query: QueryDefinition<DomainValue, Input, Output>, domain: DomainValue): RealizedQuery<Input, Output>;

package/dist/application/query/define.js

@@ -1,62 +1,13 @@
-import { Query } from '@astrale-os/kernel-core/graph/query';
 import { isDomain } from '@astrale-os/kernel-dsl/v1/domain';
-import { requireUniqueCollectionValues } from './collection/identity.js';
-import { COLLECTION_QUERY_LIMITS } from './collection/limits.js';
-import { realizeCollectionQuery, registerCollectionQuery, } from './collection/metadata.js';
-import { definedValues } from './conformance.js';
-import { queryResult } from './single/index.js';
-const DEFAULT_PAGE_SIZE = 256;
-const MAXIMUM_PAGES = 1_024;
-const projectors = new WeakMap();
+import { definitionBase, isPromiseLike, projectorOf, recipe } from './definition.js';
+import { admitSingle } from './legacy/v6/define.js';
 const realized = new WeakMap();
-/** Define one inert single Query recipe projected from its exact loaded Domain. */
-export function defineQuery() {
-    return ((project) => recipe('query', project));
-}
-/** Define one reusable complete polymorphic Class-extent Query. */
-export function defineCollectionQuery() {
-    return ((project) => {
-        const definition = defineQuery()((domain) => {
-            const specification = realizeCollectionQuery(definition, domain);
-            const selected = specification.class;
-            if (selected.kind === 'node') {
-                return {
-                    id: specification.id,
-                    page: { size: COLLECTION_QUERY_LIMITS.pageSize },
-                    pagination: { maximumPages: COLLECTION_QUERY_LIMITS.maximumPages },
-                    build: () => Query.from({ nodes: [selected] }).select({
-                        kind: 'nodes',
-                        projection: { kind: 'value' },
-                    }),
-                    project: (pages) => definedValues(domain, requireUniqueCollectionValues(queryResult.completeNodeValues(pages, specification.id), `Collection Query ${specification.id}`)),
-                };
-            }
-            return {
-                id: specification.id,
-                page: { size: COLLECTION_QUERY_LIMITS.pageSize },
-                pagination: { maximumPages: COLLECTION_QUERY_LIMITS.maximumPages },
-                build: () => Query.from({ edges: [selected] }).select({
-                    kind: 'edges',
-                    projection: { edge: 'value', source: 'reference', target: 'reference' },
-                }),
-                project: (pages) => definedValues(domain, requireUniqueCollectionValues(Object.freeze(pages.flatMap((page) => queryResult.edgeItems(page, specification.id).map((item) => {
-                    if (item.edge.kind !== 'value') {
-                        throw new TypeError(`Collection Query ${specification.id} must project Edge values.`);
-                    }
-                    return item.edge.value;
-                }))), `Collection Query ${specification.id}`)),
-            };
-        });
-        registerCollectionQuery(definition, project);
-        return definition;
-    });
-}
 /** Define one inert composite Query recipe projected from its exact loaded Domain. */
 export function defineCompositeQuery() {
     return ((project) => recipe('composite-query', project));
 }
 export function realizeQuery(query, domain) {
-    const project = projectors.get(query);
+    const project = projectorOf(query);
     if (project === undefined)
         throw new TypeError('Query must be produced by defineQuery.');
     if (!isDomain(domain))
@@ -76,37 +27,6 @@ export function realizeQuery(query, domain) {
     byDomain.set(domain, admitted);
     return admitted;
 }
-function recipe(kind, project) {
-    if (typeof project !== 'function')
-        throw new TypeError('Query projection must be a function.');
-    const definition = Object.freeze({ kind });
-    projectors.set(definition, project);
-    return definition;
-}
-function admitSingle(definition) {
-    definitionBase(definition, 'build');
-    const page = pageOf(definition.page);
-    const pagination = definition.pagination;
-    if (pagination !== undefined) {
-        if (typeof definition.project !== 'function') {
-            throw new TypeError('Paginated Query requires a project function.');
-        }
-        if (pagination === null ||
-            typeof pagination !== 'object' ||
-            Array.isArray(pagination) ||
-            Reflect.ownKeys(pagination).length !== 1 ||
-            !Object.hasOwn(pagination, 'maximumPages')) {
-            throw new TypeError('Query pagination is invalid.');
-        }
-        const maximumPages = Reflect.get(pagination, 'maximumPages');
-        if (!Number.isSafeInteger(maximumPages) ||
-            maximumPages < 1 ||
-            maximumPages > MAXIMUM_PAGES) {
-            throw new TypeError(`Query pagination must be bounded from 1 through ${MAXIMUM_PAGES}.`);
-        }
-    }
-    return Object.freeze({ ...definition, page, kind: 'single' });
-}
 function admitComposite(definition) {
     definitionBase(definition, 'compose');
     if (Object.hasOwn(definition, 'page') || Object.hasOwn(definition, 'pagination')) {
@@ -114,50 +34,3 @@ function admitComposite(definition) {
     }
     return Object.freeze({ ...definition, kind: 'composite' });
 }
-function definitionBase(definition, operation) {
-    if (definition === null || typeof definition !== 'object' || Array.isArray(definition))
-        invalid();
-    if (typeof definition.id !== 'string' ||
-        definition.id.length === 0 ||
-        definition.id.trim() !== definition.id ||
-        typeof definition[operation] !== 'function') {
-        invalid();
-    }
-    for (const optional of ['prepare', 'project', 'reject']) {
-        if (definition[optional] !== undefined && typeof definition[optional] !== 'function')
-            invalid();
-    }
-    const allowed = new Set([
-        'id',
-        operation,
-        'prepare',
-        'project',
-        'reject',
-        ...(operation === 'build' ? ['page', 'pagination'] : []),
-    ]);
-    if (Reflect.ownKeys(definition).some((key) => typeof key !== 'string' || !allowed.has(key))) {
-        invalid();
-    }
-}
-function pageOf(input) {
-    if (input === undefined)
-        return Object.freeze({ size: DEFAULT_PAGE_SIZE });
-    if (input === null ||
-        typeof input !== 'object' ||
-        Array.isArray(input) ||
-        Reflect.ownKeys(input).length !== 1 ||
-        !Object.hasOwn(input, 'size') ||
-        !Number.isSafeInteger(Reflect.get(input, 'size')) ||
-        Reflect.get(input, 'size') < 1) {
-        throw new TypeError('Query page size must be a positive safe integer.');
-    }
-    return Object.freeze({ size: Reflect.get(input, 'size') });
-}
-function invalid() {
-    throw new TypeError('Query definition is invalid.');
-}
-function isPromiseLike(input) {
-    return (input !== null &&
-        (typeof input === 'object' || typeof input === 'function') &&
-        typeof input.then === 'function');
-}

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

@@ -0,0 +1,12 @@
+import type { Domain, schema } from '../../platform/schema/index.js';
+import type { QueryDefinition } from './query.js';
+/** The private projection of one recipe from its exact loaded Domain. */
+export type QueryProjector = (domain: Domain) => Readonly<Record<string, unknown>>;
+export type ResolvedDomainOf<Schema extends schema.DomainSchema> = Extract<schema.DomainOf<Schema>, Domain>;
+/** One inert recipe of `kind`; its projector is retained privately. */
+export declare function recipe(kind: QueryDefinition['kind'], project: QueryProjector): QueryDefinition;
+/** The projector a recipe was registered with, if it was. */
+export declare function projectorOf(definition: object): QueryProjector | undefined;
+/** The fields every authored recipe shares: `id`, its operation, `prepare`, `project`, `reject`. */
+export declare function definitionBase(definition: Readonly<Record<string, unknown>>, operation: 'build' | 'compose'): void;
+export declare function isPromiseLike(input: unknown): input is PromiseLike<unknown>;

package/dist/application/query/definition.js

@@ -0,0 +1,47 @@
+const projectors = new WeakMap();
+/** One inert recipe of `kind`; its projector is retained privately. */
+export function recipe(kind, project) {
+    if (typeof project !== 'function')
+        throw new TypeError('Query projection must be a function.');
+    const definition = Object.freeze({ kind });
+    projectors.set(definition, project);
+    return definition;
+}
+/** The projector a recipe was registered with, if it was. */
+export function projectorOf(definition) {
+    return projectors.get(definition);
+}
+/** The fields every authored recipe shares: `id`, its operation, `prepare`, `project`, `reject`. */
+export function definitionBase(definition, operation) {
+    if (definition === null || typeof definition !== 'object' || Array.isArray(definition))
+        invalid();
+    if (typeof definition.id !== 'string' ||
+        definition.id.length === 0 ||
+        definition.id.trim() !== definition.id ||
+        typeof definition[operation] !== 'function') {
+        invalid();
+    }
+    for (const optional of ['prepare', 'project', 'reject']) {
+        if (definition[optional] !== undefined && typeof definition[optional] !== 'function')
+            invalid();
+    }
+    const allowed = new Set([
+        'id',
+        operation,
+        'prepare',
+        'project',
+        'reject',
+        ...(operation === 'build' ? ['page', 'pagination'] : []),
+    ]);
+    if (Reflect.ownKeys(definition).some((key) => typeof key !== 'string' || !allowed.has(key))) {
+        invalid();
+    }
+}
+function invalid() {
+    throw new TypeError('Query definition is invalid.');
+}
+export function isPromiseLike(input) {
+    return (input !== null &&
+        (typeof input === 'object' || typeof input === 'function') &&
+        typeof input.then === 'function');
+}

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

@@ -0,0 +1,20 @@
+/**
+ * The bounds a recipe keeps before anything is sent (S11, spec § Recipes: the contract): its
+ * reads, its rows, each verb's bound, and the values of a property's `in`.
+ */
+import type { ReadPlan } from '../handles/plan.js';
+import type { AnyQuery } from '../language/query.js';
+/** Each read of each stage, and each element of an `items.map`. */
+export declare const MAXIMUM_READS = 32;
+/** Across a recipe's nested lists. */
+export declare const MAXIMUM_ROWS = 100000;
+/** A verb's bound: its list, plus one for `all` and `first(n, { more })`, fits a Kernel page. */
+export declare const MAXIMUM_BOUND = 83332;
+/** Values of a property's `in`, until it is index-backed. */
+export declare const MAXIMUM_IN = 16;
+/** Whether a list verb of the read, at its root or in a relation, is bound past a Kernel page. */
+export declare function pastPage(plan: ReadPlan): boolean;
+/** The rows a read may answer, counted as the product of its verbs' bounds. */
+export declare function rowsOf(plan: ReadPlan): number;
+/** The first property `in` past its values, as a pointer into the document. */
+export declare function wideIn(document: AnyQuery): string | undefined;

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

@@ -0,0 +1,86 @@
+/** Each read of each stage, and each element of an `items.map`. */
+export const MAXIMUM_READS = 32;
+/** Across a recipe's nested lists. */
+export const MAXIMUM_ROWS = 100_000;
+/** A verb's bound: its list, plus one for `all` and `first(n, { more })`, fits a Kernel page. */
+export const MAXIMUM_BOUND = 83_332;
+/** Values of a property's `in`, until it is index-backed. */
+export const MAXIMUM_IN = 16;
+/** The rows one verb reads: `get` and `find` 2, `first(n)` n, `page` and `all` max + 1. */
+function verbRows(verb, bound = 0) {
+    switch (verb) {
+        case 'get':
+        case 'find':
+            return 2;
+        case 'first':
+            return 1;
+        case 'firstN':
+            return bound;
+        case 'firstMore':
+        case 'page':
+        case 'all':
+            return bound + 1;
+        default:
+            return 0;
+    }
+}
+/** The rows of one parent's relations, each row counting itself and what it carries. */
+function carried(branches) {
+    return branches.reduce((total, b) => total + (b.empty ? 0 : verbRows(b.verb, b.bound) * (1 + carried(b.branches))), 0);
+}
+/** The rows of a document read from its own limits: a list's `limit`, its Branches'. */
+function documentRows(document) {
+    const list = document.list;
+    if (list === undefined)
+        return 0;
+    const rows = (pattern) => {
+        const branches = (pattern.with ?? []);
+        return branches.reduce((total, b) => total + (b.mode === 'count' ? 0 : (b.limit ?? 0) * (1 + rows(b))), 0);
+    };
+    return (list.limit ?? 0) * (1 + rows(list));
+}
+const LISTS = new Set(['firstN', 'firstMore', 'page', 'all']);
+const pastBound = (verb, bound = 0) => LISTS.has(verb) && bound > MAXIMUM_BOUND;
+const branchPastBound = (branches) => branches.some((b) => pastBound(b.verb, b.bound) || branchPastBound(b.branches ?? []));
+/** Whether a list verb of the read, at its root or in a relation, is bound past a Kernel page. */
+export function pastPage(plan) {
+    const branches = plan.root?.kind === 'nodes' ? plan.root.branches : [];
+    return pastBound(plan.verb, plan.bound) || branchPastBound(branches);
+}
+/** The rows a read may answer, counted as the product of its verbs' bounds. */
+export function rowsOf(plan) {
+    if (plan.empty)
+        return 0;
+    if (plan.verb === 'document')
+        return documentRows(plan.document);
+    const branches = plan.root?.kind === 'nodes' ? plan.root.branches : [];
+    return verbRows(plan.verb, plan.bound) * (1 + carried(branches));
+}
+/** The first property `in` past its values, as a pointer into the document. */
+export function wideIn(document) {
+    const visit = (value, path) => {
+        if (Array.isArray(value)) {
+            for (const [index, entry] of value.entries()) {
+                const found = visit(entry, `${path}/${index}`);
+                if (found !== undefined)
+                    return found;
+            }
+            return undefined;
+        }
+        if (value === null || typeof value !== 'object')
+            return undefined;
+        const record = value;
+        if (record.op === 'in')
+            return record.values.length > MAXIMUM_IN ? path : undefined;
+        // A value written in a condition is data: it is never read as a condition.
+        if (record.op === 'eq' || record.op === 'range' || record.op === 'id')
+            return undefined;
+        for (const [name, entry] of Object.entries(record)) {
+            const found = visit(entry, `${path}/${name.replaceAll('~', '~0').replaceAll('/', '~1')}`);
+            if (found !== undefined)
+                return found;
+        }
+        return undefined;
+    };
+    return visit(document, '');
+}

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

@@ -0,0 +1,25 @@
+import type { ClassRef, Domain } from '../../../platform/schema/index.js';
+import type { Model } from '../handles/model.js';
+import type { ReadPlan } from '../handles/plan.js';
+/** A Class requirement as a build compiles it: an entry of `requirements.capabilities.classes`. */
+export interface DeclaredClass {
+    readonly class: ClassRef;
+    readonly operations: readonly string[];
+}
+/**
+ * The S12 refusal: a `TypeError`, the same for every input and every attempt, so a durable Step
+ * fails at once on it.
+ */
+export declare class UndeclaredCrossing extends TypeError {
+    #private;
+    constructor(recipe: string, message: string);
+    get recipe(): string;
+}
+/** The S12 check of one Domain: its dependencies, and the operations it declares on their Classes. */
+export declare class Crossings {
+    #private;
+    readonly model: Model;
+    constructor(model: Model, domain: Domain, declared: readonly DeclaredClass[]);
+    /** Throw when a relation of the read crosses a foreign Class its Domain does not declare. */
+    check(recipe: string, plan: ReadPlan): void;
+}

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

@@ -0,0 +1,169 @@
+/**
+ * The Classes a recipe's relations cross, checked against what its Domain declares (S12, spec §
+ * Details settled: "When S12 runs"). A relation that crosses a Class of a dependency needs `read`
+ * and `traverse` on it in the Domain's requirements, or the read is a programming error, raised at
+ * lowering before anything is sent, never answered as empty. It reads the document as written,
+ * so an empty list the input gives refuses what any other list does. A requirement on a parent
+ * covers its children, and an abstract Class with concrete children, each covered, is covered:
+ * the check refuses only what no declaration serves.
+ */
+import { Key } from '@astrale-os/kernel-dsl/v1/addressing';
+/** What a relation needs on each foreign Class it crosses. */
+const NEEDED = ['read', 'traverse'];
+/**
+ * The S12 refusal: a `TypeError`, the same for every input and every attempt, so a durable Step
+ * fails at once on it.
+ */
+export class UndeclaredCrossing extends TypeError {
+    #recipe;
+    constructor(recipe, message) {
+        super(message);
+        this.#recipe = recipe;
+    }
+    get recipe() {
+        return this.#recipe;
+    }
+}
+/** The S12 check of one Domain: its dependencies, and the operations it declares on their Classes. */
+export class Crossings {
+    model;
+    /** Each direct dependency's origin, by the alias the Domain gives it. */
+    #dependencies = new Map();
+    /** The operations declared on each Class, by key. */
+    #declared = new Map();
+    /** The concrete Classes of the Domain and its dependencies: those a Node or Edge can be of. */
+    #concrete;
+    constructor(model, domain, declared) {
+        this.model = model;
+        for (const [alias, dependency] of Object.entries(domain.dependencies))
+            this.#dependencies.set(dependency.origin, alias);
+        for (const requirement of declared) {
+            const key = Key.of(requirement.class);
+            const operations = this.#declared.get(key) ?? new Set();
+            requirement.operations.forEach((operation) => operations.add(operation));
+            this.#declared.set(key, operations);
+        }
+        this.#concrete = [domain, ...Object.values(domain.dependencies)]
+            .flatMap((d) => Object.values(d.classes))
+            .filter((c) => !c.abstract);
+    }
+    /** Throw when a relation of the read crosses a foreign Class its Domain does not declare. */
+    check(recipe, plan) {
+        const document = (plan.written ?? plan.document);
+        const root = (document?.list ?? document?.exists ?? document?.count);
+        if (root === undefined)
+            return;
+        const branches = plan.root?.kind === 'nodes' ? plan.root.branches : undefined;
+        this.#where(recipe, root.where, undefined);
+        this.#branches(recipe, root.with, branches, undefined);
+    }
+    #branches(recipe, value, plans, parent) {
+        for (const branch of (value ?? [])) {
+            const plan = plans?.find((p) => p.name === branch.name);
+            const name = plan?.key ?? branch.name;
+            const relation = parent === undefined ? name : `${parent}.${name}`;
+            this.#traversal(recipe, branch, `its relation ${relation}`);
+            this.#branches(recipe, branch.with, plan?.branches, relation);
+        }
+    }
+    /** The traversals a condition holds, at any depth. */
+    #where(recipe, value, at) {
+        const where = value;
+        switch (where?.op) {
+            case 'and':
+            case 'or':
+                for (const operand of where.operands)
+                    this.#where(recipe, operand, at);
+                return;
+            case 'not':
+            case 'source':
+            case 'target':
+                return this.#where(recipe, where.operand, at);
+            case 'exists':
+                return this.#traversal(recipe, where, at === undefined ? 'a condition' : `${at}'s condition`);
+        }
+    }
+    /** The Edge Classes of `via`, the Node Classes they reach, then the traversal's own conditions. */
+    #traversal(recipe, traversal, label) {
+        const via = traversal.via;
+        const direction = traversal.direction;
+        const edges = via.flatMap((key) => this.#known(key));
+        const relation = `${label} (via ${via.join(', ')}, ${direction})`;
+        const reached = this.#narrowed(this.model.reached(edges, direction), traversal.node);
+        for (const c of [...edges, ...reached])
+            this.#require(recipe, relation, c);
+        this.#where(recipe, traversal.edge, label);
+        this.#where(recipe, traversal.node, label);
+    }
+    /**
+     * The reached Classes the node condition keeps. An `is` or `isExactly` conjunct, or an `or` of
+     * them, keeps a reached Class that satisfies a Class an `is` names, and narrows any other to the
+     * named Classes that satisfy it: an `isExactly` keeps its Class alone.
+     */
+    #narrowed(reached, node) {
+        let classes = reached;
+        for (const condition of conjuncts(node)) {
+            const named = namedClasses(condition);
+            if (named === undefined)
+                continue;
+            const is = named.filter((n) => !n.exact).flatMap((n) => this.#known(n.key));
+            const all = named.flatMap((n) => this.#known(n.key));
+            classes = classes.flatMap((c) => is.some((n) => this.model.satisfies(c).has(n.key))
+                ? [c]
+                : all.filter((n) => this.model.satisfies(n).has(c.key)));
+        }
+        return [...new Set(classes)];
+    }
+    #require(recipe, relation, c) {
+        const alias = this.#dependencies.get(c.ref.origin);
+        if (alias === undefined)
+            return;
+        const missing = this.#missing(c);
+        if (missing.length === 0 || (c.abstract && this.#covered(c)))
+            return;
+        throw new UndeclaredCrossing(recipe, `Recipe ${recipe}: ${relation} crosses ${c.key}, a Class of the dependency ${alias}, on ` +
+            `which the Domain declares no ${missing.join(' or ')}. Its requirements need ` +
+            `{ class: ${c.key}, operations: ['read', 'traverse'] } in classes.`);
+    }
+    /** What a Class lacks of `read` and `traverse`, declared on it or on a parent. */
+    #missing(c) {
+        const declared = new Set([...this.model.satisfies(c)].flatMap((key) => [...(this.#declared.get(key) ?? [])]));
+        return NEEDED.filter((operation) => !declared.has(operation));
+    }
+    /** An abstract Class has concrete Classes under it, and the Domain may cross each. */
+    #covered(c) {
+        const children = this.#concrete.filter((k) => this.model.satisfies(k).has(c.key));
+        return children.length > 0 && children.every((k) => this.#served(k));
+    }
+    /** Whether a relation may cross a Class: the Domain's own, or a dependency's it declares. */
+    #served(c) {
+        return !this.#dependencies.has(c.ref.origin) || this.#missing(c).length === 0;
+    }
+    /** The Class a key names, when the Domain can name it: the Kernel refuses any other. */
+    #known(key) {
+        try {
+            return [this.model.classOf(key)];
+        }
+        catch {
+            return [];
+        }
+    }
+}
+/** The Classes an `is` or `isExactly` names, alone or in an `or` of them; else `undefined`. */
+function namedClasses(condition) {
+    if (condition.op === 'is' || condition.op === 'isExactly')
+        return [{ key: condition.class, exact: condition.op === 'isExactly' }];
+    if (condition.op !== 'or')
+        return undefined;
+    const named = condition.operands.map(namedClasses);
+    return named.every((n) => n !== undefined) ? named.flat() : undefined;
+}
+/** The conditions a condition requires all of. */
+function conjuncts(value) {
+    const where = value;
+    if (where === undefined)
+        return [];
+    if (where.op === 'and')
+        return where.operands.flatMap(conjuncts);
+    return [where];
+}

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

@@ -0,0 +1,68 @@
+/**
+ * The one error a recipe's reads raise (spec § Errors): a code, the recipe's id and the details
+ * of that code. A recipe's own business refusals are its declared errors, raised by `output`.
+ */
+import type { NodeId } from '../../../platform/graph/node/index.js';
+import type { EdgeKey } from '../handles/rows.js';
+/** The details of each code. */
+export interface QueryErrorDetails {
+    /** `get` at the root found nothing. */
+    NOT_FOUND: {
+        readonly class: string;
+        readonly target?: string;
+    };
+    /** `get` or `find` met a fact the reader may not read: a Node, or an Edge read at the root. */
+    NOT_READABLE: {
+        readonly class: string;
+        readonly id: NodeId | EdgeKey;
+    };
+    /**
+     * A relation's `get` found none, or a second row came where one is allowed. At the root, `get`
+     * or `find` has no parent, and the relation is its Classes.
+     */
+    INTEGRITY: {
+        readonly relation: string;
+        readonly parent?: NodeId;
+        readonly found: 0 | 2;
+    };
+    /** Past a verb's `max`, the recipe's 100,000 rows or its 32 reads. */
+    TOO_MANY: {
+        readonly limit: 'max' | 'rows' | 'reads';
+        readonly bound: number;
+    };
+    /** The Kernel refused the read. */
+    REFUSED: {
+        readonly kernelCode: string;
+        readonly retryable: boolean;
+    };
+    /** The Kernel refused the query the recipe built, before reading anything. */
+    INPUT_INVALID: {
+        readonly kernelCode?: string;
+        readonly phase?: string;
+        readonly path?: string;
+        readonly limit?: 'in';
+    };
+    /** The Host's Registry no longer matches what the code was built against. */
+    OUTDATED: {
+        readonly kernelCode: 'QUERY_EXPECTATION_MISMATCH';
+    };
+    /** The Host does not serve v7, or does not give each row's Class. */
+    UNSUPPORTED: {
+        readonly feature: 'v7' | 'classes';
+    };
+}
+export type QueryErrorCode = keyof QueryErrorDetails;
+export declare class QueryError<C extends QueryErrorCode = QueryErrorCode> extends Error {
+    readonly code: C;
+    /** The recipe's id. */
+    readonly recipe: string;
+    readonly details: QueryErrorDetails[C];
+    readonly name = "QueryError";
+    constructor(code: C, 
+    /** The recipe's id. */
+    recipe: string, details: QueryErrorDetails[C], options?: ErrorOptions & {
+        readonly reason?: string;
+    });
+}
+/** Whether `error` is a `QueryError`, of `code` if given. */
+export declare function isQueryError<C extends QueryErrorCode = QueryErrorCode>(error: unknown, code?: C): error is QueryError<C>;