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

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

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

@@ -87,6 +87,17 @@ export declare const mutationAstSchema: import("zod").ZodObject<{
                 }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
                     kind: import("zod").ZodLiteral<"property.present">;
                     property: import("zod").ZodString;
+                }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                    kind: import("zod").ZodLiteral<"property.range">;
+                    property: import("zod").ZodString;
+                    lower: import("zod").ZodOptional<import("zod").ZodObject<{
+                        value: import("zod").ZodUnion<readonly [import("zod").ZodNumber, import("zod").ZodString]>;
+                        inclusive: import("zod").ZodBoolean;
+                    }, import("zod/v4/core").$strict>>;
+                    upper: import("zod").ZodOptional<import("zod").ZodObject<{
+                        value: import("zod").ZodUnion<readonly [import("zod").ZodNumber, import("zod").ZodString]>;
+                        inclusive: import("zod").ZodBoolean;
+                    }, import("zod/v4/core").$strict>>;
                 }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
                     kind: import("zod").ZodLiteral<"identity.equal">;
                     identity: import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodObject<{

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,3 +1,4 @@
 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 { record, strictObject, string } from 'zod';
+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) });
+export const mutationResultSchema = strictObject({
+    createdNodes: record(binding, text),
+    replayed: literal(true).optional(),
+});

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

@@ -11,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: import("zod").ZodPipe<import("zod").ZodString & import("zod").ZodType<NodeId, string, import("zod/v4/core").$ZodTypeInternals<NodeId, string>>, import("zod").ZodTransform<NodeId, string & {
-    readonly [NODE_ID_BRAND]: true;
-}>>;
 export {};

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

@@ -1,4 +1,3 @@
-import { string } 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,6 +22,3 @@ export function isNodeId(input) {
         input.length <= NODE_ID_MAX_LENGTH &&
         !NODE_ID_INVALID_CHARACTER.test(input));
 }
-export const nodeIdSchema = 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/query/authoring/builder.js

@@ -40,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. */
@@ -190,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) {

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,11 +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, } from './order/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,5 +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, } from './order/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);

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

@@ -122,6 +122,14 @@ function predicateValue(predicate) {
     if (predicate.kind === 'property.present') {
         return { kind: predicate.kind, property: predicate.property };
     }
+    if (predicate.kind === 'property.range') {
+        return {
+            kind: predicate.kind,
+            property: predicate.property,
+            ...(predicate.lower === undefined ? {} : { lower: { ...predicate.lower } }),
+            ...(predicate.upper === undefined ? {} : { upper: { ...predicate.upper } }),
+        };
+    }
     if (predicate.kind === 'identity.equal') {
         return {
             kind: predicate.kind,

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

@@ -1,7 +1,7 @@
 import type { ClassRef, PropertyKey } from '@astrale-os/kernel-dsl/v1';
 import type * as portable from '@astrale-os/kernel-dsl/value';
 import type { EdgeKey } from '../../edge/index.js';
-import type { LocalBinding } from '../../graph/index.js';
+import type { LocalAlias } from '../../graph/index.js';
 import type { NodeId } from '../../node/index.js';
 import type { NodePath } from '../../path/index.js';
 export declare const QUERY_AST_FORMAT: 'astrale.graph.query';
@@ -20,10 +20,10 @@ export type QueryUnrankedPlacement = 'first' | 'last';
 export type QueryFingerprint = `sha256:${string}`;
 declare const NODE_BINDING: unique symbol;
 declare const EDGE_BINDING: unique symbol;
-export type NodeBinding = LocalBinding & {
+export type NodeBinding = LocalAlias & {
     readonly [NODE_BINDING]: true;
 };
-export type EdgeBinding = LocalBinding & {
+export type EdgeBinding = LocalAlias & {
     readonly [EDGE_BINDING]: true;
 };
 export type QueryBinding = NodeBinding | EdgeBinding;
@@ -76,7 +76,25 @@ export interface QueryPropertyPresentPredicate {
     readonly kind: 'property.present';
     readonly property: PropertyKey;
 }
-export type QueryPropertyPredicate = QueryPropertyEqualPredicate | QueryPropertyPresentPredicate;
+/** A range bound value: a finite number or a text, compared in Core order. */
+export type QueryRangeValue = number | string;
+/** One end of a range; an exclusive bound excludes a value equal to it. */
+export interface QueryRangeBound<Value extends QueryRangeValue = QueryRangeValue> {
+    readonly value: Value;
+    readonly inclusive: boolean;
+}
+/**
+ * A stored value of the bounds' kind within at least one and at most two bounds: numeric order for
+ * numbers, code-point order for texts. Both bounds have one kind. Any other value never passes.
+ */
+export type QueryPropertyRangePredicate = QueryPropertyRangeOf<number> | QueryPropertyRangeOf<string>;
+export interface QueryPropertyRangeOf<Value extends QueryRangeValue> {
+    readonly kind: 'property.range';
+    readonly property: PropertyKey;
+    readonly lower?: QueryRangeBound<Value>;
+    readonly upper?: QueryRangeBound<Value>;
+}
+export type QueryPropertyPredicate = QueryPropertyEqualPredicate | QueryPropertyPresentPredicate | QueryPropertyRangePredicate;
 export interface QueryNodeIdentityPredicate {
     readonly kind: 'identity.equal';
     readonly identity: NodeId;