@astrale-os/kernel-core 0.9.0-beta.7 → 0.9.0-beta.9

package/dist/graph/query/language/codec.js

@@ -1,6 +1,6 @@
 import { patterns, PropertyKey } from '@astrale-os/kernel-dsl/v1/addressing';
+import { ClassKey } from '@astrale-os/kernel-dsl/v1/addressing';
 import * as portable from '@astrale-os/kernel-dsl/value';
-import { ClassPath } from '../../class/index.js';
 import { LocalBinding } from '../../graph/index.js';
 import { NodeId } from '../../node/index.js';
 import { NodePath } from '../../path/index.js';
@@ -54,8 +54,8 @@ function decodeSource(input, symbols) {
             binding: introduce(input.binding, 'node', '/source/binding', symbols),
         });
     }
-    if (terms.some((term) => term.kind !== 'definition')) {
-        invalid('/source/terms', 'Edge source accepts Definition terms only');
+    if (terms.some((term) => term.kind !== 'class')) {
+        invalid('/source/terms', 'Edge source accepts Class terms only');
     }
     return Object.freeze({
         kind: 'edge',
@@ -115,8 +115,8 @@ function decodeSourceTerm(input, path) {
         }
     }
     return Object.freeze({
-        kind: 'definition',
-        definition: decodeDefinition(input.definition, `${path}/definition`),
+        kind: 'class',
+        class: decodeClass(input.class, `${path}/class`),
     });
 }
 function decodeStep(input, index, symbols) {
@@ -127,7 +127,7 @@ function decodeStep(input, index, symbols) {
         if (kind === undefined)
             invalid(`${path}/binding`, 'Unknown binding');
         const predicate = decodePredicate(input.predicate, `${path}/predicate`, kind);
-        if (predicate.kind === 'definition.satisfies') {
+        if (predicate.kind === 'class.satisfies' || predicate.kind === 'class.equal') {
             return Object.freeze({
                 op: 'filter',
                 binding,
@@ -141,8 +141,8 @@ function decodeStep(input, index, symbols) {
         });
     }
     const from = reference(input.from, 'node', `${path}/from`, symbols);
-    const via = input.via.map((definition, definitionIndex) => decodeDefinition(definition, `${path}/via/${definitionIndex}`));
-    uniqueBy(via, definitionKey, `${path}/via`, 'Definition reference');
+    const via = input.via.map((classRef, classIndex) => decodeClass(classRef, `${path}/via/${classIndex}`));
+    uniqueBy(via, classKey, `${path}/via`, 'Class reference');
     const edge = introduce(input.bindings.edge, 'edge', `${path}/bindings/edge`, symbols);
     const node = introduce(input.bindings.node, 'node', `${path}/bindings/node`, symbols);
     if (symbols.size > QUERY_AST_LIMITS.bindings) {
@@ -157,10 +157,10 @@ function decodeStep(input, index, symbols) {
     });
 }
 function decodePredicate(input, path, binding) {
-    if (input.kind === 'definition.satisfies') {
+    if (input.kind === 'class.satisfies' || input.kind === 'class.equal') {
         return Object.freeze({
-            kind: 'definition.satisfies',
-            definition: decodeDefinition(input.definition, `${path}/definition`),
+            kind: input.kind,
+            class: decodeClass(input.class, `${path}/class`),
         });
     }
     if (input.kind === 'identity.equal') {
@@ -182,7 +182,7 @@ function decodePredicate(input, path, binding) {
             const identity = Object.freeze({
                 source: NodeId(input.identity.source),
                 target: NodeId(input.identity.target),
-                class: ClassPath.parse(input.identity.class),
+                class: ClassKey(input.identity.class),
             });
             return Object.freeze({ kind: 'identity.equal', identity });
         }
@@ -200,8 +200,8 @@ function decodePredicate(input, path, binding) {
         value: canonicalValue(input.value, `${path}/value`),
     });
 }
-function definitionKey(definition) {
-    return `${definition.origin}\0${definition.kind}\0${definition.name}`;
+function classKey(classRef) {
+    return `${classRef.origin}\0${classRef.name}`;
 }
 function decodeProperty(input, path) {
     try {
@@ -226,13 +226,13 @@ function freezeValue(input) {
         freezeValue(value);
     return Object.freeze(input);
 }
-function decodeDefinition(input, path) {
+function decodeClass(input, path) {
     if (!patterns.origin.test(input.origin))
         invalid(`${path}/origin`, 'Invalid Domain origin');
     if (!patterns.memberName.test(input.name)) {
-        invalid(`${path}/name`, 'Invalid Definition name');
+        invalid(`${path}/name`, 'Invalid Class name');
     }
-    return Object.freeze({ origin: input.origin, kind: input.kind, name: input.name });
+    return Object.freeze({ origin: input.origin, kind: 'class', name: input.name });
 }
 function introduce(input, kind, path, symbols) {
     let name;
@@ -264,9 +264,7 @@ function reference(input, expected, path, symbols) {
     return name;
 }
 function sourceTermKey(term) {
-    return term.kind === 'path'
-        ? `path\0${term.path}`
-        : `definition\0${definitionKey(term.definition)}`;
+    return term.kind === 'path' ? `path\0${term.path}` : `class\0${classKey(term.class)}`;
 }
 function uniqueBy(values, keyOf, path, label) {
     const seen = new Set();
@@ -283,4 +281,3 @@ function invalid(path, message, cause) {
 function errorPointer(error) {
     return error instanceof portable.BoundaryError ? error.pointer : '';
 }
-//# sourceMappingURL=codec.js.map

package/dist/graph/query/language/error.d.ts

@@ -3,4 +3,3 @@ export declare class QueryASTDecodeError extends TypeError {
     readonly code: 'QUERY_AST_INVALID';
     constructor(path: string, message: string, options?: ErrorOptions);
 }
-//# sourceMappingURL=error.d.ts.map

package/dist/graph/query/language/error.js

@@ -7,4 +7,3 @@ export class QueryASTDecodeError extends TypeError {
         this.name = 'QueryASTDecodeError';
     }
 }
-//# sourceMappingURL=error.js.map

package/dist/graph/query/language/fingerprint.d.ts

@@ -2,4 +2,3 @@ import type { QueryFingerprint } from './model.js';
 import type { QueryAST } from './query-ast.js';
 /** Derive Query V6 semantic identity, erasing authored set order and alpha-renaming only. */
 export declare function fingerprintQueryAST(input: QueryAST): QueryFingerprint;
-//# sourceMappingURL=fingerprint.d.ts.map

package/dist/graph/query/language/fingerprint.js

@@ -33,7 +33,7 @@ export function fingerprintQueryAST(input) {
         const value = {
             op: 'expand',
             from: requireSlot(slots, step.from),
-            via: [...step.via].map(definitionValue).sort(comparePortableValues),
+            via: [...step.via].map(classValue).sort(comparePortableValues),
             direction: step.direction,
             bindings: { edge, node },
         };
@@ -110,14 +110,14 @@ function requireSlot(slots, binding) {
 function sourceTermValue(term) {
     return (term.kind === 'path'
         ? { kind: 'path', path: term.path }
-        : { kind: 'definition', definition: definitionValue(term.definition) });
+        : { kind: 'class', class: classValue(term.class) });
 }
-function definitionValue(definition) {
-    return { origin: definition.origin, kind: definition.kind, name: definition.name };
+function classValue(classRef) {
+    return { origin: classRef.origin, kind: 'class', name: classRef.name };
 }
 function predicateValue(predicate) {
-    if (predicate.kind === 'definition.satisfies') {
-        return { kind: predicate.kind, definition: definitionValue(predicate.definition) };
+    if (predicate.kind === 'class.satisfies' || predicate.kind === 'class.equal') {
+        return { kind: predicate.kind, class: classValue(predicate.class) };
     }
     if (predicate.kind === 'property.present') {
         return { kind: predicate.kind, property: predicate.property };
@@ -148,4 +148,3 @@ function compareBytes(left, right) {
     }
     return Math.sign(left.length - right.length);
 }
-//# sourceMappingURL=fingerprint.js.map

package/dist/graph/query/language/index.d.ts

@@ -2,6 +2,5 @@ export type * from './model.js';
 export { QueryASTDecodeError } from './error.js';
 export { decodeQueryAST, encodeQueryAST } from './codec.js';
 export { fingerprintQueryAST } from './fingerprint.js';
-export { QueryAST, type QueryEdgeAST, type QueryNodeAST } from './query-ast.js';
+export { QueryAST, type QueryEdgeAST, type QueryNodeAST, type QuerySingleSourceClassOf, type QuerySourceProvenance, type QuerySourceClassesOf, } from './query-ast.js';
 export { queryAstSchema } from './wire.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/graph/query/language/index.js

@@ -1,6 +1,5 @@
 export { QueryASTDecodeError } from './error.js';
 export { decodeQueryAST, encodeQueryAST } from './codec.js';
 export { fingerprintQueryAST } from './fingerprint.js';
-export { QueryAST } from './query-ast.js';
+export { QueryAST, } from './query-ast.js';
 export { queryAstSchema } from './wire.js';
-//# sourceMappingURL=index.js.map

package/dist/graph/query/language/model.d.ts

@@ -1,4 +1,4 @@
-import type { PropertyKey, schema } from '@astrale-os/kernel-dsl/v1';
+import type { ClassRef, PropertyKey } from '@astrale-os/kernel-dsl/v1';
 import type * as portable from '@astrale-os/kernel-dsl/value';
 import type { EdgeKey } from '../../edge/index.js';
 import type { LocalBinding } from '../../graph/index.js';
@@ -9,7 +9,7 @@ export declare const QUERY_AST_VERSION: 'v6';
 export type QueryStructuralLimits = Readonly<{
     sourceTerms: 1024;
     steps: 256;
-    expansionDefinitionsPerStep: 256;
+    expansionClassesPerStep: 256;
     bindings: 513;
 }>;
 export declare const QUERY_AST_LIMITS: QueryStructuralLimits;
@@ -27,17 +27,16 @@ export type EdgeBinding = LocalBinding & {
     readonly [EDGE_BINDING]: true;
 };
 export type QueryBinding = NodeBinding | EdgeBinding;
-export type QueryDefinitionRef = schema.DefinitionRef;
 export interface QueryPathSourceTerm {
     readonly kind: 'path';
     readonly path: NodePath;
 }
-export interface QueryDefinitionSourceTerm {
-    readonly kind: 'definition';
-    readonly definition: QueryDefinitionRef;
+export interface QueryClassSourceTerm {
+    readonly kind: 'class';
+    readonly class: ClassRef;
 }
-export type QueryNodeSourceTerm = QueryPathSourceTerm | QueryDefinitionSourceTerm;
-export type QueryEdgeSourceTerm = QueryDefinitionSourceTerm;
+export type QueryNodeSourceTerm = QueryPathSourceTerm | QueryClassSourceTerm;
+export type QueryEdgeSourceTerm = QueryClassSourceTerm;
 export interface QueryNodeSource {
     readonly kind: 'node';
     readonly terms: NonEmpty<QueryNodeSourceTerm>;
@@ -53,16 +52,21 @@ export interface QueryEdgeSource {
     };
 }
 export type QuerySource = QueryNodeSource | QueryEdgeSource;
-export interface QueryDefinitionFilter {
+export interface QueryClassFilter {
     readonly op: 'filter';
     readonly binding: QueryBinding;
-    readonly predicate: QueryDefinitionPredicate;
+    readonly predicate: QueryClassPredicate;
 }
-export interface QueryDefinitionPredicate {
-    readonly kind: 'definition.satisfies';
-    readonly definition: QueryDefinitionRef;
+export interface QueryClassSatisfiesPredicate {
+    readonly kind: 'class.satisfies';
+    readonly class: ClassRef;
+}
+export interface QueryClassEqualPredicate {
+    readonly kind: 'class.equal';
+    readonly class: ClassRef;
 }
 export type QuerySourceTerm = QueryNodeSourceTerm | QueryEdgeSourceTerm;
+export type QueryClassPredicate = QueryClassSatisfiesPredicate | QueryClassEqualPredicate;
 export interface QueryPropertyEqualPredicate {
     readonly kind: 'property.equal';
     readonly property: PropertyKey;
@@ -82,7 +86,7 @@ export interface QueryEdgeIdentityPredicate {
     readonly identity: EdgeKey;
 }
 export type QueryIdentityPredicate = QueryNodeIdentityPredicate | QueryEdgeIdentityPredicate;
-export type QueryPredicate = QueryDefinitionPredicate | QueryPropertyPredicate | QueryIdentityPredicate;
+export type QueryPredicate = QueryClassPredicate | QueryPropertyPredicate | QueryIdentityPredicate;
 export interface QueryPropertyFilter {
     readonly op: 'filter';
     readonly binding: QueryBinding;
@@ -100,14 +104,14 @@ export type QueryIdentityFilter = {
 export interface QueryExpand {
     readonly op: 'expand';
     readonly from: NodeBinding;
-    readonly via: NonEmpty<QueryDefinitionRef>;
+    readonly via: NonEmpty<ClassRef>;
     readonly direction: QueryDirection;
     readonly bindings: {
         readonly edge: EdgeBinding;
         readonly node: NodeBinding;
     };
 }
-export type QueryStep = QueryDefinitionFilter | QueryPropertyFilter | QueryIdentityFilter | QueryExpand;
+export type QueryStep = QueryClassFilter | QueryPropertyFilter | QueryIdentityFilter | QueryExpand;
 export interface QueryGraphSelect<Binding extends QueryBinding = QueryBinding> {
     readonly kind: 'graph';
     readonly binding: Binding;
@@ -145,4 +149,3 @@ export type QuerySelect = QueryGraphSelect<NodeBinding> | QueryGraphSelect<EdgeB
 export type QueryNodeTerminalSelect = QueryGraphSelect<NodeBinding> | QueryNodeSelect;
 export type QueryEdgeTerminalSelect = QueryGraphSelect<EdgeBinding> | QueryEdgeSelect;
 export {};
-//# sourceMappingURL=model.d.ts.map

package/dist/graph/query/language/model.js

@@ -3,7 +3,6 @@ export const QUERY_AST_VERSION = 'v6';
 export const QUERY_AST_LIMITS = Object.freeze({
     sourceTerms: 1024,
     steps: 256,
-    expansionDefinitionsPerStep: 256,
+    expansionClassesPerStep: 256,
     bindings: 513,
 });
-//# sourceMappingURL=model.js.map

package/dist/graph/query/language/query-ast.d.ts

@@ -1,12 +1,23 @@
 import type { QueryEdgeTerminalSelect, QueryFingerprint, QueryNodeTerminalSelect, QuerySelect, QuerySource, QueryStep, QueryStructuralLimits } from './model.js';
 import { QUERY_AST_FORMAT, QUERY_AST_VERSION } from './model.js';
-export type QueryAST<Select extends QuerySelect = QuerySelect> = {
+declare const QUERY_SOURCE_PROVENANCE: unique symbol;
+/** Type-only authoring provenance retained until Query serialization. */
+export interface QuerySourceProvenance<Classes extends readonly unknown[] = readonly unknown[], ExactNodes extends readonly unknown[] = readonly unknown[]> {
+    readonly classes: Classes;
+    readonly exactNodes: ExactNodes;
+}
+export type QueryAST<Select extends QuerySelect = QuerySelect, SourceClasses = unknown> = {
     readonly format: typeof QUERY_AST_FORMAT;
     readonly version: typeof QUERY_AST_VERSION;
     readonly source: QuerySource;
     readonly steps: readonly QueryStep[];
     readonly select: Select;
+    /** Type-only authoring provenance. It is never encoded into a Query V6 document. */
+    readonly [QUERY_SOURCE_PROVENANCE]?: SourceClasses;
 };
+export type QuerySourceClassesOf<Query> = Query extends QueryAST<QuerySelect, infer Provenance> ? Provenance extends QuerySourceProvenance<infer Classes> ? Classes[number] : Provenance : never;
+/** The selected Class only when authoring proves one Class term and no exact-Node terms. */
+export type QuerySingleSourceClassOf<Query> = Query extends QueryAST<QuerySelect, infer Provenance> ? Provenance extends QuerySourceProvenance<infer Classes, infer ExactNodes> ? Classes extends readonly [infer Class] ? ExactNodes extends readonly [] ? Class : never : never : never : never;
 export type QueryNodeAST = QueryAST<QueryNodeTerminalSelect>;
 export type QueryEdgeAST = QueryAST<QueryEdgeTerminalSelect>;
 /** Canonical Query language boundary value. */
@@ -14,8 +25,8 @@ export declare const QueryAST: {
     readonly format: 'astrale.graph.query';
     readonly version: 'v6';
     readonly limits: QueryStructuralLimits;
-    decode(input: unknown): QueryAST;
-    encode(input: QueryAST): QueryAST;
+    decode(input: unknown): QueryAST<QuerySelect, never>;
+    encode(input: QueryAST): QueryAST<QuerySelect, never>;
     fingerprint(input: QueryAST): QueryFingerprint;
 };
-//# sourceMappingURL=query-ast.d.ts.map
+export {};

package/dist/graph/query/language/query-ast.js

@@ -10,4 +10,3 @@ export const QueryAST = Object.freeze({
     encode: encodeQueryAST,
     fingerprint: fingerprintQueryAST,
 });
-//# sourceMappingURL=query-ast.js.map

package/dist/graph/query/language/selection.d.ts

@@ -1,4 +1,3 @@
 import type { QueryAST } from './query-ast.js';
 /** Resolve the Node or Edge kind of the terminal binding in an admitted Query. */
 export declare function querySelectionKind(query: QueryAST): 'node' | 'edge';
-//# sourceMappingURL=selection.d.ts.map

package/dist/graph/query/language/selection.js

@@ -26,4 +26,3 @@ export function querySelectionKind(query) {
     }
     throw new TypeError('Admitted Query selected an unknown binding.');
 }
-//# sourceMappingURL=selection.js.map

package/dist/graph/query/language/wire.d.ts

@@ -9,13 +9,10 @@ export declare const queryAstSchema: z.ZodObject<{
             kind: z.ZodLiteral<"path">;
             path: z.ZodString;
         }, z.core.$strict>, z.ZodObject<{
-            kind: z.ZodLiteral<"definition">;
-            definition: z.ZodObject<{
+            kind: z.ZodLiteral<"class">;
+            class: z.ZodObject<{
                 origin: z.ZodString;
-                kind: z.ZodEnum<{
-                    class: "class";
-                    interface: "interface";
-                }>;
+                kind: z.ZodLiteral<"class">;
                 name: z.ZodString;
             }, z.core.$strict>;
         }, z.core.$strict>], "kind">>;
@@ -23,13 +20,10 @@ export declare const queryAstSchema: z.ZodObject<{
     }, z.core.$strict>, z.ZodObject<{
         kind: z.ZodLiteral<"edge">;
         terms: z.ZodArray<z.ZodObject<{
-            kind: z.ZodLiteral<"definition">;
-            definition: z.ZodObject<{
+            kind: z.ZodLiteral<"class">;
+            class: z.ZodObject<{
                 origin: z.ZodString;
-                kind: z.ZodEnum<{
-                    class: "class";
-                    interface: "interface";
-                }>;
+                kind: z.ZodLiteral<"class">;
                 name: z.ZodString;
             }, z.core.$strict>;
         }, z.core.$strict>>;
@@ -43,13 +37,17 @@ export declare const queryAstSchema: z.ZodObject<{
         op: z.ZodLiteral<"filter">;
         binding: z.ZodString;
         predicate: z.ZodDiscriminatedUnion<[z.ZodObject<{
-            kind: z.ZodLiteral<"definition.satisfies">;
-            definition: z.ZodObject<{
+            kind: z.ZodLiteral<"class.satisfies">;
+            class: z.ZodObject<{
                 origin: z.ZodString;
-                kind: z.ZodEnum<{
-                    class: "class";
-                    interface: "interface";
-                }>;
+                kind: z.ZodLiteral<"class">;
+                name: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"class.equal">;
+            class: z.ZodObject<{
+                origin: z.ZodString;
+                kind: z.ZodLiteral<"class">;
                 name: z.ZodString;
             }, z.core.$strict>;
         }, z.core.$strict>, z.ZodObject<{
@@ -72,10 +70,7 @@ export declare const queryAstSchema: z.ZodObject<{
         from: z.ZodString;
         via: z.ZodArray<z.ZodObject<{
             origin: z.ZodString;
-            kind: z.ZodEnum<{
-                class: "class";
-                interface: "interface";
-            }>;
+            kind: z.ZodLiteral<"class">;
             name: z.ZodString;
         }, z.core.$strict>>;
         direction: z.ZodEnum<{
@@ -152,4 +147,3 @@ export declare const queryAstSchema: z.ZodObject<{
         }, z.core.$strict>>;
     }, z.core.$strict>], "kind">;
 }, z.core.$strict>;
-//# sourceMappingURL=wire.d.ts.map

package/dist/graph/query/language/wire.js

@@ -2,16 +2,16 @@ import { z } from 'zod';
 import { QUERY_AST_FORMAT, QUERY_AST_LIMITS, QUERY_AST_VERSION } from './model.js';
 const text = z.string().min(1);
 const binding = text.max(64);
-const definition = z.strictObject({
+const classRef = z.strictObject({
     origin: text.max(253),
-    kind: z.enum(['class', 'interface']),
+    kind: z.literal('class'),
     name: text,
 });
 const nodeSourceTerm = z.discriminatedUnion('kind', [
     z.strictObject({ kind: z.literal('path'), path: text }),
-    z.strictObject({ kind: z.literal('definition'), definition }),
+    z.strictObject({ kind: z.literal('class'), class: classRef }),
 ]);
-const definitionSourceTerm = z.strictObject({ kind: z.literal('definition'), definition });
+const classSourceTerm = z.strictObject({ kind: z.literal('class'), class: classRef });
 const source = z.discriminatedUnion('kind', [
     z.strictObject({
         kind: z.literal('node'),
@@ -20,12 +20,13 @@ const source = z.discriminatedUnion('kind', [
     }),
     z.strictObject({
         kind: z.literal('edge'),
-        terms: z.array(definitionSourceTerm).min(1).max(QUERY_AST_LIMITS.sourceTerms),
+        terms: z.array(classSourceTerm).min(1).max(QUERY_AST_LIMITS.sourceTerms),
         bindings: z.strictObject({ source: binding, edge: binding, target: binding }),
     }),
 ]);
 const predicate = z.discriminatedUnion('kind', [
-    z.strictObject({ kind: z.literal('definition.satisfies'), definition }),
+    z.strictObject({ kind: z.literal('class.satisfies'), class: classRef }),
+    z.strictObject({ kind: z.literal('class.equal'), class: classRef }),
     z.strictObject({ kind: z.literal('property.equal'), property: text, value: z.unknown() }),
     z.strictObject({ kind: z.literal('property.present'), property: text }),
     z.strictObject({
@@ -37,7 +38,7 @@ const filter = z.strictObject({ op: z.literal('filter'), binding, predicate });
 const expand = z.strictObject({
     op: z.literal('expand'),
     from: binding,
-    via: z.array(definition).min(1).max(QUERY_AST_LIMITS.expansionDefinitionsPerStep),
+    via: z.array(classRef).min(1).max(QUERY_AST_LIMITS.expansionClassesPerStep),
     direction: z.enum(['outgoing', 'incoming', 'incident']),
     bindings: z.strictObject({ edge: binding, node: binding }),
 });
@@ -76,4 +77,3 @@ export const queryAstSchema = z.strictObject({
     steps: z.array(z.discriminatedUnion('op', [filter, expand])).max(QUERY_AST_LIMITS.steps),
     select: z.discriminatedUnion('kind', [graphSelect, nodeSelect, edgeSelect]),
 });
-//# sourceMappingURL=wire.js.map

package/dist/graph/query/reference/error.d.ts

@@ -3,4 +3,3 @@ export declare class QueryReferenceError extends TypeError {
     readonly code: 'QUERY_REFERENCE_INVALID';
     constructor(path: string, message: string, options?: ErrorOptions);
 }
-//# sourceMappingURL=error.d.ts.map

package/dist/graph/query/reference/error.js

@@ -7,4 +7,3 @@ export class QueryReferenceError extends TypeError {
         this.name = 'QueryReferenceError';
     }
 }
-//# sourceMappingURL=error.js.map

package/dist/graph/query/reference/evaluate.d.ts

@@ -1,32 +1,34 @@
-import type { schema } from '@astrale-os/kernel-dsl/v1';
+import type { ClassRef } from '@astrale-os/kernel-dsl/v1';
+import type { ClassKey } from '@astrale-os/kernel-dsl/v1/addressing';
+import type { OrderingKind } from '@astrale-os/kernel-dsl/v1/language';
+import type { EdgeOrientation } from '@astrale-os/kernel-dsl/v1/language';
 import { type PropertyKey as PropertyKeyValue } from '@astrale-os/kernel-dsl/v1/addressing';
-import type { ClassPath } from '../../class/index.js';
 import type { Edge, EdgeKey } from '../../edge/index.js';
-import type { EdgeOrientation, GraphData as GraphDataValue } from '../../graph/index.js';
+import type { GraphData as GraphDataValue } from '../../graph/index.js';
 import type { Node, NodeId } from '../../node/index.js';
 import type { NodePath } from '../../path/index.js';
-import type { QueryAST, QueryDefinitionRef } from '../language/index.js';
+import type { QueryAST } from '../language/index.js';
 import type { QueryResult as QueryResultValue } from '../result/index.js';
 export interface QueryReferencePathWitness {
     readonly result: NodeId;
     readonly nodes: readonly NodeId[];
     readonly edges: readonly EdgeKey[];
 }
-export interface QueryReferenceDefinition {
-    readonly family: 'node' | 'edge' | 'both';
-    readonly classes: readonly ClassPath[];
+export interface QueryReferenceClassClosure {
+    readonly kind: 'node' | 'edge';
+    readonly classes: readonly ClassKey[];
 }
 export interface QueryReferenceProperty {
-    readonly nodes: readonly ClassPath[];
-    readonly edges: readonly ClassPath[];
-    readonly ordering?: schema.values.OrderingKind;
+    readonly nodes: readonly ClassKey[];
+    readonly edges: readonly ClassKey[];
+    readonly ordering?: OrderingKind;
 }
 export interface QueryReferenceContext {
     readonly graph: GraphDataValue;
     resolve(path: NodePath): readonly QueryReferencePathWitness[];
-    closeDefinition(definition: QueryDefinitionRef): QueryReferenceDefinition | undefined;
+    closeClass(classRef: ClassRef): QueryReferenceClassClosure | undefined;
     closeProperty(property: PropertyKeyValue): QueryReferenceProperty | undefined;
-    orientation(edge: ClassPath): EdgeOrientation | undefined;
+    orientation(edge: ClassKey): EdgeOrientation | undefined;
     traverseNode(node: Node): boolean;
     traverseEdge(edge: Edge): boolean;
     readNode(node: Node): boolean;
@@ -65,4 +67,3 @@ export interface QueryReferenceTrace {
 export declare const QueryReference: {
     evaluate(input: QueryAST, context: QueryReferenceContext, options: QueryReferenceOptions): QueryReferenceEvaluation;
 };
-//# sourceMappingURL=evaluate.d.ts.map