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

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

@@ -1,79 +1,59 @@
-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>;
+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 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 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,35 +1,34 @@
 import { fullMatch } from '@astrale-os/kernel-dsl/v1/value/full-match';
-import { z } from 'zod';
+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 });
+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({
+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),
 });

package/dist/graph/mutate/authoring/builder.d.ts

@@ -6,7 +6,7 @@ import type { DeltaInput } from '../../properties/index.js';
 import type { QueryEdgeAST, QueryNodeAST } from '../../query/index.js';
 import type { MutationAST } from '../language/index.js';
 import type { MutationInputEdgeSelector, MutationInputEndpoint, MutationPropertyConditionsInput, MutationPropsInput } from './model.js';
-import { LocalBinding } from '../../graph/index.js';
+import { LocalAlias } from '../../graph/index.js';
 export type MutationQueryPreconditionInput = {
     readonly query: QueryNodeAST;
     readonly equals: {
@@ -39,7 +39,7 @@ export interface MutationBuilder {
         readonly class: ClassKey;
         readonly props?: MutationPropsInput;
     }): {
-        readonly created: LocalBinding;
+        readonly created: LocalAlias;
     };
     updateNode(input: {
         readonly node: NodeTarget;

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

@@ -1,4 +1,4 @@
-import { LocalBinding } from '../../graph/index.js';
+import { LocalAlias } from '../../graph/index.js';
 import { createMutationAST } from './create.js';
 /** Run one synchronous author and admit its complete operation set. */
 export function buildMutationAST(author) {
@@ -38,7 +38,7 @@ export function buildMutationAST(author) {
         expect: expectation,
         createNode(input) {
             requireOpen();
-            const created = LocalBinding(input.as);
+            const created = LocalAlias(input.as);
             operations.push({
                 op: 'node.create',
                 as: created,

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/mutate/index.d.ts

@@ -2,7 +2,7 @@ import type { GraphSpec } from '../graph/index.js';
 import type { MutationBuilder, MutationInput } from './authoring/index.js';
 import type { MutationAST as MutationASTValue, MutationStructuralLimits } from './language/index.js';
 export type { MutationBuilder, MutationInput, MutationInputEdgeSelector, MutationInputEndpoint, MutationInputOperation, MutationInputPrecondition, MutationPropertyConditionsInput, MutationPropsInput, MutationQueryPreconditionInput, } from './authoring/index.js';
-export type { EdgeCreateOperation, EdgeDeleteOperation, EdgeUpdateOperation, LocalBinding, MutationEdgeSelector, MutationEndpoint, MutationOperation, MutationPrecondition, MutationPropertyConditions, MutationProps, MutationQueryPrecondition, MutationStructuralLimits, NodeCreateOperation, NodeDeleteOperation, NodeUpdateOperation, QueryExpectedSelection, } from './language/index.js';
+export type { EdgeCreateOperation, EdgeDeleteOperation, EdgeUpdateOperation, LocalAlias, MutationEdgeSelector, MutationEndpoint, MutationOperation, MutationPrecondition, MutationPropertyConditions, MutationProps, MutationQueryPrecondition, MutationStructuralLimits, NodeCreateOperation, NodeDeleteOperation, NodeUpdateOperation, QueryExpectedSelection, } from './language/index.js';
 export { MutationASTDecodeError } from './language/index.js';
 export type MutationAST = MutationASTValue;
 export declare const MutationAST: {

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

@@ -3,7 +3,7 @@ import { ClassKey } from '@astrale-os/kernel-dsl/v1/addressing';
 import * as portable from '@astrale-os/kernel-dsl/value';
 import { EdgeSlug, encodeEdgeKey } from '../../edge/index.js';
 import { compareEdgeKeys } from '../../edge/index.js';
-import { isLocalBinding, LocalBinding as LocalBindingValue } from '../../graph/index.js';
+import { isLocalAlias, LocalAlias as LocalAliasValue } from '../../graph/index.js';
 import { NodeId } from '../../node/index.js';
 import { compareNodeIds } from '../../node/index.js';
 import { NodePath } from '../../path/index.js';
@@ -341,9 +341,9 @@ function compare(left, right) {
     return left < right ? -1 : left > right ? 1 : 0;
 }
 function localBinding(value, path) {
-    if (!isLocalBinding(value))
+    if (!isLocalAlias(value))
         invalid(path, 'Expected a local binding name of at most 64 characters');
-    return LocalBindingValue(value);
+    return LocalAliasValue(value);
 }
 function propertyKey(value, path) {
     if (typeof value !== 'string' || !PropertyKey.is(value)) {

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

@@ -1,7 +1,7 @@
 import type { PropertyKey } from '@astrale-os/kernel-dsl/v1';
 import type { ClassKey } from '@astrale-os/kernel-dsl/v1/addressing';
 import type { EdgeSlug } from '../../edge/index.js';
-import type { LocalBinding } from '../../graph/index.js';
+import type { LocalAlias } from '../../graph/index.js';
 import type { NodePath } from '../../path/index.js';
 import type { Delta as PropertiesDelta, Properties } from '../../properties/index.js';
 import type { QueryEdgeAST, QueryNodeAST } from '../../query/index.js';
@@ -14,10 +14,10 @@ export type MutationStructuralLimits = Readonly<{
     queryExpectedIdentities: 4096;
 }>;
 export declare const MUTATION_AST_LIMITS: MutationStructuralLimits;
-export type { LocalBinding } from '../../graph/index.js';
+export type { LocalAlias } from '../../graph/index.js';
 export type MutationProps = Properties;
 export type MutationEndpoint = NodePath | {
-    readonly created: LocalBinding;
+    readonly created: LocalAlias;
 };
 export interface MutationEdgeSelector {
     readonly source: NodePath;
@@ -55,7 +55,7 @@ export type MutationPrecondition = {
 } | MutationQueryPrecondition;
 export interface NodeCreateOperation {
     readonly op: 'node.create';
-    readonly as: LocalBinding;
+    readonly as: LocalAlias;
     readonly class: ClassKey;
     readonly props: MutationProps;
 }