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

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

@@ -1,149 +1,159 @@
-import { z } from 'zod';
 /** Structural JSON contract; decodeQueryAST owns canonical identities and binding dependencies. */
-export declare const queryAstSchema: z.ZodObject<{
-    format: z.ZodLiteral<"astrale.graph.query">;
-    version: z.ZodLiteral<"v6">;
-    source: z.ZodDiscriminatedUnion<[z.ZodObject<{
-        kind: z.ZodLiteral<"node">;
-        terms: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
-            kind: z.ZodLiteral<"path">;
-            path: z.ZodString;
-        }, z.core.$strict>, z.ZodObject<{
-            kind: z.ZodLiteral<"class">;
-            class: z.ZodObject<{
-                origin: z.ZodString;
-                kind: z.ZodLiteral<"class">;
-                name: z.ZodString;
-            }, z.core.$strict>;
-        }, z.core.$strict>], "kind">>;
-        binding: z.ZodString;
-    }, z.core.$strict>, z.ZodObject<{
-        kind: z.ZodLiteral<"edge">;
-        terms: z.ZodArray<z.ZodObject<{
-            kind: z.ZodLiteral<"class">;
-            class: z.ZodObject<{
-                origin: z.ZodString;
-                kind: z.ZodLiteral<"class">;
-                name: z.ZodString;
-            }, z.core.$strict>;
-        }, z.core.$strict>>;
-        bindings: z.ZodObject<{
-            source: z.ZodString;
-            edge: z.ZodString;
-            target: z.ZodString;
-        }, z.core.$strict>;
-    }, z.core.$strict>], "kind">;
-    steps: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
-        op: z.ZodLiteral<"filter">;
-        binding: z.ZodString;
-        predicate: z.ZodDiscriminatedUnion<[z.ZodObject<{
-            kind: z.ZodLiteral<"class.satisfies">;
-            class: z.ZodObject<{
-                origin: z.ZodString;
-                kind: z.ZodLiteral<"class">;
-                name: z.ZodString;
-            }, z.core.$strict>;
-        }, z.core.$strict>, z.ZodObject<{
-            kind: z.ZodLiteral<"class.equal">;
-            class: z.ZodObject<{
-                origin: z.ZodString;
-                kind: z.ZodLiteral<"class">;
-                name: z.ZodString;
-            }, z.core.$strict>;
-        }, z.core.$strict>, z.ZodObject<{
-            kind: z.ZodLiteral<"property.equal">;
-            property: z.ZodString;
-            value: z.ZodUnknown;
-        }, z.core.$strict>, z.ZodObject<{
-            kind: z.ZodLiteral<"property.present">;
-            property: z.ZodString;
-        }, z.core.$strict>, z.ZodObject<{
-            kind: z.ZodLiteral<"identity.equal">;
-            identity: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-                source: z.ZodString;
-                target: z.ZodString;
-                class: z.ZodString;
-            }, z.core.$strict>]>;
-        }, z.core.$strict>], "kind">;
-    }, z.core.$strict>, z.ZodObject<{
-        op: z.ZodLiteral<"expand">;
-        from: z.ZodString;
-        via: z.ZodArray<z.ZodObject<{
-            origin: z.ZodString;
-            kind: z.ZodLiteral<"class">;
-            name: z.ZodString;
-        }, z.core.$strict>>;
-        direction: z.ZodEnum<{
+export declare const queryAstSchema: import("zod").ZodObject<{
+    format: import("zod").ZodLiteral<"astrale.graph.query">;
+    version: import("zod").ZodLiteral<"v6">;
+    source: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<"node">;
+        terms: import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"path">;
+            path: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"class">;
+            class: import("zod").ZodObject<{
+                origin: import("zod").ZodString;
+                kind: import("zod").ZodLiteral<"class">;
+                name: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>;
+        }, import("zod/v4/core").$strict>], "kind">>;
+        binding: import("zod").ZodString;
+    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<"edge">;
+        terms: import("zod").ZodArray<import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"class">;
+            class: import("zod").ZodObject<{
+                origin: import("zod").ZodString;
+                kind: import("zod").ZodLiteral<"class">;
+                name: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>;
+        }, import("zod/v4/core").$strict>>;
+        bindings: import("zod").ZodObject<{
+            source: import("zod").ZodString;
+            edge: import("zod").ZodString;
+            target: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>;
+    }, import("zod/v4/core").$strict>], "kind">;
+    steps: import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+        op: import("zod").ZodLiteral<"filter">;
+        binding: import("zod").ZodString;
+        predicate: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"class.satisfies">;
+            class: import("zod").ZodObject<{
+                origin: import("zod").ZodString;
+                kind: import("zod").ZodLiteral<"class">;
+                name: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"class.equal">;
+            class: import("zod").ZodObject<{
+                origin: import("zod").ZodString;
+                kind: import("zod").ZodLiteral<"class">;
+                name: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"property.equal">;
+            property: import("zod").ZodString;
+            value: import("zod").ZodUnknown;
+        }, 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<{
+                source: import("zod").ZodString;
+                target: import("zod").ZodString;
+                class: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>]>;
+        }, import("zod/v4/core").$strict>], "kind">;
+    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+        op: import("zod").ZodLiteral<"expand">;
+        from: import("zod").ZodString;
+        via: import("zod").ZodArray<import("zod").ZodObject<{
+            origin: import("zod").ZodString;
+            kind: import("zod").ZodLiteral<"class">;
+            name: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>>;
+        direction: import("zod").ZodEnum<{
             incident: "incident";
             incoming: "incoming";
             outgoing: "outgoing";
         }>;
-        bindings: z.ZodObject<{
-            edge: z.ZodString;
-            node: z.ZodString;
-        }, z.core.$strict>;
-    }, z.core.$strict>], "op">>;
-    select: z.ZodDiscriminatedUnion<[z.ZodObject<{
-        kind: z.ZodLiteral<"graph">;
-        binding: z.ZodString;
-        order: z.ZodOptional<z.ZodObject<{
-            property: z.ZodString;
-            direction: z.ZodEnum<{
+        bindings: import("zod").ZodObject<{
+            edge: import("zod").ZodString;
+            node: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>;
+    }, import("zod/v4/core").$strict>], "op">>;
+    select: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<"graph">;
+        binding: import("zod").ZodString;
+        order: import("zod").ZodOptional<import("zod").ZodObject<{
+            property: import("zod").ZodString;
+            direction: import("zod").ZodEnum<{
                 asc: "asc";
                 desc: "desc";
             }>;
-            unranked: z.ZodEnum<{
+            unranked: import("zod").ZodEnum<{
                 first: "first";
                 last: "last";
             }>;
-        }, z.core.$strict>>;
-    }, z.core.$strict>, z.ZodObject<{
-        kind: z.ZodLiteral<"nodes">;
-        binding: z.ZodString;
-        projection: z.ZodObject<{
-            kind: z.ZodEnum<{
+        }, import("zod/v4/core").$strict>>;
+    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<"nodes">;
+        binding: import("zod").ZodString;
+        projection: import("zod").ZodObject<{
+            kind: import("zod").ZodEnum<{
                 reference: "reference";
                 value: "value";
             }>;
-        }, z.core.$strict>;
-        order: z.ZodOptional<z.ZodObject<{
-            property: z.ZodString;
-            direction: z.ZodEnum<{
+        }, import("zod/v4/core").$strict>;
+        order: import("zod").ZodOptional<import("zod").ZodObject<{
+            property: import("zod").ZodString;
+            direction: import("zod").ZodEnum<{
                 asc: "asc";
                 desc: "desc";
             }>;
-            unranked: z.ZodEnum<{
+            unranked: import("zod").ZodEnum<{
                 first: "first";
                 last: "last";
             }>;
-        }, z.core.$strict>>;
-    }, z.core.$strict>, z.ZodObject<{
-        kind: z.ZodLiteral<"edges">;
-        binding: z.ZodString;
-        projection: z.ZodObject<{
-            edge: z.ZodEnum<{
+        }, import("zod/v4/core").$strict>>;
+    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<"edges">;
+        binding: import("zod").ZodString;
+        projection: import("zod").ZodObject<{
+            edge: import("zod").ZodEnum<{
                 reference: "reference";
                 value: "value";
             }>;
-            source: z.ZodEnum<{
+            source: import("zod").ZodEnum<{
                 reference: "reference";
                 value: "value";
             }>;
-            target: z.ZodEnum<{
+            target: import("zod").ZodEnum<{
                 reference: "reference";
                 value: "value";
             }>;
-        }, z.core.$strict>;
-        order: z.ZodOptional<z.ZodObject<{
-            property: z.ZodString;
-            direction: z.ZodEnum<{
+        }, import("zod/v4/core").$strict>;
+        order: import("zod").ZodOptional<import("zod").ZodObject<{
+            property: import("zod").ZodString;
+            direction: import("zod").ZodEnum<{
                 asc: "asc";
                 desc: "desc";
             }>;
-            unranked: z.ZodEnum<{
+            unranked: import("zod").ZodEnum<{
                 first: "first";
                 last: "last";
             }>;
-        }, z.core.$strict>>;
-    }, z.core.$strict>], "kind">;
-}, z.core.$strict>;
+        }, import("zod/v4/core").$strict>>;
+    }, import("zod/v4/core").$strict>], "kind">;
+}, import("zod/v4/core").$strict>;

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

@@ -1,68 +1,75 @@
-import { z } from 'zod';
+import { array, boolean, discriminatedUnion, enum as enumeration, literal, number, strictObject, string, union, unknown as unknownSchema, } from 'zod';
 import { QUERY_AST_FORMAT, QUERY_AST_LIMITS, QUERY_AST_VERSION } from './model.js';
-const text = z.string().min(1);
+const text = string().min(1);
 const binding = text.max(64);
-const classRef = z.strictObject({
+const classRef = strictObject({
     origin: text.max(253),
-    kind: z.literal('class'),
+    kind: literal('class'),
     name: text,
 });
-const nodeSourceTerm = z.discriminatedUnion('kind', [
-    z.strictObject({ kind: z.literal('path'), path: text }),
-    z.strictObject({ kind: z.literal('class'), class: classRef }),
+const nodeSourceTerm = discriminatedUnion('kind', [
+    strictObject({ kind: literal('path'), path: text }),
+    strictObject({ kind: literal('class'), class: classRef }),
 ]);
-const classSourceTerm = z.strictObject({ kind: z.literal('class'), class: classRef });
-const source = z.discriminatedUnion('kind', [
-    z.strictObject({
-        kind: z.literal('node'),
-        terms: z.array(nodeSourceTerm).min(1).max(QUERY_AST_LIMITS.sourceTerms),
+const classSourceTerm = strictObject({ kind: literal('class'), class: classRef });
+const source = discriminatedUnion('kind', [
+    strictObject({
+        kind: literal('node'),
+        terms: array(nodeSourceTerm).min(1).max(QUERY_AST_LIMITS.sourceTerms),
         binding,
     }),
-    z.strictObject({
-        kind: z.literal('edge'),
-        terms: z.array(classSourceTerm).min(1).max(QUERY_AST_LIMITS.sourceTerms),
-        bindings: z.strictObject({ source: binding, edge: binding, target: binding }),
+    strictObject({
+        kind: literal('edge'),
+        terms: array(classSourceTerm).min(1).max(QUERY_AST_LIMITS.sourceTerms),
+        bindings: strictObject({ source: binding, edge: binding, target: binding }),
     }),
 ]);
-const predicate = z.discriminatedUnion('kind', [
-    z.strictObject({ kind: z.literal('class.satisfies'), class: classRef }),
-    z.strictObject({ kind: z.literal('class.equal'), class: classRef }),
-    z.strictObject({ kind: z.literal('property.equal'), property: text, value: z.unknown() }),
-    z.strictObject({ kind: z.literal('property.present'), property: text }),
-    z.strictObject({
-        kind: z.literal('identity.equal'),
-        identity: z.union([text, z.strictObject({ source: text, target: text, class: text })]),
+const rangeBound = strictObject({ value: union([number(), string()]), inclusive: boolean() });
+const predicate = discriminatedUnion('kind', [
+    strictObject({ kind: literal('class.satisfies'), class: classRef }),
+    strictObject({ kind: literal('class.equal'), class: classRef }),
+    strictObject({ kind: literal('property.equal'), property: text, value: unknownSchema() }),
+    strictObject({ kind: literal('property.present'), property: text }),
+    strictObject({
+        kind: literal('property.range'),
+        property: text,
+        lower: rangeBound.optional(),
+        upper: rangeBound.optional(),
+    }),
+    strictObject({
+        kind: literal('identity.equal'),
+        identity: union([text, strictObject({ source: text, target: text, class: text })]),
     }),
 ]);
-const filter = z.strictObject({ op: z.literal('filter'), binding, predicate });
-const expand = z.strictObject({
-    op: z.literal('expand'),
+const filter = strictObject({ op: literal('filter'), binding, predicate });
+const expand = strictObject({
+    op: literal('expand'),
     from: binding,
-    via: z.array(classRef).min(1).max(QUERY_AST_LIMITS.expansionClassesPerStep),
-    direction: z.enum(['outgoing', 'incoming', 'incident']),
-    bindings: z.strictObject({ edge: binding, node: binding }),
+    via: array(classRef).min(1).max(QUERY_AST_LIMITS.expansionClassesPerStep),
+    direction: enumeration(['outgoing', 'incoming', 'incident']),
+    bindings: strictObject({ edge: binding, node: binding }),
 });
-const propertyOrder = z.strictObject({
+const propertyOrder = strictObject({
     property: text,
-    direction: z.enum(['asc', 'desc']),
-    unranked: z.enum(['first', 'last']),
+    direction: enumeration(['asc', 'desc']),
+    unranked: enumeration(['first', 'last']),
 });
-const projectionShape = z.enum(['reference', 'value']);
-const graphSelect = z.strictObject({
-    kind: z.literal('graph'),
+const projectionShape = enumeration(['reference', 'value']);
+const graphSelect = strictObject({
+    kind: literal('graph'),
     binding,
     order: propertyOrder.optional(),
 });
-const nodeSelect = z.strictObject({
-    kind: z.literal('nodes'),
+const nodeSelect = strictObject({
+    kind: literal('nodes'),
     binding,
-    projection: z.strictObject({ kind: projectionShape }),
+    projection: strictObject({ kind: projectionShape }),
     order: propertyOrder.optional(),
 });
-const edgeSelect = z.strictObject({
-    kind: z.literal('edges'),
+const edgeSelect = strictObject({
+    kind: literal('edges'),
     binding,
-    projection: z.strictObject({
+    projection: strictObject({
         edge: projectionShape,
         source: projectionShape,
         target: projectionShape,
@@ -70,10 +77,10 @@ const edgeSelect = z.strictObject({
     order: propertyOrder.optional(),
 });
 /** Structural JSON contract; decodeQueryAST owns canonical identities and binding dependencies. */
-export const queryAstSchema = z.strictObject({
-    format: z.literal(QUERY_AST_FORMAT),
-    version: z.literal(QUERY_AST_VERSION),
+export const queryAstSchema = strictObject({
+    format: literal(QUERY_AST_FORMAT),
+    version: literal(QUERY_AST_VERSION),
     source,
-    steps: z.array(z.discriminatedUnion('op', [filter, expand])).max(QUERY_AST_LIMITS.steps),
-    select: z.discriminatedUnion('kind', [graphSelect, nodeSelect, edgeSelect]),
+    steps: array(discriminatedUnion('op', [filter, expand])).max(QUERY_AST_LIMITS.steps),
+    select: discriminatedUnion('kind', [graphSelect, nodeSelect, edgeSelect]),
 });

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

@@ -0,0 +1,53 @@
+import type { OrderingKind } from '@astrale-os/kernel-dsl/v1/language';
+import type * as portable from '@astrale-os/kernel-dsl/value';
+import type { EdgeKey } from '../../edge/index.js';
+import type { NodeId } from '../../node/index.js';
+import type { QueryOrderDirection, QueryPropertyRangePredicate, QueryUnrankedPlacement } from '../language/index.js';
+/** The identity of one selected fact: a Node's NodeId or an Edge's complete EdgeKey. */
+export type QueryRankIdentity = NodeId | EdgeKey;
+/** A scalar ordering value of one proven kind; an instant is its canonical text. */
+export type QueryRankValue = boolean | number | string;
+/** One selected fact's position: its bucket, its ordering value when ranked, and its identity. */
+export type QueryRank<Identity extends QueryRankIdentity = QueryRankIdentity> = {
+    readonly bucket: 'identity';
+    readonly identity: Identity;
+} | {
+    readonly bucket: 'ranked';
+    readonly value: QueryRankValue;
+    readonly identity: Identity;
+} | {
+    readonly bucket: 'unranked';
+    readonly identity: Identity;
+};
+/** The ordering of one Property order: its proven value kind, direction and unranked placement. */
+export interface QueryRankOrder {
+    readonly kind: OrderingKind;
+    readonly direction: QueryOrderDirection;
+    readonly unranked: QueryUnrankedPlacement;
+}
+/**
+ * The one observable Query order. Without a Property order, facts follow identity order. With one,
+ * unranked facts sit first or last regardless of direction, ranked values compare by their kind in
+ * the requested direction, and identity breaks every tie: NodeId byte order, or EdgeKey order by
+ * source, target and ClassKey.
+ */
+export declare function compareQueryRank(left: QueryRank, right: QueryRank, order: QueryRankOrder | undefined): number;
+/**
+ * Compare two ordering values of one kind: false before true, numeric order, and code-point order
+ * for strings and instants.
+ */
+export declare function compareQueryValue(left: QueryRankValue, right: QueryRankValue, kind: OrderingKind): number;
+/**
+ * Unicode code-point order, which equals the byte order of the UTF-8 encodings. UTF-16 unit order
+ * differs from it only where a surrogate meets a unit at or above U+E000; the fixup reorders
+ * exactly that range.
+ */
+export declare function compareQueryText(left: string, right: string): number;
+/**
+ * Whether one stored value lies in a Property range: it has the kind of the bounds, a number in
+ * numeric order or a text in code-point order, and every present bound holds. A value of any other
+ * kind, an absent value included, is never in the range; this is never an error.
+ */
+export declare function queryRangeContains(range: Pick<QueryPropertyRangePredicate, 'lower' | 'upper'>, value: portable.Value | undefined): boolean;
+/** Identity order: NodeId byte order, or EdgeKey (source, target, ClassKey) tuple order. */
+export declare function compareQueryIdentity(left: QueryRankIdentity, right: QueryRankIdentity): number;

package/dist/graph/query/order/index.js

@@ -0,0 +1,79 @@
+import { compareEdgeKeys } from '../../edge/index.js';
+import { compareNodeIds } from '../../node/index.js';
+/**
+ * The one observable Query order. Without a Property order, facts follow identity order. With one,
+ * unranked facts sit first or last regardless of direction, ranked values compare by their kind in
+ * the requested direction, and identity breaks every tie: NodeId byte order, or EdgeKey order by
+ * source, target and ClassKey.
+ */
+export function compareQueryRank(left, right, order) {
+    if (order !== undefined && left.bucket !== right.bucket) {
+        const first = order.unranked === 'first' ? 'unranked' : 'ranked';
+        return left.bucket === first ? -1 : 1;
+    }
+    if (order !== undefined && left.bucket === 'ranked' && right.bucket === 'ranked') {
+        const compared = compareQueryValue(left.value, right.value, order.kind);
+        if (compared !== 0)
+            return order.direction === 'asc' ? compared : -compared;
+    }
+    return compareQueryIdentity(left.identity, right.identity);
+}
+/**
+ * Compare two ordering values of one kind: false before true, numeric order, and code-point order
+ * for strings and instants.
+ */
+export function compareQueryValue(left, right, kind) {
+    if (kind === 'boolean')
+        return Number(left) - Number(right);
+    if (kind === 'number')
+        return Math.sign(left - right);
+    return compareQueryText(left, right);
+}
+/**
+ * Unicode code-point order, which equals the byte order of the UTF-8 encodings. UTF-16 unit order
+ * differs from it only where a surrogate meets a unit at or above U+E000; the fixup reorders
+ * exactly that range.
+ */
+export function compareQueryText(left, right) {
+    const length = Math.min(left.length, right.length);
+    for (let index = 0; index < length; index++) {
+        let a = left.charCodeAt(index);
+        let b = right.charCodeAt(index);
+        if (a === b)
+            continue;
+        if (a >= 0xd800 && b >= 0xd800) {
+            a += a >= 0xe000 ? -0x800 : 0x2000;
+            b += b >= 0xe000 ? -0x800 : 0x2000;
+        }
+        return a < b ? -1 : 1;
+    }
+    return Math.sign(left.length - right.length);
+}
+/**
+ * Whether one stored value lies in a Property range: it has the kind of the bounds, a number in
+ * numeric order or a text in code-point order, and every present bound holds. A value of any other
+ * kind, an absent value included, is never in the range; this is never an error.
+ */
+export function queryRangeContains(range, value) {
+    const kind = (range.lower ?? range.upper)?.value;
+    if (typeof value !== typeof kind || (typeof value !== 'number' && typeof value !== 'string')) {
+        return false;
+    }
+    const holds = (bound, sign) => {
+        if (bound === undefined)
+            return true;
+        const compared = typeof value === 'number'
+            ? Math.sign(value - bound.value)
+            : compareQueryText(value, bound.value);
+        return compared === 0 ? bound.inclusive : compared === sign;
+    };
+    return holds(range.lower, 1) && holds(range.upper, -1);
+}
+/** Identity order: NodeId byte order, or EdgeKey (source, target, ClassKey) tuple order. */
+export function compareQueryIdentity(left, right) {
+    if (typeof left === 'string' && typeof right === 'string')
+        return compareNodeIds(left, right);
+    if (typeof left !== 'string' && typeof right !== 'string')
+        return compareEdgeKeys(left, right);
+    throw new TypeError('Query rank identities of different kinds are not comparable.');
+}

package/dist/graph/query/reference/evaluate.d.ts

@@ -29,6 +29,7 @@ export interface QueryReferenceContext {
     closeClass(classRef: ClassRef): QueryReferenceClassClosure | undefined;
     closeProperty(property: PropertyKeyValue): QueryReferenceProperty | undefined;
     orientation(edge: ClassKey): EdgeOrientation | undefined;
+    admitEdge(edge: Edge, source: Node, target: Node): boolean;
     traverseNode(node: Node): boolean;
     traverseEdge(edge: Edge): boolean;
     readNode(node: Node): boolean;