@astrale-os/kernel-dsl 0.2.0-beta.2 → 0.2.0-beta.21

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 { auto, 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, DirectedEdgeClassAuthoring as DirectedEdgeClass, DirectedEdgeClassInput, DirectedSourceInput as DirectedSource, DirectedTargetInput as DirectedTarget, EdgeClassAuthoring as EdgeClass, EdgeInterfaceAuthoring as EdgeInterface, EdgeClassOptions, EdgeInterfaceOptions, EndpointInput as Endpoint, IncidentEndpointInput as IncidentEndpoint, InterfaceAuthoring as Interface, InterfaceInput, NodeClassAuthoring as NodeClass, NodeClassInput, NodeDefinitionReferenceInput as NodeDefinitionReference, NodeInterfaceAuthoring as NodeInterface, NodeInterfaceInput, UndirectedEdgeClassAuthoring as UndirectedEdgeClass, UndirectedEdgeClassInput, } 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 { AutoOptions, AutoPropertyAuthoring as AutoProperty, 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, stateProperty } 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 { auto, 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, stateProperty } 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,11 +9,11 @@ export class V1CallableCompiler {
         this.values = values;
     }
     compile(value, placement) {
-        const config = value.config;
+        const config = callableConfiguration(value);
         if (config.auth !== 'anonymous' &&
             config.auth !== 'authenticated' &&
             config.auth !== 'authorized') {
-            fail('BUILDER_CALLABLE_AUTH', `${placement.pointer}/auth`, 'Function authentication must be anonymous, authenticated, or authorized.');
+            fail('BUILDER_CALLABLE_AUTH', `${placement.pointer}/auth`, 'Function auth must be anonymous, authenticated, or authorized.');
         }
         const auth = config.auth;
         if (auth !== 'authorized' && config.policy !== undefined) {
@@ -24,10 +24,7 @@ export class V1CallableCompiler {
             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.');
         }
@@ -36,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,
@@ -135,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,134 @@
+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?.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`),
+                    }),
+            },
+        };
+    }
+    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 {};

package/dist/v1/builder/{compiler/core.properties.js → lowering/core-properties.js}

@@ -1,13 +1,20 @@
 import { PropertyKey as admitPropertyKey } from '../../addressing/index.js';
-import { analyzeDefinitions } from '../../schema/definition/analysis.js';
-import { schemaRefIndex } from '../../schema/reference.js';
+import { definitionRefIndex } from '../../addressing/ordering.js';
+import { createPropertyValues } from '../../language/class/property-values.js';
+import { analyzeDefinitions } from '../../schema/analysis/class.js';
 import { buildDomainResolutionContext } from '../../schema/resolution/context.js';
-import { escapeToken, fail } from '../internal/diagnostic.js';
+import { escapeToken, fail } from '../schema/diagnostic.js';
 /** Lower rich builder shorthand to the canonical full-key Core representation. */
 export function canonicalizeCorePropertyKeys(candidate, lookup) {
-    const definitions = analyzeDefinitions(buildDomainResolutionContext(candidate, lookup)).definitions;
+    // Core Property values do not participate in Class composition. Analyze the
+    // already-canonical Definition surface, then admit Core values below.
+    const analysisCandidate = {
+        ...candidate,
+        core: { nodes: {}, edges: [] },
+    };
+    const definitions = analyzeDefinitions(buildDomainResolutionContext(analysisCandidate, lookup)).definitions;
     const nodes = Object.fromEntries(Object.entries(candidate.core.nodes).map(([slug, node]) => {
-        const definition = definitions.get(schemaRefIndex(node.class));
+        const definition = definitions.get(definitionRefIndex(node.class));
         if (definition === undefined) {
             fail('BUILDER_CORE_PROPERTY', `/core/nodes/${escapeToken(slug)}/class`, 'Core property shorthand requires a resolvable concrete Class.');
         }
@@ -20,7 +27,7 @@ export function canonicalizeCorePropertyKeys(candidate, lookup) {
         ];
     }));
     const edges = candidate.core.edges.map((edge, index) => {
-        const definition = definitions.get(schemaRefIndex(edge.class));
+        const definition = definitions.get(definitionRefIndex(edge.class));
         if (definition === undefined) {
             fail('BUILDER_CORE_PROPERTY', `/core/edges/${index}/class`, 'Core property shorthand requires a resolvable concrete Class.');
         }
@@ -49,7 +56,7 @@ function qualify(input, definition, pointer) {
         sourceByKey.set(key, inputKey);
         result[key] = value;
     }
-    return result;
+    return createPropertyValues(Object.entries(result).map(([key, value]) => [admitPropertyKey(key), value]));
 }
 function resolveInputKey(input, definition, byName, pointer) {
     if (admitPropertyKey.is(input)) {
@@ -67,4 +74,3 @@ function resolveInputKey(input, definition, byName, pointer) {
     }
     fail('BUILDER_CORE_PROPERTY', pointer, `Property ${JSON.stringify(input)} is ambiguous; use one of: ${candidates.join(', ')}.`);
 }
-//# sourceMappingURL=core.properties.js.map

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

@@ -0,0 +1,22 @@
+import type { Object as JsonObject } from '@astrale-os/kernel-dsl/value';
+import type { ClassRef, CoreRef } from '../../addressing/index.js';
+import type { CoreEndpointRef } from '../../language/core/model/core.js';
+import type { CoreInput } from '../core/authoring.js';
+import type { BuilderContext } from './schema/context.js';
+export declare function captureCore(input: CoreInput | undefined, context: BuilderContext): void;
+export interface UnqualifiedCoreDefinition {
+    readonly ref: CoreRef;
+    readonly class: ClassRef;
+    readonly properties: JsonObject;
+}
+export interface UnqualifiedCoreEdge {
+    readonly class: ClassRef;
+    readonly source: CoreEndpointRef;
+    readonly target: CoreEndpointRef;
+    readonly properties: JsonObject;
+}
+export interface UnqualifiedCoreContent {
+    readonly nodes: Readonly<Record<string, UnqualifiedCoreDefinition>>;
+    readonly edges: readonly UnqualifiedCoreEdge[];
+}
+export declare function compileCore(input: CoreInput | undefined, context: BuilderContext): UnqualifiedCoreContent;

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

@@ -1,5 +1,6 @@
-import { isAuthoringValue } from '../internal/authoring.js';
-import { escapeToken, fail } from '../internal/diagnostic.js';
+import { coreEdgeConfiguration, coreNodeConfiguration } from '../core/authoring.js';
+import { escapeToken, fail } from '../schema/diagnostic.js';
+import { isAuthoringValue } from '../schema/handle.js';
 export function captureCore(input, context) {
     for (const [slug, node] of Object.entries(input?.nodes ?? {})) {
         if (!isAuthoringValue(node, 'core-node')) {
@@ -11,34 +12,39 @@ export function captureCore(input, context) {
 export function compileCore(input, context) {
     const nodes = Object.fromEntries(Object.entries(input?.nodes ?? {}).map(([slug, value]) => [
         slug,
-        compileNode(value, context, `/core/nodes/${escapeToken(slug)}`),
+        compileNode(slug, value, context, `/core/nodes/${escapeToken(slug)}`),
     ]));
     const edges = (input?.edges ?? []).map((value, index) => compileEdge(value, context, `/core/edges/${index}`));
     return { nodes, edges };
 }
-function compileNode(value, context, pointer) {
-    const ref = context.resolveNodeClass(value.class, `${pointer}/class`);
+function compileNode(slug, value, context, pointer) {
+    const configuration = coreNodeConfiguration(value);
+    const ref = context.resolveNodeClass(configuration.class, `${pointer}/class`);
     if (ref.origin !== context.origin) {
         fail('BUILDER_CORE_CLASS', `${pointer}/class`, 'A Core Node Class must be local to the owning Domain.');
     }
-    return { class: ref, properties: value.properties };
+    return {
+        ref: { origin: context.origin, kind: 'core', name: slug },
+        class: ref,
+        properties: configuration.properties,
+    };
 }
 function compileEdge(value, context, pointer) {
     if (!isAuthoringValue(value, 'core-edge')) {
         fail('BUILDER_CORE_EDGE', pointer, 'core.edges entries are created by edge(...).');
     }
-    const ref = context.resolveEdgeClass(value.class, `${pointer}/class`);
+    const configuration = coreEdgeConfiguration(value);
+    const ref = context.resolveEdgeClass(configuration.class, `${pointer}/class`);
     if (ref.origin !== context.origin) {
         fail('BUILDER_CORE_CLASS', `${pointer}/class`, 'A Core Edge Class must be local to the owning Domain.');
     }
     return {
         class: ref,
-        source: resolveEndpoint(value.source, context, `${pointer}/source`),
-        target: resolveEndpoint(value.target, context, `${pointer}/target`),
-        properties: value.properties,
+        source: resolveEndpoint(configuration.source, context, `${pointer}/source`),
+        target: resolveEndpoint(configuration.target, context, `${pointer}/target`),
+        properties: configuration.properties,
     };
 }
 function resolveEndpoint(value, context, pointer) {
     return context.resolveCoreEndpoint(value, pointer);
 }
-//# sourceMappingURL=core.js.map

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

@@ -0,0 +1,16 @@
+import type { PolicyRef } from '../../addressing/index.js';
+import type { PolicyDefinition } from '../../language/policy/model/policy.js';
+import type { Policy } from '../policy/authoring.js';
+import type { Lazy } from '../schema/lazy.js';
+import type { BuilderContext } from './schema/context.js';
+export interface PolicyCompiler {
+    compile(value: Policy, name: string, pointer: string): PolicyDefinition;
+    ref(value: Lazy<unknown>, pointer: string): PolicyRef;
+}
+export declare class V1PolicyCompiler implements PolicyCompiler {
+    readonly context: BuilderContext;
+    constructor(context: BuilderContext);
+    ref(value: Lazy<unknown>, pointer: string): PolicyRef;
+    compile(value: Policy, name: string, pointer: string): PolicyDefinition;
+}
+export declare function assertPolicyCompositionAcyclic(declarations: Readonly<Record<string, PolicyDefinition>>, origin: string): void;

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

@@ -1,6 +1,6 @@
-import { normalizePolicyDeclaration } from '../../schema/policy/normalize.js';
-import { fail } from '../internal/diagnostic.js';
-import { createPatternContext } from '../policy.js';
+import { normalizePolicyExpression } from '../../language/policy/normalization/normalize.js';
+import { createPatternContext, policyDeclaration } from '../policy/authoring.js';
+import { fail } from '../schema/diagnostic.js';
 export class V1PolicyCompiler {
     context;
     constructor(context) {
@@ -9,21 +9,26 @@ export class V1PolicyCompiler {
     ref(value, pointer) {
         return this.context.resolvePolicy(value, pointer);
     }
-    compile(value, pointer) {
-        const input = value.input;
+    compile(value, name, pointer) {
+        const input = policyDeclaration(value);
+        const ref = { origin: this.context.origin, kind: 'policy', name };
         if ('operator' in input) {
             const refs = input.policies.map((policy, index) => this.context.resolvePolicy(policy, `${pointer}/${input.operator}/${index}`));
-            return normalizePolicyDeclaration(input.operator === 'allOf' ? { allOf: refs } : { anyOf: refs });
+            return {
+                ref,
+                expression: normalizePolicyExpression(input.operator === 'allOf' ? { allOf: refs } : { anyOf: refs }),
+            };
         }
         const match = input.match(createPatternContext({
             resolveEdgeClass: (definition, refPointer) => this.context.resolveEdgeClass(definition, refPointer),
             resolveNodeClass: (definition, refPointer) => this.context.resolveNodeClass(definition, refPointer),
             pointer,
         }));
-        return normalizePolicyDeclaration({
+        return {
+            ref,
             ...(input.description === undefined ? {} : { description: input.description }),
-            match,
-        });
+            expression: normalizePolicyExpression({ match }),
+        };
     }
 }
 export function assertPolicyCompositionAcyclic(declarations, origin) {
@@ -37,10 +42,11 @@ export function assertPolicyCompositionAcyclic(declarations, origin) {
             return;
         visiting.add(name);
         const declaration = declarations[name];
-        const refs = declaration !== undefined && 'allOf' in declaration
-            ? declaration.allOf
-            : declaration !== undefined && 'anyOf' in declaration
-                ? declaration.anyOf
+        const expression = declaration?.expression;
+        const refs = expression !== undefined && 'allOf' in expression
+            ? expression.allOf
+            : expression !== undefined && 'anyOf' in expression
+                ? expression.anyOf
                 : [];
         for (const ref of refs)
             if (ref.origin === origin)
@@ -51,4 +57,3 @@ export function assertPolicyCompositionAcyclic(declarations, origin) {
     for (const name of Object.keys(declarations))
         visit(name);
 }
-//# sourceMappingURL=policy.js.map

package/dist/v1/builder/{compiler/schema.capture.d.ts → lowering/schema/capture.d.ts}

@@ -1,5 +1,4 @@
-import type { DomainSchemaInput } from '../schema.input.js';
-import { BuilderContext } from './schema.context.js';
+import type { DomainSchemaInput } from '../../schema/input.js';
+import { BuilderContext } from './context.js';
 export declare function captureSchema(input: DomainSchemaInput, context: BuilderContext): void;
 export declare function commitSchemaOwnership(input: DomainSchemaInput, origin: string): void;
-//# sourceMappingURL=schema.capture.d.ts.map