@astrale-os/kernel-dsl 0.2.0-beta.47 → 0.2.0-beta.49

package/dist/v1/compiled/admission/wire/policy.js

@@ -0,0 +1,168 @@
+import {} from '@astrale-os/kernel-dsl/value';
+import { Key } from '../../../addressing/index.js';
+import { invalid, pointer } from '../diagnostic.js';
+import { definitionRef, policyObjectRef } from './reference.js';
+import { object, exact, description, array, unique, boundedInteger, integer, memberName, } from './value.js';
+/** Decode a named Policy and its expression grammar. */
+export function compiledPolicy(input, path) {
+    const value = object(input, 'Policy', path);
+    exact(value, ['ref', 'expression'], 'Policy', path, ['description']);
+    definitionRef(value.ref, 'policy', 'Policy ref', `${path}/ref`);
+    description(value.description, 'Policy description', `${path}/description`);
+    policyExpression(value.expression, 0, `${path}/expression`);
+    return value;
+}
+function policyExpression(input, depth, path) {
+    if (depth > 64)
+        invalid('Policy expression depth', undefined, path);
+    const value = object(input, 'Policy expression', path);
+    if (Object.hasOwn(value, 'match')) {
+        exact(value, ['match'], 'Policy expression', path);
+        policyPattern(value.match, depth + 1, `${path}/match`);
+        return;
+    }
+    const member = Object.hasOwn(value, 'allOf') ? 'allOf' : 'anyOf';
+    exact(value, [member], 'Policy expression', path);
+    const memberPath = pointer(path, member);
+    const refs = array(value[member], `Policy ${member}`, memberPath).map((item, index) => definitionRef(item, 'policy', `Policy ${member} ref`, `${memberPath}/${index}`));
+    if (refs.length === 0)
+        invalid(`Policy ${member}`, undefined, memberPath);
+    unique(refs.map(Key.of), `Policy ${member}`, memberPath);
+}
+function policyPattern(input, depth, path) {
+    if (depth > 64)
+        invalid('Policy pattern depth', undefined, path);
+    const value = object(input, 'Policy pattern', path);
+    if (Object.hasOwn(value, 'sameNode')) {
+        exact(value, ['sameNode'], 'Policy equality', path);
+        const pair = object(value.sameNode, 'Policy equality', `${path}/sameNode`);
+        exact(pair, ['left', 'right'], 'Policy equality operands', `${path}/sameNode`);
+        policyTerm(pair.left, false, `${path}/sameNode/left`);
+        policyTerm(pair.right, false, `${path}/sameNode/right`);
+        return;
+    }
+    if (Object.hasOwn(value, 'exists')) {
+        exact(value, ['exists'], 'Policy exists', path);
+        const existsPath = `${path}/exists`;
+        const exists = object(value.exists, 'Policy exists', existsPath);
+        exact(exists, ['nodes', 'where'], 'Policy exists', existsPath);
+        const nodesPath = `${existsPath}/nodes`;
+        const nodes = array(exists.nodes, 'Policy variables', nodesPath);
+        if (nodes.length < 1 || nodes.length > 4)
+            invalid('Policy variables', undefined, nodesPath);
+        for (const [index, node] of nodes.entries()) {
+            const variablePath = `${nodesPath}/${index}`;
+            const variable = object(node, 'Policy variable', variablePath);
+            policyTerm(variable.variable, true, `${variablePath}/variable`);
+            if (Object.hasOwn(variable, 'class')) {
+                exact(variable, ['variable', 'class'], 'Policy variable', variablePath);
+                definitionRef(variable.class, 'class', 'Policy variable Class', `${variablePath}/class`);
+            }
+            else {
+                exact(variable, ['variable', 'selector'], 'Policy variable', variablePath);
+                const selectorPath = `${variablePath}/selector`;
+                const selector = object(variable.selector, 'Policy variable selector', selectorPath);
+                if (selector.kind === 'any') {
+                    exact(selector, ['kind'], 'Policy variable selector', selectorPath);
+                }
+                else if (selector.kind === 'satisfies') {
+                    exact(selector, ['kind', 'class'], 'Policy variable selector', selectorPath);
+                    definitionRef(selector.class, 'class', 'Policy variable selector Class', `${selectorPath}/class`);
+                }
+                else {
+                    invalid('Policy variable selector kind', undefined, `${selectorPath}/kind`);
+                }
+            }
+        }
+        policyPattern(exists.where, depth + 1, `${existsPath}/where`);
+        return;
+    }
+    if (Object.hasOwn(value, 'allOf') || Object.hasOwn(value, 'anyOf')) {
+        const member = Object.hasOwn(value, 'allOf') ? 'allOf' : 'anyOf';
+        exact(value, [member], 'Policy pattern composition', path);
+        const memberPath = pointer(path, member);
+        const expressions = array(value[member], `Policy pattern ${member}`, memberPath);
+        if (expressions.length === 0)
+            invalid(`Policy pattern ${member}`, undefined, memberPath);
+        for (const [index, expression] of expressions.entries())
+            policyPattern(expression, depth + 1, `${memberPath}/${index}`);
+        return;
+    }
+    exact(value, ['source', 'class', 'target'], 'Policy Edge pattern', path, ['repeat']);
+    policyTerm(value.source, false, `${path}/source`);
+    definitionRef(value.class, 'class', 'Policy Edge Class', `${path}/class`);
+    policyTerm(value.target, false, `${path}/target`);
+    if (value.repeat !== undefined) {
+        const repeatPath = `${path}/repeat`;
+        const repeat = object(value.repeat, 'Policy repeat', repeatPath);
+        exact(repeat, ['min', 'max'], 'Policy repeat', repeatPath);
+        const minimum = boundedInteger(repeat.min, 0, 3, 'Policy repeat minimum', `${repeatPath}/min`);
+        const maximum = boundedInteger(repeat.max, 0, 3, 'Policy repeat maximum', `${repeatPath}/max`);
+        if (minimum > maximum)
+            invalid('Policy repeat order', undefined, repeatPath);
+    }
+}
+function policyTerm(input, variableOnly, path) {
+    const value = object(input, 'Policy pattern term', path);
+    if (!variableOnly && value.kind === 'ref') {
+        exact(value, ['kind', 'ref'], 'Policy reference term', path);
+        policyObjectRef(value.ref, `${path}/ref`);
+        return;
+    }
+    if (value.kind === 'variable') {
+        exact(value, ['kind', 'id'], 'Policy variable term', path);
+        integer(value.id, 'Policy variable id', `${path}/id`);
+        return;
+    }
+    if (variableOnly ||
+        (value.kind !== 'subject' &&
+            value.kind !== 'object' &&
+            value.kind !== 'source' &&
+            value.kind !== 'target')) {
+        invalid('Policy pattern term', undefined, `${path}/kind`);
+    }
+    exact(value, ['kind'], 'Policy pattern term', path);
+}
+/** Check the recursive callable Policy wire grammar. */
+export function policyCheck(input, depth, path) {
+    if (depth > 64)
+        invalid('Callable Policy depth', undefined, path);
+    const value = object(input, 'Callable Policy', path);
+    if (Object.hasOwn(value, 'sameNode')) {
+        exact(value, ['sameNode'], 'Callable equality', path);
+        const pair = object(value.sameNode, 'Callable equality', `${path}/sameNode`);
+        exact(pair, ['left', 'right'], 'Callable equality operands', `${path}/sameNode`);
+        policyCheckObject(pair.left, `${path}/sameNode/left`);
+        policyCheckObject(pair.right, `${path}/sameNode/right`);
+        return;
+    }
+    if (Object.hasOwn(value, 'check')) {
+        exact(value, ['check', 'object'], 'Callable Policy check', path);
+        definitionRef(value.check, 'policy', 'Callable Policy ref', `${path}/check`);
+        policyCheckObject(value.object, `${path}/object`);
+        return;
+    }
+    const member = Object.hasOwn(value, 'allOf') ? 'allOf' : 'anyOf';
+    exact(value, [member], 'Callable Policy composition', path);
+    const memberPath = pointer(path, member);
+    const expressions = array(value[member], `Callable Policy ${member}`, memberPath);
+    if (expressions.length === 0)
+        invalid(`Callable Policy ${member}`, undefined, memberPath);
+    for (const [index, expression] of expressions.entries())
+        policyCheck(expression, depth + 1, `${memberPath}/${index}`);
+}
+function policyCheckObject(input, objectPath) {
+    const target = object(input, 'Callable Policy object', objectPath);
+    if (target.kind === 'self')
+        exact(target, ['kind'], 'Callable Policy self', objectPath);
+    else if (target.kind === 'input') {
+        exact(target, ['kind', 'field'], 'Callable Policy input', objectPath);
+        memberName(target.field, 'Callable Policy input field', `${objectPath}/field`);
+    }
+    else if (target.kind === 'ref') {
+        exact(target, ['kind', 'ref'], 'Callable Policy object ref', objectPath);
+        policyObjectRef(target.ref, `${objectPath}/ref`);
+    }
+    else
+        invalid('Callable Policy object', undefined, `${objectPath}/kind`);
+}

package/dist/v1/compiled/admission/wire/program.d.ts

@@ -0,0 +1,4 @@
+import { type Value as JsonValue } from '@astrale-os/kernel-dsl/value';
+import { type Pattern, type RunPattern, type IndexedValueProgram } from '../../model/schema.js';
+/** Decode a value program and validate its local node and pattern indices. */
+export declare function program(input: JsonValue, programIndex: number, path: string, table: readonly (Pattern | RunPattern)[]): IndexedValueProgram;

package/dist/v1/compiled/admission/wire/program.js

@@ -0,0 +1,52 @@
+import {} from '@astrale-os/kernel-dsl/value';
+import { isValueObject } from '../../../language/value/model/object.js';
+import {} from '../../model/schema.js';
+import { invalid, pointer } from '../diagnostic.js';
+import { object, exact, array, index, unique, integer } from './value.js';
+/** Decode a value program and validate its local node and pattern indices. */
+export function program(input, programIndex, path, table) {
+    const value = object(input, `values[${programIndex}]`, path);
+    exact(value, ['root', 'nodes', 'patterns'], 'ValueProgram', path);
+    const nodesPath = `${path}/nodes`;
+    const nodes = array(value.nodes, 'ValueProgram nodes', nodesPath).map((node, index) => valueNode(node, index, `${nodesPath}/${index}`));
+    const root = index(value.root, nodes.length, 'ValueProgram root', `${path}/root`);
+    const patternsPath = `${path}/patterns`;
+    const patterns = array(value.patterns, 'ValueProgram patterns', patternsPath).map((item, position) => index(item, table.length, 'ValueProgram pattern', `${patternsPath}/${position}`));
+    const sources = patterns.map((index) => table[index].source);
+    unique(sources, 'patterns', patternsPath);
+    const available = new Set(sources);
+    for (const [nodeIndex, node] of nodes.entries()) {
+        if (isValueObject(node.schema)) {
+            const required = [node.schema.pattern, node.schema.fullMatch];
+            if (isValueObject(node.schema.patternProperties)) {
+                required.push(...Object.keys(node.schema.patternProperties));
+            }
+            for (const source of required) {
+                if (typeof source === 'string' && !available.has(source)) {
+                    invalid('ValueProgram pattern binding', undefined, patternsPath);
+                }
+            }
+        }
+        for (const [name, child] of Object.entries(node.children))
+            index(child, nodes.length, 'ValueNode child', pointer(`${nodesPath}/${nodeIndex}/children`, name));
+        if (node.reference !== undefined)
+            index(node.reference, nodes.length, 'ValueNode reference', `${nodesPath}/${nodeIndex}/reference`);
+    }
+    return { root, nodes, patterns };
+}
+function valueNode(input, nodeIndex, path) {
+    const value = object(input, `nodes[${nodeIndex}]`, path);
+    exact(value, ['schema', 'children'], 'ValueNode', path, ['reference']);
+    const children = {};
+    const childrenPath = `${path}/children`;
+    for (const [name, child] of Object.entries(object(value.children, 'ValueNode children', childrenPath))) {
+        children[name] = integer(child, 'ValueNode child', pointer(childrenPath, name));
+    }
+    return {
+        schema: value.schema,
+        children,
+        ...(value.reference === undefined
+            ? {}
+            : { reference: integer(value.reference, 'reference', `${path}/reference`) }),
+    };
+}

package/dist/v1/compiled/admission/wire/property.d.ts

@@ -0,0 +1,4 @@
+import { type Value as JsonValue } from '@astrale-os/kernel-dsl/value';
+import { type ValueProgram, type CompiledClass } from '../../model/schema.js';
+/** Decode a Property and re-admit its State and ordering contracts. */
+export declare function compiledProperty(input: JsonValue, values: readonly ValueProgram[], node: boolean, path: string): CompiledClass['properties'][number];

package/dist/v1/compiled/admission/wire/property.js

@@ -0,0 +1,74 @@
+import {} from '@astrale-os/kernel-dsl/value';
+import {} from '../../../language/state/index.js';
+import { admitStateTopology } from '../../../language/state/topology.js';
+import { classifyValueProgramOrdering } from '../../../language/value/ordering.js';
+import {} from '../../model/schema.js';
+import { invalid } from '../diagnostic.js';
+import { object, exact, memberName, boolean, description, index, array, unique } from './value.js';
+/** Decode a Property and re-admit its State and ordering contracts. */
+export function compiledProperty(input, values, node, path) {
+    const value = object(input, 'Compiled Property', path);
+    exact(value, ['name', 'required', 'value'], 'Compiled Property', path, [
+        'auto',
+        'description',
+        'immutable',
+        'ordering',
+        'state',
+    ]);
+    memberName(value.name, 'Property name', `${path}/name`);
+    boolean(value.required, 'Property required', `${path}/required`);
+    description(value.description, 'Property description', `${path}/description`);
+    if (value.auto !== undefined)
+        propertyAuto(value.auto, `${path}/auto`);
+    if (value.immutable !== undefined && value.immutable !== 'create' && value.immutable !== 'once') {
+        invalid('Property immutability', undefined, `${path}/immutable`);
+    }
+    const valueIndex = index(value.value, values.length, 'Property value', `${path}/value`);
+    let state;
+    if (value.state !== undefined) {
+        if (!node)
+            invalid('Property state placement', 'COMPILED_SOURCE_INVALID', `${path}/state`);
+        let topology;
+        try {
+            topology = admitStateTopology(value.state);
+        }
+        catch {
+            invalid('Property state topology', 'COMPILED_SOURCE_INVALID', `${path}/state`);
+        }
+        const program = values[valueIndex];
+        const schema = program.nodes[program.root].schema;
+        const states = Object.keys(topology.transitions);
+        const schemaObject = schema;
+        const schemaMatches = schema !== null &&
+            typeof schema === 'object' &&
+            !Array.isArray(schema) &&
+            Object.keys(schemaObject).length === 2 &&
+            schemaObject.type === 'string' &&
+            Array.isArray(schemaObject.enum) &&
+            schemaObject.enum.length === states.length &&
+            schemaObject.enum.every((state, index) => state === states[index]);
+        if (!value.required || value.auto !== undefined || !schemaMatches) {
+            invalid('Property state contract', 'COMPILED_SOURCE_INVALID', `${path}/state`);
+        }
+        state = topology;
+    }
+    if (value.ordering !== classifyValueProgramOrdering(values[valueIndex])) {
+        invalid('Property ordering', 'COMPILED_CANONICAL_MISMATCH', `${path}/ordering`);
+    }
+    return {
+        ...value,
+        ...(state === undefined ? {} : { state }),
+    };
+}
+function propertyAuto(input, path) {
+    const value = object(input, 'Property auto', path);
+    exact(value, ['on', 'set'], 'Property auto', path);
+    const eventsPath = `${path}/on`;
+    const events = array(value.on, 'Property auto events', eventsPath);
+    if (events.length === 0 || events.some((event) => event !== 'create' && event !== 'update')) {
+        invalid('Property auto events', undefined, eventsPath);
+    }
+    unique(events.map(String), 'Property auto events', eventsPath);
+    if (value.set !== 'instant')
+        invalid('Property auto setter', undefined, `${path}/set`);
+}

package/dist/v1/compiled/admission/wire/reference.d.ts

@@ -0,0 +1,8 @@
+import { type Value as JsonValue } from '@astrale-os/kernel-dsl/value';
+import { type DefinitionRef } from '../../../addressing/index.js';
+/** Check a Domain or projected declaration endpoint. */
+export declare function coreEndpoint(input: JsonValue | undefined, label: string, path: string): void;
+/** Check a Policy reference to a projected declaration. */
+export declare function policyObjectRef(input: JsonValue | undefined, path: string): void;
+/** Require a canonical Definition coordinate of the expected kind. */
+export declare function definitionRef<Kind extends DefinitionRef['kind'] | undefined>(input: JsonValue | undefined, kind: Kind, label: string, path: string): DefinitionRef;

package/dist/v1/compiled/admission/wire/reference.js

@@ -0,0 +1,33 @@
+import {} from '@astrale-os/kernel-dsl/value';
+import { isDefinitionRef } from '../../../addressing/index.js';
+import { MEMBER_NAME_PATTERN } from '../../../addressing/patterns.js';
+import { invalid } from '../diagnostic.js';
+import { object, exact } from './value.js';
+/** Check a Domain or projected declaration endpoint. */
+export function coreEndpoint(input, label, path) {
+    const value = object(input, label, path);
+    if (value.kind === 'domain')
+        exact(value, ['kind'], label, path);
+    else
+        projectedMemberRef(value, label, path);
+}
+/** Check a Policy reference to a projected declaration. */
+export function policyObjectRef(input, path) {
+    projectedMemberRef(object(input, 'Policy object ref', path), 'Policy object ref', path);
+}
+function projectedMemberRef(ref, label, path) {
+    if (ref.kind !== 'method') {
+        definitionRef(ref, undefined, label, path);
+        return;
+    }
+    exact(ref, ['kind', 'owner', 'name'], `${label} Method`, path);
+    definitionRef(ref.owner, 'class', `${label} Method owner`, `${path}/owner`);
+    if (typeof ref.name !== 'string' || !MEMBER_NAME_PATTERN.test(ref.name))
+        invalid(`${label} Method name`, undefined, `${path}/name`);
+}
+/** Require a canonical Definition coordinate of the expected kind. */
+export function definitionRef(input, kind, label, path) {
+    if (!isDefinitionRef(input) || (kind !== undefined && input.kind !== kind))
+        invalid(label, undefined, path);
+    return input;
+}

package/dist/v1/compiled/admission/wire/value.d.ts

@@ -0,0 +1,29 @@
+import { type Value as JsonValue, type Object as JsonObject } from '@astrale-os/kernel-dsl/value';
+/** Require a portable Object at the named wire boundary. */
+export declare function object(input: JsonValue | undefined, label: string, path: string): JsonObject;
+/** Require a portable Array at the named wire boundary. */
+export declare function array(input: JsonValue | undefined, label: string, path: string): readonly JsonValue[];
+/** Reject unknown and missing members in deterministic diagnostic order. */
+export declare function exact(value: JsonObject, required: readonly string[], label: string, path: string, optional?: readonly string[]): void;
+/** Require a non-negative safe integer. */
+export declare function integer(input: JsonValue | undefined, label: string, path: string): number;
+/** Require an integer within an inclusive interval. */
+export declare function boundedInteger(input: JsonValue | undefined, minimum: number, maximum: number, label: string, path: string): number;
+/** Require a Boolean wire value. */
+export declare function boolean(input: JsonValue | undefined, label: string, path: string): boolean;
+/** Require a String wire value. */
+export declare function string(input: JsonValue | undefined, label: string, path: string): string;
+/** Require a canonical declaration member name. */
+export declare function memberName(input: JsonValue | undefined, label: string, path: string): string;
+/** Check the length of an optional String member. */
+export declare function boundedString(input: JsonValue | undefined, minimum: number, maximum: number, label: string, path: string): void;
+/** Check the optional declaration description budget. */
+export declare function description(input: JsonValue | undefined, label: string, path: string): void;
+/** Reject the first repeated value at its exact index. */
+export declare function unique(values: readonly string[], label: string, path: string): void;
+/** Require an index within the referenced table. */
+export declare function index(input: JsonValue | undefined, length: number, label: string, path: string): number;
+/** Require a Unicode scalar-range bound. */
+export declare function scalar(input: JsonValue | undefined, label: string, path: string): number;
+/** Order wire names independently of the host locale. */
+export declare function compare(left: string, right: string): number;

package/dist/v1/compiled/admission/wire/value.js

@@ -0,0 +1,98 @@
+import {} from '@astrale-os/kernel-dsl/value';
+import { MEMBER_NAME_PATTERN } from '../../../addressing/patterns.js';
+import { invalid, pointer } from '../diagnostic.js';
+/** Require a portable Object at the named wire boundary. */
+export function object(input, label, path) {
+    if (input === null || typeof input !== 'object' || Array.isArray(input))
+        invalid(label, undefined, path);
+    return input;
+}
+/** Require a portable Array at the named wire boundary. */
+export function array(input, label, path) {
+    if (!Array.isArray(input))
+        invalid(label, undefined, path);
+    return input;
+}
+/** Reject unknown and missing members in deterministic diagnostic order. */
+export function exact(value, required, label, path, optional = []) {
+    const allowed = new Set([...required, ...optional]);
+    const unknown = Object.keys(value)
+        .filter((key) => !allowed.has(key))
+        .sort(compare)[0];
+    if (unknown !== undefined)
+        invalid(label, undefined, pointer(path, unknown));
+    const missing = required.find((key) => !Object.hasOwn(value, key));
+    if (missing !== undefined)
+        invalid(label, undefined, pointer(path, missing));
+}
+/** Require a non-negative safe integer. */
+export function integer(input, label, path) {
+    if (!Number.isSafeInteger(input) || input < 0)
+        invalid(label, undefined, path);
+    return input;
+}
+/** Require an integer within an inclusive interval. */
+export function boundedInteger(input, minimum, maximum, label, path) {
+    const value = integer(input, label, path);
+    if (value < minimum || value > maximum)
+        invalid(label, undefined, path);
+    return value;
+}
+/** Require a Boolean wire value. */
+export function boolean(input, label, path) {
+    if (typeof input !== 'boolean')
+        invalid(label, undefined, path);
+    return input;
+}
+/** Require a String wire value. */
+export function string(input, label, path) {
+    if (typeof input !== 'string')
+        invalid(label, undefined, path);
+    return input;
+}
+/** Require a canonical declaration member name. */
+export function memberName(input, label, path) {
+    const value = string(input, label, path);
+    if (!MEMBER_NAME_PATTERN.test(value))
+        invalid(label, undefined, path);
+    return value;
+}
+/** Check the length of an optional String member. */
+export function boundedString(input, minimum, maximum, label, path) {
+    if (input === undefined)
+        return;
+    const value = string(input, label, path);
+    if (value.length < minimum || value.length > maximum)
+        invalid(label, undefined, path);
+}
+/** Check the optional declaration description budget. */
+export function description(input, label, path) {
+    boundedString(input, 1, 1000, label, path);
+}
+/** Reject the first repeated value at its exact index. */
+export function unique(values, label, path) {
+    const seen = new Set();
+    for (const [indexValue, value] of values.entries()) {
+        if (seen.has(value))
+            invalid(label, undefined, `${path}/${indexValue}`);
+        seen.add(value);
+    }
+}
+/** Require an index within the referenced table. */
+export function index(input, length, label, path) {
+    const value = integer(input, label, path);
+    if (value >= length)
+        invalid(label, undefined, path);
+    return value;
+}
+/** Require a Unicode scalar-range bound. */
+export function scalar(input, label, path) {
+    const value = integer(input, label, path);
+    if (value > 0x10ffff)
+        invalid(label, undefined, path);
+    return value;
+}
+/** Order wire names independently of the host locale. */
+export function compare(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}

package/dist/v1/compiled/admission/wire/view.d.ts

@@ -0,0 +1,3 @@
+import { type Value as JsonValue } from '@astrale-os/kernel-dsl/value';
+/** Decode a View and its explicit target grammar. */
+export declare function compiledView(input: JsonValue, path: string): never;

package/dist/v1/compiled/admission/wire/view.js

@@ -0,0 +1,17 @@
+import {} from '@astrale-os/kernel-dsl/value';
+import { invalid } from '../diagnostic.js';
+import { definitionRef } from './reference.js';
+import { object, exact, description } from './value.js';
+/** Decode a View and its explicit target grammar. */
+export function compiledView(input, path) {
+    const value = object(input, 'View', path);
+    exact(value, ['ref', 'target'], 'View', path, ['description']);
+    definitionRef(value.ref, 'view', 'View ref', `${path}/ref`);
+    description(value.description, 'View description', `${path}/description`);
+    const targetPath = `${path}/target`;
+    const target = object(value.target, 'View target', targetPath);
+    exact(target, ['kind'], 'Domain View target', targetPath);
+    if (target.kind !== 'domain')
+        invalid('View target', undefined, targetPath);
+    return value;
+}

package/dist/v1/compiled/compiler/compile.js

@@ -125,6 +125,8 @@ function compileEntry(schema, lookup) {
     return Object.freeze({
         origin: schema.origin,
         revision: revisionOfDomainSchema(schema),
+        name: schema.name,
+        ...(schema.entrypoint === undefined ? {} : { entrypoint: schema.entrypoint }),
         dependencies: schema.dependencies,
         definitions: Object.freeze({
             classes: Object.freeze(classes),

package/dist/v1/compiled/model/schema.d.ts

@@ -1,5 +1,5 @@
 import type { Key } from '../../addressing/index.js';
-import type { DomainDependency, DomainDependencyMap, Revision } from '../../addressing/index.js';
+import type { DomainDependency, DomainDependencyMap, Revision, ViewRef } from '../../addressing/index.js';
 import type { Domain } from '../../domain/model/domain.js';
 import type { MethodDefinition } from '../../language/callable/model/callable.js';
 import type { ClassDefinition } from '../../language/class/model/class.js';
@@ -53,6 +53,10 @@ export type CompiledCoreEdge = CoreEdge;
 export interface CompiledSchemaEntry {
     readonly origin: Key.Origin;
     readonly revision: Revision;
+    /** The source Domain display name. */
+    readonly name: string;
+    /** The source Domain entrypoint View. */
+    readonly entrypoint?: ViewRef;
     readonly dependencies: DomainDependencyMap;
     readonly definitions: {
         readonly classes: readonly CompiledClass[];

package/dist/v1/domain/projection/classes.js

@@ -1,5 +1,6 @@
 import { Key, MethodKey as MethodKeyValue, PropertyKey as PropertyKeyValue, } from '../../addressing/index.js';
 import { isMethodExecutable } from '../../language/callable/executable.js';
+import { classSatisfies } from '../../language/class/inheritance.js';
 import { acceptPropertyValues } from '../../language/class/property-values.js';
 import { appendPointer } from '../../language/value/syntax/pointer.js';
 import { createMethodCollection, createPropertyCollection } from '../namespace/member-collection.js';
@@ -102,15 +103,7 @@ export function createClasses(definitions, validation) {
                 static: Object.freeze({ methods: createMethodCollection(ownStaticMethods) }),
             }),
             satisfies(selected) {
-                if (key === selected.key)
-                    return true;
-                return parents.some((parent) => {
-                    if (parent.kind === 'node' && selected.kind === 'node')
-                        return parent.satisfies(selected);
-                    if (parent.kind === 'edge' && selected.kind === 'edge')
-                        return parent.satisfies(selected);
-                    return false;
-                });
+                return classSatisfies(definition, selected.definition, (ref) => declarations.get(Key.of(ref)));
             },
             validateProperties(input) {
                 return validateProperties(definition.abstract, effectiveProperties, input);

package/dist/v1/index.d.ts

@@ -5,7 +5,7 @@ export { isBinaryInput } from './language/callable/model/callable.js';
 export type { EventOf, StateMachine, StateOf } from './language/state/index.js';
 export { PropertyValues } from './language/index.js';
 export * as metadata from './language/definition/metadata.js';
-export type { AnyResolvedClass, BoundMethodOf, BoundMethodShortcutsOf, CallableResultOf, CallableInputOf, CallableInputModeOf, CallableOutputOf, ClassSatisfactionKeysOf, ClassDefinition, CoreDefinition, CoreEdge, FunctionAuth, FunctionDefinition, BinaryInput, BinaryInputProjection, CallableInputContract, MethodDefinition, MethodOwnerKeyOf, PolicyCheckExpression, PolicyDefinition, PropertyInputOf, PropertyAccessOf, PropertyOutputOf, PropertyShortcutsOf, PropertyValuesOf, ResolvedClass, ResolvedCoreDefinition, ResolvedCoreEndpoint, ResolvedData, ResolvedFunction, ExecutableMethod, ResolvedMethod, ResolvedMethodCollection, ResolvedPolicy, ResolvedProperty, ResolvedView, MethodAccessOf, SelfMethodsOf, SelfPropertiesOf, SelfStaticMethodsOf, StaticMethodsOf, ViewDefinition, } from './language/index.js';
+export type { AnyResolvedClass, BoundMethodOf, BoundMethodShortcutsOf, CallableResultOf, CallableInputOf, CallableInputModeOf, CallableOutputOf, ClassSatisfactionKeysOf, ClassDefinition, CoreDefinition, CoreEdge, FunctionAuth, FunctionDefinition, BinaryInput, BinaryInputProjection, CallableInputContract, MethodDefinition, MethodOwnerKeyOf, PolicyCheckExpression, PolicyDefinition, PropertyImmutability, PropertyInputOf, PropertyAccessOf, PropertyOutputOf, PropertyShortcutsOf, PropertyValuesOf, ResolvedClass, ResolvedCoreDefinition, ResolvedCoreEndpoint, ResolvedData, ResolvedFunction, ExecutableMethod, ResolvedMethod, ResolvedMethodCollection, ResolvedPolicy, ResolvedProperty, ResolvedView, MethodAccessOf, SelfMethodsOf, SelfPropertiesOf, SelfStaticMethodsOf, StaticMethodsOf, ViewDefinition, } from './language/index.js';
 export { acceptDefinitionRef, callableAddress, ClassKey, equalDefinitionRefs, isDefinitionRef, Key, MethodKey, PropertyKey, } from './addressing/index.js';
 export type { ClassRef, CoreRef, DefinitionBase, DefinitionKey, DefinitionRef, FunctionRef, MethodAddress, PolicyRef, Revision, ViewRef, } from './addressing/index.js';
 export type { Definition } from './language/index.js';

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

@@ -0,0 +1,12 @@
+import type { ClassRef } from '../../addressing/index.js';
+import type { ClassKind } from './model/class.js';
+/** The representation shared by source, compiled and resolved Class admission. */
+export interface ClassInheritance {
+    readonly ref: ClassRef;
+    readonly kind: ClassKind;
+    readonly extends: readonly ClassRef[];
+}
+/** Kernel graph roots are intrinsic supertypes, not authored structural Edge contracts. */
+export declare function isGraphRoot(value: Pick<ClassInheritance, 'ref' | 'kind'>): boolean;
+/** Same-kind satisfaction includes the intrinsic root and the declared parent closure. */
+export declare function classSatisfies(candidate: ClassInheritance, required: ClassInheritance, resolve: (ref: ClassRef) => ClassInheritance | undefined): boolean;

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

@@ -0,0 +1,25 @@
+/** Kernel graph roots are intrinsic supertypes, not authored structural Edge contracts. */
+export function isGraphRoot(value) {
+    return (value.ref.origin === 'kernel.astrale.ai' &&
+        value.ref.name === (value.kind === 'node' ? 'Node' : 'Edge'));
+}
+/** Same-kind satisfaction includes the intrinsic root and the declared parent closure. */
+export function classSatisfies(candidate, required, resolve) {
+    if (candidate.kind !== required.kind)
+        return false;
+    if (isGraphRoot(required))
+        return true;
+    const seen = new Set();
+    const visit = (value) => {
+        if (value.ref.origin === required.ref.origin && value.ref.name === required.ref.name)
+            return true;
+        if (seen.has(value))
+            return false;
+        seen.add(value);
+        return value.extends.some((ref) => {
+            const parent = resolve(ref);
+            return parent !== undefined && parent.kind === required.kind && visit(parent);
+        });
+    };
+    return visit(candidate);
+}

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

@@ -45,6 +45,7 @@ export interface ResolvedClass<Kind extends ClassKind = ClassKind, Properties ex
     readonly kind: Kind;
     readonly abstract: boolean;
     readonly definition: Definition;
+    /** Explicitly authored parents; intrinsic graph roots do not alter schema bytes. */
     readonly extends: Parents & readonly ResolvedClass<Kind>[];
     /** Local observation Policies; Class inheritance never contributes an attachment. */
     readonly policies: Definition['policies'];
@@ -62,14 +63,17 @@ export interface ResolvedClass<Kind extends ClassKind = ClassKind, Properties ex
             readonly methods: Kind extends 'node' ? SelfStaticMethods : ResolvedMethodCollection<Record<never, never>>;
         };
     };
+    /** Same-kind nominal inheritance, including the universal Kernel Node or Edge root. */
     satisfies(selected: ResolvedClass<Kind>): boolean;
     validateProperties(input: unknown): readonly Diagnostic[];
 }
 /** One resolved Class with an exact graph kind, used at heterogeneous Domain boundaries. */
 export type AnyResolvedClass = ResolvedClass<'node'> | ResolvedClass<'edge'>;
-/** Exact Class keys satisfied by one resolved Class, including transitive parents. */
+/** Class keys satisfied by one resolved Class, including its graph root and transitive parents. */
 export type ClassSatisfactionKeysOf<Class> = ClassSatisfactionKeys<Class, never>;
 type ClassSatisfactionKeys<Class, Seen> = Class extends Seen ? never : (Class extends {
+    readonly kind: infer Kind extends ClassKind;
+} ? DefinitionKey<'kernel.astrale.ai', 'class', Kind extends 'node' ? 'Node' : 'Edge'> : never) | (Class extends {
     readonly key: infer ExactKey extends DefinitionKey<Key.Origin, 'class'>;
 } ? ExactKey : never) | (Class extends ResolvedClass<ClassKind, ResolvedPropertyCollection, ResolvedMethodCollection, ResolvedMethodCollection, ResolvedPropertyCollection, ResolvedMethodCollection, ResolvedMethodCollection, ClassDefinition, infer Parents> ? ClassSatisfactionKeys<Extract<Parents[number], ResolvedClass>, Seen | Class> : never);
 export type PropertyValueOf<Property> = Property extends ResolvedProperty<infer Value, boolean, StateTopology | undefined, unknown> ? Value : never;