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

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, ['read', '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, ['read', 'traverse']);
+    if (value.constraints !== undefined)
+        assertKnownKeys(value.constraints, ['noSelf']);
+}

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

@@ -0,0 +1,58 @@
+import type { z } from 'zod';
+import type { AutoEvent, AutoSet } from '../../language/class/model/property.js';
+import type { StateMachine } from '../../language/state/index.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 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, out Machine = unknown> {
+    readonly [AUTHORING]: 'property';
+    readonly [PROPERTY_INPUT]: {
+        readonly schema: Schema;
+        readonly options: Options;
+        readonly machine?: Machine;
+    };
+}
+export type PropertySchemaOf<Value extends Property> = Value extends Property<infer Schema, PropertyOptions, unknown> ? Schema : never;
+export type PropertyOptionsOf<Value extends Property> = Value extends Property<ValueSchemaInput, infer Options, unknown> ? Options : never;
+export type PropertyStateMachineOf<Value extends Property> = Value extends Property<ValueSchemaInput, PropertyOptions, infer Machine> ? Machine : 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, infer Machine> ? {
+    readonly schema: Schema;
+    readonly options: Options;
+    readonly machine?: Machine;
+} : 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, never>;
+export declare function stateProperty<const Machine extends StateMachine, const Options extends Omit<PropertyOptions, 'required'> = Record<never, never>>(machine: Machine, options?: Options & Record<Exclude<keyof Options, 'description'>, never>): Property<Machine['stateSchema'], Readonly<Options & {
+    readonly required: true;
+}>, Machine>;
+export declare function auto<const PropertyValue extends Property>(property: [PropertyStateMachineOf<PropertyValue>] extends [never] ? PropertyValue : never, options: AutoOptions): AutoProperty<PropertyValue>;
+export {};

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

@@ -0,0 +1,57 @@
+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, ['required', 'description']);
+    return authoringValue('property', {
+        [PROPERTY_INPUT]: {
+            schema,
+            options: admitted,
+        },
+    });
+}
+export function stateProperty(machine, options) {
+    const admitted = options ?? {};
+    assertKnownKeys(admitted, ['description']);
+    return authoringValue('property', {
+        [PROPERTY_INPUT]: {
+            schema: machine.stateSchema,
+            options: { ...admitted, required: true },
+            machine,
+        },
+    });
+}
+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,47 @@
+import type { Object as JsonObject } from '@astrale-os/kernel-dsl/value';
+import type { DomainEndpointRef } from '../../language/core/model/core.js';
+import type { PolicyObjectInput } from '../callable/authoring.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';
+}
+/**
+ * The owning Domain, or any local Definition of it: a Class, Function, Method, Policy, View, or
+ * Core Node, authored as a handle, a lazy handle, or its canonical ref. A lazy handle lets a Core
+ * Edge name a declaration that only exists later in a module cycle.
+ */
+export type CoreEndpoint = PolicyObjectInput | 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, input, 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, BinaryInputAuthoring, 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, PolicyNodeBinder, 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, input, 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/lowering/callable.js

@@ -0,0 +1,150 @@
+import { normalizePolicyChecks } from '../../language/policy/normalization/normalize.js';
+import { callableInputField, callableConfiguration, callablePolicyObject, callableRef, callableSelf, isBinaryInputAuthoring, isCallableOutputAuthoring, } from '../callable/authoring.js';
+import { fail } from '../schema/diagnostic.js';
+export class V1CallableCompiler {
+    context;
+    values;
+    constructor(context, values) {
+        this.context = context;
+        this.values = values;
+    }
+    compile(value, placement) {
+        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;
+        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.abstract !== undefined)) {
+            fail('BUILDER_CALLABLE_PLACEMENT', placement.pointer, 'A standalone Function cannot declare Method staticness or abstractness.');
+        }
+        const isStatic = method ? (config.static ?? false) : undefined;
+        const isAbstract = method ? (config.abstract ?? false) : undefined;
+        const binaryInput = isBinaryInputAuthoring(config.input) ? config.input : undefined;
+        if (method && binaryInput !== undefined) {
+            fail('BUILDER_CALLABLE_PLACEMENT', `${placement.pointer}/input`, 'Methods require Value input.');
+        }
+        const metadata = isBinaryInputAuthoring(config.input) ? config.input.metadata : config.input;
+        const inputSchema = this.values.schema(metadata, 'callable-input', binaryInput ? `${placement.pointer}/input/metadata` : `${placement.pointer}/input`);
+        const input = binaryInput
+            ? { mode: 'binary', metadata: inputSchema, maximumBytes: binaryInput.maximumBytes }
+            : inputSchema;
+        const output = this.compileOutput(config.output, `${placement.pointer}/output`);
+        const policy = config.policy === undefined
+            ? undefined
+            : normalizePolicyChecks(config.policy(this.policyContext(inputSchema, placement, isStatic ?? false)));
+        const base = {
+            ...(config.description === undefined ? {} : { description: config.description }),
+            input,
+            output,
+            ...(config.execution === undefined ? {} : { execution: config.execution }),
+        };
+        const contract = auth === 'authorized'
+            ? { ...base, auth, ...(policy === undefined ? {} : { policy }) }
+            : { ...base, auth };
+        if (!method) {
+            return {
+                ref: placement.ref,
+                ...contract,
+            };
+        }
+        return {
+            ...contract,
+            input: inputSchema,
+            static: isStatic,
+            abstract: isAbstract,
+        };
+    }
+    compileOutput(value, pointer) {
+        if (!isCallableOutputAuthoring(value)) {
+            return {
+                mode: 'value',
+                schema: this.values.schema(value, 'callable-output', pointer),
+            };
+        }
+        if (value.mode === 'binary')
+            return { mode: 'binary' };
+        return {
+            mode: 'stream',
+            item: this.values.schema(value.item, 'callable-output', `${pointer}/item`),
+        };
+    }
+    policyContext(inputSchema, placement, isStatic) {
+        const input = new Proxy(Object.create(null), {
+            get(_target, key) {
+                return typeof key === 'string' ? callableInputField(key) : undefined;
+            },
+        });
+        const self = callableSelf();
+        const admitObject = (object) => {
+            const resolvedObject = callablePolicyObject(object);
+            let admittedObject = resolvedObject;
+            if (resolvedObject.kind === 'self') {
+                if (placement.kind === 'function' || isStatic) {
+                    fail('BUILDER_POLICY_SELF', `${placement.pointer}/policy`, 'self is available only to a non-static Node Method.');
+                }
+            }
+            else if (resolvedObject.kind === 'input') {
+                if (isRequiredDirectNodePath(inputSchema, resolvedObject.field)) {
+                    // The field contract is admitted below as-is.
+                }
+                else {
+                    fail('BUILDER_POLICY_INPUT', `${placement.pointer}/policy`, `input.${resolvedObject.field} is not one direct required single-Node path field.`);
+                }
+            }
+            else {
+                admittedObject = callableRef(this.context.resolvePolicyObject(resolvedObject.ref, `${placement.pointer}/policy/ref`));
+            }
+            return admittedObject;
+        };
+        return Object.freeze({
+            input,
+            self,
+            ref: (member) => callableRef(this.context.resolvePolicyObject(member, `${placement.pointer}/policy/ref`)),
+            sameNode: (left, right) => ({
+                sameNode: { left: admitObject(left), right: admitObject(right) },
+            }),
+            check: (policy, object) => ({
+                check: this.context.resolvePolicy(policy, `${placement.pointer}/policy/check`),
+                object: admitObject(object),
+            }),
+            allOf: (...expressions) => {
+                nonEmpty(expressions, `${placement.pointer}/policy/allOf`);
+                return { allOf: expressions };
+            },
+            anyOf: (...expressions) => {
+                nonEmpty(expressions, `${placement.pointer}/policy/anyOf`);
+                return { anyOf: expressions };
+            },
+        });
+    }
+}
+function isRequiredDirectNodePath(schema, field) {
+    if (schema === null || typeof schema !== 'object' || Array.isArray(schema))
+        return false;
+    if (schema.type !== 'object' ||
+        schema.additionalProperties !== false ||
+        !Array.isArray(schema.required) ||
+        !schema.required.includes(field) ||
+        schema.properties === null ||
+        typeof schema.properties !== 'object' ||
+        Array.isArray(schema.properties)) {
+        return false;
+    }
+    const fieldSchema = schema.properties[field];
+    return (fieldSchema !== null &&
+        typeof fieldSchema === 'object' &&
+        !Array.isArray(fieldSchema) &&
+        fieldSchema.$ref ===
+            'https://schemas.astrale.ai/graph/1/node-path' &&
+        Object.hasOwn(fieldSchema, 'x-astrale-path'));
+}
+function nonEmpty(values, pointer) {
+    if (values.length === 0)
+        fail('BUILDER_POLICY_EMPTY_COMPOSITION', pointer, 'Policy check composition must be non-empty.');
+}

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;
+}