@astrale-os/kernel-core 0.9.0-beta.62 → 0.9.0-beta.64

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,
+    });
+}

package/dist/schema/identity/composition.d.ts

@@ -1,2 +1,7 @@
 import { type builder } from '@astrale-os/kernel-dsl/v1';
+/**
+ * One Identity-composition Edge Class. Each is `noSelf` and `acyclic` on its own; no constraint spans
+ * the three Classes, so stored data may hold a cycle that crosses them. Core authority decides every
+ * binder whose closure reaches such a cycle false, and no other (AUTH-AUTHORITY-DENOTATION).
+ */
 export declare function identityComposition(role: 'constraint' | 'excluded' | 'extension', description: string): builder.EdgeClass;

package/dist/schema/identity/composition.js

@@ -1,6 +1,11 @@
 import { edgeClass } from '@astrale-os/kernel-dsl/v1';
 import { Edge } from '../meta/index.js';
 import { Identity } from './identity.js';
+/**
+ * One Identity-composition Edge Class. Each is `noSelf` and `acyclic` on its own; no constraint spans
+ * the three Classes, so stored data may hold a cycle that crosses them. Core authority decides every
+ * binder whose closure reaches such a cycle false, and no other (AUTH-AUTHORITY-DENOTATION).
+ */
 export function identityComposition(role, description) {
     return edgeClass.directed({
         abstract: false,

package/dist/schema/index.d.ts

@@ -5,3 +5,4 @@ export * as graph from './kernel/projection/index.js';
 export * as introspection from './introspection/index.js';
 export * as installation from './installation/index.js';
 export { OperationCore } from './core/index.js';
+export { authorityVocabulary } from './authority/vocabulary.js';

package/dist/schema/index.js

@@ -4,3 +4,4 @@ export * as graph from './kernel/projection/index.js';
 export * as introspection from './introspection/index.js';
 export * as installation from './installation/index.js';
 export { OperationCore } from './core/index.js';
+export { authorityVocabulary } from './authority/vocabulary.js';

package/dist/schema/introspection/language.d.ts

@@ -9,4 +9,6 @@ export type Introspection = {
 } | {
     readonly kind: 'dependencies';
     readonly origin: Key.Origin;
+} | {
+    readonly kind: 'installed';
 };

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

@@ -8469,29 +8469,6 @@ declare const KernelDefinitions: {
                     };
                 })[];
                 operations: ({
-                    op: "edge.update";
-                    edge: {
-                        source: string;
-                        target: string;
-                        class: string;
-                    };
-                    slug: unknown;
-                    props?: {
-                        set: Record<string, unknown>;
-                        unset: string[];
-                    } | undefined;
-                } | {
-                    op: "edge.update";
-                    edge: {
-                        source: string;
-                        target: string;
-                        class: string;
-                    };
-                    props: {
-                        set: Record<string, unknown>;
-                        unset: string[];
-                    };
-                } | {
                     op: "node.create";
                     as: string;
                     class: string;
@@ -8519,6 +8496,29 @@ declare const KernelDefinitions: {
                     };
                     slug?: unknown;
                     props: Record<string, unknown>;
+                } | {
+                    op: "edge.update";
+                    edge: {
+                        source: string;
+                        target: string;
+                        class: string;
+                    };
+                    slug: unknown;
+                    props?: {
+                        set: Record<string, unknown>;
+                        unset: string[];
+                    } | undefined;
+                } | {
+                    op: "edge.update";
+                    edge: {
+                        source: string;
+                        target: string;
+                        class: string;
+                    };
+                    props: {
+                        set: Record<string, unknown>;
+                        unset: string[];
+                    };
                 } | {
                     op: "edge.delete";
                     edge: {
@@ -8563,6 +8563,14 @@ declare const KernelDefinitions: {
         install: builder.Function<builder.CallableProjection<{
             operation: string;
             domains: ({
+                publication: {
+                    url: string;
+                    token?: string | undefined;
+                    etag?: string | undefined;
+                };
+                revision?: string | undefined;
+                currentRevision?: string | null | undefined;
+            } | {
                 artifact: {
                     digest: string;
                     mediaType: string;
@@ -8570,11 +8578,18 @@ declare const KernelDefinitions: {
                 };
                 currentRevision?: string | null | undefined;
             } | {
-                publication: {
+                release: {
                     url: string;
                     token?: string | undefined;
-                    etag?: string | undefined;
+                    digest?: string | undefined;
                 };
+                consent?: {
+                    issuer: {
+                        from: string;
+                        to: string;
+                    };
+                    previous?: "drain" | "revoke" | undefined;
+                } | undefined;
                 revision?: string | undefined;
                 currentRevision?: string | null | undefined;
             })[];
@@ -8584,6 +8599,8 @@ declare const KernelDefinitions: {
         introspect: builder.Function<builder.CallableProjection<{
             kind: "bundle" | "dependencies" | "inspect";
             origin: string;
+        } | {
+            kind: "installed";
         }, {
             readonly mode: 'binary';
         }, "authenticated", false, false, undefined>>;
@@ -8612,6 +8629,13 @@ declare const KernelDefinitions: {
                             revision: string;
                             generation: string;
                         } | null;
+                        consent?: {
+                            issuer: {
+                                from: string;
+                                to: string;
+                            };
+                            previous: "drain" | "revoke";
+                        } | undefined;
                     };
                     phase: "converge" | "cutover";
                     state: "committed";
@@ -8964,6 +8988,14 @@ export declare const KernelRootFunctions: readonly ((import("@astrale-os/kernel-
 }) | (import("@astrale-os/kernel-dsl/v1").ResolvedFunction<{
     operation: string;
     domains: ({
+        publication: {
+            url: string;
+            token?: string | undefined;
+            etag?: string | undefined;
+        };
+        revision?: string | undefined;
+        currentRevision?: string | null | undefined;
+    } | {
         artifact: {
             digest: string;
             mediaType: string;
@@ -8971,11 +9003,18 @@ export declare const KernelRootFunctions: readonly ((import("@astrale-os/kernel-
         };
         currentRevision?: string | null | undefined;
     } | {
-        publication: {
+        release: {
             url: string;
             token?: string | undefined;
-            etag?: string | undefined;
+            digest?: string | undefined;
         };
+        consent?: {
+            issuer: {
+                from: string;
+                to: string;
+            };
+            previous?: "drain" | "revoke" | undefined;
+        } | undefined;
         revision?: string | undefined;
         currentRevision?: string | null | undefined;
     })[];
@@ -9143,29 +9182,6 @@ export declare const KernelRootFunctions: readonly ((import("@astrale-os/kernel-
             };
         })[];
         operations: ({
-            op: "edge.update";
-            edge: {
-                source: string;
-                target: string;
-                class: string;
-            };
-            slug: unknown;
-            props?: {
-                set: Record<string, unknown>;
-                unset: string[];
-            } | undefined;
-        } | {
-            op: "edge.update";
-            edge: {
-                source: string;
-                target: string;
-                class: string;
-            };
-            props: {
-                set: Record<string, unknown>;
-                unset: string[];
-            };
-        } | {
             op: "node.create";
             as: string;
             class: string;
@@ -9193,6 +9209,29 @@ export declare const KernelRootFunctions: readonly ((import("@astrale-os/kernel-
             };
             slug?: unknown;
             props: Record<string, unknown>;
+        } | {
+            op: "edge.update";
+            edge: {
+                source: string;
+                target: string;
+                class: string;
+            };
+            slug: unknown;
+            props?: {
+                set: Record<string, unknown>;
+                unset: string[];
+            } | undefined;
+        } | {
+            op: "edge.update";
+            edge: {
+                source: string;
+                target: string;
+                class: string;
+            };
+            props: {
+                set: Record<string, unknown>;
+                unset: string[];
+            };
         } | {
             op: "edge.delete";
             edge: {
@@ -9508,6 +9547,13 @@ export declare const KernelRootFunctions: readonly ((import("@astrale-os/kernel-
                     revision: string;
                     generation: string;
                 } | null;
+                consent?: {
+                    issuer: {
+                        from: string;
+                        to: string;
+                    };
+                    previous: "drain" | "revoke";
+                } | undefined;
             };
             phase: "converge" | "cutover";
             state: "committed";
@@ -9563,30 +9609,15 @@ export declare const KernelRootFunctions: readonly ((import("@astrale-os/kernel-
     readonly key: "kernel.astrale.ai:function.journal";
     readonly execution: undefined;
 }) | (import("@astrale-os/kernel-dsl/v1").ResolvedMethod<{
-    iss: string;
-    sub: string;
+    audience?: string | undefined;
+    ttlSeconds: number;
+    grant?: unknown;
+    identity: string;
 }, {
     readonly mode: 'value';
-    readonly value: {
-        id: string;
-        iss: string;
-        sub: string;
-        frozen: boolean;
-        requiredClaims: ({
-            claim: string;
-            op: "contains";
-            value: unknown;
-        } | {
-            claim: string;
-            op: "eq";
-            value: unknown;
-        } | {
-            claim: string;
-            op: "exists";
-        })[];
-    } | null;
-}, 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.whois"> & {
-    readonly name: "whois";
+    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<{
@@ -9633,15 +9664,30 @@ export declare const KernelRootFunctions: readonly ((import("@astrale-os/kernel-
     readonly executable: true;
     readonly execution: undefined;
 }) | (import("@astrale-os/kernel-dsl/v1").ResolvedMethod<{
-    audience?: string | undefined;
-    ttlSeconds: number;
-    grant?: unknown;
-    identity: string;
+    iss: string;
+    sub: 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 value: {
+        id: string;
+        iss: string;
+        sub: string;
+        frozen: boolean;
+        requiredClaims: ({
+            claim: string;
+            op: "contains";
+            value: unknown;
+        } | {
+            claim: string;
+            op: "eq";
+            value: unknown;
+        } | {
+            claim: string;
+            op: "exists";
+        })[];
+    } | null;
+}, 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.whois"> & {
+    readonly name: "whois";
     readonly executable: true;
     readonly execution: undefined;
 }))[];