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

package/dist/v1/builder/{callable.d.ts → callable/authoring.d.ts}

@@ -1,12 +1,14 @@
-import type { FunctionAuth, MethodInheritance, PolicyCheckExpression, PolicyCheckObject, PolicyObjectRef } from '../schema/index.js';
-import type { CoreNodeAuthoring } from './core.js';
-import type { DefinitionAuthoring } from './definition.js';
-import type { Lazy } from './internal/authoring.lazy.js';
-import type { Policy, PolicyInput } from './policy.js';
-import type { ValueSchemaInput } from './property.js';
-import type { ViewAuthoring } from './view.js';
-import { type AUTHORING } from './internal/authoring.js';
+import type { FunctionAuth, MethodInheritance } from '../../language/callable/model/callable.js';
+import type { PolicyCheckExpression, PolicyCheckObject, PolicyObjectRef } from '../../language/policy/model/policy.js';
+import type { Class } from '../class/authoring.js';
+import type { ValueSchemaInput } from '../class/property.js';
+import type { CoreNode } from '../core/authoring.js';
+import type { Policy, PolicyInput } from '../policy/authoring.js';
+import type { Lazy } from '../schema/lazy.js';
+import type { View } from '../view/authoring.js';
+import { type AUTHORING } from '../schema/handle.js';
 declare const CALLABLE_OUTPUT: unique symbol;
+declare const CALLABLE_INPUT: unique symbol;
 export interface CallablePolicyContext {
     readonly input: Readonly<Record<string, Extract<PolicyCheckObject, {
         readonly kind: 'input';
@@ -32,7 +34,7 @@ export interface BinaryOutput {
     readonly [CALLABLE_OUTPUT]: true;
 }
 export type CallableOutputInput = ValueSchemaInput | StreamOutput | BinaryOutput;
-interface CallableInputBase {
+export interface CallableInputBase {
     readonly description?: string;
     readonly input: ValueSchemaInput;
     readonly output: CallableOutputInput;
@@ -49,6 +51,11 @@ export type CallableInput = CallableInputBase & ({
     readonly auth: 'authorized';
     readonly policy?: CallablePolicyBuilder;
 });
+export type FunctionInput = CallableInput & {
+    readonly static?: never;
+    readonly inheritance?: never;
+};
+export type MethodInput = CallableInput;
 /** Exact public callable coordinates derived from an authored config. */
 export type AuthoredCallableInput<Input extends ValueSchemaInput, Output extends CallableOutputInput, Auth extends FunctionAuth, Static extends boolean = never, Inheritance extends MethodInheritance = never> = {
     readonly description?: string;
@@ -64,13 +71,21 @@ export type AuthoredCallableInput<Input extends ValueSchemaInput, Output extends
 }) & ([Inheritance] extends [never] ? {} : {
     readonly inheritance: Inheritance;
 });
-export interface FunctionAuthoring<out Config extends CallableInput = CallableInput> {
+export interface Function<out Config extends CallableInput = CallableInput> {
     readonly [AUTHORING]: 'function';
-    readonly config: Config;
+    readonly [CALLABLE_INPUT]: Config;
+}
+export interface Method<out Config extends MethodInput = MethodInput> {
+    readonly [AUTHORING]: 'method';
+    readonly [CALLABLE_INPUT]: Config;
 }
-export type PolicyObjectAuthoring = DefinitionAuthoring | FunctionAuthoring | Policy | ViewAuthoring | CoreNodeAuthoring;
+export type CallableAuthoringInput<Value extends Function | Method> = Value extends Function<infer Config> ? Config : Value extends Method<infer Config> ? Config : never;
+/** Internal lowering access; Callable authoring handles expose no public configuration object. */
+export declare function callableAuthoringInput<const Value extends Function | Method>(value: Value): CallableAuthoringInput<Value>;
+export type PolicyObjectAuthoring = Class | Function | Policy | View | CoreNode;
 export type PolicyObjectInput = Lazy<PolicyObjectAuthoring>;
-export declare function fn<const Config extends CallableInput>(config: Config): FunctionAuthoring<Config>;
+export declare function func<const Config extends FunctionInput>(config: Config): Function<Config>;
+export declare function method<const Config extends MethodInput>(config: Config): Method<Config>;
 export declare function callableInputField(name: string): Extract<PolicyCheckObject, {
     readonly kind: 'input';
 }>;
@@ -88,4 +103,3 @@ export declare const output: {
 };
 export declare function isCallableOutputAuthoring(value: CallableOutputInput): value is StreamOutput | BinaryOutput;
 export {};
-//# sourceMappingURL=callable.d.ts.map

package/dist/v1/builder/{callable.js → callable/authoring.js}

@@ -1,6 +1,11 @@
-import { authoringValue, isAuthoringValue } from './internal/authoring.js';
-import { assertKnownKeys } from './internal/diagnostic.js';
-export function fn(config) {
+import { assertKnownKeys } from '../schema/diagnostic.js';
+import { authoringValue, isAuthoringValue } from '../schema/handle.js';
+const CALLABLE_INPUT = Symbol('astrale.v1.callable-input');
+/** Internal lowering access; Callable authoring handles expose no public configuration object. */
+export function callableAuthoringInput(value) {
+    return value[CALLABLE_INPUT];
+}
+export function func(config) {
     assertKnownKeys(config, [
         'description',
         'input',
@@ -11,7 +16,21 @@ export function fn(config) {
         'inheritance',
     ]);
     return authoringValue('function', {
-        config: { ...config },
+        [CALLABLE_INPUT]: { ...config },
+    });
+}
+export function method(config) {
+    assertKnownKeys(config, [
+        'description',
+        'input',
+        'output',
+        'auth',
+        'policy',
+        'static',
+        'inheritance',
+    ]);
+    return authoringValue('method', {
+        [CALLABLE_INPUT]: { ...config },
     });
 }
 export function callableInputField(name) {
@@ -43,4 +62,3 @@ export const output = Object.freeze({
 export function isCallableOutputAuthoring(value) {
     return isAuthoringValue(value, 'callable-output');
 }
-//# sourceMappingURL=callable.js.map

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

@@ -0,0 +1,128 @@
+import type { ClassRef } from '../../addressing/index.js';
+import type { MethodRecord } from '../../language/callable/model/callable.js';
+import type { MediaType } from '../../language/class/model/data.js';
+import type { ResolvedClass } from '../../language/class/resolved.js';
+import type { Method } from '../callable/authoring.js';
+import type { Policy } from '../policy/authoring.js';
+import type { Lazy } from '../schema/lazy.js';
+import type { PropertyRecordInput } from './property.js';
+import { type AUTHORING } from '../schema/handle.js';
+declare const CLASS_TYPE: unique symbol;
+export type ClassReferenceInput = Lazy<Class | ClassRef | ResolvedClass<'node'> | ResolvedClass<'edge'>>;
+export type NodeClassReferenceInput = Lazy<NodeClass | ClassRef | ResolvedClass<'node'>>;
+export type EdgeClassReferenceInput = Lazy<EdgeClass | ClassRef | ResolvedClass<'edge'>>;
+export interface DirectedSourceInput {
+    readonly as: string;
+    readonly accepts: readonly NodeClassReferenceInput[];
+    readonly outgoing: import('../../language/class/model/edge.js').EdgeCount;
+}
+export interface DirectedTargetInput {
+    readonly as: string;
+    readonly accepts: readonly NodeClassReferenceInput[];
+    readonly incoming: import('../../language/class/model/edge.js').EdgeCount;
+}
+export interface IncidentEndpointInput {
+    readonly as: string;
+    readonly accepts: readonly NodeClassReferenceInput[];
+    readonly incident: import('../../language/class/model/edge.js').EdgeCount;
+}
+type ExactEndpointInput<Input, Shape> = Input & Record<Exclude<keyof Input, keyof Shape>, never>;
+export interface NodeClassInput {
+    readonly abstract?: boolean;
+    readonly description?: string;
+    readonly extends?: readonly NodeClassReferenceInput[];
+    readonly properties?: PropertyRecordInput;
+    readonly data?: MediaType;
+    readonly methods?: Readonly<Record<string, Method>>;
+    readonly icon?: string;
+    readonly policies?: {
+        readonly read?: Lazy<Policy>;
+        readonly traverse?: Lazy<Policy>;
+    };
+}
+export interface EdgeClassOptions {
+    readonly abstract?: boolean;
+    readonly description?: string;
+    readonly extends?: readonly EdgeClassReferenceInput[];
+    readonly properties?: PropertyRecordInput;
+    readonly policies?: {
+        readonly traverse?: Lazy<Policy>;
+    };
+    readonly constraints?: {
+        readonly noSelf?: true;
+        readonly acyclic?: true;
+    };
+}
+export interface DirectedEdgeInput extends EdgeClassOptions {
+    readonly orientation: 'directed';
+    readonly source: DirectedSourceInput;
+    readonly target: DirectedTargetInput;
+}
+export interface UndirectedEdgeInput extends Omit<EdgeClassOptions, 'constraints'> {
+    readonly orientation: 'undirected';
+    readonly endpoints: readonly [IncidentEndpointInput, IncidentEndpointInput];
+    readonly constraints?: {
+        readonly noSelf?: true;
+    };
+}
+export type EdgeClassCommon = EdgeClassOptions;
+export type EdgeClassInput = DirectedEdgeInput | UndirectedEdgeInput;
+export type ClassInput = ({
+    readonly kind: 'node';
+    readonly abstract: boolean;
+} & NodeClassInput) | ({
+    readonly kind: 'edge';
+    readonly orientation: 'directed';
+    readonly abstract: boolean;
+} & Omit<DirectedEdgeInput, 'orientation'>) | ({
+    readonly kind: 'edge';
+    readonly orientation: 'undirected';
+    readonly abstract: boolean;
+} & Omit<UndirectedEdgeInput, 'orientation'>);
+export type Class = NodeClass | EdgeClass;
+export interface NodeClass<out Config extends NodeClassInput = NodeClassInput> {
+    readonly [AUTHORING]: 'definition';
+    readonly kind: 'node';
+    readonly [CLASS_TYPE]?: () => Config;
+}
+export interface DirectedEdgeClass<out Input extends Omit<DirectedEdgeInput, 'orientation'> = Omit<DirectedEdgeInput, 'orientation'>> {
+    readonly [AUTHORING]: 'definition';
+    readonly kind: 'edge';
+    readonly orientation: 'directed';
+    readonly [CLASS_TYPE]?: () => Input;
+}
+export interface UndirectedEdgeClass<out Input extends Omit<UndirectedEdgeInput, 'orientation'> = Omit<UndirectedEdgeInput, 'orientation'>> {
+    readonly [AUTHORING]: 'definition';
+    readonly kind: 'edge';
+    readonly orientation: 'undirected';
+    readonly [CLASS_TYPE]?: () => Input;
+}
+export type EdgeClass = DirectedEdgeClass | UndirectedEdgeClass;
+export declare function defineClass(config: {
+    readonly kind: 'node';
+    readonly abstract: boolean;
+} & NodeClassInput): NodeClass;
+export declare function defineClass(config: {
+    readonly kind: 'edge';
+    readonly orientation: 'directed';
+    readonly abstract: boolean;
+} & Omit<DirectedEdgeInput, 'orientation'>): DirectedEdgeClass;
+export declare function defineClass(config: {
+    readonly kind: 'edge';
+    readonly orientation: 'undirected';
+    readonly abstract: boolean;
+} & Omit<UndirectedEdgeInput, 'orientation'>): UndirectedEdgeClass;
+export declare function nodeClass<const Config extends NodeClassInput = Record<never, never>>(config?: Config & Record<Exclude<keyof Config, keyof NodeClassInput>, never>): NodeClass<Config>;
+export declare const edgeClass: Readonly<{
+    directed<const Input extends Omit<DirectedEdgeInput, 'orientation'>>(input: Input & {
+        readonly source: ExactEndpointInput<Input['source'], DirectedSourceInput>;
+        readonly target: ExactEndpointInput<Input['target'], DirectedTargetInput>;
+    }): DirectedEdgeClass<Input>;
+    undirected<const Input extends Omit<UndirectedEdgeInput, 'orientation'>>(input: Input & {
+        readonly endpoints: readonly [ExactEndpointInput<Input['endpoints'][0], IncidentEndpointInput>, ExactEndpointInput<Input['endpoints'][1], IncidentEndpointInput>];
+    }): UndirectedEdgeClass<Input>;
+}>;
+export type ClassAuthoringInput<Value extends Class> = Value extends NodeClass<infer Config> ? Config : Value extends DirectedEdgeClass<infer Input> ? Input : Value extends UndirectedEdgeClass<infer Input> ? Input : never;
+/** Internal lowering access; Class authoring handles expose no public configuration object. */
+export declare function classAuthoringInput<const Value extends Class>(value: Value): ClassAuthoringInput<Value>;
+export type { MethodRecord };

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

@@ -0,0 +1,135 @@
+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;
+    },
+});
+/** Internal lowering access; Class authoring handles expose no public configuration object. */
+export function classAuthoringInput(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,32 @@
+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 { CorePropertyInput } from '../schema/projection.js';
+export interface CoreNode<out Definition extends Lazy<NodeClass> = Lazy<NodeClass>, out Properties extends JsonObject = CorePropertyInput<Definition> & JsonObject> {
+    readonly [AUTHORING]: 'core-node';
+    readonly class: Definition;
+    readonly properties: Properties;
+}
+export type CoreEndpoint = CoreNode | CoreRef | DomainEndpointRef;
+export interface CoreEdge<out Source extends CoreEndpoint = CoreEndpoint, out Definition extends Lazy<EdgeClass> = Lazy<EdgeClass>, out Target extends CoreEndpoint = CoreEndpoint, out Properties extends JsonObject = CorePropertyInput<Definition> & JsonObject> {
+    readonly [AUTHORING]: 'core-edge';
+    readonly source: Source;
+    readonly class: Definition;
+    readonly target: Target;
+    readonly properties: Properties;
+}
+export interface CoreInput {
+    readonly nodes?: Readonly<Record<string, CoreNode>>;
+    readonly edges?: readonly CoreEdge[];
+}
+declare function node<const Definition extends Lazy<NodeClass>, const Properties extends CorePropertyInput<Definition> & JsonObject>(definition: Definition, properties: Properties): CoreNode<Definition, Properties>;
+declare function edge<const Source extends CoreEndpoint, const Definition extends Lazy<EdgeClass>, const Target extends CoreEndpoint, const Properties extends CorePropertyInput<Definition> & JsonObject>(source: Source, definition: Definition, target: Target, properties: Properties): CoreEdge<Source, Definition, Target, Properties>;
+export declare const core: Readonly<{
+    node: typeof node;
+    edge: typeof edge;
+    domain: DomainEndpointRef;
+}>;
+export {};

package/dist/v1/builder/{core.js → core/authoring.js}

@@ -1,16 +1,14 @@
 import { accept as acceptJsonValue } from '@astrale-os/kernel-dsl/value';
-import { authoringValue } from './internal/authoring.js';
+import { authoringValue } from '../schema/handle.js';
 /** Reference the owning Domain instance as one Core Edge endpoint. */
-export function domain() {
-    return Object.freeze({ kind: 'domain' });
-}
-export function node(definition, properties) {
+const domain = Object.freeze({ kind: 'domain' });
+function node(definition, properties) {
     return authoringValue('core-node', {
         class: definition,
         properties: acceptJsonValue(properties),
     });
 }
-export function edge(source, definition, target, properties) {
+function edge(source, definition, target, properties) {
     return authoringValue('core-edge', {
         source,
         class: definition,
@@ -18,4 +16,4 @@ export function edge(source, definition, target, properties) {
         properties: acceptJsonValue(properties),
     });
 }
-//# sourceMappingURL=core.js.map
+export const core = Object.freeze({ node, edge, domain });

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

@@ -1,22 +1,25 @@
-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 } from './class/property.js';
+export { defineSchema } from './schema/define.js';
+export type { DefinedSchema } from './schema/define.js';
+export type { DomainOfInput } 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, 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 { Class, 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, ResolvedClassOfAuthoring } 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 } 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;
+}