@astrale-os/kernel-dsl 0.2.0-beta.5 → 0.2.0-beta.7

package/dist/v1/compiled/codec/json.d.ts

@@ -0,0 +1,3 @@
+import type { CompiledSchema } from '../model/schema.js';
+export declare function encode(schema: CompiledSchema): Uint8Array;
+export declare function decode(input: string | Uint8Array): CompiledSchema;

package/dist/v1/compiled/codec/json.js

@@ -0,0 +1,9 @@
+import { json } from '@astrale-os/kernel-dsl/value';
+import { acceptCompiledSchema } from '../admission/accept.js';
+export function encode(schema) {
+    return new TextEncoder().encode(json.serialize(schema));
+}
+export function decode(input) {
+    const text = typeof input === 'string' ? input : new TextDecoder().decode(input);
+    return acceptCompiledSchema(json.decode(text));
+}

package/dist/v1/compiled/compiler/compile.d.ts

@@ -0,0 +1,4 @@
+import type { DomainOfSchema, DomainSchema } from '../../schema/model/schema.js';
+import type { CompiledSchema } from '../model/schema.js';
+/** Compile one admitted source closure into deterministic, dependency-closed Domain data. */
+export declare function compile<const Schema extends DomainSchema>(schema: Schema): CompiledSchema<DomainOfSchema<Schema>>;

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

@@ -0,0 +1,113 @@
+import { inputFieldNodes } from '../../language/value/compile/fields.js';
+import { prepareValueSchema } from '../../language/value/evaluate/preparation.js';
+import { classifyOrdering } from '../../language/value/ordering.js';
+import { revisionOfDomainSchema } from '../../schema/canonical/revision.js';
+import { lookupForDomainClosure, requireDomainClosure } from '../../schema/resolution/closure.js';
+import { createDomainValueSchemaRegistry } from '../../schema/resolution/value.registry.js';
+/** Compile one admitted source closure into deterministic, dependency-closed Domain data. */
+export function compile(schema) {
+    const lookup = lookupForDomainClosure(schema);
+    const sources = [
+        schema,
+        ...requireDomainClosure(schema).map(({ schema: dependency }) => dependency),
+    ]
+        .filter((value, index, all) => all.findIndex(({ origin }) => origin === value.origin) === index)
+        .sort((left, right) => compare(left.origin, right.origin));
+    const closure = Object.freeze(sources.map((source) => compileEntry(source, lookup)));
+    return Object.freeze({
+        format: 'astrale.dsl.compiled-schema',
+        version: 1,
+        root: Object.freeze({ origin: schema.origin, revision: revisionOfDomainSchema(schema) }),
+        closure,
+    });
+}
+function compileEntry(schema, lookup) {
+    const registry = createDomainValueSchemaRegistry(schema, lookup);
+    const values = [];
+    const add = (contract, pointer) => {
+        const result = prepareValueSchema(contract, registry, pointer);
+        if (!result.compiled)
+            throw new TypeError(`Cannot compile ValueSchema: ${result.message}`);
+        return values.push(result.value.program()) - 1;
+    };
+    const properties = (definition, pointer) => Object.entries(definition.properties)
+        .sort(([left], [right]) => compare(left, right))
+        .map(([name, property]) => {
+        const ordering = classifyOrdering(property.schema, registry);
+        return {
+            name,
+            required: property.required,
+            visibility: property.visibility,
+            ...(property.auto === undefined ? {} : { auto: property.auto }),
+            ...(property.description === undefined ? {} : { description: property.description }),
+            ...(ordering === undefined ? {} : { ordering }),
+            value: add(property.schema, `${pointer}/properties/${name}/schema`),
+        };
+    });
+    const output = (value, pointer) => value.mode === 'binary'
+        ? { mode: 'binary' }
+        : {
+            mode: value.mode,
+            value: add(value.mode === 'value' ? value.schema : value.item, pointer),
+        };
+    const classes = Object.values(schema.classes)
+        .sort((left, right) => compare(left.ref.name, right.ref.name))
+        .map((definition) => {
+        const pointer = `/classes/${definition.ref.name}`;
+        if (definition.kind === 'edge') {
+            const { properties: _, ...rest } = definition;
+            return { ...rest, properties: properties(definition, pointer) };
+        }
+        const { properties: _, methods: __, ...rest } = definition;
+        const methods = Object.entries(definition.methods)
+            .sort(([left], [right]) => compare(left, right))
+            .map(([name, method]) => {
+            const input = add(method.input, `${pointer}/methods/${name}/input`);
+            const fields = inputFieldNodes(values[input]);
+            return {
+                name,
+                auth: method.auth,
+                ...(method.policy === undefined ? {} : { policy: method.policy }),
+                ...(method.description === undefined ? {} : { description: method.description }),
+                static: method.static,
+                inheritance: method.inheritance,
+                input,
+                ...(fields === undefined ? {} : { fields }),
+                output: output(method.output, `${pointer}/methods/${name}/output`),
+            };
+        });
+        return { ...rest, properties: properties(definition, pointer), methods };
+    });
+    const functions = Object.values(schema.functions)
+        .sort((left, right) => compare(left.ref.name, right.ref.name))
+        .map((definition) => {
+        const input = add(definition.input, `/functions/${definition.ref.name}/input`);
+        const fields = inputFieldNodes(values[input]);
+        return {
+            ref: definition.ref,
+            auth: definition.auth,
+            ...(definition.policy === undefined ? {} : { policy: definition.policy }),
+            ...(definition.description === undefined ? {} : { description: definition.description }),
+            input,
+            ...(fields === undefined ? {} : { fields }),
+            output: output(definition.output, `/functions/${definition.ref.name}/output`),
+        };
+    });
+    return Object.freeze({
+        origin: schema.origin,
+        revision: revisionOfDomainSchema(schema),
+        dependencies: schema.dependencies,
+        definitions: Object.freeze({
+            classes: Object.freeze(classes),
+            functions: Object.freeze(functions),
+            policies: Object.freeze(Object.values(schema.policies)),
+            views: Object.freeze(Object.values(schema.views)),
+            core: Object.freeze(Object.values(schema.core.nodes)),
+        }),
+        facts: Object.freeze({ core: schema.core.edges }),
+        values: Object.freeze(values),
+    });
+}
+function compare(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}

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

@@ -0,0 +1,11 @@
+export type CompiledDiagnosticCode = 'COMPILED_CANONICAL_MISMATCH' | 'COMPILED_DEPENDENCY_CYCLE' | 'COMPILED_SOURCE_INVALID' | 'COMPILED_STRUCTURE_INVALID';
+export interface CompiledDiagnostic<out Code extends CompiledDiagnosticCode = CompiledDiagnosticCode> {
+    readonly code: Code;
+    readonly pointer: string;
+    readonly message: string;
+}
+export declare class CompiledSchemaError extends Error {
+    readonly diagnostics: readonly CompiledDiagnostic[];
+    constructor(diagnostics: readonly CompiledDiagnostic[], options?: ErrorOptions);
+}
+export declare function invalidCompiled(code: CompiledDiagnosticCode, message: string, pointer: string, options?: ErrorOptions): never;

package/dist/v1/compiled/diagnostic.js

@@ -0,0 +1,13 @@
+export class CompiledSchemaError extends Error {
+    diagnostics;
+    constructor(diagnostics, options) {
+        super(diagnostics
+            .map(({ code, pointer, message }) => `${pointer || '/'} [${code}] ${message}`)
+            .join('\n'), options);
+        this.name = 'CompiledSchemaError';
+        this.diagnostics = Object.freeze([...diagnostics]);
+    }
+}
+export function invalidCompiled(code, message, pointer, options) {
+    throw new CompiledSchemaError([Object.freeze({ code, pointer, message })], options);
+}

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

@@ -0,0 +1,7 @@
+export { acceptCompiledSchema as accept } from './admission/accept.js';
+export { compile } from './compiler/compile.js';
+export { decode, encode } from './codec/json.js';
+export { load } from './loader/load.js';
+export { CompiledSchemaError as Error } from './diagnostic.js';
+export type { CompiledDiagnostic as Diagnostic, CompiledDiagnosticCode as DiagnosticCode, } from './diagnostic.js';
+export type * from './model/schema.js';

package/dist/v1/compiled/index.js

@@ -0,0 +1,5 @@
+export { acceptCompiledSchema as accept } from './admission/accept.js';
+export { compile } from './compiler/compile.js';
+export { decode, encode } from './codec/json.js';
+export { load } from './loader/load.js';
+export { CompiledSchemaError as Error } from './diagnostic.js';

package/dist/v1/compiled/loader/index.d.ts

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

package/dist/v1/compiled/loader/index.js

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

package/dist/v1/compiled/loader/load.d.ts

@@ -0,0 +1,4 @@
+import type { CompiledSchema, DomainOfCompiled } from '../model/schema.js';
+/** Load admitted compiled data through the one resolved Domain constructor. */
+export declare function load<const Input extends CompiledSchema>(input: Input): DomainOfCompiled<Input>;
+export declare function load(input: unknown): import('../../domain/model/domain.js').Domain;

package/dist/v1/compiled/loader/load.js

@@ -0,0 +1,139 @@
+import { Key, MethodKey, PropertyKey as PropertyKeyValue } from '../../addressing/index.js';
+import { compareUnicode } from '../../addressing/ordering.js';
+import { createDomain } from '../../domain/create.js';
+import { combineDomainValidation, createDomainValidation, unknownInputField, } from '../../domain/validation/create.js';
+import { validateValueProgram } from '../../language/value/evaluate/program.js';
+import { acceptCompiledSchema } from '../admission/accept.js';
+export function load(input) {
+    const compiled = acceptCompiledSchema(input);
+    const entries = new Map(compiled.closure.map((entry) => [entry.origin, loadEntry(entry)]));
+    const root = entries.get(compiled.root.origin);
+    if (root === undefined || root.entry.revision !== compiled.root.revision) {
+        throw new TypeError('Compiled root is absent or has the wrong revision.');
+    }
+    return createDomain({
+        origin: root.entry.origin,
+        revision: root.entry.revision,
+        closure: Object.freeze(compiled.closure
+            .map(({ origin, revision }) => Object.freeze({ origin, revision }))
+            .sort((left, right) => compareUnicode(left.origin, right.origin))),
+        dependencies: root.entry.dependencies,
+        definitions: Object.freeze([...entries.values()].flatMap(({ definitions }) => definitions)),
+        coreEdges: root.entry.facts.core,
+        validation: combineDomainValidation([...entries.values()].map(({ validation }) => validation)),
+    });
+}
+function loadEntry(entry) {
+    const propertyPrograms = new Map();
+    const propertyOrdering = new Map();
+    const callablePrograms = new Map();
+    const classes = entry.definitions.classes.map((compiled) => {
+        const properties = Object.fromEntries(compiled.properties.map(({ name, value, ordering, ...definition }) => {
+            const key = PropertyKeyValue.of(compiled.ref, name);
+            propertyPrograms.set(key, value);
+            if (ordering !== undefined)
+                propertyOrdering.set(key, ordering);
+            return [name, { ...definition, schema: schemaOf(entry, value) }];
+        }));
+        if (compiled.kind === 'edge') {
+            const { properties: _, ...definition } = compiled;
+            return Object.freeze({ ...definition, properties });
+        }
+        const { properties: _, methods: __, ...definition } = compiled;
+        const methods = Object.fromEntries(compiled.methods.map((method) => {
+            const key = MethodKey.of(compiled.ref, method.name);
+            callablePrograms.set(key, callableProgram(method));
+            return [method.name, loadMethod(entry, method)];
+        }));
+        return Object.freeze({ ...definition, properties, methods });
+    });
+    const functions = entry.definitions.functions.map((compiled) => {
+        callablePrograms.set(Key.of(compiled.ref), callableProgram(compiled));
+        return loadFunction(entry, compiled);
+    });
+    return {
+        entry,
+        definitions: Object.freeze([
+            ...classes,
+            ...functions,
+            ...entry.definitions.policies,
+            ...entry.definitions.views,
+            ...entry.definitions.core,
+        ]),
+        validation: programValidation(entry.values, propertyPrograms, propertyOrdering, callablePrograms),
+    };
+}
+function loadMethod(entry, value) {
+    const { name: _, input, fields: __, output, ...definition } = value;
+    return Object.freeze({
+        ...definition,
+        input: schemaOf(entry, input),
+        output: loadOutput(entry, output),
+    });
+}
+function loadFunction(entry, value) {
+    const { input, fields: _, output, ...definition } = value;
+    return Object.freeze({
+        ...definition,
+        input: schemaOf(entry, input),
+        output: loadOutput(entry, output),
+    });
+}
+function loadOutput(entry, output) {
+    if (output.mode === 'binary')
+        return output;
+    const schema = schemaOf(entry, output.value);
+    return output.mode === 'value'
+        ? { mode: 'value', schema }
+        : { mode: 'stream', item: schema };
+}
+function schemaOf(entry, index) {
+    const program = entry.values[index];
+    const root = program?.nodes[program.root];
+    if (root === undefined)
+        throw new TypeError(`Compiled Value program ${index} is absent.`);
+    return root.schema;
+}
+function callableProgram(value) {
+    return {
+        input: value.input,
+        ...(value.fields === undefined ? {} : { fields: value.fields }),
+        ...(value.output.mode === 'binary' ? {} : { output: value.output.value }),
+    };
+}
+function programValidation(programs, properties, propertyOrdering, callables) {
+    const propertyValidation = new Map();
+    for (const [key, index] of properties) {
+        const program = programs[index];
+        if (program === undefined)
+            throw new TypeError(`Compiled Property program ${index} is absent.`);
+        propertyValidation.set(key, Object.freeze({
+            ordering: propertyOrdering.get(key),
+            validate: (value) => validateValueProgram(program, value),
+        }));
+    }
+    const callableValidation = new Map();
+    for (const [key, callable] of callables) {
+        const input = programs[callable.input];
+        if (input === undefined)
+            throw new TypeError(`Compiled Callable input ${callable.input} is absent.`);
+        const output = callable.output === undefined ? undefined : programs[callable.output];
+        if (callable.output !== undefined && output === undefined) {
+            throw new TypeError(`Compiled Callable output ${callable.output} is absent.`);
+        }
+        callableValidation.set(key, Object.freeze({
+            ...(callable.fields === undefined
+                ? {}
+                : { fields: Object.freeze(Object.keys(callable.fields)) }),
+            validateInput: (value) => validateValueProgram(input, value),
+            validateInputField(field, value) {
+                const nodes = callable.fields?.[field];
+                return nodes === undefined
+                    ? unknownInputField(field)
+                    : validateValueProgram(input, value, nodes);
+            },
+            validateOutput: (value) => output === undefined ? [] : validateValueProgram(output, value),
+        }));
+    }
+    return createDomainValidation(propertyValidation, callableValidation);
+}

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

@@ -0,0 +1,73 @@
+import type { Key } from '../../addressing/index.js';
+import type { DomainDependency, Revision } 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';
+import type { PropertyDefinition } from '../../language/class/model/property.js';
+import type { CoreDefinition, CoreEdge } from '../../language/core/model/core.js';
+import type { PolicyDefinition } from '../../language/policy/model/policy.js';
+import type { ValueProgram } from '../../language/value/compile/model.js';
+import type { OrderingKind } from '../../language/value/ordering.js';
+import type { ViewDefinition } from '../../language/view/model/view.js';
+export type { Pattern, PatternState, PatternTransition, ScalarRange, ValueNode, ValueProgram, } from '../../language/value/compile/model.js';
+export interface CompiledProperty extends Omit<PropertyDefinition, 'schema'> {
+    readonly name: string;
+    readonly value: number;
+    readonly ordering?: OrderingKind;
+}
+export interface CompiledMethod extends Omit<MethodDefinition, 'input' | 'output'> {
+    readonly name: string;
+    readonly input: number;
+    readonly fields?: Readonly<Record<string, readonly number[]>>;
+    readonly output: CompiledOutput;
+}
+export type CompiledOutput = {
+    readonly mode: 'value' | 'stream';
+    readonly value: number;
+} | {
+    readonly mode: 'binary';
+};
+export type CompiledClass = (Omit<Extract<ClassDefinition, {
+    readonly kind: 'node';
+}>, 'properties' | 'methods'> & {
+    readonly properties: readonly CompiledProperty[];
+    readonly methods: readonly CompiledMethod[];
+}) | (Omit<Extract<ClassDefinition, {
+    readonly kind: 'edge';
+}>, 'properties'> & {
+    readonly properties: readonly CompiledProperty[];
+});
+export interface CompiledFunction extends Omit<import('../../language/callable/model/callable.js').FunctionDefinition, 'input' | 'output'> {
+    readonly input: number;
+    readonly fields?: Readonly<Record<string, readonly number[]>>;
+    readonly output: CompiledOutput;
+}
+export type CompiledPolicy = PolicyDefinition;
+export type CompiledView = ViewDefinition;
+export type CompiledCoreDefinition = CoreDefinition;
+export type CompiledCoreEdge = CoreEdge;
+export interface CompiledSchemaEntry {
+    readonly origin: Key.Origin;
+    readonly revision: Revision;
+    readonly dependencies: readonly DomainDependency[];
+    readonly definitions: {
+        readonly classes: readonly CompiledClass[];
+        readonly functions: readonly CompiledFunction[];
+        readonly policies: readonly PolicyDefinition[];
+        readonly views: readonly ViewDefinition[];
+        readonly core: readonly CoreDefinition[];
+    };
+    readonly facts: {
+        readonly core: readonly CoreEdge[];
+    };
+    readonly values: readonly ValueProgram[];
+}
+declare const COMPILED_DOMAIN: unique symbol;
+export interface CompiledSchema<Resolved = Domain> {
+    readonly format: 'astrale.dsl.compiled-schema';
+    readonly version: 1;
+    readonly root: DomainDependency;
+    readonly closure: readonly CompiledSchemaEntry[];
+    readonly [COMPILED_DOMAIN]?: Resolved;
+}
+export type DomainOfCompiled<Value extends CompiledSchema> = Value extends CompiledSchema<infer Resolved> ? Resolved : Domain;

package/dist/v1/compiled/model/schema.js

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

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

@@ -0,0 +1,8 @@
+import type { Domain } from './model/domain.js';
+import type { SourceDomain } from './model/domain.js';
+import type { DomainInput } from './model/input.js';
+/** True only for an immutable Domain created by DSL resolution or compiled loading. */
+export declare function isDomain(input: unknown): input is Domain;
+/** Retain source provenance without losing the admitted Domain identity. */
+export declare function createSourceDomain<Source, Resolved extends Domain>(domain: Resolved, source: Source): SourceDomain<Source, Resolved>;
+export declare function createDomain(input: DomainInput): Domain;

package/dist/v1/domain/create.js

@@ -0,0 +1,192 @@
+import { Key } 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 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;
+}
+export function createDomain(input) {
+    const classesByKey = createClasses(input.definitions, input.validation);
+    const definitionsByKey = new Map();
+    for (const value of classesByKey.values())
+        definitionsByKey.set(value.key, value);
+    for (const definition of input.definitions) {
+        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,
+                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);
+            const resolved = Object.freeze({
+                ref: definition.ref,
+                key,
+                expression: definition.expression,
+                description: definition.description,
+                definition,
+            });
+            definitionsByKey.set(key, resolved);
+            continue;
+        }
+        if (isViewDefinition(definition)) {
+            const key = Key.of(definition.ref);
+            const resolved = Object.freeze({
+                ref: definition.ref,
+                key,
+                target: definition.target,
+                description: definition.description,
+                definition,
+            });
+            definitionsByKey.set(key, resolved);
+            continue;
+        }
+    }
+    for (const definition of input.definitions) {
+        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);
+    }
+    const local = [...definitionsByKey.values()]
+        .filter(({ ref }) => ref.origin === input.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: input.origin,
+    });
+    const coreEdges = Object.freeze(input.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)}.`);
+        return Object.freeze({
+            class: classValue,
+            source: edge.source.kind === 'domain'
+                ? domainEndpoint
+                : requiredCore(definitionsByKey, edge.source),
+            target: edge.target.kind === 'domain'
+                ? domainEndpoint
+                : requiredCore(definitionsByKey, edge.target),
+            properties: edge.properties,
+        });
+    }));
+    const callables = new Map();
+    for (const definition of definitionsByKey.values()) {
+        if (definition.ref.kind === 'function')
+            callables.set(definition.key, definition);
+    }
+    for (const definition of classesByKey.values()) {
+        if (definition.kind !== 'node')
+            continue;
+        for (const method of [...definition.methods, ...definition.static.methods])
+            callables.set(method.key, method);
+    }
+    const definitionLookup = ((value) => definitionsByKey.get(typeof value === 'string' ? value : Key.of(value)));
+    const domain = {
+        origin: input.origin,
+        revision: input.revision,
+        closure: Object.freeze(input.closure.map(({ origin, revision }) => Object.freeze({ origin, revision }))),
+        dependencies: Object.freeze(input.dependencies.map(({ origin, revision }) => Object.freeze({ origin, revision }))),
+        classes,
+        functions,
+        policies,
+        views,
+        core: Object.freeze({ nodes: coreNodes, edges: coreEdges }),
+        definition: definitionLookup,
+        callable(key) {
+            return callables.get(key);
+        },
+        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);
+    admittedDomains.add(admitted);
+    return admitted;
+}
+function namespace(definitions, kind) {
+    return frozenRecord(definitions
+        .filter((value) => value.ref.kind === kind)
+        .map((value) => [value.ref.name, value]));
+}
+function requiredCore(definitions, ref) {
+    const value = definitions.get(Key.of(ref));
+    if (value?.ref.kind !== 'core')
+        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';