@astrale-os/kernel-core 0.9.0-beta.6 → 0.9.0-beta.61

package/dist/graph/properties/value/index.d.ts

@@ -1,17 +1,12 @@
-import { PropertyKey } from '@astrale-os/kernel-dsl/v1/addressing';
-import * as portable from '@astrale-os/kernel-dsl/value';
-declare const PROPERTIES_BRAND: unique symbol;
+import type { PropertyKey } from '@astrale-os/kernel-dsl/v1/addressing';
+import type { PropertyValues } from '@astrale-os/kernel-dsl/v1/language';
+import type { Value } from '@astrale-os/kernel-dsl/value';
 /** Untrusted structural representation accepted at a Properties boundary. */
-export type PropertiesInput = Readonly<Record<PropertyKey, portable.Value>>;
-/** Complete immutable canonical graph Property values keyed by their declaring Property identity. */
-export type Properties = PropertiesInput & {
-    readonly [PROPERTIES_BRAND]: true;
-};
-/** Validate, detach, deterministically order, and deeply freeze a Property map. */
-export declare function normalizeProperties(input: unknown, pointer?: string): Properties;
-/** Construct canonical Properties from already-admitted canonical entries. */
-export declare function createProperties(entries: Iterable<readonly [PropertyKey, portable.Value]>): Properties;
+export type PropertiesInput = Readonly<Record<PropertyKey, Value>>;
+/** Core uses the one DSL-owned canonical Property map; no parallel brand exists. */
+export type Properties = PropertyValues;
+export declare const normalizeProperties: (input: unknown, pointer?: string) => Properties;
+/** Trusted sibling constructor over already-admitted exact Property entries. */
+export declare const createProperties: (entries: Iterable<readonly [PropertyKey, Value]>) => Properties;
 /** Compare complete Property maps by canonical portable-value meaning. */
 export declare function equal(left: Properties, right: Properties): boolean;
-export {};
-//# sourceMappingURL=index.d.ts.map

package/dist/graph/properties/value/index.js

@@ -1,29 +1,8 @@
-import { PropertyKey } from '@astrale-os/kernel-dsl/v1/addressing';
-import * as portable from '@astrale-os/kernel-dsl/value';
-/** Validate, detach, deterministically order, and deeply freeze a Property map. */
-export function normalizeProperties(input, pointer = '') {
-    const admitted = portable.accept(input);
-    if (admitted === null || typeof admitted !== 'object' || Array.isArray(admitted)) {
-        throw new TypeError(`Expected Properties object at ${pointer || '/'}.`);
-    }
-    const object = admitted;
-    const entries = [];
-    for (const key of Object.keys(object)) {
-        if (!PropertyKey.is(key)) {
-            throw new TypeError(`Invalid PropertyKey ${JSON.stringify(key)} at ${pointer || '/'}.`);
-        }
-        entries.push([PropertyKey(key), freezeJson(object[key])]);
-    }
-    return createProperties(entries);
-}
-/** Construct canonical Properties from already-admitted canonical entries. */
-export function createProperties(entries) {
-    const properties = Object.create(null);
-    for (const [key, value] of [...entries].sort(([left], [right]) => compare(left, right))) {
-        Object.defineProperty(properties, key, { enumerable: true, value });
-    }
-    return Object.freeze(properties);
-}
+import { PropertyValues as PropertyValuesValue } from '@astrale-os/kernel-dsl/v1/language';
+import { equal as equalValue } from '@astrale-os/kernel-dsl/value';
+export const normalizeProperties = PropertyValuesValue.accept;
+/** Trusted sibling constructor over already-admitted exact Property entries. */
+export const createProperties = PropertyValuesValue.create;
 /** Compare complete Property maps by canonical portable-value meaning. */
 export function equal(left, right) {
     if (left === right)
@@ -31,16 +10,5 @@ export function equal(left, right) {
     const leftKeys = Object.keys(left);
     const rightKeys = Object.keys(right);
     return (leftKeys.length === rightKeys.length &&
-        leftKeys.every((key, index) => key === rightKeys[index] && portable.equal(left[PropertyKey(key)], right[PropertyKey(key)])));
-}
-function freezeJson(value) {
-    if (value === null || typeof value !== 'object')
-        return value;
-    for (const member of Object.values(value))
-        freezeJson(member);
-    return Object.freeze(value);
-}
-function compare(left, right) {
-    return left < right ? -1 : left > right ? 1 : 0;
+        leftKeys.every((key, index) => key === rightKeys[index] && equalValue(left[key], right[key])));
 }
-//# sourceMappingURL=index.js.map

package/dist/graph/query/authoring/builder.d.ts

@@ -1,50 +1,63 @@
 import { type PropertyKey as PropertyKeyValue } from '@astrale-os/kernel-dsl/v1/addressing';
-import type { EdgeBinding, NodeBinding, QueryAST, QueryEdgeProjection, QueryEdgeSelect, QueryGraphSelect, QueryNodeProjection, QueryNodeSelect } from '../language/index.js';
-import type { QueryCurrentNodeExpandInput, QueryCurrentNodeFilterInput, QueryEdgeGraphSelectInput, QueryEdgeSelectInput, QueryEdgeSourceInput, QueryExpandInput, QueryFilterInput, QueryNodeGraphSelectInput, QueryNodeSourceInput, QueryNodeSelectInput, QueryPropertyPredicateBuilder, QuerySourceInput } from './model.js';
-export interface NodeQueryBuilder {
+import type { EdgeBinding, NodeBinding, QueryAST, QueryEdgeProjection, QueryEdgeSelect, QueryGraphSelect, QueryNodeProjection, QueryNodeSelect, QuerySourceProvenance } from '../language/index.js';
+import type { QueryCurrentNodeExpandInput, QueryCurrentNodeFilterInput, QueryClassInput, QueryEdgeGraphSelectInput, QueryEdgeSelectInput, QueryEdgeSourceInput, QueryExpandInput, QueryFilterInput, QueryNodeGraphSelectInput, QueryNodeSourceInput, QueryNodeSelectInput, QueryPropertyPredicateBuilder, QuerySourceInput } from './model.js';
+type ClassInputsOf<Inputs extends readonly unknown[]> = Inputs extends readonly [
+    infer Head,
+    ...infer Tail
+] ? Head extends QueryClassInput ? readonly [Head, ...ClassInputsOf<Tail>] : ClassInputsOf<Tail> : readonly [];
+type ExactNodeInputsOf<Inputs extends readonly unknown[]> = Inputs extends readonly [
+    infer Head,
+    ...infer Tail
+] ? Head extends QueryClassInput ? ExactNodeInputsOf<Tail> : readonly [Head, ...ExactNodeInputsOf<Tail>] : readonly [];
+type SourceClassesOf<Input> = Input extends {
+    readonly nodes: infer Nodes extends readonly unknown[];
+} ? ClassInputsOf<Nodes> extends readonly [] ? never : QuerySourceProvenance<ClassInputsOf<Nodes>, ExactNodeInputsOf<Nodes>> : Input extends {
+    readonly edges: infer Edges extends readonly unknown[];
+} ? QuerySourceProvenance<Edges, readonly []> : never;
+type ExactSourceInput<Input, Shape> = Input & Record<Exclude<keyof Input, keyof Shape>, never>;
+export interface NodeQueryBuilder<SourceClasses = never> {
     readonly node: NodeBinding;
-    filter(input: QueryCurrentNodeFilterInput): NodeQueryBuilder;
+    filter(input: QueryCurrentNodeFilterInput): NodeQueryBuilder<SourceClasses>;
     expand(input: QueryCurrentNodeExpandInput): ExpandedQueryBuilder;
-    select(input: QueryNodeGraphSelectInput): QueryAST<QueryGraphSelect<NodeBinding>>;
-    select<Projection extends QueryNodeProjection>(input: QueryNodeSelectInput<Projection>): QueryAST<QueryNodeSelect<Projection>>;
+    select(input: QueryNodeGraphSelectInput): QueryAST<QueryGraphSelect<NodeBinding>, SourceClasses>;
+    select<Projection extends QueryNodeProjection>(input: QueryNodeSelectInput<Projection>): QueryAST<QueryNodeSelect<Projection>, SourceClasses>;
 }
 export interface ExpandedQueryBuilder {
     readonly node: NodeBinding;
     readonly edge: EdgeBinding;
     filter(input: QueryCurrentNodeFilterInput): ExpandedQueryBuilder;
     expand(input: QueryCurrentNodeExpandInput): ExpandedQueryBuilder;
-    select(input: QueryNodeGraphSelectInput): QueryAST<QueryGraphSelect<NodeBinding>>;
-    select<Projection extends QueryNodeProjection>(input: QueryNodeSelectInput<Projection>): QueryAST<QueryNodeSelect<Projection>>;
-    select(input: QueryEdgeGraphSelectInput): QueryAST<QueryGraphSelect<EdgeBinding>>;
-    select<Projection extends QueryEdgeProjection>(input: QueryEdgeSelectInput<Projection>): QueryAST<QueryEdgeSelect<Projection>>;
+    select(input: QueryNodeGraphSelectInput): QueryAST<QueryGraphSelect<NodeBinding>, never>;
+    select<Projection extends QueryNodeProjection>(input: QueryNodeSelectInput<Projection>): QueryAST<QueryNodeSelect<Projection>, never>;
+    select(input: QueryEdgeGraphSelectInput): QueryAST<QueryGraphSelect<EdgeBinding>, never>;
+    select<Projection extends QueryEdgeProjection>(input: QueryEdgeSelectInput<Projection>): QueryAST<QueryEdgeSelect<Projection>, never>;
 }
-export interface EdgeQueryBuilder {
+export interface EdgeQueryBuilder<SourceClasses = never> {
     readonly source: NodeBinding;
     readonly edge: EdgeBinding;
     readonly target: NodeBinding;
-    filter(input: QueryFilterInput): EdgeQueryBuilder;
+    filter(input: QueryFilterInput): EdgeQueryBuilder<SourceClasses>;
     expand(input: QueryExpandInput): ExpandedQueryBuilder;
     select(input: Omit<QueryNodeGraphSelectInput, 'binding'> & {
         readonly binding: NodeBinding;
-    }): QueryAST<QueryGraphSelect<NodeBinding>>;
+    }): QueryAST<QueryGraphSelect<NodeBinding>, never>;
     select<Projection extends QueryNodeProjection>(input: Omit<QueryNodeSelectInput<Projection>, 'binding'> & {
         readonly binding: NodeBinding;
-    }): QueryAST<QueryNodeSelect<Projection>>;
+    }): QueryAST<QueryNodeSelect<Projection>, never>;
     select(input: Omit<QueryEdgeGraphSelectInput, 'binding'> & {
         readonly binding?: EdgeBinding;
-    }): QueryAST<QueryGraphSelect<EdgeBinding>>;
+    }): QueryAST<QueryGraphSelect<EdgeBinding>, SourceClasses>;
     select<Projection extends QueryEdgeProjection>(input: Omit<QueryEdgeSelectInput<Projection>, 'binding'> & {
         readonly binding?: EdgeBinding;
-    }): QueryAST<QueryEdgeSelect<Projection>>;
+    }): QueryAST<QueryEdgeSelect<Projection>, SourceClasses>;
 }
-interface QueryAPI {
-    from(input: QueryNodeSourceInput): NodeQueryBuilder;
-    from(input: QueryEdgeSourceInput): EdgeQueryBuilder;
-    from(input: QuerySourceInput): NodeQueryBuilder | EdgeQueryBuilder;
+export interface QueryAPI {
+    from<const Input extends QueryNodeSourceInput>(input: ExactSourceInput<Input, QueryNodeSourceInput>): NodeQueryBuilder<SourceClassesOf<Input>>;
+    from<const Input extends QueryEdgeSourceInput>(input: ExactSourceInput<Input, QueryEdgeSourceInput>): EdgeQueryBuilder<SourceClassesOf<Input>>;
+    from(input: QuerySourceInput): NodeQueryBuilder<SourceClassesOf<QuerySourceInput>> | EdgeQueryBuilder<SourceClassesOf<QuerySourceInput>>;
 }
 /** Author one exact Property-predicate leaf without extending the relational Query namespace. */
 export declare function Property(input: PropertyKeyValue): QueryPropertyPredicateBuilder;
 /** Primary persistent Query V6 authoring entry point. */
 export declare const Query: QueryAPI;
 export {};
-//# sourceMappingURL=builder.d.ts.map

package/dist/graph/query/authoring/builder.js

@@ -1,16 +1,24 @@
-import { PropertyKey, } from '@astrale-os/kernel-dsl/v1/addressing';
+import { ClassKey, PropertyKey, } from '@astrale-os/kernel-dsl/v1/addressing';
 import * as portable from '@astrale-os/kernel-dsl/value';
 import { Path } from '../../path/index.js';
 import { QueryAST as QueryASTBoundary, QueryASTDecodeError } from '../language/index.js';
 function from(input) {
     if (!isRecord(input))
         invalid('', 'Query source input must be an object');
-    const kind = input.kind;
-    if (kind === 'node')
+    const hasNodes = Object.hasOwn(input, 'nodes');
+    const hasEdges = Object.hasOwn(input, 'edges');
+    if (hasNodes && hasEdges) {
+        invalid('/source/edges', 'Query source must contain nodes or edges, not both');
+    }
+    if (hasNodes)
         return nodeSource(input);
-    if (kind === 'edge')
+    if (hasEdges)
         return edgeSource(input);
-    invalid('/kind', 'Query source kind must be node or edge');
+    const legacy = ['kind', 'paths', 'classes', 'definitions'].find((key) => Object.hasOwn(input, key));
+    if (legacy !== undefined) {
+        invalid(`/source/${legacy}`, 'Query source contains an unsupported legacy field');
+    }
+    invalid('/source', 'Query source must contain nodes or edges');
 }
 /** Author one exact Property-predicate leaf without extending the relational Query namespace. */
 export function Property(input) {
@@ -37,24 +45,9 @@ export function Property(input) {
 /** Primary persistent Query V6 authoring entry point. */
 export const Query = Object.freeze({ from });
 function nodeSource(input) {
-    exactKeys(input, ['kind', 'paths', 'definitions', 'binding'], '', 'Node source input');
-    const paths = optionalArray(input.paths, '/source/paths');
-    const definitions = optionalArray(input.definitions, '/source/definitions');
-    const terms = [];
-    paths.forEach((path, index) => {
-        try {
-            terms.push(Object.freeze({ kind: 'path', path: Path.from(path).raw }));
-        }
-        catch (cause) {
-            invalid(`/source/paths/${index}`, 'Invalid Path source', cause);
-        }
-    });
-    definitions.forEach((definition, index) => {
-        terms.push(Object.freeze({
-            kind: 'definition',
-            definition: normalizeDefinition(definition, `/source/definitions/${index}`),
-        }));
-    });
+    exactKeys(input, ['nodes', 'binding'], '/source', 'Node source input');
+    const nodes = requiredArray(input.nodes, '/source/nodes', 'Node source');
+    const terms = nodes.map((nodeInput, index) => lowerNodeSource(nodeInput, index));
     const binding = input.binding === undefined ? 'n0' : input.binding;
     const ast = QueryASTBoundary.decode({
         format: QueryASTBoundary.format,
@@ -68,11 +61,11 @@ function nodeSource(input) {
     return nodeBuilder(Object.freeze({ source: ast.source, steps: ast.steps, node: ast.source.binding }));
 }
 function edgeSource(input) {
-    exactKeys(input, ['kind', 'definitions', 'bindings'], '', 'Edge source input');
-    const definitions = optionalArray(input.definitions, '/source/definitions');
-    const terms = definitions.map((definition, index) => Object.freeze({
-        kind: 'definition',
-        definition: normalizeDefinition(definition, `/source/definitions/${index}`),
+    exactKeys(input, ['edges', 'bindings'], '/source', 'Edge source input');
+    const edges = requiredArray(input.edges, '/source/edges', 'Edge source');
+    const terms = edges.map((classInput, index) => Object.freeze({
+        kind: 'class',
+        class: normalizeClass(classInput, 'edge', `/source/edges/${index}`),
     }));
     const used = new Set();
     const bindingsInput = input.bindings;
@@ -156,23 +149,38 @@ function appendFilter(state, input, defaultBinding) {
     if (binding === undefined)
         invalid(`${path}/binding`, 'Filter binding is required');
     let step;
-    if (Object.hasOwn(input, 'satisfies')) {
-        exactKeys(input, ['binding', 'satisfies'], path, 'Definition filter input');
-        step = {
-            op: 'filter',
-            binding,
-            predicate: {
-                kind: 'definition.satisfies',
-                definition: normalizeDefinition(record.satisfies, `${path}/satisfies`),
-            },
-        };
+    if (Object.hasOwn(input, 'class')) {
+        exactKeys(input, ['binding', 'class'], path, 'Class filter input');
+        const targetKind = bindingKind(state, binding);
+        const classInput = record.class;
+        if (isRecord(classInput) && Object.hasOwn(classInput, 'equals')) {
+            exactKeys(classInput, ['equals'], `${path}/class`, 'Exact Class filter input');
+            step = {
+                op: 'filter',
+                binding,
+                predicate: {
+                    kind: 'class.equal',
+                    class: normalizeClass(classInput.equals, targetKind, `${path}/class/equals`),
+                },
+            };
+        }
+        else {
+            step = {
+                op: 'filter',
+                binding,
+                predicate: {
+                    kind: 'class.satisfies',
+                    class: normalizeClass(classInput, targetKind, `${path}/class`),
+                },
+            };
+        }
     }
     else if (Object.hasOwn(input, 'predicate')) {
         exactKeys(input, ['binding', 'predicate'], path, 'Property filter input');
         step = { op: 'filter', binding, predicate: record.predicate };
     }
     else {
-        invalid(path, 'Filter input must contain satisfies or a Property predicate');
+        invalid(path, 'Filter input must contain class or a Property predicate');
     }
     const ast = admitPrefix(state, step);
     return Object.freeze({
@@ -226,7 +234,7 @@ function appendExpand(state, input) {
                 ? invalid(`${path}/from`, 'Expansion from an Edge source requires a Node binding')
                 : state.node
             : input.from,
-        via: optionalArray(input.via, `${path}/via`).map((definition, index) => normalizeDefinition(definition, `${path}/via/${index}`)),
+        via: optionalArray(input.via, `${path}/via`).map((classInput, index) => normalizeClass(classInput, 'edge', `${path}/via/${index}`)),
         direction: input.direction,
         bindings: { edge, node },
     });
@@ -315,6 +323,28 @@ function bindingNames(state) {
     }
     return names;
 }
+function bindingKind(state, binding) {
+    if (state.source.kind === 'node') {
+        if (binding === state.source.binding)
+            return 'node';
+    }
+    else {
+        if (binding === state.source.bindings.source || binding === state.source.bindings.target) {
+            return 'node';
+        }
+        if (binding === state.source.bindings.edge)
+            return 'edge';
+    }
+    for (const step of state.steps) {
+        if (step.op !== 'expand')
+            continue;
+        if (binding === step.bindings.node)
+            return 'node';
+        if (binding === step.bindings.edge)
+            return 'edge';
+    }
+    invalid('/steps/binding', 'Filter binding is unavailable');
+}
 function lowestFree(prefix, used) {
     for (let index = 0; index <= used.size; index++) {
         const candidate = `${prefix}${index}`;
@@ -330,15 +360,54 @@ function optionalArray(input, path) {
         invalid(path, 'Expected an array');
     return input;
 }
-function normalizeDefinition(input, path) {
+function requiredArray(input, path, label) {
+    if (!Array.isArray(input))
+        invalid(path, 'Expected an array');
+    if (input.length === 0)
+        invalid(path, `${label} requires at least one entry`);
+    return input;
+}
+function lowerNodeSource(input, index) {
+    const path = `/source/nodes/${index}`;
+    if (ClassKey.is(input)) {
+        return Object.freeze({ kind: 'class', class: ClassKey.ref(input) });
+    }
+    if (input instanceof Path ||
+        typeof input === 'string' ||
+        (isRecord(input) &&
+            (input.kind === 'core' ||
+                input.kind === 'function' ||
+                input.kind === 'policy' ||
+                input.kind === 'view'))) {
+        try {
+            const target = Path.target(input);
+            return Object.freeze({ kind: 'path', path: target.raw });
+        }
+        catch (cause) {
+            invalid(path, 'Invalid Node target', cause);
+        }
+    }
+    return Object.freeze({ kind: 'class', class: normalizeClass(input, 'node', path) });
+}
+function normalizeClass(input, expectedKind, path) {
+    if (ClassKey.is(input))
+        return ClassKey.ref(input);
     if (!isRecord(input))
-        invalid(path, 'Definition input must be an object');
-    if (typeof input.origin !== 'string' ||
-        (input.kind !== 'class' && input.kind !== 'interface') ||
-        typeof input.name !== 'string') {
-        invalid(path, 'Definition input must contain origin, kind, and name');
+        invalid(path, 'Class input must be an object');
+    const candidate = Object.hasOwn(input, 'ref') ? input.ref : input;
+    if (Object.hasOwn(input, 'ref')) {
+        if (input.kind !== expectedKind) {
+            invalid(`${path}/kind`, `Class input must be a ${expectedKind} Class`);
+        }
+    }
+    if (!isRecord(candidate))
+        invalid(path, 'Class input must contain a structured ref');
+    if (typeof candidate.origin !== 'string' ||
+        candidate.kind !== 'class' ||
+        typeof candidate.name !== 'string') {
+        invalid(`${path}/ref`, 'Class ref must contain origin, kind, and name');
     }
-    return Object.freeze({ origin: input.origin, kind: input.kind, name: input.name });
+    return Object.freeze({ origin: candidate.origin, kind: 'class', name: candidate.name });
 }
 function isRecord(input) {
     return input !== null && typeof input === 'object' && !Array.isArray(input);
@@ -355,4 +424,3 @@ function escapeToken(input) {
 function invalid(path, message, cause) {
     throw new QueryASTDecodeError(path, message, cause === undefined ? undefined : { cause });
 }
-//# sourceMappingURL=builder.js.map

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

@@ -1,4 +1,3 @@
 export { Property, Query } from './builder.js';
-export type { EdgeQueryBuilder, ExpandedQueryBuilder, NodeQueryBuilder } from './builder.js';
+export type { EdgeQueryBuilder, ExpandedQueryBuilder, NodeQueryBuilder, QueryAPI, } from './builder.js';
 export type * from './model.js';
-//# sourceMappingURL=index.d.ts.map

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

@@ -1,2 +1 @@
 export { Property, Query } from './builder.js';
-//# sourceMappingURL=index.js.map

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

@@ -1,22 +1,24 @@
+import type * as dslApi from '@astrale-os/kernel-dsl/v1';
 import type * as portable from '@astrale-os/kernel-dsl/value';
-import type { PathLike } from '../../path/index.js';
-import type { EdgeBinding, NodeBinding, QueryBinding, QueryDefinitionRef, QueryDirection, QueryEdgeIdentityPredicate, QueryEdgeProjection, QueryNodeIdentityPredicate, QueryNodeProjection, QueryPropertyOrder, QueryPropertyPredicate, QueryPropertyEqualPredicate, QueryPropertyPresentPredicate } from '../language/index.js';
+import type { NodeTarget } from '../../path/index.js';
+import type { EdgeBinding, NodeBinding, QueryBinding, QueryDirection, QueryEdgeIdentityPredicate, QueryEdgeProjection, QueryNodeIdentityPredicate, QueryNodeProjection, QueryPropertyOrder, QueryPropertyPredicate, QueryPropertyEqualPredicate, QueryPropertyPresentPredicate } from '../language/index.js';
 type NonEmpty<Value> = readonly [Value, ...Value[]];
-export type QueryDefinitionInput = QueryDefinitionRef;
-export type QueryNodeSourceInput = {
-    readonly kind: 'node';
-    readonly paths: NonEmpty<PathLike>;
-    readonly definitions?: readonly QueryDefinitionInput[];
-    readonly binding?: string;
-} | {
-    readonly kind: 'node';
-    readonly paths?: readonly PathLike[];
-    readonly definitions: NonEmpty<QueryDefinitionInput>;
+export type QueryClassInput<Kind extends 'node' | 'edge' = 'node' | 'edge'> = dslApi.ClassRef | dslApi.ClassKey | Readonly<{
+    readonly ref: dslApi.ClassRef;
+    readonly kind: Kind;
+}>;
+export type QueryNodeClassInput = QueryClassInput<'node'>;
+export type QueryEdgeClassInput = QueryClassInput<'edge'>;
+export type QueryNodeInput = NodeTarget | QueryNodeClassInput;
+export type QueryEdgeInput = QueryEdgeClassInput;
+export interface QueryNodeSourceInput {
+    readonly nodes: NonEmpty<QueryNodeInput>;
+    readonly edges?: never;
     readonly binding?: string;
-};
+}
 export interface QueryEdgeSourceInput {
-    readonly kind: 'edge';
-    readonly definitions: NonEmpty<QueryDefinitionInput>;
+    readonly edges: NonEmpty<QueryEdgeInput>;
+    readonly nodes?: never;
     readonly bindings?: {
         readonly source?: string;
         readonly edge?: string;
@@ -24,9 +26,11 @@ export interface QueryEdgeSourceInput {
     };
 }
 export type QuerySourceInput = QueryNodeSourceInput | QueryEdgeSourceInput;
-export interface QueryDefinitionFilterInput {
+export interface QueryClassFilterInput {
     readonly binding: QueryBinding;
-    readonly satisfies: QueryDefinitionInput;
+    readonly class: QueryClassInput | {
+        readonly equals: QueryClassInput;
+    };
 }
 export interface QueryPropertyFilterInput {
     readonly binding: QueryBinding;
@@ -39,8 +43,8 @@ export type QueryIdentityFilterInput = {
     readonly binding: EdgeBinding;
     readonly predicate: QueryEdgeIdentityPredicate;
 };
-export type QueryFilterInput = QueryDefinitionFilterInput | QueryPropertyFilterInput | QueryIdentityFilterInput;
-export type QueryCurrentNodeFilterInput = (Omit<QueryDefinitionFilterInput, 'binding'> & {
+export type QueryFilterInput = QueryClassFilterInput | QueryPropertyFilterInput | QueryIdentityFilterInput;
+export type QueryCurrentNodeFilterInput = (Omit<QueryClassFilterInput, 'binding'> & {
     readonly binding?: QueryBinding;
 }) | (Omit<QueryPropertyFilterInput, 'binding'> & {
     readonly binding?: QueryBinding;
@@ -57,7 +61,7 @@ export interface QueryPropertyPredicateBuilder {
 }
 export interface QueryExpandInput {
     readonly from: NodeBinding;
-    readonly via: NonEmpty<QueryDefinitionInput>;
+    readonly via: NonEmpty<QueryEdgeClassInput>;
     readonly direction: QueryDirection;
     readonly bindings?: {
         readonly edge: string;
@@ -100,4 +104,3 @@ export type QueryEdgeSourceSelectInput = (Omit<QueryNodeGraphSelectInput, 'bindi
     readonly binding?: EdgeBinding;
 });
 export {};
-//# sourceMappingURL=model.d.ts.map

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

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=model.js.map

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

@@ -1,10 +1,9 @@
 /** Stable flat facade over Query language, authoring, result, and reference semantics. */
 export { Property, Query } from './authoring/index.js';
-export type { EdgeQueryBuilder, ExpandedQueryBuilder, NodeQueryBuilder, QueryCurrentNodeExpandInput, QueryCurrentNodeFilterInput, QueryDefinitionInput, QueryDefinitionFilterInput, QueryEdgeSourceInput, QueryEdgeGraphSelectInput, QueryEdgeSelectInput, QueryExpandInput, QueryFilterInput, QueryIdentityFilterInput, QueryNodeGraphSelectInput, QueryNodeSelectInput, QueryNodeSourceInput, QueryPropertyFilterInput, QueryPropertyPredicateBuilder, QuerySelectInput, QuerySourceInput, } from './authoring/index.js';
+export type { EdgeQueryBuilder, ExpandedQueryBuilder, NodeQueryBuilder, QueryCurrentNodeExpandInput, QueryCurrentNodeFilterInput, QueryClassInput, QueryEdgeClassInput, QueryEdgeInput, QueryClassFilterInput, QueryEdgeSourceInput, QueryEdgeGraphSelectInput, QueryEdgeSelectInput, QueryExpandInput, QueryFilterInput, QueryIdentityFilterInput, QueryNodeClassInput, QueryNodeGraphSelectInput, QueryNodeInput, QueryNodeSelectInput, QueryNodeSourceInput, QueryPropertyFilterInput, QueryPropertyPredicateBuilder, QuerySelectInput, QuerySourceInput, } from './authoring/index.js';
 export { QueryAST, QueryASTDecodeError } from './language/index.js';
-export type { EdgeBinding, NodeBinding, QueryBinding, QueryDefinitionFilter, QueryDefinitionPredicate, QueryDefinitionRef, QueryDefinitionSourceTerm, QueryDirection, QueryEdgeSource, QueryEdgeSourceTerm, QueryEdgeSelect, QueryEdgeAST, QueryEdgeIdentityPredicate, QueryEdgeProjection, QueryExpand, QueryFingerprint, QueryIdentityFilter, QueryIdentityPredicate, QueryGraphSelect, QueryNodeAST, QueryNodeIdentityPredicate, QueryNodeProjection, QueryNodeSelect, QueryNodeSource, QueryNodeSourceTerm, QueryNodeTerminalSelect, QueryEdgeTerminalSelect, QueryOrderDirection, QueryPathSourceTerm, QueryPredicate, QueryProjectionShape, QueryPropertyEqualPredicate, QueryPropertyFilter, QueryPropertyOrder, QueryPropertyPredicate, QueryPropertyPresentPredicate, QuerySelect, QuerySource, QuerySourceTerm, QueryStep, QueryStructuralLimits, QueryUnrankedPlacement, } from './language/index.js';
+export type { EdgeBinding, NodeBinding, QueryBinding, QueryClassFilter, QueryClassPredicate, QueryClassSourceTerm, QueryClassSatisfiesPredicate, QueryClassEqualPredicate, QueryDirection, QueryEdgeSource, QueryEdgeSourceTerm, QueryEdgeSelect, QueryEdgeAST, QueryEdgeIdentityPredicate, QueryEdgeProjection, QueryExpand, QueryFingerprint, QueryIdentityFilter, QueryIdentityPredicate, QueryGraphSelect, QueryNodeAST, QueryNodeIdentityPredicate, QueryNodeProjection, QueryNodeSelect, QueryNodeSource, QueryNodeSourceTerm, QueryNodeTerminalSelect, QueryEdgeTerminalSelect, QueryOrderDirection, QueryPathSourceTerm, QueryPredicate, QueryProjectionShape, QueryPropertyEqualPredicate, QueryPropertyFilter, QueryPropertyOrder, QueryPropertyPredicate, QueryPropertyPresentPredicate, QuerySelect, QuerySingleSourceClassOf, QuerySource, QuerySourceClassesOf, QuerySourceTerm, QueryStep, QueryStructuralLimits, QueryUnrankedPlacement, } from './language/index.js';
 export { QueryResult, QueryResultDecodeError } from './result/index.js';
 export type { QueryEdgeComponentFor, QueryEdgeGraphResult, QueryEdgeItemFor, QueryEdgeResult, QueryGraphResult, QueryNodeComponentFor, QueryNodeGraphResult, QueryNodeItemFor, QueryNodeReference, QueryNodeResult, QueryResultFor, QueryResultForSelect, QuerySelection, QuerySelectionFor, } from './result/index.js';
 export { QueryReference, QueryReferenceError } from './reference/index.js';
-export type { QueryReferenceContext, QueryReferenceDefinition, QueryReferenceEvaluation, QueryReferenceFrontier, QueryReferenceIdentity, QueryReferenceOptions, QueryReferencePathWitness, QueryReferenceProperty, QueryReferenceTrace, } from './reference/index.js';
-//# sourceMappingURL=index.d.ts.map
+export type { QueryReferenceContext, QueryReferenceClassClosure, QueryReferenceEvaluation, QueryReferenceFrontier, QueryReferenceIdentity, QueryReferenceOptions, QueryReferencePathWitness, QueryReferenceProperty, QueryReferenceTrace, } from './reference/index.js';

package/dist/graph/query/index.js

@@ -3,4 +3,3 @@ export { Property, Query } from './authoring/index.js';
 export { QueryAST, QueryASTDecodeError } from './language/index.js';
 export { QueryResult, QueryResultDecodeError } from './result/index.js';
 export { QueryReference, QueryReferenceError } from './reference/index.js';
-//# sourceMappingURL=index.js.map

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

@@ -1,6 +1,6 @@
+import type { QuerySelect } from './model.js';
 import type { QueryAST } from './query-ast.js';
 /** Admit unknown JSON as one detached, deeply immutable QueryAST V6. */
-export declare function decodeQueryAST(input: unknown): QueryAST;
+export declare function decodeQueryAST(input: unknown): QueryAST<QuerySelect, never>;
 /** Re-admit a typed value before it crosses a trust or transport boundary. */
-export declare function encodeQueryAST(input: QueryAST): QueryAST;
-//# sourceMappingURL=codec.d.ts.map
+export declare function encodeQueryAST(input: QueryAST): QueryAST<QuerySelect, never>;