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

package/dist/auth/authority/semantics/interpret.d.ts

@@ -15,6 +15,12 @@ export interface AuthorityEvaluationOptions {
      * as a captured fact table. Undefined leaves the atom to its meaning over the snapshot.
      */
     readonly atom?: (atom: AuthorityAtom, subject: NodeId | undefined) => boolean | undefined;
+    /**
+     * Pure observation of the snapshot's evidence token. It changes (Object.is) at every
+     * acquisition and stays stable otherwise; observing it must not acquire evidence.
+     * Stable snapshots may omit it. Tokens must not be mutated or reused across acquisitions.
+     */
+    readonly evidenceEpoch?: () => unknown;
 }
 /** Decisions of one program over one snapshot. Memoized evidence never outlives the evaluator. */
 export interface AuthorityEvaluator {

package/dist/auth/authority/semantics/interpret.js

@@ -10,6 +10,9 @@ export function createAuthorityEvaluator(program, snapshot, vocabulary, options
     const references = new Map();
     const closures = new Map();
     const projections = new Map();
+    const walks = new Map();
+    const walkPlans = new WeakMap();
+    const existentialPlans = new WeakMap();
     const instanceOf = classKey(vocabulary.instanceOf);
     const reference = (path) => {
         const known = references.get(path.raw);
@@ -65,7 +68,8 @@ export function createAuthorityEvaluator(program, snapshot, vocabulary, options
         const key = classKey(ref);
         let nodes = projections.get(key);
         if (nodes === undefined) {
-            nodes = Object.freeze([...new Set(snapshot.resolve(Path.project(ref)))].filter((node) => snapshot.node(node)));
+            const candidates = snapshot.classProjection?.(ref) ?? snapshot.resolve(Path.project(ref));
+            nodes = Object.freeze([...new Set(candidates)].filter((node) => snapshot.node(node)));
             projections.set(key, nodes);
         }
         return nodes;
@@ -77,19 +81,52 @@ export function createAuthorityEvaluator(program, snapshot, vocabulary, options
      * Bounded walks: a Node reached at any depth within [min, max], revisits allowed. Each hop may
      * take any member of the Edge Class extent.
      */
-    const related = (source, extent, target, repeat) => {
+    const related = (expression, source, target) => {
+        const { repeat, via: extent } = expression;
         const min = repeat?.min ?? 1;
         const max = repeat?.max ?? 1;
+        // The empty walk is already a proof. Do not spend a read budget exploring longer walks.
         if (min === 0 && source === target)
             return true;
-        let frontier = new Set([source]);
+        let plan = walkPlans.get(expression);
+        if (plan === undefined) {
+            const key = JSON.stringify([min, max, extent.map(classKey)]);
+            plan = walks.get(key);
+            if (plan === undefined) {
+                plan = new Map();
+                walks.set(key, plan);
+            }
+            walkPlans.set(expression, plan);
+        }
+        const epoch = options.evidenceEpoch?.();
+        let walk = plan.get(source);
+        if (walk === undefined || !Object.is(walk.epoch, epoch)) {
+            walk = { epoch, layers: [new Set([source])] };
+            plan.delete(source);
+        }
+        let frontier = walk.layers[0];
         for (let depth = 1; depth <= max && frontier.size > 0; depth++) {
-            const next = new Set();
-            for (const node of frontier) {
-                for (const edge of extent)
-                    for (const reached of step(node, edge))
-                        next.add(reached);
+            let next = walk.layers[depth];
+            if (next === undefined) {
+                const before = options.evidenceEpoch?.();
+                const acquired = new Set();
+                for (const node of frontier) {
+                    for (const edge of extent)
+                        for (const reached of step(node, edge))
+                            acquired.add(reached);
+                }
+                next = acquired;
+                walk.layers.push(next);
+                // Every retained layer must belong to the same epoch. A provisional prefix remains
+                // usable for this search only, even if its later extensions acquire no further evidence.
+                if (Object.is(walk.epoch, before) && Object.is(before, options.evidenceEpoch?.())) {
+                    plan.set(source, walk);
+                }
+                else {
+                    plan.delete(source);
+                }
             }
+            // Like the frozen interpreter, acquire no layer beyond the first admissible witness.
             if (depth >= min && next.has(target))
                 return true;
             frontier = next;
@@ -127,7 +164,7 @@ export function createAuthorityEvaluator(program, snapshot, vocabulary, options
             case 'same-node':
                 return term(expression.left, frame) === term(expression.right, frame);
             case 'related':
-                return related(term(expression.source, frame), expression.via, term(expression.target, frame), expression.repeat);
+                return related(expression, term(expression.source, frame), term(expression.target, frame));
             case 'instance-of':
                 return sameClass(classOf(term(expression.node, frame)), expression.class);
             case 'edge-class': {
@@ -155,13 +192,111 @@ export function createAuthorityEvaluator(program, snapshot, vocabulary, options
     };
     const exists = (expression, frame) => {
         const candidates = expression.nodes.map((local) => local.kind === 'any' ? snapshot.nodes() : snapshot.nodes(local.classes));
-        const bind = (index, locals) => {
-            if (index === expression.nodes.length)
-                return holds(expression.where, { ...frame, locals });
+        // Acquire every extent in declaration order, even when the product has no tuple.
+        if (candidates.some((extent) => extent.length === 0))
+            return false;
+        let plan = existentialPlans.get(expression);
+        if (plan === undefined) {
+            const predicates = expression.where.op === 'all' ? expression.where.predicates : [expression.where];
+            const usedIndices = new Set();
+            // Each entry describes the whole prefix, including its earlier true predicates.
+            // gates[i] rejects values of local i; resets[i] invalidates their earlier context.
+            const gates = expression.nodes.map(() => []);
+            const resets = expression.nodes.map(() => []);
+            const dependency = predicates.map((predicate, item) => {
+                const used = localDependencies(predicate);
+                for (let index = 0; index < expression.nodes.length; index++) {
+                    if (used.has(expression.nodes[index].id))
+                        usedIndices.add(index);
+                }
+                const ordered = [...usedIndices].sort((left, right) => left - right);
+                const last = ordered.at(-1) ?? -1;
+                const earlier = ordered.at(-2) ?? -1;
+                if (last >= 0)
+                    gates[last].push(item);
+                // An exclusion of the last dependency is valid only while all earlier ones stay fixed.
+                for (let index = 0; index <= earlier; index++)
+                    resets[index].push(item);
+                return last;
+            });
+            plan = { predicates, dependency, gates, resets };
+            existentialPlans.set(expression, plan);
+        }
+        const { predicates, dependency, gates, resets } = plan;
+        const excluded = predicates.map(() => new Set());
+        const rejected = (index, node) => {
+            for (const item of gates[index])
+                if (excluded[item].has(node))
+                    return true;
+            return false;
+        };
+        const clear = (item) => {
+            if (excluded[item].size === 0)
+                return;
+            excluded[item].clear();
+        };
+        let prefix = 0;
+        let observedEpoch = options.evidenceEpoch?.();
+        const refresh = () => {
+            const current = options.evidenceEpoch?.();
+            if (Object.is(current, observedEpoch))
+                return false;
+            observedEpoch = current;
+            prefix = 0;
+            excluded.forEach((_, item) => clear(item));
+            return true;
+        };
+        // -2 means a witness. Every other result identifies the last bound variable that
+        // may change the evaluated prefix. Descendants cannot alter its reads or result.
+        const locals = new Map(frame.locals);
+        const complete = { ...frame, locals };
+        const bind = (index) => {
+            if (index === expression.nodes.length) {
+                for (let item = prefix; item < predicates.length; item++) {
+                    if (!holds(predicates[item], complete)) {
+                        if (refresh())
+                            return expression.nodes.length - 1;
+                        const target = dependency[item];
+                        if (target >= 0) {
+                            const value = locals.get(expression.nodes[target].id);
+                            if (!excluded[item].has(value)) {
+                                excluded[item].add(value);
+                            }
+                        }
+                        return dependency[item];
+                    }
+                    prefix = item + 1;
+                }
+                return -2;
+            }
             const id = expression.nodes[index].id;
-            return candidates[index].some((node) => bind(index + 1, new Map([...locals, [id, node]])));
+            const previous = locals.get(id);
+            try {
+                for (let ordinal = 0; ordinal < candidates[index].length; ordinal++) {
+                    refresh();
+                    const node = candidates[index][ordinal];
+                    if (rejected(index, node)) {
+                        continue;
+                    }
+                    for (const item of resets[index])
+                        clear(item);
+                    while (prefix > 0 && dependency[prefix - 1] >= index)
+                        prefix--;
+                    locals.set(id, node);
+                    const result = bind(index + 1);
+                    if (result === -2 || result < index)
+                        return result;
+                }
+                return index - 1;
+            }
+            finally {
+                if (previous === undefined)
+                    locals.delete(id);
+                else
+                    locals.set(id, previous);
+            }
         };
-        return bind(0, frame.locals);
+        return bind(0) === -2;
     };
     return Object.freeze({
         admit() {
@@ -184,6 +319,44 @@ export function createAuthorityEvaluator(program, snapshot, vocabulary, options
         },
     });
 }
+/** Locals whose assignment can affect the result of this expression. */
+function localDependencies(expression) {
+    const result = new Set();
+    const addTerm = (term) => {
+        if (term.kind === 'local')
+            result.add(term.id);
+    };
+    const visit = (value) => {
+        switch (value.op) {
+            case 'all':
+            case 'any':
+                value.predicates.forEach(visit);
+                return;
+            case 'not':
+                visit(value.predicate);
+                return;
+            case 'as':
+            case 'exists':
+                visit(value.where);
+                return;
+            case 'same-node':
+                addTerm(value.left);
+                addTerm(value.right);
+                return;
+            case 'related':
+                addTerm(value.source);
+                addTerm(value.target);
+                return;
+            case 'instance-of':
+                addTerm(value.node);
+                return;
+            case 'class-authority':
+                addTerm(value.identity);
+        }
+    };
+    visit(expression);
+    return result;
+}
 /** Every Identity a binder of the program names, sorted. */
 export function binderRoots(expressions) {
     const roots = new Set();

package/dist/auth/authority/semantics/snapshot.d.ts

@@ -21,6 +21,12 @@ export interface AuthoritySnapshot {
     orientation(edge: ClassRef): 'directed' | 'undirected';
     /** Every live Node the Path reaches; a fixed term requires exactly one. */
     resolve(path: Path): readonly NodeId[];
+    /**
+     * Pinned Registry candidates for derived `instance_of`, admitted through `node` before use.
+     * An absent hook falls back to `resolve(Path.project(ref))`; an empty result never does.
+     * Fixed terms always use `resolve` independently of this projection.
+     */
+    classProjection?(ref: ClassRef): readonly NodeId[];
     /** Every live Node, restricted to exact Classes when given. */
     nodes(classes?: readonly ClassRef[]): readonly NodeId[];
 }

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

@@ -2,6 +2,7 @@ import type { NodeId } from '../../node/index.js';
 import type { LocalAlias } from '../language/index.js';
 export type MutationResult = {
     readonly createdNodes: Readonly<Record<LocalAlias, NodeId>>;
+    readonly replayed?: true;
 };
 export declare const MutationResult: {
     decode(input: unknown): MutationResult;

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

@@ -20,7 +20,8 @@ export function encodeMutationResult(input) {
 /** 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) {

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

@@ -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,

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

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

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

@@ -56,6 +56,17 @@ export declare const queryAstSchema: 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/query/language/wire.js

@@ -1,4 +1,4 @@
-import { array, discriminatedUnion, enum as enumeration, literal, strictObject, string, union, unknown as unknownSchema, } 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 = string().min(1);
 const binding = text.max(64);
@@ -24,11 +24,18 @@ const source = discriminatedUnion('kind', [
         bindings: strictObject({ source: binding, edge: binding, target: binding }),
     }),
 ]);
+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 })]),

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

@@ -1,7 +1,8 @@
 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, QueryUnrankedPlacement } from '../language/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. */
@@ -42,5 +43,11 @@ export declare function compareQueryValue(left: QueryRankValue, right: QueryRank
  * 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

@@ -49,6 +49,26 @@ export function compareQueryText(left, right) {
     }
     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')

package/dist/graph/query/reference/evaluate.js

@@ -6,7 +6,7 @@ import { GraphData } from '../../graph/index.js';
 import { NodeId as admitNodeId } from '../../node/index.js';
 import { compareNodeIds } from '../../node/index.js';
 import { encodeQueryAST, QueryASTDecodeError } from '../language/index.js';
-import { compareQueryRank } from '../order/index.js';
+import { compareQueryRank, queryRangeContains } from '../order/index.js';
 import { decodeQueryResult } from '../result/index.js';
 import { QueryReferenceError } from './error.js';
 /** Independent backend-neutral executable Query V6 row algebra. */
@@ -142,8 +142,10 @@ function evaluate(ast, context, options) {
                     if (!Object.hasOwn(value.value.props, predicate.property)) {
                         return false;
                     }
-                    return (predicate.kind === 'property.present' ||
-                        portable.equal(value.value.props[predicate.property], predicate.value));
+                    const stored = value.value.props[predicate.property];
+                    if (predicate.kind === 'property.range')
+                        return queryRangeContains(predicate, stored);
+                    return predicate.kind === 'property.present' || portable.equal(stored, predicate.value);
                 });
             }
             stepRows.push(rows.length);

package/dist/schema/kernel/schema.d.ts

@@ -7923,6 +7923,17 @@ declare const KernelDefinitions: {
                     } | {
                         kind: "property.present";
                         property: string;
+                    } | {
+                        kind: "property.range";
+                        property: string;
+                        lower?: {
+                            value: string | number;
+                            inclusive: boolean;
+                        } | undefined;
+                        upper?: {
+                            value: string | number;
+                            inclusive: boolean;
+                        } | undefined;
                     } | {
                         kind: "identity.equal";
                         identity: string | {
@@ -8200,6 +8211,17 @@ declare const KernelDefinitions: {
                             } | {
                                 kind: "property.present";
                                 property: string;
+                            } | {
+                                kind: "property.range";
+                                property: string;
+                                lower?: {
+                                    value: string | number;
+                                    inclusive: boolean;
+                                } | undefined;
+                                upper?: {
+                                    value: string | number;
+                                    inclusive: boolean;
+                                } | undefined;
                             } | {
                                 kind: "identity.equal";
                                 identity: string | {
@@ -8332,10 +8354,12 @@ declare const KernelDefinitions: {
                 origin: string;
                 revision: string;
             }[] | undefined;
+            idempotencyKey?: string | undefined;
         }, {
             readonly mode: 'value';
             readonly value: {
                 createdNodes: Record<string, string>;
+                replayed?: true | undefined;
             };
         }, "authorized", false, false, undefined>>;
         register: builder.Function<builder.CallableProjection<{
@@ -8759,21 +8783,24 @@ export declare const AuthorityRelations: Readonly<{
     };
 }>;
 /** Exact authorized Kernel Functions for which pristine Root receives direct can_use authority. */
-export declare const KernelRootFunctions: readonly ((import("@astrale-os/kernel-dsl/v1").ResolvedFunction<{
-    node: string;
-    property: string;
-} | {
-    slots: {
-        node: string;
-        property: string;
-    }[];
-}, {
-    readonly mode: 'binary';
+export declare const KernelRootFunctions: readonly ((import("@astrale-os/kernel-dsl/v1").ResolvedFunction<import("@astrale-os/kernel-dsl/v1").BinaryInputProjection<{
+    mediaType: string;
+}>, {
+    readonly mode: 'value';
+    readonly value: {
+        receipt: string;
+        ref: {
+            digest: string;
+            mediaType: string;
+            size: number;
+        };
+        expiresAt: string;
+    };
 }, "authorized", import("@astrale-os/kernel-dsl/v1").PolicyCheckExpression<import("@astrale-os/kernel-dsl/v1").PolicyRef, import("@astrale-os/kernel-dsl/v1/language").PolicyCheckObject>> & {
-    readonly ref: import("@astrale-os/kernel-dsl/v1").FunctionRef<"download"> & {
+    readonly ref: import("@astrale-os/kernel-dsl/v1").FunctionRef<"upload"> & {
         readonly origin: "kernel.astrale.ai";
     };
-    readonly key: "kernel.astrale.ai:function.download";
+    readonly key: "kernel.astrale.ai:function.upload";
     readonly execution: undefined;
 }) | (import("@astrale-os/kernel-dsl/v1").ResolvedFunction<{
     operation: string;
@@ -8808,39 +8835,6 @@ export declare const KernelRootFunctions: readonly ((import("@astrale-os/kernel-
     };
     readonly key: "kernel.astrale.ai:function.install";
     readonly execution: undefined;
-}) | (import("@astrale-os/kernel-dsl/v1").ResolvedFunction<{
-    invocation?: {
-        source: string;
-        id: string;
-    } | undefined;
-    topics?: {
-        exact?: string[] | undefined;
-        prefixes?: string[] | undefined;
-    } | undefined;
-    principal?: string | undefined;
-    since?: string | undefined;
-    until?: string | undefined;
-    cursor?: string | undefined;
-    limit?: number | undefined;
-}, {
-    readonly mode: 'value';
-    readonly value: {
-        records: unknown[];
-        frontier: {
-            id: string;
-            first?: number | undefined;
-            committed: number;
-            durable: number;
-        };
-        cursor?: string | undefined;
-        gap?: unknown;
-    };
-}, "authorized", import("@astrale-os/kernel-dsl/v1").PolicyCheckExpression<import("@astrale-os/kernel-dsl/v1").PolicyRef, import("@astrale-os/kernel-dsl/v1/language").PolicyCheckObject>> & {
-    readonly ref: import("@astrale-os/kernel-dsl/v1").FunctionRef<"journal"> & {
-        readonly origin: "kernel.astrale.ai";
-    };
-    readonly key: "kernel.astrale.ai:function.journal";
-    readonly execution: undefined;
 }) | (import("@astrale-os/kernel-dsl/v1").ResolvedFunction<{
     ast: {
         format: "astrale.graph.mutation";
@@ -8928,6 +8922,17 @@ export declare const KernelRootFunctions: readonly ((import("@astrale-os/kernel-
                     } | {
                         kind: "property.present";
                         property: string;
+                    } | {
+                        kind: "property.range";
+                        property: string;
+                        lower?: {
+                            value: string | number;
+                            inclusive: boolean;
+                        } | undefined;
+                        upper?: {
+                            value: string | number;
+                            inclusive: boolean;
+                        } | undefined;
                     } | {
                         kind: "identity.equal";
                         identity: string | {
@@ -9060,10 +9065,12 @@ export declare const KernelRootFunctions: readonly ((import("@astrale-os/kernel-
         origin: string;
         revision: string;
     }[] | undefined;
+    idempotencyKey?: string | undefined;
 }, {
     readonly mode: 'value';
     readonly value: {
         createdNodes: Record<string, string>;
+        replayed?: true | undefined;
     };
 }, "authorized", import("@astrale-os/kernel-dsl/v1").PolicyCheckExpression<import("@astrale-os/kernel-dsl/v1").PolicyRef, import("@astrale-os/kernel-dsl/v1/language").PolicyCheckObject>> & {
     readonly ref: import("@astrale-os/kernel-dsl/v1").FunctionRef<"mutate"> & {
@@ -9129,6 +9136,17 @@ export declare const KernelRootFunctions: readonly ((import("@astrale-os/kernel-
             } | {
                 kind: "property.present";
                 property: string;
+            } | {
+                kind: "property.range";
+                property: string;
+                lower?: {
+                    value: string | number;
+                    inclusive: boolean;
+                } | undefined;
+                upper?: {
+                    value: string | number;
+                    inclusive: boolean;
+                } | undefined;
             } | {
                 kind: "identity.equal";
                 identity: string | {
@@ -9379,24 +9397,54 @@ export declare const KernelRootFunctions: readonly ((import("@astrale-os/kernel-
     };
     readonly key: "kernel.astrale.ai:function.uninstall";
     readonly execution: undefined;
-}) | (import("@astrale-os/kernel-dsl/v1").ResolvedFunction<import("@astrale-os/kernel-dsl/v1").BinaryInputProjection<{
-    mediaType: string;
-}>, {
+}) | (import("@astrale-os/kernel-dsl/v1").ResolvedFunction<{
+    invocation?: {
+        source: string;
+        id: string;
+    } | undefined;
+    topics?: {
+        exact?: string[] | undefined;
+        prefixes?: string[] | undefined;
+    } | undefined;
+    principal?: string | undefined;
+    since?: string | undefined;
+    until?: string | undefined;
+    cursor?: string | undefined;
+    limit?: number | undefined;
+}, {
     readonly mode: 'value';
     readonly value: {
-        receipt: string;
-        ref: {
-            digest: string;
-            mediaType: string;
-            size: number;
+        records: unknown[];
+        frontier: {
+            id: string;
+            first?: number | undefined;
+            committed: number;
+            durable: number;
         };
-        expiresAt: string;
+        cursor?: string | undefined;
+        gap?: unknown;
     };
 }, "authorized", import("@astrale-os/kernel-dsl/v1").PolicyCheckExpression<import("@astrale-os/kernel-dsl/v1").PolicyRef, import("@astrale-os/kernel-dsl/v1/language").PolicyCheckObject>> & {
-    readonly ref: import("@astrale-os/kernel-dsl/v1").FunctionRef<"upload"> & {
+    readonly ref: import("@astrale-os/kernel-dsl/v1").FunctionRef<"journal"> & {
         readonly origin: "kernel.astrale.ai";
     };
-    readonly key: "kernel.astrale.ai:function.upload";
+    readonly key: "kernel.astrale.ai:function.journal";
+    readonly execution: undefined;
+}) | (import("@astrale-os/kernel-dsl/v1").ResolvedFunction<{
+    node: string;
+    property: string;
+} | {
+    slots: {
+        node: string;
+        property: string;
+    }[];
+}, {
+    readonly mode: 'binary';
+}, "authorized", import("@astrale-os/kernel-dsl/v1").PolicyCheckExpression<import("@astrale-os/kernel-dsl/v1").PolicyRef, import("@astrale-os/kernel-dsl/v1/language").PolicyCheckObject>> & {
+    readonly ref: import("@astrale-os/kernel-dsl/v1").FunctionRef<"download"> & {
+        readonly origin: "kernel.astrale.ai";
+    };
+    readonly key: "kernel.astrale.ai:function.download";
     readonly execution: undefined;
 }) | (import("@astrale-os/kernel-dsl/v1").ResolvedMethod<{
     iss: string;
@@ -9425,17 +9473,6 @@ export declare const KernelRootFunctions: readonly ((import("@astrale-os/kernel-
     readonly name: "whois";
     readonly executable: true;
     readonly execution: undefined;
-}) | (import("@astrale-os/kernel-dsl/v1").ResolvedMethod<{
-    audience?: string | undefined;
-    ttlSeconds: number;
-    identity: string;
-}, {
-    readonly mode: 'value';
-    readonly value: string;
-}, true, false, "authorized", import("@astrale-os/kernel-dsl/v1").PolicyCheckExpression<import("@astrale-os/kernel-dsl/v1").PolicyRef, import("@astrale-os/kernel-dsl/v1/language").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.impersonate"> & {
-    readonly name: "impersonate";
-    readonly executable: true;
-    readonly execution: undefined;
 }) | (import("@astrale-os/kernel-dsl/v1").ResolvedMethod<{
     target: string;
 }, {
@@ -9468,6 +9505,17 @@ export declare const KernelRootFunctions: readonly ((import("@astrale-os/kernel-
     readonly name: "resolve";
     readonly executable: true;
     readonly execution: undefined;
+}) | (import("@astrale-os/kernel-dsl/v1").ResolvedMethod<{
+    audience?: string | undefined;
+    ttlSeconds: number;
+    identity: string;
+}, {
+    readonly mode: 'value';
+    readonly value: string;
+}, true, false, "authorized", import("@astrale-os/kernel-dsl/v1").PolicyCheckExpression<import("@astrale-os/kernel-dsl/v1").PolicyRef, import("@astrale-os/kernel-dsl/v1/language").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.impersonate"> & {
+    readonly name: "impersonate";
+    readonly executable: true;
+    readonly execution: undefined;
 }))[];
 export { AuthorityOperationOrder, AuthorityOperations, operationOf } from '../authority/index.js';
 export type { AuthorityOperation, AuthorityRelation } from '../authority/index.js';

package/dist/schema/kernel/syscalls/contracts/mutate.d.ts

@@ -85,6 +85,17 @@ export declare const mutateInput: 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<{
@@ -251,7 +262,9 @@ export declare const mutateInput: import("zod").ZodObject<{
         origin: import("zod").ZodString;
         revision: import("zod").ZodString;
     }, import("zod/v4/core").$strict>>>;
+    idempotencyKey: import("zod").ZodOptional<import("zod").ZodString>;
 }, import("zod/v4/core").$strict>;
 export declare const mutateOutput: 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/schema/kernel/syscalls/contracts/mutate.js

@@ -1,8 +1,9 @@
-import { strictObject } from 'zod';
+import { strictObject, string } from 'zod';
 import { mutationAstSchema, mutationResultSchema } from '#graph/mutate/wire';
 import { domainExpectations } from './expected.js';
 export const mutateInput = strictObject({
     ast: mutationAstSchema,
     expected: domainExpectations.optional(),
+    idempotencyKey: string().min(1).max(256).optional(),
 });
 export const mutateOutput = mutationResultSchema;

package/dist/schema/kernel/syscalls/contracts/query.d.ts

@@ -57,6 +57,17 @@ export declare const queryInput: 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/schema/kernel/syscalls/declarations/index.d.ts

@@ -58,6 +58,17 @@ export declare const Functions: Readonly<{
                 } | {
                     kind: "property.present";
                     property: string;
+                } | {
+                    kind: "property.range";
+                    property: string;
+                    lower?: {
+                        value: string | number;
+                        inclusive: boolean;
+                    } | undefined;
+                    upper?: {
+                        value: string | number;
+                        inclusive: boolean;
+                    } | undefined;
                 } | {
                     kind: "identity.equal";
                     identity: string | {
@@ -335,6 +346,17 @@ export declare const Functions: Readonly<{
                         } | {
                             kind: "property.present";
                             property: string;
+                        } | {
+                            kind: "property.range";
+                            property: string;
+                            lower?: {
+                                value: string | number;
+                                inclusive: boolean;
+                            } | undefined;
+                            upper?: {
+                                value: string | number;
+                                inclusive: boolean;
+                            } | undefined;
                         } | {
                             kind: "identity.equal";
                             identity: string | {
@@ -467,10 +489,12 @@ export declare const Functions: Readonly<{
             origin: string;
             revision: string;
         }[] | undefined;
+        idempotencyKey?: string | undefined;
     }, {
         readonly mode: 'value';
         readonly value: {
             createdNodes: Record<string, string>;
+            replayed?: true | undefined;
         };
     }, "authorized", false, false, undefined>>;
     register: builder.Function<builder.CallableProjection<{

package/dist/schema/kernel/syscalls/declarations/mutate.d.ts

@@ -86,6 +86,17 @@ export declare const Mutate: builder.Function<builder.CallableProjection<{
                     } | {
                         kind: "property.present";
                         property: string;
+                    } | {
+                        kind: "property.range";
+                        property: string;
+                        lower?: {
+                            value: string | number;
+                            inclusive: boolean;
+                        } | undefined;
+                        upper?: {
+                            value: string | number;
+                            inclusive: boolean;
+                        } | undefined;
                     } | {
                         kind: "identity.equal";
                         identity: string | {
@@ -218,9 +229,11 @@ export declare const Mutate: builder.Function<builder.CallableProjection<{
         origin: string;
         revision: string;
     }[] | undefined;
+    idempotencyKey?: string | undefined;
 }, {
     readonly mode: 'value';
     readonly value: {
         createdNodes: Record<string, string>;
+        replayed?: true | undefined;
     };
 }, "authorized", false, false, undefined>>;

package/dist/schema/kernel/syscalls/declarations/query.d.ts

@@ -57,6 +57,17 @@ export declare const Query: builder.Function<builder.CallableProjection<{
             } | {
                 kind: "property.present";
                 property: string;
+            } | {
+                kind: "property.range";
+                property: string;
+                lower?: {
+                    value: string | number;
+                    inclusive: boolean;
+                } | undefined;
+                upper?: {
+                    value: string | number;
+                    inclusive: boolean;
+                } | undefined;
             } | {
                 kind: "identity.equal";
                 identity: string | {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrale-os/kernel-core",
-  "version": "0.9.0-beta.66",
+  "version": "0.9.0-beta.67",
   "description": "Astrale Kernel Core - Types, Invariants, and Pure Logic",
   "license": "Apache-2.0",
   "repository": {
@@ -160,7 +160,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@astrale-os/kernel-dsl": "0.2.0-beta.48",
+    "@astrale-os/kernel-dsl": "0.2.0-beta.49",
     "@noble/hashes": "2.3.0",
     "@types/json-schema": "^7.0.15",
     "dequal": "2.0.3"