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

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/graph/reconcile/condition/model.d.ts

@@ -1,13 +1,13 @@
 import type { PropertyKey } from '@astrale-os/kernel-dsl/v1';
 import type { ClassKey } from '@astrale-os/kernel-dsl/v1/addressing';
 import type { EdgeKey, EdgeSlug } from '../../edge/index.js';
-import type { LocalBinding, MergeConflict as GraphMergeConflict } from '../../graph/index.js';
+import type { LocalAlias, MergeConflict as GraphMergeConflict } from '../../graph/index.js';
 import type { NodeId } from '../../node/index.js';
 import type { DesiredProperties } from '../../properties/index.js';
 import type { QueryEdgeAST, QueryNodeAST } from '../../query/index.js';
 declare const DESIRED_BRAND: unique symbol;
 export type DesiredNodeRef = NodeId | {
-    readonly desired: LocalBinding;
+    readonly desired: LocalAlias;
 };
 export interface DesiredEdgeRef {
     readonly source: DesiredNodeRef;

package/dist/graph/reconcile/condition/references.d.ts

@@ -2,7 +2,6 @@ import type { DesiredEdge, DesiredEdgeRef, DesiredNode, DesiredNodeRef, Expectat
 import { type EdgeKey, type EdgeSlug } from '../../edge/index.js';
 export declare function admitDesiredNode(node: DesiredNode): DesiredNode;
 export declare function admitDesiredEdge(edge: DesiredEdge): DesiredEdge;
-export declare function admitNodeRef(ref: DesiredNodeRef): DesiredNodeRef;
 export declare function admitEdgeRef(ref: DesiredEdgeRef | EdgeKey): DesiredEdgeRef;
 export declare function equalExpectation(left: Expectation<EdgeSlug>, right: Expectation<EdgeSlug>): boolean;
 export declare function encodeDesiredNodeRef(ref: DesiredNodeRef): string;

package/dist/graph/reconcile/condition/references.js

@@ -1,6 +1,6 @@
 import { ClassKey } from '@astrale-os/kernel-dsl/v1/addressing';
 import { isEdgeSlug } from '../../edge/index.js';
-import { LocalBinding, isLocalBinding } from '../../graph/index.js';
+import { LocalAlias, isLocalAlias } from '../../graph/index.js';
 import { isNodeId } from '../../node/index.js';
 export function admitDesiredNode(node) {
     const ref = admitNodeRef(node.node);
@@ -29,14 +29,14 @@ export function admitDesiredEdge(edge) {
         properties: edge.properties,
     });
 }
-export function admitNodeRef(ref) {
+function admitNodeRef(ref) {
     if (typeof ref === 'string') {
         requireNodeId(ref);
         return ref;
     }
-    if (!isLocalBinding(ref.desired))
+    if (!isLocalAlias(ref.desired))
         throw new TypeError(`Invalid desired Node binding.`);
-    return Object.freeze({ desired: LocalBinding(ref.desired) });
+    return Object.freeze({ desired: LocalAlias(ref.desired) });
 }
 export function admitEdgeRef(ref) {
     if (!ClassKey.is(ref.class))

package/dist/graph/reconcile/correspondence.d.ts

@@ -1,8 +1,8 @@
-import type { LocalBinding } from '../graph/index.js';
+import type { LocalAlias } from '../graph/index.js';
 import type { NodeId } from '../node/index.js';
 import type { QueryObservation } from './evidence.js';
 export type CorrespondenceEntry = {
-    readonly desired: LocalBinding;
+    readonly desired: LocalAlias;
     readonly kind: 'present';
     readonly node: NodeId;
     readonly observation: Extract<QueryObservation, {
@@ -11,7 +11,7 @@ export type CorrespondenceEntry = {
         };
     }>;
 } | {
-    readonly desired: LocalBinding;
+    readonly desired: LocalAlias;
     readonly kind: 'absent';
     readonly observation: Extract<QueryObservation, {
         readonly selection: {
@@ -24,18 +24,19 @@ export interface Correspondence {
 }
 export type CorrespondenceConflict = {
     readonly kind: 'correspondence-duplicate';
-    readonly desired: LocalBinding;
+    readonly desired: LocalAlias;
 } | {
     readonly kind: 'correspondence-noninjective';
     readonly node: NodeId;
-    readonly desired: readonly LocalBinding[];
+    readonly desired: readonly LocalAlias[];
 } | {
     readonly kind: 'correspondence-observation-invalid';
-    readonly desired: LocalBinding;
+    readonly desired: LocalAlias;
 };
-export interface CorrespondenceAnalysis {
-    readonly entries: ReadonlyMap<LocalBinding, CorrespondenceEntry>;
+interface CorrespondenceAnalysis {
+    readonly entries: ReadonlyMap<LocalAlias, CorrespondenceEntry>;
     readonly conflicts: readonly CorrespondenceConflict[];
 }
 /** Canonically index correspondence and classify duplicate or non-injective mappings. */
 export declare function analyzeCorrespondence(entries: readonly CorrespondenceEntry[]): CorrespondenceAnalysis;
+export {};

package/dist/graph/reconcile/evidence.d.ts

@@ -1,10 +1,10 @@
-import type { LocalBinding } from '../graph/index.js';
+import type { LocalAlias } from '../graph/index.js';
 import type { NodeId } from '../node/index.js';
 import type { QueryEdgeAST, QueryNodeAST, QuerySelection } from '../query/index.js';
 import { type EdgeKey } from '../edge/index.js';
 export type ObservationRequirement = {
     readonly kind: 'correspondence';
-    readonly desired: LocalBinding;
+    readonly desired: LocalAlias;
 } | {
     readonly kind: 'selection';
     readonly query: QueryNodeAST | QueryEdgeAST;

package/dist/graph/reconcile/mutation/assess.d.ts

@@ -4,7 +4,7 @@ export type QueryPremise = Extract<ReconciliationPlan['premises'][number], {
     kind: 'query';
 }>;
 export type PointPremise = Exclude<ReconciliationPlan['premises'][number], QueryPremise>;
-export type MutationAssessment = {
+type MutationAssessment = {
     readonly kind: 'supported';
     readonly pointPremises: readonly PointPremise[];
     readonly queryPremises: readonly QueryPremise[];
@@ -14,3 +14,4 @@ export type MutationAssessment = {
 };
 /** Classify whether one complete semantic plan fits the target's atomic Mutation profile. */
 export declare function assess(plan: ReconciliationPlan, profile: MutationRealizationProfile): MutationAssessment;
+export {};

package/dist/graph/reconcile/observation.d.ts

@@ -1,4 +1,4 @@
-import type { GraphData, LocalBinding } from '../graph/index.js';
+import type { GraphData, LocalAlias } from '../graph/index.js';
 import type { Node, NodeId } from '../node/index.js';
 import type { Correspondence, CorrespondenceEntry } from './correspondence.js';
 import type { EvidenceRequirement, ObservationEvidence } from './evidence.js';
@@ -16,11 +16,12 @@ export type ObservationConflict = {
     readonly kind: 'observation-evidence-contradiction';
     readonly requirement: EvidenceRequirement;
 };
-export interface ObservationAnalysis {
+interface ObservationAnalysis {
     readonly nodes: ReadonlyMap<NodeId, Node>;
     readonly edges: ReadonlyMap<string, Edge>;
     readonly evidence: readonly ObservationEvidence[];
     readonly conflicts: readonly ObservationConflict[];
 }
 /** Index finite facts and classify contradictory or duplicate evidence. */
-export declare function analyzeObservation(observation: Observation, correspondence: ReadonlyMap<LocalBinding, CorrespondenceEntry>): ObservationAnalysis;
+export declare function analyzeObservation(observation: Observation, correspondence: ReadonlyMap<LocalAlias, CorrespondenceEntry>): ObservationAnalysis;
+export {};

package/dist/graph/reconcile/planning/context.d.ts

@@ -2,15 +2,15 @@ import { type CorrespondenceEntry } from '#graph/reconcile/correspondence';
 import { type ObservationEvidence, type ObservationRequirement } from '#graph/reconcile/evidence';
 import { type Observation } from '#graph/reconcile/observation';
 import type { Edge } from '../../edge/index.js';
-import type { LocalBinding } from '../../graph/index.js';
+import type { LocalAlias } from '../../graph/index.js';
 import type { Node, NodeId } from '../../node/index.js';
 import type { Effect, PlanningBlocker, PlanningConflict, Premise } from './model.js';
 import { type DesiredProperties } from '../../properties/index.js';
 export interface PlanningContext {
     readonly nodes: ReadonlyMap<NodeId, Node>;
     readonly edges: ReadonlyMap<string, Edge>;
-    readonly correspondence: ReadonlyMap<LocalBinding, CorrespondenceEntry>;
-    readonly created: Set<LocalBinding>;
+    readonly correspondence: ReadonlyMap<LocalAlias, CorrespondenceEntry>;
+    readonly created: Set<LocalAlias>;
     readonly evidence: readonly ObservationEvidence[];
     readonly premises: Premise[];
     readonly effects: Effect[];

package/dist/graph/reconcile/planning/model.d.ts

@@ -3,12 +3,12 @@ import type { CorrespondenceConflict } from '#graph/reconcile/correspondence';
 import type { ObservationRequirement, QueryObservation } from '#graph/reconcile/evidence';
 import type { ObservationConflict } from '#graph/reconcile/observation';
 import type { EdgeKey, EdgeSlug } 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 { Delta, DesiredProperties, Properties } from '../../properties/index.js';
 import type { DesiredFingerprint, DesiredSelection, Expectation, ReconcileConflict } from '../condition/index.js';
 export type ResolvedNodeRef = NodeId | {
-    readonly created: LocalBinding;
+    readonly created: LocalAlias;
 };
 export interface ResolvedEdgeRef {
     readonly source: ResolvedNodeRef;
@@ -35,7 +35,7 @@ export interface QueryPremise {
 }
 export type Effect = {
     readonly op: 'node.create';
-    readonly as: LocalBinding;
+    readonly as: LocalAlias;
     readonly class: ClassKey;
     readonly properties: Properties;
 } | {
@@ -63,7 +63,7 @@ export type Effect = {
 };
 export type PlanningConflict = ReconcileConflict | CorrespondenceConflict | ObservationConflict | {
     readonly kind: 'desired-binding-uncreated';
-    readonly desired: LocalBinding;
+    readonly desired: LocalAlias;
 } | {
     readonly kind: 'node-class-observed';
     readonly node: NodeId;

package/dist/schema/callables/{view-for.d.ts → entrypoint.d.ts}

@@ -1,5 +1,5 @@
 import { type builder } from '@astrale-os/kernel-dsl/v1';
-export declare const ViewFor: builder.DirectedEdgeClass<{
+export declare const Entrypoint: builder.DirectedEdgeClass<{
     readonly depth: 1;
     readonly abstract: false;
     readonly extends: readonly [builder.ClassReferenceProjection<"edge", {
@@ -19,12 +19,14 @@ export declare const ViewFor: builder.DirectedEdgeClass<{
     readonly properties: never;
     readonly source: {
         readonly as: "view";
-        readonly outgoing: "1..*";
+        readonly outgoing: "0..1";
     };
     readonly target: {
-        readonly as: "target";
-        readonly incoming: "0..*";
+        readonly as: "domain";
+        readonly incoming: "0..1";
+    };
+    readonly constraints: {
+        readonly noSelf: true;
     };
-    readonly constraints: Record<never, never>;
     readonly effectiveProperties: never;
 }>;

package/dist/schema/callables/entrypoint.js

@@ -0,0 +1,12 @@
+import { edgeClass } from '@astrale-os/kernel-dsl/v1';
+import { Domain } from '../domain/index.js';
+import { Edge } from '../meta/index.js';
+import { View } from './view.js';
+export const Entrypoint = edgeClass.directed({
+    abstract: false,
+    source: { as: 'view', accepts: [View], outgoing: '0..1' },
+    target: { as: 'domain', accepts: [Domain], incoming: '0..1' },
+    description: 'The one View a Domain opens by default; a Domain declares at most one.',
+    extends: [Edge],
+    constraints: { noSelf: true },
+});