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

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,8 @@
-import type { Key, schema } from '@astrale-os/kernel-dsl/v1';
+import type { DefinitionRef, Key } from '@astrale-os/kernel-dsl/v1/addressing';
+import { MethodKey } 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 +12,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;
+    static instanceMethod(source: Path, callable: MethodKey): Path.Method;
+    out(classKey: ClassKeyValue, options?: Path.TraversalOptions): Path;
+    in(classKey: ClassKeyValue, options?: Path.TraversalOptions): Path;
     equals(other: Path): boolean;
     toString(): NodePath;
     toJSON(): NodePath;
@@ -27,6 +30,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 +48,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 +72,3 @@ export declare namespace Path {
     type Diagnostic = PathDiagnostic;
 }
 export {};
-//# sourceMappingURL=path.d.ts.map

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

@@ -1,5 +1,7 @@
-import { ClassPath } from '../../class/index.js';
+import { MethodKey } from '@astrale-os/kernel-dsl/v1/addressing';
+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 +12,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,25 +44,29 @@ 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,
             steps: [...owner.ast.steps, { kind: 'method', dispatch: 'static', name }],
         }));
     }
-    static instanceMethod(source, name) {
+    static instanceMethod(source, callable) {
+        const { owner, name } = MethodKey.address(callable);
         return createPath(normalizePathAST({
             anchor: source.ast.anchor,
-            steps: [...source.ast.steps, { kind: 'method', dispatch: 'instance', name }],
+            steps: [
+                ...source.ast.steps,
+                { kind: 'method', dispatch: 'instance', class: ClassKey.of(owner), 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 +77,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 +86,7 @@ export class Path {
                 {
                     kind: 'traverse',
                     direction,
-                    class: ClassPath.parse(classPath),
+                    class: ClassKey(classKey),
                     ...(slug === undefined ? {} : { slug }),
                 },
             ],
@@ -85,8 +103,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 +136,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;
@@ -25,18 +25,23 @@ export interface ProjectionStep {
     readonly kind: 'projection';
     readonly projection: DomainProjection;
 }
-export interface MethodStep {
+export type MethodStep = {
     readonly kind: 'method';
-    readonly dispatch: 'static' | 'instance';
+    readonly dispatch: 'static';
     readonly name: string;
-}
+} | {
+    readonly kind: 'method';
+    readonly dispatch: 'instance';
+    readonly class: ClassKey;
+    readonly name: string;
+};
 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 +53,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 { patterns, MethodKey } from '@astrale-os/kernel-dsl/v1/addressing';
+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);
@@ -41,7 +34,9 @@ export function normalizePathAST(input) {
             continue;
         }
         if (candidate.kind === 'method') {
-            if (!hasExactKeys(candidate, ['kind', 'dispatch', 'name']))
+            if (!hasExactKeys(candidate, candidate.dispatch === 'instance'
+                ? ['kind', 'dispatch', 'class', 'name']
+                : ['kind', 'dispatch', 'name']))
                 invalidAST();
             if (candidate.dispatch !== 'static' && candidate.dispatch !== 'instance')
                 invalidAST();
@@ -52,11 +47,22 @@ 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();
                 }
             }
-            steps.push({ kind: 'method', dispatch: candidate.dispatch, name: candidate.name });
+            if (candidate.dispatch === 'instance') {
+                if (!ClassKey.is(candidate.class))
+                    invalidAST();
+                steps.push({
+                    kind: 'method',
+                    dispatch: 'instance',
+                    class: ClassKey(candidate.class),
+                    name: candidate.name,
+                });
+            }
+            else
+                steps.push({ kind: 'method', dispatch: 'static', name: candidate.name });
             continue;
         }
         if (candidate.kind === 'traverse') {
@@ -69,20 +75,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;
@@ -124,11 +124,12 @@ function parseSteps(input, start, anchorKind) {
     let cursor = start;
     while (cursor < input.length) {
         if (input.startsWith('::', cursor)) {
-            const name = input.slice(cursor + 2);
-            if (!patterns.memberName.test(name)) {
-                throw pathError(input, 'PATH_INVALID_METHOD', 'Invalid instance Method name.', cursor + 2);
+            const key = input.slice(cursor + 2);
+            if (!MethodKey.is(key)) {
+                throw pathError(input, 'PATH_INVALID_METHOD', 'Instance Method requires a complete domain-qualified Method key.', cursor + 2);
             }
-            steps.push({ kind: 'method', dispatch: 'instance', name });
+            const { owner, name } = MethodKey.address(key);
+            steps.push({ kind: 'method', dispatch: 'instance', class: ClassKey.of(owner), name });
             cursor = input.length;
             continue;
         }
@@ -143,7 +144,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 +181,7 @@ function parseSteps(input, start, anchorKind) {
         steps.push({
             kind: 'traverse',
             direction,
-            class: parsedClass.classPath,
+            class: parsedClass.classKey,
             ...(slug === undefined ? {} : { slug }),
         });
     }
@@ -205,14 +206,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))
@@ -251,7 +248,8 @@ function serializeNormalizedPathAST(ast) {
             output += `:${step.projection.kind}.${step.projection.name}`;
         }
         else if (step.kind === 'method') {
-            output += `${step.dispatch === 'instance' ? '::' : ':'}${step.name}`;
+            output +=
+                step.dispatch === 'instance' ? `::${step.class}.method.${step.name}` : `:${step.name}`;
         }
         else {
             output += `${step.direction === 'in' ? '<~' : '~'}"${step.class}"`;
@@ -298,9 +296,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

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

@@ -11,4 +11,3 @@ export type MergeResult = {
     readonly conflicts: readonly MergeConflict[];
 };
 export declare function merge(base: Properties, current: Properties, target: Properties): MergeResult;
-//# sourceMappingURL=index.d.ts.map

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

@@ -45,4 +45,3 @@ function equalState(left, right) {
 function compare(left, right) {
     return left < right ? -1 : left > right ? 1 : 0;
 }
-//# sourceMappingURL=index.js.map