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

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

@@ -6,6 +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 { decodeQueryResult } from '../result/index.js';
 import { QueryReferenceError } from './error.js';
 /** Independent backend-neutral executable Query V6 row algebra. */
@@ -273,9 +274,13 @@ function decodeWitness(input, path, context) {
 }
 function selectNodes(rows, select, size, after, admission, properties) {
     const selected = new Map();
+    const ordered = orderedClasses(select.order, 'node', properties);
     rows.forEach((row) => {
         const node = boundNode(row, select.binding, '/select/binding');
-        const needsRead = select.kind === 'graph' || (select.kind === 'nodes' && select.projection.kind === 'value');
+        // A value is read; an ordered reference reads a fact its order applies to before ranking it.
+        const needsRead = select.kind === 'graph' ||
+            (select.kind === 'nodes' && select.projection.kind === 'value') ||
+            ordered.has(node.class);
         if (needsRead && !admission.readNode(node, '/select/binding'))
             return;
         selected.set(node.id, node);
@@ -305,6 +310,7 @@ function selectNodes(rows, select, size, after, admission, properties) {
 }
 function selectEdges(rows, select, size, after, context, admission, properties) {
     const selected = new Map();
+    const ordered = orderedClasses(select.order, 'edge', properties);
     rows.forEach((row) => {
         const edge = boundEdge(row, select.binding, '/select/binding');
         const source = requireNode(context, edge.source, '/select/binding');
@@ -319,7 +325,7 @@ function selectEdges(rows, select, size, after, context, admission, properties)
                 admission.readNode(source, '/select/binding') &&
                 admission.readNode(target, '/select/binding')
             : select.kind === 'edges'
-                ? (select.projection.edge === 'reference' ||
+                ? ((select.projection.edge === 'reference' && !ordered.has(edge.class)) ||
                     admission.readEdge(edge, '/select/binding')) &&
                     (select.projection.source === 'reference' ||
                         admission.readNode(source, '/select/binding')) &&
@@ -362,12 +368,24 @@ function selectEdges(rows, select, size, after, context, admission, properties)
     const next = last === undefined ? undefined : frontierOf(last, order, 'edge', properties);
     return Object.freeze({ result, ...(next === undefined ? {} : { next }) });
 }
+/** The Classes a Property order applies to, whose facts are read before they are ranked. */
+function orderedClasses(order, kind, properties) {
+    return order === undefined
+        ? new Set()
+        : properties.close(order.property, kind, '/select/order/property');
+}
 function orderingComparator(order, kind, properties) {
-    return (left, right) => compareReferenceRank(rankOf(left, order, kind, properties), rankOf(right, order, kind, properties), order);
+    const ordering = orderingOf(order, kind, properties);
+    return (left, right) => compareReferenceRank(rankOf(left, order, kind, properties), rankOf(right, order, kind, properties), order, ordering);
+}
+function orderingOf(order, kind, properties) {
+    return order === undefined
+        ? undefined
+        : properties.ordering(order.property, kind, '/select/order/property');
 }
 function compareFrontier(frontier, fact, order, kind, properties) {
     const admitted = decodeReferenceFrontier(frontier, order, kind, properties);
-    return compareReferenceRank(admitted, rankOf(fact, order, kind, properties), order);
+    return compareReferenceRank(admitted, rankOf(fact, order, kind, properties), order, orderingOf(order, kind, properties));
 }
 function frontierOf(fact, order, kind, properties) {
     const rank = rankOf(fact, order, kind, properties);
@@ -413,36 +431,8 @@ function decodeReferenceFrontier(frontier, order, kind, properties) {
     }
     return Object.freeze({ bucket: 'ranked', value: frontier.value, identity });
 }
-function compareReferenceRank(left, right, order) {
-    if (order === undefined)
-        return compareIdentity(left.identity, right.identity);
-    if (left.bucket !== right.bucket) {
-        return left.bucket === 'unranked'
-            ? order.unranked === 'first'
-                ? -1
-                : 1
-            : order.unranked === 'first'
-                ? 1
-                : -1;
-    }
-    if (left.bucket === 'ranked' && right.bucket === 'ranked') {
-        const kind = typeof left.value === 'boolean'
-            ? 'boolean'
-            : typeof left.value === 'number'
-                ? 'number'
-                : 'string';
-        const compared = compareOrderingValue(left.value, right.value, kind);
-        if (compared !== 0)
-            return order.direction === 'asc' ? compared : -compared;
-    }
-    return compareIdentity(left.identity, right.identity);
-}
-function compareIdentity(left, right) {
-    if (typeof left === 'string' && typeof right === 'string')
-        return compareNodeIds(left, right);
-    if (typeof left !== 'string' && typeof right !== 'string')
-        return compareEdgeKeys(left, right);
-    invalid('/after/identity', 'Frontier identity kind disagrees with selection');
+function compareReferenceRank(left, right, order, ordering) {
+    return compareQueryRank(left, right, order === undefined || ordering === undefined ? undefined : { ...order, kind: ordering });
 }
 function orderingValue(input, kind) {
     if (kind === 'boolean')
@@ -451,22 +441,6 @@ function orderingValue(input, kind) {
         return typeof input === 'number' && Number.isFinite(input);
     return typeof input === 'string';
 }
-function compareOrderingValue(left, right, kind) {
-    if (kind === 'boolean')
-        return Number(left) - Number(right);
-    if (kind === 'number')
-        return left - right;
-    return compareUnicodeScalars(left, right);
-}
-function compareUnicodeScalars(left, right) {
-    const a = Array.from(left, (value) => value.codePointAt(0));
-    const b = Array.from(right, (value) => value.codePointAt(0));
-    for (let index = 0; index < Math.min(a.length, b.length); index += 1) {
-        if (a[index] !== b[index])
-            return a[index] - b[index];
-    }
-    return a.length - b.length;
-}
 function projectNode(node, shape) {
     return shape === 'value'
         ? Object.freeze({ kind: 'value', value: node })

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

@@ -2,6 +2,12 @@ import { type ObservationRequirement } from '#graph/reconcile/evidence';
 import type { Effect, PlanningBlocker, PlanningConflict, Premise, ReconciliationPlan } from './model.js';
 export declare function canonicalRequirements(values: readonly ObservationRequirement[]): ObservationRequirement[];
 export declare function canonicalPremises(values: readonly Premise[]): Premise[];
+/**
+ * Distinct desired refs can name one target: an explicit NodeId and a binding whose
+ * correspondence observes that Node. Effects with one key and equal content collapse; effects with
+ * one key and different content contradict the desired state, which no transition can establish.
+ */
+export declare function contradictoryEffects(values: readonly Effect[]): PlanningConflict[];
 export declare function canonicalEffects(values: readonly Effect[]): Effect[];
 export declare function canonicalConflicts(values: readonly PlanningConflict[]): PlanningConflict[];
 export declare function canonicalBlockers(values: readonly PlanningBlocker[]): PlanningBlocker[];

package/dist/graph/reconcile/planning/canonical.js

@@ -1,3 +1,4 @@
+import * as portable from '@astrale-os/kernel-dsl/value';
 import { freezeRequirement, requirementKey, } from '#graph/reconcile/evidence';
 import { encodeEdgeKey } from '../../edge/index.js';
 export function canonicalRequirements(values) {
@@ -8,6 +9,30 @@ export function canonicalRequirements(values) {
 export function canonicalPremises(values) {
     return [...new Map(values.map((value) => [premiseKey(value), value])).values()].sort(comparePremises);
 }
+/**
+ * Distinct desired refs can name one target: an explicit NodeId and a binding whose
+ * correspondence observes that Node. Effects with one key and equal content collapse; effects with
+ * one key and different content contradict the desired state, which no transition can establish.
+ */
+export function contradictoryEffects(values) {
+    const groups = new Map();
+    for (const value of values) {
+        const key = effectKey(value);
+        const group = groups.get(key) ?? new Map();
+        group.set(portable.json.serialize(value), value);
+        groups.set(key, group);
+    }
+    const conflicts = [];
+    for (const group of groups.values()) {
+        if (group.size < 2)
+            continue;
+        conflicts.push({
+            kind: 'desired-target-contradictory',
+            effects: [...group].sort(([left], [right]) => compare(left, right)).map(([, value]) => value),
+        });
+    }
+    return conflicts;
+}
 export function canonicalEffects(values) {
     return [...new Map(values.map((value) => [effectKey(value), value])).values()].sort(compareEffects);
 }
@@ -66,6 +91,9 @@ function freezeConflict(value) {
     if (value.kind === 'correspondence-noninjective') {
         return Object.freeze({ ...value, desired: Object.freeze([...value.desired]) });
     }
+    if (value.kind === 'desired-target-contradictory') {
+        return Object.freeze({ ...value, effects: Object.freeze([...value.effects]) });
+    }
     return Object.freeze({ ...value });
 }
 function compare(left, right) {

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

@@ -72,6 +72,10 @@ export type PlanningConflict = ReconcileConflict | CorrespondenceConflict | Obse
 } | {
     readonly kind: 'node-identity-absent';
     readonly node: NodeId;
+} | {
+    /** One effect target reached through aliasing refs with different desired content. */
+    readonly kind: 'desired-target-contradictory';
+    readonly effects: readonly Effect[];
 };
 export type PlanningBlocker = {
     readonly kind: 'selection-unsatisfied';

package/dist/graph/reconcile/planning/plan.js

@@ -1,5 +1,5 @@
 import { fingerprint } from '../condition/index.js';
-import { canonicalBlockers, canonicalConflicts, canonicalEffects, canonicalPremises, canonicalRequirements, createPlan, } from './canonical.js';
+import { canonicalBlockers, canonicalConflicts, canonicalEffects, canonicalPremises, canonicalRequirements, contradictoryEffects, createPlan, } from './canonical.js';
 import { createPlanningContext } from './context.js';
 import { planEdge } from './edge.js';
 import { planNode } from './node.js';
@@ -13,6 +13,7 @@ export function plan(input) {
         planEdge(edge, context);
     for (const selection of input.desired.selections)
         planSelection(selection, context);
+    context.conflicts.push(...contradictoryEffects(context.effects));
     if (context.conflicts.length > 0) {
         return Object.freeze({
             kind: 'conflict',

package/dist/schema/authority/vocabulary.d.ts

@@ -0,0 +1,3 @@
+import type { authority } from '../../auth/index.js';
+/** The Kernel instance of the authority vocabulary; Core Auth interprets authority through it. */
+export declare const authorityVocabulary: authority.AuthorityVocabulary;

package/dist/schema/authority/vocabulary.js

@@ -0,0 +1,25 @@
+import { K } from '../kernel/schema.js';
+/** The Kernel instance of the authority vocabulary; Core Auth interprets authority through it. */
+export const authorityVocabulary = Object.freeze({
+    identity: ref(K.classes.Identity.ref),
+    composition: Object.freeze({
+        extension: ref(K.classes.extends_with.ref),
+        constraint: ref(K.classes.constrained_by.ref),
+        exclusion: ref(K.classes.excluded_from.ref),
+    }),
+    capabilities: Object.freeze({
+        create: ref(K.classes.can_create.ref),
+        read: ref(K.classes.can_read.ref),
+        traverse: ref(K.classes.can_traverse.ref),
+        update: ref(K.classes.can_update.ref),
+        delete: ref(K.classes.can_delete.ref),
+    }),
+    instanceOf: ref(K.classes.instance_of.ref),
+});
+function ref(value) {
+    return Object.freeze({
+        origin: value.origin,
+        kind: 'class',
+        name: value.name,
+    });
+}