@astrale-os/kernel-dsl 1.0.0-beta.12 → 1.0.0-beta.13

package/dist/v1/compiled/admission/semantics/cardinality.js

@@ -1,128 +0,0 @@
-import { Key } from '../../../addressing/index.js';
-import { compareUnicode } from '../../../addressing/ordering.js';
-import {} from '../../../language/class/model/edge.js';
-import { coveringEdgeUniqueTuples, edgeUniqueKeys } from '../../../language/class/unique.js';
-import {} from '../../model/schema.js';
-import { fail } from '../diagnostic.js';
-import { isCompiledEdge, classSatisfiesAny, } from './context.js';
-import {} from './core.js';
-import { sameIncidentEndpoint, countBounds } from './edge.js';
-/** Check normalized Edge identity, keys, noSelf, cycles and complete Core degrees. */
-export function validateCoreEdgeSet(context, entry, entryIndex, nodes, edges) {
-    const seen = new Set();
-    const slices = new Map();
-    for (const edge of edges) {
-        const classKey = Key.of(edge.value.class);
-        const [source, target] = edge.class.value.orientation === 'undirected' &&
-            compareUnicode(edge.source.key, edge.target.key) > 0
-            ? [edge.target.key, edge.source.key]
-            : [edge.source.key, edge.target.key];
-        const key = `${classKey}\u0000${source}\u0000${target}`;
-        if (seen.has(key))
-            fail(edge.pointer, 'Core Edge duplicates an exact normalized Edge identity.');
-        seen.add(key);
-        const values = slices.get(classKey) ?? [];
-        values.push(edge);
-        slices.set(classKey, values);
-        if (edge.class.value.constraints.noSelf === true && edge.source.key === edge.target.key)
-            fail(edge.pointer, 'Core Edge violates noSelf.');
-    }
-    // No two Core Edges hold one key under a tuple covering their Classes (DV-EDGE-UNIQUE).
-    const resolve = (ref) => context.classes.get(Key.of(ref))?.value;
-    const holders = new Set();
-    for (const edge of edges) {
-        const keys = edgeUniqueKeys(coveringEdgeUniqueTuples(edge.class.value, resolve), {
-            source: edge.source.key,
-            target: edge.target.key,
-            props: edge.value.properties,
-        });
-        if (keys.some((key) => holders.has(key)))
-            fail(edge.pointer, 'Core Edge holds a key another Core Edge holds.');
-        for (const key of keys)
-            holders.add(key);
-    }
-    for (const edgeClass of entry.definitions.classes) {
-        if (!isCompiledEdge(edgeClass))
-            continue;
-        const classEdges = slices.get(Key.of(edgeClass.ref)) ?? [];
-        if (edgeClass.constraints.acyclic === true && hasCycle(classEdges))
-            fail(`/closure/${entryIndex}/facts/core`, 'Core Edge set violates exact-Class acyclicity.');
-        validateCardinality(context, edgeClass, classEdges, nodes);
-    }
-}
-function validateCardinality(context, declaration, edges, nodes) {
-    for (const subject of cardinalitySubjects(edges, nodes)) {
-        if (declaration.orientation === 'directed') {
-            if (classSatisfiesAny(context, subject.class, declaration.endpoints.source.accepts))
-                checkCount(declaration.endpoints.source.outgoing, edges.filter(({ source }) => source.key === subject.key).length, subject.pointer, subject.minimum);
-            if (classSatisfiesAny(context, subject.class, declaration.endpoints.target.accepts))
-                checkCount(declaration.endpoints.target.incoming, edges.filter(({ target }) => target.key === subject.key).length, subject.pointer, subject.minimum);
-        }
-        else {
-            const degree = edges.filter(({ source, target }) => source.key === subject.key || target.key === subject.key).length;
-            const [first, second] = declaration.endpoints;
-            if (classSatisfiesAny(context, subject.class, first.accepts))
-                checkCount(first.incident, degree, subject.pointer, subject.minimum);
-            if (!sameIncidentEndpoint(first, second) &&
-                classSatisfiesAny(context, subject.class, second.accepts))
-                checkCount(second.incident, degree, subject.pointer, subject.minimum);
-        }
-    }
-}
-/**
- * Every declared Core Node proves its own complete degree, so both bounds hold. A Definition
- * endpoint is only named by the Edges that reach it: the Domain may also create ordinary Edges of
- * the same Class against it, so a minimum is unprovable here and only the maximum is enforced.
- */
-function cardinalitySubjects(edges, nodes) {
-    const subjects = new Map();
-    for (const node of nodes.values()) {
-        subjects.set(node.key, {
-            key: node.key,
-            class: node.value.class,
-            pointer: node.pointer,
-            minimum: true,
-        });
-    }
-    for (const edge of edges) {
-        for (const endpoint of [edge.source, edge.target]) {
-            if ('value' in endpoint || !('class' in endpoint) || subjects.has(endpoint.key))
-                continue;
-            subjects.set(endpoint.key, {
-                key: endpoint.key,
-                class: endpoint.class,
-                pointer: endpoint.pointer,
-                minimum: false,
-            });
-        }
-    }
-    return Object.freeze([...subjects.values()]);
-}
-function checkCount(count, degree, path, enforceMinimum) {
-    const [minimum, maximum] = countBounds(count);
-    if (degree > maximum || (degree < minimum && enforceMinimum))
-        fail(path, `Core degree ${degree} violates Edge count ${count}.`);
-}
-function hasCycle(edges) {
-    const outgoing = new Map();
-    for (const edge of edges) {
-        const values = outgoing.get(edge.source.key) ?? [];
-        values.push(edge.target.key);
-        outgoing.set(edge.source.key, values);
-    }
-    const visiting = new Set();
-    const visited = new Set();
-    const visit = (key) => {
-        if (visiting.has(key))
-            return true;
-        if (visited.has(key))
-            return false;
-        visiting.add(key);
-        if ((outgoing.get(key) ?? []).some(visit))
-            return true;
-        visiting.delete(key);
-        visited.add(key);
-        return false;
-    };
-    return [...outgoing.keys()].some(visit);
-}

package/dist/v1/compiled/admission/semantics/policy/equality.d.ts

@@ -1,8 +0,0 @@
-/** Retain and merge term equalities while typing one Policy branch. */
-export declare class CompiledUnionFind {
-    #private;
-    constructor(values: Iterable<string>);
-    add(value: string): void;
-    find(value: string): string;
-    join(left: string, right: string): void;
-}

package/dist/v1/compiled/admission/semantics/policy/equality.js

@@ -1,27 +0,0 @@
-/** Retain and merge term equalities while typing one Policy branch. */
-export class CompiledUnionFind {
-    #parents = new Map();
-    constructor(values) {
-        for (const value of values)
-            this.add(value);
-    }
-    add(value) {
-        if (!this.#parents.has(value))
-            this.#parents.set(value, value);
-    }
-    find(value) {
-        this.add(value);
-        const parent = this.#parents.get(value);
-        if (parent === value)
-            return value;
-        const root = this.find(parent);
-        this.#parents.set(value, root);
-        return root;
-    }
-    join(left, right) {
-        const a = this.find(left);
-        const b = this.find(right);
-        if (a !== b)
-            this.#parents.set(b, a);
-    }
-}

package/dist/v1/compiled/admission/semantics/policy/measure.d.ts

@@ -1,9 +0,0 @@
-import { type PolicyExpression } from '../../../../language/policy/model/policy.js';
-interface CompiledPatternMeasure {
-    readonly depth: number;
-    readonly edgeCounts: readonly number[];
-    readonly domains: ReadonlySet<string>;
-}
-/** Measure expanded Policy branches, depth and referenced Domains. */
-export declare function measureCompiledPolicy(origin: string, name: string, normalized: ReadonlyMap<string, PolicyExpression>, visiting: Set<string>): CompiledPatternMeasure | undefined;
-export {};

package/dist/v1/compiled/admission/semantics/policy/measure.js

@@ -1,81 +0,0 @@
-import { policyObjectOrigin, policyVariableClass } from '../../../../language/index.js';
-import { BRANCH_OVERFLOW } from '../../../../language/policy/analysis/budgets.js';
-import {} from '../../../../language/policy/model/policy.js';
-/** Measure expanded Policy branches, depth and referenced Domains. */
-export function measureCompiledPolicy(origin, name, normalized, visiting) {
-    if (visiting.has(name))
-        return undefined;
-    const expression = normalized.get(name);
-    if (expression === undefined)
-        return undefined;
-    if ('match' in expression)
-        return measureCompiledPattern(expression.match, origin);
-    const nested = new Set(visiting);
-    nested.add(name);
-    const refs = 'allOf' in expression ? expression.allOf : expression.anyOf;
-    const children = refs.map((ref) => ref.origin === origin ? measureCompiledPolicy(origin, ref.name, normalized, nested) : undefined);
-    if (children.some((value) => value === undefined))
-        return undefined;
-    return combineCompiledMeasures('allOf' in expression ? 'allOf' : 'anyOf', children);
-}
-function measureCompiledPattern(pattern, origin) {
-    if ('sameNode' in pattern)
-        return {
-            depth: 1,
-            edgeCounts: [1],
-            domains: new Set([
-                origin,
-                ...[pattern.sameNode.left, pattern.sameNode.right].flatMap((term) => term.kind === 'ref' ? [policyObjectOrigin(term.ref)] : []),
-            ]),
-        };
-    if ('source' in pattern)
-        return {
-            depth: 1,
-            edgeCounts: [1],
-            domains: new Set([
-                origin,
-                pattern.class.origin,
-                ...[pattern.source, pattern.target].flatMap((term) => term.kind === 'ref' ? [policyObjectOrigin(term.ref)] : []),
-            ]),
-        };
-    if ('exists' in pattern) {
-        const child = measureCompiledPattern(pattern.exists.where, origin);
-        return {
-            depth: child.depth + 1,
-            edgeCounts: child.edgeCounts,
-            domains: new Set([
-                ...child.domains,
-                ...pattern.exists.nodes.flatMap((node) => {
-                    const ref = policyVariableClass(node);
-                    return ref === undefined ? [] : [ref.origin];
-                }),
-            ]),
-        };
-    }
-    return combineCompiledMeasures('allOf' in pattern ? 'allOf' : 'anyOf', ('allOf' in pattern ? pattern.allOf : pattern.anyOf).map((child) => measureCompiledPattern(child, origin)));
-}
-function combineCompiledMeasures(kind, children) {
-    const depth = 1 + Math.max(0, ...children.map((child) => child.depth));
-    const domains = new Set(children.flatMap((child) => [...child.domains]));
-    if (kind === 'anyOf')
-        return {
-            depth,
-            edgeCounts: children.flatMap((child) => child.edgeCounts).slice(0, BRANCH_OVERFLOW),
-            domains,
-        };
-    let edgeCounts = [0];
-    for (const child of children) {
-        const next = [];
-        for (const left of edgeCounts) {
-            for (const right of child.edgeCounts) {
-                next.push(left + right);
-                if (next.length >= BRANCH_OVERFLOW)
-                    break;
-            }
-            if (next.length >= BRANCH_OVERFLOW)
-                break;
-        }
-        edgeCounts = next;
-    }
-    return { depth, edgeCounts, domains };
-}

package/dist/v1/compiled/admission/semantics/policy/variants.d.ts

@@ -1,10 +0,0 @@
-import type { CompiledPolicyTyping } from './typing.js';
-import { type ClassRef } from '../../../../addressing/index.js';
-import { type PatternEdgeUse } from '../../../../language/policy/analysis/branches.js';
-/** One possible combination of endpoint constraints and term equalities. */
-export interface CompiledEdgeVariant {
-    readonly constraints: readonly (readonly [string, readonly ClassRef[]])[];
-    readonly equalities: readonly (readonly [string, string])[];
-}
-/** Enumerate satisfiable endpoint variants for a branch’s Edge uses. */
-export declare function compiledEdgeAlternatives(edges: readonly PatternEdgeUse[], typing: CompiledPolicyTyping): readonly (readonly CompiledEdgeVariant[])[];

package/dist/v1/compiled/admission/semantics/policy/variants.js

@@ -1,65 +0,0 @@
-import { Key } from '../../../../addressing/index.js';
-import { compareUnicode } from '../../../../addressing/ordering.js';
-import {} from '../../../../language/class/model/edge.js';
-import { termKey } from '../../../../language/policy/analysis/branches.js';
-import { isCompiledEdge } from '../context.js';
-/** Enumerate satisfiable endpoint variants for a branch’s Edge uses. */
-export function compiledEdgeAlternatives(edges, typing) {
-    let result = [[]];
-    for (const edge of edges) {
-        const variants = compiledVariantsForEdge(edge, typing);
-        if (variants.length === 0)
-            return [];
-        result = result.flatMap((prefix) => variants.map((variant) => [...prefix, variant]));
-    }
-    return result;
-}
-function compiledVariantsForEdge(use, typing) {
-    const declaration = typing.context.classes.get(Key.of(use.pattern.class))?.value;
-    if (declaration === undefined || !isCompiledEdge(declaration))
-        return [];
-    const endpoints = declaration.orientation === 'directed'
-        ? [declaration.endpoints.source, declaration.endpoints.target]
-        : declaration.endpoints;
-    const repeat = use.pattern.repeat ?? { min: 1, max: 1 };
-    const sourceKey = termKey(use.pattern.source, use.namespace);
-    const targetKey = termKey(use.pattern.target, use.namespace);
-    const variants = [];
-    for (let length = repeat.min; length <= repeat.max; length++) {
-        if (length === 0) {
-            variants.push({ constraints: [], equalities: [[sourceKey, targetKey]] });
-            continue;
-        }
-        const orientationCount = declaration.orientation === 'undirected' ? 2 ** length : 1;
-        for (let mask = 0; mask < orientationCount; mask++) {
-            const reversed = Array.from({ length }, (_, index) => declaration.orientation === 'undirected' && (mask & (1 << index)) !== 0);
-            let valid = true;
-            for (let index = 0; index + 1 < length; index++) {
-                const incoming = reversed[index] ? endpoints[0] : endpoints[1];
-                const outgoing = reversed[index + 1] ? endpoints[1] : endpoints[0];
-                if (!typing.endpointsOverlap(incoming.accepts, outgoing.accepts))
-                    valid = false;
-            }
-            if (!valid)
-                continue;
-            const first = reversed[0] ? endpoints[1] : endpoints[0];
-            const last = reversed[length - 1] ? endpoints[0] : endpoints[1];
-            variants.push({
-                constraints: [
-                    [sourceKey, first.accepts],
-                    [targetKey, last.accepts],
-                ],
-                equalities: [],
-            });
-        }
-    }
-    return uniqueCompiledEdgeVariants(variants);
-}
-function uniqueCompiledEdgeVariants(values) {
-    const result = new Map();
-    for (const value of values) {
-        const key = `${value.constraints.map(([term, accepts]) => `${term}:${accepts.map(Key.of).sort(compareUnicode).join(',')}`).join('|')}=${value.equalities.map(([left, right]) => `${left}:${right}`).join('|')}`;
-        result.set(key, value);
-    }
-    return [...result.values()];
-}

package/dist/v1/language/class/index.d.ts

@@ -1,8 +0,0 @@
-export type * from './model/class.js';
-export type * from './model/data.js';
-export type * from './model/edge.js';
-export type * from './model/property.js';
-export { PropertyValues } from './property-values.js';
-export type { PropertyValuesOperations } from './property-values.js';
-export type * from './facets.js';
-export type * from './resolved.js';

package/dist/v1/language/class/index.js

@@ -1 +0,0 @@
-export { PropertyValues } from './property-values.js';

package/dist/v1/language/core/index.d.ts

@@ -1,2 +0,0 @@
-export type * from './model/core.js';
-export type * from './resolved.js';

package/dist/v1/language/core/index.js

@@ -1 +0,0 @@
-export {};

package/dist/v1/language/value/index.d.ts

@@ -1,11 +0,0 @@
-/** Complete V1 inline value language. Named Type Definitions do not exist. */
-export type { JsonSchema as ValueSchema, JsonSchemaObject as ValueSchemaObject, PathAnnotation, PropertyObjectSchema, ValueSchemaContext, } from './model/schema.js';
-export { JSON_SCHEMA_DIALECT, VALUE_SCHEMA_DIALECT, VALUE_SCHEMA_VOCABULARY, } from './model/schema.js';
-export { instant, isInstantValue } from './model/instant.js';
-export { classifyOrdering, classifyValueKind, type OrderingKind } from './ordering.js';
-export { canonicalizeValueSchema } from './profile/canonicalize.js';
-export { validateValueSchema } from './profile/validate.js';
-export { validateJsonInstance } from './evaluate/validate.js';
-export { prepareValueSchema, type InstanceSchemaCompilation } from './evaluate/preparation.js';
-export type { ValueProgram } from './compile/model.js';
-export type { ValueSchemaRegistry, ValueSchemaDomainRegistry } from './reference/registry.js';

package/dist/v1/language/value/index.js

@@ -1,8 +0,0 @@
-/** Complete V1 inline value language. Named Type Definitions do not exist. */
-export { JSON_SCHEMA_DIALECT, VALUE_SCHEMA_DIALECT, VALUE_SCHEMA_VOCABULARY, } from './model/schema.js';
-export { instant, isInstantValue } from './model/instant.js';
-export { classifyOrdering, classifyValueKind } from './ordering.js';
-export { canonicalizeValueSchema } from './profile/canonicalize.js';
-export { validateValueSchema } from './profile/validate.js';
-export { validateJsonInstance } from './evaluate/validate.js';
-export { prepareValueSchema } from './evaluate/preparation.js';