@astrale-os/kernel-core 0.9.0-beta.8 → 1.0.0-beta.1

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

@@ -1,4 +1,3 @@
 export { Property, Query } from './builder.js';
 export type { EdgeQueryBuilder, ExpandedQueryBuilder, NodeQueryBuilder, QueryAPI, } from './builder.js';
 export type * from './model.js';
-//# sourceMappingURL=index.d.ts.map

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

@@ -1,2 +1 @@
 export { Property, Query } from './builder.js';
-//# sourceMappingURL=index.js.map

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

@@ -1,9 +1,9 @@
 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 | Readonly<{
+export type QueryClassInput<Kind extends 'node' | 'edge' = 'node' | 'edge'> = dslApi.ClassRef | dslApi.ClassKey | Readonly<{
     readonly ref: dslApi.ClassRef;
     readonly kind: Kind;
 }>;
@@ -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;
@@ -104,4 +123,3 @@ export type QueryEdgeSourceSelectInput = (Omit<QueryNodeGraphSelectInput, 'bindi
     readonly binding?: EdgeBinding;
 });
 export {};
-//# sourceMappingURL=model.d.ts.map

package/dist/graph/query/authoring/model.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=model.js.map

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

@@ -1,10 +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';
-//# sourceMappingURL=index.d.ts.map

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, queryRangeContains, } from './order/index.js';
 export { QueryReference, QueryReferenceError } from './reference/index.js';
-//# sourceMappingURL=index.js.map

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

@@ -4,4 +4,3 @@ import type { QueryAST } from './query-ast.js';
 export declare function decodeQueryAST(input: unknown): QueryAST<QuerySelect, never>;
 /** Re-admit a typed value before it crosses a trust or transport boundary. */
 export declare function encodeQueryAST(input: QueryAST): QueryAST<QuerySelect, never>;
-//# sourceMappingURL=codec.d.ts.map

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);
@@ -281,4 +296,3 @@ function invalid(path, message, cause) {
 function errorPointer(error) {
     return error instanceof portable.BoundaryError ? error.pointer : '';
 }
-//# sourceMappingURL=codec.js.map

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

@@ -3,4 +3,3 @@ export declare class QueryASTDecodeError extends TypeError {
     readonly code: 'QUERY_AST_INVALID';
     constructor(path: string, message: string, options?: ErrorOptions);
 }
-//# sourceMappingURL=error.d.ts.map

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

@@ -7,4 +7,3 @@ export class QueryASTDecodeError extends TypeError {
         this.name = 'QueryASTDecodeError';
     }
 }
-//# sourceMappingURL=error.js.map

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

@@ -2,4 +2,3 @@ import type { QueryFingerprint } from './model.js';
 import type { QueryAST } from './query-ast.js';
 /** Derive Query V6 semantic identity, erasing authored set order and alpha-renaming only. */
 export declare function fingerprintQueryAST(input: QueryAST): QueryFingerprint;
-//# sourceMappingURL=fingerprint.d.ts.map

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,
@@ -148,4 +156,3 @@ function compareBytes(left, right) {
     }
     return Math.sign(left.length - right.length);
 }
-//# sourceMappingURL=fingerprint.js.map

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

@@ -4,4 +4,3 @@ export { decodeQueryAST, encodeQueryAST } from './codec.js';
 export { fingerprintQueryAST } from './fingerprint.js';
 export { QueryAST, type QueryEdgeAST, type QueryNodeAST, type QuerySingleSourceClassOf, type QuerySourceProvenance, type QuerySourceClassesOf, } from './query-ast.js';
 export { queryAstSchema } from './wire.js';
-//# sourceMappingURL=index.d.ts.map

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

@@ -3,4 +3,3 @@ export { decodeQueryAST, encodeQueryAST } from './codec.js';
 export { fingerprintQueryAST } from './fingerprint.js';
 export { QueryAST, } from './query-ast.js';
 export { queryAstSchema } from './wire.js';
-//# sourceMappingURL=index.js.map

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;
@@ -149,4 +167,3 @@ export type QuerySelect = QueryGraphSelect<NodeBinding> | QueryGraphSelect<EdgeB
 export type QueryNodeTerminalSelect = QueryGraphSelect<NodeBinding> | QueryNodeSelect;
 export type QueryEdgeTerminalSelect = QueryGraphSelect<EdgeBinding> | QueryEdgeSelect;
 export {};
-//# sourceMappingURL=model.d.ts.map

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

@@ -6,4 +6,3 @@ export const QUERY_AST_LIMITS = Object.freeze({
     expansionClassesPerStep: 256,
     bindings: 513,
 });
-//# sourceMappingURL=model.js.map

package/dist/graph/query/language/query-ast.d.ts

@@ -30,4 +30,3 @@ export declare const QueryAST: {
     fingerprint(input: QueryAST): QueryFingerprint;
 };
 export {};
-//# sourceMappingURL=query-ast.d.ts.map

package/dist/graph/query/language/query-ast.js

@@ -10,4 +10,3 @@ export const QueryAST = Object.freeze({
     encode: encodeQueryAST,
     fingerprint: fingerprintQueryAST,
 });
-//# sourceMappingURL=query-ast.js.map

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

@@ -1,4 +1,3 @@
 import type { QueryAST } from './query-ast.js';
 /** Resolve the Node or Edge kind of the terminal binding in an admitted Query. */
 export declare function querySelectionKind(query: QueryAST): 'node' | 'edge';
-//# sourceMappingURL=selection.d.ts.map

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

@@ -26,4 +26,3 @@ export function querySelectionKind(query) {
     }
     throw new TypeError('Admitted Query selected an unknown binding.');
 }
-//# sourceMappingURL=selection.js.map

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

@@ -1,150 +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>;
-//# sourceMappingURL=wire.d.ts.map
+        }, import("zod/v4/core").$strict>>;
+    }, import("zod/v4/core").$strict>], "kind">;
+}, import("zod/v4/core").$strict>;