@astrale-os/kernel-core 0.9.0-beta.65 → 0.9.0-beta.66

package/dist/auth/authority/admission/admission.d.ts

@@ -8,7 +8,6 @@ export declare const limits: {
     readonly classesPerRelation: 1024;
     readonly repeatMaximum: 16;
 };
-export declare const MAX_BOOLEAN_OPERANDS: 512;
 export declare function admitAuthorityExpr(input: portable.Value): AuthorityExpr;
 /** Internal constructor admission: the outer identity binder binds subject; no local escapes into it. */
 export declare function admitBinderBody(input: portable.Value): AuthorityExpr;

package/dist/auth/authority/admission/admission.js

@@ -1,7 +1,8 @@
-import { patterns } from '@astrale-os/kernel-dsl/v1/addressing';
 import { isNodeId } from '../../../graph/node/index.js';
-import { AuthValueError } from '../../error.js';
 import { ownsExpression } from '../ownership.optimization.js';
+import { classRef } from './references.js';
+import { localId, term } from './term.js';
+import { array, exact, invalid, record, required } from './wire.js';
 export const limits = Object.freeze({
     expressionDepth: 64,
     operandsPerExpression: 512,
@@ -10,7 +11,7 @@ export const limits = Object.freeze({
     classesPerRelation: 1024,
     repeatMaximum: 16,
 });
-export const MAX_BOOLEAN_OPERANDS = limits.operandsPerExpression;
+const MAX_BOOLEAN_OPERANDS = limits.operandsPerExpression;
 export function admitAuthorityExpr(input) {
     return admit(input, '/predicate', new Set(), false, 0);
 }
@@ -67,7 +68,7 @@ function admit(input, path, locals, subjectBound, depth) {
             return {
                 op: 'related',
                 source: term(value.source, `${path}/source`, locals, subjectBound),
-                via: array(value.via, `${path}/via`, 1, limits.classesPerRelation).map((entry, index) => edgeClassRef(entry, `${path}/via/${index}`)),
+                via: array(value.via, `${path}/via`, 1, limits.classesPerRelation).map((entry, index) => classRef(entry, `${path}/via/${index}`)),
                 target: term(value.target, `${path}/target`, locals, subjectBound),
                 ...(hasRepeat ? { repeat: repeat(value.repeat, `${path}/repeat`) } : {}),
             };
@@ -96,11 +97,11 @@ function admit(input, path, locals, subjectBound, depth) {
             return {
                 op: 'instance-of',
                 node: term(value.node, `${path}/node`, locals, subjectBound),
-                class: nodeClassRef(value.class, `${path}/class`),
+                class: classRef(value.class, `${path}/class`),
             };
         case 'edge-class':
             exact(value, ['class', 'op'], path);
-            return { op: 'edge-class', class: edgeClassRef(value.class, `${path}/class`) };
+            return { op: 'edge-class', class: classRef(value.class, `${path}/class`) };
         case 'class-authority':
             exact(value, ['class', 'evidence', 'identity', 'op', 'operation'], path);
             return {
@@ -114,55 +115,6 @@ function admit(input, path, locals, subjectBound, depth) {
             invalid(`${path}/op`, 'Unsupported authority operation');
     }
 }
-function term(input, path, locals, subjectBound) {
-    const value = record(input, path);
-    switch (value.kind) {
-        case 'input':
-            exact(value, ['input', 'kind'], path);
-            if (value.input !== 'object' && value.input !== 'source' && value.input !== 'target') {
-                invalid(`${path}/input`, 'Expected object, source, or target');
-            }
-            return { kind: 'input', input: value.input };
-        case 'node':
-            exact(value, ['id', 'kind'], path);
-            if (!isNodeId(value.id))
-                invalid(`${path}/id`, 'Expected a canonical NodeId');
-            return { kind: 'node', id: value.id };
-        case 'class':
-            exact(value, ['kind', 'ref'], path);
-            return { kind: 'class', ref: classRef(value.ref, `${path}/ref`) };
-        case 'domain':
-            exact(value, ['kind', 'origin'], path);
-            return { kind: 'domain', origin: domainOrigin(value.origin, `${path}/origin`) };
-        case 'ref': {
-            exact(value, ['kind', 'ref'], path);
-            const ref = absoluteRef(value.ref, `${path}/ref`);
-            if (ref.kind === 'core')
-                return { kind: 'ref', ref: coreRef(value.ref, `${path}/ref`) };
-            if (!['class', 'function', 'policy', 'view'].includes(ref.kind))
-                invalid(`${path}/ref/kind`, 'Expected a projected Schema member');
-            definitionName(ref.name, `${path}/ref/name`);
-            return { kind: 'ref', ref: ref };
-        }
-        case 'core':
-            exact(value, ['kind', 'ref'], path);
-            return { kind: 'core', ref: coreRef(value.ref, `${path}/ref`) };
-        case 'local': {
-            exact(value, ['id', 'kind'], path);
-            const id = localId(value.id, `${path}/id`);
-            if (!locals.has(id))
-                invalid(`${path}/id`, `Local ${id} is outside its lexical scope`);
-            return { kind: 'local', id };
-        }
-        case 'subject':
-            exact(value, ['kind'], path);
-            if (!subjectBound)
-                invalid(path, 'Binder subject is outside its lexical scope');
-            return { kind: 'subject' };
-        default:
-            invalid(`${path}/kind`, 'Unsupported authority term');
-    }
-}
 function localDeclaration(input, path) {
     const value = record(input, path);
     const id = localId(value.id, `${path}/id`);
@@ -172,7 +124,7 @@ function localDeclaration(input, path) {
     }
     if (value.kind === 'classes') {
         exact(value, ['classes', 'id', 'kind'], path);
-        const classes = array(value.classes, `${path}/classes`, 1, limits.classesPerLocal).map((entry, index) => nodeClassRef(entry, `${path}/classes/${index}`));
+        const classes = array(value.classes, `${path}/classes`, 1, limits.classesPerLocal).map((entry, index) => classRef(entry, `${path}/classes/${index}`));
         return {
             id,
             kind: 'classes',
@@ -193,61 +145,6 @@ function repeat(input, path) {
     }
     return { min, max };
 }
-function classRef(input, path) {
-    const value = absoluteRef(input, path);
-    if (value.kind !== 'class')
-        invalid(`${path}/kind`, 'Expected class');
-    definitionName(value.name, `${path}/name`);
-    return value;
-}
-function nodeClassRef(input, path) {
-    const value = absoluteRef(input, path);
-    if (value.kind !== 'class')
-        invalid(`${path}/kind`, 'Expected class');
-    definitionName(value.name, `${path}/name`);
-    return value;
-}
-function edgeClassRef(input, path) {
-    const value = absoluteRef(input, path);
-    if (value.kind !== 'class')
-        invalid(`${path}/kind`, 'Expected class');
-    definitionName(value.name, `${path}/name`);
-    return value;
-}
-function absoluteRef(input, path) {
-    const value = record(input, path);
-    exact(value, ['kind', 'name', 'origin'], path);
-    const origin = domainOrigin(value.origin, `${path}/origin`);
-    if (typeof value.kind !== 'string')
-        invalid(`${path}/kind`, 'Expected a reference kind');
-    if (typeof value.name !== 'string')
-        invalid(`${path}/name`, 'Expected a reference name');
-    return { origin, kind: value.kind, name: value.name };
-}
-function definitionName(input, path) {
-    if (!patterns.memberName.test(input))
-        invalid(path, 'Expected a Definition member name');
-}
-function coreRef(input, path) {
-    const value = absoluteRef(input, path);
-    if (value.kind !== 'core')
-        invalid(`${path}/kind`, 'Expected core');
-    if (!patterns.coreSlug.test(value.name))
-        invalid(`${path}/name`, 'Expected a Core slug');
-    return value;
-}
-function domainOrigin(input, path) {
-    if (typeof input !== 'string' || !patterns.origin.test(input)) {
-        invalid(path, 'Expected a canonical Domain origin');
-    }
-    return input;
-}
-function localId(input, path) {
-    if (!Number.isSafeInteger(input) || input < 0) {
-        invalid(path, 'Expected a non-negative safe integer');
-    }
-    return input;
-}
 function operation(input, path) {
     if (input !== 'create' &&
         input !== 'read' &&
@@ -263,33 +160,3 @@ function evidence(input, path) {
         invalid(path, 'Expected allowed or owner');
     return input;
 }
-function record(input, path) {
-    if (input === undefined || input === null || Array.isArray(input) || typeof input !== 'object') {
-        invalid(path, 'Expected an object');
-    }
-    return input;
-}
-function array(input, path, minimum, maximum) {
-    if (!Array.isArray(input) || input.length < minimum || input.length > maximum) {
-        invalid(path, `Expected ${minimum}-${maximum} entries`);
-    }
-    return input;
-}
-function required(input, path) {
-    if (input === undefined)
-        invalid(path, 'Expected a value');
-    return input;
-}
-function exact(value, expected, path) {
-    const actual = Object.keys(value).sort(compare);
-    const wanted = [...expected].sort(compare);
-    if (actual.length !== wanted.length || actual.some((key, index) => key !== wanted[index])) {
-        invalid(path, `Expected exactly ${expected.join(', ')}`);
-    }
-}
-function compare(left, right) {
-    return left < right ? -1 : left > right ? 1 : 0;
-}
-function invalid(path, message) {
-    throw new AuthValueError('AUTHORITY_PREDICATE_INVALID', message, path);
-}

package/dist/auth/authority/admission/references.d.ts

@@ -0,0 +1,13 @@
+import type { Key } from '@astrale-os/kernel-dsl/v1';
+import type { ClassRef, CoreRef } from '@astrale-os/kernel-dsl/v1/addressing';
+import type * as portable from '@astrale-os/kernel-dsl/value';
+/** One `{ origin, kind, name }` reference with a canonical origin and an unchecked kind and name. */
+export declare function absoluteRef(input: portable.Value | undefined, path: string): {
+    readonly origin: Key.Origin;
+    readonly kind: string;
+    readonly name: string;
+};
+export declare function classRef(input: portable.Value | undefined, path: string): ClassRef;
+export declare function coreRef(input: portable.Value | undefined, path: string): CoreRef;
+export declare function definitionName(input: string, path: string): void;
+export declare function domainOrigin(input: portable.Value | undefined, path: string): Key.Origin;

package/dist/auth/authority/admission/references.js

@@ -0,0 +1,38 @@
+import { patterns } from '@astrale-os/kernel-dsl/v1/addressing';
+import { exact, invalid, record } from './wire.js';
+/** One `{ origin, kind, name }` reference with a canonical origin and an unchecked kind and name. */
+export function absoluteRef(input, path) {
+    const value = record(input, path);
+    exact(value, ['kind', 'name', 'origin'], path);
+    const origin = domainOrigin(value.origin, `${path}/origin`);
+    if (typeof value.kind !== 'string')
+        invalid(`${path}/kind`, 'Expected a reference kind');
+    if (typeof value.name !== 'string')
+        invalid(`${path}/name`, 'Expected a reference name');
+    return { origin, kind: value.kind, name: value.name };
+}
+export function classRef(input, path) {
+    const value = absoluteRef(input, path);
+    if (value.kind !== 'class')
+        invalid(`${path}/kind`, 'Expected class');
+    definitionName(value.name, `${path}/name`);
+    return value;
+}
+export function coreRef(input, path) {
+    const value = absoluteRef(input, path);
+    if (value.kind !== 'core')
+        invalid(`${path}/kind`, 'Expected core');
+    if (!patterns.coreSlug.test(value.name))
+        invalid(`${path}/name`, 'Expected a Core slug');
+    return value;
+}
+export function definitionName(input, path) {
+    if (!patterns.memberName.test(input))
+        invalid(path, 'Expected a Definition member name');
+}
+export function domainOrigin(input, path) {
+    if (typeof input !== 'string' || !patterns.origin.test(input)) {
+        invalid(path, 'Expected a canonical Domain origin');
+    }
+    return input;
+}

package/dist/auth/authority/admission/term.d.ts

@@ -0,0 +1,6 @@
+import type * as portable from '@astrale-os/kernel-dsl/value';
+import type { Term } from '../language/index.js';
+/** Admit one term; `locals` and `subjectBound` are the lexical scope it may reference. */
+export declare function term(input: portable.Value | undefined, path: string, locals: ReadonlySet<number>, subjectBound: boolean): Term;
+/** A local id or repeat bound: a non-negative safe integer. */
+export declare function localId(input: portable.Value | undefined, path: string): number;

package/dist/auth/authority/admission/term.js

@@ -0,0 +1,60 @@
+import { isNodeId } from '../../../graph/node/index.js';
+import { absoluteRef, classRef, coreRef, definitionName, domainOrigin } from './references.js';
+import { exact, invalid, record } from './wire.js';
+/** Admit one term; `locals` and `subjectBound` are the lexical scope it may reference. */
+export function term(input, path, locals, subjectBound) {
+    const value = record(input, path);
+    switch (value.kind) {
+        case 'input':
+            exact(value, ['input', 'kind'], path);
+            if (value.input !== 'object' && value.input !== 'source' && value.input !== 'target') {
+                invalid(`${path}/input`, 'Expected object, source, or target');
+            }
+            return { kind: 'input', input: value.input };
+        case 'node':
+            exact(value, ['id', 'kind'], path);
+            if (!isNodeId(value.id))
+                invalid(`${path}/id`, 'Expected a canonical NodeId');
+            return { kind: 'node', id: value.id };
+        case 'class':
+            exact(value, ['kind', 'ref'], path);
+            return { kind: 'class', ref: classRef(value.ref, `${path}/ref`) };
+        case 'domain':
+            exact(value, ['kind', 'origin'], path);
+            return { kind: 'domain', origin: domainOrigin(value.origin, `${path}/origin`) };
+        case 'ref': {
+            exact(value, ['kind', 'ref'], path);
+            const ref = absoluteRef(value.ref, `${path}/ref`);
+            if (ref.kind === 'core')
+                return { kind: 'ref', ref: coreRef(value.ref, `${path}/ref`) };
+            if (!['class', 'function', 'policy', 'view'].includes(ref.kind))
+                invalid(`${path}/ref/kind`, 'Expected a projected Schema member');
+            definitionName(ref.name, `${path}/ref/name`);
+            return { kind: 'ref', ref: ref };
+        }
+        case 'core':
+            exact(value, ['kind', 'ref'], path);
+            return { kind: 'core', ref: coreRef(value.ref, `${path}/ref`) };
+        case 'local': {
+            exact(value, ['id', 'kind'], path);
+            const id = localId(value.id, `${path}/id`);
+            if (!locals.has(id))
+                invalid(`${path}/id`, `Local ${id} is outside its lexical scope`);
+            return { kind: 'local', id };
+        }
+        case 'subject':
+            exact(value, ['kind'], path);
+            if (!subjectBound)
+                invalid(path, 'Binder subject is outside its lexical scope');
+            return { kind: 'subject' };
+        default:
+            invalid(`${path}/kind`, 'Unsupported authority term');
+    }
+}
+/** A local id or repeat bound: a non-negative safe integer. */
+export function localId(input, path) {
+    if (!Number.isSafeInteger(input) || input < 0) {
+        invalid(path, 'Expected a non-negative safe integer');
+    }
+    return input;
+}

package/dist/auth/authority/admission/wire.d.ts

@@ -0,0 +1,8 @@
+import type * as portable from '@astrale-os/kernel-dsl/value';
+/** Fail admission at one JSON-pointer path with the stable Authority predicate code. */
+export declare function invalid(path: string, message: string): never;
+export declare function record(input: portable.Value | undefined, path: string): portable.Object;
+export declare function array(input: portable.Value | undefined, path: string, minimum: number, maximum: number): readonly portable.Value[];
+export declare function required(input: portable.Value | undefined, path: string): portable.Value;
+/** Reject a record whose own keys differ from `expected`, in any order. */
+export declare function exact(value: portable.Object, expected: readonly string[], path: string): void;

package/dist/auth/authority/admission/wire.js

@@ -0,0 +1,33 @@
+import { AuthValueError } from '../../error.js';
+/** Fail admission at one JSON-pointer path with the stable Authority predicate code. */
+export function invalid(path, message) {
+    throw new AuthValueError('AUTHORITY_PREDICATE_INVALID', message, path);
+}
+export function record(input, path) {
+    if (input === undefined || input === null || Array.isArray(input) || typeof input !== 'object') {
+        invalid(path, 'Expected an object');
+    }
+    return input;
+}
+export function array(input, path, minimum, maximum) {
+    if (!Array.isArray(input) || input.length < minimum || input.length > maximum) {
+        invalid(path, `Expected ${minimum}-${maximum} entries`);
+    }
+    return input;
+}
+export function required(input, path) {
+    if (input === undefined)
+        invalid(path, 'Expected a value');
+    return input;
+}
+/** Reject a record whose own keys differ from `expected`, in any order. */
+export function exact(value, expected, path) {
+    const actual = Object.keys(value).sort(compare);
+    const wanted = [...expected].sort(compare);
+    if (actual.length !== wanted.length || actual.some((key, index) => key !== wanted[index])) {
+        invalid(path, `Expected exactly ${expected.join(', ')}`);
+    }
+}
+function compare(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}

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

@@ -4,7 +4,7 @@ export type { Delta, DeltaConflict, DeltaResult } from './delta/index.js';
 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 { LocalAlias, isLocalAlias } from './model/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';

package/dist/graph/graph/index.js

@@ -1,5 +1,5 @@
 /** Stable aggregate facade over Graph model, admission, indexes, delta, and merge. */
 export { Graph } from './graph.js';
 export { GraphData, GraphDataDecodeError, GraphSpec, GraphSpecDecodeError } from './model/index.js';
-export { LocalBinding, isLocalBinding } from './model/index.js';
+export { LocalAlias, isLocalAlias } from './model/index.js';
 export { GraphAdmissionError } from './admission/index.js';

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

@@ -5,7 +5,7 @@ import { node as constructNode, NodeId } from '../../node/index.js';
 import { NodePath } from '../../path/index.js';
 import { normalizeProperties } from '../../properties/index.js';
 import { decodeWire } from '../../wire.js';
-import { isLocalBinding, LocalBinding } from './model.js';
+import { isLocalAlias, LocalAlias } from './model.js';
 import { graphSpecSchema } from './wire.js';
 export class GraphDataDecodeError extends TypeError {
     path;
@@ -124,10 +124,10 @@ function decodeEndpoint(input, path) {
     return Object.freeze({ created: binding(input.created, `${path}/created`) });
 }
 function binding(input, path) {
-    if (!isLocalBinding(input)) {
+    if (!isLocalAlias(input)) {
         specInvalid(path, 'Expected a local binding name of at most 64 characters');
     }
-    return LocalBinding(input);
+    return LocalAlias(input);
 }
 function validateGraphSpec(nodes, edges) {
     const ids = new Set();

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

@@ -13,5 +13,5 @@ export declare const GraphSpec: {
     encode(spec: GraphSpecValue): GraphSpecJson;
 };
 export type { AnonymousNodeSpec, GraphSpecEdge, GraphSpecEndpoint, GraphSpecJson, GraphSpecNode, } from './model.js';
-export { LocalBinding, isLocalBinding } from './model.js';
+export { LocalAlias, isLocalAlias } from './model.js';
 export { GraphSpecDecodeError } from './codec.js';

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

@@ -2,5 +2,5 @@ import { decodeGraphData, decodeGraphSpec, encodeGraphData, encodeGraphSpec } fr
 export const GraphData = Object.freeze({ decode: decodeGraphData, encode: encodeGraphData });
 export { GraphDataDecodeError } from './codec.js';
 export const GraphSpec = Object.freeze({ decode: decodeGraphSpec, encode: encodeGraphSpec });
-export { LocalBinding, isLocalBinding } from './model.js';
+export { LocalAlias, isLocalAlias } from './model.js';
 export { GraphSpecDecodeError } from './codec.js';

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

@@ -2,21 +2,21 @@ import type { EdgeSpec } from '../../edge/index.js';
 import type { Node, NodeId, NodeSpec } from '../../node/index.js';
 import type { NodePath } from '../../path/index.js';
 import type { Properties } from '../../properties/index.js';
-declare const LOCAL_BINDING_BRAND: unique symbol;
+declare const LOCAL_ALIAS_BRAND: unique symbol;
 /** A graph-local lexical name. It is never Node identity. */
-export type LocalBinding = string & {
-    readonly [LOCAL_BINDING_BRAND]: true;
+export type LocalAlias = string & {
+    readonly [LOCAL_ALIAS_BRAND]: true;
 };
-export declare function LocalBinding(input: string): LocalBinding;
-export declare function isLocalBinding(input: unknown): input is LocalBinding;
+export declare function LocalAlias(input: string): LocalAlias;
+export declare function isLocalAlias(input: unknown): input is LocalAlias;
 export interface AnonymousNodeSpec extends NodeSpec {
-    readonly as: LocalBinding;
+    readonly as: LocalAlias;
 }
 export type GraphSpecNode = Node | AnonymousNodeSpec;
 export type GraphSpecEndpoint = NodeId | {
     readonly path: NodePath;
 } | {
-    readonly created: LocalBinding;
+    readonly created: LocalAlias;
 };
 export type GraphSpecEdge = EdgeSpec<GraphSpecEndpoint>;
 /** Detached structural graph values, including graph-local anonymous Nodes. */

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

@@ -1,10 +1,10 @@
-const LOCAL_BINDING_PATTERN = /^[A-Za-z][A-Za-z0-9_]{0,63}$/u;
-export function LocalBinding(input) {
-    if (!isLocalBinding(input)) {
-        throw new TypeError(`Invalid local binding ${JSON.stringify(input)}.`);
+const LOCAL_ALIAS_PATTERN = /^[A-Za-z][A-Za-z0-9_]{0,63}$/u;
+export function LocalAlias(input) {
+    if (!isLocalAlias(input)) {
+        throw new TypeError(`Invalid local alias ${JSON.stringify(input)}.`);
     }
     return input;
 }
-export function isLocalBinding(input) {
-    return typeof input === 'string' && LOCAL_BINDING_PATTERN.test(input);
+export function isLocalAlias(input) {
+    return typeof input === 'string' && LOCAL_ALIAS_PATTERN.test(input);
 }

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

@@ -5,11 +5,6 @@ export declare const graphNodeSchema: import("zod").ZodObject<{
     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;
@@ -22,21 +17,6 @@ export declare const graphEdgeSchema: import("zod").ZodObject<{
     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;

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

@@ -9,7 +9,7 @@ const edgeSlug = string()
     .max(edgeSlugSchema.maxLength)
     .check(fullMatch(edgeSlugSchema.fullMatch));
 export const graphNodeSchema = strictObject({ id: text, class: text, props });
-export const anonymousGraphNodeSchema = strictObject({ as: binding, 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 = union([
@@ -17,7 +17,7 @@ const graphSpecEndpointSchema = union([
     strictObject({ path: text }),
     strictObject({ created: binding }),
 ]);
-export const graphSpecEdgeSchema = strictObject({
+const graphSpecEdgeSchema = strictObject({
     source: graphSpecEndpointSchema,
     target: graphSpecEndpointSchema,
     class: text,

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/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;
 }