@astrale-os/sdk 0.5.0-beta.63 → 0.5.0-beta.65

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

@@ -1,24 +1,27 @@
+import { COLLECTION_QUERY_LIMITS } from '../collection/limits.js';
+import { compileCollectionUnion, partitionCollectionUnion } from '../collection/union.js';
 import { createQueryComposition, executeQueryPlan } from '../composite/index.js';
 import { realizeQuery } from '../define.js';
 import { queryFailure } from '../failure.js';
-import { completeSelection } from '../single/index.js';
+import { completeSelection, queryResult } from '../single/index.js';
 import { executePages } from './pages.js';
-export async function executeQuery(client, domain, definition, input) {
+export async function executeQuery(client, domain, query, input) {
     if (client === null || typeof client !== 'object' || typeof client.query !== 'function') {
         throw new TypeError('Query execution requires a Client query capability.');
     }
     const execute = (ast, options) => client.query(ast, { ...options, expected: domain.closure });
-    const operation = realizeQuery(definition, domain);
+    const operation = realizeQuery(query, domain);
     try {
-        if (operation.kind === 'single')
+        if (operation.kind === 'single') {
             return (await runSingle(execute, operation, input));
+        }
         const prepared = operation.prepare?.(input) ?? input;
         const session = createQueryComposition();
         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, realizeSingle(child, domain), childInput));
+        const result = await executeQueryPlan(plan, (child, childInput) => runSingle(execute, realizeSingle(child, domain), childInput), (definitions, outputPath) => runCollectionUnion(execute, domain, definitions, outputPath));
         return (operation.project === undefined ? result : operation.project(result, prepared));
     }
     catch (cause) {
@@ -29,6 +32,20 @@ export async function executeQuery(client, domain, definition, input) {
         throw cause;
     }
 }
+async function runCollectionUnion(execute, domain, definitions, outputPath) {
+    const compiled = compileCollectionUnion(domain, definitions, outputPath);
+    const pages = await executePages(execute, compiled.ast, { size: COLLECTION_QUERY_LIMITS.pageSize }, { maximumPages: COLLECTION_QUERY_LIMITS.maximumPages });
+    const context = outputPath.length === 0 ? 'collection union' : outputPath.join('.');
+    const values = compiled.kind === 'node'
+        ? queryResult.completeNodeValues(pages, context)
+        : Object.freeze(pages.flatMap((page) => queryResult.edgeItems(page, context).map((item) => {
+            if (item.edge.kind !== 'value') {
+                throw new TypeError(`${context} must project Edge values.`);
+            }
+            return item.edge.value;
+        })));
+    return partitionCollectionUnion(domain, compiled, values);
+}
 function realizeSingle(definition, domain) {
     const operation = realizeQuery(definition, domain);
     if (operation.kind !== 'single')

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

@@ -3,7 +3,8 @@ import type { QueryDefinition } from '../query.js';
 import type { QueryClient } from './execute.js';
 /** Invocation-bound executor for authored Query definitions. */
 export interface QueryExecutor<DomainValue extends Domain = Domain> {
-    <Input, Output>(definition: QueryDefinition<DomainValue, Input, Output>, input: Input): Promise<Output>;
+    <Output>(query: QueryDefinition<DomainValue, void, Output>): Promise<Output>;
+    <Input, Output>(query: QueryDefinition<DomainValue, Input, Output>, input: Input): Promise<Output>;
 }
 type ExecutableDomain<DomainValue extends Domain> = DomainValue extends {
     readonly source: infer Source extends schema.DomainSchema;

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

@@ -2,6 +2,6 @@ import { executeQuery } from './execute.js';
 /** Private Runtime binding to one Client and the exact loaded root Domain. */
 export function bindQuery(client, domain) {
     const executable = domain;
-    const execute = (definition, input) => executeQuery(client, executable, definition, input);
+    const execute = (query, input) => executeQuery(client, executable, query, input);
     return execute;
 }

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

@@ -1,7 +1,8 @@
-export { defineCompositeQuery, defineQuery, realizeQuery } from './define.js';
+export { defineCollectionQuery, defineCompositeQuery, defineQuery, realizeQuery } from './define.js';
+export type { CollectionQuerySpec } from './collection/metadata.js';
 export { executeQuery, type QueryClient, type QueryExecutor } from './execution/index.js';
 export { QueryPaginationError, type QueryFailure, type QueryPaginationErrorCode, } from './failure.js';
-export type { CompositeQueryDefinition, QueryAstOf, QueryDefinition, QueryInputOf, QueryOutputOf, SingleQueryDefinition, } from './query.js';
+export type { CollectionQueryDefinition, CollectionValue, 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, realizeQuery } from './define.js';
+export { defineCollectionQuery, 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,10 +1,14 @@
 import type { QueryAST, QueryResult } from '@astrale-os/kernel-core/graph/query';
+import type { AnyResolvedClass, ResolvedClass } from '@astrale-os/kernel-dsl/v1';
+import type { Edge } from '../../platform/graph/edge/index.js';
+import type { Node } from '../../platform/graph/node/index.js';
 import type { Domain } from '../../platform/schema/index.js';
 import type { CompositeQuery } from './composite/index.js';
 import type { QueryLifecycle, SingleQuery } from './single/index.js';
 declare const QUERY_DOMAIN: unique symbol;
 declare const QUERY_INPUT: unique symbol;
 declare const QUERY_OUTPUT: unique symbol;
+declare const COLLECTION_QUERY_CLASS: 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';
@@ -15,6 +19,11 @@ export interface QueryDefinition<DomainValue extends Domain = Domain, Input = un
 export interface SingleQueryDefinition<DomainValue extends Domain = Domain, Input = unknown, Output = QueryResult> extends QueryDefinition<DomainValue, Input, Output> {
     readonly kind: 'query';
 }
+export type CollectionValue<Class extends AnyResolvedClass> = Class extends ResolvedClass<'node'> ? Node : Class extends ResolvedClass<'edge'> ? Edge : never;
+/** Closed complete-Class Query recipe admitted for explicit physical union planning. */
+export interface CollectionQueryDefinition<DomainValue extends Domain = Domain, Class extends AnyResolvedClass = AnyResolvedClass> extends SingleQueryDefinition<DomainValue, void, readonly CollectionValue<Class>[]> {
+    readonly [COLLECTION_QUERY_CLASS]: Class;
+}
 export interface CompositeQueryDefinition<DomainValue extends Domain = Domain, Input = unknown, Output = unknown> extends QueryDefinition<DomainValue, Input, Output> {
     readonly kind: 'composite-query';
 }

package/dist/index.d.ts

@@ -7,8 +7,8 @@ export { defineIntegration, defineProvider } from './application/integration/ind
 export type { IntegrationClient, IntegrationDefinition, Provider, } from './application/integration/index.js';
 export { defineMutation, executeMutation } from './application/mutation/index.js';
 export type { Mutation, MutationFailure } from './application/mutation/index.js';
-export { defineCompositeQuery, defineQuery, executeQuery } from './application/query/index.js';
-export type { QueryDefinition, QueryFailure } from './application/query/index.js';
+export { defineCollectionQuery, defineCompositeQuery, defineQuery, executeQuery, } from './application/query/index.js';
+export type { CollectionQueryDefinition, QueryDefinition, QueryFailure, } from './application/query/index.js';
 export { defineRuntime } from './application/runtime/index.js';
 export type { Runtime } from './application/runtime/index.js';
 export { stateMachine } from './application/state/index.js';

package/dist/index.js

@@ -3,7 +3,7 @@ export { defineAction } from './application/action/index.js';
 export { defineApplication, defineFrontend, external, requirements, route, routes, vite, } from './application/index.js';
 export { defineIntegration, defineProvider } from './application/integration/index.js';
 export { defineMutation, executeMutation } from './application/mutation/index.js';
-export { defineCompositeQuery, defineQuery, executeQuery } from './application/query/index.js';
+export { defineCollectionQuery, defineCompositeQuery, defineQuery, executeQuery, } from './application/query/index.js';
 export { defineRuntime } from './application/runtime/index.js';
 export { stateMachine } from './application/state/index.js';
 export { defineWorkflow } from './application/workflow/index.js';

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

@@ -4,6 +4,7 @@ export { collectDependencyIssues, resolveProjectImport } from './imports.js';
 export { importedSymbol, isLocallyDeclared, resolveImportedSymbol, location, objectProperty, propertyChain, staticText, unwrap, visit, } from './syntax.js';
 export { assertSingleTypeUniverse } from './type-universe.js';
 export { observeQueryDefinitions } from './query-observation.js';
+export { queryCollectionKind } from './query-collection-type.js';
 export { collectSuppressionDirectives } from './suppression-directives.js';
 import type ts from 'typescript';
 import type { DomainPolicy } from '../../policy/index.js';

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

@@ -4,4 +4,5 @@ export { collectDependencyIssues, resolveProjectImport } from './imports.js';
 export { importedSymbol, isLocallyDeclared, resolveImportedSymbol, location, objectProperty, propertyChain, staticText, unwrap, visit, } from './syntax.js';
 export { assertSingleTypeUniverse } from './type-universe.js';
 export { observeQueryDefinitions } from './query-observation.js';
+export { queryCollectionKind } from './query-collection-type.js';
 export { collectSuppressionDirectives } from './suppression-directives.js';

package/dist/tooling/linter/adapters/typescript/query-collection-type.d.ts

@@ -0,0 +1,4 @@
+import ts from 'typescript';
+import type { SourceFile, SourceProject } from './index.js';
+/** Infer the closed collection graph kind only when the Domain's real TypeScript program proves it. */
+export declare function queryCollectionKind(project: SourceProject, file: SourceFile, expression: ts.Expression): 'node' | 'edge' | undefined;

package/dist/tooling/linter/adapters/typescript/query-collection-type.js

@@ -0,0 +1,94 @@
+import { dirname } from 'node:path';
+import ts from 'typescript';
+const contexts = new WeakMap();
+/** Infer the closed collection graph kind only when the Domain's real TypeScript program proves it. */
+export function queryCollectionKind(project, file, expression) {
+    const context = typeContext(project);
+    if (context === null)
+        return undefined;
+    const source = context.program.getSourceFile(file.absolutePath);
+    if (source === undefined)
+        return undefined;
+    const node = matchingNode(source, expression.getStart(file.source), expression.end);
+    if (node === undefined || !ts.isExpression(node))
+        return undefined;
+    const kinds = graphKinds(context.checker, context.checker.getTypeAtLocation(node), node);
+    return kinds.size === 1 ? [...kinds][0] : undefined;
+}
+function typeContext(project) {
+    const existing = contexts.get(project);
+    if (existing !== undefined)
+        return existing;
+    try {
+        const configPath = ts.findConfigFile(project.root, ts.sys.fileExists);
+        if (configPath === undefined)
+            return remember(project, null);
+        const loaded = ts.readConfigFile(configPath, ts.sys.readFile);
+        if (loaded.error !== undefined)
+            return remember(project, null);
+        const parsed = ts.parseJsonConfigFileContent(loaded.config, ts.sys, dirname(configPath), { noEmit: true }, configPath);
+        const context = {
+            program: ts.createProgram({ rootNames: parsed.fileNames, options: parsed.options }),
+        };
+        return remember(project, {
+            program: context.program,
+            checker: context.program.getTypeChecker(),
+        });
+    }
+    catch {
+        return remember(project, null);
+    }
+}
+function remember(project, context) {
+    contexts.set(project, context);
+    return context;
+}
+function matchingNode(source, start, end) {
+    let match;
+    const visit = (node) => {
+        if (node.getStart(source) > start || node.end < end)
+            return;
+        if (node.getStart(source) === start && node.end === end)
+            match = node;
+        node.forEachChild(visit);
+    };
+    visit(source);
+    return match;
+}
+function graphKinds(checker, type, location) {
+    const kinds = new Set();
+    const inspect = (candidate) => {
+        if (candidate.isUnionOrIntersection()) {
+            for (const member of candidate.types)
+                inspect(member);
+            return;
+        }
+        for (const property of candidate.getProperties()) {
+            if (!isCollectionClassBrand(property))
+                continue;
+            const propertyType = checker.getTypeOfSymbolAtLocation(property, location);
+            const kind = propertyType.getProperty('kind');
+            if (kind === undefined)
+                continue;
+            const kindType = checker.getTypeOfSymbolAtLocation(kind, location);
+            if (!(kindType.flags & ts.TypeFlags.StringLiteral))
+                continue;
+            const value = kindType.value;
+            if (value === 'node' || value === 'edge')
+                kinds.add(value);
+        }
+    };
+    inspect(type);
+    return kinds;
+}
+function isCollectionClassBrand(property) {
+    return Boolean(property.declarations?.some((declaration) => {
+        if (!ts.isPropertySignature(declaration) ||
+            !ts.isInterfaceDeclaration(declaration.parent) ||
+            declaration.parent.name.text !== 'CollectionQueryDefinition') {
+            return false;
+        }
+        const path = declaration.getSourceFile().fileName.replaceAll('\\', '/');
+        return path.includes('/node_modules/@astrale-os/sdk/');
+    }));
+}

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

@@ -22,7 +22,7 @@ function observeFile(file) {
             return;
         const origin = resolveImportedSymbol(file, factory.expression);
         if ((origin.kind !== 'resolved' && origin.kind !== 'ambiguous') ||
-            origin.name !== 'defineQuery' ||
+            (origin.name !== 'defineQuery' && origin.name !== 'defineCollectionQuery') ||
             (origin.kind === 'resolved' && !SDK_MODULES.has(origin.module))) {
             return;
         }
@@ -41,6 +41,18 @@ function observeFile(file) {
             }));
             return;
         }
+        if (origin.name === 'defineCollectionQuery') {
+            observations.push(Object.freeze({
+                subjectId,
+                location: sourceLocation,
+                constructorIdentity: known(sdkConstructorIdentity(file, factory.expression, origin.name)),
+                definitionKind: known('single'),
+                canonicalRequestCount: known(1),
+                buildCallbackCount: known(1),
+                projectCallbackCount: known(0),
+            }));
+            return;
+        }
         const object = projectedObject(node);
         if (!object) {
             const reason = 'definition input is not a static object literal';
@@ -129,12 +141,14 @@ function localConstInitializers(build) {
     }
     return declarations;
 }
-function sdkConstructorIdentity(file, expression) {
+function sdkConstructorIdentity(file, expression, name = 'defineQuery') {
     const spelling = expression.getText(file.source);
     return Object.freeze({
         kind: 'sdk-query',
-        canonicalId: 'astrale.sdk.defineQuery',
-        aliases: Object.freeze(spelling === 'defineQuery' ? [] : [spelling]),
+        canonicalId: name === 'defineCollectionQuery'
+            ? 'astrale.sdk.defineCollectionQuery'
+            : 'astrale.sdk.defineQuery',
+        aliases: Object.freeze(spelling === name ? [] : [spelling]),
     });
 }
 function canonicalRoots(file, node) {

package/dist/tooling/linter/analysis/query/observation.d.ts

@@ -14,7 +14,7 @@ export type Epistemic<T> = Readonly<{
 }>;
 export type QueryConstructorIdentity = Readonly<{
     kind: 'sdk-query';
-    canonicalId: 'astrale.sdk.defineQuery';
+    canonicalId: 'astrale.sdk.defineQuery' | 'astrale.sdk.defineCollectionQuery';
     aliases: readonly string[];
 }> | Readonly<{
     kind: 'other';

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

@@ -494,6 +494,7 @@ export const globalRules = [
             const evidence = [];
             const owners = new Map();
             const definitions = [
+                { layer: 'queries', name: 'defineCollectionQuery', members: [undefined] },
                 { layer: 'queries', name: 'defineQuery', members: [undefined] },
                 { layer: 'queries', name: 'defineCompositeQuery', members: [undefined] },
                 { layer: 'mutations', name: 'defineMutation', members: [undefined] },
@@ -637,6 +638,7 @@ export const globalRules = [
                 if (file.layer === 'queries' || file.layer === 'mutations') {
                     const definitions = file.layer === 'queries'
                         ? [
+                            ...definitionObjects(file, 'defineCollectionQuery'),
                             ...definitionObjects(file, 'defineQuery'),
                             ...definitionObjects(file, 'defineCompositeQuery'),
                         ]

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

@@ -1,7 +1,7 @@
 import ts from 'typescript';
-import { importedSymbol, observeQueryDefinitions, propertyChain, unwrap, visit, } from '../../adapters/typescript/index.js';
+import { importedSymbol, observeQueryDefinitions, propertyChain, queryCollectionKind, unwrap, visit, } from '../../adapters/typescript/index.js';
 import { decideCanonicalQuery, decideSingleQuery } from '../../analysis/query/index.js';
-import { ambiguity, callback, definitionOriginAmbiguity, definitionObjects, domainProjectorEvidence, production, staticId, violation, } from './shared.js';
+import { ambiguity, callback, definitionOriginAmbiguity, definitionObjects, domainProjectorEvidence, propertyExpression, production, returnedExpressions, staticId, violation, } from './shared.js';
 import { sourceEvidence } from './verifier.js';
 const FORBIDDEN_COMPOSE_NAMES = new Set(['fetch', 'invoke', 'mutate', 'run', 'step', 'then']);
 export const queryRules = [
@@ -12,6 +12,7 @@ export const queryRules = [
             return [
                 ...sourceEvidence(decideCanonicalQuery(observeQueryDefinitions(project))),
                 ...production(project, 'queries').flatMap((file) => [
+                    ...domainProjectorEvidence(file, 'defineCollectionQuery', 'Collection Query'),
                     ...domainProjectorEvidence(file, 'defineQuery', 'Query'),
                     ...domainProjectorEvidence(file, 'defineCompositeQuery', 'Composite Query'),
                 ]),
@@ -170,7 +171,161 @@ export const queryRules = [
             return evidence;
         },
     },
+    {
+        id: 'QRY-COLL-FANOUT',
+        ruleRevision: '50279cef3618d44cc1c3212a0d72213eca26a78c540f7a2998df244c38fc54ca',
+        evaluate(project) {
+            const evidence = [];
+            for (const file of production(project, 'queries')) {
+                for (const definition of definitionObjects(file, 'defineCompositeQuery')) {
+                    if (definition.origin !== 'resolved' || !definition.object)
+                        continue;
+                    const compose = callback(definition.object, 'compose');
+                    if (!compose)
+                        continue;
+                    const builder = composeBuilder(compose);
+                    if (!builder)
+                        continue;
+                    const groups = {
+                        node: [],
+                        edge: [],
+                    };
+                    let logicalQueries = 0;
+                    let physicalQueries = 0;
+                    const returns = returnedExpressions(compose);
+                    if (returns.length !== 1)
+                        continue;
+                    visit(returns[0], (node) => {
+                        if (!ts.isCallExpression(node))
+                            return;
+                        const method = composeBuilderMethod(node.expression, builder);
+                        if (method === 'query') {
+                            logicalQueries += 1;
+                            physicalQueries += 1;
+                            if (!isVoidCollectionLeaf(node))
+                                return;
+                            const selected = node.arguments[1];
+                            if (selected === undefined)
+                                return;
+                            const kind = queryCollectionKind(project, file, selected);
+                            const member = kind && collectionMember(file, selected, node);
+                            if (kind && member)
+                                groups[kind].push(member);
+                            return;
+                        }
+                        if (method !== 'union')
+                            return;
+                        const members = staticRecordMembers(node.arguments[0]);
+                        if (members === undefined)
+                            return;
+                        logicalQueries += members;
+                        physicalQueries += 1;
+                    });
+                    const candidates = ['node', 'edge'].filter((kind) => {
+                        const members = groups[kind];
+                        return (members.length >= 3 &&
+                            new Set(members.map(({ id }) => id)).size === members.length &&
+                            new Set(members.map(({ classKey }) => classKey)).size === members.length);
+                    });
+                    if (candidates.length === 0)
+                        continue;
+                    const optimizedPhysical = physicalQueries -
+                        candidates.reduce((total, kind) => total + groups[kind].length, 0) +
+                        candidates.length;
+                    const scaffold = candidates
+                        .map((kind) => {
+                        const outer = kind === 'node' ? 'nodes' : 'relations';
+                        const members = groups[kind]
+                            .map(({ name, value }) => (name === value ? name : `${name}: ${value}`))
+                            .join(', ');
+                        return `${outer}: query.union({ ${members} })`;
+                    })
+                        .join('\n');
+                    evidence.push(violation(file, compose, `Compatible collection fan-out has a direct replacement:\n${scaffold}\nPlan estimate: ${logicalQueries} logical → ${optimizedPhysical} physical cursor chains (currently ${physicalQueries} physical).`));
+                }
+            }
+            return evidence;
+        },
+    },
 ];
+function isVoidCollectionLeaf(call) {
+    const input = call.arguments[2];
+    if (input === undefined)
+        return true;
+    const value = unwrap(input);
+    return ((ts.isIdentifier(value) && value.text === 'undefined') ||
+        (ts.isVoidExpression(value) && ts.isNumericLiteral(unwrap(value.expression))));
+}
+function collectionMember(file, expression, call) {
+    const value = unwrap(expression);
+    if (!ts.isIdentifier(value))
+        return undefined;
+    const outputName = directOutputName(call);
+    const semantics = collectionDefinitionSemantics(file, value.text);
+    if (outputName === undefined || semantics === undefined)
+        return undefined;
+    return { name: outputName, value: value.text, ...semantics };
+}
+function directOutputName(call) {
+    const property = call.parent;
+    if (!ts.isPropertyAssignment(property) || unwrap(property.initializer) !== call)
+        return undefined;
+    const name = property.name;
+    return ts.isIdentifier(name) || ts.isStringLiteral(name) ? name.text : undefined;
+}
+function collectionDefinitionSemantics(file, name) {
+    const declarations = [];
+    visit(file.source, (node) => {
+        if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.name.text === name) {
+            declarations.push(node);
+        }
+    });
+    if (declarations.length !== 1)
+        return undefined;
+    const application = declarations[0].initializer && unwrap(declarations[0].initializer);
+    if (!application || !ts.isCallExpression(application))
+        return undefined;
+    const factory = unwrap(application.expression);
+    if (!ts.isCallExpression(factory))
+        return undefined;
+    const origin = importedSymbol(file, factory.expression);
+    if (origin?.name !== 'defineCollectionQuery' ||
+        (origin.module !== '@astrale-os/sdk' && origin.module !== '@astrale-os/sdk/query')) {
+        return undefined;
+    }
+    const projected = application.arguments[0] && unwrap(application.arguments[0]);
+    if (!projected || (!ts.isArrowFunction(projected) && !ts.isFunctionExpression(projected))) {
+        return undefined;
+    }
+    const domain = projected.parameters[0]?.name;
+    if (!domain || !ts.isIdentifier(domain))
+        return undefined;
+    const returns = returnedExpressions(projected);
+    if (returns.length !== 1)
+        return undefined;
+    const object = unwrap(returns[0]);
+    if (!ts.isObjectLiteralExpression(object))
+        return undefined;
+    const id = staticId(propertyExpression(object, 'id'));
+    const selected = propertyExpression(object, 'class');
+    const chain = selected && propertyChain(selected);
+    if (!id || chain?.length !== 3 || chain[0] !== domain.text || chain[1] !== 'classes') {
+        return undefined;
+    }
+    return { id, classKey: chain.slice(1).join('.') };
+}
+function staticRecordMembers(expression) {
+    if (!expression)
+        return undefined;
+    const value = unwrap(expression);
+    if (!ts.isObjectLiteralExpression(value))
+        return undefined;
+    if (value.properties.some((property) => ts.isSpreadAssignment(property) ||
+        ('name' in property && property.name && ts.isComputedPropertyName(property.name)))) {
+        return undefined;
+    }
+    return value.properties.length;
+}
 function composeBuilder(compose) {
     const name = compose.parameters[0]?.name;
     if (!name)
@@ -188,20 +343,24 @@ function composeBuilder(compose) {
                 ? element.propertyName.text
                 : undefined
             : element.name.text;
-        if (source !== 'query' && source !== 'combine')
+        if (source !== 'query' && source !== 'union' && source !== 'combine')
             continue;
         if (bindings[source])
             return undefined;
         bindings[source] = element.name;
     }
-    return bindings.query || bindings.combine ? { owner: compose, ...bindings } : undefined;
+    return bindings.query || bindings.union || bindings.combine
+        ? { owner: compose, ...bindings }
+        : undefined;
 }
 function composeBuilderMethod(expression, builder) {
     const target = unwrap(expression);
     if (builder.root && ts.isPropertyAccessExpression(target)) {
         const root = unwrap(target.expression);
         if (ts.isIdentifier(root) &&
-            (target.name.text === 'query' || target.name.text === 'combine') &&
+            (target.name.text === 'query' ||
+                target.name.text === 'union' ||
+                target.name.text === 'combine') &&
             referencesComposeBinding(root, builder.root, builder.owner)) {
             return target.name.text;
         }
@@ -210,6 +369,8 @@ function composeBuilderMethod(expression, builder) {
         return undefined;
     if (builder.query && referencesComposeBinding(target, builder.query, builder.owner))
         return 'query';
+    if (builder.union && referencesComposeBinding(target, builder.union, builder.owner))
+        return 'union';
     if (builder.combine && referencesComposeBinding(target, builder.combine, builder.owner)) {
         return 'combine';
     }
@@ -320,10 +481,10 @@ function composeReturnEvidence(file, compose, builder) {
     if (!compose.body)
         return [];
     if (!ts.isBlock(compose.body)) {
-        return isBuilderCombineCall(compose.body, builder)
+        return isBuilderClosedPlanCall(compose.body, builder)
             ? []
             : [
-                violation(file, compose.body, 'Composite Query compose does not return the closed plan from combine.'),
+                violation(file, compose.body, 'Composite Query compose does not return the closed plan from combine or union.'),
             ];
     }
     const evidence = [];
@@ -331,8 +492,8 @@ function composeReturnEvidence(file, compose, builder) {
     visitOwnBody(compose, (node) => {
         if (ts.isReturnStatement(node)) {
             returns += 1;
-            if (!node.expression || !isBuilderCombineCall(node.expression, builder)) {
-                evidence.push(violation(file, node, 'Composite Query compose return does not produce the closed plan from combine.'));
+            if (!node.expression || !isBuilderClosedPlanCall(node.expression, builder)) {
+                evidence.push(violation(file, node, 'Composite Query compose return does not produce the closed plan from combine or union.'));
             }
         }
         else if (ts.isThrowStatement(node)) {
@@ -344,9 +505,12 @@ function composeReturnEvidence(file, compose, builder) {
     }
     return evidence;
 }
-function isBuilderCombineCall(expression, builder) {
+function isBuilderClosedPlanCall(expression, builder) {
     const value = unwrap(expression);
-    return ts.isCallExpression(value) && composeBuilderMethod(value.expression, builder) === 'combine';
+    if (!ts.isCallExpression(value))
+        return false;
+    const method = composeBuilderMethod(value.expression, builder);
+    return method === 'combine' || method === 'union';
 }
 function composePlanReachabilityEvidence(file, compose, builder) {
     const authored = new Set();
@@ -360,7 +524,7 @@ function composePlanReachabilityEvidence(file, compose, builder) {
     const roots = [];
     if (!ts.isBlock(compose.body)) {
         const root = unwrap(compose.body);
-        if (ts.isCallExpression(root) && composeBuilderMethod(root.expression, builder) === 'combine') {
+        if (ts.isCallExpression(root) && isBuilderClosedPlanCall(root, builder)) {
             roots.push(root);
         }
     }
@@ -369,8 +533,7 @@ function composePlanReachabilityEvidence(file, compose, builder) {
             if (!ts.isReturnStatement(node) || !node.expression)
                 return;
             const root = unwrap(node.expression);
-            if (ts.isCallExpression(root) &&
-                composeBuilderMethod(root.expression, builder) === 'combine') {
+            if (ts.isCallExpression(root) && isBuilderClosedPlanCall(root, builder)) {
                 roots.push(root);
             }
         });
@@ -937,6 +1100,7 @@ function writeTargetReferencesBuilder(node, builder) {
 function isComposeBuilderReference(reference, builder) {
     return Boolean((builder.root && referencesComposeBinding(reference, builder.root, builder.owner)) ||
         (builder.query && referencesComposeBinding(reference, builder.query, builder.owner)) ||
+        (builder.union && referencesComposeBinding(reference, builder.union, builder.owner)) ||
         (builder.combine && referencesComposeBinding(reference, builder.combine, builder.owner)));
 }
 function statementShadowsComposeBinding(statement, name, scope, owner) {

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

@@ -21,7 +21,7 @@ export declare function memberCalls(file: SourceFile, importedName: string, memb
 export declare function definitionObjects(file: SourceFile, importedName: string, member?: string, modules?: Set<string>, argumentIndex?: number): DefinitionObject[];
 export declare function definitionOriginAmbiguity(file: SourceFile, definition: DefinitionObject, name: string): SourceRuleEvidence | undefined;
 /** Prove the clean curried Domain projector shape for Query and Mutation recipes. */
-export declare function domainProjectorEvidence(file: SourceFile, importedName: 'defineCompositeQuery' | 'defineMutation' | 'defineQuery', label: string): SourceRuleEvidence[];
+export declare function domainProjectorEvidence(file: SourceFile, importedName: 'defineCollectionQuery' | 'defineCompositeQuery' | 'defineMutation' | 'defineQuery', label: string): SourceRuleEvidence[];
 export declare function violation(file: SourceFile, node: ts.Node, evidence: string): SourceRuleEvidence;
 export declare function ambiguity(file: SourceFile, node: ts.Node, evidence: string): SourceRuleEvidence;
 export declare function localTarget(project: SourceProject, file: SourceFile, sourceImport: SourceImport): SourceFile | undefined;

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

@@ -15,7 +15,12 @@ export const DSL_MODULES = new Set([
     '@astrale-os/kernel-dsl/v1',
     '@astrale-os/kernel-core',
 ]);
-const DOMAIN_BOUND_DEFINITIONS = new Set(['defineCompositeQuery', 'defineMutation', 'defineQuery']);
+const DOMAIN_BOUND_DEFINITIONS = new Set([
+    'defineCollectionQuery',
+    'defineCompositeQuery',
+    'defineMutation',
+    'defineQuery',
+]);
 export function production(project, layer) {
     return project.files.filter((file) => file.role === 'production' && (layer === undefined || file.layer === layer));
 }

package/dist/tooling/linter/policy/generated.d.ts

@@ -1,4 +1,4 @@
 import type { DomainPolicySource } from './index.js';
-/** Generated from the validated Domain knowledge catalog. Do not edit by hand. */
+/** Generated from the validated Domain knowledge catalog. Regenerate with pnpm sync:linter-policy. */
 export declare const domainPolicyDigest: string;
 export declare const domainPolicySource: DomainPolicySource;