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

package/dist/v1/addressing/definition-ref.js

@@ -8,55 +8,39 @@ const DEFINITION_KINDS = new Set([
 ]);
 /** Admit and detach one canonical DefinitionRef from an untrusted value. */
 export function acceptDefinitionRef(input) {
-    if (input === null || typeof input !== 'object' || Array.isArray(input)) {
-        invalid(input);
-    }
+    return readDefinitionRef(input) ?? invalid(input);
+}
+/** Identify a canonical DefinitionRef-shaped value without retaining caller state. */
+export function isDefinitionRef(input) {
+    return readDefinitionRef(input) !== undefined;
+}
+/** Compare exact Definition coordinates, independent of object identity. */
+export function equalDefinitionRefs(left, right) {
+    return left.origin === right.origin && left.kind === right.kind && left.name === right.name;
+}
+function invalid(input) {
+    throw new TypeError(`Invalid DefinitionRef: ${JSON.stringify(input)}.`);
+}
+/** A detached copy of the canonical DefinitionRef `input` holds, reading each field once. */
+function readDefinitionRef(input) {
+    if (input === null || typeof input !== 'object' || Array.isArray(input))
+        return undefined;
     const value = input;
     const keys = Reflect.ownKeys(value);
     if (keys.length !== 3 ||
         !keys.every((key) => key === 'origin' || key === 'kind' || key === 'name')) {
-        invalid(input);
+        return undefined;
     }
-    const origin = value.origin;
-    const kind = value.kind;
-    const name = value.name;
+    const { origin, kind, name } = value;
     if (typeof origin !== 'string' ||
         !DOMAIN_ORIGIN_PATTERN.test(origin) ||
         typeof kind !== 'string' ||
         !DEFINITION_KINDS.has(kind) ||
         typeof name !== 'string' ||
         !definitionNameMatches(kind, name)) {
-        invalid(input);
+        return undefined;
     }
-    return Object.freeze({
-        origin,
-        kind: kind,
-        name,
-    });
-}
-/** Identify a canonical DefinitionRef-shaped value without retaining caller state. */
-export function isDefinitionRef(input) {
-    if (input === null || typeof input !== 'object' || Array.isArray(input))
-        return false;
-    const value = input;
-    const keys = Reflect.ownKeys(value);
-    if (keys.length !== 3 ||
-        !keys.every((key) => key === 'origin' || key === 'kind' || key === 'name')) {
-        return false;
-    }
-    return (typeof value.origin === 'string' &&
-        DOMAIN_ORIGIN_PATTERN.test(value.origin) &&
-        typeof value.kind === 'string' &&
-        DEFINITION_KINDS.has(value.kind) &&
-        typeof value.name === 'string' &&
-        definitionNameMatches(value.kind, value.name));
-}
-/** Compare exact Definition coordinates, independent of object identity. */
-export function equalDefinitionRefs(left, right) {
-    return left.origin === right.origin && left.kind === right.kind && left.name === right.name;
-}
-function invalid(input) {
-    throw new TypeError(`Invalid DefinitionRef: ${JSON.stringify(input)}.`);
+    return Object.freeze({ origin, kind: kind, name });
 }
 function definitionNameMatches(kind, name) {
     return kind === 'core' ? CORE_SLUG_PATTERN.test(name) : MEMBER_NAME_PATTERN.test(name);

package/dist/v1/addressing/ordering.d.ts

@@ -4,3 +4,5 @@ export declare function definitionRefIndex(ref: DefinitionRef): string;
 export declare function compareDefinitionRefs(left: DefinitionRef, right: DefinitionRef): number;
 /** Locale-independent Unicode code-point ordering for canonical DSL values. */
 export declare function compareUnicode(left: string, right: string): number;
+/** Order strings by UTF-16 code unit, the order `<` gives strings. */
+export declare function compareCodeUnits(left: string, right: string): number;

package/dist/v1/addressing/ordering.js

@@ -18,3 +18,7 @@ export function compareUnicode(left, right) {
     }
     return a.length - b.length;
 }
+/** Order strings by UTF-16 code unit, the order `<` gives strings. */
+export function compareCodeUnits(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}

package/dist/v1/addressing/patterns.d.ts

@@ -19,4 +19,3 @@ export declare const patterns: Readonly<{
     revision: RegExp;
     revisionFullMatch: "sha256:[0-9a-f]{64}";
 }>;
-export declare function assertMemberName(name: string): void;

package/dist/v1/addressing/patterns.js

@@ -22,8 +22,3 @@ export const patterns = Object.freeze({
     revision: DOMAIN_REVISION_PATTERN,
     revisionFullMatch: DOMAIN_REVISION_FULL_MATCH,
 });
-export function assertMemberName(name) {
-    if (!MEMBER_NAME_PATTERN.test(name)) {
-        throw new TypeError(`Invalid member name: ${JSON.stringify(name)}.`);
-    }
-}

package/dist/v1/builder/class/authoring.js

@@ -59,7 +59,7 @@ export const edgeClass = Object.freeze({
         validateDirectedSourceInput(input.source);
         validateDirectedTargetInput(input.target);
         const { source, target, unique, ...options } = input;
-        validateEdgeClassOptions(options);
+        validateEdgeClassOptions(options, ['noSelf', 'acyclic']);
         const value = authoringValue('definition', {
             kind: 'edge',
             orientation: 'directed',
@@ -94,7 +94,7 @@ export const edgeClass = Object.freeze({
         validateIncidentEndpointInput(input.endpoints[0]);
         validateIncidentEndpointInput(input.endpoints[1]);
         const { endpoints, ...options } = input;
-        validateUndirectedEdgeClassOptions(options);
+        validateEdgeClassOptions(options, ['noSelf']);
         const value = authoringValue('definition', {
             kind: 'edge',
             orientation: 'undirected',
@@ -122,33 +122,10 @@ function validateDirectedTargetInput(value) {
 function validateIncidentEndpointInput(value) {
     assertKnownKeys(value, ['as', 'accepts', 'incident', 'onDelete']);
 }
-function validateEdgeClassOptions(value) {
-    assertKnownKeys(value, [
-        'abstract',
-        'inheritance',
-        'description',
-        'extends',
-        'properties',
-        'policies',
-        'constraints',
-    ]);
-    if (value.policies !== undefined)
-        assertKnownKeys(value.policies, ['read', 'traverse']);
-    if (value.constraints !== undefined)
-        assertKnownKeys(value.constraints, ['noSelf', 'acyclic']);
-}
-function validateUndirectedEdgeClassOptions(value) {
-    assertKnownKeys(value, [
-        'abstract',
-        'inheritance',
-        'description',
-        'extends',
-        'properties',
-        'policies',
-        'constraints',
-    ]);
+/** Check the nested Edge Class options; the caller has checked the option keys themselves. */
+function validateEdgeClassOptions(value, constraints) {
     if (value.policies !== undefined)
         assertKnownKeys(value.policies, ['read', 'traverse']);
     if (value.constraints !== undefined)
-        assertKnownKeys(value.constraints, ['noSelf']);
+        assertKnownKeys(value.constraints, constraints);
 }

package/dist/v1/builder/lowering/schema/context.js

@@ -4,6 +4,7 @@ import { isMethodExecutable } from '../../../language/callable/executable.js';
 import { admitsForeignSubclass, inheritanceOf } from '../../../language/class/inheritance.js';
 import { policyObjectKey, policyObjectOrigin } from '../../../language/index.js';
 import { graphNodePathSchema } from '../../../language/value/syntax/node-path/schema.js';
+import { escapePointerToken } from '../../../language/value/syntax/pointer.js';
 import { revisionOfDomainSchema } from '../../../schema/canonical/revision.js';
 import { requireDomainClosure } from '../../../schema/resolution/closure.js';
 import { collectUsedForeignOrigins } from '../../../schema/resolution/origins.js';
@@ -23,7 +24,7 @@ export class BuilderContext {
     constructor(origin, dependencies) {
         this.origin = origin;
         for (const [alias, schema] of Object.entries(dependencies)) {
-            const pointer = `/dependencies/${escapePointer(alias)}`;
+            const pointer = `/dependencies/${escapePointerToken(alias)}`;
             if (!DEPENDENCY_ALIAS_PATTERN.test(alias)) {
                 fail('BUILDER_DEPENDENCY_ALIAS', pointer, `Dependency alias ${JSON.stringify(alias)} must be an ASCII lower-camel identifier.`);
             }
@@ -223,9 +224,6 @@ export class BuilderContext {
         this.policyObjectRefs.add(policyObjectKey(ref));
     }
 }
-function escapePointer(value) {
-    return value.replaceAll('~', '~0').replaceAll('/', '~1');
-}
 function isResolvedClass(value) {
     if (typeof value !== 'object' || value === null)
         return false;

package/dist/v1/builder/lowering/value/path.js

@@ -1,9 +1,10 @@
+import { escapePointerToken } from '../../../language/value/syntax/pointer.js';
 import { pathAccepts } from '../../value/path-metadata.js';
 export function lowerPathSchema(context, resolveAccepts, pointer) {
     const inputs = pathAccepts(context.zodSchema);
     if (inputs === undefined)
         return;
-    const location = context.path.reduce((current, segment) => `${current}/${escapeToken(String(segment))}`, pointer);
+    const location = context.path.reduce((current, segment) => `${current}/${escapePointerToken(String(segment))}`, pointer);
     for (const key of Object.keys(context.jsonSchema))
         delete context.jsonSchema[key];
     Object.assign(context.jsonSchema, {
@@ -15,6 +16,3 @@ export function lowerPathSchema(context, resolveAccepts, pointer) {
         },
     });
 }
-function escapeToken(value) {
-    return value.replaceAll('~', '~0').replaceAll('/', '~1');
-}

package/dist/v1/builder/lowering/value/zod.js

@@ -4,6 +4,7 @@ import { canonicalizeValueSchema } from '../../../language/value/profile/canonic
 import { validateValueSchema } from '../../../language/value/profile/validate.js';
 import { isIRegexp } from '../../../language/value/regexp/syntax.js';
 import { fullMatchSource } from '../../../language/value/syntax/full-match.js';
+import { escapePointerToken } from '../../../language/value/syntax/pointer.js';
 import { diagnostic } from '../../schema/diagnostic.js';
 /**
  * Converts only Zod contracts whose JSON-value acceptance is represented
@@ -289,9 +290,6 @@ function getCheckDefinition(value) {
 function isZodType(value) {
     return value instanceof ZodType;
 }
-function escapePointerToken(value) {
-    return value.replaceAll('~', '~0').replaceAll('/', '~1');
-}
 function isPlainRecord(value) {
     return value !== null && typeof value === 'object' && !Array.isArray(value);
 }

package/dist/v1/builder/schema/define.d.ts

@@ -2,7 +2,6 @@ import type { Domain } from '../../domain/model/domain.js';
 import type { DomainSchema } from '../../schema/model/schema.js';
 import type { DomainSchemaInput, EntrypointOf } from './input.js';
 import type { ResolvedDomainOfInput } from './projection.js';
-export type { DomainSchemaInput } from './input.js';
 /** Exact named Schema produced from one authored input. */
 export interface DefinedSchema<Origin extends string, Resolved extends Domain> extends DomainSchema<Origin, Resolved> {
 }

package/dist/v1/builder/schema/diagnostic.d.ts

@@ -1,4 +1,6 @@
 import type { DiagnosticCode as LanguageDiagnosticCode } from '../../language/validation/diagnostic.js';
+import { escapePointerToken as escapeToken } from '../../language/value/syntax/pointer.js';
+export { escapeToken };
 export type BuilderDiagnosticCode = LanguageDiagnosticCode | 'BUILDER_ABSTRACT_POLICY' | 'BUILDER_AMBIGUOUS_OWNERSHIP' | 'BUILDER_AUTO_EVENT_INVALID' | 'BUILDER_AUTO_IMMUTABLE' | 'BUILDER_AUTO_NESTED' | 'BUILDER_AUTO_SET_INVALID' | 'BUILDER_CALLABLE_AUTH' | 'BUILDER_CALLABLE_PLACEMENT' | 'BUILDER_CALLABLE_POLICY_AUTH' | 'BUILDER_CLASS_INHERITANCE' | 'BUILDER_CORE_CLASS' | 'BUILDER_CORE_EDGE' | 'BUILDER_CORE_NODE' | 'BUILDER_CORE_PROPERTY' | 'BUILDER_CORE_REF' | 'BUILDER_DEFINITION' | 'BUILDER_DEPENDENCY_CONFLICT' | 'BUILDER_DEPENDENCY_ALIAS' | 'BUILDER_DEPENDENCY_DIRECT' | 'BUILDER_DUPLICATE_MEMBER' | 'BUILDER_EDGE_LIFETIME' | 'BUILDER_FOREIGN_POLICY' | 'BUILDER_FULL_MATCH_INVALID' | 'BUILDER_FUNCTION' | 'BUILDER_METHOD' | 'BUILDER_PATH_DUPLICATE' | 'BUILDER_PATH_EMPTY' | 'BUILDER_POLICY' | 'BUILDER_POLICY_COMPOSITION' | 'BUILDER_POLICY_CYCLE' | 'BUILDER_POLICY_EMPTY_COMPOSITION' | 'BUILDER_POLICY_EMPTY_EXISTS' | 'BUILDER_POLICY_INPUT' | 'BUILDER_POLICY_REF' | 'BUILDER_POLICY_SELF' | 'BUILDER_PROPERTY_IMMUTABLE_INVALID' | 'BUILDER_REFERENCE_CYCLE' | 'BUILDER_REFERENCE_KIND' | 'BUILDER_REFERENCE_MISSING' | 'BUILDER_UNIQUE_PROPERTY' | 'BUILDER_UNKNOWN_FIELD' | 'BUILDER_UNOWNED_REFERENCE' | 'BUILDER_VIEW' | 'ZOD_SCHEMA_NOT_LOSSLESS';
 export interface BuilderDiagnostic<out Code extends BuilderDiagnosticCode = BuilderDiagnosticCode> {
     readonly code: Code;
@@ -13,4 +15,3 @@ export declare class BuilderError extends Error {
 }
 export declare function assertKnownKeys(value: object, allowed: readonly string[], pointer?: string): void;
 export declare function fail(code: BuilderDiagnosticCode, pointer: string, message: string): never;
-export declare function escapeToken(value: string): string;

package/dist/v1/builder/schema/diagnostic.js

@@ -1,16 +1,14 @@
-import { compareUnicode } from '../../addressing/ordering.js';
+import { formatDiagnostics, orderDiagnostics } from '../../language/validation/diagnostic.js';
+import { escapePointerToken as escapeToken } from '../../language/value/syntax/pointer.js';
+export { escapeToken };
 export function diagnostic(code, pointer, message, ref) {
     return Object.freeze({ code, pointer, message, ...(ref === undefined ? {} : { ref }) });
 }
 export class BuilderError extends Error {
     diagnostics;
     constructor(diagnostics) {
-        const ordered = [...diagnostics].sort((left, right) => compareUnicode(left.pointer, right.pointer) ||
-            compareUnicode(left.code, right.code) ||
-            compareUnicode(left.message, right.message));
-        super(ordered
-            .map(({ code, pointer, message }) => `${pointer || '/'} [${code}] ${message}`)
-            .join('\n'));
+        const ordered = orderDiagnostics(diagnostics);
+        super(formatDiagnostics(ordered));
         this.name = 'BuilderError';
         this.diagnostics = Object.freeze(ordered);
     }
@@ -26,6 +24,3 @@ export function assertKnownKeys(value, allowed, pointer = '') {
 export function fail(code, pointer, message) {
     throw new BuilderError([diagnostic(code, pointer, message)]);
 }
-export function escapeToken(value) {
-    return value.replaceAll('~', '~0').replaceAll('/', '~1');
-}

package/dist/v1/builder/schema/projection.d.ts

@@ -1,4 +1,4 @@
-export type { PropertyProjection, MethodProjection, FunctionProjection, ClassProjection, DomainProjection, } from './projection/model.js';
+export type { PropertyProjection, MethodProjection, FunctionProjection, ClassProjection, } from './projection/model.js';
 export type { ResolvedDomainOfInput } from './projection/domain.js';
 export type { CoreNamedPropertyInput, CorePropertyInput } from './projection/core-input.js';
 export type { ClassProjectionOfResolved } from './projection/resolved-class.js';

package/dist/v1/builder/value/full-match.d.ts

@@ -1,4 +1,3 @@
 import { type FullMatch } from '../../language/value/syntax/full-match.js';
-export { fullMatchSource, type FullMatch } from '../../language/value/syntax/full-match.js';
 /** Authoring facade preserving the Builder-owned diagnostic for invalid source syntax. */
 export declare function fullMatch(source: string): FullMatch;

package/dist/v1/builder/value/full-match.js

@@ -1,7 +1,6 @@
 import { refuseIRegexp, stateBudgetMessage } from '../../language/value/regexp/syntax.js';
 import { fullMatch as languageFullMatch, } from '../../language/value/syntax/full-match.js';
 import { fail } from '../schema/diagnostic.js';
-export { fullMatchSource } from '../../language/value/syntax/full-match.js';
 /** Authoring facade preserving the Builder-owned diagnostic for invalid source syntax. */
 export function fullMatch(source) {
     const refusal = refuseIRegexp(source);

package/dist/v1/bundle/codec.js

@@ -1,6 +1,7 @@
 import { accept as acceptJsonValue, BoundaryError as JsonBoundaryError, json, } from '@astrale-os/kernel-dsl/value';
 import { dependencyLimits } from '../addressing/domain-dependency.js';
 import { compareUnicode } from '../addressing/ordering.js';
+import { escapePointerToken } from '../language/value/syntax/pointer.js';
 import { acceptDomainSchema } from '../schema/admission/accept.js';
 import { canonicalDomainSchemaAfterValidation } from '../schema/canonical/revision.js';
 import { revisionOfDomainSchema } from '../schema/canonical/revision.js';
@@ -9,9 +10,6 @@ import { SchemaError } from '../schema/diagnostic.js';
 import { BundleError, diagnostic } from './diagnostic.js';
 import { asDomainSchemaBundle, } from './model.js';
 import { parseDomainSchemaBundleStructure } from './structure.js';
-function escapeToken(value) {
-    return value.replaceAll('~', '~0').replaceAll('/', '~1');
-}
 export function acceptDomainSchemaBundle(input) {
     let admitted;
     try {
@@ -136,7 +134,7 @@ function collectReachable(current, root, candidates, reachable, active, revision
         return;
     }
     for (const [alias, dependency] of Object.entries(current.schema.dependencies)) {
-        const pointer = `${current.pointer}/dependencies/${escapeToken(alias)}`;
+        const pointer = `${current.pointer}/dependencies/${escapePointerToken(alias)}`;
         const dependencyKey = keyOf(dependency.origin, dependency.revision);
         if (dependencyKey === root.key) {
             diagnostics.push(diagnostic('BUNDLE_CLOSURE_CYCLE', pointer, 'Bundle dependency closure returns to its root.'));

package/dist/v1/bundle/diagnostic.js

@@ -1,16 +1,12 @@
-import { compareUnicode } from '../addressing/ordering.js';
+import { formatDiagnostics, orderDiagnostics } from '../language/validation/diagnostic.js';
 export function diagnostic(code, pointer, message, ref) {
     return Object.freeze({ code, pointer, message, ...(ref === undefined ? {} : { ref }) });
 }
 export class BundleError extends Error {
     diagnostics;
     constructor(diagnostics) {
-        const ordered = [...diagnostics].sort((left, right) => compareUnicode(left.pointer, right.pointer) ||
-            compareUnicode(left.code, right.code) ||
-            compareUnicode(left.message, right.message));
-        super(ordered
-            .map(({ code, pointer, message }) => `${pointer || '/'} [${code}] ${message}`)
-            .join('\n'));
+        const ordered = orderDiagnostics(diagnostics);
+        super(formatDiagnostics(ordered));
         this.name = 'BundleError';
         this.diagnostics = Object.freeze(ordered);
     }

package/dist/v1/bundle/structure.js

@@ -1,3 +1,4 @@
+import { escapePointerToken } from '../language/value/syntax/pointer.js';
 import { SchemaError } from '../schema/diagnostic.js';
 import { routeDomainSchema } from '../schema/validation/domain.route.js';
 import { BundleError, diagnostic } from './diagnostic.js';
@@ -12,7 +13,7 @@ export function parseDomainSchemaBundleStructure(input) {
     const expected = new Set(['format', 'version', 'root', 'closure']);
     for (const key of Object.keys(input)) {
         if (!expected.has(key)) {
-            diagnostics.push(diagnostic('BUNDLE_STRUCTURE', `/${escapeToken(key)}`, `Unknown bundle field ${key}.`));
+            diagnostics.push(diagnostic('BUNDLE_STRUCTURE', `/${escapePointerToken(key)}`, `Unknown bundle field ${key}.`));
         }
     }
     for (const key of expected) {
@@ -66,6 +67,3 @@ function isObject(value) {
 function describe(value) {
     return value === undefined ? '(missing)' : JSON.stringify(value);
 }
-function escapeToken(value) {
-    return value.replaceAll('~', '~0').replaceAll('/', '~1');
-}

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

@@ -1,6 +1,6 @@
 import { type CompiledDiagnosticCode } from '../diagnostic.js';
 /** Append one escaped JSON Pointer segment. */
-export declare function pointer(parent: string, member: string | number): string;
+export { appendPointer as pointer } from '../../language/value/syntax/pointer.js';
 /** 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. */

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

@@ -1,8 +1,6 @@
 import { invalidCompiled } from '../diagnostic.js';
 /** Append one escaped JSON Pointer segment. */
-export function pointer(parent, member) {
-    return `${parent}/${String(member).replaceAll('~', '~0').replaceAll('/', '~1')}`;
-}
+export { appendPointer as pointer } from '../../language/value/syntax/pointer.js';
 /** 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);

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

@@ -1,4 +1,12 @@
 import type { Revision } from '../../addressing/index.js';
-import type { CompiledSchemaEntry } from '../model/schema.js';
+import type { FunctionDefinition, MethodDefinition } from '../../language/callable/model/callable.js';
+import type { JsonSchema } from '../../language/value/model/schema.js';
+import type { CompiledFunction, CompiledMethod, CompiledSchemaEntry } from '../model/schema.js';
 /** Derive the exact canonical source-revision preimage without constructing an authored Schema. */
 export declare function revisionOfCompiledEntry(entry: CompiledSchemaEntry): Revision;
+/** The source definition of a compiled Method: its value programs back to their schemas. */
+export declare function sourceMethod(entry: CompiledSchemaEntry, method: CompiledMethod): MethodDefinition;
+/** The source definition of a compiled Function: its value programs back to their schemas. */
+export declare function sourceFunction(entry: CompiledSchemaEntry, definition: CompiledFunction): FunctionDefinition;
+/** The schema of the root node of the entry's value program `index`. */
+export declare function schemaOf(entry: CompiledSchemaEntry, index: number): JsonSchema;

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

@@ -44,7 +44,8 @@ function sourceClass(entry, definition) {
         methods: Object.fromEntries(methods.map((method) => [method.name, sourceMethod(entry, method)])),
     };
 }
-function sourceMethod(entry, method) {
+/** The source definition of a compiled Method: its value programs back to their schemas. */
+export function sourceMethod(entry, method) {
     const { name: _, input, fields: __, output, ...rest } = method;
     return {
         ...rest,
@@ -52,7 +53,8 @@ function sourceMethod(entry, method) {
         output: sourceOutput(entry, output),
     };
 }
-function sourceFunction(entry, definition) {
+/** The source definition of a compiled Function: its value programs back to their schemas. */
+export function sourceFunction(entry, definition) {
     const { input, fields: _, output, ...rest } = definition;
     return {
         ...rest,
@@ -72,7 +74,8 @@ function sourceOutput(entry, output) {
     const schema = schemaOf(entry, output.value);
     return output.mode === 'value' ? { mode: 'value', schema } : { mode: 'stream', item: schema };
 }
-function schemaOf(entry, index) {
+/** The schema of the root node of the entry's value program `index`. */
+export function schemaOf(entry, index) {
     const program = entry.values[index];
     const root = program?.nodes[program.root];
     if (root === undefined)

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

@@ -1,5 +1,8 @@
 import { type Located, type CompiledClass, type ClassAnalysis, type SemanticIndex } from './context.js';
-/** Compose inherited Properties, Methods and Data ownership once per Class. */
+/**
+ * Compose inherited Properties, Methods and Data ownership once per Class. The closure check has
+ * already proved every parent present and the inheritance graph acyclic.
+ */
 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

@@ -7,22 +7,19 @@ 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. */
+/**
+ * Compose inherited Properties, Methods and Data ownership once per Class. The closure check has
+ * already proved every parent present and the inheritance graph acyclic.
+ */
 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.');
             if (parent.value.inheritance === 'final')
                 fail(`${located.pointer}/extends/${index}`, 'A final Class has no subclass.');
             return analyze(parent);
@@ -71,7 +68,6 @@ export function analyzeClasses(classes) {
             ...(dataOwner === undefined ? {} : { dataOwner }),
         };
         analyses.set(classKey, analysis);
-        visiting.delete(classKey);
         return analysis;
     };
     for (const value of classes.values())

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

@@ -1,7 +1,5 @@
-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';
+import { type Located, type CompiledClass, type ClassAnalysis, type SemanticIndex } from './context.js';
 /** A local Core Node paired with its admitted Class analysis. */
 export interface CoreNode {
     readonly key: string;
@@ -10,26 +8,5 @@ export interface CoreNode {
     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 {};