@astrale-os/kernel-core 0.9.0-beta.4 → 0.9.0-beta.41

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

@@ -1,79 +1,75 @@
 import { patterns } from '@astrale-os/kernel-dsl/v1/addressing';
-import { fullMatch } from '@astrale-os/kernel-dsl/v1/schema/full-match';
-import { z } from 'zod';
+import { fullMatch } from '@astrale-os/kernel-dsl/v1/value/full-match';
+import { array, discriminatedUnion, literal, record, strictObject, string, union, unknown as unknownSchema, } from 'zod';
 import { edgeSlugSchema } from '../../edge/index.js';
 import { queryAstSchema } from '../../query/language/index.js';
 import { MUTATION_AST_FORMAT, MUTATION_AST_LIMITS, MUTATION_AST_VERSION } from './model.js';
-const text = z.string().min(1);
-const binding = z.string().min(1).max(64);
-const propertyKey = z.string().check(fullMatch(patterns.propertyKeyFullMatch));
-const props = z.record(propertyKey, z.unknown());
-const patch = z.strictObject({ set: props, unset: z.array(propertyKey) });
-const endpoint = z.union([text, z.strictObject({ created: binding })]);
-const edgeSelector = z.strictObject({ source: text, target: text, class: text });
-const edgeSlug = z
-    .string()
+const text = string().min(1);
+const binding = string().min(1).max(64);
+const propertyKey = string().check(fullMatch(patterns.propertyKeyFullMatch));
+const props = record(propertyKey, unknownSchema());
+const patch = strictObject({ set: props, unset: array(propertyKey) });
+const endpoint = union([text, strictObject({ created: binding })]);
+const edgeSelector = strictObject({ source: text, target: text, class: text });
+const edgeSlug = string()
     .min(edgeSlugSchema.minLength)
     .max(edgeSlugSchema.maxLength)
     .check(fullMatch(edgeSlugSchema.fullMatch));
-const edgeUpdateWithSlug = z.strictObject({
-    op: z.literal('edge.update'),
+const edgeUpdateWithSlug = strictObject({
+    op: literal('edge.update'),
     edge: edgeSelector,
     slug: edgeSlug.nullable(),
     props: patch.optional(),
 });
-const edgeUpdateWithProperties = z.strictObject({
-    op: z.literal('edge.update'),
+const edgeUpdateWithProperties = strictObject({
+    op: literal('edge.update'),
     edge: edgeSelector,
     props: patch,
 });
-const propertyConditions = z.union([
-    z.strictObject({ equals: props, absent: z.array(propertyKey).optional() }),
-    z.strictObject({ absent: z.array(propertyKey).min(1) }),
+const propertyConditions = union([
+    strictObject({ equals: props, absent: array(propertyKey).optional() }),
+    strictObject({ absent: array(propertyKey).min(1) }),
 ]);
-const expectedSelection = z.discriminatedUnion('kind', [
-    z.strictObject({
-        kind: z.literal('node'),
-        ids: z.array(text).max(MUTATION_AST_LIMITS.queryExpectedIdentities),
+const expectedSelection = discriminatedUnion('kind', [
+    strictObject({
+        kind: literal('node'),
+        ids: array(text).max(MUTATION_AST_LIMITS.queryExpectedIdentities),
     }),
-    z.strictObject({
-        kind: z.literal('edge'),
-        keys: z
-            .array(z.strictObject({ source: text, target: text, class: text }))
-            .max(MUTATION_AST_LIMITS.queryExpectedIdentities),
+    strictObject({
+        kind: literal('edge'),
+        keys: array(strictObject({ source: text, target: text, class: text })).max(MUTATION_AST_LIMITS.queryExpectedIdentities),
     }),
 ]);
-const precondition = z.union([
-    z.strictObject({
-        kind: z.literal('node'),
+const precondition = union([
+    strictObject({
+        kind: literal('node'),
         node: text,
         class: text,
         props: propertyConditions.optional(),
     }),
-    z.strictObject({
-        kind: z.literal('edge'),
+    strictObject({
+        kind: literal('edge'),
         edge: edgeSelector,
         slug: edgeSlug.nullable().optional(),
         props: propertyConditions.optional(),
     }),
-    z.strictObject({
-        kind: z.literal('query'),
+    strictObject({
+        kind: literal('query'),
         query: queryAstSchema,
         equals: expectedSelection,
     }),
 ]);
 /** Structural JSON contract; decodeMutationAST owns paths, bindings and atomic semantics. */
-export const mutationAstSchema = z.strictObject({
-    format: z.literal(MUTATION_AST_FORMAT),
-    version: z.literal(MUTATION_AST_VERSION),
-    preconditions: z.array(precondition).max(MUTATION_AST_LIMITS.preconditions),
-    operations: z
-        .array(z.union([
-        z.strictObject({ op: z.literal('node.create'), as: binding, class: text, props }),
-        z.strictObject({ op: z.literal('node.update'), node: text, class: text, props: patch }),
-        z.strictObject({ op: z.literal('node.delete'), node: text, class: text }),
-        z.strictObject({
-            op: z.literal('edge.create'),
+export const mutationAstSchema = strictObject({
+    format: literal(MUTATION_AST_FORMAT),
+    version: literal(MUTATION_AST_VERSION),
+    preconditions: array(precondition).max(MUTATION_AST_LIMITS.preconditions),
+    operations: array(union([
+        strictObject({ op: literal('node.create'), as: binding, class: text, props }),
+        strictObject({ op: literal('node.update'), node: text, class: text, props: patch }),
+        strictObject({ op: literal('node.delete'), node: text, class: text }),
+        strictObject({
+            op: literal('edge.create'),
             class: text,
             source: endpoint,
             target: endpoint,
@@ -82,8 +78,6 @@ export const mutationAstSchema = z.strictObject({
         }),
         edgeUpdateWithSlug,
         edgeUpdateWithProperties,
-        z.strictObject({ op: z.literal('edge.delete'), edge: edgeSelector }),
-    ]))
-        .min(1),
+        strictObject({ op: literal('edge.delete'), edge: edgeSelector }),
+    ])).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

@@ -1,5 +1,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
+export declare const mutationResultSchema: import("zod").ZodObject<{
+    createdNodes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
+}, import("zod/v4/core").$strict>;

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

@@ -1,5 +1,4 @@
-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
+import { record, strictObject, string } from 'zod';
+const text = string().min(1);
+const binding = string().min(1).max(64);
+export const mutationResultSchema = strictObject({ createdNodes: record(binding, text) });

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

@@ -1,4 +1,3 @@
-import { z } from 'zod';
 declare const NODE_ID_BRAND: unique symbol;
 /** Stable opaque identity: 1-255 ASCII characters from [A-Za-z0-9._-]. */
 export type NodeId = string & {
@@ -12,8 +11,7 @@ export declare class NodeIdError extends TypeError {
 /** Admit opaque 1-255 character ASCII NodeId text without repair or format-specific semantics. */
 export declare function NodeId(input: string): NodeId;
 export declare function isNodeId(input: unknown): input is NodeId;
-export declare const nodeIdSchema: z.ZodPipe<z.ZodString & z.ZodType<NodeId, string, z.core.$ZodTypeInternals<NodeId, string>>, z.ZodTransform<NodeId, string & {
+export declare const nodeIdSchema: import("zod").ZodPipe<import("zod").ZodString & import("zod").ZodType<NodeId, string, import("zod/v4/core").$ZodTypeInternals<NodeId, string>>, import("zod").ZodTransform<NodeId, string & {
     readonly [NODE_ID_BRAND]: true;
 }>>;
 export {};
-//# sourceMappingURL=id.d.ts.map

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

@@ -1,4 +1,4 @@
-import { z } from 'zod';
+import { string } from 'zod';
 const NODE_ID_MAX_LENGTH = 255;
 const NODE_ID_INVALID_CHARACTER = /[^A-Za-z0-9._-]/u;
 const NODE_ID_ERROR_MESSAGE = 'NodeId must be 1-255 ASCII characters drawn from [A-Za-z0-9._-].';
@@ -23,8 +23,6 @@ export function isNodeId(input) {
         input.length <= NODE_ID_MAX_LENGTH &&
         !NODE_ID_INVALID_CHARACTER.test(input));
 }
-export const nodeIdSchema = z
-    .string()
+export const nodeIdSchema = 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 { 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. */
@@ -11,15 +11,17 @@ export declare class Path {
     private constructor();
     /** Retain an admitted rich Path or parse its canonical serialized form. */
     static from(input: PathLike): Path;
+    /** Normalize an exact graph target without resolving its installed Node identity. */
+    static target(input: NodeTarget): Path;
     static parse(input: string): 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 +29,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; DefinitionRefs address their projected graph nodes, not Class extents. */
+export type NodeTarget = NodeId | PathLike | DefinitionRef;
 /** Runtime-established proof that a Path addresses one callable Node. */
 export type CallablePath = Path & {
     readonly [CALLABLE_PATH]: true;
@@ -43,7 +47,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;
     interface TraversalOptions {
         readonly slug?: EdgeSlugValue;
     }
@@ -66,4 +71,3 @@ export declare namespace Path {
     type Diagnostic = PathDiagnostic;
 }
 export {};
-//# sourceMappingURL=path.d.ts.map

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

@@ -1,5 +1,6 @@
-import { ClassPath } from '../../class/index.js';
+import { ClassKey, isDefinitionRef, } from '@astrale-os/kernel-dsl/v1/addressing';
 import { EdgeSlug } from '../../edge/slug/index.js';
+import { isNodeId } from '../../node/identity/index.js';
 import { normalizePathAST, parsePathAST, pathError, serializePathAST } from '../language/index.js';
 /** Immutable rich value for one admitted NodePath. */
 export class Path {
@@ -10,6 +11,18 @@ export class Path {
     static from(input) {
         return input instanceof Path ? input : Path.parse(input);
     }
+    /** Normalize an exact graph target without resolving its installed Node identity. */
+    static target(input) {
+        if (input instanceof Path)
+            return input;
+        if (isNodeId(input))
+            return Path.id(input);
+        if (typeof input === 'string')
+            return Path.parse(input);
+        if (isDefinitionRef(input))
+            return Path.project(input);
+        throw pathError(input, 'PATH_INVALID_PROJECTION', 'Node target requires an ID, Path, or DefinitionRef.');
+    }
     static parse(input) {
         return createPath(parsePathAST(input));
     }
@@ -30,8 +43,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 +57,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 +72,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 +81,7 @@ export class Path {
                 {
                     kind: 'traverse',
                     direction,
-                    class: ClassPath.parse(classPath),
+                    class: ClassKey(classKey),
                     ...(slug === undefined ? {} : { slug }),
                 },
             ],
@@ -85,8 +98,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 +131,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