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

package/dist/application/mutation/failure.js

@@ -10,7 +10,11 @@ export function stateTransitionFailure(from, event) {
     localStateTransitionFailures.add(failure);
     return failure;
 }
-export function mutationFailure(input) {
+/**
+ * The Mutation refusal `input` carries, if any. `nameAt` names the precondition at an index of
+ * the built Mutation's `preconditions`, the index a precondition refusal points at.
+ */
+export function mutationFailure(input, nameAt) {
     if (!(input instanceof Error))
         return undefined;
     const reason = mutationReason(input);
@@ -30,15 +34,20 @@ export function mutationFailure(input) {
         return input;
     }
     const rule = code === 'MUTATION_POST_STATE_INVALID' ? reason.rule : undefined;
+    const precondition = code === 'MUTATION_PRECONDITION_FAILED' && reason.precondition !== undefined
+        ? nameAt?.(reason.precondition)
+        : undefined;
     return Object.assign(new Error(input.message, { cause: input }), {
         code,
         outcomeKnown: explicit !== false && !UNKNOWN_OUTCOME_CODES.has(code),
         ...(rule === undefined ? {} : { rule }),
+        ...(precondition === undefined ? {} : { precondition }),
     });
 }
 /**
  * The Mutation refusal an error carries, on itself, as its Kernel reason, or as its protocol data:
- * its code and, from the same carrier's details, the post-state rule it names.
+ * its code and, from the same carrier's details, the post-state rule it names and the index of the
+ * precondition it points at.
  */
 function mutationReason(input) {
     const value = input;
@@ -48,14 +57,20 @@ function mutationReason(input) {
         const code = typeof carrier === 'string' ? carrier : field(carrier, 'code');
         if (typeof code !== 'string' || !code.startsWith('MUTATION_'))
             continue;
-        const rule = field(field(carrier, 'details'), 'rule');
+        const details = field(carrier, 'details');
+        const rule = field(details, 'rule');
+        const precondition = field(details, 'precondition');
         return {
             code: code,
             ...(typeof rule === 'string' ? { rule } : {}),
+            ...(isIndex(precondition) ? { precondition } : {}),
         };
     }
     return undefined;
 }
+function isIndex(input) {
+    return typeof input === 'number' && Number.isSafeInteger(input) && input >= 0;
+}
 function field(input, key) {
     return input !== null && typeof input === 'object' && !Array.isArray(input)
         ? Reflect.get(input, key)

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

@@ -1,8 +1,12 @@
 export { defineMutation } from './define.js';
 export { executeMutation, type MutationClient, type MutationExecutor } from './execution/index.js';
 export type { MutationFailure } from './failure.js';
-export type { Mutation, MutationDefinition, MutationInputOf, MutationOutputOf } from './mutation.js';
-export type { CreatedNode, EdgeSelector, ExistingEndpoint, MutationEndpoint, QueryPrecondition, RichMutationBuilder, RichPropertyConditions, RichPropertyDelta, RichPropertyInput, RichPropertyName, } from './authoring/index.js';
-/** Canonical low-level Mutation documents remain available as the explicit escape hatch. */
-export * from '@astrale-os/kernel-core/graph/mutate';
+export type { Mutation, MutationDefinition, MutationInputOf, MutationOutputOf, MutationRecipe, MutationRecipeDefinitions, } from './mutation.js';
+export type { ClosureMutationBuilder, CountBounds, CreatedNode, EdgeSelector, ExistingEndpoint, GuardIdentity, GuardRange, MutationEndpoint, PreconditionOptions, QueryPrecondition, RecipeMutationBuilder, RichMutationBuilder, RichPropertyConditions, RichPropertyDelta, RichPropertyInput, RichPropertyName, } from './authoring/index.js';
+/**
+ * Canonical low-level Mutation documents remain available as the explicit escape hatch, listed one
+ * by one as the SDK has exported them, so a newer Kernel's Mutation internals never reach it.
+ */
+export { MutationAST, MutationASTDecodeError, MutationResult, MutationResultDecodeError, } from '@astrale-os/kernel-core/graph/mutate';
+export type { EdgeCreateOperation, EdgeDeleteOperation, EdgeUpdateOperation, MutationBuilder, MutationEdgeSelector, MutationInput, MutationInputEdgeSelector, MutationInputEndpoint, MutationInputOperation, MutationInputPrecondition, MutationOperation, MutationPrecondition, MutationPropertyConditions, MutationPropertyConditionsInput, MutationProps, MutationPropsInput, MutationQueryPrecondition, MutationQueryPreconditionInput, MutationStructuralLimits, NodeCreateOperation, NodeDeleteOperation, NodeUpdateOperation, QueryExpectedSelection, } from '@astrale-os/kernel-core/graph/mutate';
 export type { LocalAlias } from '../../platform/graph/alias.js';

package/dist/application/mutation/index.js

@@ -1,4 +1,7 @@
 export { defineMutation } from './define.js';
 export { executeMutation } from './execution/index.js';
-/** Canonical low-level Mutation documents remain available as the explicit escape hatch. */
-export * from '@astrale-os/kernel-core/graph/mutate';
+/**
+ * Canonical low-level Mutation documents remain available as the explicit escape hatch, listed one
+ * by one as the SDK has exported them, so a newer Kernel's Mutation internals never reach it.
+ */
+export { MutationAST, MutationASTDecodeError, MutationResult, MutationResultDecodeError, } from '@astrale-os/kernel-core/graph/mutate';

package/dist/application/mutation/legacy/v6/builder.d.ts

@@ -0,0 +1,84 @@
+import type { EdgeSlug } from '@astrale-os/kernel-core/graph/edge';
+import type { QueryEdgeAST, QueryNodeAST } from '@astrale-os/kernel-core/graph/query';
+import type { ResolvedClass } from '@astrale-os/kernel-dsl/v1';
+import type { CreatedNode, ExistingEndpoint, MutationEndpoint } from '../../authoring/endpoint.js';
+import type { CountBounds, GuardIdentity, GuardRange, PreconditionOptions } from '../../authoring/guard.js';
+import type { RichPropertyConditions, RichPropertyDelta, RichPropertyInput } from '../../authoring/properties.js';
+import type { EventOfTopology, StateOfTopology, StatePropertyName, StatePropertyTopology, StateTransitionInput } from '../../authoring/transition.js';
+import type { QueryPrecondition } from './precondition.js';
+/**
+ * The builder of the closure form (`defineMutation<Schema>()((domain) => …)`), deprecated: each
+ * verb names its Class as resolved, `domain.classes.<Class>`. Each precondition verb (`expect.*`)
+ * takes `{ name }` last: a refusal of the Mutation because that precondition fails carries the
+ * name as `failure.precondition`. A name is unique in its Mutation.
+ */
+export interface ClosureMutationBuilder {
+    readonly expect: {
+        /** The Node exists, of this Class, and its Properties meet `props`. */
+        node<Class extends ResolvedClass<'node'>>(input: {
+            readonly node: ExistingEndpoint;
+            readonly class: Class;
+            readonly props?: RichPropertyConditions<Class>;
+        }, options?: PreconditionOptions): ClosureMutationBuilder;
+        /** The Edge exists, its slug is `slug`, and its Properties meet `props`. */
+        edge<Class extends ResolvedClass<'edge'>>(input: EdgeSelector<Class> & {
+            readonly slug?: EdgeSlug | null;
+            readonly props?: RichPropertyConditions<Class>;
+        }, options?: PreconditionOptions): ClosureMutationBuilder;
+        /**
+         * A guard (Mutation v4): no root of the range matches. It takes a range built from the handles
+         * `build` receives, `d.<Class>.where(…)`, or a canonical v7 Query.
+         */
+        none<S, K extends string>(range: GuardRange<S, K>, options?: PreconditionOptions): ClosureMutationBuilder;
+        /** A guard (Mutation v4): a root of the range matches. */
+        exists<S, K extends string>(range: GuardRange<S, K>, options?: PreconditionOptions): ClosureMutationBuilder;
+        /**
+         * A guard (Mutation v4): the number of the range's roots is `bounds`, or lies within
+         * `{ atLeast?, atMost? }`, bounded at least once.
+         */
+        count<S, K extends string>(range: GuardRange<S, K>, bounds: CountBounds, options?: PreconditionOptions): ClosureMutationBuilder;
+        /**
+         * A guard (Mutation v4): the range's roots, in its `orderBy`, are exactly these identities, in
+         * the order a read of them returned them: a `NodeId` per Node, an `EdgeKey` per Edge.
+         */
+        unchanged<S, K extends string>(range: GuardRange<S, K>, ids: readonly GuardIdentity[], options?: PreconditionOptions): ClosureMutationBuilder;
+        /**
+         * @deprecated Query V6 precondition (Mutation v3): write a guard on a range,
+         * `expect.unchanged(range, ids)`. A Mutation holds guards or V6 Query preconditions,
+         * never both.
+         */
+        query<Query extends QueryNodeAST | QueryEdgeAST>(input: QueryPrecondition<Query>): ClosureMutationBuilder;
+    };
+    createNode<Class extends ResolvedClass<'node'>>(input: {
+        readonly as: string;
+        readonly class: Class;
+        readonly props?: RichPropertyInput<Class>;
+    }): CreatedNode<Class>;
+    updateNode<Class extends ResolvedClass<'node'>>(input: {
+        readonly node: ExistingEndpoint;
+        readonly class: Class;
+        readonly props: RichPropertyDelta<Class>;
+    }): this;
+    transition<Class extends ResolvedClass<'node'>, Property extends StatePropertyName<Class>, From extends StateOfTopology<StatePropertyTopology<Class, Property>>, Event extends EventOfTopology<StatePropertyTopology<Class, Property>, From>>(input: StateTransitionInput<Class, Property, From, Event>): this;
+    deleteNode<Class extends ResolvedClass<'node'>>(input: {
+        readonly node: ExistingEndpoint;
+        readonly class: Class;
+    }): this;
+    createEdge<Class extends ResolvedClass<'edge'>>(input: {
+        readonly class: Class;
+        readonly source: MutationEndpoint;
+        readonly target: MutationEndpoint;
+        readonly slug?: EdgeSlug;
+        readonly props?: RichPropertyInput<Class>;
+    }): this;
+    updateEdge<Class extends ResolvedClass<'edge'>>(input: EdgeSelector<Class> & {
+        readonly slug?: EdgeSlug | null;
+        readonly props?: RichPropertyDelta<Class>;
+    }): this;
+    deleteEdge<Class extends ResolvedClass<'edge'>>(input: EdgeSelector<Class>): this;
+}
+export interface EdgeSelector<Class extends ResolvedClass<'edge'>> {
+    readonly source: ExistingEndpoint;
+    readonly target: ExistingEndpoint;
+    readonly class: Class;
+}

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

@@ -0,0 +1,18 @@
+import type { MutationResult } from '@astrale-os/kernel-core/graph/mutate';
+import type { Domain, schema } from '../../../../platform/schema/index.js';
+import type { Handles } from '../../../query/handles/handles.js';
+import type { Mutation, MutationDefinition } from './mutation.js';
+type ResolvedDomainOf<Schema extends schema.DomainSchema> = Extract<schema.DomainOf<Schema>, Domain>;
+type AuthoringDomainOf<Schema extends schema.DomainSchema> = ResolvedDomainOf<Schema>;
+export interface MutationProjector<Schema extends schema.DomainSchema> {
+    /**
+     * @deprecated The closure form: define the Mutation as a recipe,
+     * `defineMutation<Schema>()(id, { build(input, d, mutation), output?, reject?, errors? })`. A
+     * Mutation of this form called without `as` writes as the executor.
+     */
+    <Input, Output = MutationResult>(project: (domain: AuthoringDomainOf<Schema>) => MutationDefinition<Input, Output, Handles<Schema>>): Mutation<ResolvedDomainOf<Schema>, Input, Output>;
+}
+/** Define one inert Mutation of the closure form, projected from its exact loaded Domain. */
+export declare function defineMutation<Schema extends schema.DomainSchema>(): MutationProjector<Schema>;
+export declare function realizeMutation<DomainValue extends Domain, Input, Output>(mutation: Mutation<DomainValue, Input, Output>, domain: DomainValue): MutationDefinition<Input, Output>;
+export {};

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

@@ -0,0 +1,56 @@
+import { isDomain } from '@astrale-os/kernel-dsl/v1/domain';
+const projectors = new WeakMap();
+const realized = new WeakMap();
+/** Define one inert Mutation of the closure form, projected from its exact loaded Domain. */
+export function defineMutation() {
+    return ((project) => {
+        if (typeof project !== 'function')
+            throw new TypeError('Mutation projection must be a function.');
+        const mutation = Object.freeze({ kind: 'mutation' });
+        projectors.set(mutation, project);
+        return mutation;
+    });
+}
+export function realizeMutation(mutation, domain) {
+    const project = projectors.get(mutation);
+    if (project === undefined)
+        throw new TypeError('Mutation must be produced by defineMutation.');
+    if (!isDomain(domain))
+        throw new TypeError('Mutation projection requires an admitted Domain.');
+    let byDomain = realized.get(mutation);
+    const cached = byDomain?.get(domain);
+    if (cached !== undefined)
+        return cached;
+    const authored = project(domain);
+    if (isPromiseLike(authored))
+        throw new TypeError('Mutation projection must be synchronous.');
+    const admitted = admitMutation(authored);
+    if (byDomain === undefined) {
+        byDomain = new WeakMap();
+        realized.set(mutation, byDomain);
+    }
+    byDomain.set(domain, admitted);
+    return admitted;
+}
+function admitMutation(definition) {
+    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.build !== 'function' ||
+        (definition.project !== undefined && typeof definition.project !== 'function') ||
+        (definition.reject !== undefined && typeof definition.reject !== 'function') ||
+        Reflect.ownKeys(definition).some((key) => key !== 'id' && key !== 'build' && key !== 'project' && key !== 'reject')) {
+        invalid();
+    }
+    return Object.freeze({ ...definition });
+}
+function invalid() {
+    throw new TypeError('Mutation definition is invalid.');
+}
+function isPromiseLike(input) {
+    return (input !== null &&
+        (typeof input === 'object' || typeof input === 'function') &&
+        typeof input.then === 'function');
+}

package/dist/application/mutation/legacy/v6/mutation.d.ts

@@ -0,0 +1,28 @@
+import type { MutationResult } from '@astrale-os/kernel-core/graph/mutate';
+import type { Domain } from '../../../../platform/schema/index.js';
+import type { MutationFailure } from '../../failure.js';
+import type { ClosureMutationBuilder } from './builder.js';
+declare const MUTATION_DOMAIN: unique symbol;
+declare const MUTATION_INPUT: unique symbol;
+declare const MUTATION_OUTPUT: unique symbol;
+/**
+ * A Mutation of the closure form, deprecated: inert and Domain-bound. Its projector is retained
+ * privately by the SDK.
+ */
+export interface Mutation<DomainValue extends Domain = Domain, Input = unknown, Output = MutationResult> {
+    readonly kind: 'mutation';
+    readonly [MUTATION_DOMAIN]: (domain: DomainValue) => DomainValue;
+    readonly [MUTATION_INPUT]?: Input;
+    readonly [MUTATION_OUTPUT]?: Output;
+}
+/**
+ * Canonical admitted operation produced by realizing one Mutation of the closure form. `build`
+ * receives the handles `D` a recipe's `build` does, for the ranges its guards take.
+ */
+export interface MutationDefinition<Input, Output = MutationResult, D = unknown> {
+    readonly id: string;
+    build(input: Input, mutation: ClosureMutationBuilder, d: D): undefined;
+    project?(result: MutationResult, input: NoInfer<Input>): Output;
+    reject?(failure: MutationFailure): Output;
+}
+export {};

package/dist/application/mutation/legacy/v6/mutation.js

@@ -0,0 +1 @@
+export {};

package/dist/application/mutation/{authoring → legacy/v6}/precondition.d.ts

@@ -1,5 +1,9 @@
 import type { MutationBuilder } from '@astrale-os/kernel-core/graph/mutate';
 import type { QueryEdgeAST, QueryNodeAST, QueryResultFor, QuerySelectionFor } from '@astrale-os/kernel-core/graph/query';
+/**
+ * @deprecated Query V6 precondition (Mutation v3): write a guard on a Query v7,
+ * `expect.unchanged(query, identities)`, `expect.none`, `expect.exists` or `expect.count`.
+ */
 export interface QueryPrecondition<Query extends QueryNodeAST | QueryEdgeAST> {
     readonly query: Query;
     readonly equals: QuerySelectionFor<QueryResultFor<Query>>;

package/dist/application/mutation/mutation.d.ts

@@ -1,24 +1,35 @@
 import type { MutationResult } from '@astrale-os/kernel-core/graph/mutate';
-import type { Domain } from '../../platform/schema/index.js';
-import type { RichMutationBuilder } from './authoring/index.js';
+import type { Handles } from '../query/handles/handles.js';
+import type { Errors, OutputContext } from '../query/recipe/recipe.js';
+import type { RecipeMutationBuilder } from './authoring/builder.js';
 import type { MutationFailure } from './failure.js';
-declare const MUTATION_DOMAIN: unique symbol;
-declare const MUTATION_INPUT: unique symbol;
-declare const MUTATION_OUTPUT: unique symbol;
-/** Inert Domain-bound Mutation recipe. Its projector is retained privately by the SDK. */
-export interface Mutation<DomainValue extends Domain = Domain, Input = unknown, Output = MutationResult> {
+import type { Mutation, MutationDefinition } from './legacy/v6/mutation.js';
+export type { Mutation, MutationDefinition } from './legacy/v6/mutation.js';
+/**
+ * A Mutation of the recipe form (D31): inert, its id and the errors its `reject` may raise are
+ * public, and what it writes is kept for the runtime. A call names its authority,
+ * `mutate(recipe, input, { as: 'executor' | 'caller' })`.
+ */
+export interface MutationRecipe<Id extends string = string, Input = unknown, Output = unknown, E extends Errors = Errors> {
     readonly kind: 'mutation';
-    readonly [MUTATION_DOMAIN]: (domain: DomainValue) => DomainValue;
-    readonly [MUTATION_INPUT]?: Input;
-    readonly [MUTATION_OUTPUT]?: Output;
+    readonly id: Id;
+    readonly errors: E;
+    readonly '~input'?: Input;
+    readonly '~output'?: Output;
 }
-/** Canonical admitted operation produced by realizing one Mutation recipe. */
-export interface MutationDefinition<Input, Output = MutationResult> {
-    readonly id: string;
-    build(input: Input, mutation: RichMutationBuilder): undefined;
-    project?(result: MutationResult, input: NoInfer<Input>): Output;
-    reject?(failure: MutationFailure): Output;
+/** `defineMutation<Schema>()`'s recipe form: a string id first. */
+export interface MutationRecipeDefinitions<S> {
+    /**
+     * `build` writes the Mutation with the builder, naming each Class by its handle, `d.<Class>`;
+     * `output` maps the committed result, `reject` an expected refusal, and may raise a declared
+     * error through `context.error`, which a Function that calls the Mutation re-declares.
+     */
+    <const Id extends string, Input, Output = MutationResult, E extends Errors = {}>(id: Id, spec: {
+        readonly build: (input: Input, d: Handles<S>, mutation: RecipeMutationBuilder<S>) => undefined;
+        readonly output?: (result: MutationResult, input: Input) => Output;
+        readonly reject?: (failure: MutationFailure, input: Input, context: OutputContext<S, E>) => NoInfer<Output>;
+        readonly errors?: E;
+    }): MutationRecipe<Id, Input, Output, E>;
 }
-export type MutationInputOf<Value> = Value extends Mutation<infer _Domain, infer Input, infer _Output> ? Input : Value extends MutationDefinition<infer Input, infer _Output> ? Input : never;
-export type MutationOutputOf<Value> = Value extends Mutation<infer _Domain, infer _Input, infer Output> ? Output : Value extends MutationDefinition<infer _Input, infer Output> ? Output : never;
-export {};
+export type MutationInputOf<Value> = Value extends MutationRecipe<string, infer Input, infer _Output, Errors> ? Input : Value extends Mutation<infer _Domain, infer Input, infer _Output> ? Input : Value extends MutationDefinition<infer Input, infer _Output> ? Input : never;
+export type MutationOutputOf<Value> = Value extends MutationRecipe<string, infer _Input, infer Output, Errors> ? Output : Value extends Mutation<infer _Domain, infer _Input, infer Output> ? Output : Value extends MutationDefinition<infer _Input, infer Output> ? Output : never;

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

@@ -0,0 +1,117 @@
+/**
+ * What a v7 Query answers (page "Fondations Query v7", § Résultats), typed by its Query: the
+ * Kernel's answer as it arrives, never reshaped. A list answers a tree of references (its Page,
+ * each item's Branches) and one table of the facts it renders as values; an `exists` a boolean;
+ * a `count` a bounded number.
+ *
+ * The types read the Query's own JSON type: the Branch names, their modes and their nesting give
+ * the shape of every item; the Domain gives the type of every value by its Property key. A fact
+ * carries no Class, so a value is typed by its key alone; a Node item carries its Class (K-C),
+ * which a Kernel before K-C leaves out.
+ */
+import type { EdgeKey } from '../../../platform/graph/edge/index.js';
+import type { NodeId } from '../../../platform/graph/node/index.js';
+import type { QueryPropertyKey, QueryPropertyValues, QueryRendering } from '../language/query.js';
+/** On request (W8): the roots the caller's view cannot decide, up to the fold's bound. */
+export interface QueryUndecided {
+    readonly count: number;
+    readonly more: boolean;
+}
+/** One Page of a list: the exact prefix of its order, and the cursor that continues it (W3). */
+export type QueryPageOf<Item> = {
+    readonly items: readonly Item[];
+    readonly undecided?: QueryUndecided;
+} & ({
+    readonly complete: true;
+} | {
+    readonly complete: false;
+    readonly cursor: string;
+});
+/** Bounded so a Query typed only by its constraint still resolves: 8 nested lists. */
+type Depth = readonly unknown[];
+type Deeper<D extends Depth> = readonly [...D, 0];
+type Branches<W> = W extends readonly unknown[] ? W[number] : never;
+/** The answer of one Branch: a `count`, or the Page of its list. */
+export type QueryBranchAnswer<B, D extends Depth = []> = B extends {
+    readonly mode: 'count';
+} ? {
+    readonly count: number;
+    readonly more: boolean;
+    readonly undecided?: QueryUndecided;
+} : QueryPageOf<QueryBranchItem<B, D>>;
+/** The Branches of an item, by name. */
+export type QueryBranchesOf<W, D extends Depth = []> = D['length'] extends 8 ? {} : {
+    readonly [B in Branches<W> as B extends {
+        readonly name: infer N extends string;
+    } ? N : never]: QueryBranchAnswer<B, Deeper<D>>;
+};
+/** One item of a Branch list: the Node it reached, the Edge when the Branch selects it. */
+export type QueryBranchItem<B, D extends Depth = []> = {
+    readonly fact: NodeId;
+    readonly class?: string;
+    readonly branches: QueryBranchesOf<B extends {
+        readonly with?: infer W;
+    } ? W : never, D>;
+} & (B extends {
+    readonly selectEdge: QueryRendering;
+} ? {
+    readonly edge: EdgeKey;
+} : {
+    readonly edge?: never;
+});
+/** One item of the root list: a Node with its Branches, or an Edge with its rendered ends. */
+export type QueryRootItem<R> = R extends {
+    readonly nodes: unknown;
+} ? {
+    readonly fact: NodeId;
+    readonly class?: string;
+    readonly branches: QueryBranchesOf<R extends {
+        readonly with?: infer W;
+    } ? W : never>;
+} : {
+    readonly fact: EdgeKey;
+    readonly source?: {
+        readonly fact: NodeId;
+        readonly class?: string;
+        readonly branches: {};
+    };
+    readonly target?: {
+        readonly fact: NodeId;
+        readonly class?: string;
+        readonly branches: {};
+    };
+    readonly branches: {};
+};
+/** One fact a list renders as values: its readable values and the keys it withholds (R9). */
+export interface QueryFact<Source> {
+    readonly fact: NodeId | EdgeKey;
+    /** By Property key; a key the Domain does not define may appear (a newer Schema). */
+    readonly values: QueryPropertyValues<Source>;
+    readonly withheld: readonly QueryPropertyKey<Source>[];
+}
+/** The answer of a `list`: its Page, the facts it renders, the revision it read (W6). */
+export interface QueryListAnswer<Source, Q> {
+    readonly list: QueryPageOf<QueryRootItem<Q extends {
+        readonly list: infer R;
+    } ? R : never>>;
+    readonly facts: readonly QueryFact<Source>[];
+    readonly revision: string;
+    /** A continuation crossed a revision: its Page reads a later snapshot than its first. */
+    readonly revised?: true;
+}
+export interface QueryExistsAnswer {
+    readonly exists: boolean;
+    readonly undecided?: boolean;
+}
+export interface QueryCountAnswer {
+    readonly count: number;
+    readonly more: boolean;
+    readonly undecided?: QueryUndecided;
+}
+/** What a Query answers, by its family (the name of its root fold). */
+export type QueryAnswerOf<Source, Q> = Q extends {
+    readonly list: unknown;
+} ? QueryListAnswer<Source, Q> : Q extends {
+    readonly exists: unknown;
+} ? QueryExistsAnswer : QueryCountAnswer;
+export {};

package/dist/application/query/answer/answer.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,4 @@
+import type { Domain } from '../../../platform/schema/index.js';
+import type { QueryListAnswer } from './answer.js';
+/** Throw `QueryValueMismatchError` for the first value that does not match its Property. */
+export declare function requireAnswerConformance(domain: Domain, answer: QueryListAnswer<unknown, unknown>): void;

package/dist/application/query/answer/conformance.js

@@ -0,0 +1,27 @@
+import { definedClass } from '@astrale-os/kernel-client/graph';
+import { QueryValueMismatchError } from '../failure.js';
+import { factKey } from './facts.js';
+const PROPERTY = '.property.';
+/** The Property a key names in `domain`, or `undefined` when `domain` does not define it. */
+function propertyOf(domain, key) {
+    const at = key.lastIndexOf(PROPERTY);
+    if (at <= 0)
+        return undefined;
+    const owner = definedClass(domain, key.slice(0, at));
+    return owner?.properties.get(key);
+}
+/** Throw `QueryValueMismatchError` for the first value that does not match its Property. */
+export function requireAnswerConformance(domain, answer) {
+    for (const fact of answer.facts) {
+        const values = fact.values;
+        for (const key of Object.keys(values)) {
+            const property = propertyOf(domain, key);
+            if (property === undefined)
+                continue;
+            const [diagnostic] = property.validate(values[key]);
+            if (diagnostic !== undefined) {
+                throw new QueryValueMismatchError(`The value of ${key} on ${factKey(fact.fact)} does not match its Property in this Domain: ${diagnostic.message}`);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,17 @@
+/**
+ * The facts table of a list answer, by identity: one index per answer, and the Pages of a root
+ * list joined into one complete answer.
+ */
+import type { QueryFact, QueryListAnswer } from './answer.js';
+type FactId = QueryFact<unknown>['fact'];
+/** The text that names a fact: a NodeId as itself, an EdgeKey by its fields in key order. */
+export declare function factKey(fact: FactId): string;
+/** The facts of a list answer by identity, indexed once per answer. */
+export declare function factsOf(answer: QueryListAnswer<unknown, unknown>): ReadonlyMap<string, QueryFact<unknown>>;
+/**
+ * The Pages of one root list, joined: their items in order, their facts by identity (a later
+ * Page's row wins: it was read at a later revision), the last Page's revision, `revised` when a
+ * continuation crossed a revision. The last Page is complete; Branch lists stay as cut.
+ */
+export declare function joinPages<A extends QueryListAnswer<unknown, unknown>>(pages: readonly [A, ...A[]]): A;
+export {};

package/dist/application/query/answer/facts.js

@@ -0,0 +1,57 @@
+/** The text that names a fact: a NodeId as itself, an EdgeKey by its fields in key order. */
+export function factKey(fact) {
+    if (typeof fact === 'string')
+        return fact;
+    const fields = fact;
+    return JSON.stringify(Object.keys(fields)
+        .sort()
+        .map((name) => [name, fields[name]]));
+}
+const indexes = new WeakMap();
+/** The facts of a list answer by identity, indexed once per answer. */
+export function factsOf(answer) {
+    const known = indexes.get(answer);
+    if (known !== undefined)
+        return known;
+    const index = new Map();
+    for (const fact of answer.facts)
+        index.set(factKey(fact.fact), fact);
+    indexes.set(answer, index);
+    return index;
+}
+function undecidedOf(pages) {
+    const reported = pages.flatMap((page) => page.list.undecided === undefined ? [] : [page.list.undecided]);
+    if (reported.length === 0)
+        return undefined;
+    return Object.freeze({
+        count: reported.reduce((total, undecided) => total + undecided.count, 0),
+        more: reported.some((undecided) => undecided.more),
+    });
+}
+/**
+ * The Pages of one root list, joined: their items in order, their facts by identity (a later
+ * Page's row wins: it was read at a later revision), the last Page's revision, `revised` when a
+ * continuation crossed a revision. The last Page is complete; Branch lists stay as cut.
+ */
+export function joinPages(pages) {
+    if (pages.length === 1)
+        return pages[0];
+    const last = pages[pages.length - 1];
+    const facts = new Map();
+    for (const page of pages)
+        for (const fact of page.facts)
+            facts.set(factKey(fact.fact), fact);
+    const undecided = undecidedOf(pages);
+    const revised = pages.some((page) => page.revised === true) ||
+        pages.some((page) => page.revision !== pages[0].revision);
+    return Object.freeze({
+        list: Object.freeze({
+            items: Object.freeze(pages.flatMap((page) => page.list.items)),
+            complete: true,
+            ...(undecided === undefined ? {} : { undecided }),
+        }),
+        facts: Object.freeze([...facts.values()]),
+        revision: last.revision,
+        ...(revised ? { revised: true } : {}),
+    });
+}

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

@@ -1,5 +1,5 @@
 import type { Domain } from '../../../platform/schema/index.js';
-import type { CollectionDefinitionRecord } from '../collection/union.js';
+import type { CollectionDefinitionRecord } from '../legacy/v6/collection/union.js';
 import type { SingleQueryDefinition } from '../query.js';
 import type { QueryComposition, QueryPlan } from './query.js';
 declare const PLAN: unique symbol;

package/dist/application/query/composite/builder.js

@@ -1,4 +1,4 @@
-import { admitCollectionDefinitions } from '../collection/union.js';
+import { admitCollectionDefinitions } from '../legacy/v6/collection/union.js';
 import { QueryCompositionError } from './errors.js';
 const PLAN = Symbol('astrale.sdk.query.plan');
 const REFERENCE = Symbol('astrale.sdk.query.reference');

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

@@ -1,5 +1,5 @@
 import type { Domain } from '../../../platform/schema/index.js';
-import type { CollectionDefinitionRecord } from '../collection/union.js';
+import type { CollectionDefinitionRecord } from '../legacy/v6/collection/union.js';
 import type { SingleQueryDefinition } from '../query.js';
 import type { InternalPlan } from './builder.js';
 export declare const QUERY_COMPOSITION_LIMITS: Readonly<{

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

@@ -1,4 +1,4 @@
-import { COLLECTION_QUERY_LIMITS } from '../collection/limits.js';
+import { COLLECTION_QUERY_LIMITS } from '../legacy/v6/collection/limits.js';
 import { inspectPlan, referencesIn, resolveInput } from './builder.js';
 import { QueryCompositionError } from './errors.js';
 export const QUERY_COMPOSITION_LIMITS = Object.freeze({

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

@@ -1,7 +1,6 @@
 import type { ResolvedClass } from '@astrale-os/kernel-dsl/v1';
 import type { Domain } from '../../../platform/schema/index.js';
-import type { CollectionQueryDefinition, QueryOutputOf, SingleQueryDefinition } from '../query.js';
-import type { QueryLifecycle } from '../single/index.js';
+import type { CollectionQueryDefinition, QueryLifecycle, QueryOutputOf, SingleQueryDefinition } from '../query.js';
 declare const QUERY_PLAN_OUTPUT: unique symbol;
 declare const QUERY_PLAN_VALUE: unique symbol;
 export type QueryPlanValue<Value> = Readonly<{