@astrale-os/kernel-dsl 0.2.0-beta.9 → 1.0.0-beta.1

package/dist/v1/compiled/admission/closure.d.ts

@@ -0,0 +1,3 @@
+import { type CompiledSchema } from '../model/schema.js';
+/** Require closed direct references, acyclic inheritance and concrete Core Classes. */
+export declare function validateClosure(candidate: CompiledSchema): void;

package/dist/v1/compiled/admission/closure.js

@@ -0,0 +1,173 @@
+import {} from '@astrale-os/kernel-dsl/value';
+import { dependencyLimits } from '../../addressing/domain-dependency.js';
+import { Key, isDefinitionRef } from '../../addressing/index.js';
+import {} from '../../language/class/model/edge.js';
+import {} from '../model/schema.js';
+import { invalid, pointer } from './diagnostic.js';
+/** Require closed direct references, acyclic inheritance and concrete Core Classes. */
+export function validateClosure(candidate) {
+    validateDependencyCycles(candidate);
+    const definitions = new Map();
+    for (const [entryIndex, entry] of candidate.closure.entries()) {
+        const collections = [
+            ['classes', entry.definitions.classes],
+            ['functions', entry.definitions.functions],
+            ['policies', entry.definitions.policies],
+            ['views', entry.definitions.views],
+            ['core', entry.definitions.core],
+        ];
+        for (const [collection, values] of collections) {
+            for (const [definitionIndex, definition] of values.entries()) {
+                const path = `/closure/${entryIndex}/definitions/${collection}/${definitionIndex}`;
+                const key = Key.of(definition.ref);
+                if (definitions.has(key))
+                    invalid('duplicate Definition', undefined, `${path}/ref`);
+                definitions.set(key, { value: definition, path });
+            }
+        }
+    }
+    const requireDefinition = (ref, label, path) => {
+        const result = definitions.get(Key.of(ref));
+        if (result === undefined)
+            invalid(label, 'COMPILED_SOURCE_INVALID', path);
+        return result.value;
+    };
+    for (const [entryIndex, entry] of candidate.closure.entries()) {
+        const visibleOrigins = new Set([
+            entry.origin,
+            ...Object.values(entry.dependencies).map(({ origin }) => origin),
+        ]);
+        const collections = [
+            ['definitions/classes', entry.definitions.classes],
+            ['definitions/functions', entry.definitions.functions],
+            ['definitions/policies', entry.definitions.policies],
+            ['definitions/views', entry.definitions.views],
+            ['definitions/core', entry.definitions.core],
+            ['facts/core', entry.facts.core],
+        ];
+        for (const [collection, values] of collections) {
+            for (const [definitionIndex, definition] of values.entries()) {
+                walk(definition, `/closure/${entryIndex}/${collection}/${definitionIndex}`, (ref, path) => {
+                    const resolved = requireDefinition(ref, 'unresolved Definition ref', path);
+                    if (!visibleOrigins.has(ref.origin))
+                        invalid('non-direct dependency ref', 'COMPILED_SOURCE_INVALID', path);
+                    if (resolved.ref === undefined)
+                        invalid('resolved Definition', 'COMPILED_SOURCE_INVALID', path);
+                });
+            }
+        }
+    }
+    const classes = new Map();
+    for (const [entryIndex, entry] of candidate.closure.entries())
+        for (const [classIndex, definition] of entry.definitions.classes.entries())
+            classes.set(Key.of(definition.ref), {
+                value: definition,
+                path: `/closure/${entryIndex}/definitions/classes/${classIndex}`,
+            });
+    const visiting = new Set();
+    const visited = new Set();
+    const visitClass = (key) => {
+        if (visited.has(key))
+            return;
+        if (visiting.has(key))
+            invalid('Class inheritance cycle', 'COMPILED_SOURCE_INVALID', `${classes.get(key)?.path ?? ''}/extends`);
+        const definition = classes.get(key);
+        if (definition === undefined)
+            invalid('Class inheritance ref', 'COMPILED_SOURCE_INVALID', '/closure');
+        visiting.add(key);
+        for (const [parentIndex, parentRef] of definition.value.extends.entries()) {
+            const parent = classes.get(Key.of(parentRef));
+            if (parent === undefined || parent.value.kind !== definition.value.kind) {
+                invalid('Class inheritance kind', 'COMPILED_SOURCE_INVALID', `${definition.path}/extends/${parentIndex}`);
+            }
+            visitClass(Key.of(parentRef));
+        }
+        visiting.delete(key);
+        visited.add(key);
+    };
+    for (const key of classes.keys())
+        visitClass(key);
+    for (const definition of classes.values()) {
+        if (definition.value.kind !== 'edge')
+            continue;
+        const endpoints = definition.value.orientation === 'directed'
+            ? [
+                definition.value.endpoints.source,
+                definition.value.endpoints.target,
+            ]
+            : definition.value.endpoints;
+        for (const [endpointIndex, endpoint] of endpoints.entries()) {
+            const endpointPath = definition.value.orientation === 'directed'
+                ? `${definition.path}/endpoints/${endpointIndex === 0 ? 'source' : 'target'}`
+                : `${definition.path}/endpoints/${endpointIndex}`;
+            for (const [acceptedIndex, accepted] of endpoint.accepts.entries()) {
+                if (classes.get(Key.of(accepted))?.value.kind !== 'node') {
+                    invalid('Edge endpoint Class', 'COMPILED_SOURCE_INVALID', `${endpointPath}/accepts/${acceptedIndex}`);
+                }
+            }
+        }
+    }
+    for (const [entryIndex, entry] of candidate.closure.entries()) {
+        for (const [definitionIndex, definition] of entry.definitions.core.entries()) {
+            const owner = classes.get(Key.of(definition.class));
+            if (owner?.value.kind !== 'node' || owner.value.abstract) {
+                invalid('Core exact Class', 'COMPILED_SOURCE_INVALID', `/closure/${entryIndex}/definitions/core/${definitionIndex}/class`);
+            }
+        }
+        for (const [edgeIndex, edge] of entry.facts.core.entries()) {
+            const owner = classes.get(Key.of(edge.class));
+            if (owner?.value.kind !== 'edge' || owner.value.abstract) {
+                invalid('Core Edge exact Class', 'COMPILED_SOURCE_INVALID', `/closure/${entryIndex}/facts/core/${edgeIndex}/class`);
+            }
+        }
+    }
+}
+function validateDependencyCycles(candidate) {
+    const byOrigin = new Map(candidate.closure.map((entry, index) => [entry.origin, { entry, index }]));
+    const active = new Set();
+    const visited = new Set();
+    const frames = [];
+    const push = (origin, depth) => {
+        if (depth > dependencyLimits.depth) {
+            invalid('dependency depth limit', 'COMPILED_DEPENDENCY_LIMITS', `/closure/${byOrigin.get(origin)?.index ?? 0}/dependencies`);
+        }
+        active.add(origin);
+        frames.push({
+            origin,
+            depth,
+            dependencies: Object.values(byOrigin.get(origin)?.entry.dependencies ?? {}),
+            index: 0,
+        });
+    };
+    push(candidate.root.origin, 0);
+    while (frames.length > 0) {
+        const frame = frames.at(-1);
+        const dependency = frame.dependencies[frame.index++];
+        if (dependency === undefined) {
+            frames.pop();
+            active.delete(frame.origin);
+            visited.add(frame.origin);
+            continue;
+        }
+        if (active.has(dependency.origin)) {
+            invalid('dependency cycle', 'COMPILED_DEPENDENCY_CYCLE', `/closure/${byOrigin.get(dependency.origin)?.index ?? 0}/dependencies`);
+        }
+        if (!visited.has(dependency.origin))
+            push(dependency.origin, frame.depth + 1);
+    }
+}
+function walk(input, path, visit) {
+    if (isDefinitionRef(input)) {
+        visit(input, path);
+        return;
+    }
+    if (input === null || typeof input !== 'object')
+        return;
+    if (Array.isArray(input)) {
+        for (const [index, value] of input.entries())
+            walk(value, `${path}/${index}`, visit);
+        return;
+    }
+    for (const [key, value] of Object.entries(input))
+        walk(value, pointer(path, key), visit);
+}

package/dist/v1/compiled/admission/diagnostic.d.ts

@@ -0,0 +1,7 @@
+import { type CompiledDiagnosticCode } from '../diagnostic.js';
+/** Append one escaped JSON Pointer segment. */
+export declare function pointer(parent: string, member: string | number): string;
+/** Report a structural compiled-input violation with its stable diagnostic code. */
+export declare function invalid(label: string, code?: CompiledDiagnosticCode, path?: string): never;
+/** Report a contextual compiled-language violation at its original source pointer. */
+export declare function fail(pointer: string, message: string): never;

package/dist/v1/compiled/admission/diagnostic.js

@@ -0,0 +1,13 @@
+import { invalidCompiled } from '../diagnostic.js';
+/** Append one escaped JSON Pointer segment. */
+export function pointer(parent, member) {
+    return `${parent}/${String(member).replaceAll('~', '~0').replaceAll('/', '~1')}`;
+}
+/** Report a structural compiled-input violation with its stable diagnostic code. */
+export function invalid(label, code = 'COMPILED_STRUCTURE_INVALID', path = '') {
+    return invalidCompiled(code, `Invalid compiled Schema ${label}.`, path);
+}
+/** Report a contextual compiled-language violation at its original source pointer. */
+export function fail(pointer, message) {
+    return invalidCompiled('COMPILED_SOURCE_INVALID', message, pointer);
+}

package/dist/v1/compiled/admission/revision.js

@@ -9,6 +9,8 @@ function revisionPreimage(entry) {
         format: 'astrale.dsl',
         version: 'v1',
         origin: entry.origin,
+        name: entry.name,
+        ...(entry.entrypoint === undefined ? {} : { entrypoint: entry.entrypoint }),
         dependencies: entry.dependencies,
         classes: Object.fromEntries(entry.definitions.classes.map((definition) => [
             definition.ref.name,
@@ -54,7 +56,13 @@ function sourceFunction(entry, definition) {
     const { input, fields: _, output, ...rest } = definition;
     return {
         ...rest,
-        input: schemaOf(entry, input),
+        input: typeof input === 'number'
+            ? schemaOf(entry, input)
+            : {
+                mode: 'binary',
+                metadata: schemaOf(entry, input.metadata),
+                maximumBytes: input.maximumBytes,
+            },
         output: sourceOutput(entry, output),
     };
 }

package/dist/v1/compiled/admission/semantics/cardinality.d.ts

@@ -0,0 +1,5 @@
+import { type CompiledSchemaEntry } from '../../model/schema.js';
+import { type SemanticIndex } from './context.js';
+import { type CoreNode, type CoreEdgeValue } from './core.js';
+/** Check normalized Edge uniqueness, noSelf, cycles and complete Core degrees. */
+export declare function validateCoreEdgeSet(context: SemanticIndex, entry: CompiledSchemaEntry, entryIndex: number, nodes: ReadonlyMap<string, CoreNode>, edges: readonly CoreEdgeValue[]): void;

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

@@ -0,0 +1,113 @@
+import { Key } from '../../../addressing/index.js';
+import { compareUnicode } from '../../../addressing/ordering.js';
+import {} from '../../../language/class/model/edge.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 uniqueness, 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.');
+    }
+    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/class.d.ts

@@ -0,0 +1,5 @@
+import { type Located, type CompiledClass, type ClassAnalysis, type SemanticIndex } from './context.js';
+/** Compose inherited Properties, Methods and Data ownership once per Class. */
+export declare function analyzeClasses(classes: ReadonlyMap<string, Located<CompiledClass>>): ReadonlyMap<string, ClassAnalysis>;
+/** Check automatic Properties, immutability and abstract Class obligations. */
+export declare function validateClassFacets(context: SemanticIndex): void;

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

@@ -0,0 +1,125 @@
+import { json } from '@astrale-os/kernel-dsl/value';
+import { Key, PropertyKey as PropertyKeyValue, } from '../../../addressing/index.js';
+import { composeMethods } from '../../../language/callable/composition.js';
+import { isMethodExecutable } from '../../../language/callable/executable.js';
+import { bindValueProgram } from '../../../language/value/compile/load.js';
+import {} from '../../model/schema.js';
+import { fail } from '../diagnostic.js';
+import {} from './context.js';
+/** Compose inherited Properties, Methods and Data ownership once per Class. */
+export function analyzeClasses(classes) {
+    const analyses = new Map();
+    const visiting = new Set();
+    const analyze = (located) => {
+        const classKey = Key.of(located.value.ref);
+        const cached = analyses.get(classKey);
+        if (cached !== undefined)
+            return cached;
+        if (visiting.has(classKey))
+            fail(`${located.pointer}/extends`, 'Class inheritance is cyclic.');
+        visiting.add(classKey);
+        const parents = located.value.extends.map((ref, index) => {
+            const parent = classes.get(Key.of(ref));
+            if (parent === undefined)
+                fail(`${located.pointer}/extends/${index}`, 'Parent Class is absent.');
+            return analyze(parent);
+        });
+        const properties = new Map();
+        for (const parent of parents)
+            for (const [key, value] of parent.properties)
+                properties.set(key, value);
+        for (const property of located.value.properties) {
+            const key = PropertyKeyValue.of(located.value.ref, property.name);
+            properties.set(key, {
+                key,
+                owner: located.value.ref,
+                declaration: property,
+                entry: located.entry,
+            });
+        }
+        let dataOwner;
+        for (const parent of parents) {
+            if (parent.dataOwner === undefined)
+                continue;
+            if (dataOwner !== undefined && Key.of(dataOwner) !== Key.of(parent.dataOwner)) {
+                fail(located.pointer, 'Data has distinct inherited declaring owners.');
+            }
+            dataOwner = parent.dataOwner;
+        }
+        if (located.value.kind === 'node' && located.value.data !== undefined) {
+            if (dataOwner !== undefined)
+                fail(`${located.pointer}/data`, 'Data cannot redeclare an inherited contract.');
+            dataOwner = located.value.ref;
+        }
+        const own = new Map((located.value.kind === 'node' ? located.value.methods : []).map((method) => [
+            method.name,
+            {
+                key: `${classKey}.method.${method.name}`,
+                name: method.name,
+                owner: located.value.ref,
+                declaration: method,
+                entry: located.entry,
+            },
+        ]));
+        const composition = composeMethods(parents, own, located.value.abstract, (left, right) => sameMethodSignature(left.entry, left.declaration, right.entry, right.declaration), (message) => fail(`${located.pointer}/methods`, message));
+        const analysis = {
+            properties,
+            ...composition,
+            ...(dataOwner === undefined ? {} : { dataOwner }),
+        };
+        analyses.set(classKey, analysis);
+        visiting.delete(classKey);
+        return analysis;
+    };
+    for (const value of classes.values())
+        analyze(value);
+    return analyses;
+}
+function sameMethodSignature(leftEntry, left, rightEntry, right) {
+    return (programKey(leftEntry, left.input) === programKey(rightEntry, right.input) &&
+        outputKey(leftEntry, left.output) === outputKey(rightEntry, right.output) &&
+        left.auth === right.auth &&
+        left.static === right.static &&
+        left.execution?.durable === right.execution?.durable);
+}
+function outputKey(entry, output) {
+    return output.mode === 'binary' ? 'binary' : `${output.mode}:${programKey(entry, output.value)}`;
+}
+function programKey(entry, value) {
+    return json.serialize(bindValueProgram(entry.values[value], entry.patterns));
+}
+/** Check automatic Properties, immutability and abstract Class obligations. */
+export function validateClassFacets(context) {
+    for (const located of context.classes.values()) {
+        if (located.value.abstract &&
+            (located.value.policies.read !== undefined || located.value.policies.traverse !== undefined)) {
+            fail(`${located.pointer}/policies`, 'Abstract Classes cannot declare observation Policies.');
+        }
+        for (const [index, property] of located.value.properties.entries()) {
+            const path = `${located.pointer}/properties/${index}`;
+            if (property.auto !== undefined) {
+                if (property.required && !property.auto.on.includes('create')) {
+                    fail(`${path}/auto/on`, 'A required auto Property must run on create.');
+                }
+                if (property.auto.set === 'instant' && property.ordering !== 'instant') {
+                    fail(`${path}/auto/set`, 'The instant setter requires an Instant value program.');
+                }
+            }
+            if (property.immutable !== undefined) {
+                if (property.auto !== undefined || property.state !== undefined) {
+                    fail(`${path}/immutable`, 'An immutable Property is neither automatic nor a State Property.');
+                }
+                if (property.immutable === 'once' && property.required) {
+                    fail(`${path}/immutable`, 'A required immutable Property is declared create, not once.');
+                }
+            }
+        }
+        if (located.value.kind === 'node') {
+            for (const [index, method] of located.value.methods.entries()) {
+                if (!isMethodExecutable(located.value, method) && method.policy !== undefined) {
+                    fail(`${located.pointer}/methods/${index}/policy`, 'An abstract Method cannot have a Policy.');
+                }
+            }
+        }
+    }
+}

package/dist/v1/compiled/admission/semantics/context.d.ts

@@ -0,0 +1,60 @@
+import { type PropertyKey, type ClassRef, type DefinitionRef } from '../../../addressing/index.js';
+import { type MethodComposition } from '../../../language/callable/composition.js';
+import { type EdgeClassDefinition } from '../../../language/class/model/class.js';
+import { type CompiledSchemaEntry, type CompiledProperty, type CompiledMethod, type CompiledSchema } from '../../model/schema.js';
+/** One decoded Class declaration in a compiled entry. */
+export type CompiledClass = CompiledSchemaEntry['definitions']['classes'][number];
+/** The Edge variant of a decoded Class declaration. */
+export type CompiledEdge = EdgeClassDefinition extends infer Definition ? Definition extends EdgeClassDefinition ? Omit<Definition, 'properties'> & {
+    readonly properties: readonly CompiledProperty[];
+} : never : never;
+/** One decoded named Policy declaration. */
+export type CompiledPolicy = CompiledSchemaEntry['definitions']['policies'][number];
+/** A declaration together with its owner and exact diagnostic coordinates. */
+export interface Located<Value> {
+    readonly value: Value;
+    readonly entry: CompiledSchemaEntry;
+    readonly entryIndex: number;
+    readonly index: number;
+    readonly pointer: string;
+}
+/** An inherited Property together with its declaring owner and value program. */
+export interface EffectiveProperty {
+    readonly key: PropertyKey;
+    readonly owner: ClassRef;
+    readonly declaration: CompiledProperty;
+    readonly entry: CompiledSchemaEntry;
+}
+/** An inherited Method together with its declaring owner and value program. */
+export interface EffectiveMethod {
+    readonly name: string;
+    readonly key: string;
+    readonly owner: ClassRef;
+    readonly declaration: CompiledMethod;
+    readonly entry: CompiledSchemaEntry;
+}
+/** The effective Properties, Methods and Data owner of one Class. */
+export interface ClassAnalysis extends MethodComposition<EffectiveMethod> {
+    readonly properties: ReadonlyMap<PropertyKey, EffectiveProperty>;
+    readonly dataOwner?: ClassRef;
+}
+/** Closure-wide declaration indexes and composed Class contracts. */
+export interface SemanticIndex {
+    readonly definitions: ReadonlyMap<string, Located<DefinitionRef>>;
+    readonly classes: ReadonlyMap<string, Located<CompiledClass>>;
+    readonly policies: ReadonlyMap<string, Located<CompiledPolicy>>;
+    readonly core: ReadonlyMap<string, Located<CompiledSchemaEntry['definitions']['core'][number]>>;
+    readonly analyses: ReadonlyMap<string, ClassAnalysis>;
+}
+/** Index declarations by exact coordinates while retaining their source pointers. */
+export declare function index(candidate: CompiledSchema): Omit<SemanticIndex, 'analyses'>;
+/**
+ * The origins each closure entry was admitted against: itself and its transitive dependencies.
+ * Source admission types Policies within that closure alone, so a
+ * dependent's Class extending a dependency's Classes never reaches the dependency's own decisions.
+ */
+export declare function admittedOrigins(candidate: CompiledSchema): ReadonlyMap<string, ReadonlySet<string>>;
+/** Decide whether a Class satisfies any accepted ancestor contract. */
+export declare function classSatisfiesAny(context: SemanticIndex, candidate: ClassRef, accepted: readonly ClassRef[]): boolean;
+/** Narrow a compiled Class to its Edge contract. */
+export declare function isCompiledEdge(value: CompiledClass): value is CompiledEdge;

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

@@ -0,0 +1,81 @@
+import { Key, } from '../../../addressing/index.js';
+import {} from '../../../language/callable/composition.js';
+import { classSatisfies } from '../../../language/class/inheritance.js';
+import {} from '../../../language/class/model/class.js';
+import {} from '../../model/schema.js';
+/** Index declarations by exact coordinates while retaining their source pointers. */
+export function index(candidate) {
+    const definitions = new Map();
+    const classes = new Map();
+    const policies = new Map();
+    const core = new Map();
+    for (const [entryIndex, entry] of candidate.closure.entries()) {
+        const collections = [
+            ['classes', entry.definitions.classes],
+            ['functions', entry.definitions.functions],
+            ['policies', entry.definitions.policies],
+            ['views', entry.definitions.views],
+            ['core', entry.definitions.core],
+        ];
+        for (const [collection, values] of collections) {
+            for (const [valueIndex, value] of values.entries()) {
+                const located = {
+                    value,
+                    entry,
+                    entryIndex,
+                    index: valueIndex,
+                    pointer: `/closure/${entryIndex}/definitions/${collection}/${valueIndex}`,
+                };
+                definitions.set(Key.of(value.ref), {
+                    ...located,
+                    value: value.ref,
+                });
+                if (value.ref.kind === 'class')
+                    classes.set(Key.of(value.ref), located);
+                if (value.ref.kind === 'policy')
+                    policies.set(Key.of(value.ref), located);
+                if (value.ref.kind === 'core')
+                    core.set(Key.of(value.ref), located);
+            }
+        }
+    }
+    return { definitions, classes, policies, core };
+}
+/**
+ * The origins each closure entry was admitted against: itself and its transitive dependencies.
+ * Source admission types Policies within that closure alone, so a
+ * dependent's Class extending a dependency's Classes never reaches the dependency's own decisions.
+ */
+export function admittedOrigins(candidate) {
+    const entries = new Map(candidate.closure.map((entry) => [entry.origin, entry]));
+    const scopes = new Map();
+    const scope = (origin) => {
+        const known = scopes.get(origin);
+        if (known !== undefined)
+            return known;
+        const origins = new Set([origin]);
+        for (const dependency of Object.values(entries.get(origin)?.dependencies ?? {}))
+            for (const reached of scope(dependency.origin))
+                origins.add(reached);
+        scopes.set(origin, origins);
+        return origins;
+    };
+    for (const entry of candidate.closure)
+        scope(entry.origin);
+    return scopes;
+}
+/** Decide whether a Class satisfies any accepted ancestor contract. */
+export function classSatisfiesAny(context, candidate, accepted) {
+    const resolve = (ref) => context.classes.get(Key.of(ref))?.value;
+    const actual = resolve(candidate);
+    if (actual === undefined)
+        return false;
+    return accepted.some((ref) => {
+        const required = resolve(ref);
+        return required !== undefined && classSatisfies(actual, required, resolve);
+    });
+}
+/** Narrow a compiled Class to its Edge contract. */
+export function isCompiledEdge(value) {
+    return value.kind === 'edge';
+}

package/dist/v1/compiled/admission/semantics/core.d.ts

@@ -0,0 +1,35 @@
+import { type ClassRef } from '../../../addressing/index.js';
+import { type CoreEdge } from '../../../language/core/model/core.js';
+import { type CompiledSchemaEntry, type CompiledSchema } from '../../model/schema.js';
+import { type Located, type CompiledClass, type ClassAnalysis, type CompiledEdge, type SemanticIndex } from './context.js';
+/** A local Core Node paired with its admitted Class analysis. */
+export interface CoreNode {
+    readonly key: string;
+    readonly value: CompiledSchemaEntry['definitions']['core'][number];
+    readonly class: Located<CompiledClass>;
+    readonly analysis: ClassAnalysis;
+    readonly pointer: string;
+}
+/**
+ * A local Definition other than a Core Node, or a Class-owned Method. The Domain projects it as a
+ * Kernel declaration Node, so `class` names that Kernel Class rather than an authored one.
+ */
+interface CoreMemberEndpoint {
+    readonly key: string;
+    readonly class: ClassRef;
+    readonly pointer: string;
+}
+type CoreEndpoint = CoreNode | CoreMemberEndpoint | {
+    readonly key: 'domain';
+};
+/** A Core Edge paired with resolved endpoints and its exact Class. */
+export interface CoreEdgeValue {
+    readonly source: CoreEndpoint;
+    readonly target: CoreEndpoint;
+    readonly value: CoreEdge;
+    readonly class: Located<CompiledEdge>;
+    readonly pointer: string;
+}
+/** Admit local Core Nodes, Properties and Edge endpoint contracts. */
+export declare function validateCore(candidate: CompiledSchema, context: SemanticIndex): void;
+export {};