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

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

@@ -0,0 +1,134 @@
+import { assertKnownKeys } from '../schema/diagnostic.js';
+import { authoringValue } from '../schema/handle.js';
+const classInputs = new WeakMap();
+export function defineClass(config) {
+    if (config.kind === 'node') {
+        const { kind: _, ...input } = config;
+        return nodeClass(input);
+    }
+    if (config.orientation === 'directed') {
+        const { kind: _, orientation: __, ...input } = config;
+        return edgeClass.directed(input);
+    }
+    const { kind: _, orientation: __, ...input } = config;
+    return edgeClass.undirected(input);
+}
+export function nodeClass(config) {
+    const admitted = config ?? {};
+    assertKnownKeys(admitted, [
+        'abstract',
+        'description',
+        'extends',
+        'properties',
+        'data',
+        'methods',
+        'icon',
+        'policies',
+    ]);
+    if (admitted.policies !== undefined)
+        assertKnownKeys(admitted.policies, ['read', 'traverse']);
+    const value = authoringValue('definition', {
+        kind: 'node',
+    });
+    classInputs.set(value, { ...admitted, abstract: admitted.abstract ?? false });
+    return value;
+}
+export const edgeClass = Object.freeze({
+    directed(input) {
+        assertKnownKeys(input, [
+            'source',
+            'target',
+            'abstract',
+            'description',
+            'extends',
+            'properties',
+            'policies',
+            'constraints',
+        ]);
+        validateDirectedSourceInput(input.source);
+        validateDirectedTargetInput(input.target);
+        const { source, target, ...options } = input;
+        validateEdgeClassOptions(options);
+        const value = authoringValue('definition', {
+            kind: 'edge',
+            orientation: 'directed',
+        });
+        classInputs.set(value, {
+            source: { ...source },
+            target: { ...target },
+            ...options,
+            abstract: options.abstract ?? false,
+        });
+        return value;
+    },
+    undirected(input) {
+        assertKnownKeys(input, [
+            'endpoints',
+            'abstract',
+            'description',
+            'extends',
+            'properties',
+            'policies',
+            'constraints',
+        ]);
+        if (input.endpoints.length !== 2)
+            throw new TypeError('Undirected Edge Classes require exactly two endpoints.');
+        validateIncidentEndpointInput(input.endpoints[0]);
+        validateIncidentEndpointInput(input.endpoints[1]);
+        const { endpoints, ...options } = input;
+        validateUndirectedEdgeClassOptions(options);
+        const value = authoringValue('definition', {
+            kind: 'edge',
+            orientation: 'undirected',
+        });
+        classInputs.set(value, {
+            endpoints: [{ ...endpoints[0] }, { ...endpoints[1] }],
+            ...options,
+            abstract: options.abstract ?? false,
+        });
+        return value;
+    },
+});
+export function classConfiguration(value) {
+    const input = classInputs.get(value);
+    if (input === undefined)
+        throw new TypeError('Unknown Class authoring handle.');
+    return input;
+}
+function validateDirectedSourceInput(value) {
+    assertKnownKeys(value, ['as', 'accepts', 'outgoing']);
+}
+function validateDirectedTargetInput(value) {
+    assertKnownKeys(value, ['as', 'accepts', 'incoming']);
+}
+function validateIncidentEndpointInput(value) {
+    assertKnownKeys(value, ['as', 'accepts', 'incident']);
+}
+function validateEdgeClassOptions(value) {
+    assertKnownKeys(value, [
+        'abstract',
+        'description',
+        'extends',
+        'properties',
+        'policies',
+        'constraints',
+    ]);
+    if (value.policies !== undefined)
+        assertKnownKeys(value.policies, ['traverse']);
+    if (value.constraints !== undefined)
+        assertKnownKeys(value.constraints, ['noSelf', 'acyclic']);
+}
+function validateUndirectedEdgeClassOptions(value) {
+    assertKnownKeys(value, [
+        'abstract',
+        'description',
+        'extends',
+        'properties',
+        'policies',
+        'constraints',
+    ]);
+    if (value.policies !== undefined)
+        assertKnownKeys(value.policies, ['traverse']);
+    if (value.constraints !== undefined)
+        assertKnownKeys(value.constraints, ['noSelf']);
+}

package/dist/v1/builder/class/property.d.ts

@@ -0,0 +1,52 @@
+import type { z } from 'zod';
+import type { AutoEvent, AutoSet } from '../../language/class/model/property.js';
+import type { JsonSchema } from '../../language/value/model/schema.js';
+import type { AUTHORING } from '../schema/handle.js';
+declare const PROPERTY_INPUT: unique symbol;
+declare const AUTO_INPUT: unique symbol;
+export type ValueSchemaInput = z.ZodType | JsonSchema;
+export interface PropertyOptions {
+    readonly visibility?: 'public' | 'private';
+    readonly required?: boolean;
+    readonly description?: string;
+}
+export interface AutoOptions {
+    readonly on: AutoEvent | readonly AutoEvent[];
+    readonly set: AutoSet;
+}
+export interface Property<out Schema extends ValueSchemaInput = ValueSchemaInput, out Options extends PropertyOptions = PropertyOptions> {
+    readonly [AUTHORING]: 'property';
+    readonly [PROPERTY_INPUT]: {
+        readonly schema: Schema;
+        readonly options: Options;
+    };
+}
+export type PropertySchemaOf<Value extends Property> = Value extends Property<infer Schema, PropertyOptions> ? Schema : never;
+export type PropertyOptionsOf<Value extends Property> = Value extends Property<ValueSchemaInput, infer Options> ? Options : never;
+export interface AutoProperty<out PropertyValue extends Property = Property> {
+    readonly [AUTHORING]: 'auto';
+    readonly [AUTO_INPUT]: {
+        readonly property: PropertyValue;
+        readonly options: {
+            readonly on: readonly AutoEvent[];
+            readonly set: AutoSet;
+        };
+    };
+}
+export type PropertyAuthoringInput<Value extends Property> = Value extends Property<infer Schema, infer Options> ? {
+    readonly schema: Schema;
+    readonly options: Options;
+} : never;
+export declare function propertyAuthoringInput<const Value extends Property>(value: Value): PropertyAuthoringInput<Value>;
+export declare function autoPropertyAuthoringInput<const Value extends AutoProperty>(value: Value): Value extends AutoProperty<infer Property> ? {
+    readonly property: Property;
+    readonly options: {
+        readonly on: readonly AutoEvent[];
+        readonly set: AutoSet;
+    };
+} : never;
+export type PropertyFieldInput = ValueSchemaInput | Property | AutoProperty;
+export type PropertyRecordInput = Readonly<Record<string, PropertyFieldInput>>;
+export declare function property<const Schema extends ValueSchemaInput, const Options extends PropertyOptions = Record<never, never>>(schema: Schema, options?: Options): Property<Schema, Options>;
+export declare function auto<const PropertyValue extends Property>(property: PropertyValue, options: AutoOptions): AutoProperty<PropertyValue>;
+export {};

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

@@ -0,0 +1,49 @@
+import { assertKnownKeys, fail } from '../schema/diagnostic.js';
+import { authoringValue, isAuthoringValue } from '../schema/handle.js';
+const PROPERTY_INPUT = Symbol('astrale.v1.property-input');
+const AUTO_INPUT = Symbol('astrale.v1.auto-property-input');
+export function propertyAuthoringInput(value) {
+    return value[PROPERTY_INPUT];
+}
+export function autoPropertyAuthoringInput(value) {
+    return value[AUTO_INPUT];
+}
+export function property(schema, options) {
+    const admitted = options ?? {};
+    assertKnownKeys(admitted, ['visibility', 'required', 'description']);
+    return authoringValue('property', {
+        [PROPERTY_INPUT]: {
+            schema,
+            options: {
+                ...admitted,
+                visibility: admitted.visibility ?? 'public',
+            },
+        },
+    });
+}
+export function auto(property, options) {
+    if (isAuthoringValue(property, 'auto')) {
+        fail('BUILDER_AUTO_NESTED', '', 'auto(...) cannot wrap another auto Property.');
+    }
+    assertKnownKeys(options, ['on', 'set']);
+    const authored = Array.isArray(options.on) ? options.on : [options.on];
+    if (authored.length === 0)
+        fail('BUILDER_AUTO_EVENT_INVALID', '/on', 'auto(...) requires an event.');
+    const events = [...new Set(authored)];
+    if (events.some((event) => event !== 'create' && event !== 'update')) {
+        fail('BUILDER_AUTO_EVENT_INVALID', '/on', 'Automatic events are create or update.');
+    }
+    if (options.set !== 'instant') {
+        fail('BUILDER_AUTO_SET_INVALID', '/set', 'The auto setter must be instant.');
+    }
+    events.sort((left, right) => (left === right ? 0 : left === 'create' ? -1 : 1));
+    if (propertyAuthoringInput(property).options.required === true && !events.includes('create')) {
+        fail('BUILDER_AUTO_EVENT_INVALID', '/on', 'A required auto Property must run on create.');
+    }
+    return authoringValue('auto', {
+        [AUTO_INPUT]: {
+            property,
+            options: { on: Object.freeze(events), set: options.set },
+        },
+    });
+}

package/dist/v1/builder/core/authoring.d.ts

@@ -0,0 +1,42 @@
+import type { Object as JsonObject } from '@astrale-os/kernel-dsl/value';
+import type { CoreRef } from '../../addressing/index.js';
+import type { DomainEndpointRef } from '../../language/core/model/core.js';
+import type { EdgeClass, NodeClass } from '../class/authoring.js';
+import type { AUTHORING } from '../schema/handle.js';
+import type { Lazy } from '../schema/lazy.js';
+import type { CoreNamedPropertyInput } from '../schema/projection.js';
+interface CoreNodeConfiguration {
+    readonly class: Lazy<NodeClass>;
+    readonly properties: JsonObject;
+}
+interface CoreEdgeConfiguration {
+    readonly source: CoreEndpoint;
+    readonly class: Lazy<EdgeClass>;
+    readonly target: CoreEndpoint;
+    readonly properties: JsonObject;
+}
+export interface CoreNode {
+    readonly [AUTHORING]: 'core-node';
+}
+export type CoreEndpoint = CoreNode | CoreRef | DomainEndpointRef;
+export interface CoreEdge {
+    readonly [AUTHORING]: 'core-edge';
+}
+export interface CoreInput {
+    readonly nodes?: Readonly<Record<string, CoreNode>>;
+    readonly edges?: readonly CoreEdge[];
+}
+/** Internal lowering access; Core Node handles expose no public configuration object. */
+export declare function coreNodeConfiguration(value: CoreNode): CoreNodeConfiguration;
+/** Internal lowering access; Core Edge handles expose no public configuration object. */
+export declare function coreEdgeConfiguration(value: CoreEdge): CoreEdgeConfiguration;
+declare function node(definition: () => NodeClass, properties: JsonObject): CoreNode;
+declare function node<const Definition extends NodeClass, const Properties extends CoreNamedPropertyInput<Definition> & JsonObject>(definition: Definition, properties: Properties): CoreNode;
+declare function edge(source: CoreEndpoint, definition: () => EdgeClass, target: CoreEndpoint, properties: JsonObject): CoreEdge;
+declare function edge<const Definition extends EdgeClass, const Properties extends CoreNamedPropertyInput<Definition> & JsonObject>(source: CoreEndpoint, definition: Definition, target: CoreEndpoint, properties: Properties): CoreEdge;
+export declare const core: Readonly<{
+    node: typeof node;
+    edge: typeof edge;
+    domain: DomainEndpointRef;
+}>;
+export {};

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

@@ -0,0 +1,39 @@
+import { accept as acceptJsonValue } from '@astrale-os/kernel-dsl/value';
+import { authoringValue } from '../schema/handle.js';
+const coreNodeConfigurations = new WeakMap();
+const coreEdgeConfigurations = new WeakMap();
+/** Reference the owning Domain instance as one Core Edge endpoint. */
+const domain = Object.freeze({ kind: 'domain' });
+/** Internal lowering access; Core Node handles expose no public configuration object. */
+export function coreNodeConfiguration(value) {
+    const configuration = coreNodeConfigurations.get(value);
+    if (configuration === undefined)
+        throw new TypeError('Unknown Core Node authoring handle.');
+    return configuration;
+}
+/** Internal lowering access; Core Edge handles expose no public configuration object. */
+export function coreEdgeConfiguration(value) {
+    const configuration = coreEdgeConfigurations.get(value);
+    if (configuration === undefined)
+        throw new TypeError('Unknown Core Edge authoring handle.');
+    return configuration;
+}
+function node(definition, properties) {
+    const value = authoringValue('core-node', {});
+    coreNodeConfigurations.set(value, {
+        class: definition,
+        properties: acceptJsonValue(properties),
+    });
+    return value;
+}
+function edge(source, definition, target, properties) {
+    const value = authoringValue('core-edge', {});
+    coreEdgeConfigurations.set(value, {
+        source,
+        class: definition,
+        target,
+        properties: acceptJsonValue(properties),
+    });
+    return value;
+}
+export const core = Object.freeze({ node, edge, domain });

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

@@ -1,22 +1,26 @@
-export { fn, output } from './callable.js';
-export { domain, edge, node } from './core.js';
-export { defineInterface, edgeClass, edgeInterface, nodeClass, nodeInterface, } from './definition.js';
-export { fullMatch } from './full-match.js';
-export type { FullMatch } from './full-match.js';
-export { path } from './path.js';
-export { definePolicy, policy } from './policy.js';
-export { property } from './property.js';
-export { defineSchema } from './schema.js';
-export { valueSchema } from './value-schema.js';
-export { view } from './view.js';
-export type { AuthoredCallableInput, CallableInput, CallableOutputInput, CallablePolicyBuilder, CallablePolicyContext, BinaryOutput, FunctionAuthoring as Function, PolicyObjectAuthoring, PolicyObjectInput, StreamOutput, } from './callable.js';
-export type { CoreEdgeAuthoring as Edge, CoreEndpointAuthoring as CoreEndpoint, CoreInput as Core, CoreNodeAuthoring as Node, } from './core.js';
-export type { DefinitionAuthoring as Definition, DefinitionReferenceInput as DefinitionRef, DefinitionReferenceInput as DefinitionReference, EdgeClassAuthoring as EdgeClass, EdgeInterfaceAuthoring as EdgeInterface, EdgeClassOptions, EdgeInterfaceOptions, EndpointInput as Endpoint, InterfaceAuthoring as Interface, InterfaceInput, NodeClassAuthoring as NodeClass, NodeClassInput, NodeDefinitionReferenceInput as NodeDefinitionReference, NodeInterfaceAuthoring as NodeInterface, NodeInterfaceInput, } from './definition.js';
-export type { PathAuthoring as Path } from './path.js';
-export type { Lazy } from './internal/authoring.lazy.js';
-export type { MatchPolicyInput, Policy, PolicyComposition, PolicyEdgeInput, PolicyExistsContext, PolicyInput, PolicyPatternContext, } from './policy.js';
-export type { PropertyAuthoring as Property, PropertyFieldInput, PropertyOptions, PropertyRecordInput, ValueSchemaInput, } from './property.js';
-export type { DomainSchemaInput as SchemaInput } from './schema.input.js';
-export type { TypedValueSchema } from './value-schema.js';
-export type { ViewAuthoring as View, ViewDefinitionTargetsInput, ViewInput, ViewTargetInput, } from './view.js';
-//# sourceMappingURL=index.d.ts.map
+export { func, method, output } from './callable/authoring.js';
+export { core } from './core/authoring.js';
+export { defineClass, edgeClass, nodeClass } from './class/authoring.js';
+export { fullMatch } from './value/full-match.js';
+export { path } from './value/path.js';
+export { policy } from './policy/authoring.js';
+export { auto, property } from './class/property.js';
+export { defineSchema } from './schema/define.js';
+export type { DefinedSchema } from './schema/define.js';
+export type { ResolvedDomainOfInput } from './schema/projection.js';
+export { valueSchema } from './value/schema.js';
+export { view } from './view/authoring.js';
+export { BuilderError as Error } from './schema/diagnostic.js';
+export type { BuilderDiagnostic as Diagnostic, BuilderDiagnosticCode as DiagnosticCode, } from './schema/diagnostic.js';
+export type { CallableInputBase, CallableInput, CallableOutputInput, CallableProjection, CallablePolicyBuilder, CallablePolicyContext, BinaryOutput, Function, FunctionInput, Method, MethodInput, PolicyObjectInput, StreamOutput, } from './callable/authoring.js';
+export type { CoreEdge, CoreEndpoint, CoreInput, CoreNode } from './core/authoring.js';
+export type { AuthoredPropertyProjection, AuthoredMethodProjection, Class, ClassIdentityProjection, ClassOwnerProjection, ClassReferenceProjection, ClassReferenceInput as ClassReference, DirectedEdgeInput, DirectedEdgeClass, DirectedSourceInput, DirectedTargetInput, EdgeClassCommon, EdgeClassInput, EdgeClass, EdgeClassReferenceInput as EdgeClassReference, IncidentEndpointInput, NodeClass, NodeClassInput, NodeClassReferenceInput as NodeClassReference, UndirectedEdgeInput, UndirectedEdgeClass, } from './class/authoring.js';
+export type { PathAuthoring } from './value/path.js';
+export type { Lazy } from './schema/lazy.js';
+export type { MatchPolicyInput, Policy, PolicyBuilder as PolicyFactory, PolicyEdgeInput, PolicyExistsContext, PolicyInput, PolicyPatternContext, } from './policy/authoring.js';
+export type { AutoOptions, AutoProperty, Property, PropertyFieldInput as PropertyField, PropertyOptions, ValueSchemaInput, } from './class/property.js';
+export type { CorePropertyInput } from './schema/projection.js';
+export type { ClassProjection, FunctionProjection, MethodProjection, PropertyProjection, } from './schema/projection.js';
+export type { DomainSchemaInput as SchemaInput } from './schema/input.js';
+export type { TypedValueSchema } from './value/schema.js';
+export type { View, ViewInput } from './view/authoring.js';

package/dist/v1/builder/index.js

@@ -1,11 +1,11 @@
-export { fn, output } from './callable.js';
-export { domain, edge, node } from './core.js';
-export { defineInterface, edgeClass, edgeInterface, nodeClass, nodeInterface, } from './definition.js';
-export { fullMatch } from './full-match.js';
-export { path } from './path.js';
-export { definePolicy, policy } from './policy.js';
-export { property } from './property.js';
-export { defineSchema } from './schema.js';
-export { valueSchema } from './value-schema.js';
-export { view } from './view.js';
-//# sourceMappingURL=index.js.map
+export { func, method, output } from './callable/authoring.js';
+export { core } from './core/authoring.js';
+export { defineClass, edgeClass, nodeClass } from './class/authoring.js';
+export { fullMatch } from './value/full-match.js';
+export { path } from './value/path.js';
+export { policy } from './policy/authoring.js';
+export { auto, property } from './class/property.js';
+export { defineSchema } from './schema/define.js';
+export { valueSchema } from './value/schema.js';
+export { view } from './view/authoring.js';
+export { BuilderError as Error } from './schema/diagnostic.js';

package/dist/v1/builder/lowering/callable.d.ts

@@ -0,0 +1,24 @@
+import type { FunctionRef } from '../../addressing/index.js';
+import type { FunctionDefinition, MethodDefinition } from '../../language/callable/model/callable.js';
+import type { Function, Method } from '../callable/authoring.js';
+import type { BuilderContext } from './schema/context.js';
+import type { BuilderValueSchemas } from './value/compile.js';
+export type CallablePlacement = {
+    readonly kind: 'function';
+    readonly ref: FunctionRef;
+    readonly pointer: string;
+} | {
+    readonly kind: 'node-class-method';
+    readonly pointer: string;
+};
+export interface CallableCompiler {
+    compile(value: Function | Method, placement: CallablePlacement): FunctionDefinition | MethodDefinition;
+}
+export declare class V1CallableCompiler implements CallableCompiler {
+    readonly context: BuilderContext;
+    readonly values: BuilderValueSchemas;
+    constructor(context: BuilderContext, values: BuilderValueSchemas);
+    compile(value: Function | Method, placement: CallablePlacement): FunctionDefinition | MethodDefinition;
+    private compileOutput;
+    private policyContext;
+}

package/dist/v1/builder/{compiler → lowering}/callable.js

@@ -1,6 +1,6 @@
-import { normalizePolicyChecks } from '../../schema/policy/normalize.js';
-import { callableInputField, callablePolicyObject, callableRef, callableSelf, isCallableOutputAuthoring, } from '../callable.js';
-import { fail } from '../internal/diagnostic.js';
+import { normalizePolicyChecks } from '../../language/policy/normalization/normalize.js';
+import { callableInputField, callableConfiguration, callablePolicyObject, callableRef, callableSelf, isCallableOutputAuthoring, } from '../callable/authoring.js';
+import { fail } from '../schema/diagnostic.js';
 export class V1CallableCompiler {
     context;
     values;
@@ -9,26 +9,22 @@ export class V1CallableCompiler {
         this.values = values;
     }
     compile(value, placement) {
-        const config = value.config;
-        if (config.auth !== undefined &&
-            config.auth !== 'required' &&
-            config.auth !== 'optional' &&
-            config.auth !== 'public') {
-            fail('BUILDER_CALLABLE_AUTH', `${placement.pointer}/auth`, 'Callable authentication must be required, optional, or public.');
+        const config = callableConfiguration(value);
+        if (config.auth !== 'anonymous' &&
+            config.auth !== 'authenticated' &&
+            config.auth !== 'authorized') {
+            fail('BUILDER_CALLABLE_AUTH', `${placement.pointer}/auth`, 'Function auth must be anonymous, authenticated, or authorized.');
         }
-        const auth = config.auth ?? 'required';
-        if (auth === 'public' && config.policy !== undefined) {
-            fail('BUILDER_PUBLIC_POLICY', `${placement.pointer}/policy`, 'A public callable cannot declare a Policy check.');
+        const auth = config.auth;
+        if (auth !== 'authorized' && config.policy !== undefined) {
+            fail('BUILDER_CALLABLE_POLICY_AUTH', `${placement.pointer}/policy`, 'Only an authorized Function or Method may declare a Policy check.');
         }
         const method = placement.kind !== 'function';
         if (!method && (config.static !== undefined || config.inheritance !== undefined)) {
             fail('BUILDER_CALLABLE_PLACEMENT', placement.pointer, 'A standalone Function cannot declare Method staticness or inheritance.');
         }
         const isStatic = method ? (config.static ?? false) : undefined;
-        const inheritance = method
-            ? (config.inheritance ??
-                (placement.kind === 'node-interface-method' ? 'abstract' : 'default'))
-            : undefined;
+        const inheritance = method ? (config.inheritance ?? 'default') : undefined;
         if (inheritance === 'abstract' && config.policy !== undefined) {
             fail('BUILDER_ABSTRACT_POLICY', `${placement.pointer}/policy`, 'An abstract Method cannot declare a Policy check.');
         }
@@ -37,15 +33,16 @@ export class V1CallableCompiler {
         const policy = config.policy === undefined
             ? undefined
             : normalizePolicyChecks(config.policy(this.policyContext(input, placement, isStatic ?? false)));
-        const contract = {
+        const base = {
             ...(config.description === undefined ? {} : { description: config.description }),
             input,
             output,
-            auth,
-            ...(policy === undefined ? {} : { policy }),
         };
+        const contract = auth === 'authorized'
+            ? { ...base, auth, ...(policy === undefined ? {} : { policy }) }
+            : { ...base, auth };
         if (!method)
-            return contract;
+            return { ref: placement.ref, ...contract };
         return {
             ...contract,
             static: isStatic,
@@ -136,4 +133,3 @@ function nonEmpty(values, pointer) {
     if (values.length === 0)
         fail('BUILDER_POLICY_EMPTY_COMPOSITION', pointer, 'Policy check composition must be non-empty.');
 }
-//# sourceMappingURL=callable.js.map

package/dist/v1/builder/lowering/class.d.ts

@@ -0,0 +1,22 @@
+import type { ClassDefinition } from '../../language/class/model/class.js';
+import type { Class } from '../class/authoring.js';
+import type { CallableCompiler } from './callable.js';
+import type { PolicyCompiler } from './policy.js';
+import type { BuilderContext } from './schema/context.js';
+import type { BuilderValueSchemas } from './value/compile.js';
+export declare class V1DefinitionCompiler {
+    readonly context: BuilderContext;
+    readonly values: BuilderValueSchemas;
+    readonly callables: CallableCompiler;
+    readonly policies: PolicyCompiler;
+    constructor(context: BuilderContext, values: BuilderValueSchemas, callables: CallableCompiler, policies: PolicyCompiler);
+    compileClass(value: Class, name: string, pointer: string): ClassDefinition;
+    private nodeClass;
+    private edgeClass;
+    private endpointBase;
+    private directedSource;
+    private directedTarget;
+    private incidentEndpoint;
+    private parents;
+    private methods;
+}

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

@@ -0,0 +1,129 @@
+import { compareDefinitionRefs } from '../../addressing/ordering.js';
+import { classConfiguration } from '../class/authoring.js';
+import { escapeToken } from '../schema/diagnostic.js';
+export class V1DefinitionCompiler {
+    context;
+    values;
+    callables;
+    policies;
+    constructor(context, values, callables, policies) {
+        this.context = context;
+        this.values = values;
+        this.callables = callables;
+        this.policies = policies;
+    }
+    compileClass(value, name, pointer) {
+        return value.kind === 'node'
+            ? this.nodeClass(value, name, pointer)
+            : this.edgeClass(value, name, pointer);
+    }
+    nodeClass(value, name, pointer) {
+        const input = classConfiguration(value);
+        const facet = this.values.properties(input.properties, `${pointer}/properties`);
+        const data = dataDeclaration(input.data);
+        return {
+            ref: { origin: this.context.origin, kind: 'class', name },
+            kind: 'node',
+            abstract: input.abstract ?? false,
+            ...(input.description === undefined ? {} : { description: input.description }),
+            extends: this.parents(input.extends, 'node', `${pointer}/extends`),
+            properties: facet,
+            methods: this.methods(input.methods, `${pointer}/methods`),
+            ...(data === undefined ? {} : { data }),
+            ...(input.icon === undefined ? {} : { icon: input.icon }),
+            policies: {
+                ...(input.policies?.read === undefined
+                    ? {}
+                    : { read: this.policies.ref(input.policies.read, `${pointer}/policies/read`) }),
+                ...(input.policies?.traverse === undefined
+                    ? {}
+                    : {
+                        traverse: this.policies.ref(input.policies.traverse, `${pointer}/policies/traverse`),
+                    }),
+            },
+        };
+    }
+    edgeClass(value, name, pointer) {
+        const input = classConfiguration(value);
+        const facet = this.values.properties(input.properties, `${pointer}/properties`);
+        const contract = (() => {
+            if (value.orientation === 'directed') {
+                const directed = classConfiguration(value);
+                return {
+                    orientation: 'directed',
+                    endpoints: {
+                        source: this.directedSource(directed.source, `${pointer}/endpoints/source`),
+                        target: this.directedTarget(directed.target, `${pointer}/endpoints/target`),
+                    },
+                    constraints: directedConstraints(directed),
+                };
+            }
+            const undirected = classConfiguration(value);
+            return {
+                orientation: 'undirected',
+                endpoints: [
+                    this.incidentEndpoint(undirected.endpoints[0], `${pointer}/endpoints/0`),
+                    this.incidentEndpoint(undirected.endpoints[1], `${pointer}/endpoints/1`),
+                ],
+                constraints: undirectedConstraints(undirected),
+            };
+        })();
+        return {
+            ref: { origin: this.context.origin, kind: 'class', name },
+            kind: 'edge',
+            abstract: input.abstract ?? false,
+            ...(input.description === undefined ? {} : { description: input.description }),
+            extends: this.parents(input.extends, 'edge', `${pointer}/extends`),
+            properties: facet,
+            ...contract,
+            policies: input.policies?.traverse === undefined
+                ? {}
+                : {
+                    traverse: this.policies.ref(input.policies.traverse, `${pointer}/policies/traverse`),
+                },
+        };
+    }
+    endpointBase(value, pointer) {
+        return {
+            role: value.as,
+            accepts: value.accepts
+                .map((entry, index) => this.context.resolveNodeClass(entry, `${pointer}/accepts/${index}`))
+                .sort(compareDefinitionRefs),
+        };
+    }
+    directedSource(value, pointer) {
+        return { ...this.endpointBase(value, pointer), outgoing: value.outgoing };
+    }
+    directedTarget(value, pointer) {
+        return { ...this.endpointBase(value, pointer), incoming: value.incoming };
+    }
+    incidentEndpoint(value, pointer) {
+        return { ...this.endpointBase(value, pointer), incident: value.incident };
+    }
+    parents(values, kind, pointer) {
+        return (values ?? [])
+            .map((entry, index) => this.context.resolveClass(entry, kind, `${pointer}/${index}`))
+            .sort(compareDefinitionRefs);
+    }
+    methods(values, pointer) {
+        return Object.fromEntries(Object.entries(values ?? {}).map(([name, value]) => [
+            name,
+            this.callables.compile(value, {
+                kind: 'node-class-method',
+                pointer: `${pointer}/${escapeToken(name)}`,
+            }),
+        ]));
+    }
+}
+function dataDeclaration(mediaType) {
+    return mediaType === undefined ? undefined : { mediaType };
+}
+function directedConstraints(options) {
+    return {
+        ...(options.constraints?.noSelf === true ? { noSelf: true } : {}),
+        ...(options.constraints?.acyclic === true ? { acyclic: true } : {}),
+    };
+}
+function undirectedConstraints(options) {
+    return options.constraints?.noSelf === true ? { noSelf: true } : {};
+}

package/dist/v1/builder/lowering/core-properties.d.ts

@@ -0,0 +1,10 @@
+import type { CoreContent } from '../../language/core/model/core.js';
+import type { DomainSchemaLookup } from '../../schema/dependency/lookup.js';
+import type { DomainSchemaIR } from '../../schema/model/schema.js';
+import type { UnqualifiedCoreContent } from './core.js';
+type UnqualifiedDomainSchema = Omit<DomainSchemaIR, 'core'> & {
+    readonly core: UnqualifiedCoreContent;
+};
+/** Lower rich builder shorthand to the canonical full-key Core representation. */
+export declare function canonicalizeCorePropertyKeys(candidate: UnqualifiedDomainSchema, lookup: DomainSchemaLookup): CoreContent;
+export {};