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

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

@@ -1,5 +1,5 @@
 import type { PropertyKey } from '@astrale-os/kernel-dsl/v1';
-import type { ClassPath } from '../../class/index.js';
+import type { ClassKey } from '@astrale-os/kernel-dsl/v1/addressing';
 import type { EdgeSlug } from '../../edge/index.js';
 import type { LocalBinding } from '../../graph/index.js';
 import type { NodePath } from '../../path/index.js';
@@ -22,7 +22,7 @@ export type MutationEndpoint = NodePath | {
 export interface MutationEdgeSelector {
     readonly source: NodePath;
     readonly target: NodePath;
-    readonly class: ClassPath;
+    readonly class: ClassKey;
 }
 export interface MutationPropertyConditions {
     readonly equals?: MutationProps;
@@ -45,7 +45,7 @@ export type MutationQueryPrecondition = {
 export type MutationPrecondition = {
     readonly kind: 'node';
     readonly node: NodePath;
-    readonly class: ClassPath;
+    readonly class: ClassKey;
     readonly props?: MutationPropertyConditions;
 } | {
     readonly kind: 'edge';
@@ -56,23 +56,23 @@ export type MutationPrecondition = {
 export interface NodeCreateOperation {
     readonly op: 'node.create';
     readonly as: LocalBinding;
-    readonly class: ClassPath;
+    readonly class: ClassKey;
     readonly props: MutationProps;
 }
 export interface NodeUpdateOperation {
     readonly op: 'node.update';
     readonly node: NodePath;
-    readonly class: ClassPath;
+    readonly class: ClassKey;
     readonly props: PropertiesDelta;
 }
 export interface NodeDeleteOperation {
     readonly op: 'node.delete';
     readonly node: NodePath;
-    readonly class: ClassPath;
+    readonly class: ClassKey;
 }
 export interface EdgeCreateOperation {
     readonly op: 'edge.create';
-    readonly class: ClassPath;
+    readonly class: ClassKey;
     readonly source: MutationEndpoint;
     readonly target: MutationEndpoint;
     readonly slug?: EdgeSlug;
@@ -101,4 +101,3 @@ export interface MutationAST {
     readonly preconditions: readonly MutationPrecondition[];
     readonly operations: readonly MutationOperation[];
 }
-//# sourceMappingURL=model.d.ts.map

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

@@ -5,4 +5,3 @@ export const MUTATION_AST_LIMITS = Object.freeze({
     queryPreconditions: 64,
     queryExpectedIdentities: 4096,
 });
-//# sourceMappingURL=model.js.map

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

@@ -39,13 +39,10 @@ export declare const mutationAstSchema: 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">>;
@@ -53,13 +50,10 @@ export declare const mutationAstSchema: 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>>;
@@ -73,13 +67,17 @@ export declare const mutationAstSchema: 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<{
@@ -102,10 +100,7 @@ export declare const mutationAstSchema: 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<{
@@ -254,4 +249,3 @@ export declare const mutationAstSchema: z.ZodObject<{
         }, z.core.$strict>;
     }, z.core.$strict>]>>;
 }, z.core.$strict>;
-//# sourceMappingURL=wire.d.ts.map

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

@@ -1,5 +1,5 @@
 import { patterns } from '@astrale-os/kernel-dsl/v1/addressing';
-import { fullMatch } from '@astrale-os/kernel-dsl/v1/schema/full-match';
+import { fullMatch } from '@astrale-os/kernel-dsl/v1/value/full-match';
 import { z } from 'zod';
 import { edgeSlugSchema } from '../../edge/index.js';
 import { queryAstSchema } from '../../query/language/index.js';
@@ -86,4 +86,3 @@ export const mutationAstSchema = z.strictObject({
     ]))
         .min(1),
 });
-//# sourceMappingURL=wire.js.map

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

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

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

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

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

@@ -6,6 +6,7 @@ export type MutationResult = {
 export declare const MutationResult: {
     decode(input: unknown): MutationResult;
     encode(input: MutationResult): MutationResult;
+    createdNode(result: MutationResult, binding: string): NodeId | undefined;
 };
 export { MutationResultDecodeError } from './error.js';
 export { mutationResultSchema } from './wire.js';
@@ -13,4 +14,3 @@ export { mutationResultSchema } from './wire.js';
 export declare function encodeMutationResult(input: MutationResult): MutationResult;
 /** Decode unknown JSON into immutable admitted LocalBinding-to-NodeId results. */
 export declare function decodeMutationResult(input: unknown): MutationResult;
-//# sourceMappingURL=index.d.ts.map

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

@@ -1,10 +1,16 @@
 import * as portable from '@astrale-os/kernel-dsl/value';
-import { isLocalBinding } from '#graph/graph';
+import { isLocalBinding, LocalBinding as LocalBindingValue } from '#graph/graph';
 import { NodeId as nodeId } from '../../node/index.js';
 import { decodeWire } from '../../wire.js';
 import { MutationResultDecodeError } from './error.js';
 import { mutationResultSchema } from './wire.js';
-export const MutationResult = Object.freeze({ decode: decodeMutationResult, encode: encodeMutationResult });
+export const MutationResult = Object.freeze({
+    decode: decodeMutationResult,
+    encode: encodeMutationResult,
+    createdNode(result, binding) {
+        return result.createdNodes[LocalBindingValue(binding)];
+    },
+});
 export { MutationResultDecodeError } from './error.js';
 export { mutationResultSchema } from './wire.js';
 /** Re-admit one mutation result before it crosses a trust or transport boundary. */
@@ -52,4 +58,3 @@ function invalid(path, message, cause) {
 function errorPointer(error) {
     return error instanceof portable.BoundaryError ? error.pointer : '';
 }
-//# sourceMappingURL=index.js.map

package/dist/graph/mutate/result/wire.d.ts

@@ -2,4 +2,3 @@ import { z } from 'zod';
 export declare const mutationResultSchema: z.ZodObject<{
     createdNodes: z.ZodRecord<z.ZodString, z.ZodString>;
 }, z.core.$strict>;
-//# sourceMappingURL=wire.d.ts.map

package/dist/graph/mutate/result/wire.js

@@ -2,4 +2,3 @@ import { z } from 'zod';
 const text = z.string().min(1);
 const binding = z.string().min(1).max(64);
 export const mutationResultSchema = z.strictObject({ createdNodes: z.record(binding, text) });
-//# sourceMappingURL=wire.js.map

package/dist/graph/mutate/wire/index.d.ts

@@ -1,4 +1,3 @@
 /** Private compatibility facade for callable-admission Zod carriers. */
 export { mutationAstSchema } from '../language/index.js';
 export { mutationResultSchema } from '../result/index.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/graph/mutate/wire/index.js

@@ -1,4 +1,3 @@
 /** Private compatibility facade for callable-admission Zod carriers. */
 export { mutationAstSchema } from '../language/index.js';
 export { mutationResultSchema } from '../result/index.js';
-//# sourceMappingURL=index.js.map

package/dist/graph/node/identity/id.d.ts

@@ -16,4 +16,3 @@ export declare const nodeIdSchema: z.ZodPipe<z.ZodString & z.ZodType<NodeId, str
     readonly [NODE_ID_BRAND]: true;
 }>>;
 export {};
-//# sourceMappingURL=id.d.ts.map

package/dist/graph/node/identity/id.js

@@ -27,4 +27,3 @@ export const nodeIdSchema = z
     .string()
     .refine(isNodeId, NODE_ID_ERROR_MESSAGE)
     .transform((value) => value);
-//# sourceMappingURL=id.js.map

package/dist/graph/node/identity/index.d.ts

@@ -1,3 +1,2 @@
 export { NodeId, NodeIdError, isNodeId } from './id.js';
 export { compareNodeIds } from './order.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/graph/node/identity/index.js

@@ -1,3 +1,2 @@
 export { NodeId, NodeIdError, isNodeId } from './id.js';
 export { compareNodeIds } from './order.js';
-//# sourceMappingURL=index.js.map

package/dist/graph/node/identity/order.d.ts

@@ -1,4 +1,3 @@
 import type { NodeId } from './id.js';
 /** Compare canonical Node identity by unsigned lexicographic UTF-8 byte order. */
 export declare function compareNodeIds(left: NodeId, right: NodeId): number;
-//# sourceMappingURL=order.d.ts.map

package/dist/graph/node/identity/order.js

@@ -11,4 +11,3 @@ export function compareNodeIds(left, right) {
     }
     return Math.sign(a.length - b.length);
 }
-//# sourceMappingURL=order.js.map

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

@@ -2,4 +2,3 @@
 export { NodeId, NodeIdError, compareNodeIds, isNodeId } from './identity/index.js';
 export { node } from './model/index.js';
 export type { Node, NodeCollection, NodeSpec } from './model/index.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/graph/node/index.js

@@ -1,4 +1,3 @@
 /** Stable aggregate facade over Node identity and model semantics. */
 export { NodeId, NodeIdError, compareNodeIds, isNodeId } from './identity/index.js';
 export { node } from './model/index.js';
-//# sourceMappingURL=index.js.map

package/dist/graph/node/model/index.d.ts

@@ -1,9 +1,9 @@
-import type { ClassPath } from '../../class/index.js';
+import type { ClassKey } from '@astrale-os/kernel-dsl/v1/addressing';
 import type { Properties } from '../../properties/index.js';
 import type { NodeId } from '../identity/index.js';
 /** One complete logical Node value without identity. */
 export interface NodeSpec {
-    readonly class: ClassPath;
+    readonly class: ClassKey;
     readonly props: Properties;
 }
 /** One complete identified logical Node fact. */
@@ -13,4 +13,3 @@ export interface Node extends NodeSpec {
 /** Construct one immutable Node record from canonical components. */
 export declare function node(value: Node): Node;
 export type NodeCollection = readonly Node[];
-//# sourceMappingURL=index.d.ts.map

package/dist/graph/node/model/index.js

@@ -2,4 +2,3 @@
 export function node(value) {
     return Object.freeze({ id: value.id, class: value.class, props: value.props });
 }
-//# sourceMappingURL=index.js.map

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

@@ -1,3 +1,2 @@
 export { Path } from './path.js';
-export type { CallablePath, PathLike } from './path.js';
-//# sourceMappingURL=index.d.ts.map
+export type { CallablePath, NodeTarget, PathLike } from './path.js';

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

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

package/dist/graph/path/authoring/path.d.ts

@@ -1,7 +1,7 @@
-import type { Key, schema } from '@astrale-os/kernel-dsl/v1';
+import type { CoreRef, DefinitionRef, Key } from '@astrale-os/kernel-dsl/v1/addressing';
+import { type ClassKey as ClassKeyValue } from '@astrale-os/kernel-dsl/v1/addressing';
 import type { NodeId } from '../../node/identity/index.js';
 import type { DomainAnchor as PathDomainAnchor, DomainProjection as PathDomainProjection, IdAnchor as PathIdAnchor, MethodStep as PathMethodStep, NodePath, PathAST, PathAnchor, PathDiagnostic, PathDiagnosticCode, PathStep, ProjectionKind as PathProjectionKind, ProjectionStep as PathProjectionStep, TraversalStep as PathTraversalStep } from '../language/index.js';
-import { type ClassPath as ClassPathValue } from '../../class/index.js';
 import { type EdgeSlug as EdgeSlugValue } from '../../edge/slug/index.js';
 declare const CALLABLE_PATH: unique symbol;
 /** Immutable rich value for one admitted NodePath. */
@@ -15,11 +15,11 @@ export declare class Path {
     static fromAST(ast: Path.AST): Path;
     static id(id: NodeId): Path.Id;
     static domain(origin: Key.Origin): Path.Domain;
-    static project(input: ClassPathValue | Path.ProjectionRef): Path.Projection;
+    static project(input: ClassKeyValue | Path.ProjectionRef): Path.Projection;
     static staticMethod(owner: Path.Projection, name: string): Path.Method;
     static instanceMethod(source: Path, name: string): Path.Method;
-    out(classPath: ClassPathValue, options?: Path.TraversalOptions): Path;
-    in(classPath: ClassPathValue, options?: Path.TraversalOptions): Path;
+    out(classKey: ClassKeyValue, options?: Path.TraversalOptions): Path;
+    in(classKey: ClassKeyValue, options?: Path.TraversalOptions): Path;
     equals(other: Path): boolean;
     toString(): NodePath;
     toJSON(): NodePath;
@@ -27,6 +27,8 @@ export declare class Path {
 }
 /** Rich or already-admitted serialized Path accepted at in-process authoring boundaries. */
 export type PathLike = Path | NodePath;
+/** Exact existing Node accepted by ID-first graph authoring facades. */
+export type NodeTarget = NodeId | PathLike;
 /** Runtime-established proof that a Path addresses one callable Node. */
 export type CallablePath = Path & {
     readonly [CALLABLE_PATH]: true;
@@ -43,7 +45,8 @@ export declare namespace Path {
     type TraversalStep = PathTraversalStep;
     type ProjectionKind = PathProjectionKind;
     type DomainProjection = PathDomainProjection;
-    type ProjectionRef = schema.SchemaRef<'interface' | 'class' | 'function' | 'policy' | 'view' | 'core'>;
+    /** Structured coordinate accepted for a graph-projected Definition or Core object. */
+    type ProjectionRef = DefinitionRef<'class' | 'function' | 'policy' | 'view'> | CoreRef;
     interface TraversalOptions {
         readonly slug?: EdgeSlugValue;
     }
@@ -66,4 +69,3 @@ export declare namespace Path {
     type Diagnostic = PathDiagnostic;
 }
 export {};
-//# sourceMappingURL=path.d.ts.map

package/dist/graph/path/authoring/path.js

@@ -1,4 +1,4 @@
-import { ClassPath } from '../../class/index.js';
+import { ClassKey } from '@astrale-os/kernel-dsl/v1/addressing';
 import { EdgeSlug } from '../../edge/slug/index.js';
 import { normalizePathAST, parsePathAST, pathError, serializePathAST } from '../language/index.js';
 /** Immutable rich value for one admitted NodePath. */
@@ -30,8 +30,8 @@ export class Path {
         }));
     }
     static staticMethod(owner, name) {
-        if (owner.projection.kind !== 'class' && owner.projection.kind !== 'interface') {
-            throw pathError(owner.raw, 'PATH_INVALID_POSITION', 'Static Method owner must be a Class or Interface.');
+        if (owner.projection.kind !== 'class') {
+            throw pathError(owner.raw, 'PATH_INVALID_POSITION', 'Static Method owner must be a Class.');
         }
         return createPath(normalizePathAST({
             anchor: owner.ast.anchor,
@@ -44,11 +44,11 @@ export class Path {
             steps: [...source.ast.steps, { kind: 'method', dispatch: 'instance', name }],
         }));
     }
-    out(classPath, options = {}) {
-        return this.traverse('out', classPath, options);
+    out(classKey, options = {}) {
+        return this.traverse('out', classKey, options);
     }
-    in(classPath, options = {}) {
-        return this.traverse('in', classPath, options);
+    in(classKey, options = {}) {
+        return this.traverse('in', classKey, options);
     }
     equals(other) {
         return this.raw === other.raw;
@@ -59,7 +59,7 @@ export class Path {
     toJSON() {
         return this.raw;
     }
-    traverse(direction, classPath, options) {
+    traverse(direction, classKey, options) {
         const slug = options.slug === undefined ? undefined : EdgeSlug(options.slug);
         return createPath(normalizePathAST({
             anchor: this.ast.anchor,
@@ -68,7 +68,7 @@ export class Path {
                 {
                     kind: 'traverse',
                     direction,
-                    class: ClassPath.parse(classPath),
+                    class: ClassKey(classKey),
                     ...(slug === undefined ? {} : { slug }),
                 },
             ],
@@ -85,8 +85,8 @@ function createPath(ast) {
 function projectionOf(input) {
     if (typeof input === 'string') {
         return {
-            origin: ClassPath.origin(input),
-            projection: { kind: 'class', name: ClassPath.name(input) },
+            origin: ClassKey.ref(input).origin,
+            projection: { kind: 'class', name: ClassKey.ref(input).name },
         };
     }
     const kind = projectedKind(input.kind);
@@ -118,4 +118,3 @@ function defineRefinement(path) {
 function define(target, key, value) {
     Object.defineProperty(target, key, { enumerable: true, value });
 }
-//# sourceMappingURL=path.js.map

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

@@ -1,5 +1,4 @@
 /** Stable aggregate facade over the NodePath language and rich Path authoring value. */
 export { Path } from './authoring/index.js';
-export type { CallablePath, PathLike } from './authoring/index.js';
+export type { CallablePath, NodeTarget, PathLike } from './authoring/index.js';
 export { NodePath, PathError, isNodePath } from './language/index.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/graph/path/index.js

@@ -1,4 +1,3 @@
 /** Stable aggregate facade over the NodePath language and rich Path authoring value. */
 export { Path } from './authoring/index.js';
 export { NodePath, PathError, isNodePath } from './language/index.js';
-//# sourceMappingURL=index.js.map

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

@@ -7,4 +7,3 @@ export declare class PathError extends TypeError {
     constructor(input: unknown, diagnostics: readonly [PathDiagnostic, ...PathDiagnostic[]]);
 }
 export declare function pathError(input: unknown, code: PathDiagnosticCode, message: string, position?: number): PathError;
-//# sourceMappingURL=error.d.ts.map

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

@@ -19,4 +19,3 @@ export function pathError(input, code, message, position) {
         },
     ]);
 }
-//# sourceMappingURL=error.js.map

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

@@ -7,4 +7,3 @@ export { normalizePathAST, parsePathAST, serializePathAST } from './syntax.js';
 export declare function NodePath(input: string): NodePathValue;
 /** Return whether an unknown value is exact canonical V1 NodePath text. */
 export declare function isNodePath(input: unknown): input is NodePathValue;
-//# sourceMappingURL=index.d.ts.map

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

@@ -19,4 +19,3 @@ export function isNodePath(input) {
         throw error;
     }
 }
-//# sourceMappingURL=index.js.map

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

@@ -1,5 +1,5 @@
 import type { Key } from '@astrale-os/kernel-dsl/v1';
-import type { ClassPath } from '../../class/index.js';
+import type { ClassKey } from '@astrale-os/kernel-dsl/v1/addressing';
 import type { EdgeSlug } from '../../edge/slug/index.js';
 import type { NodeId } from '../../node/identity/index.js';
 declare const NODE_PATH_BRAND: unique symbol;
@@ -33,10 +33,10 @@ export interface MethodStep {
 export interface TraversalStep {
     readonly kind: 'traverse';
     readonly direction: 'out' | 'in';
-    readonly class: ClassPath;
+    readonly class: ClassKey;
     readonly slug?: EdgeSlug;
 }
-export type ProjectionKind = 'class' | 'interface' | 'function' | 'policy' | 'view' | 'core';
+export type ProjectionKind = 'class' | 'function' | 'policy' | 'view' | 'core';
 export interface DomainProjection {
     readonly kind: ProjectionKind;
     readonly name: string;
@@ -48,4 +48,3 @@ export interface PathDiagnostic {
     readonly message: string;
 }
 export {};
-//# sourceMappingURL=model.d.ts.map

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

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

package/dist/graph/path/language/syntax.d.ts

@@ -2,4 +2,3 @@ import type { NodePath, PathAST } from './model.js';
 export declare function parsePathAST(input: string): PathAST;
 export declare function normalizePathAST(input: unknown): PathAST;
 export declare function serializePathAST(input: PathAST): NodePath;
-//# sourceMappingURL=syntax.d.ts.map

package/dist/graph/path/language/syntax.js

@@ -1,16 +1,9 @@
 import { patterns } from '@astrale-os/kernel-dsl/v1/addressing';
-import { ClassPath, ClassPathError } from '../../class/index.js';
+import { ClassKey } from '@astrale-os/kernel-dsl/v1/addressing';
 import { EdgeSlug, isEdgeSlug } from '../../edge/slug/index.js';
 import { isNodeId } from '../../node/identity/index.js';
 import { pathError } from './error.js';
-const PROJECTION_KINDS = new Set([
-    'class',
-    'interface',
-    'function',
-    'policy',
-    'view',
-    'core',
-]);
+const PROJECTION_KINDS = new Set(['class', 'function', 'policy', 'view', 'core']);
 export function parsePathAST(input) {
     if (input.length === 0)
         throw pathError(input, 'PATH_EMPTY', 'Path source is empty.', 0);
@@ -52,7 +45,7 @@ export function normalizePathAST(input) {
                 const owner = steps.length === 1 ? steps[0] : undefined;
                 if (anchor.kind !== 'domain' ||
                     owner?.kind !== 'projection' ||
-                    (owner.projection.kind !== 'class' && owner.projection.kind !== 'interface')) {
+                    owner.projection.kind !== 'class') {
                     invalidAST();
                 }
             }
@@ -69,20 +62,14 @@ export function normalizePathAST(input) {
                 invalidAST();
             if (typeof candidate.class !== 'string')
                 invalidAST();
-            let classPath;
-            try {
-                classPath = ClassPath.parse(candidate.class);
-            }
-            catch (error) {
-                if (error instanceof ClassPathError)
-                    return invalidAST();
-                throw error;
-            }
+            if (!ClassKey.is(candidate.class))
+                invalidAST();
+            const classKey = ClassKey(candidate.class);
             const slug = candidate.slug === undefined ? undefined : normalizeSlug(candidate.slug);
             steps.push({
                 kind: 'traverse',
                 direction: candidate.direction,
-                class: classPath,
+                class: classKey,
                 ...(slug === undefined ? {} : { slug }),
             });
             continue;
@@ -143,7 +130,7 @@ function parseSteps(input, start, anchorKind) {
             const owner = steps.length === 1 ? steps[0] : undefined;
             if (anchorKind !== 'domain' ||
                 owner?.kind !== 'projection' ||
-                (owner.projection.kind !== 'class' && owner.projection.kind !== 'interface') ||
+                owner.projection.kind !== 'class' ||
                 end !== input.length ||
                 !patterns.memberName.test(token)) {
                 throw pathError(input, 'PATH_INVALID_POSITION', 'Static Method is not in a valid position.', cursor);
@@ -180,7 +167,7 @@ function parseSteps(input, start, anchorKind) {
         steps.push({
             kind: 'traverse',
             direction,
-            class: parsedClass.classPath,
+            class: parsedClass.classKey,
             ...(slug === undefined ? {} : { slug }),
         });
     }
@@ -205,14 +192,10 @@ function parseQuotedClass(input, start) {
     const close = input.indexOf('"', start + 1);
     if (close < 0)
         invalidClass(input, start);
-    try {
-        return { classPath: ClassPath.parse(input.slice(start + 1, close)), end: close + 1 };
-    }
-    catch (error) {
-        if (error instanceof ClassPathError)
-            return invalidClass(input, start);
-        throw error;
-    }
+    const value = input.slice(start + 1, close);
+    if (!ClassKey.is(value))
+        invalidClass(input, start);
+    return { classKey: ClassKey(value), end: close + 1 };
 }
 function normalizeAnchor(value) {
     if (!isRecord(value))
@@ -298,9 +281,8 @@ function invalidProjection(input, position) {
     throw pathError(input, 'PATH_INVALID_PROJECTION', 'Domain projection reference is invalid.', position);
 }
 function invalidClass(input, position) {
-    throw pathError(input, 'PATH_INVALID_CLASS', 'Traversal ClassPath is invalid.', position);
+    throw pathError(input, 'PATH_INVALID_CLASS', 'Traversal ClassKey is invalid.', position);
 }
 function invalidEdgeSlug(input, position) {
     throw pathError(input, 'PATH_INVALID_EDGE_SLUG', 'Traversal Edge slug is invalid.', position);
 }
-//# sourceMappingURL=syntax.js.map

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

@@ -36,4 +36,3 @@ export declare function isDesiredProperties(value: Properties | DesiredPropertie
 export declare function combine(left: DesiredProperties, right: DesiredProperties): DesiredPropertiesResult;
 export declare function createDesiredProperties(values: Properties, absent: readonly PropertyKeyValue[]): DesiredProperties;
 export {};
-//# sourceMappingURL=index.d.ts.map

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

@@ -119,4 +119,3 @@ function compare(left, right) {
 function child(pointer, suffix) {
     return `${pointer}/${suffix}`;
 }
-//# sourceMappingURL=index.js.map

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

@@ -21,4 +21,3 @@ export declare function apply(current: Properties, delta: Delta): Properties;
 export declare function compose(first: Delta, second: Delta): Delta;
 export declare function createDelta(set: Properties, unset: readonly PropertyKeyValue[]): Delta;
 export {};
-//# sourceMappingURL=index.d.ts.map

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

@@ -101,4 +101,3 @@ function hasExactKeys(value, expected) {
 function child(pointer, suffix) {
     return `${pointer}/${suffix}`;
 }
-//# sourceMappingURL=index.js.map

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

@@ -12,4 +12,3 @@ export type { MergeConflict, MergeResult } from './merge/index.js';
 /** Compose complete-target and partial-condition Delta derivation behind the flat public facade. */
 export declare function delta(current: Properties, target: Properties): Delta | null;
 export declare function delta(current: Properties, desired: DesiredProperties): Delta | null;
-//# sourceMappingURL=index.d.ts.map

package/dist/graph/properties/index.js

@@ -9,4 +9,3 @@ export function delta(current, target) {
         ? conditionDelta(current, target)
         : completeDelta(current, target);
 }
-//# sourceMappingURL=index.js.map