@astrale-os/kernel-dsl 0.2.0-beta.4 → 0.2.0-beta.41

package/dist/v1/domain/create.js

@@ -0,0 +1,273 @@
+import { Key, MethodKey } from '../addressing/index.js';
+import { frozenRecord } from './namespace/member-collection.js';
+import { createClasses } from './projection/classes.js';
+const admittedDomains = new WeakSet();
+/** True only for an immutable Domain created by DSL resolution or compiled loading. */
+export function isDomain(input) {
+    return input !== null && typeof input === 'object' && admittedDomains.has(input);
+}
+/** Retain source provenance without losing the admitted root Domain identity. */
+export function createSourceDomain(domain, source) {
+    if (!isDomain(domain))
+        throw new TypeError('Source provenance requires an admitted Domain.');
+    const resolved = Object.freeze({ ...domain, source });
+    admittedDomains.add(resolved);
+    return resolved;
+}
+/** Construct one resolved Definition universe and one memoized facade per closure Domain. */
+export function createDomain(input) {
+    const entries = new Map();
+    for (const entry of input.entries) {
+        if (entries.has(entry.origin))
+            throw new TypeError(`Domain entry ${entry.origin} is duplicated.`);
+        entries.set(entry.origin, entry);
+    }
+    const root = entries.get(input.root.origin);
+    if (root === undefined || root.revision !== input.root.revision) {
+        throw new TypeError('Domain root is absent or has the wrong revision.');
+    }
+    const declarations = Object.freeze(input.entries.flatMap(({ definitions }) => definitions));
+    const classesByKey = createClasses(declarations, input.validation);
+    const definitionsByKey = createDefinitions(declarations, classesByKey, input);
+    const callables = createCallables(definitionsByKey, classesByKey);
+    const facades = new Map();
+    const projecting = new Set();
+    const project = (entry) => {
+        const cached = facades.get(entry.origin);
+        if (cached !== undefined)
+            return cached;
+        if (projecting.has(entry.origin))
+            throw new TypeError(`Dependency cycle reaches ${entry.origin}.`);
+        projecting.add(entry.origin);
+        const visibleEntries = reachableEntries(entry, entries);
+        const visibleOrigins = new Set(visibleEntries.map(({ origin }) => origin));
+        const local = [...definitionsByKey.values()]
+            .filter(({ ref }) => ref.origin === entry.origin)
+            .sort((left, right) => compare(left.key, right.key));
+        const classes = namespace(local, 'class');
+        const functions = namespace(local, 'function');
+        const policies = namespace(local, 'policy');
+        const views = namespace(local, 'view');
+        const coreNodes = namespace(local, 'core');
+        const domainEndpoint = Object.freeze({
+            kind: 'domain',
+            origin: entry.origin,
+        });
+        const coreEdges = Object.freeze(entry.coreEdges.map((edge) => {
+            const classValue = classesByKey.get(Key.of(edge.class));
+            if (classValue?.kind !== 'edge') {
+                throw new TypeError(`Core Edge has no Edge Class ${Key.of(edge.class)}.`);
+            }
+            const endpoint = (ref) => ref.kind === 'domain'
+                ? domainEndpoint
+                : requiredCoreEndpoint(definitionsByKey, callables, ref);
+            return Object.freeze({
+                class: classValue,
+                source: endpoint(edge.source),
+                target: endpoint(edge.target),
+                properties: edge.properties,
+            });
+        }));
+        const dependencies = frozenRecord(Object.entries(entry.dependencies).map(([alias, pin]) => {
+            const dependency = entries.get(pin.origin);
+            if (dependency === undefined || dependency.revision !== pin.revision) {
+                throw new TypeError(`Dependency alias ${alias} has no exact ${pin.origin}@${pin.revision} entry.`);
+            }
+            return [alias, project(dependency)];
+        }));
+        const definitionLookup = ((value) => {
+            const resolved = definitionsByKey.get(typeof value === 'string' ? value : Key.of(value));
+            return resolved !== undefined && visibleOrigins.has(resolved.ref.origin)
+                ? resolved
+                : undefined;
+        });
+        const domain = {
+            origin: entry.origin,
+            revision: entry.revision,
+            closure: Object.freeze(visibleEntries
+                .map(({ origin, revision }) => Object.freeze({ origin, revision }))
+                .sort((left, right) => compare(left.origin, right.origin))),
+            dependencies,
+            classes,
+            functions,
+            policies,
+            views,
+            core: Object.freeze({ nodes: coreNodes, edges: coreEdges }),
+            definition: definitionLookup,
+            callable(key) {
+                const callable = callables.get(key);
+                if (callable === undefined)
+                    return undefined;
+                const origin = 'ref' in callable ? callable.ref.origin : callable.owner.ref.origin;
+                return visibleOrigins.has(origin) ? callable : undefined;
+            },
+            definitions(kind) {
+                return kind === undefined ? local : local.filter(({ ref }) => ref.kind === kind);
+            },
+            viewsFor(target) {
+                return Object.freeze(Object.values(views).filter((view) => {
+                    if (view.target.kind === 'domain')
+                        return target === 'domain';
+                    if (target === 'domain')
+                        return false;
+                    return view.target.definitions.some((ref) => {
+                        const selected = classesByKey.get(Key.of(ref));
+                        if (target.kind === 'node' && selected?.kind === 'node') {
+                            return target.satisfies(selected);
+                        }
+                        if (target.kind === 'edge' && selected?.kind === 'edge') {
+                            return target.satisfies(selected);
+                        }
+                        return false;
+                    });
+                }));
+            },
+        };
+        const admitted = Object.freeze(domain);
+        facades.set(entry.origin, admitted);
+        admittedDomains.add(admitted);
+        projecting.delete(entry.origin);
+        return admitted;
+    };
+    return project(root);
+}
+function createDefinitions(declarations, classesByKey, input) {
+    const definitionsByKey = new Map();
+    for (const value of classesByKey.values())
+        definitionsByKey.set(value.key, value);
+    for (const definition of declarations) {
+        if (definition.ref.kind === 'class')
+            continue;
+        if (isFunctionDefinition(definition)) {
+            const key = Key.of(definition.ref);
+            const inputFields = input.validation.callableFields(key);
+            const resolved = Object.freeze({
+                ref: definition.ref,
+                key,
+                description: definition.description,
+                input: definition.input,
+                output: definition.output,
+                ...(definition.execution === undefined ? {} : { execution: definition.execution }),
+                auth: definition.auth,
+                policy: definition.policy,
+                ...(inputFields === undefined ? {} : { inputFields }),
+                definition,
+                validateInput: (value) => input.validation.callableInput(key, value),
+                validateInputField: (field, value) => input.validation.callableInputField(key, field, value),
+                validateOutput: (value) => input.validation.callableOutput(key, value),
+            });
+            definitionsByKey.set(key, resolved);
+            continue;
+        }
+        if (isPolicyDefinition(definition)) {
+            const key = Key.of(definition.ref);
+            definitionsByKey.set(key, Object.freeze({
+                ref: definition.ref,
+                key,
+                expression: definition.expression,
+                description: definition.description,
+                definition,
+            }));
+            continue;
+        }
+        if (isViewDefinition(definition)) {
+            const key = Key.of(definition.ref);
+            definitionsByKey.set(key, Object.freeze({
+                ref: definition.ref,
+                key,
+                target: definition.target,
+                description: definition.description,
+                definition,
+            }));
+        }
+    }
+    for (const definition of declarations) {
+        if (!isCoreDefinition(definition))
+            continue;
+        const classValue = classesByKey.get(Key.of(definition.class));
+        if (classValue?.kind !== 'node') {
+            throw new TypeError(`Core ${Key.of(definition.ref)} has no Node Class.`);
+        }
+        if (classValue.abstract) {
+            throw new TypeError(`Core ${Key.of(definition.ref)} cannot use abstract Class ${classValue.key}.`);
+        }
+        const resolved = Object.freeze({
+            ref: definition.ref,
+            key: Key.of(definition.ref),
+            class: classValue,
+            properties: definition.properties,
+            definition,
+        });
+        definitionsByKey.set(resolved.key, resolved);
+    }
+    return definitionsByKey;
+}
+function createCallables(definitions, classes) {
+    const callables = new Map();
+    for (const definition of definitions.values()) {
+        if (definition.ref.kind === 'function') {
+            callables.set(definition.key, definition);
+        }
+    }
+    for (const definition of classes.values()) {
+        if (definition.kind !== 'node')
+            continue;
+        for (const method of [...definition.methods, ...definition.static.methods]) {
+            callables.set(method.key, method);
+        }
+    }
+    return callables;
+}
+function reachableEntries(root, entries) {
+    const reachable = new Map();
+    const pending = [root];
+    while (pending.length > 0) {
+        const current = pending.pop();
+        if (reachable.has(current.origin))
+            continue;
+        reachable.set(current.origin, current);
+        for (const dependency of Object.values(current.dependencies)) {
+            const nested = entries.get(dependency.origin);
+            if (nested === undefined || nested.revision !== dependency.revision) {
+                throw new TypeError(`Domain universe has no exact ${dependency.origin}@${dependency.revision}.`);
+            }
+            pending.push(nested);
+        }
+    }
+    return [...reachable.values()];
+}
+function namespace(definitions, kind) {
+    return frozenRecord(definitions
+        .filter((value) => value.ref.kind === kind)
+        .map((value) => [value.ref.name, value]));
+}
+/** Every non-Domain Core endpoint addresses one already-resolved local Definition or Method. */
+function requiredCoreEndpoint(definitions, callables, ref) {
+    if (ref.kind === 'method') {
+        const key = MethodKey.of(ref.owner, ref.name);
+        const method = callables.get(key);
+        if (method === undefined || !('owner' in method)) {
+            throw new TypeError(`Core endpoint ${key} is absent.`);
+        }
+        return method;
+    }
+    const value = definitions.get(Key.of(ref));
+    if (value === undefined)
+        throw new TypeError(`Core endpoint ${Key.of(ref)} is absent.`);
+    return value;
+}
+function isFunctionDefinition(value) {
+    return value.ref.kind === 'function';
+}
+function isPolicyDefinition(value) {
+    return value.ref.kind === 'policy';
+}
+function isViewDefinition(value) {
+    return value.ref.kind === 'view';
+}
+function isCoreDefinition(value) {
+    return value.ref.kind === 'core';
+}
+function compare(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}

package/dist/v1/domain/index.d.ts

@@ -0,0 +1,2 @@
+export { isDomain } from './create.js';
+export type * from './model/domain.js';

package/dist/v1/domain/index.js

@@ -0,0 +1 @@
+export { isDomain } from './create.js';

package/dist/v1/domain/model/domain.d.ts

@@ -0,0 +1,59 @@
+import type { DefinitionKey, DefinitionRef, Key, Revision } from '../../addressing/index.js';
+import type { DomainDependency } from '../../addressing/index.js';
+import type { MethodOwnerKeyOf, ResolvedCallable, ResolvedFunction } from '../../language/callable/resolved.js';
+import type { AnyResolvedClass } from '../../language/class/resolved.js';
+import type { ResolvedCoreDefinition, ResolvedCoreEdge } from '../../language/core/resolved.js';
+import type { ResolvedPolicy } from '../../language/policy/resolved.js';
+import type { ResolvedDefinition, ResolvedDefinitionOf } from '../../language/resolved.js';
+import type { ResolvedView } from '../../language/view/resolved.js';
+export type ClassNamespace<Classes extends Readonly<Record<string, unknown>> = Readonly<Record<string, AnyResolvedClass>>> = Readonly<Classes>;
+export type FunctionNamespace<Functions extends Readonly<Record<string, unknown>> = Readonly<Record<string, ResolvedFunction>>> = Readonly<Functions>;
+export type PolicyNamespace<Policies extends Readonly<Record<string, unknown>> = Readonly<Record<string, ResolvedPolicy>>> = Readonly<Policies>;
+export type ViewNamespace<Views extends Readonly<Record<string, unknown>> = Readonly<Record<string, ResolvedView>>> = Readonly<Views>;
+export interface CoreNamespace<Nodes extends Readonly<Record<string, unknown>> = Readonly<Record<string, ResolvedCoreDefinition>>> {
+    readonly nodes: Readonly<Nodes>;
+    readonly edges: readonly ResolvedCoreEdge[];
+}
+/** Erased recursive dependency projection used when no authored Schema witness is available. */
+export interface DependencyDomains {
+    readonly [alias: string]: Domain<Readonly<Record<string, AnyResolvedClass>>, Readonly<Record<string, ResolvedFunction>>, Readonly<Record<string, ResolvedPolicy>>, Readonly<Record<string, ResolvedView>>, Readonly<Record<string, ResolvedCoreDefinition>>, Revision>;
+}
+export type DependencyDomainNamespace<Dependencies extends Readonly<Record<string, unknown>> = DependencyDomains> = Readonly<Dependencies>;
+export interface Domain<Classes extends Readonly<Record<string, unknown>> = Readonly<Record<string, AnyResolvedClass>>, Functions extends Readonly<Record<string, unknown>> = Readonly<Record<string, ResolvedFunction>>, Policies extends Readonly<Record<string, unknown>> = Readonly<Record<string, ResolvedPolicy>>, Views extends Readonly<Record<string, unknown>> = Readonly<Record<string, ResolvedView>>, CoreNodes extends Readonly<Record<string, unknown>> = Readonly<Record<string, ResolvedCoreDefinition>>, RevisionValue extends Revision = Revision> {
+    readonly origin: Key.Origin;
+    readonly revision: RevisionValue;
+    /** Exact admitted root and transitive dependency revisions, ordered by origin. */
+    readonly closure: readonly DomainDependency[];
+    /** Exact immutable direct dependency Domains keyed by authored Schema aliases. */
+    readonly dependencies: DependencyDomainNamespace;
+    readonly classes: ClassNamespace<Classes>;
+    readonly functions: FunctionNamespace<Functions>;
+    readonly policies: PolicyNamespace<Policies>;
+    readonly views: ViewNamespace<Views>;
+    readonly core: CoreNamespace<CoreNodes>;
+    definition<const Ref extends DefinitionRef>(ref: Ref): ResolvedDefinitionOf<Ref['kind']> | undefined;
+    definition<const Origin extends Key.Origin, const Kind extends DefinitionRef['kind'], const Name extends string>(key: DefinitionKey<Origin, Kind, Name>): ResolvedDefinitionOf<Kind> | undefined;
+    callable(key: Key.Callable): ResolvedCallable | undefined;
+    definitions(): readonly ResolvedDefinition[];
+    definitions<const Kind extends DefinitionRef['kind']>(kind: Kind): readonly ResolvedDefinitionOf<Kind>[];
+    viewsFor(target: 'domain' | AnyResolvedClass): readonly Views[keyof Views][];
+}
+declare const DOMAIN_SOURCE_RESOLVED: unique symbol;
+/** Type-only witness carried by a source that retains its exact resolved Domain. */
+export interface DomainSource<Resolved extends Domain = Domain> {
+    readonly [DOMAIN_SOURCE_RESOLVED]: Resolved;
+}
+export type DomainOfSource<Source> = Source extends DomainSource<infer Resolved> ? Resolved : Domain;
+export type SourceDomain<Source, Resolved extends Domain = DomainOfSource<Source>> = Resolved & {
+    readonly source: Source;
+};
+export type ClassesOf<Value> = Value extends Domain<infer Classes> ? Classes : never;
+export type MethodOwnerOf<Work extends Domain, Method> = Extract<ClassesOf<Work>[keyof ClassesOf<Work>], {
+    readonly key: MethodOwnerKeyOf<Method>;
+}>;
+export type FunctionsOf<Value> = Value extends Domain<Readonly<Record<string, unknown>>, infer Functions> ? Functions : never;
+export type PoliciesOf<Value> = Value extends Domain<Readonly<Record<string, unknown>>, Readonly<Record<string, unknown>>, infer Policies> ? Policies : never;
+export type ViewsOf<Value> = Value extends Domain<Readonly<Record<string, unknown>>, Readonly<Record<string, unknown>>, Readonly<Record<string, unknown>>, infer Views> ? Views : never;
+export type PropertyInputFor<Class extends AnyResolvedClass> = import('../../language/class/resolved.js').PropertyInputOf<Class>;
+export type PropertyValuesFor<Class extends AnyResolvedClass> = ReturnType<Class['properties']['from']>;
+export {};

package/dist/v1/domain/model/domain.js

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

package/dist/v1/domain/model/input.d.ts

@@ -0,0 +1,31 @@
+import type { Key as AddressKey, PropertyKey, Revision } from '../../addressing/index.js';
+import type { DomainDependency, DomainDependencyMap } from '../../addressing/index.js';
+import type { CoreEdge } from '../../language/core/model/core.js';
+import type { Definition } from '../../language/definition.js';
+import type { Diagnostic } from '../../language/validation/diagnostic.js';
+import type { OrderingKind } from '../../language/value/ordering.js';
+/** One admitted Schema entry in a dependency-closed Domain universe. */
+export interface DomainEntryInput {
+    readonly origin: AddressKey.Origin;
+    readonly revision: Revision;
+    readonly dependencies: DomainDependencyMap;
+    readonly definitions: readonly Definition[];
+    readonly coreEdges: readonly CoreEdge[];
+}
+/** Dependency-closed, representation-neutral input to the one Domain universe constructor. */
+export interface DomainInput {
+    readonly root: DomainDependency;
+    readonly entries: readonly DomainEntryInput[];
+    readonly validation: DomainValidation;
+}
+/** Already-bound validation semantics supplied by source compilation or compiled loading. */
+export interface DomainValidation {
+    propertyExists(key: PropertyKey): boolean;
+    property(key: PropertyKey, input: unknown): readonly Diagnostic[];
+    propertyOrdering(key: PropertyKey): OrderingKind | undefined;
+    callableExists(key: AddressKey.Callable): boolean;
+    callableInput(key: AddressKey.Callable, input: unknown): readonly Diagnostic[];
+    callableFields(key: AddressKey.Callable): readonly string[] | undefined;
+    callableInputField(key: AddressKey.Callable, field: string, input: unknown): readonly Diagnostic[];
+    callableOutput(key: AddressKey.Callable, output: unknown): readonly Diagnostic[];
+}

package/dist/v1/domain/model/input.js

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

package/dist/v1/domain/namespace/member-collection.d.ts

@@ -0,0 +1,5 @@
+import type { ResolvedMethod, ResolvedMethodCollection } from '../../language/callable/resolved.js';
+import type { ResolvedProperty, ResolvedPropertyCollection } from '../../language/class/resolved.js';
+export declare function createPropertyCollection(values: Iterable<ResolvedProperty>): ResolvedPropertyCollection;
+export declare function createMethodCollection(values: Iterable<ResolvedMethod>): ResolvedMethodCollection;
+export declare function frozenRecord<Value>(entries: Iterable<readonly [string, Value]>): Readonly<Record<string, Value>>;

package/dist/v1/domain/namespace/member-collection.js

@@ -0,0 +1,81 @@
+import { PropertyKey as PropertyKeyValue } from '../../addressing/index.js';
+import { createPropertyValues } from '../../language/class/property-values.js';
+const PROPERTY_OPERATIONS = new Set(['byKey', 'get', 'from']);
+const METHOD_OPERATIONS = new Set(['byKey', 'get']);
+export function createPropertyCollection(values) {
+    const ordered = [...values].sort((left, right) => compare(left.key, right.key));
+    const byKey = frozenRecord(ordered.map((value) => [value.key, value]));
+    const named = uniqueNames(ordered);
+    const collection = {
+        byKey,
+        get(key) {
+            return byKey[key];
+        },
+        from(input) {
+            const entries = new Map();
+            const source = new Map();
+            for (const [candidate, value] of Object.entries(input)) {
+                const property = PropertyKeyValue.is(candidate) ? byKey[candidate] : named[candidate];
+                if (property === undefined) {
+                    throw new TypeError(`Unknown or ambiguous Property ${JSON.stringify(candidate)}.`);
+                }
+                if (entries.has(property.key)) {
+                    throw new TypeError(`Property ${property.key} is supplied through both ${JSON.stringify(source.get(property.key))} and ${JSON.stringify(candidate)}.`);
+                }
+                const diagnostics = property.validate(value);
+                if (diagnostics.length > 0) {
+                    throw new TypeError(`Invalid value for Property ${property.key}: ${diagnostics.map(({ message }) => message).join('; ')}`);
+                }
+                source.set(property.key, candidate);
+                entries.set(property.key, value);
+            }
+            return createPropertyValues(entries);
+        },
+        *[Symbol.iterator]() {
+            yield* ordered;
+        },
+    };
+    installShortcuts(collection, named, PROPERTY_OPERATIONS);
+    return Object.freeze(collection);
+}
+export function createMethodCollection(values) {
+    const ordered = [...values].sort((left, right) => compare(left.key, right.key));
+    const byKey = frozenRecord(ordered.map((value) => [value.key, value]));
+    const named = uniqueNames(ordered);
+    const collection = {
+        byKey,
+        get(key) {
+            return byKey[key];
+        },
+        *[Symbol.iterator]() {
+            yield* ordered;
+        },
+    };
+    installShortcuts(collection, named, METHOD_OPERATIONS);
+    return Object.freeze(collection);
+}
+function uniqueNames(values) {
+    const candidates = new Map();
+    for (const value of values) {
+        const list = candidates.get(value.name) ?? [];
+        list.push(value);
+        candidates.set(value.name, list);
+    }
+    return frozenRecord([...candidates].flatMap(([name, list]) => list.length === 1 ? [[name, list[0]]] : []));
+}
+function installShortcuts(target, named, reserved) {
+    for (const [name, value] of Object.entries(named)) {
+        if (!reserved.has(name))
+            Object.defineProperty(target, name, { enumerable: true, value });
+    }
+}
+export function frozenRecord(entries) {
+    const output = Object.create(null);
+    for (const [key, value] of [...entries].sort(([left], [right]) => compare(left, right))) {
+        Object.defineProperty(output, key, { enumerable: true, value });
+    }
+    return Object.freeze(output);
+}
+function compare(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}

package/dist/v1/domain/projection/classes.d.ts

@@ -0,0 +1,4 @@
+import type { AnyResolvedClass } from '../../language/class/resolved.js';
+import type { Definition } from '../../language/definition.js';
+import type { DomainValidation } from '../model/input.js';
+export declare function createClasses(definitions: readonly Definition[], validation: DomainValidation): ReadonlyMap<string, AnyResolvedClass>;

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

@@ -0,0 +1,178 @@
+import { Key, MethodKey as MethodKeyValue, PropertyKey as PropertyKeyValue, } from '../../addressing/index.js';
+import { isMethodExecutable } from '../../language/callable/executable.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';
+export function createClasses(definitions, validation) {
+    const declarations = new Map(definitions
+        .filter((value) => value.ref.kind === 'class')
+        .map((value) => [Key.of(value.ref), value]));
+    const resolved = new Map();
+    const visiting = new Set();
+    const resolve = (ref) => {
+        const key = Key.of(ref);
+        const cached = resolved.get(key);
+        if (cached !== undefined)
+            return cached;
+        if (visiting.has(key))
+            throw new TypeError(`Class inheritance cycle reaches ${key}.`);
+        const definition = declarations.get(key);
+        if (definition === undefined)
+            throw new TypeError(`Class ${key} is absent from Domain input.`);
+        visiting.add(key);
+        const parents = definition.extends.map(resolve);
+        if (parents.some((parent) => parent.kind !== definition.kind)) {
+            throw new TypeError(`Class ${key} extends a Class of another graph kind.`);
+        }
+        const shell = {};
+        const effectiveProperties = new Map();
+        let inheritedData;
+        for (const parent of parents) {
+            for (const property of parent.properties) {
+                effectiveProperties.set(property.key, property);
+            }
+            if (parent.kind === 'node' && inheritedData === undefined)
+                inheritedData = parent.data;
+        }
+        const ownProperties = [];
+        for (const [name, propertyDefinition] of Object.entries(definition.properties)) {
+            const propertyKey = PropertyKeyValue.of(ref, name);
+            const ordering = validation.propertyOrdering(propertyKey);
+            const property = Object.freeze({
+                owner: shell,
+                name,
+                key: propertyKey,
+                definition: propertyDefinition,
+                ...(ordering === undefined ? {} : { ordering }),
+                validate: (input) => validation.property(propertyKey, input),
+            });
+            ownProperties.push(property);
+            effectiveProperties.set(property.key, property);
+        }
+        const ownInstanceMethods = [];
+        const ownStaticMethods = [];
+        const ownData = definition.kind === 'node' && definition.data !== undefined
+            ? Object.freeze({ owner: shell, definition: definition.data })
+            : undefined;
+        if (definition.kind === 'node') {
+            for (const [name, methodDefinition] of Object.entries(definition.methods)) {
+                const methodKey = MethodKeyValue.of(ref, name);
+                const inputFields = validation.callableFields(methodKey);
+                const method = Object.freeze({
+                    owner: shell,
+                    name,
+                    key: methodKey,
+                    description: methodDefinition.description,
+                    input: methodDefinition.input,
+                    output: methodDefinition.output,
+                    ...(methodDefinition.execution === undefined
+                        ? {}
+                        : { execution: methodDefinition.execution }),
+                    auth: methodDefinition.auth,
+                    policy: methodDefinition.policy,
+                    static: methodDefinition.static,
+                    abstract: methodDefinition.abstract,
+                    executable: isMethodExecutable(definition, methodDefinition),
+                    ...(inputFields === undefined ? {} : { inputFields }),
+                    definition: methodDefinition,
+                    validateInput: (input) => validation.callableInput(methodKey, input),
+                    validateInputField: (field, input) => validation.callableInputField(methodKey, field, input),
+                    validateOutput: (output) => validation.callableOutput(methodKey, output),
+                });
+                (methodDefinition.static ? ownStaticMethods : ownInstanceMethods).push(method);
+            }
+        }
+        Object.assign(shell, {
+            ref: definition.ref,
+            key,
+            kind: definition.kind,
+            abstract: definition.abstract,
+            definition,
+            extends: Object.freeze(parents),
+            policies: definition.policies,
+            data: definition.kind === 'node' ? (ownData ?? inheritedData) : undefined,
+            properties: createPropertyCollection(effectiveProperties.values()),
+            methods: createMethodCollection(ownInstanceMethods),
+            static: Object.freeze({ methods: createMethodCollection(ownStaticMethods) }),
+            self: Object.freeze({
+                data: definition.kind === 'node' ? ownData : undefined,
+                properties: createPropertyCollection(ownProperties),
+                methods: createMethodCollection(ownInstanceMethods),
+                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;
+                });
+            },
+            validateProperties(input) {
+                return validateProperties(definition.abstract, effectiveProperties, input);
+            },
+        });
+        const value = Object.freeze(shell);
+        resolved.set(key, value);
+        visiting.delete(key);
+        return value;
+    };
+    for (const definition of declarations.values())
+        resolve(definition.ref);
+    return resolved;
+}
+function validateProperties(abstract, properties, input) {
+    if (abstract) {
+        return [
+            {
+                code: 'DOMAIN_CLASS_ABSTRACT',
+                pointer: '/class',
+                message: 'An abstract Class cannot admit exact object Properties.',
+            },
+        ];
+    }
+    let values;
+    try {
+        values = acceptPropertyValues(input, '/properties');
+    }
+    catch (cause) {
+        return [
+            {
+                code: 'DOMAIN_PROPERTY_INPUT_INVALID',
+                pointer: '/properties',
+                message: cause instanceof Error ? cause.message : 'Properties are not canonical.',
+            },
+        ];
+    }
+    const diagnostics = [];
+    for (const key of Object.keys(values)) {
+        if (!properties.has(key)) {
+            diagnostics.push({
+                code: 'DOMAIN_PROPERTY_UNKNOWN',
+                pointer: appendPointer('/properties', key),
+                message: `Property ${key} is not effective on this Class.`,
+            });
+        }
+    }
+    for (const property of properties.values()) {
+        if (!Object.hasOwn(values, property.key)) {
+            if (property.definition.required) {
+                diagnostics.push({
+                    code: 'DOMAIN_PROPERTY_REQUIRED',
+                    pointer: appendPointer('/properties', property.key),
+                    message: `Required Property ${property.key} is absent.`,
+                });
+            }
+            continue;
+        }
+        const pointer = appendPointer('/properties', property.key);
+        diagnostics.push(...property.validate(values[property.key]).map((item) => ({
+            ...item,
+            pointer: `${pointer}${item.pointer}`,
+        })));
+    }
+    return Object.freeze(diagnostics);
+}