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

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

@@ -1,19 +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) {
-    return authoringValue('core-node', {
+    const value = authoringValue('core-node', {});
+    coreNodeConfigurations.set(value, {
         class: definition,
         properties: acceptJsonValue(properties),
     });
+    return value;
 }
 function edge(source, definition, target, properties) {
-    return authoringValue('core-edge', {
+    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,25 +1,26 @@
-export { func, method, output } from './callable/authoring.js';
+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 } from './class/property.js';
+export { auto, property, stateProperty } from './class/property.js';
 export { defineSchema } from './schema/define.js';
 export type { DefinedSchema } from './schema/define.js';
-export type { DirectDependenciesOf, DomainOfInput } from './schema/projection.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, CallablePolicyBuilder, CallablePolicyContext, BinaryOutput, Function, FunctionInput, Method, MethodInput, PolicyObjectInput, StreamOutput, } from './callable/authoring.js';
+export type { CallableInputBase, CallableInput, BinaryInputAuthoring, CallableOutputInput, CallableProjection, CallablePolicyBuilder, CallablePolicyContext, PolicyCheckContext, 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 { AuthoredPropertyProjection, AuthoredMethodProjection, Class, ClassIdentityProjection, ClassOwnerProjection, ClassReferenceProjection, ClassReferenceInput as ClassReference, ClassRuleBuilder, ClassRuleContext, DirectedEdgeInput, DirectedEdgeClass, DirectedSourceInput, DirectedTargetInput, EdgeClassCommon, EdgeClassInput, EdgeClass, EdgeClassReferenceInput as EdgeClassReference, IncidentEndpointInput, NodeClass, NodeClassInput, NodeClassPoliciesInput, NodeClassPolicyInput, 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 { 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, ResolvedClassOfAuthoring } from './schema/projection.js';
-export type { DomainSchemaInput as SchemaInput } from './schema/input.js';
+export type { CorePropertyInput } from './schema/projection.js';
+export type { ClassProjection, FunctionProjection, MethodProjection, PropertyProjection, } from './schema/projection.js';
+export type { DomainSchemaInput as SchemaInput, EntrypointOf } 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,10 +1,10 @@
-export { func, method, output } from './callable/authoring.js';
+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 } from './class/property.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';

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

@@ -3,7 +3,7 @@ import type { FunctionDefinition, MethodDefinition } from '../../language/callab
 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 = {
+type CallablePlacement = {
     readonly kind: 'function';
     readonly ref: FunctionRef;
     readonly pointer: string;
@@ -19,6 +19,8 @@ export declare class V1CallableCompiler implements CallableCompiler {
     readonly values: BuilderValueSchemas;
     constructor(context: BuilderContext, values: BuilderValueSchemas);
     compile(value: Function | Method, placement: CallablePlacement): FunctionDefinition | MethodDefinition;
+    private callablePolicy;
     private compileOutput;
     private policyContext;
 }
+export {};

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

@@ -1,6 +1,7 @@
 import { normalizePolicyChecks } from '../../language/policy/normalization/normalize.js';
-import { callableInputField, callableAuthoringInput, callablePolicyObject, callableRef, callableSelf, isCallableOutputAuthoring, } from '../callable/authoring.js';
+import { callableInputField, callableConfiguration, isBinaryInputAuthoring, isCallableOutputAuthoring, } from '../callable/authoring.js';
 import { fail } from '../schema/diagnostic.js';
+import { policyCheckContext } from './policy.js';
 export class V1CallableCompiler {
     context;
     values;
@@ -9,7 +10,7 @@ export class V1CallableCompiler {
         this.values = values;
     }
     compile(value, placement) {
-        const config = callableAuthoringInput(value);
+        const config = callableConfiguration(value);
         if (config.auth !== 'anonymous' &&
             config.auth !== 'authenticated' &&
             config.auth !== 'authorized') {
@@ -20,35 +21,55 @@ export class V1CallableCompiler {
             fail('BUILDER_CALLABLE_POLICY_AUTH', `${placement.pointer}/policy`, 'Only an authorized Function or Method may declare a Policy check.');
         }
         const method = placement.kind !== 'function';
-        if (!method && (config.static !== undefined || config.inheritance !== undefined)) {
-            fail('BUILDER_CALLABLE_PLACEMENT', placement.pointer, 'A standalone Function cannot declare Method staticness or inheritance.');
+        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 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.');
+        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 input = this.values.schema(config.input, 'callable-input', `${placement.pointer}/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(input, placement, isStatic ?? false)));
+        const policy = this.callablePolicy(config.policy, `${placement.pointer}/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 };
+        if (!method) {
+            return {
+                ref: placement.ref,
+                ...contract,
+            };
+        }
         return {
             ...contract,
+            input: inputSchema,
             static: isStatic,
-            inheritance: inheritance,
+            abstract: isAbstract,
         };
     }
+    callablePolicy(value, pointer, context) {
+        if (value === undefined)
+            return undefined;
+        if (typeof value === 'function')
+            return normalizePolicyChecks(value(context()));
+        if (typeof value !== 'boolean') {
+            fail('BUILDER_POLICY', pointer, 'A callable Policy is a check builder, true or false.');
+        }
+        // `false` is the meaning of an absent Policy, so it lowers to none.
+        return value ? true : undefined;
+    }
     compileOutput(value, pointer) {
         if (!isCallableOutputAuthoring(value)) {
             return {
@@ -69,43 +90,18 @@ export class V1CallableCompiler {
                 return typeof key === 'string' ? callableInputField(key) : undefined;
             },
         });
-        const self = callableSelf();
+        const pointer = `${placement.pointer}/policy`;
         return Object.freeze({
             input,
-            self,
-            ref: (member) => callableRef(this.context.resolvePolicyObject(member, `${placement.pointer}/policy/ref`)),
-            check: (policy, 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.');
-                    }
+            ...policyCheckContext(this.context, pointer, (object) => {
+                if (object.kind === 'self' && (placement.kind === 'function' || isStatic)) {
+                    fail('BUILDER_POLICY_SELF', pointer, '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.`);
-                    }
+                if (object.kind === 'input' && !isRequiredDirectNodePath(inputSchema, object.field)) {
+                    fail('BUILDER_POLICY_INPUT', pointer, `input.${object.field} is not one direct required single-Node path field.`);
                 }
-                else {
-                    admittedObject = callableRef(this.context.resolvePolicyObject(resolvedObject.ref, `${placement.pointer}/policy/ref`));
-                }
-                return {
-                    check: this.context.resolvePolicy(policy, `${placement.pointer}/policy/check`),
-                    object: admittedObject,
-                };
-            },
-            allOf: (...expressions) => {
-                nonEmpty(expressions, `${placement.pointer}/policy/allOf`);
-                return { allOf: expressions };
-            },
-            anyOf: (...expressions) => {
-                nonEmpty(expressions, `${placement.pointer}/policy/anyOf`);
-                return { anyOf: expressions };
-            },
+                return object;
+            }),
         });
     }
 }
@@ -129,7 +125,3 @@ function isRequiredDirectNodePath(schema, field) {
             '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

@@ -13,6 +13,13 @@ export declare class V1DefinitionCompiler {
     compileClass(value: Class, name: string, pointer: string): ClassDefinition;
     private nodeClass;
     private edgeClass;
+    private classPolicies;
+    /**
+     * A lazy Policy ignores the context it is called with; a rule builder returns Policy checks. Both
+     * are functions, so the result tells them apart.
+     */
+    private classPolicy;
+    private classRuleContext;
     private endpointBase;
     private directedSource;
     private directedTarget;

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

@@ -1,6 +1,12 @@
 import { compareDefinitionRefs } from '../../addressing/ordering.js';
-import { classAuthoringInput } from '../class/authoring.js';
-import { escapeToken } from '../schema/diagnostic.js';
+import { isMethodExecutable } from '../../language/callable/executable.js';
+import { isClassRuleChecks } from '../../language/policy/model/policy.js';
+import { normalizeClassRule } from '../../language/policy/normalization/normalize.js';
+import { callableConfiguration } from '../callable/authoring.js';
+import { classConfiguration } from '../class/authoring.js';
+import { escapeToken, fail } from '../schema/diagnostic.js';
+import { isAuthoringValue } from '../schema/handle.js';
+import { policyCheckContext } from './policy.js';
 export class V1DefinitionCompiler {
     context;
     values;
@@ -18,7 +24,7 @@ export class V1DefinitionCompiler {
             : this.edgeClass(value, name, pointer);
     }
     nodeClass(value, name, pointer) {
-        const input = classAuthoringInput(value);
+        const input = classConfiguration(value);
         const facet = this.values.properties(input.properties, `${pointer}/properties`);
         const data = dataDeclaration(input.data);
         return {
@@ -28,27 +34,18 @@ export class V1DefinitionCompiler {
             ...(input.description === undefined ? {} : { description: input.description }),
             extends: this.parents(input.extends, 'node', `${pointer}/extends`),
             properties: facet,
-            methods: this.methods(input.methods, `${pointer}/methods`),
+            methods: this.methods(input.methods, input.abstract ?? false, `${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`),
-                    }),
-            },
+            policies: this.classPolicies(input, 'node', `${pointer}/policies`),
         };
     }
     edgeClass(value, name, pointer) {
-        const input = classAuthoringInput(value);
+        const input = classConfiguration(value);
         const facet = this.values.properties(input.properties, `${pointer}/properties`);
         const contract = (() => {
             if (value.orientation === 'directed') {
-                const directed = classAuthoringInput(value);
+                const directed = classConfiguration(value);
                 return {
                     orientation: 'directed',
                     endpoints: {
@@ -58,7 +55,7 @@ export class V1DefinitionCompiler {
                     constraints: directedConstraints(directed),
                 };
             }
-            const undirected = classAuthoringInput(value);
+            const undirected = classConfiguration(value);
             return {
                 orientation: 'undirected',
                 endpoints: [
@@ -76,13 +73,53 @@ export class V1DefinitionCompiler {
             extends: this.parents(input.extends, 'edge', `${pointer}/extends`),
             properties: facet,
             ...contract,
-            policies: input.policies?.traverse === undefined
-                ? {}
-                : {
-                    traverse: this.policies.ref(input.policies.traverse, `${pointer}/policies/traverse`),
-                },
+            // classPolicy refuses Policy checks on an Edge Class, so only Class Policies remain.
+            policies: this.classPolicies(input, 'edge', `${pointer}/policies`),
         };
     }
+    classPolicies(input, kind, pointer) {
+        const slot = (operation) => {
+            const value = input.policies?.[operation];
+            if (value === undefined)
+                return undefined;
+            if (typeof value !== 'boolean')
+                return this.classPolicy(value, kind, `${pointer}/${operation}`);
+            // `true` on an abstract Class would otherwise lower to nothing and pass unnoticed.
+            if (input.abstract === true) {
+                fail('BUILDER_ABSTRACT_POLICY', `${pointer}/${operation}`, 'Abstract Classes cannot declare observation Policies.');
+            }
+            // `true` is the meaning of an absent observation Policy, so it lowers to none.
+            return value ? undefined : false;
+        };
+        const read = slot('read');
+        const traverse = slot('traverse');
+        return {
+            ...(read === undefined ? {} : { read }),
+            ...(traverse === undefined ? {} : { traverse }),
+        };
+    }
+    /**
+     * A lazy Policy ignores the context it is called with; a rule builder returns Policy checks. Both
+     * are functions, so the result tells them apart.
+     */
+    classPolicy(value, kind, pointer) {
+        if (typeof value !== 'function')
+            return this.policies.ref(value, pointer);
+        const result = value(this.classRuleContext(pointer));
+        if (!isClassRuleResult(result))
+            return this.policies.ref(result, pointer);
+        if (kind === 'edge') {
+            fail('BUILDER_POLICY', pointer, 'An Edge Class observation names one Policy, true or false.');
+        }
+        return normalizeClassRule(result);
+    }
+    classRuleContext(pointer) {
+        return policyCheckContext(this.context, pointer, (object) => {
+            if (object?.kind === 'self' || object?.kind === 'ref')
+                return object;
+            fail('BUILDER_POLICY_INPUT', pointer, 'A Class rule checks self or one ref(...) member.');
+        });
+    }
     endpointBase(value, pointer) {
         return {
             role: value.as,
@@ -105,14 +142,20 @@ export class V1DefinitionCompiler {
             .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, {
+    methods(values, abstractOwner, pointer) {
+        return Object.fromEntries(Object.entries(values ?? {}).map(([name, value]) => {
+            const methodPointer = `${pointer}/${escapeToken(name)}`;
+            const method = this.callables.compile(value, {
                 kind: 'node-class-method',
-                pointer: `${pointer}/${escapeToken(name)}`,
-            }),
-        ]));
+                pointer: methodPointer,
+            });
+            // `false` on a contract-only Method would otherwise lower to nothing and pass unnoticed.
+            if (!isMethodExecutable({ abstract: abstractOwner }, method) &&
+                typeof callableConfiguration(value).policy === 'boolean') {
+                fail('BUILDER_ABSTRACT_POLICY', `${methodPointer}/policy`, 'Abstract Methods cannot have a Policy.');
+            }
+            return [name, method];
+        }));
     }
 }
 function dataDeclaration(mediaType) {
@@ -127,3 +170,10 @@ function directedConstraints(options) {
 function undirectedConstraints(options) {
     return options.constraints?.noSelf === true ? { noSelf: true } : {};
 }
+/** A rule builder's result, not the Policy handle a lazy reference returns. */
+function isClassRuleResult(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        !isAuthoringValue(value, 'policy') &&
+        isClassRuleChecks(value));
+}

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

@@ -4,12 +4,12 @@ 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 {
+interface UnqualifiedCoreDefinition {
     readonly ref: CoreRef;
     readonly class: ClassRef;
     readonly properties: JsonObject;
 }
-export interface UnqualifiedCoreEdge {
+interface UnqualifiedCoreEdge {
     readonly class: ClassRef;
     readonly source: CoreEndpointRef;
     readonly target: CoreEndpointRef;
@@ -20,3 +20,4 @@ export interface UnqualifiedCoreContent {
     readonly edges: readonly UnqualifiedCoreEdge[];
 }
 export declare function compileCore(input: CoreInput | undefined, context: BuilderContext): UnqualifiedCoreContent;
+export {};

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

@@ -1,3 +1,4 @@
+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) {
@@ -17,29 +18,31 @@ export function compileCore(input, context) {
     return { nodes, edges };
 }
 function compileNode(slug, value, context, pointer) {
-    const ref = context.resolveNodeClass(value.class, `${pointer}/class`);
+    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 {
         ref: { origin: context.origin, kind: 'core', name: slug },
         class: ref,
-        properties: value.properties,
+        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) {

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

@@ -1,5 +1,6 @@
 import type { PolicyRef } from '../../addressing/index.js';
-import type { PolicyDefinition } from '../../language/policy/model/policy.js';
+import type { PolicyCheckObject, PolicyDefinition } from '../../language/policy/model/policy.js';
+import type { PolicyCheckContext } from '../callable/authoring.js';
 import type { Policy } from '../policy/authoring.js';
 import type { Lazy } from '../schema/lazy.js';
 import type { BuilderContext } from './schema/context.js';
@@ -14,3 +15,9 @@ export declare class V1PolicyCompiler implements PolicyCompiler {
     compile(value: Policy, name: string, pointer: string): PolicyDefinition;
 }
 export declare function assertPolicyCompositionAcyclic(declarations: Readonly<Record<string, PolicyDefinition>>, origin: string): void;
+/**
+ * The check vocabulary of every rule site: an authorized callable's Policy and a Node Class rule.
+ * A `ref` object resolves to one exact projected member however it was written; `admit` keeps the
+ * objects the site accepts. `pointer` is the site's rule slot.
+ */
+export declare function policyCheckContext<Object extends PolicyCheckObject>(context: BuilderContext, pointer: string, admit: (object: PolicyCheckObject) => Object): PolicyCheckContext<Object>;

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

@@ -1,4 +1,5 @@
 import { normalizePolicyExpression } from '../../language/policy/normalization/normalize.js';
+import { callableRef, callableSelf } from '../callable/authoring.js';
 import { createPatternContext, policyDeclaration } from '../policy/authoring.js';
 import { fail } from '../schema/diagnostic.js';
 export class V1PolicyCompiler {
@@ -20,6 +21,7 @@ export class V1PolicyCompiler {
             };
         }
         const match = input.match(createPatternContext({
+            resolveObject: (member, refPointer) => this.context.resolvePolicyObject(member, refPointer),
             resolveEdgeClass: (definition, refPointer) => this.context.resolveEdgeClass(definition, refPointer),
             resolveNodeClass: (definition, refPointer) => this.context.resolveNodeClass(definition, refPointer),
             pointer,
@@ -57,3 +59,36 @@ export function assertPolicyCompositionAcyclic(declarations, origin) {
     for (const name of Object.keys(declarations))
         visit(name);
 }
+/**
+ * The check vocabulary of every rule site: an authorized callable's Policy and a Node Class rule.
+ * A `ref` object resolves to one exact projected member however it was written; `admit` keeps the
+ * objects the site accepts. `pointer` is the site's rule slot.
+ */
+export function policyCheckContext(context, pointer, admit) {
+    const object = (value) => admit(value?.kind === 'ref'
+        ? callableRef(context.resolvePolicyObject(value.ref, `${pointer}/ref`))
+        : value);
+    return Object.freeze({
+        self: callableSelf(),
+        ref: (member) => callableRef(context.resolvePolicyObject(member, `${pointer}/ref`)),
+        check: (policy, value) => ({
+            check: context.resolvePolicy(policy, `${pointer}/check`),
+            object: object(value),
+        }),
+        sameNode: (left, right) => ({
+            sameNode: { left: object(left), right: object(right) },
+        }),
+        allOf: (...expressions) => {
+            nonEmpty(expressions, `${pointer}/allOf`);
+            return { allOf: expressions };
+        },
+        anyOf: (...expressions) => {
+            nonEmpty(expressions, `${pointer}/anyOf`);
+            return { anyOf: expressions };
+        },
+    });
+}
+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/schema/capture.js

@@ -1,5 +1,4 @@
-import { MethodKey } from '../../../addressing/index.js';
-import { classAuthoringInput } from '../../class/authoring.js';
+import { classConfiguration } from '../../class/authoring.js';
 import { escapeToken, fail } from '../../schema/diagnostic.js';
 import { isAuthoringValue } from '../../schema/handle.js';
 import { captureCore } from '../core.js';
@@ -38,11 +37,17 @@ function captureExecutables(input, context) {
     for (const [definitionName, definition] of Object.entries(input.classes ?? {})) {
         if (definition.kind !== 'node')
             continue;
-        const methods = classAuthoringInput(definition).methods;
+        const methods = classConfiguration(definition).methods;
         for (const [methodName, method] of Object.entries(methods ?? {})) {
             const pointer = `/classes/${escapeToken(definitionName)}/methods/${escapeToken(methodName)}`;
             assertMethod(method, pointer);
-            context.ownership.capture(method, MethodKey.of({ origin: context.origin, kind: 'class', name: definitionName }, methodName), pointer);
+            const ref = {
+                kind: 'method',
+                owner: { origin: context.origin, kind: 'class', name: definitionName },
+                name: methodName,
+            };
+            context.ownership.captureDefinition(method, ref, pointer);
+            context.capturePolicyObject(method, ref);
         }
     }
     for (const [name, value] of Object.entries(input.views ?? {})) {

package/dist/v1/builder/lowering/schema/compile.d.ts

@@ -1,10 +1,10 @@
 import type { DomainSchema } from '../../../schema/model/schema.js';
 import type { DomainSchemaInput } from '../../schema/input.js';
-import type { DomainOfInput } from '../../schema/projection.js';
+import type { ResolvedDomainOfInput } from '../../schema/projection.js';
 /**
  * Compile the V1 TypeScript builder graph through the same semantic acceptance
  * path used for untrusted decoded schemas.
  *
  * This is the private implementation behind defineSchema.
  */
-export declare function compileSchema<const Origin extends string, const Input extends DomainSchemaInput>(origin: Origin, input: Input): DomainSchema<Origin, Input, DomainOfInput<Origin, Input>>;
+export declare function compileSchema<const Origin extends string, const Input extends DomainSchemaInput>(origin: Origin, input: Input): DomainSchema<Origin, ResolvedDomainOfInput<Origin, Input>>;

package/dist/v1/builder/lowering/schema/compile.js

@@ -29,7 +29,16 @@ export function compileSchema(origin, input) {
 }
 /** Structural assembly before whole-Domain semantic acceptance. */
 function assembleDomainSchema(origin, input, lookup) {
-    assertKnownKeys(input, ['dependencies', 'classes', 'functions', 'policies', 'views', 'core']);
+    assertKnownKeys(input, [
+        'name',
+        'entrypoint',
+        'dependencies',
+        'classes',
+        'functions',
+        'policies',
+        'views',
+        'core',
+    ]);
     if (input.core !== undefined)
         assertKnownKeys(input.core, ['nodes', 'edges'], '/core');
     const context = new BuilderContext(origin, input.dependencies ?? {});
@@ -47,12 +56,16 @@ function assembleDomainSchema(origin, input, lookup) {
     }));
     const policies = mapRecord(input.policies ?? {}, (value, name) => policyCompiler.compile(value, name, `/policies/${escapeToken(name)}`));
     assertPolicyCompositionAcyclic(policies, origin);
-    const views = mapRecord(input.views ?? {}, (value, name) => viewCompiler.compile(value, name, `/views/${escapeToken(name)}`));
+    const views = mapRecord(input.views ?? {}, (value, name) => viewCompiler.compile(value, name));
     const core = compileCore(input.core, context);
     const semanticContent = {
         format: 'astrale.dsl',
         version: 'v1',
         origin,
+        name: input.name,
+        ...(input.entrypoint === undefined
+            ? {}
+            : { entrypoint: { origin, kind: 'view', name: input.entrypoint } }),
         // Class/Property resolution needs every dependency already referenced by
         // authored Definitions. Core endpoint refs are added immediately below.
         dependencies: context.dependencies(),