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

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()];
-}