@astrale-os/kernel-core 0.9.0-beta.35 → 0.9.0-beta.36

package/dist/auth/authority/normalization/normalize.js

@@ -89,7 +89,8 @@ function normalizeBoolean(op, input, path, locals, subjectBound) {
     for (const expr of flattened) {
         if (expr.op === identity)
             continue;
-        unique.set(portable.json.serialize(expr), expr);
+        // Admission and normalization own these detached subtrees; sorting does not lose that proof.
+        unique.set(portable.json.serializeAdmitted(expr), expr);
     }
     const predicates = [...unique.entries()]
         .sort(([left], [right]) => compare(left, right))

package/dist/graph/mutate/authoring/create.js

@@ -1,5 +1,4 @@
-import { isNodeId } from '../../node/index.js';
-import { Path } from '../../path/index.js';
+import { Path, PathError } from '../../path/index.js';
 import { MutationLanguage } from '../language/index.js';
 /** Lower rich TypeScript inputs into the one canonical public MutationAST representation. */
 export function createMutationAST(input) {
@@ -69,6 +68,9 @@ function lowerOperation(operation) {
     }
 }
 function lowerEndpoint(endpoint) {
+    if (typeof endpoint === 'object' && endpoint !== null && 'kind' in endpoint) {
+        return nodeTargetText(endpoint);
+    }
     return typeof endpoint === 'object' && endpoint !== null && 'created' in endpoint
         ? endpoint
         : nodeTargetText(endpoint);
@@ -84,9 +86,15 @@ function pathText(path) {
     return nodeTargetText(path);
 }
 function nodeTargetText(target) {
-    if (target instanceof Path)
-        return target.raw;
-    return isNodeId(target) ? Path.id(target).raw : target;
+    try {
+        return Path.target(target).raw;
+    }
+    catch (cause) {
+        // The Mutation codec owns invalid-input errors and their operation/precondition coordinates.
+        if (cause instanceof PathError)
+            return target;
+        throw cause;
+    }
 }
 function mutationProps(input) {
     return input;

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

@@ -1,4 +1,4 @@
-import type { CoreRef, DefinitionRef, Key } from '@astrale-os/kernel-dsl/v1/addressing';
+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';
@@ -11,6 +11,8 @@ 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;
@@ -27,8 +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 accepted by ID-first graph authoring facades. */
-export type NodeTarget = NodeId | PathLike;
+/** 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;
@@ -46,7 +48,7 @@ export declare namespace Path {
     type ProjectionKind = PathProjectionKind;
     type DomainProjection = PathDomainProjection;
     /** Structured coordinate accepted for a graph-projected Definition or Core object. */
-    type ProjectionRef = DefinitionRef<'class' | 'function' | 'policy' | 'view'> | CoreRef;
+    type ProjectionRef = DefinitionRef;
     interface TraversalOptions {
         readonly slug?: EdgeSlugValue;
     }

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

@@ -1,5 +1,6 @@
-import { ClassKey } 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 +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));
     }

package/dist/graph/query/authoring/builder.js

@@ -1,6 +1,5 @@
 import { ClassKey, PropertyKey, } from '@astrale-os/kernel-dsl/v1/addressing';
 import * as portable from '@astrale-os/kernel-dsl/value';
-import { isNodeId } from '../../node/index.js';
 import { Path } from '../../path/index.js';
 import { QueryAST as QueryASTBoundary, QueryASTDecodeError } from '../language/index.js';
 function from(input) {
@@ -373,9 +372,15 @@ function lowerNodeSource(input, index) {
     if (ClassKey.is(input)) {
         return Object.freeze({ kind: 'class', class: ClassKey.ref(input) });
     }
-    if (input instanceof Path || typeof input === 'string') {
+    if (input instanceof Path ||
+        typeof input === 'string' ||
+        (isRecord(input) &&
+            (input.kind === 'core' ||
+                input.kind === 'function' ||
+                input.kind === 'policy' ||
+                input.kind === 'view'))) {
         try {
-            const target = input instanceof Path ? input : isNodeId(input) ? Path.id(input) : Path.parse(input);
+            const target = Path.target(input);
             return Object.freeze({ kind: 'path', path: target.raw });
         }
         catch (cause) {

package/dist/schema/kernel/schema.d.ts

@@ -5625,6 +5625,16 @@ export declare const AuthorityRelations: Readonly<{
 }>;
 /** Exact authorized Kernel Functions for which pristine Root receives direct can_use authority. */
 export declare const KernelRootFunctions: readonly ((import("@astrale-os/kernel-dsl/v1").ResolvedFunction<{
+    kind: "bundle" | "inspect";
+    origin: string;
+}, {
+    readonly mode: 'binary';
+}, "authenticated", import("@astrale-os/kernel-dsl/v1").PolicyCheckExpression<import("@astrale-os/kernel-dsl/v1").PolicyRef, import("@astrale-os/kernel-dsl/v1/language").PolicyCheckObject>> & {
+    readonly ref: import("@astrale-os/kernel-dsl/v1").FunctionRef<"introspect"> & {
+        readonly origin: "kernel.astrale.ai";
+    };
+    readonly key: "kernel.astrale.ai:function.introspect";
+}) | (import("@astrale-os/kernel-dsl/v1").ResolvedFunction<{
     operation: string;
     domains: ({
         artifact: {
@@ -5650,15 +5660,232 @@ export declare const KernelRootFunctions: readonly ((import("@astrale-os/kernel-
     };
     readonly key: "kernel.astrale.ai:function.install";
 }) | (import("@astrale-os/kernel-dsl/v1").ResolvedFunction<{
-    kind: "bundle" | "inspect";
-    origin: string;
+    ast: {
+        format: "astrale.graph.query";
+        version: "v6";
+        source: {
+            kind: "node";
+            terms: ({
+                kind: "path";
+                path: string;
+            } | {
+                kind: "class";
+                class: {
+                    origin: string;
+                    kind: "class";
+                    name: string;
+                };
+            })[];
+            binding: string;
+        } | {
+            kind: "edge";
+            terms: {
+                kind: "class";
+                class: {
+                    origin: string;
+                    kind: "class";
+                    name: string;
+                };
+            }[];
+            bindings: {
+                source: string;
+                edge: string;
+                target: string;
+            };
+        };
+        steps: ({
+            op: "filter";
+            binding: string;
+            predicate: {
+                kind: "class.satisfies";
+                class: {
+                    origin: string;
+                    kind: "class";
+                    name: string;
+                };
+            } | {
+                kind: "class.equal";
+                class: {
+                    origin: string;
+                    kind: "class";
+                    name: string;
+                };
+            } | {
+                kind: "property.equal";
+                property: string;
+                value: unknown;
+            } | {
+                kind: "property.present";
+                property: string;
+            } | {
+                kind: "identity.equal";
+                identity: string | {
+                    source: string;
+                    target: string;
+                    class: string;
+                };
+            };
+        } | {
+            op: "expand";
+            from: string;
+            via: {
+                origin: string;
+                kind: "class";
+                name: string;
+            }[];
+            direction: "incident" | "incoming" | "outgoing";
+            bindings: {
+                edge: string;
+                node: string;
+            };
+        })[];
+        select: {
+            kind: "graph";
+            binding: string;
+            order?: {
+                property: string;
+                direction: "asc" | "desc";
+                unranked: "first" | "last";
+            } | undefined;
+        } | {
+            kind: "nodes";
+            binding: string;
+            projection: {
+                kind: "reference" | "value";
+            };
+            order?: {
+                property: string;
+                direction: "asc" | "desc";
+                unranked: "first" | "last";
+            } | undefined;
+        } | {
+            kind: "edges";
+            binding: string;
+            projection: {
+                edge: "reference" | "value";
+                source: "reference" | "value";
+                target: "reference" | "value";
+            };
+            order?: {
+                property: string;
+                direction: "asc" | "desc";
+                unranked: "first" | "last";
+            } | undefined;
+        };
+    };
+    expected?: {
+        origin: string;
+        revision: string;
+    }[] | undefined;
+    page: {
+        size: number;
+        after?: string | undefined;
+    };
 }, {
-    readonly mode: 'binary';
-}, "authenticated", import("@astrale-os/kernel-dsl/v1").PolicyCheckExpression<import("@astrale-os/kernel-dsl/v1").PolicyRef, import("@astrale-os/kernel-dsl/v1/language").PolicyCheckObject>> & {
-    readonly ref: import("@astrale-os/kernel-dsl/v1").FunctionRef<"introspect"> & {
+    readonly mode: 'value';
+    readonly value: {
+        result: {
+            kind: "graph";
+            graph: {
+                nodes: {
+                    id: string;
+                    class: string;
+                    props: Record<string, unknown>;
+                }[];
+                edges: {
+                    source: string;
+                    target: string;
+                    class: string;
+                    slug?: import("../../graph/edge/index.js").EdgeSlug | undefined;
+                    props: Record<string, unknown>;
+                }[];
+            };
+            selection: {
+                kind: "node";
+                ids: string[];
+            } | {
+                kind: "edge";
+                keys: {
+                    source: string;
+                    target: string;
+                    class: string;
+                }[];
+            };
+        } | {
+            kind: "nodes";
+            nodes: ({
+                kind: "reference";
+                value: {
+                    id: string;
+                    class: string;
+                };
+            } | {
+                kind: "value";
+                value: {
+                    id: string;
+                    class: string;
+                    props: Record<string, unknown>;
+                };
+            })[];
+        } | {
+            kind: "edges";
+            edges: {
+                edge: {
+                    kind: "reference";
+                    value: {
+                        source: string;
+                        target: string;
+                        class: string;
+                    };
+                } | {
+                    kind: "value";
+                    value: {
+                        source: string;
+                        target: string;
+                        class: string;
+                        slug?: import("../../graph/edge/index.js").EdgeSlug | undefined;
+                        props: Record<string, unknown>;
+                    };
+                };
+                source: {
+                    kind: "reference";
+                    value: {
+                        id: string;
+                        class: string;
+                    };
+                } | {
+                    kind: "value";
+                    value: {
+                        id: string;
+                        class: string;
+                        props: Record<string, unknown>;
+                    };
+                };
+                target: {
+                    kind: "reference";
+                    value: {
+                        id: string;
+                        class: string;
+                    };
+                } | {
+                    kind: "value";
+                    value: {
+                        id: string;
+                        class: string;
+                        props: Record<string, unknown>;
+                    };
+                };
+            }[];
+        };
+        page: {
+            next?: string | undefined;
+        };
+    };
+}, "authorized", import("@astrale-os/kernel-dsl/v1").PolicyCheckExpression<import("@astrale-os/kernel-dsl/v1").PolicyRef, import("@astrale-os/kernel-dsl/v1/language").PolicyCheckObject>> & {
+    readonly ref: import("@astrale-os/kernel-dsl/v1").FunctionRef<"query"> & {
         readonly origin: "kernel.astrale.ai";
     };
-    readonly key: "kernel.astrale.ai:function.introspect";
+    readonly key: "kernel.astrale.ai:function.query";
 }) | (import("@astrale-os/kernel-dsl/v1").ResolvedFunction<{
     invocation?: {
         source: string;
@@ -6193,233 +6420,6 @@ export declare const KernelRootFunctions: readonly ((import("@astrale-os/kernel-
         readonly origin: "kernel.astrale.ai";
     };
     readonly key: "kernel.astrale.ai:function.provision";
-}) | (import("@astrale-os/kernel-dsl/v1").ResolvedFunction<{
-    ast: {
-        format: "astrale.graph.query";
-        version: "v6";
-        source: {
-            kind: "node";
-            terms: ({
-                kind: "path";
-                path: string;
-            } | {
-                kind: "class";
-                class: {
-                    origin: string;
-                    kind: "class";
-                    name: string;
-                };
-            })[];
-            binding: string;
-        } | {
-            kind: "edge";
-            terms: {
-                kind: "class";
-                class: {
-                    origin: string;
-                    kind: "class";
-                    name: string;
-                };
-            }[];
-            bindings: {
-                source: string;
-                edge: string;
-                target: string;
-            };
-        };
-        steps: ({
-            op: "filter";
-            binding: string;
-            predicate: {
-                kind: "class.satisfies";
-                class: {
-                    origin: string;
-                    kind: "class";
-                    name: string;
-                };
-            } | {
-                kind: "class.equal";
-                class: {
-                    origin: string;
-                    kind: "class";
-                    name: string;
-                };
-            } | {
-                kind: "property.equal";
-                property: string;
-                value: unknown;
-            } | {
-                kind: "property.present";
-                property: string;
-            } | {
-                kind: "identity.equal";
-                identity: string | {
-                    source: string;
-                    target: string;
-                    class: string;
-                };
-            };
-        } | {
-            op: "expand";
-            from: string;
-            via: {
-                origin: string;
-                kind: "class";
-                name: string;
-            }[];
-            direction: "incident" | "incoming" | "outgoing";
-            bindings: {
-                edge: string;
-                node: string;
-            };
-        })[];
-        select: {
-            kind: "graph";
-            binding: string;
-            order?: {
-                property: string;
-                direction: "asc" | "desc";
-                unranked: "first" | "last";
-            } | undefined;
-        } | {
-            kind: "nodes";
-            binding: string;
-            projection: {
-                kind: "reference" | "value";
-            };
-            order?: {
-                property: string;
-                direction: "asc" | "desc";
-                unranked: "first" | "last";
-            } | undefined;
-        } | {
-            kind: "edges";
-            binding: string;
-            projection: {
-                edge: "reference" | "value";
-                source: "reference" | "value";
-                target: "reference" | "value";
-            };
-            order?: {
-                property: string;
-                direction: "asc" | "desc";
-                unranked: "first" | "last";
-            } | undefined;
-        };
-    };
-    expected?: {
-        origin: string;
-        revision: string;
-    }[] | undefined;
-    page: {
-        size: number;
-        after?: string | undefined;
-    };
-}, {
-    readonly mode: 'value';
-    readonly value: {
-        result: {
-            kind: "graph";
-            graph: {
-                nodes: {
-                    id: string;
-                    class: string;
-                    props: Record<string, unknown>;
-                }[];
-                edges: {
-                    source: string;
-                    target: string;
-                    class: string;
-                    slug?: import("../../graph/edge/index.js").EdgeSlug | undefined;
-                    props: Record<string, unknown>;
-                }[];
-            };
-            selection: {
-                kind: "node";
-                ids: string[];
-            } | {
-                kind: "edge";
-                keys: {
-                    source: string;
-                    target: string;
-                    class: string;
-                }[];
-            };
-        } | {
-            kind: "nodes";
-            nodes: ({
-                kind: "reference";
-                value: {
-                    id: string;
-                    class: string;
-                };
-            } | {
-                kind: "value";
-                value: {
-                    id: string;
-                    class: string;
-                    props: Record<string, unknown>;
-                };
-            })[];
-        } | {
-            kind: "edges";
-            edges: {
-                edge: {
-                    kind: "reference";
-                    value: {
-                        source: string;
-                        target: string;
-                        class: string;
-                    };
-                } | {
-                    kind: "value";
-                    value: {
-                        source: string;
-                        target: string;
-                        class: string;
-                        slug?: import("../../graph/edge/index.js").EdgeSlug | undefined;
-                        props: Record<string, unknown>;
-                    };
-                };
-                source: {
-                    kind: "reference";
-                    value: {
-                        id: string;
-                        class: string;
-                    };
-                } | {
-                    kind: "value";
-                    value: {
-                        id: string;
-                        class: string;
-                        props: Record<string, unknown>;
-                    };
-                };
-                target: {
-                    kind: "reference";
-                    value: {
-                        id: string;
-                        class: string;
-                    };
-                } | {
-                    kind: "value";
-                    value: {
-                        id: string;
-                        class: string;
-                        props: Record<string, unknown>;
-                    };
-                };
-            }[];
-        };
-        page: {
-            next?: string | undefined;
-        };
-    };
-}, "authorized", import("@astrale-os/kernel-dsl/v1").PolicyCheckExpression<import("@astrale-os/kernel-dsl/v1").PolicyRef, import("@astrale-os/kernel-dsl/v1/language").PolicyCheckObject>> & {
-    readonly ref: import("@astrale-os/kernel-dsl/v1").FunctionRef<"query"> & {
-        readonly origin: "kernel.astrale.ai";
-    };
-    readonly key: "kernel.astrale.ai:function.query";
 }) | (import("@astrale-os/kernel-dsl/v1").ResolvedFunction<{
     operation: string;
     domains: string[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrale-os/kernel-core",
-  "version": "0.9.0-beta.35",
+  "version": "0.9.0-beta.36",
   "description": "Astrale Kernel Core - Types, Invariants, and Pure Logic",
   "license": "Apache-2.0",
   "repository": {
@@ -160,7 +160,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@astrale-os/kernel-dsl": "0.2.0-beta.26",
+    "@astrale-os/kernel-dsl": "0.2.0-beta.27",
     "@noble/hashes": "2.3.0",
     "@types/json-schema": "^7.0.15",
     "dequal": "2.0.3"