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

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

@@ -1,67 +1,68 @@
-import { z } from 'zod';
+import { array, discriminatedUnion, enum as enumeration, literal, strictObject, string, union, unknown as unknownSchema, } from 'zod';
 import { QUERY_AST_FORMAT, QUERY_AST_LIMITS, QUERY_AST_VERSION } from './model.js';
-const text = z.string().min(1);
+const text = string().min(1);
 const binding = text.max(64);
-const definition = z.strictObject({
+const classRef = strictObject({
     origin: text.max(253),
-    kind: z.enum(['class', 'interface']),
+    kind: literal('class'),
     name: text,
 });
-const nodeSourceTerm = z.discriminatedUnion('kind', [
-    z.strictObject({ kind: z.literal('path'), path: text }),
-    z.strictObject({ kind: z.literal('definition'), definition }),
+const nodeSourceTerm = discriminatedUnion('kind', [
+    strictObject({ kind: literal('path'), path: text }),
+    strictObject({ kind: literal('class'), class: classRef }),
 ]);
-const definitionSourceTerm = z.strictObject({ kind: z.literal('definition'), definition });
-const source = z.discriminatedUnion('kind', [
-    z.strictObject({
-        kind: z.literal('node'),
-        terms: z.array(nodeSourceTerm).min(1).max(QUERY_AST_LIMITS.sourceTerms),
+const classSourceTerm = strictObject({ kind: literal('class'), class: classRef });
+const source = discriminatedUnion('kind', [
+    strictObject({
+        kind: literal('node'),
+        terms: array(nodeSourceTerm).min(1).max(QUERY_AST_LIMITS.sourceTerms),
         binding,
     }),
-    z.strictObject({
-        kind: z.literal('edge'),
-        terms: z.array(definitionSourceTerm).min(1).max(QUERY_AST_LIMITS.sourceTerms),
-        bindings: z.strictObject({ source: binding, edge: binding, target: binding }),
+    strictObject({
+        kind: literal('edge'),
+        terms: array(classSourceTerm).min(1).max(QUERY_AST_LIMITS.sourceTerms),
+        bindings: 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('property.equal'), property: text, value: z.unknown() }),
-    z.strictObject({ kind: z.literal('property.present'), property: text }),
-    z.strictObject({
-        kind: z.literal('identity.equal'),
-        identity: z.union([text, z.strictObject({ source: text, target: text, class: text })]),
+const predicate = discriminatedUnion('kind', [
+    strictObject({ kind: literal('class.satisfies'), class: classRef }),
+    strictObject({ kind: literal('class.equal'), class: classRef }),
+    strictObject({ kind: literal('property.equal'), property: text, value: unknownSchema() }),
+    strictObject({ kind: literal('property.present'), property: text }),
+    strictObject({
+        kind: literal('identity.equal'),
+        identity: union([text, strictObject({ source: text, target: text, class: text })]),
     }),
 ]);
-const filter = z.strictObject({ op: z.literal('filter'), binding, predicate });
-const expand = z.strictObject({
-    op: z.literal('expand'),
+const filter = strictObject({ op: literal('filter'), binding, predicate });
+const expand = strictObject({
+    op: literal('expand'),
     from: binding,
-    via: z.array(definition).min(1).max(QUERY_AST_LIMITS.expansionDefinitionsPerStep),
-    direction: z.enum(['outgoing', 'incoming', 'incident']),
-    bindings: z.strictObject({ edge: binding, node: binding }),
+    via: array(classRef).min(1).max(QUERY_AST_LIMITS.expansionClassesPerStep),
+    direction: enumeration(['outgoing', 'incoming', 'incident']),
+    bindings: strictObject({ edge: binding, node: binding }),
 });
-const propertyOrder = z.strictObject({
+const propertyOrder = strictObject({
     property: text,
-    direction: z.enum(['asc', 'desc']),
-    unranked: z.enum(['first', 'last']),
+    direction: enumeration(['asc', 'desc']),
+    unranked: enumeration(['first', 'last']),
 });
-const projectionShape = z.enum(['reference', 'value']);
-const graphSelect = z.strictObject({
-    kind: z.literal('graph'),
+const projectionShape = enumeration(['reference', 'value']);
+const graphSelect = strictObject({
+    kind: literal('graph'),
     binding,
     order: propertyOrder.optional(),
 });
-const nodeSelect = z.strictObject({
-    kind: z.literal('nodes'),
+const nodeSelect = strictObject({
+    kind: literal('nodes'),
     binding,
-    projection: z.strictObject({ kind: projectionShape }),
+    projection: strictObject({ kind: projectionShape }),
     order: propertyOrder.optional(),
 });
-const edgeSelect = z.strictObject({
-    kind: z.literal('edges'),
+const edgeSelect = strictObject({
+    kind: literal('edges'),
     binding,
-    projection: z.strictObject({
+    projection: strictObject({
         edge: projectionShape,
         source: projectionShape,
         target: projectionShape,
@@ -69,11 +70,10 @@ const edgeSelect = z.strictObject({
     order: propertyOrder.optional(),
 });
 /** Structural JSON contract; decodeQueryAST owns canonical identities and binding dependencies. */
-export const queryAstSchema = z.strictObject({
-    format: z.literal(QUERY_AST_FORMAT),
-    version: z.literal(QUERY_AST_VERSION),
+export const queryAstSchema = strictObject({
+    format: literal(QUERY_AST_FORMAT),
+    version: literal(QUERY_AST_VERSION),
     source,
-    steps: z.array(z.discriminatedUnion('op', [filter, expand])).max(QUERY_AST_LIMITS.steps),
-    select: z.discriminatedUnion('kind', [graphSelect, nodeSelect, edgeSelect]),
+    steps: array(discriminatedUnion('op', [filter, expand])).max(QUERY_AST_LIMITS.steps),
+    select: 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,35 @@
-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;
+    admitEdge(edge: Edge, source: Node, target: Node): boolean;
     traverseNode(node: Node): boolean;
     traverseEdge(edge: Edge): boolean;
     readNode(node: Node): boolean;
@@ -65,4 +68,3 @@ export interface QueryReferenceTrace {
 export declare const QueryReference: {
     evaluate(input: QueryAST, context: QueryReferenceContext, options: QueryReferenceOptions): QueryReferenceEvaluation;
 };
-//# sourceMappingURL=evaluate.d.ts.map

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

@@ -1,6 +1,6 @@
 import { PropertyKey, } from '@astrale-os/kernel-dsl/v1/addressing';
+import { ClassKey as admitClassKey } from '@astrale-os/kernel-dsl/v1/addressing';
 import * as portable from '@astrale-os/kernel-dsl/value';
-import { ClassPath as admitClassPath } from '../../class/index.js';
 import { compareEdgeKeys, edgeKeyOf, encodeEdgeKey } from '../../edge/index.js';
 import { GraphData } from '../../graph/index.js';
 import { NodeId as admitNodeId } from '../../node/index.js';
@@ -33,7 +33,7 @@ export const QueryReference = Object.freeze({
 });
 function evaluate(ast, context, options) {
     const admission = new Admission(context);
-    const definitions = new Definitions(context);
+    const classes = new Classes(context);
     const properties = new PropertyClosures(context);
     let rows;
     let sourceRows;
@@ -48,9 +48,9 @@ function evaluate(ast, context, options) {
                 sourceFromPath(term.path, path, context, admission, source);
                 return;
             }
-            const classes = definitions.close(term.definition, 'node', `${path}/definition`);
+            const extent = classes.close(term.class, 'node', `${path}/class`);
             for (const node of context.graph.nodes) {
-                if (classes.has(node.class) && admission.node(node, `${path}/definition`)) {
+                if (extent.has(node.class) && admission.node(node, `${path}/class`)) {
                     source.set(node.id, node);
                 }
             }
@@ -61,15 +61,15 @@ function evaluate(ast, context, options) {
     }
     else {
         const edgeSource = ast.source;
-        const classes = new Set();
+        const extentClasses = new Set();
         edgeSource.terms.forEach((term, index) => {
-            for (const classPath of definitions.close(term.definition, 'edge', `/source/terms/${index}/definition`)) {
-                classes.add(classPath);
+            for (const classKey of classes.close(term.class, 'edge', `/source/terms/${index}/class`)) {
+                extentClasses.add(classKey);
             }
         });
         const source = new Map();
         for (const edge of context.graph.edges) {
-            if (!classes.has(edge.class))
+            if (!extentClasses.has(edge.class))
                 continue;
             const sourceNode = requireNode(context, edge.source, '/source');
             const targetNode = requireNode(context, edge.target, '/source');
@@ -100,12 +100,21 @@ function evaluate(ast, context, options) {
     ast.steps.forEach((step, index) => {
         const path = `/steps/${index}`;
         if (step.op === 'filter') {
-            if (step.predicate.kind === 'definition.satisfies') {
+            if (step.predicate.kind === 'class.satisfies' || step.predicate.kind === 'class.equal') {
                 const kind = kinds.get(step.binding);
                 if (kind === undefined)
                     invalid(`${path}/binding`, 'Filter binding is unavailable');
-                const classes = definitions.close(step.predicate.definition, kind, `${path}/predicate/definition`);
-                rows = rows.filter((row) => classes.has(boundValue(row, step.binding, `${path}/binding`).value.class));
+                const extent = classes.close(step.predicate.class, kind, `${path}/predicate/class`);
+                if (step.predicate.kind === 'class.satisfies') {
+                    rows = rows.filter((row) => extent.has(boundValue(row, step.binding, `${path}/binding`).value.class));
+                }
+                else {
+                    const exact = admitClassKey.of(step.predicate.class);
+                    rows = rows.filter((row) => {
+                        const value = boundValue(row, step.binding, `${path}/binding`).value;
+                        return value.class === exact;
+                    });
+                }
             }
             else if (step.predicate.kind === 'identity.equal') {
                 const predicate = step.predicate;
@@ -140,12 +149,12 @@ function evaluate(ast, context, options) {
             return;
         }
         const orientations = new Map();
-        step.via.forEach((definition, definitionIndex) => {
-            const classes = definitions.close(definition, 'edge', `${path}/via/${definitionIndex}`);
-            for (const edge of classes) {
-                const orientation = call(`${path}/via/${definitionIndex}`, 'Edge Class orientation could not be resolved', () => context.orientation(edge));
+        step.via.forEach((classRef, classIndex) => {
+            const extent = classes.close(classRef, 'edge', `${path}/via/${classIndex}`);
+            for (const edge of extent) {
+                const orientation = call(`${path}/via/${classIndex}`, 'Edge Class orientation could not be resolved', () => context.orientation(edge));
                 if (orientation !== 'directed' && orientation !== 'undirected') {
-                    invalid(`${path}/via/${definitionIndex}`, 'Definition closes to a non-Edge Class');
+                    invalid(`${path}/via/${classIndex}`, 'Class closes to a non-Edge Class');
                 }
                 orientations.set(edge, orientation);
             }
@@ -501,29 +510,28 @@ function boundValue(row, binding, path) {
         invalid(path, 'Binding is unavailable');
     return value;
 }
-class Definitions {
+class Classes {
     context;
     #cache = new Map();
     constructor(context) {
         this.context = context;
     }
-    close(definition, expected, path) {
-        const key = `${expected}\0${definition.origin}\0${definition.kind}\0${definition.name}`;
+    close(classRef, expected, path) {
+        const key = `${expected}\0${classRef.origin}\0${classRef.name}`;
         const cached = this.#cache.get(key);
         if (cached !== undefined)
             return cached;
-        const value = call(path, 'Definition closure failed', () => this.context.closeDefinition(definition));
-        if (value === undefined || !isRecord(value) || !exactKeys(value, ['family', 'classes'])) {
-            invalid(path, 'Definition is unresolved');
+        const value = call(path, 'Class closure failed', () => this.context.closeClass(classRef));
+        if (value === undefined || !isRecord(value) || !exactKeys(value, ['kind', 'classes'])) {
+            invalid(path, 'Class is unresolved');
         }
-        if ((value.family !== 'node' && value.family !== 'edge' && value.family !== 'both') ||
-            (value.family !== expected && value.family !== 'both')) {
-            invalid(path, `Definition is not ${expected}-capable`);
+        if (value.kind !== expected) {
+            invalid(path, `Class is not a ${expected} Class`);
         }
         if (!Array.isArray(value.classes))
-            invalid(`${path}/classes`, 'Classes must be an array');
-        const classes = value.classes.map((entry, index) => decodeClassPath(entry, `${path}/classes/${index}`));
-        unique(classes, (entry) => entry, `${path}/classes`, 'ClassPath');
+            invalid(`${path}/classes`, 'Class extent must be an array');
+        const classes = value.classes.map((entry, index) => decodeClassKey(entry, `${path}/classes/${index}`));
+        unique(classes, (entry) => entry, `${path}/classes`, 'ClassKey');
         const accepted = new Set(classes);
         this.#cache.set(key, accepted);
         return accepted;
@@ -563,8 +571,8 @@ class PropertyClosures {
         const inputClasses = value[kind === 'node' ? 'nodes' : 'edges'];
         if (!Array.isArray(inputClasses))
             invalid(path, 'Property Classes must be an array');
-        const classes = inputClasses.map((entry, index) => decodeClassPath(entry, `${path}/classes/${index}`));
-        unique(classes, (entry) => entry, `${path}/classes`, 'ClassPath');
+        const classes = inputClasses.map((entry, index) => decodeClassKey(entry, `${path}/classes/${index}`));
+        unique(classes, (entry) => entry, `${path}/classes`, 'ClassKey');
         const accepted = new Set(classes);
         this.#cache.set(cacheKey, accepted);
         this.#ordering.set(property, value.ordering);
@@ -603,6 +611,15 @@ class Admission {
         const cached = this.#edges.get(key);
         if (cached !== undefined)
             return cached;
+        const source = requireNode(this.context, edge.source, path);
+        const target = requireNode(this.context, edge.target, path);
+        const admitted = call(path, 'Logical Edge fact admission failed', () => this.context.admitEdge(edge, source, target));
+        if (typeof admitted !== 'boolean')
+            invalid(path, 'Logical Edge fact admission must return boolean');
+        if (!admitted) {
+            this.#edges.set(key, false);
+            return false;
+        }
         const explicit = call(path, 'Edge traversal admission failed', () => this.context.traverseEdge(edge));
         if (typeof explicit !== 'boolean')
             invalid(path, 'Edge traversal admission must return boolean');
@@ -637,9 +654,10 @@ function acceptContext(input) {
         invalid('', 'Reference context must be an object');
     for (const name of [
         'resolve',
-        'closeDefinition',
+        'closeClass',
         'closeProperty',
         'orientation',
+        'admitEdge',
         'traverseNode',
         'traverseEdge',
         'readNode',
@@ -660,9 +678,10 @@ function acceptContext(input) {
         nodes: new Map(graph.nodes.map((node) => [node.id, node])),
         edges: new Map(graph.edges.map((edge) => [encodeEdgeKey(edge), edge])),
         resolve: input.resolve.bind(input),
-        closeDefinition: input.closeDefinition.bind(input),
+        closeClass: input.closeClass.bind(input),
         closeProperty: input.closeProperty.bind(input),
         orientation: input.orientation.bind(input),
+        admitEdge: input.admitEdge.bind(input),
         traverseNode: input.traverseNode.bind(input),
         traverseEdge: input.traverseEdge.bind(input),
         readNode: input.readNode.bind(input),
@@ -691,15 +710,12 @@ function decodeNodeId(input, path) {
         invalid(path, 'Invalid NodeId', cause);
     }
 }
-function decodeClassPath(input, path) {
+function decodeClassKey(input, path) {
     if (typeof input !== 'string')
-        invalid(path, 'Expected ClassPath string');
-    try {
-        return admitClassPath.parse(input);
-    }
-    catch (cause) {
-        invalid(path, 'Invalid ClassPath', cause);
-    }
+        invalid(path, 'Expected ClassKey string');
+    if (!admitClassKey.is(input))
+        invalid(path, 'Invalid ClassKey');
+    return admitClassKey(input);
 }
 function decodeEdgeKey(input, path) {
     if (!isRecord(input) || !exactKeys(input, ['source', 'target', 'class'])) {
@@ -708,7 +724,7 @@ function decodeEdgeKey(input, path) {
     return Object.freeze({
         source: decodeNodeId(input.source, `${path}/source`),
         target: decodeNodeId(input.target, `${path}/target`),
-        class: decodeClassPath(input.class, `${path}/class`),
+        class: decodeClassKey(input.class, `${path}/class`),
     });
 }
 function unique(values, keyOf, path, label) {
@@ -738,4 +754,3 @@ function isRecord(input) {
 function invalid(path, message, cause) {
     throw new QueryReferenceError(path, message, cause === undefined ? undefined : { cause });
 }
-//# sourceMappingURL=evaluate.js.map

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

@@ -1,4 +1,3 @@
 export { QueryReference } from './evaluate.js';
-export type { QueryReferenceContext, QueryReferenceDefinition, QueryReferenceEvaluation, QueryReferenceFrontier, QueryReferenceIdentity, QueryReferenceOptions, QueryReferencePathWitness, QueryReferenceProperty, QueryReferenceTrace, } from './evaluate.js';
+export type { QueryReferenceContext, QueryReferenceClassClosure, QueryReferenceEvaluation, QueryReferenceFrontier, QueryReferenceIdentity, QueryReferenceOptions, QueryReferencePathWitness, QueryReferenceProperty, QueryReferenceTrace, } from './evaluate.js';
 export { QueryReferenceError } from './error.js';
-//# sourceMappingURL=index.d.ts.map

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

@@ -1,3 +1,2 @@
 export { QueryReference } from './evaluate.js';
 export { QueryReferenceError } from './error.js';
-//# sourceMappingURL=index.js.map

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

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

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

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

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

@@ -1,11 +1,11 @@
-import type { ClassPath as ClassPathValue } from '../../class/index.js';
+import type { ClassKey as ClassKeyValue } from '@astrale-os/kernel-dsl/v1/addressing';
 import type { Edge, EdgeKey } from '../../edge/index.js';
 import type { GraphData as GraphDataValue } from '../../graph/index.js';
 import type { Node, NodeId as NodeIdValue } from '../../node/index.js';
 import type { EdgeBinding, NodeBinding, QueryAST, QueryEdgeProjection, QueryEdgeSelect, QueryGraphSelect, QueryNodeProjection, QueryNodeSelect, QueryProjectionShape, QuerySelect } from '../language/index.js';
 export interface QueryNodeReference {
     readonly id: NodeIdValue;
-    readonly class: ClassPathValue;
+    readonly class: ClassKeyValue;
 }
 export type QueryNodeItemFor<Projection extends QueryNodeProjection> = Projection extends {
     readonly kind: 'reference';
@@ -89,4 +89,3 @@ export declare function encodeQueryResult(input: QueryResult): QueryResult;
 export declare function queryResultSelection<Result extends QueryResult>(input: Result): QuerySelectionFor<Result>;
 /** Decode exact QueryResult structure; Query-relative closure remains Runtime-owned. */
 export declare function decodeQueryResult(input: unknown): QueryResult;
-//# sourceMappingURL=index.d.ts.map

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

@@ -1,5 +1,5 @@
+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 { edgeKeyOf, encodeEdgeKey } from '../../edge/index.js';
 import { GraphData, GraphDataDecodeError } from '../../graph/index.js';
 import { NodeId as admitNodeId } from '../../node/index.js';
@@ -35,7 +35,7 @@ export function queryResultSelection(input) {
 /** Decode exact QueryResult structure; Query-relative closure remains Runtime-owned. */
 export function decodeQueryResult(input) {
     try {
-        const value = decodeWire(queryResultSchema, portable.accept(input), invalid);
+        const value = decodeWire(queryResultSchema, portable.acceptForRead(input), invalid);
         if (value.kind === 'graph') {
             const graph = decodeGraph(value.graph, '/graph');
             const selection = decodeSelection(value.selection, graph);
@@ -71,7 +71,7 @@ function decodeNodeProjection(input, path) {
             kind: input.kind,
             value: Object.freeze({
                 id: decodeNodeId(value.id, `${path}/value/id`),
-                class: decodeClassPath(value.class, `${path}/value/class`),
+                class: decodeClassKey(value.class, `${path}/value/class`),
             }),
         });
     }
@@ -86,7 +86,7 @@ function decodeEdgeProjection(input, path) {
             value: Object.freeze({
                 source: decodeNodeId(value.source, `${path}/value/source`),
                 target: decodeNodeId(value.target, `${path}/value/target`),
-                class: decodeClassPath(value.class, `${path}/value/class`),
+                class: decodeClassKey(value.class, `${path}/value/class`),
             }),
         });
     }
@@ -114,13 +114,10 @@ function decodeNodeId(input, path) {
         invalid(path, 'Invalid NodeId', cause);
     }
 }
-function decodeClassPath(input, path) {
-    try {
-        return ClassPath.parse(input);
-    }
-    catch (cause) {
-        invalid(path, 'Invalid ClassPath', cause);
-    }
+function decodeClassKey(input, path) {
+    if (!ClassKey.is(input))
+        invalid(path, 'Invalid ClassKey');
+    return ClassKey(input);
 }
 function decodeSelection(input, graph) {
     if (input.kind === 'node') {
@@ -151,7 +148,7 @@ function decodeSelection(input, graph) {
             key = Object.freeze({
                 source: admitNodeId(entry.source),
                 target: admitNodeId(entry.target),
-                class: ClassPath.parse(entry.class),
+                class: ClassKey(entry.class),
             });
         }
         catch (cause) {
@@ -176,4 +173,3 @@ function joinPointer(base, nested) {
 function errorPointer(error) {
     return error instanceof portable.BoundaryError ? error.pointer : '';
 }
-//# sourceMappingURL=index.js.map