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

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

@@ -399,29 +399,6 @@ export declare const Functions: Readonly<{
                 };
             })[];
             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;
@@ -449,6 +426,29 @@ export declare const Functions: Readonly<{
                 };
                 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: {
@@ -493,6 +493,14 @@ export declare const Functions: Readonly<{
     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;
@@ -514,14 +522,6 @@ export declare const Functions: Readonly<{
             } | undefined;
             revision?: string | undefined;
             currentRevision?: string | null | undefined;
-        } | {
-            publication: {
-                url: string;
-                token?: string | undefined;
-                etag?: string | undefined;
-            };
-            revision?: string | undefined;
-            currentRevision?: string | null | undefined;
         })[];
     }, {
         readonly mode: 'binary';

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

@@ -2,6 +2,14 @@ import { type builder } from '@astrale-os/kernel-dsl/v1';
 export declare const 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;
@@ -23,14 +31,6 @@ export declare const Install: builder.Function<builder.CallableProjection<{
         } | undefined;
         revision?: string | undefined;
         currentRevision?: string | null | undefined;
-    } | {
-        publication: {
-            url: string;
-            token?: string | undefined;
-            etag?: string | undefined;
-        };
-        revision?: string | undefined;
-        currentRevision?: string | null | undefined;
     })[];
 }, {
     readonly mode: 'binary';

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

@@ -155,29 +155,6 @@ export declare const Mutate: builder.Function<builder.CallableProjection<{
             };
         })[];
         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;
@@ -205,6 +182,29 @@ export declare const Mutate: builder.Function<builder.CallableProjection<{
             };
             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: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrale-os/kernel-core",
-  "version": "0.9.0-beta.63",
+  "version": "0.9.0-beta.64",
   "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.45",
+    "@astrale-os/kernel-dsl": "0.2.0-beta.46",
     "@noble/hashes": "2.3.0",
     "@types/json-schema": "^7.0.15",
     "dequal": "2.0.3"

package/dist/auth/authority/prepare-grant-body.d.ts

@@ -1,4 +0,0 @@
-import type { Grant } from '../grant/index.js';
-import type { AuthorityExpr, AuthorityPredicate } from './language/index.js';
-/** Prepare one body in a fresh Grant subject scope, independently of any concrete Grant. */
-export declare function prepareGrantBody(where: AuthorityExpr): (grant: Grant) => AuthorityPredicate;

package/dist/auth/authority/prepare-grant-body.js

@@ -1,27 +0,0 @@
-import * as portable from '@astrale-os/kernel-dsl/value';
-import { accept as acceptGrant, canonicalize as canonicalizeGrant } from '../grant/index.js';
-import { admitGrantBody } from './admission/index.js';
-import { AUTHORITY_PREDICATE_VERSION } from './language/index.js';
-import { normalizeGrantBodyAdmitted } from './normalization/index.js';
-import { ownCanonical } from './ownership.optimization.js';
-/** Prepare one body in a fresh Grant subject scope, independently of any concrete Grant. */
-export function prepareGrantBody(where) {
-    const admitted = admitGrantBody(portable.acceptForRead(where));
-    const body = portable.acceptImmutable(normalizeGrantBodyAdmitted(admitted));
-    return grantBinder(body);
-}
-// A distinct closure scope retains only the normalized body, never an initial Grant or caller input.
-function grantBinder(where) {
-    return (grant) => {
-        // Charge the entire expression on every binding, including the body and its outer container.
-        const value = portable.acceptForRead({ op: 'grant', grant, where });
-        return ownCanonical(Object.freeze({
-            version: AUTHORITY_PREDICATE_VERSION,
-            predicate: Object.freeze({
-                op: 'grant',
-                grant: canonicalizeGrant(acceptGrant(value.grant)),
-                where,
-            }),
-        }));
-    };
-}

package/dist/auth/expression/normalization/canonicalize.d.ts

@@ -1,7 +0,0 @@
-import * as portable from '@astrale-os/kernel-dsl/value';
-import type { IdentityExpr } from '../language/index.js';
-export declare const EXPRESSION_DEPTH_LIMIT = 32;
-export declare const EXPRESSION_OPERAND_LIMIT = 64;
-/** Validate and canonicalize a resolved expression. */
-export declare function canonicalize(expr: IdentityExpr): IdentityExpr;
-export declare function admitResolvedExpression(input: portable.Value, path: string, depth: number): IdentityExpr;

package/dist/auth/expression/normalization/canonicalize.js

@@ -1,102 +0,0 @@
-import * as portable from '@astrale-os/kernel-dsl/value';
-import { NodeId } from '../../../graph/node/index.js';
-import { AuthValueError } from '../../error.js';
-export const EXPRESSION_DEPTH_LIMIT = 32;
-export const EXPRESSION_OPERAND_LIMIT = 64;
-/** Validate and canonicalize a resolved expression. */
-export function canonicalize(expr) {
-    try {
-        return admit(portable.accept(expr), '', 0);
-    }
-    catch (cause) {
-        if (cause instanceof AuthValueError)
-            throw cause;
-        throw new AuthValueError('AUTH_GRANT_INVALID', 'Expected a resolved Identity expression', '', {
-            cause,
-        });
-    }
-}
-export function admitResolvedExpression(input, path, depth) {
-    return admit(input, path, depth);
-}
-function admit(input, path, depth) {
-    if (depth > EXPRESSION_DEPTH_LIMIT)
-        invalid(path, 'Identity expression exceeds its depth limit');
-    const value = record(input, path);
-    switch (value.kind) {
-        case 'identity':
-            exact(value, ['id', 'kind'], path);
-            if (typeof value.id !== 'string')
-                invalid(`${path}/id`, 'Expected a NodeId');
-            return Object.freeze({ kind: 'identity', id: NodeId(value.id) });
-        case 'union':
-        case 'intersect': {
-            exact(value, ['kind', 'operands'], path);
-            const source = list(value.operands, `${path}/operands`, 2);
-            const kind = value.kind;
-            const operands = unique(source
-                .map((operand, index) => admit(operand, `${path}/operands/${index}`, depth + 1))
-                .flatMap((operand) => (operand.kind === kind ? operand.operands : [operand])));
-            if (operands.length > EXPRESSION_OPERAND_LIMIT) {
-                invalid(`${path}/operands`, `Expected 2-${EXPRESSION_OPERAND_LIMIT} operands`);
-            }
-            return operands.length === 1
-                ? operands[0]
-                : Object.freeze({ kind, operands: Object.freeze(operands) });
-        }
-        case 'exclude': {
-            exact(value, ['base', 'excluded', 'kind'], path);
-            const excluded = unique(list(value.excluded, `${path}/excluded`, 1)
-                .map((operand, index) => admit(operand, `${path}/excluded/${index}`, depth + 1))
-                .flatMap((operand) => (operand.kind === 'union' ? operand.operands : [operand])));
-            if (excluded.length > EXPRESSION_OPERAND_LIMIT) {
-                invalid(`${path}/excluded`, `Expected 1-${EXPRESSION_OPERAND_LIMIT} operands`);
-            }
-            return Object.freeze({
-                kind: 'exclude',
-                base: admit(required(value.base, `${path}/base`), `${path}/base`, depth + 1),
-                excluded: Object.freeze(excluded),
-            });
-        }
-        default:
-            invalid(`${path}/kind`, 'Expected identity, union, intersect, or exclude');
-    }
-}
-function unique(input) {
-    const keyed = input
-        .map((expr) => ({ expr, key: portable.json.serialize(expr) }))
-        .sort((left, right) => compare(left.key, right.key));
-    return keyed
-        .filter((entry, index) => index === 0 || entry.key !== keyed[index - 1].key)
-        .map((entry) => entry.expr);
-}
-function record(input, path) {
-    if (input === null || Array.isArray(input) || typeof input !== 'object') {
-        invalid(path, 'Expected an object');
-    }
-    return input;
-}
-function list(input, path, minimum) {
-    if (!Array.isArray(input) || input.length < minimum || input.length > EXPRESSION_OPERAND_LIMIT) {
-        invalid(path, `Expected ${minimum}-${EXPRESSION_OPERAND_LIMIT} operands`);
-    }
-    return input;
-}
-function required(input, path) {
-    if (input === undefined)
-        invalid(path, 'Expected a value');
-    return input;
-}
-function exact(value, expected, path) {
-    const actual = Object.keys(value).sort(compare);
-    const wanted = [...expected].sort(compare);
-    if (actual.length !== wanted.length || actual.some((key, index) => key !== wanted[index])) {
-        invalid(path, `Expected exactly ${expected.join(', ')}`);
-    }
-}
-function compare(left, right) {
-    return left < right ? -1 : left > right ? 1 : 0;
-}
-function invalid(path, message) {
-    throw new AuthValueError('AUTH_GRANT_INVALID', message, path);
-}

package/dist/auth/expression/normalization/index.d.ts

@@ -1,2 +0,0 @@
-export { admitResolvedExpression, canonicalize, EXPRESSION_DEPTH_LIMIT, EXPRESSION_OPERAND_LIMIT, } from './canonicalize.js';
-export { raiseDenials } from './raise-denials.js';

package/dist/auth/expression/normalization/index.js

@@ -1,2 +0,0 @@
-export { admitResolvedExpression, canonicalize, EXPRESSION_DEPTH_LIMIT, EXPRESSION_OPERAND_LIMIT, } from './canonicalize.js';
-export { raiseDenials } from './raise-denials.js';

package/dist/auth/expression/normalization/raise-denials.d.ts

@@ -1,3 +0,0 @@
-import type { IdentityExpr } from '../language/index.js';
-/** Raise every positive-position exclusion into one Grant-wide veto. */
-export declare function raiseDenials(expr: IdentityExpr): IdentityExpr;

package/dist/auth/expression/normalization/raise-denials.js

@@ -1,59 +0,0 @@
-/** Raise every positive-position exclusion into one Grant-wide veto. */
-export function raiseDenials(expr) {
-    const denials = [...collectDenials(expr, new WeakMap())];
-    if (denials.length === 0)
-        return expr;
-    return Object.freeze({
-        kind: 'exclude',
-        base: stripExcludes(expr, new WeakMap()),
-        excluded: Object.freeze(denials),
-    });
-}
-function stripExcludes(expr, memo) {
-    const cached = memo.get(expr);
-    if (cached !== undefined)
-        return cached;
-    let stripped;
-    switch (expr.kind) {
-        case 'identity':
-            stripped = expr;
-            break;
-        case 'union':
-        case 'intersect':
-            stripped = Object.freeze({
-                kind: expr.kind,
-                operands: Object.freeze(expr.operands.map((operand) => stripExcludes(operand, memo))),
-            });
-            break;
-        case 'exclude':
-            stripped = stripExcludes(expr.base, memo);
-            break;
-    }
-    memo.set(expr, stripped);
-    return stripped;
-}
-function collectDenials(expr, memo) {
-    const cached = memo.get(expr);
-    if (cached !== undefined)
-        return cached;
-    const denials = new Set();
-    switch (expr.kind) {
-        case 'identity':
-            break;
-        case 'union':
-        case 'intersect':
-            for (const operand of expr.operands) {
-                for (const denial of collectDenials(operand, memo))
-                    denials.add(denial);
-            }
-            break;
-        case 'exclude':
-            for (const excluded of expr.excluded)
-                denials.add(excluded);
-            for (const denial of collectDenials(expr.base, memo))
-                denials.add(denial);
-            break;
-    }
-    memo.set(expr, denials);
-    return denials;
-}

package/dist/graph/graph/navigation/error.d.ts

@@ -1,12 +0,0 @@
-import type { NodePath } from '../../path/index.js';
-export declare class GraphPathAmbiguousError extends Error {
-    readonly path: NodePath;
-    readonly matches: number;
-    readonly code: 'GRAPH_PATH_AMBIGUOUS';
-    constructor(path: NodePath, matches: number);
-}
-export declare class GraphPathWalkerRequiredError extends Error {
-    readonly path: NodePath;
-    readonly code: 'GRAPH_PATH_WALKER_REQUIRED';
-    constructor(path: NodePath);
-}

package/dist/graph/graph/navigation/error.js

@@ -1,20 +0,0 @@
-export class GraphPathAmbiguousError extends Error {
-    path;
-    matches;
-    code = 'GRAPH_PATH_AMBIGUOUS';
-    constructor(path, matches) {
-        super(`Graph Path ${JSON.stringify(path)} matched ${matches} distinct Nodes.`);
-        this.path = path;
-        this.matches = matches;
-        this.name = 'GraphPathAmbiguousError';
-    }
-}
-export class GraphPathWalkerRequiredError extends Error {
-    path;
-    code = 'GRAPH_PATH_WALKER_REQUIRED';
-    constructor(path) {
-        super(`Graph Path ${JSON.stringify(path)} requires a walker.`);
-        this.path = path;
-        this.name = 'GraphPathWalkerRequiredError';
-    }
-}

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

@@ -1,2 +0,0 @@
-export type { GraphPathContext, GraphPathWalker } from './model.js';
-export { GraphPathAmbiguousError, GraphPathWalkerRequiredError } from './error.js';

package/dist/graph/graph/navigation/index.js

@@ -1 +0,0 @@
-export { GraphPathAmbiguousError, GraphPathWalkerRequiredError } from './error.js';

package/dist/graph/graph/navigation/model.d.ts

@@ -1,15 +0,0 @@
-import type { ClassKey } from '@astrale-os/kernel-dsl/v1/addressing';
-import type { EdgeOrientation } from '@astrale-os/kernel-dsl/v1/language';
-import type { Node } from '../../node/index.js';
-import type { Path } from '../../path/index.js';
-import type { GraphEdges, GraphNodes } from '../indexes/index.js';
-/** Semantic read-only graph capabilities available to a Path walker. */
-export interface GraphPathContext {
-    readonly nodes: GraphNodes;
-    readonly edges: GraphEdges;
-    orientation(classKey: ClassKey): EdgeOrientation | undefined;
-}
-/** Pure injected semantics for walking one Path against an admitted Graph. */
-export interface GraphPathWalker {
-    walk(path: Path, context: GraphPathContext): Node | undefined;
-}

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

@@ -1,2 +0,0 @@
-import type { GraphPathWalker } from '#graph/graph';
-export declare const projectionPathWalker: GraphPathWalker;

package/dist/schema/kernel/projection/path.js

@@ -1,113 +0,0 @@
-import { ClassKey } from '@astrale-os/kernel-dsl/v1/addressing';
-import { GraphPathAmbiguousError } from '#graph/graph';
-import { K } from '../index.js';
-export const projectionPathWalker = Object.freeze({
-    walk: walkProjectionPath,
-});
-function walkProjectionPath(path, context) {
-    let candidates = anchorCandidates(path.ast, context);
-    for (const step of path.ast.steps)
-        candidates = applyStep(candidates, step, context);
-    if (candidates.length === 0)
-        return undefined;
-    if (candidates.length === 1)
-        return candidates[0];
-    throw new GraphPathAmbiguousError(path.raw, candidates.length);
-}
-function anchorCandidates(ast, context) {
-    if (ast.anchor.kind === 'id') {
-        const node = context.nodes.byId(ast.anchor.id);
-        return node === undefined ? [] : [node];
-    }
-    const domainClass = ClassKey.of(K.classes.Domain.ref);
-    const origin = ast.anchor.origin;
-    return context.nodes
-        .byClass(domainClass)
-        .filter((node) => node.props[K.classes.Domain.properties.origin.key] === origin);
-}
-function applyStep(current, step, context) {
-    switch (step.kind) {
-        case 'projection':
-            return domainMembers(current, `${step.projection.kind}.${step.projection.name}`, context);
-        case 'method':
-            return step.dispatch === 'static'
-                ? directMethods(current, step.name, true, context)
-                : instanceMethods(current.filter((node) => node.class === step.class), step.name, context);
-        case 'traverse':
-            return traverse(current, step, context);
-    }
-}
-function domainMembers(domains, member, context) {
-    const domainIds = new Set(domains.map((node) => node.id));
-    return distinctNodes(edgesOf(K.classes.of_domain, context).flatMap((edge) => {
-        if (!domainIds.has(edge.target) ||
-            edge.props[K.classes.of_domain.properties.member.key] !== member) {
-            return [];
-        }
-        const node = context.nodes.byId(edge.source);
-        return node === undefined ? [] : [node];
-    }));
-}
-function directMethods(owners, name, isStatic, context) {
-    const ownerIds = new Set(owners.map((node) => node.id));
-    return distinctNodes(edgesOf(K.classes.method_of, context).flatMap((edge) => {
-        if (!ownerIds.has(edge.target) ||
-            edge.props[K.classes.method_of.properties.name.key] !== name ||
-            edge.props[K.classes.method_of.properties.static.key] !== isStatic) {
-            return [];
-        }
-        const method = context.nodes.byId(edge.source);
-        return method === undefined ? [] : [method];
-    }));
-}
-function instanceMethods(instances, name, context) {
-    return distinctNodes(instances.flatMap((instance) => {
-        const owner = resolveClassProjection(instance.class, context);
-        return owner.length === 0 ? [] : directMethods(owner, name, false, context);
-    }));
-}
-function resolveClassProjection(key, context) {
-    const domainClass = ClassKey.of(K.classes.Domain.ref);
-    const domains = context.nodes
-        .byClass(domainClass)
-        .filter((node) => node.props[K.classes.Domain.properties.origin.key] === ClassKey.ref(key).origin);
-    return domainMembers(domains, `class.${ClassKey.ref(key).name}`, context);
-}
-function traverse(current, step, context) {
-    const currentIds = new Set(current.map((node) => node.id));
-    const edgeClass = step.class;
-    const orientation = context.orientation(edgeClass);
-    const candidates = context.edges.byClass(edgeClass);
-    return distinctNodes(candidates.flatMap((edge) => {
-        if (step.slug !== undefined && edge.slug !== step.slug)
-            return [];
-        const endpoint = traversedEndpoint(edge, currentIds, step.direction, orientation);
-        if (endpoint === undefined)
-            return [];
-        const node = context.nodes.byId(endpoint);
-        return node === undefined ? [] : [node];
-    }));
-}
-function traversedEndpoint(edge, current, direction, orientation) {
-    if (orientation === 'undirected') {
-        if (current.has(edge.source))
-            return edge.target;
-        if (current.has(edge.target))
-            return edge.source;
-        return undefined;
-    }
-    if (direction === 'out' && current.has(edge.source))
-        return edge.target;
-    if (direction === 'in' && current.has(edge.target))
-        return edge.source;
-    return undefined;
-}
-function edgesOf(relation, context) {
-    return context.edges.byClass(ClassKey.of(relation.ref));
-}
-function distinctNodes(nodes) {
-    const byId = new Map();
-    for (const node of nodes)
-        byId.set(node.id, node);
-    return [...byId.values()];
-}