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

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

@@ -1,79 +1,75 @@
 import { patterns } from '@astrale-os/kernel-dsl/v1/addressing';
 import { fullMatch } from '@astrale-os/kernel-dsl/v1/value/full-match';
-import { z } from 'zod';
+import { array, discriminatedUnion, literal, record, strictObject, string, union, unknown as unknownSchema, } from 'zod';
 import { edgeSlugSchema } from '../../edge/index.js';
 import { queryAstSchema } from '../../query/language/index.js';
 import { MUTATION_AST_FORMAT, MUTATION_AST_LIMITS, MUTATION_AST_VERSION } from './model.js';
-const text = z.string().min(1);
-const binding = z.string().min(1).max(64);
-const propertyKey = z.string().check(fullMatch(patterns.propertyKeyFullMatch));
-const props = z.record(propertyKey, z.unknown());
-const patch = z.strictObject({ set: props, unset: z.array(propertyKey) });
-const endpoint = z.union([text, z.strictObject({ created: binding })]);
-const edgeSelector = z.strictObject({ source: text, target: text, class: text });
-const edgeSlug = z
-    .string()
+const text = string().min(1);
+const binding = string().min(1).max(64);
+const propertyKey = string().check(fullMatch(patterns.propertyKeyFullMatch));
+const props = record(propertyKey, unknownSchema());
+const patch = strictObject({ set: props, unset: array(propertyKey) });
+const endpoint = union([text, strictObject({ created: binding })]);
+const edgeSelector = strictObject({ source: text, target: text, class: text });
+const edgeSlug = string()
     .min(edgeSlugSchema.minLength)
     .max(edgeSlugSchema.maxLength)
     .check(fullMatch(edgeSlugSchema.fullMatch));
-const edgeUpdateWithSlug = z.strictObject({
-    op: z.literal('edge.update'),
+const edgeUpdateWithSlug = strictObject({
+    op: literal('edge.update'),
     edge: edgeSelector,
     slug: edgeSlug.nullable(),
     props: patch.optional(),
 });
-const edgeUpdateWithProperties = z.strictObject({
-    op: z.literal('edge.update'),
+const edgeUpdateWithProperties = strictObject({
+    op: literal('edge.update'),
     edge: edgeSelector,
     props: patch,
 });
-const propertyConditions = z.union([
-    z.strictObject({ equals: props, absent: z.array(propertyKey).optional() }),
-    z.strictObject({ absent: z.array(propertyKey).min(1) }),
+const propertyConditions = union([
+    strictObject({ equals: props, absent: array(propertyKey).optional() }),
+    strictObject({ absent: array(propertyKey).min(1) }),
 ]);
-const expectedSelection = z.discriminatedUnion('kind', [
-    z.strictObject({
-        kind: z.literal('node'),
-        ids: z.array(text).max(MUTATION_AST_LIMITS.queryExpectedIdentities),
+const expectedSelection = discriminatedUnion('kind', [
+    strictObject({
+        kind: literal('node'),
+        ids: array(text).max(MUTATION_AST_LIMITS.queryExpectedIdentities),
     }),
-    z.strictObject({
-        kind: z.literal('edge'),
-        keys: z
-            .array(z.strictObject({ source: text, target: text, class: text }))
-            .max(MUTATION_AST_LIMITS.queryExpectedIdentities),
+    strictObject({
+        kind: literal('edge'),
+        keys: array(strictObject({ source: text, target: text, class: text })).max(MUTATION_AST_LIMITS.queryExpectedIdentities),
     }),
 ]);
-const precondition = z.union([
-    z.strictObject({
-        kind: z.literal('node'),
+const precondition = union([
+    strictObject({
+        kind: literal('node'),
         node: text,
         class: text,
         props: propertyConditions.optional(),
     }),
-    z.strictObject({
-        kind: z.literal('edge'),
+    strictObject({
+        kind: literal('edge'),
         edge: edgeSelector,
         slug: edgeSlug.nullable().optional(),
         props: propertyConditions.optional(),
     }),
-    z.strictObject({
-        kind: z.literal('query'),
+    strictObject({
+        kind: literal('query'),
         query: queryAstSchema,
         equals: expectedSelection,
     }),
 ]);
 /** Structural JSON contract; decodeMutationAST owns paths, bindings and atomic semantics. */
-export const mutationAstSchema = z.strictObject({
-    format: z.literal(MUTATION_AST_FORMAT),
-    version: z.literal(MUTATION_AST_VERSION),
-    preconditions: z.array(precondition).max(MUTATION_AST_LIMITS.preconditions),
-    operations: z
-        .array(z.union([
-        z.strictObject({ op: z.literal('node.create'), as: binding, class: text, props }),
-        z.strictObject({ op: z.literal('node.update'), node: text, class: text, props: patch }),
-        z.strictObject({ op: z.literal('node.delete'), node: text, class: text }),
-        z.strictObject({
-            op: z.literal('edge.create'),
+export const mutationAstSchema = strictObject({
+    format: literal(MUTATION_AST_FORMAT),
+    version: literal(MUTATION_AST_VERSION),
+    preconditions: array(precondition).max(MUTATION_AST_LIMITS.preconditions),
+    operations: array(union([
+        strictObject({ op: literal('node.create'), as: binding, class: text, props }),
+        strictObject({ op: literal('node.update'), node: text, class: text, props: patch }),
+        strictObject({ op: literal('node.delete'), node: text, class: text }),
+        strictObject({
+            op: literal('edge.create'),
             class: text,
             source: endpoint,
             target: endpoint,
@@ -82,7 +78,6 @@ export const mutationAstSchema = z.strictObject({
         }),
         edgeUpdateWithSlug,
         edgeUpdateWithProperties,
-        z.strictObject({ op: z.literal('edge.delete'), edge: edgeSelector }),
-    ]))
-        .min(1),
+        strictObject({ op: literal('edge.delete'), edge: edgeSelector }),
+    ])).min(1),
 });

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

@@ -1,7 +1,8 @@
 import type { NodeId } from '../../node/index.js';
-import type { LocalBinding } from '../language/index.js';
+import type { LocalAlias } from '../language/index.js';
 export type MutationResult = {
-    readonly createdNodes: Readonly<Record<LocalBinding, NodeId>>;
+    readonly createdNodes: Readonly<Record<LocalAlias, NodeId>>;
+    readonly replayed?: true;
 };
 export declare const MutationResult: {
     decode(input: unknown): MutationResult;
@@ -12,5 +13,5 @@ export { MutationResultDecodeError } from './error.js';
 export { mutationResultSchema } from './wire.js';
 /** Re-admit one mutation result before it crosses a trust or transport boundary. */
 export declare function encodeMutationResult(input: MutationResult): MutationResult;
-/** Decode unknown JSON into immutable admitted LocalBinding-to-NodeId results. */
+/** Decode unknown JSON into immutable admitted LocalAlias-to-NodeId results. */
 export declare function decodeMutationResult(input: unknown): MutationResult;

package/dist/graph/mutate/result/index.js

@@ -1,5 +1,5 @@
 import * as portable from '@astrale-os/kernel-dsl/value';
-import { isLocalBinding, LocalBinding as LocalBindingValue } from '#graph/graph';
+import { isLocalAlias, LocalAlias as LocalAliasValue } from '#graph/graph';
 import { NodeId as nodeId } from '../../node/index.js';
 import { decodeWire } from '../../wire.js';
 import { MutationResultDecodeError } from './error.js';
@@ -8,7 +8,7 @@ export const MutationResult = Object.freeze({
     decode: decodeMutationResult,
     encode: encodeMutationResult,
     createdNode(result, binding) {
-        return result.createdNodes[LocalBindingValue(binding)];
+        return result.createdNodes[LocalAliasValue(binding)];
     },
 });
 export { MutationResultDecodeError } from './error.js';
@@ -17,10 +17,11 @@ export { mutationResultSchema } from './wire.js';
 export function encodeMutationResult(input) {
     return decodeMutationResult(input);
 }
-/** Decode unknown JSON into immutable admitted LocalBinding-to-NodeId results. */
+/** Decode unknown JSON into immutable admitted LocalAlias-to-NodeId results. */
 export function decodeMutationResult(input) {
     try {
-        const encoded = decodeWire(mutationResultSchema, portable.accept(input), invalid).createdNodes;
+        const admitted = decodeWire(mutationResultSchema, portable.accept(input), invalid);
+        const encoded = admitted.createdNodes;
         const createdNodes = {};
         for (const binding of Object.keys(encoded).sort()) {
             const path = `/createdNodes/${escapePointer(binding)}`;
@@ -35,6 +36,7 @@ export function decodeMutationResult(input) {
         }
         return Object.freeze({
             createdNodes: Object.freeze(createdNodes),
+            ...(admitted.replayed === true ? { replayed: true } : {}),
         });
     }
     catch (error) {
@@ -46,8 +48,8 @@ export function decodeMutationResult(input) {
     }
 }
 function requireBinding(value, path) {
-    if (!isLocalBinding(value))
-        invalid(path, 'Invalid LocalBinding');
+    if (!isLocalAlias(value))
+        invalid(path, 'Invalid LocalAlias');
 }
 function escapePointer(value) {
     return value.replaceAll('~', '~0').replaceAll('/', '~1');

package/dist/graph/mutate/result/wire.d.ts

@@ -1,4 +1,4 @@
-import { z } from 'zod';
-export declare const mutationResultSchema: z.ZodObject<{
-    createdNodes: z.ZodRecord<z.ZodString, z.ZodString>;
-}, z.core.$strict>;
+export declare const mutationResultSchema: import("zod").ZodObject<{
+    createdNodes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
+    replayed: import("zod").ZodOptional<import("zod").ZodLiteral<true>>;
+}, import("zod/v4/core").$strict>;

package/dist/graph/mutate/result/wire.js

@@ -1,4 +1,7 @@
-import { z } from 'zod';
-const text = z.string().min(1);
-const binding = z.string().min(1).max(64);
-export const mutationResultSchema = z.strictObject({ createdNodes: z.record(binding, text) });
+import { literal, record, strictObject, string } from 'zod';
+const text = string().min(1);
+const binding = string().min(1).max(64);
+export const mutationResultSchema = strictObject({
+    createdNodes: record(binding, text),
+    replayed: literal(true).optional(),
+});

package/dist/graph/node/identity/id.d.ts

@@ -1,4 +1,3 @@
-import { z } from 'zod';
 declare const NODE_ID_BRAND: unique symbol;
 /** Stable opaque identity: 1-255 ASCII characters from [A-Za-z0-9._-]. */
 export type NodeId = string & {
@@ -12,7 +11,4 @@ export declare class NodeIdError extends TypeError {
 /** Admit opaque 1-255 character ASCII NodeId text without repair or format-specific semantics. */
 export declare function NodeId(input: string): NodeId;
 export declare function isNodeId(input: unknown): input is NodeId;
-export declare const nodeIdSchema: z.ZodPipe<z.ZodString & z.ZodType<NodeId, string, z.core.$ZodTypeInternals<NodeId, string>>, z.ZodTransform<NodeId, string & {
-    readonly [NODE_ID_BRAND]: true;
-}>>;
 export {};

package/dist/graph/node/identity/id.js

@@ -1,4 +1,3 @@
-import { z } from 'zod';
 const NODE_ID_MAX_LENGTH = 255;
 const NODE_ID_INVALID_CHARACTER = /[^A-Za-z0-9._-]/u;
 const NODE_ID_ERROR_MESSAGE = 'NodeId must be 1-255 ASCII characters drawn from [A-Za-z0-9._-].';
@@ -23,7 +22,3 @@ export function isNodeId(input) {
         input.length <= NODE_ID_MAX_LENGTH &&
         !NODE_ID_INVALID_CHARACTER.test(input));
 }
-export const nodeIdSchema = z
-    .string()
-    .refine(isNodeId, NODE_ID_ERROR_MESSAGE)
-    .transform((value) => value);

package/dist/graph/node/identity/order.js

@@ -1,6 +1,26 @@
 const encoder = new TextEncoder();
 /** Compare canonical Node identity by unsigned lexicographic UTF-8 byte order. */
 export function compareNodeIds(left, right) {
+    // UTF-8 preserves code point order, and identical UTF-16 prefixes encode identically. Below the
+    // surrogate block, the first differing code unit therefore decides the UTF-8 byte order.
+    const length = Math.min(left.length, right.length);
+    let index = 0;
+    while (index < length && left.charCodeAt(index) === right.charCodeAt(index))
+        index++;
+    if (index < length) {
+        const a = left.charCodeAt(index);
+        const b = right.charCodeAt(index);
+        if (a < 0xd800 && b < 0xd800)
+            return a < b ? -1 : 1;
+    }
+    else {
+        const next = (left.length > right.length ? left : right).charCodeAt(index);
+        if (Number.isNaN(next) || next < 0xdc00 || next > 0xdfff)
+            return Math.sign(left.length - right.length);
+    }
+    return compareUtf8(left, right);
+}
+function compareUtf8(left, right) {
     const a = encoder.encode(left);
     const b = encoder.encode(right);
     const length = Math.min(a.length, b.length);

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

@@ -1,4 +1,5 @@
-import type { CoreRef, DefinitionRef, Key } from '@astrale-os/kernel-dsl/v1/addressing';
+import type { DefinitionRef, Key } from '@astrale-os/kernel-dsl/v1/addressing';
+import { MethodKey } from '@astrale-os/kernel-dsl/v1/addressing';
 import { type ClassKey as ClassKeyValue } from '@astrale-os/kernel-dsl/v1/addressing';
 import type { NodeId } from '../../node/identity/index.js';
 import type { DomainAnchor as PathDomainAnchor, DomainProjection as PathDomainProjection, IdAnchor as PathIdAnchor, MethodStep as PathMethodStep, NodePath, PathAST, PathAnchor, PathDiagnostic, PathDiagnosticCode, PathStep, ProjectionKind as PathProjectionKind, ProjectionStep as PathProjectionStep, TraversalStep as PathTraversalStep } from '../language/index.js';
@@ -11,13 +12,15 @@ export declare class Path {
     private constructor();
     /** Retain an admitted rich Path or parse its canonical serialized form. */
     static from(input: PathLike): Path;
+    /** Normalize an exact graph target without resolving its installed Node identity. */
+    static target(input: NodeTarget): Path;
     static parse(input: string): Path;
     static fromAST(ast: Path.AST): Path;
     static id(id: NodeId): Path.Id;
     static domain(origin: Key.Origin): Path.Domain;
     static project(input: ClassKeyValue | Path.ProjectionRef): Path.Projection;
     static staticMethod(owner: Path.Projection, name: string): Path.Method;
-    static instanceMethod(source: Path, name: string): Path.Method;
+    static instanceMethod(source: Path, callable: MethodKey): Path.Method;
     out(classKey: ClassKeyValue, options?: Path.TraversalOptions): Path;
     in(classKey: ClassKeyValue, options?: Path.TraversalOptions): Path;
     equals(other: Path): boolean;
@@ -27,8 +30,8 @@ export declare class Path {
 }
 /** Rich or already-admitted serialized Path accepted at in-process authoring boundaries. */
 export type PathLike = Path | NodePath;
-/** Exact existing Node 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 +49,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,7 @@
-import { ClassKey } from '@astrale-os/kernel-dsl/v1/addressing';
+import { MethodKey } from '@astrale-os/kernel-dsl/v1/addressing';
+import { ClassKey, isDefinitionRef, } from '@astrale-os/kernel-dsl/v1/addressing';
 import { EdgeSlug } from '../../edge/slug/index.js';
+import { isNodeId } from '../../node/identity/index.js';
 import { normalizePathAST, parsePathAST, pathError, serializePathAST } from '../language/index.js';
 /** Immutable rich value for one admitted NodePath. */
 export class Path {
@@ -10,6 +12,18 @@ export class Path {
     static from(input) {
         return input instanceof Path ? input : Path.parse(input);
     }
+    /** Normalize an exact graph target without resolving its installed Node identity. */
+    static target(input) {
+        if (input instanceof Path)
+            return input;
+        if (isNodeId(input))
+            return Path.id(input);
+        if (typeof input === 'string')
+            return Path.parse(input);
+        if (isDefinitionRef(input))
+            return Path.project(input);
+        throw pathError(input, 'PATH_INVALID_PROJECTION', 'Node target requires an ID, Path, or DefinitionRef.');
+    }
     static parse(input) {
         return createPath(parsePathAST(input));
     }
@@ -38,10 +52,14 @@ export class Path {
             steps: [...owner.ast.steps, { kind: 'method', dispatch: 'static', name }],
         }));
     }
-    static instanceMethod(source, name) {
+    static instanceMethod(source, callable) {
+        const { owner, name } = MethodKey.address(callable);
         return createPath(normalizePathAST({
             anchor: source.ast.anchor,
-            steps: [...source.ast.steps, { kind: 'method', dispatch: 'instance', name }],
+            steps: [
+                ...source.ast.steps,
+                { kind: 'method', dispatch: 'instance', class: ClassKey.of(owner), name },
+            ],
         }));
     }
     out(classKey, options = {}) {

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

@@ -25,11 +25,16 @@ export interface ProjectionStep {
     readonly kind: 'projection';
     readonly projection: DomainProjection;
 }
-export interface MethodStep {
+export type MethodStep = {
     readonly kind: 'method';
-    readonly dispatch: 'static' | 'instance';
+    readonly dispatch: 'static';
     readonly name: string;
-}
+} | {
+    readonly kind: 'method';
+    readonly dispatch: 'instance';
+    readonly class: ClassKey;
+    readonly name: string;
+};
 export interface TraversalStep {
     readonly kind: 'traverse';
     readonly direction: 'out' | 'in';

package/dist/graph/path/language/syntax.js

@@ -1,4 +1,4 @@
-import { patterns } from '@astrale-os/kernel-dsl/v1/addressing';
+import { patterns, MethodKey } from '@astrale-os/kernel-dsl/v1/addressing';
 import { ClassKey } from '@astrale-os/kernel-dsl/v1/addressing';
 import { EdgeSlug, isEdgeSlug } from '../../edge/slug/index.js';
 import { isNodeId } from '../../node/identity/index.js';
@@ -34,7 +34,9 @@ export function normalizePathAST(input) {
             continue;
         }
         if (candidate.kind === 'method') {
-            if (!hasExactKeys(candidate, ['kind', 'dispatch', 'name']))
+            if (!hasExactKeys(candidate, candidate.dispatch === 'instance'
+                ? ['kind', 'dispatch', 'class', 'name']
+                : ['kind', 'dispatch', 'name']))
                 invalidAST();
             if (candidate.dispatch !== 'static' && candidate.dispatch !== 'instance')
                 invalidAST();
@@ -49,7 +51,18 @@ export function normalizePathAST(input) {
                     invalidAST();
                 }
             }
-            steps.push({ kind: 'method', dispatch: candidate.dispatch, name: candidate.name });
+            if (candidate.dispatch === 'instance') {
+                if (!ClassKey.is(candidate.class))
+                    invalidAST();
+                steps.push({
+                    kind: 'method',
+                    dispatch: 'instance',
+                    class: ClassKey(candidate.class),
+                    name: candidate.name,
+                });
+            }
+            else
+                steps.push({ kind: 'method', dispatch: 'static', name: candidate.name });
             continue;
         }
         if (candidate.kind === 'traverse') {
@@ -111,11 +124,12 @@ function parseSteps(input, start, anchorKind) {
     let cursor = start;
     while (cursor < input.length) {
         if (input.startsWith('::', cursor)) {
-            const name = input.slice(cursor + 2);
-            if (!patterns.memberName.test(name)) {
-                throw pathError(input, 'PATH_INVALID_METHOD', 'Invalid instance Method name.', cursor + 2);
+            const key = input.slice(cursor + 2);
+            if (!MethodKey.is(key)) {
+                throw pathError(input, 'PATH_INVALID_METHOD', 'Instance Method requires a complete domain-qualified Method key.', cursor + 2);
             }
-            steps.push({ kind: 'method', dispatch: 'instance', name });
+            const { owner, name } = MethodKey.address(key);
+            steps.push({ kind: 'method', dispatch: 'instance', class: ClassKey.of(owner), name });
             cursor = input.length;
             continue;
         }
@@ -234,7 +248,8 @@ function serializeNormalizedPathAST(ast) {
             output += `:${step.projection.kind}.${step.projection.name}`;
         }
         else if (step.kind === 'method') {
-            output += `${step.dispatch === 'instance' ? '::' : ':'}${step.name}`;
+            output +=
+                step.dispatch === 'instance' ? `::${step.class}.method.${step.name}` : `:${step.name}`;
         }
         else {
             output += `${step.direction === 'in' ? '<~' : '~'}"${step.class}"`;

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) {
@@ -41,6 +40,33 @@ export function Property(input) {
         isPresent() {
             return Object.freeze({ kind: 'property.present', property: key });
         },
+        greater: (value) => range(key, bound(value, false, 'lower'), undefined),
+        greaterOrEqual: (value) => range(key, bound(value, true, 'lower'), undefined),
+        less: (value) => range(key, undefined, bound(value, false, 'upper')),
+        lessOrEqual: (value) => range(key, undefined, bound(value, true, 'upper')),
+        between(lower, upper, bounds = {}) {
+            if (typeof lower !== typeof upper) {
+                invalid('/predicate/upper/value', 'Range bounds must have one kind');
+            }
+            return range(key, bound(lower, bounds.lower !== 'exclusive', 'lower'), bound(upper, bounds.upper !== 'exclusive', 'upper'));
+        },
+    });
+}
+function bound(value, inclusive, side) {
+    if (typeof value !== 'number' && typeof value !== 'string') {
+        invalid(`/predicate/${side}/value`, 'Range bound must be a number or a text');
+    }
+    return Object.freeze({
+        value: canonicalValue(value, `/predicate/${side}/value`),
+        inclusive,
+    });
+}
+function range(property, lower, upper) {
+    return Object.freeze({
+        kind: 'property.range',
+        property,
+        ...(lower === undefined ? {} : { lower }),
+        ...(upper === undefined ? {} : { upper }),
     });
 }
 /** Primary persistent Query V6 authoring entry point. */
@@ -191,12 +217,12 @@ function appendFilter(state, input, defaultBinding) {
         ...(state.edge === undefined ? {} : { edge: state.edge }),
     });
 }
-function canonicalValue(input) {
+function canonicalValue(input, path = '/predicate/value') {
     try {
         return freezeValue(portable.json.decode(portable.json.encode(input)));
     }
     catch (cause) {
-        invalid('/predicate/value', 'Invalid portable equality value', cause);
+        invalid(path, 'Invalid portable Property value', cause);
     }
 }
 function freezeValue(input) {
@@ -373,9 +399,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/graph/query/authoring/model.d.ts

@@ -1,7 +1,7 @@
 import type * as dslApi from '@astrale-os/kernel-dsl/v1';
 import type * as portable from '@astrale-os/kernel-dsl/value';
 import type { NodeTarget } from '../../path/index.js';
-import type { EdgeBinding, NodeBinding, QueryBinding, QueryDirection, QueryEdgeIdentityPredicate, QueryEdgeProjection, QueryNodeIdentityPredicate, QueryNodeProjection, QueryPropertyOrder, QueryPropertyPredicate, QueryPropertyEqualPredicate, QueryPropertyPresentPredicate } from '../language/index.js';
+import type { EdgeBinding, NodeBinding, QueryBinding, QueryDirection, QueryEdgeIdentityPredicate, QueryEdgeProjection, QueryNodeIdentityPredicate, QueryNodeProjection, QueryPropertyOrder, QueryPropertyPredicate, QueryPropertyEqualPredicate, QueryPropertyPresentPredicate, QueryPropertyRangeOf } from '../language/index.js';
 type NonEmpty<Value> = readonly [Value, ...Value[]];
 export type QueryClassInput<Kind extends 'node' | 'edge' = 'node' | 'edge'> = dslApi.ClassRef | dslApi.ClassKey | Readonly<{
     readonly ref: dslApi.ClassRef;
@@ -55,9 +55,28 @@ export type QueryCurrentNodeFilterInput = (Omit<QueryClassFilterInput, 'binding'
 }) | Extract<QueryIdentityFilterInput, {
     readonly binding: EdgeBinding;
 }>;
+/** Whether each end of `between` includes its bound; both are inclusive by default. */
+export interface QueryRangeBoundsInput {
+    readonly lower?: 'inclusive' | 'exclusive';
+    readonly upper?: 'inclusive' | 'exclusive';
+}
+/**
+ * Property predicate leaves. The range forms are one canonical `property.range` predicate: a
+ * number range compares numerically, a text range in code-point order.
+ */
 export interface QueryPropertyPredicateBuilder {
     equals(value: portable.Value): QueryPropertyEqualPredicate;
     isPresent(): QueryPropertyPresentPredicate;
+    greater(value: number): QueryPropertyRangeOf<number>;
+    greater(value: string): QueryPropertyRangeOf<string>;
+    greaterOrEqual(value: number): QueryPropertyRangeOf<number>;
+    greaterOrEqual(value: string): QueryPropertyRangeOf<string>;
+    less(value: number): QueryPropertyRangeOf<number>;
+    less(value: string): QueryPropertyRangeOf<string>;
+    lessOrEqual(value: number): QueryPropertyRangeOf<number>;
+    lessOrEqual(value: string): QueryPropertyRangeOf<string>;
+    between(lower: number, upper: number, bounds?: QueryRangeBoundsInput): QueryPropertyRangeOf<number>;
+    between(lower: string, upper: string, bounds?: QueryRangeBoundsInput): QueryPropertyRangeOf<string>;
 }
 export interface QueryExpandInput {
     readonly from: NodeBinding;

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

@@ -1,9 +1,11 @@
 /** Stable flat facade over Query language, authoring, result, and reference semantics. */
 export { Property, Query } from './authoring/index.js';
-export type { EdgeQueryBuilder, ExpandedQueryBuilder, NodeQueryBuilder, QueryCurrentNodeExpandInput, QueryCurrentNodeFilterInput, QueryClassInput, QueryEdgeClassInput, QueryEdgeInput, QueryClassFilterInput, QueryEdgeSourceInput, QueryEdgeGraphSelectInput, QueryEdgeSelectInput, QueryExpandInput, QueryFilterInput, QueryIdentityFilterInput, QueryNodeClassInput, QueryNodeGraphSelectInput, QueryNodeInput, QueryNodeSelectInput, QueryNodeSourceInput, QueryPropertyFilterInput, QueryPropertyPredicateBuilder, QuerySelectInput, QuerySourceInput, } from './authoring/index.js';
+export type { EdgeQueryBuilder, ExpandedQueryBuilder, NodeQueryBuilder, QueryCurrentNodeExpandInput, QueryCurrentNodeFilterInput, QueryClassInput, QueryEdgeClassInput, QueryEdgeInput, QueryClassFilterInput, QueryEdgeSourceInput, QueryEdgeGraphSelectInput, QueryEdgeSelectInput, QueryExpandInput, QueryFilterInput, QueryIdentityFilterInput, QueryNodeClassInput, QueryNodeGraphSelectInput, QueryNodeInput, QueryNodeSelectInput, QueryNodeSourceInput, QueryPropertyFilterInput, QueryPropertyPredicateBuilder, QueryRangeBoundsInput, QuerySelectInput, QuerySourceInput, } from './authoring/index.js';
 export { QueryAST, QueryASTDecodeError } from './language/index.js';
-export type { EdgeBinding, NodeBinding, QueryBinding, QueryClassFilter, QueryClassPredicate, QueryClassSourceTerm, QueryClassSatisfiesPredicate, QueryClassEqualPredicate, QueryDirection, QueryEdgeSource, QueryEdgeSourceTerm, QueryEdgeSelect, QueryEdgeAST, QueryEdgeIdentityPredicate, QueryEdgeProjection, QueryExpand, QueryFingerprint, QueryIdentityFilter, QueryIdentityPredicate, QueryGraphSelect, QueryNodeAST, QueryNodeIdentityPredicate, QueryNodeProjection, QueryNodeSelect, QueryNodeSource, QueryNodeSourceTerm, QueryNodeTerminalSelect, QueryEdgeTerminalSelect, QueryOrderDirection, QueryPathSourceTerm, QueryPredicate, QueryProjectionShape, QueryPropertyEqualPredicate, QueryPropertyFilter, QueryPropertyOrder, QueryPropertyPredicate, QueryPropertyPresentPredicate, QuerySelect, QuerySingleSourceClassOf, QuerySource, QuerySourceClassesOf, QuerySourceTerm, QueryStep, QueryStructuralLimits, QueryUnrankedPlacement, } from './language/index.js';
+export type { EdgeBinding, NodeBinding, QueryBinding, QueryClassFilter, QueryClassPredicate, QueryClassSourceTerm, QueryClassSatisfiesPredicate, QueryClassEqualPredicate, QueryDirection, QueryEdgeSource, QueryEdgeSourceTerm, QueryEdgeSelect, QueryEdgeAST, QueryEdgeIdentityPredicate, QueryEdgeProjection, QueryExpand, QueryFingerprint, QueryIdentityFilter, QueryIdentityPredicate, QueryGraphSelect, QueryNodeAST, QueryNodeIdentityPredicate, QueryNodeProjection, QueryNodeSelect, QueryNodeSource, QueryNodeSourceTerm, QueryNodeTerminalSelect, QueryEdgeTerminalSelect, QueryOrderDirection, QueryPathSourceTerm, QueryPredicate, QueryProjectionShape, QueryPropertyEqualPredicate, QueryPropertyFilter, QueryPropertyOrder, QueryPropertyPredicate, QueryPropertyPresentPredicate, QueryPropertyRangeOf, QueryPropertyRangePredicate, QueryRangeBound, QueryRangeValue, QuerySelect, QuerySingleSourceClassOf, QuerySource, QuerySourceClassesOf, QuerySourceTerm, QueryStep, QueryStructuralLimits, QueryUnrankedPlacement, } from './language/index.js';
 export { QueryResult, QueryResultDecodeError } from './result/index.js';
 export type { QueryEdgeComponentFor, QueryEdgeGraphResult, QueryEdgeItemFor, QueryEdgeResult, QueryGraphResult, QueryNodeComponentFor, QueryNodeGraphResult, QueryNodeItemFor, QueryNodeReference, QueryNodeResult, QueryResultFor, QueryResultForSelect, QuerySelection, QuerySelectionFor, } from './result/index.js';
+export { compareQueryIdentity, compareQueryRank, compareQueryText, compareQueryValue, queryRangeContains, } from './order/index.js';
+export type { QueryRank, QueryRankIdentity, QueryRankOrder, QueryRankValue } from './order/index.js';
 export { QueryReference, QueryReferenceError } from './reference/index.js';
 export type { QueryReferenceContext, QueryReferenceClassClosure, QueryReferenceEvaluation, QueryReferenceFrontier, QueryReferenceIdentity, QueryReferenceOptions, QueryReferencePathWitness, QueryReferenceProperty, QueryReferenceTrace, } from './reference/index.js';

package/dist/graph/query/index.js

@@ -2,4 +2,5 @@
 export { Property, Query } from './authoring/index.js';
 export { QueryAST, QueryASTDecodeError } from './language/index.js';
 export { QueryResult, QueryResultDecodeError } from './result/index.js';
+export { compareQueryIdentity, compareQueryRank, compareQueryText, compareQueryValue, queryRangeContains, } from './order/index.js';
 export { QueryReference, QueryReferenceError } from './reference/index.js';

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

@@ -1,7 +1,7 @@
 import { patterns, PropertyKey } from '@astrale-os/kernel-dsl/v1/addressing';
 import { ClassKey } from '@astrale-os/kernel-dsl/v1/addressing';
 import * as portable from '@astrale-os/kernel-dsl/value';
-import { LocalBinding } from '../../graph/index.js';
+import { LocalAlias } from '../../graph/index.js';
 import { NodeId } from '../../node/index.js';
 import { NodePath } from '../../path/index.js';
 import { decodeWire } from '../../wire.js';
@@ -194,6 +194,21 @@ function decodePredicate(input, path, binding) {
     if (input.kind === 'property.present') {
         return Object.freeze({ kind: 'property.present', property });
     }
+    if (input.kind === 'property.range') {
+        const lower = input.lower === undefined ? undefined : Object.freeze({ ...input.lower });
+        const upper = input.upper === undefined ? undefined : Object.freeze({ ...input.upper });
+        if (lower === undefined && upper === undefined)
+            invalid(path, 'Range requires a bound');
+        if (lower !== undefined && upper !== undefined && typeof lower.value !== typeof upper.value) {
+            invalid(`${path}/upper/value`, 'Range bounds must have one kind');
+        }
+        return Object.freeze({
+            kind: 'property.range',
+            property,
+            ...(lower === undefined ? {} : { lower }),
+            ...(upper === undefined ? {} : { upper }),
+        });
+    }
     return Object.freeze({
         kind: 'property.equal',
         property,
@@ -237,7 +252,7 @@ function decodeClass(input, path) {
 function introduce(input, kind, path, symbols) {
     let name;
     try {
-        name = LocalBinding(input);
+        name = LocalAlias(input);
     }
     catch (cause) {
         invalid(path, 'Invalid binding name', cause);
@@ -250,7 +265,7 @@ function introduce(input, kind, path, symbols) {
 function reference(input, expected, path, symbols) {
     let name;
     try {
-        name = LocalBinding(input);
+        name = LocalAlias(input);
     }
     catch (cause) {
         invalid(path, 'Invalid binding name', cause);