@astrale-os/sdk 0.5.0-beta.28 → 0.5.0-beta.29

package/dist/application/action/context.d.ts

@@ -29,7 +29,7 @@ export interface ActionExecution {
         body(): Uint8Array;
     };
 }
-type AuthorityOf<Callable> = Callable extends {
+type AuthorityOf<Callable, DomainValue extends Domain> = Callable extends {
     readonly auth: 'anonymous';
 } ? {
     readonly caller: AnonymousCaller;
@@ -39,13 +39,13 @@ type AuthorityOf<Callable> = Callable extends {
 } | {
     readonly caller: AuthenticatedCaller;
     readonly client: BoundClientSession;
-    readonly query: QueryExecutor;
-    readonly mutate: MutationExecutor;
+    readonly query: QueryExecutor<DomainValue>;
+    readonly mutate: MutationExecutor<DomainValue>;
 } : {
     readonly caller: AuthenticatedCaller;
     readonly client: BoundClientSession;
-    readonly query: QueryExecutor;
-    readonly mutate: MutationExecutor;
+    readonly query: QueryExecutor<DomainValue>;
+    readonly mutate: MutationExecutor<DomainValue>;
 };
 type SelfOf<Callable> = Callable extends ResolvedMethod<unknown, unknown, false> ? {
     readonly self: NodeId;
@@ -59,5 +59,5 @@ export type ActionContext<Callable extends ResolvedCallable, DomainValue extends
     readonly input: CallableInputOf<Callable>;
     readonly integrations: IntegrationClients<Definitions>;
     readonly execution: ActionExecution;
-} & AuthorityOf<Callable> & SelfOf<Callable>;
+} & AuthorityOf<Callable, DomainValue> & SelfOf<Callable>;
 export {};

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

@@ -1,3 +1,11 @@
 import type { MutationResult } from '@astrale-os/kernel-core/graph/mutate';
-import type { Mutation } from './mutation.js';
-export declare function defineMutation<Input, Output = MutationResult>(definition: Mutation<Input, Output>): Mutation<Input, Output>;
+import type { Domain, schema } from '../../platform/schema/index.js';
+import type { Mutation, MutationDefinition } from './mutation.js';
+type ResolvedDomainOf<Schema extends schema.DomainSchema> = Extract<schema.DomainOf<Schema>, Domain>;
+interface MutationProjector<Schema extends schema.DomainSchema> {
+    <Input, Output = MutationResult>(project: (domain: ResolvedDomainOf<Schema>) => MutationDefinition<Input, Output>): Mutation<ResolvedDomainOf<Schema>, Input, Output>;
+}
+/** Define one inert Mutation recipe 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/define.js

@@ -1,13 +1,47 @@
-export function defineMutation(definition) {
+import { isDomain } from '@astrale-os/kernel-dsl/v1/domain';
+const projectors = new WeakMap();
+const realized = new WeakMap();
+/** Define one inert Mutation recipe 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.change !== 'function' ||
+        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 !== 'change' && key !== 'project' && key !== 'reject')) {
+        Reflect.ownKeys(definition).some((key) => key !== 'id' && key !== 'build' && key !== 'project' && key !== 'reject')) {
         invalid();
     }
     return Object.freeze({ ...definition });
@@ -15,3 +49,8 @@ export function defineMutation(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/execution/execute.d.ts

@@ -1,8 +1,9 @@
-import type { GraphApi } from '../../../platform/client/index.js';
+import { MutationAST, type MutationResult } from '@astrale-os/kernel-core/graph/mutate';
 import type { Domain } from '../../../platform/schema/index.js';
 import type { Mutation } from '../mutation.js';
-/** Canonical caller-scoped graph capability required by Mutation execution. */
-export type MutationClient = Pick<GraphApi, 'mutate'>;
-export declare function executeMutation<Input, Output>(client: MutationClient, definition: Mutation<Input, Output>, input: Input): Promise<Output>;
-/** Private Runtime binding; public callers use executeMutation with an explicit Client. */
-export declare function executeMutationWithExpected<Input, Output>(client: MutationClient, definition: Mutation<Input, Output>, input: Input, expected?: Domain['closure']): Promise<Output>;
+export interface MutationClient {
+    mutate(ast: ReturnType<typeof MutationAST.build>, options?: {
+        readonly expected?: Domain['closure'];
+    }): Promise<MutationResult>;
+}
+export declare function executeMutation<DomainValue extends Domain, Input, Output>(client: MutationClient, domain: DomainValue, definition: Mutation<DomainValue, Input, Output>, input: Input): Promise<Output>;

package/dist/application/mutation/execution/execute.js

@@ -1,24 +1,21 @@
 import { MutationAST } from '@astrale-os/kernel-core/graph/mutate';
 import { richMutationBuilder } from '../authoring/index.js';
+import { realizeMutation } from '../define.js';
 import { mutationFailure } from '../failure.js';
 import { projectMutation } from './projection.js';
-export async function executeMutation(client, definition, input) {
-    return executeMutationWithExpected(client, definition, input);
-}
-/** Private Runtime binding; public callers use executeMutation with an explicit Client. */
-export async function executeMutationWithExpected(client, definition, input, expected) {
+export async function executeMutation(client, domain, definition, input) {
     if (client === null || typeof client !== 'object' || typeof client.mutate !== 'function') {
         throw new TypeError('Mutation execution requires a Client mutate capability.');
     }
+    const operation = realizeMutation(definition, domain);
     try {
-        const ast = MutationAST.build((builder) => definition.change(richMutationBuilder(builder), input));
-        const result = await client.mutate(ast, expected === undefined ? undefined : { expected });
-        return projectMutation(definition, result, input);
+        const ast = MutationAST.build((builder) => operation.build(input, richMutationBuilder(builder)));
+        return projectMutation(operation, await client.mutate(ast, { expected: domain.closure }), input);
     }
     catch (cause) {
         const expected = mutationFailure(cause);
-        if (definition.reject !== undefined && expected !== undefined)
-            return definition.reject(expected);
+        if (operation.reject !== undefined && expected !== undefined)
+            return operation.reject(expected);
         throw cause;
     }
 }

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

@@ -2,8 +2,8 @@ import type { Domain } from '../../../platform/schema/index.js';
 import type { Mutation } from '../mutation.js';
 import type { MutationClient } from './execute.js';
 /** Invocation-bound executor for authored Mutation definitions. */
-export interface MutationExecutor {
-    <Input, Output>(definition: Mutation<Input, Output>, input: Input): Promise<Output>;
+export interface MutationExecutor<DomainValue extends Domain = Domain> {
+    <Input, Output>(definition: Mutation<DomainValue, Input, Output>, input: Input): Promise<Output>;
 }
-/** Private Runtime binding; public consumers use executeMutation(client, definition, input). */
-export declare function bindMutation(client: MutationClient, expected: Domain['closure']): MutationExecutor;
+/** Private Runtime binding to one Client and the exact loaded root Domain. */
+export declare function bindMutation<DomainValue extends Domain>(client: MutationClient, domain: DomainValue): MutationExecutor<DomainValue>;

package/dist/application/mutation/execution/executor.js

@@ -1,5 +1,5 @@
-import { executeMutationWithExpected } from './execute.js';
-/** Private Runtime binding; public consumers use executeMutation(client, definition, input). */
-export function bindMutation(client, expected) {
-    return (definition, input) => executeMutationWithExpected(client, definition, input, expected);
+import { executeMutation } from './execute.js';
+/** Private Runtime binding to one Client and the exact loaded root Domain. */
+export function bindMutation(client, domain) {
+    return (definition, input) => executeMutation(client, domain, definition, input);
 }

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

@@ -1,3 +1,3 @@
 import type { MutationResult } from '@astrale-os/kernel-core/graph/mutate';
-import type { Mutation } from '../mutation.js';
-export declare function projectMutation<Input, Output>(definition: Mutation<Input, Output>, result: MutationResult, input: Input): Output;
+import type { MutationDefinition } from '../mutation.js';
+export declare function projectMutation<Input, Output>(definition: MutationDefinition<Input, Output>, result: MutationResult, input: Input): Output;

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

@@ -1,7 +1,7 @@
 export { defineMutation } from './define.js';
 export { executeMutation, type MutationClient, type MutationExecutor } from './execution/index.js';
 export type { MutationFailure } from './failure.js';
-export type { Mutation, MutationInputOf, MutationOutputOf } from './mutation.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';

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

@@ -1,16 +1,24 @@
 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 { MutationFailure } from './failure.js';
+declare const MUTATION_DOMAIN: unique symbol;
 declare const MUTATION_INPUT: unique symbol;
 declare const MUTATION_OUTPUT: unique symbol;
-export interface Mutation<Input, Output = MutationResult> {
-    readonly id: string;
+/** Inert Domain-bound Mutation recipe. 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;
-    change(mutation: RichMutationBuilder, input: Input): undefined;
-    project?(result: MutationResult, input: Input): 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;
 }
-export type MutationInputOf<Value> = Value extends Mutation<infer Input, infer _Output> ? Input : never;
-export type MutationOutputOf<Value> = Value extends Mutation<infer _Input, infer Output> ? Output : never;
+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 {};

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

@@ -1,4 +1,5 @@
-import type { SingleQuery } from '../single/index.js';
+import type { Domain } from '../../../platform/schema/index.js';
+import type { SingleQueryDefinition } from '../query.js';
 import type { QueryComposition, QueryPlan } from './query.js';
 declare const PLAN: unique symbol;
 export interface PlanReference {
@@ -10,7 +11,7 @@ export interface LeafPlan {
     readonly kind: 'leaf';
     readonly key: number;
     readonly id: string;
-    readonly definition: SingleQuery<unknown, unknown>;
+    readonly definition: SingleQueryDefinition<Domain, unknown, unknown>;
     readonly input: unknown;
 }
 export interface CombinedPlan {
@@ -25,11 +26,11 @@ export interface InternalPlan extends QueryPlan<unknown> {
         node: PlanNode;
     }>;
 }
-export interface QueryCompositionSession {
-    readonly builder: QueryComposition;
+export interface QueryCompositionSession<DomainValue extends Domain = Domain> {
+    readonly builder: QueryComposition<DomainValue>;
     close(output: unknown): InternalPlan;
 }
-export declare function createQueryComposition(): QueryCompositionSession;
+export declare function createQueryComposition<DomainValue extends Domain>(): QueryCompositionSession<DomainValue>;
 export declare function inspectPlan(plan: InternalPlan): Readonly<{
     token: object;
     node: PlanNode;

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

@@ -10,8 +10,8 @@ export function createQueryComposition() {
         query(id, definition, input) {
             requireOpen(open);
             requireLocalId(id, ids);
-            if (definition?.kind !== 'single')
-                invalid('Composite leaves must be single Queries.');
+            if (definition?.kind !== 'query')
+                invalid('Composite leaves must be single Query recipes.');
             requireLocalReferences(input, token);
             return createPlan(token, Object.freeze({
                 kind: 'leaf',

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

@@ -1,8 +1,9 @@
-import type { SingleQuery } from '../single/index.js';
+import type { Domain } from '../../../platform/schema/index.js';
+import type { SingleQueryDefinition } from '../query.js';
 import type { InternalPlan } from './builder.js';
 export interface QueryPlanAnalysis {
     readonly queries: number;
     readonly depth: number;
 }
 export declare function analyzeQueryPlan(plan: InternalPlan): QueryPlanAnalysis;
-export declare function executeQueryPlan(plan: InternalPlan, run: (definition: SingleQuery<unknown, unknown>, input: unknown) => Promise<unknown>): Promise<unknown>;
+export declare function executeQueryPlan(plan: InternalPlan, run: (definition: SingleQueryDefinition<Domain, unknown, unknown>, input: unknown) => Promise<unknown>): Promise<unknown>;

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

@@ -1,4 +1,6 @@
-import type { QueryLifecycle, SingleQuery } from '../single/index.js';
+import type { Domain } from '../../../platform/schema/index.js';
+import type { SingleQueryDefinition } from '../query.js';
+import type { QueryLifecycle } from '../single/index.js';
 declare const QUERY_PLAN_OUTPUT: unique symbol;
 declare const QUERY_PLAN_VALUE: unique symbol;
 export type QueryPlanValue<Value> = Readonly<{
@@ -14,21 +16,21 @@ export interface QueryPlan<Output> {
     readonly value: QueryPlanValue<Output>;
 }
 export type QueryPlanOutput<Plan extends QueryPlan<unknown>> = Plan[typeof QUERY_PLAN_OUTPUT];
-export interface QueryComposition {
-    query<Input, Output>(id: string, definition: SingleQuery<Input, Output>, input: QueryPlanInput<Input>): QueryPlan<Output>;
+export interface QueryComposition<DomainValue extends Domain = Domain> {
+    query<Input, Output>(id: string, definition: SingleQueryDefinition<DomainValue, Input, Output>, input: QueryPlanInput<Input>): QueryPlan<Output>;
     combine<const Plans extends Readonly<Record<string, QueryPlan<unknown>>>>(plans: Plans): QueryPlan<{
         readonly [Name in keyof Plans]: QueryPlanOutput<Plans[Name]>;
     }>;
 }
-export interface CompositeQueryBase<Input, Composed, Output> extends QueryLifecycle<Input, Output> {
+export interface CompositeQueryBase<Input, Composed, Output, DomainValue extends Domain = Domain> extends QueryLifecycle<Input, Output> {
     readonly kind: 'composite';
-    compose(builder: QueryComposition, input: Input): QueryPlan<Composed>;
+    compose(builder: QueryComposition<DomainValue>, input: Input): QueryPlan<Composed>;
 }
-export interface RawCompositeQuery<Input, Output> extends CompositeQueryBase<Input, Output, Output> {
+export interface RawCompositeQuery<Input, Output, DomainValue extends Domain = Domain> extends CompositeQueryBase<Input, Output, Output, DomainValue> {
     readonly project?: undefined;
 }
-export interface ProjectedCompositeQuery<Input, Composed, Output> extends CompositeQueryBase<Input, Composed, Output> {
+export interface ProjectedCompositeQuery<Input, Composed, Output, DomainValue extends Domain = Domain> extends CompositeQueryBase<Input, Composed, Output, DomainValue> {
     project(value: Composed, input: Input): Output;
 }
-export type CompositeQuery<Input, Composed, Output = Composed> = RawCompositeQuery<Input, Composed> | ProjectedCompositeQuery<Input, Composed, Output>;
+export type CompositeQuery<Input, Composed, Output = Composed, DomainValue extends Domain = Domain> = RawCompositeQuery<Input, Composed, DomainValue> | ProjectedCompositeQuery<Input, Composed, Output, DomainValue>;
 export {};

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

@@ -1,6 +1,8 @@
 import type { QueryAST } from '@astrale-os/kernel-core/graph/query';
+import type { Domain, schema } from '../../platform/schema/index.js';
 import type { ProjectedCompositeQuery, RawCompositeQuery } from './composite/index.js';
-import type { PaginatedQuery, ProjectedQuery, RawQuery } from './single/index.js';
+import type { CompositeQueryDefinition, QueryDefinition, RealizedQuery, SingleQueryDefinition } from './query.js';
+import type { PaginatedQuery, ProjectedQuery, RawQuery, SingleQuery } from './single/index.js';
 type AuthoredRaw<Input, Ast extends QueryAST> = Omit<RawQuery<Input, Ast>, 'kind' | 'page'> & {
     readonly page?: {
         readonly size: number;
@@ -16,9 +18,19 @@ type AuthoredPaginated<Input, Output, Ast extends QueryAST> = Omit<PaginatedQuer
         readonly size: number;
     };
 };
-export declare function defineQuery<Input, Ast extends QueryAST>(definition: AuthoredRaw<Input, Ast>): RawQuery<Input, Ast>;
-export declare function defineQuery<Input, Output, Ast extends QueryAST>(definition: AuthoredProjected<Input, Output, Ast>): ProjectedQuery<Input, Output, Ast>;
-export declare function defineQuery<Input, Output, Ast extends QueryAST>(definition: AuthoredPaginated<Input, Output, Ast>): PaginatedQuery<Input, Output, Ast>;
-export declare function defineCompositeQuery<Input, Output>(definition: Omit<RawCompositeQuery<Input, Output>, 'kind'>): RawCompositeQuery<Input, Output>;
-export declare function defineCompositeQuery<Input, Composed, Output>(definition: Omit<ProjectedCompositeQuery<Input, Composed, Output>, 'kind'>): ProjectedCompositeQuery<Input, Composed, Output>;
+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 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>(project: (domain: ResolvedDomainOf<Schema>) => Omit<ProjectedCompositeQuery<Input, Composed, Output, ResolvedDomainOf<Schema>>, 'kind'>): 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 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>(definition: QueryDefinition<DomainValue, Input, Output>, domain: DomainValue): RealizedQuery<Input, Output>;
 export {};

package/dist/application/query/define.js

@@ -1,6 +1,45 @@
+import { isDomain } from '@astrale-os/kernel-dsl/v1/domain';
 const DEFAULT_PAGE_SIZE = 256;
 const MAXIMUM_PAGES = 1_024;
-export function defineQuery(definition) {
+const projectors = new WeakMap();
+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 inert composite Query recipe projected from its exact loaded Domain. */
+export function defineCompositeQuery() {
+    return ((project) => recipe('composite-query', project));
+}
+export function realizeQuery(definition, domain) {
+    const project = projectors.get(definition);
+    if (project === undefined)
+        throw new TypeError('Query must be produced by defineQuery.');
+    if (!isDomain(domain))
+        throw new TypeError('Query projection requires an admitted Domain.');
+    let byDomain = realized.get(definition);
+    const cached = byDomain?.get(domain);
+    if (cached !== undefined)
+        return cached;
+    const authored = project(domain);
+    if (isPromiseLike(authored))
+        throw new TypeError('Query projection must be synchronous.');
+    const admitted = definition.kind === 'query' ? admitSingle(authored) : admitComposite(authored);
+    if (byDomain === undefined) {
+        byDomain = new WeakMap();
+        realized.set(definition, byDomain);
+    }
+    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;
@@ -24,7 +63,7 @@ export function defineQuery(definition) {
     }
     return Object.freeze({ ...definition, page, kind: 'single' });
 }
-export function defineCompositeQuery(definition) {
+function admitComposite(definition) {
     definitionBase(definition, 'compose');
     if (Object.hasOwn(definition, 'page') || Object.hasOwn(definition, 'pagination')) {
         throw new TypeError('Composite Query cannot declare pagination.');
@@ -73,3 +112,8 @@ function pageOf(input) {
 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/execution/execute.d.ts

@@ -1,7 +1,13 @@
-import type { GraphApi } from '../../../platform/client/index.js';
+import type { QueryPageRequest, QueryResponse } from '@astrale-os/kernel-client/graph';
+import type { QueryAST, QueryResultFor } from '@astrale-os/kernel-core/graph/query';
+import type { Domain } from '../../../platform/schema/index.js';
 import type { CompositeQuery } from '../composite/index.js';
 import type { QueryDefinition } from '../query.js';
-/** Canonical caller-scoped graph capability required by Query execution. */
-export type QueryClient = Pick<GraphApi, 'query'>;
-export declare function executeQuery<Input, Output>(client: QueryClient, definition: QueryDefinition<Input, Output>, input: Input): Promise<Output>;
+export interface QueryClient {
+    query<Ast extends QueryAST>(ast: Ast, options: {
+        readonly page: QueryPageRequest;
+        readonly expected?: Domain['closure'];
+    }): Promise<QueryResponse<QueryResultFor<Ast>>>;
+}
+export declare function executeQuery<DomainValue extends Domain, Input, Output>(client: QueryClient, domain: DomainValue, definition: QueryDefinition<DomainValue, Input, Output>, input: Input): Promise<Output>;
 export type ExecutableCompositeQuery = CompositeQuery<unknown, unknown, unknown>;

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

@@ -1,32 +1,40 @@
 import { createQueryComposition, executeQueryPlan } from '../composite/index.js';
+import { realizeQuery } from '../define.js';
 import { queryFailure } from '../failure.js';
 import { completeSelection } from '../single/index.js';
 import { executePages } from './pages.js';
-export async function executeQuery(client, definition, input) {
+export async function executeQuery(client, domain, definition, input) {
     if (client === null || typeof client !== 'object' || typeof client.query !== 'function') {
         throw new TypeError('Query execution requires a Client query capability.');
     }
-    const execute = client.query.bind(client);
+    const execute = (ast, options) => client.query(ast, { ...options, expected: domain.closure });
+    const operation = realizeQuery(definition, domain);
     try {
-        const prepared = definition.prepare?.(input) ?? input;
-        if (definition.kind === 'single')
-            return (await runSingle(execute, definition, prepared));
+        if (operation.kind === 'single')
+            return (await runSingle(execute, operation, input));
+        const prepared = operation.prepare?.(input) ?? input;
         const session = createQueryComposition();
-        const composed = definition.compose(session.builder, prepared);
+        const composed = operation.compose(session.builder, prepared);
         if (isPromiseLike(composed))
             throw new TypeError('Composite Query composition must be synchronous.');
         const plan = session.close(composed);
-        const result = await executeQueryPlan(plan, (child, childInput) => runSingle(execute, child, childInput));
-        return (definition.project === undefined ? result : definition.project(result, prepared));
+        const result = await executeQueryPlan(plan, (child, childInput) => runSingle(execute, realizeSingle(child, domain), childInput));
+        return (operation.project === undefined ? result : operation.project(result, prepared));
     }
     catch (cause) {
         const expected = queryFailure(cause);
-        if (definition.reject !== undefined && expected !== undefined) {
-            return definition.reject(expected);
+        if (operation.reject !== undefined && expected !== undefined) {
+            return operation.reject(expected);
         }
         throw cause;
     }
 }
+function realizeSingle(definition, domain) {
+    const operation = realizeQuery(definition, domain);
+    if (operation.kind !== 'single')
+        throw new TypeError('Composite Query leaves must be single.');
+    return operation;
+}
 async function runSingle(execute, definition, input) {
     const prepared = definition.prepare?.(input) ?? input;
     const ast = definition.build(prepared);

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

@@ -2,8 +2,8 @@ import type { Domain } from '../../../platform/schema/index.js';
 import type { QueryDefinition } from '../query.js';
 import type { QueryClient } from './execute.js';
 /** Invocation-bound executor for authored Query definitions. */
-export interface QueryExecutor {
-    <Input, Output>(definition: QueryDefinition<Input, Output>, input: Input): Promise<Output>;
+export interface QueryExecutor<DomainValue extends Domain = Domain> {
+    <Input, Output>(definition: QueryDefinition<DomainValue, Input, Output>, input: Input): Promise<Output>;
 }
-/** Private Runtime binding; public consumers use executeQuery(client, definition, input). */
-export declare function bindQuery(client: QueryClient, expected: Domain['closure']): QueryExecutor;
+/** Private Runtime binding to one Client and the exact loaded root Domain. */
+export declare function bindQuery<DomainValue extends Domain>(client: QueryClient, domain: DomainValue): QueryExecutor<DomainValue>;

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

@@ -1,10 +1,5 @@
 import { executeQuery } from './execute.js';
-/** Private Runtime binding; public consumers use executeQuery(client, definition, input). */
-export function bindQuery(client, expected) {
-    const bound = Object.freeze({
-        query(ast, options) {
-            return client.query(ast, { ...options, expected });
-        },
-    });
-    return (definition, input) => executeQuery(bound, definition, input);
+/** Private Runtime binding to one Client and the exact loaded root Domain. */
+export function bindQuery(client, domain) {
+    return (definition, input) => executeQuery(client, domain, definition, input);
 }

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

@@ -1,7 +1,7 @@
-export { defineCompositeQuery, defineQuery } from './define.js';
+export { defineCompositeQuery, defineQuery, realizeQuery } from './define.js';
 export { executeQuery, type QueryClient, type QueryExecutor } from './execution/index.js';
 export { QueryPaginationError, type QueryFailure, type QueryPaginationErrorCode, } from './failure.js';
-export type { QueryAstOf, QueryDefinition, QueryInputOf, QueryOutputOf } from './query.js';
+export type { CompositeQueryDefinition, QueryAstOf, QueryDefinition, QueryInputOf, QueryOutputOf, SingleQueryDefinition, } from './query.js';
 export { queryResult } from './single/index.js';
 export type { CompleteQueryProjectionContext, PaginatedQuery, ProjectedQuery, QueryPages, QueryPagination, QueryProjectionContext, RawQuery, SingleQuery, } from './single/index.js';
 export type { CompositeQuery, ProjectedCompositeQuery, QueryComposition, QueryPlan, QueryPlanInput, QueryPlanOutput, QueryPlanValue, RawCompositeQuery, } from './composite/index.js';

package/dist/application/query/index.js

@@ -1,4 +1,4 @@
-export { defineCompositeQuery, defineQuery } from './define.js';
+export { defineCompositeQuery, defineQuery, realizeQuery } from './define.js';
 export { executeQuery } from './execution/index.js';
 export { QueryPaginationError, } from './failure.js';
 export { queryResult } from './single/index.js';

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

@@ -1,7 +1,26 @@
 import type { QueryAST, QueryResult } from '@astrale-os/kernel-core/graph/query';
+import type { Domain } from '../../platform/schema/index.js';
 import type { CompositeQuery } from './composite/index.js';
 import type { QueryLifecycle, SingleQuery } from './single/index.js';
-export type QueryDefinition<Input, Output = QueryResult, Ast extends QueryAST = QueryAST> = SingleQuery<Input, Output, Ast> | CompositeQuery<Input, unknown, Output>;
-export type QueryInputOf<Value> = Value extends QueryLifecycle<infer Input, infer _Output> ? Input : never;
-export type QueryOutputOf<Value> = Value extends QueryLifecycle<infer _Input, infer Output> ? Output : never;
-export type QueryAstOf<Value> = Value extends SingleQuery<unknown, unknown, infer Ast> ? Ast : never;
+declare const QUERY_DOMAIN: unique symbol;
+declare const QUERY_INPUT: unique symbol;
+declare const QUERY_OUTPUT: unique symbol;
+/** Inert Domain-bound Query recipe. Its projector is retained privately by the SDK. */
+export interface QueryDefinition<DomainValue extends Domain = Domain, Input = unknown, Output = QueryResult> {
+    readonly kind: 'query' | 'composite-query';
+    readonly [QUERY_DOMAIN]: (domain: DomainValue) => DomainValue;
+    readonly [QUERY_INPUT]?: Input;
+    readonly [QUERY_OUTPUT]?: Output;
+}
+export interface SingleQueryDefinition<DomainValue extends Domain = Domain, Input = unknown, Output = QueryResult> extends QueryDefinition<DomainValue, Input, Output> {
+    readonly kind: 'query';
+}
+export interface CompositeQueryDefinition<DomainValue extends Domain = Domain, Input = unknown, Output = unknown> extends QueryDefinition<DomainValue, Input, Output> {
+    readonly kind: 'composite-query';
+}
+/** Canonical admitted operation produced by realizing one Query recipe. */
+export type RealizedQuery<Input, Output = QueryResult, Ast extends QueryAST = QueryAST> = SingleQuery<Input, Output, Ast> | CompositeQuery<Input, unknown, Output, Domain>;
+export type QueryInputOf<Value> = Value extends QueryDefinition<infer _Domain, infer Input, infer _Output> ? Input : Value extends QueryLifecycle<infer Input, infer _Output> ? Input : never;
+export type QueryOutputOf<Value> = Value extends QueryDefinition<infer _Domain, infer _Input, infer Output> ? Output : Value extends QueryLifecycle<infer _Input, infer Output> ? Output : never;
+export type QueryAstOf<Value> = Value extends RealizedQuery<unknown, unknown, infer Ast> ? Ast : never;
+export {};

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

@@ -21,8 +21,8 @@ export function context(request, runtime, authentication, self) {
         ...(client === null
             ? {}
             : {
-                query: bindQuery(client, runtime.loaded.domain.closure),
-                mutate: bindMutation(client, runtime.loaded.domain.closure),
+                query: bindQuery(client, runtime.loaded.domain),
+                mutate: bindMutation(client, runtime.loaded.domain),
             }),
         integrations: clients(runtime, request.context, client),
         execution,

package/dist/execution/runtime/load.d.ts

@@ -1,11 +1,14 @@
 import type { Domain } from '@astrale-os/kernel-dsl/v1/domain';
+import type { DomainSchema, DomainOf } from '@astrale-os/kernel-dsl/v1/schema';
 import type { RuntimeRegistry } from '../../application/runtime/index.js';
 import type { Build } from '../../deployment/build/build.js';
 import type { Release } from '../../deployment/release/release.js';
+type DomainOfBuild<BuildValue extends Build> = BuildValue extends Build<infer Schema extends DomainSchema, object> ? Extract<DomainOf<Schema>, Domain> : Domain;
 export interface LoadedRuntime<BuildValue extends Build = Build> {
     readonly release: Release<BuildValue>;
-    readonly domain: Domain;
+    readonly domain: DomainOfBuild<BuildValue>;
     readonly registry: RuntimeRegistry;
 }
 /** Load one execution Runtime from the exact evidence retained by its admitted Build. */
 export declare function load<const BuildValue extends Build>(release: Release<BuildValue>): LoadedRuntime<BuildValue>;
+export {};