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

package/dist/graph/graph/admission/model.d.ts

@@ -1,14 +1,15 @@
-import type { ClassPath } from '../../class/index.js';
+import type { ClassKey } from '@astrale-os/kernel-dsl/v1/addressing';
+import type { EdgeOrientation } from '@astrale-os/kernel-dsl/v1/language';
 import type { Properties } from '../../properties/index.js';
-export type EdgeOrientation = 'directed' | 'undirected';
-export type EdgeEndpoint = 'source' | 'target';
 export type GraphClassInfo = {
-    readonly path: ClassPath;
+    readonly key: ClassKey;
     readonly kind: 'node';
+    readonly abstract: boolean;
     readonly orientation?: never;
 } | {
-    readonly path: ClassPath;
+    readonly key: ClassKey;
     readonly kind: 'edge';
+    readonly abstract: boolean;
     readonly orientation: EdgeOrientation;
 };
 export interface GraphDiagnostic {
@@ -17,10 +18,9 @@ export interface GraphDiagnostic {
     readonly message: string;
 }
 export interface GraphAdmissionContext {
-    inspectClass(classPath: ClassPath): GraphClassInfo | undefined;
-    validateProperties(classPath: ClassPath, props: Properties): readonly GraphDiagnostic[];
-    validateEndpoint(edgeClass: ClassPath, endpoint: EdgeEndpoint, nodeClass: ClassPath): readonly GraphDiagnostic[];
+    inspectClass(classKey: ClassKey): GraphClassInfo | undefined;
+    validateProperties(classKey: ClassKey, props: Properties): readonly GraphDiagnostic[];
+    validateEndpoints(edgeClass: ClassKey, sourceClass: ClassKey | undefined, targetClass: ClassKey | undefined): readonly GraphDiagnostic[];
 }
 export declare function graphDiagnostic(code: string, path: string, message: string): GraphDiagnostic;
 export declare function sortGraphDiagnostics(diagnostics: readonly GraphDiagnostic[]): readonly GraphDiagnostic[];
-//# sourceMappingURL=model.d.ts.map

package/dist/graph/graph/admission/model.js

@@ -9,4 +9,3 @@ export function sortGraphDiagnostics(diagnostics) {
 function compareText(left, right) {
     return left < right ? -1 : left > right ? 1 : 0;
 }
-//# sourceMappingURL=model.js.map

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

@@ -1,4 +1,4 @@
-import type { ClassPath } from '../../class/index.js';
+import type { ClassKey } from '@astrale-os/kernel-dsl/v1/addressing';
 import type { EdgeCollection } from '../../edge/index.js';
 import type { NodeCollection, NodeId } from '../../node/index.js';
 import type { GraphData } from '../model/index.js';
@@ -18,8 +18,8 @@ export interface Delta {
 export interface DeltaConflict {
     readonly kind: 'node-class';
     readonly node: NodeId;
-    readonly left: ClassPath;
-    readonly right: ClassPath;
+    readonly left: ClassKey;
+    readonly right: ClassKey;
 }
 export type DeltaResult = {
     readonly kind: 'delta';
@@ -30,4 +30,3 @@ export type DeltaResult = {
 };
 export declare function delta(left: GraphDeltaSource, right: GraphDeltaSource): DeltaResult;
 export declare function apply(left: GraphDeltaSource, change: Delta): GraphData;
-//# sourceMappingURL=index.d.ts.map

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

@@ -79,4 +79,3 @@ function data(nodes, edges) {
 function invalid(message) {
     throw new TypeError(message);
 }
-//# sourceMappingURL=index.js.map

package/dist/graph/graph/graph.d.ts

@@ -26,4 +26,3 @@ export declare class Graph {
     toData(): GraphData;
     equals(other: Graph): boolean;
 }
-//# sourceMappingURL=graph.d.ts.map

package/dist/graph/graph/graph.js

@@ -30,8 +30,8 @@ export class Graph {
         this.#pathContext = Object.freeze({
             nodes: this.nodes,
             edges: this.edges,
-            orientation: (classPath) => {
-                const info = this.#indexes.classes.byPath.get(classPath);
+            orientation: (classKey) => {
+                const info = this.#indexes.classes.byKey.get(classKey);
                 return info?.kind === 'edge' ? info.orientation : undefined;
             },
         });
@@ -95,4 +95,3 @@ function equalEdge(left, right) {
         left.slug === right.slug &&
         equalProperties(left.props, right.props));
 }
-//# sourceMappingURL=graph.js.map

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

@@ -5,9 +5,8 @@ export type { MergeConflict, MergeResult } from './merge/index.js';
 export { GraphData, GraphDataDecodeError, GraphSpec, GraphSpecDecodeError } from './model/index.js';
 export type { AnonymousNodeSpec, GraphDataJson, GraphSpecEdge, GraphSpecEndpoint, GraphSpecJson, GraphSpecNode, } from './model/index.js';
 export { LocalBinding, isLocalBinding } from './model/index.js';
-export type { EdgeEndpoint, EdgeOrientation, GraphAdmissionContext, GraphClassInfo, GraphDiagnostic, } from './admission/index.js';
+export type { GraphAdmissionContext, GraphClassInfo, GraphDiagnostic } from './admission/index.js';
 export { GraphAdmissionError } from './admission/index.js';
 export type { GraphEdges, GraphNodes } from './indexes/index.js';
 export type { GraphPathContext, GraphPathWalker } from './navigation/index.js';
 export { GraphPathAmbiguousError, GraphPathWalkerRequiredError } from './navigation/index.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/graph/graph/index.js

@@ -4,4 +4,3 @@ export { GraphData, GraphDataDecodeError, GraphSpec, GraphSpecDecodeError } from
 export { LocalBinding, isLocalBinding } from './model/index.js';
 export { GraphAdmissionError } from './admission/index.js';
 export { GraphPathAmbiguousError, GraphPathWalkerRequiredError } from './navigation/index.js';
-//# sourceMappingURL=index.js.map

package/dist/graph/graph/indexes/collection.d.ts

@@ -1,4 +1,4 @@
-import type { ClassPath } from '../../class/index.js';
+import type { ClassKey } from '@astrale-os/kernel-dsl/v1/addressing';
 import type { EdgeCollection } from '../../edge/index.js';
 import type { NodeCollection } from '../../node/index.js';
 import type { GraphClassInfo } from '../admission/index.js';
@@ -7,5 +7,4 @@ export declare function createCollections(nodes: NodeCollection, edges: EdgeColl
     readonly nodes: GraphNodes;
     readonly edges: GraphEdges;
 };
-export declare function buildIndexes(nodes: NodeCollection, edges: EdgeCollection, classes: ReadonlyMap<ClassPath, GraphClassInfo>): GraphIndexes;
-//# sourceMappingURL=collection.d.ts.map
+export declare function buildIndexes(nodes: NodeCollection, edges: EdgeCollection, classes: ReadonlyMap<ClassKey, GraphClassInfo>): GraphIndexes;

package/dist/graph/graph/indexes/collection.js

@@ -7,19 +7,19 @@ export function createCollections(nodes, edges, indexes) {
         all: nodes,
         length: nodes.length,
         byId: (id) => indexes.nodes.byId.get(id),
-        byClass: (classPath) => indexes.nodes.byClass.get(classPath) ?? EMPTY_NODES,
+        byClass: (classKey) => indexes.nodes.byClass.get(classKey) ?? EMPTY_NODES,
     });
     const graphEdges = Object.freeze({
         all: edges,
         length: edges.length,
         byKey: (key) => indexes.edges.byKey.get(encodeEdgeKey(canonicalEdgeKey(key, indexes.classes))),
-        byClass: (classPath) => indexes.edges.byClass.get(classPath) ?? EMPTY_EDGES,
+        byClass: (classKey) => indexes.edges.byClass.get(classKey) ?? EMPTY_EDGES,
         incident: (id) => indexes.edges.byEndpoint.get(id) ?? EMPTY_EDGES,
     });
     return Object.freeze({ nodes: graphNodes, edges: graphEdges });
 }
 function canonicalEdgeKey(key, classes) {
-    const info = classes.byPath.get(key.class);
+    const info = classes.byKey.get(key.class);
     if (info?.kind !== 'edge' || info.orientation !== 'undirected')
         return key;
     if (compareNodeIds(key.source, key.target) <= 0)
@@ -27,7 +27,7 @@ function canonicalEdgeKey(key, classes) {
     return { source: key.target, target: key.source, class: key.class };
 }
 export function buildIndexes(nodes, edges, classes) {
-    const classByPath = new Map(classes);
+    const classByKey = new Map(classes);
     const nodeById = new Map();
     const edgeByKey = new Map();
     const nodesByClass = new Map();
@@ -54,7 +54,7 @@ export function buildIndexes(nodes, edges, classes) {
             byClass: edgesByClass,
             byEndpoint: edgesByEndpoint,
         }),
-        classes: Object.freeze({ byPath: classByPath }),
+        classes: Object.freeze({ byKey: classByKey }),
     });
 }
 function add(map, key, value) {
@@ -68,4 +68,3 @@ function freezeBuckets(map) {
     for (const [key, bucket] of map)
         map.set(key, Object.freeze(bucket));
 }
-//# sourceMappingURL=collection.js.map

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

@@ -1,3 +1,2 @@
 export type { GraphClassIndex, GraphEdgeIndex, GraphEdges, GraphIndexes, GraphNodeIndex, GraphNodes, } from './model.js';
 export { buildIndexes, createCollections } from './collection.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/graph/graph/indexes/index.js

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

package/dist/graph/graph/indexes/model.d.ts

@@ -1,4 +1,4 @@
-import type { ClassPath } from '../../class/index.js';
+import type { ClassKey } from '@astrale-os/kernel-dsl/v1/addressing';
 import type { Edge, EdgeCollection, EdgeKey } from '../../edge/index.js';
 import type { Node, NodeCollection, NodeId } from '../../node/index.js';
 import type { GraphClassInfo } from '../admission/index.js';
@@ -6,30 +6,29 @@ export interface GraphNodes {
     readonly all: NodeCollection;
     readonly length: number;
     byId(id: NodeId): Node | undefined;
-    byClass(classPath: ClassPath): NodeCollection;
+    byClass(classKey: ClassKey): NodeCollection;
 }
 export interface GraphEdges {
     readonly all: EdgeCollection;
     readonly length: number;
     byKey(key: EdgeKey): Edge | undefined;
-    byClass(classPath: ClassPath): EdgeCollection;
+    byClass(classKey: ClassKey): EdgeCollection;
     incident(id: NodeId): EdgeCollection;
 }
 export interface GraphNodeIndex {
     readonly byId: ReadonlyMap<NodeId, Node>;
-    readonly byClass: ReadonlyMap<ClassPath, readonly Node[]>;
+    readonly byClass: ReadonlyMap<ClassKey, readonly Node[]>;
 }
 export interface GraphEdgeIndex {
     readonly byKey: ReadonlyMap<string, Edge>;
-    readonly byClass: ReadonlyMap<ClassPath, readonly Edge[]>;
+    readonly byClass: ReadonlyMap<ClassKey, readonly Edge[]>;
     readonly byEndpoint: ReadonlyMap<NodeId, readonly Edge[]>;
 }
 export interface GraphClassIndex {
-    readonly byPath: ReadonlyMap<ClassPath, GraphClassInfo>;
+    readonly byKey: ReadonlyMap<ClassKey, GraphClassInfo>;
 }
 export interface GraphIndexes {
     readonly nodes: GraphNodeIndex;
     readonly edges: GraphEdgeIndex;
     readonly classes: GraphClassIndex;
 }
-//# sourceMappingURL=model.d.ts.map

package/dist/graph/graph/indexes/model.js

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

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

@@ -32,4 +32,3 @@ export type MergeResult = {
 };
 /** Apply exact three-way merge semantics to already canonical finite GraphData values. */
 export declare function mergeData(base: GraphData, current: GraphData, target: GraphData): MergeResult;
-//# sourceMappingURL=index.d.ts.map

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

@@ -44,8 +44,8 @@ function mergeNode(id, base, current, target) {
         return Object.freeze({ conflicts: [Object.freeze({ kind: 'node-presence', node: id })] });
     }
     const conflicts = [];
-    const classPath = mergeScalar(base.class, current.class, target.class);
-    if (classPath === CONFLICT)
+    const classKey = mergeScalar(base.class, current.class, target.class);
+    if (classKey === CONFLICT)
         conflicts.push(Object.freeze({ kind: 'node-class', node: id }));
     const props = properties.merge(base.props, current.props, target.props);
     if (props.kind === 'conflict') {
@@ -53,11 +53,11 @@ function mergeNode(id, base, current, target) {
             conflicts.push(Object.freeze({ kind: 'node-property', node: id, property: conflict.property }));
         }
     }
-    if (classPath === CONFLICT || props.kind === 'conflict') {
+    if (classKey === CONFLICT || props.kind === 'conflict') {
         return Object.freeze({ conflicts: Object.freeze(conflicts) });
     }
     return Object.freeze({
-        value: Object.freeze({ id, class: classPath, props: props.value }),
+        value: Object.freeze({ id, class: classKey, props: props.value }),
         conflicts: Object.freeze([]),
     });
 }
@@ -127,4 +127,3 @@ function edgeIndex(edges) {
 function data(nodes, edges) {
     return Object.freeze({ nodes: Object.freeze(nodes), edges: Object.freeze(edges) });
 }
-//# sourceMappingURL=index.js.map

package/dist/graph/graph/model/codec.d.ts

@@ -21,4 +21,3 @@ export declare function encodeGraphSpec(input: GraphSpecValue): GraphSpecJson;
 /** Strengthen unknown JSON into detached immutable structural graph facts. */
 export declare function decodeGraphData(input: unknown): GraphData;
 export declare function encodeGraphData(input: GraphData): GraphDataJson;
-//# sourceMappingURL=codec.d.ts.map

package/dist/graph/graph/model/codec.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 { edge as constructEdge, EdgeSlug } from '../../edge/index.js';
 import { node as constructNode, NodeId } from '../../node/index.js';
 import { NodePath } from '../../path/index.js';
@@ -28,7 +28,7 @@ export class GraphSpecDecodeError extends TypeError {
 /** Strengthen unknown JSON into detached immutable structural graph values. */
 export function decodeGraphSpec(input) {
     try {
-        const value = decodeWire(graphSpecSchema, portable.accept(input), specInvalid);
+        const value = decodeWire(graphSpecSchema, portable.acceptForRead(input), specInvalid);
         const nodes = value.nodes.map((node, index) => decodeSpecNode(node, `/nodes/${index}`));
         const edges = value.edges.map((edge, index) => decodeSpecEdge(edge, `/edges/${index}`));
         validateGraphSpec(nodes, edges);
@@ -94,18 +94,18 @@ export function encodeGraphData(input) {
     return encoded;
 }
 function decodeSpecNode(input, path) {
-    const classPath = decodeClassPath(input.class, `${path}/class`);
+    const classKey = decodeClassKey(input.class, `${path}/class`);
     const props = decodeProperties(input.props, `${path}/props`);
     if ('id' in input) {
-        return constructNode({ id: decodeNodeId(input.id, `${path}/id`), class: classPath, props });
+        return constructNode({ id: decodeNodeId(input.id, `${path}/id`), class: classKey, props });
     }
-    return Object.freeze({ as: binding(input.as, `${path}/as`), class: classPath, props });
+    return Object.freeze({ as: binding(input.as, `${path}/as`), class: classKey, props });
 }
 function decodeSpecEdge(input, path) {
     return Object.freeze({
         source: decodeEndpoint(input.source, `${path}/source`),
         target: decodeEndpoint(input.target, `${path}/target`),
-        class: decodeClassPath(input.class, `${path}/class`),
+        class: decodeClassKey(input.class, `${path}/class`),
         ...(input.slug === undefined ? {} : { slug: decodeEdgeSlug(input.slug, `${path}/slug`) }),
         props: decodeProperties(input.props, `${path}/props`),
     });
@@ -202,13 +202,10 @@ function invalid(path, message) {
 function specInvalid(path, message, options) {
     throw new GraphSpecDecodeError(path, message, options);
 }
-function decodeClassPath(input, path) {
-    try {
-        return ClassPath.parse(input);
-    }
-    catch (error) {
-        specInvalid(path, 'Invalid ClassPath', { cause: error });
-    }
+function decodeClassKey(input, path) {
+    if (!ClassKey.is(input))
+        specInvalid(path, 'Invalid ClassKey');
+    return ClassKey(input);
 }
 function decodeNodeId(input, path) {
     try {
@@ -237,4 +234,3 @@ function decodeProperties(input, path) {
 function errorPointer(error, fallback = '') {
     return error instanceof portable.BoundaryError ? error.pointer : fallback;
 }
-//# sourceMappingURL=codec.js.map

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

@@ -15,4 +15,3 @@ export declare const GraphSpec: {
 export type { AnonymousNodeSpec, GraphSpecEdge, GraphSpecEndpoint, GraphSpecJson, GraphSpecNode, } from './model.js';
 export { LocalBinding, isLocalBinding } from './model.js';
 export { GraphSpecDecodeError } from './codec.js';
-//# sourceMappingURL=index.d.ts.map

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

@@ -4,4 +4,3 @@ export { GraphDataDecodeError } from './codec.js';
 export const GraphSpec = Object.freeze({ decode: decodeGraphSpec, encode: encodeGraphSpec });
 export { LocalBinding, isLocalBinding } from './model.js';
 export { GraphSpecDecodeError } from './codec.js';
-//# sourceMappingURL=index.js.map

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

@@ -65,4 +65,3 @@ export interface GraphDataJson extends GraphSpecJson {
     }[];
 }
 export {};
-//# sourceMappingURL=model.d.ts.map

package/dist/graph/graph/model/model.js

@@ -8,4 +8,3 @@ export function LocalBinding(input) {
 export function isLocalBinding(input) {
     return typeof input === 'string' && LOCAL_BINDING_PATTERN.test(input);
 }
-//# sourceMappingURL=model.js.map

package/dist/graph/graph/model/wire.d.ts

@@ -1,80 +1,79 @@
-import { z } from 'zod';
+import { type ZodType } from 'zod';
 import { type EdgeSlug } from '../../edge/index.js';
-export declare const graphNodeSchema: z.ZodObject<{
-    id: z.ZodString;
-    class: z.ZodString;
-    props: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-}, z.core.$strict>;
-export declare const anonymousGraphNodeSchema: z.ZodObject<{
-    as: z.ZodString;
-    class: z.ZodString;
-    props: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-}, z.core.$strict>;
-export declare const edgeKeySchema: z.ZodObject<{
-    source: z.ZodString;
-    target: z.ZodString;
-    class: z.ZodString;
-}, z.core.$strict>;
-export declare const graphEdgeSchema: z.ZodObject<{
-    source: z.ZodString;
-    target: z.ZodString;
-    class: z.ZodString;
-    slug: z.ZodOptional<z.ZodType<EdgeSlug, unknown, z.core.$ZodTypeInternals<EdgeSlug, unknown>>>;
-    props: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-}, z.core.$strict>;
-export declare const graphSpecEdgeSchema: z.ZodObject<{
-    source: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-        path: z.ZodString;
-    }, z.core.$strict>, z.ZodObject<{
-        created: z.ZodString;
-    }, z.core.$strict>]>;
-    target: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-        path: z.ZodString;
-    }, z.core.$strict>, z.ZodObject<{
-        created: z.ZodString;
-    }, z.core.$strict>]>;
-    class: z.ZodString;
-    slug: z.ZodOptional<z.ZodType<EdgeSlug, unknown, z.core.$ZodTypeInternals<EdgeSlug, unknown>>>;
-    props: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-}, z.core.$strict>;
-export declare const graphSpecSchema: z.ZodObject<{
-    nodes: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
-        id: z.ZodString;
-        class: z.ZodString;
-        props: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-    }, z.core.$strict>, z.ZodObject<{
-        as: z.ZodString;
-        class: z.ZodString;
-        props: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-    }, z.core.$strict>]>>;
-    edges: z.ZodArray<z.ZodObject<{
-        source: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-            path: z.ZodString;
-        }, z.core.$strict>, z.ZodObject<{
-            created: z.ZodString;
-        }, z.core.$strict>]>;
-        target: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-            path: z.ZodString;
-        }, z.core.$strict>, z.ZodObject<{
-            created: z.ZodString;
-        }, z.core.$strict>]>;
-        class: z.ZodString;
-        slug: z.ZodOptional<z.ZodType<EdgeSlug, unknown, z.core.$ZodTypeInternals<EdgeSlug, unknown>>>;
-        props: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-export declare const graphDataSchema: z.ZodObject<{
-    nodes: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        class: z.ZodString;
-        props: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-    }, z.core.$strict>>;
-    edges: z.ZodArray<z.ZodObject<{
-        source: z.ZodString;
-        target: z.ZodString;
-        class: z.ZodString;
-        slug: z.ZodOptional<z.ZodType<EdgeSlug, unknown, z.core.$ZodTypeInternals<EdgeSlug, unknown>>>;
-        props: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-//# sourceMappingURL=wire.d.ts.map
+export declare const graphNodeSchema: import("zod").ZodObject<{
+    id: import("zod").ZodString;
+    class: import("zod").ZodString;
+    props: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+}, import("zod/v4/core").$strict>;
+export declare const anonymousGraphNodeSchema: import("zod").ZodObject<{
+    as: import("zod").ZodString;
+    class: import("zod").ZodString;
+    props: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+}, import("zod/v4/core").$strict>;
+export declare const edgeKeySchema: import("zod").ZodObject<{
+    source: import("zod").ZodString;
+    target: import("zod").ZodString;
+    class: import("zod").ZodString;
+}, import("zod/v4/core").$strict>;
+export declare const graphEdgeSchema: import("zod").ZodObject<{
+    source: import("zod").ZodString;
+    target: import("zod").ZodString;
+    class: import("zod").ZodString;
+    slug: import("zod").ZodOptional<ZodType<EdgeSlug, unknown, import("zod/v4/core").$ZodTypeInternals<EdgeSlug, unknown>>>;
+    props: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+}, import("zod/v4/core").$strict>;
+export declare const graphSpecEdgeSchema: import("zod").ZodObject<{
+    source: import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodObject<{
+        path: import("zod").ZodString;
+    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+        created: import("zod").ZodString;
+    }, import("zod/v4/core").$strict>]>;
+    target: import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodObject<{
+        path: import("zod").ZodString;
+    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+        created: import("zod").ZodString;
+    }, import("zod/v4/core").$strict>]>;
+    class: import("zod").ZodString;
+    slug: import("zod").ZodOptional<ZodType<EdgeSlug, unknown, import("zod/v4/core").$ZodTypeInternals<EdgeSlug, unknown>>>;
+    props: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+}, import("zod/v4/core").$strict>;
+export declare const graphSpecSchema: import("zod").ZodObject<{
+    nodes: import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+        id: import("zod").ZodString;
+        class: import("zod").ZodString;
+        props: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+        as: import("zod").ZodString;
+        class: import("zod").ZodString;
+        props: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+    }, import("zod/v4/core").$strict>]>>;
+    edges: import("zod").ZodArray<import("zod").ZodObject<{
+        source: import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodObject<{
+            path: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            created: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>]>;
+        target: import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodObject<{
+            path: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            created: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>]>;
+        class: import("zod").ZodString;
+        slug: import("zod").ZodOptional<ZodType<EdgeSlug, unknown, import("zod/v4/core").$ZodTypeInternals<EdgeSlug, unknown>>>;
+        props: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+    }, import("zod/v4/core").$strict>>;
+}, import("zod/v4/core").$strict>;
+export declare const graphDataSchema: import("zod").ZodObject<{
+    nodes: import("zod").ZodArray<import("zod").ZodObject<{
+        id: import("zod").ZodString;
+        class: import("zod").ZodString;
+        props: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+    }, import("zod/v4/core").$strict>>;
+    edges: import("zod").ZodArray<import("zod").ZodObject<{
+        source: import("zod").ZodString;
+        target: import("zod").ZodString;
+        class: import("zod").ZodString;
+        slug: import("zod").ZodOptional<ZodType<EdgeSlug, unknown, import("zod/v4/core").$ZodTypeInternals<EdgeSlug, unknown>>>;
+        props: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+    }, import("zod/v4/core").$strict>>;
+}, import("zod/v4/core").$strict>;

package/dist/graph/graph/model/wire.js

@@ -1,36 +1,34 @@
-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, record, strictObject, string, union, unknown as unknownSchema, } from 'zod';
 import { edgeSlugSchema } from '../../edge/index.js';
-const text = z.string().min(1);
-const props = z.record(z.string(), z.unknown());
-const binding = z.string().regex(/^[A-Za-z][A-Za-z0-9_]{0,63}$/u);
-const edgeSlug = z
-    .string()
+const text = string().min(1);
+const props = record(string(), unknownSchema());
+const binding = string().regex(/^[A-Za-z][A-Za-z0-9_]{0,63}$/u);
+const edgeSlug = string()
     .min(edgeSlugSchema.minLength)
     .max(edgeSlugSchema.maxLength)
     .check(fullMatch(edgeSlugSchema.fullMatch));
-export const graphNodeSchema = z.strictObject({ id: text, class: text, props });
-export const anonymousGraphNodeSchema = z.strictObject({ as: binding, class: text, props });
-export const edgeKeySchema = z.strictObject({ source: text, target: text, class: text });
+export const graphNodeSchema = strictObject({ id: text, class: text, props });
+export const anonymousGraphNodeSchema = strictObject({ as: binding, class: text, props });
+export const edgeKeySchema = strictObject({ source: text, target: text, class: text });
 export const graphEdgeSchema = edgeKeySchema.extend({ slug: edgeSlug.optional(), props });
-const graphSpecEndpointSchema = z.union([
+const graphSpecEndpointSchema = union([
     text,
-    z.strictObject({ path: text }),
-    z.strictObject({ created: binding }),
+    strictObject({ path: text }),
+    strictObject({ created: binding }),
 ]);
-export const graphSpecEdgeSchema = z.strictObject({
+export const graphSpecEdgeSchema = strictObject({
     source: graphSpecEndpointSchema,
     target: graphSpecEndpointSchema,
     class: text,
     slug: edgeSlug.optional(),
     props,
 });
-export const graphSpecSchema = z.strictObject({
-    nodes: z.array(z.union([graphNodeSchema, anonymousGraphNodeSchema])),
-    edges: z.array(graphSpecEdgeSchema),
+export const graphSpecSchema = strictObject({
+    nodes: array(union([graphNodeSchema, anonymousGraphNodeSchema])),
+    edges: array(graphSpecEdgeSchema),
 });
-export const graphDataSchema = z.strictObject({
-    nodes: z.array(graphNodeSchema),
-    edges: z.array(graphEdgeSchema),
+export const graphDataSchema = strictObject({
+    nodes: array(graphNodeSchema),
+    edges: array(graphEdgeSchema),
 });
-//# sourceMappingURL=wire.js.map

package/dist/graph/graph/navigation/error.d.ts

@@ -10,4 +10,3 @@ export declare class GraphPathWalkerRequiredError extends Error {
     readonly code: 'GRAPH_PATH_WALKER_REQUIRED';
     constructor(path: NodePath);
 }
-//# sourceMappingURL=error.d.ts.map

package/dist/graph/graph/navigation/error.js

@@ -18,4 +18,3 @@ export class GraphPathWalkerRequiredError extends Error {
         this.name = 'GraphPathWalkerRequiredError';
     }
 }
-//# sourceMappingURL=error.js.map

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

@@ -1,3 +1,2 @@
 export type { GraphPathContext, GraphPathWalker } from './model.js';
 export { GraphPathAmbiguousError, GraphPathWalkerRequiredError } from './error.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/graph/graph/navigation/index.js

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

package/dist/graph/graph/navigation/model.d.ts

@@ -1,16 +1,15 @@
-import type { ClassPath } from '../../class/index.js';
+import type { ClassKey } from '@astrale-os/kernel-dsl/v1/addressing';
+import type { EdgeOrientation } from '@astrale-os/kernel-dsl/v1/language';
 import type { Node } from '../../node/index.js';
 import type { Path } from '../../path/index.js';
-import type { EdgeOrientation } from '../admission/index.js';
 import type { GraphEdges, GraphNodes } from '../indexes/index.js';
 /** Semantic read-only graph capabilities available to a Path walker. */
 export interface GraphPathContext {
     readonly nodes: GraphNodes;
     readonly edges: GraphEdges;
-    orientation(classPath: ClassPath): EdgeOrientation | undefined;
+    orientation(classKey: ClassKey): EdgeOrientation | undefined;
 }
 /** Pure injected semantics for walking one Path against an admitted Graph. */
 export interface GraphPathWalker {
     walk(path: Path, context: GraphPathContext): Node | undefined;
 }
-//# sourceMappingURL=model.d.ts.map

package/dist/graph/graph/navigation/model.js

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