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

package/dist/v1/schema/compatibility/versioning/surface.js

@@ -0,0 +1,61 @@
+import { methodInheritance } from '../comparators/callables.js';
+import { compareAddedProperties } from '../comparators/classes.js';
+import { compareFacet } from '../comparators/index.js';
+import { fingerprintMeaning } from '../comparators/values.js';
+import { classCoordinate, methodCoordinate } from '../coordinate.js';
+/**
+ * Compare inherited contracts and newly imposed obligations on existing Classes.
+ * Obligations are reported at their declaring Method: changed signatures retain their comparison;
+ * an unchanged obligation newly inherited by a Class is added and unsatisfied.
+ */
+export function compareSurface({ context, report, }) {
+    const established = new Map();
+    const imposed = new Map();
+    for (const declaration of Object.values(context.source.classes)) {
+        if (context.target.classes[declaration.ref.name] === undefined)
+            continue;
+        const pair = context.pair(classCoordinate(declaration.ref));
+        const { source, target } = pair;
+        if (source?.kind !== 'class' || target?.kind !== 'class')
+            continue;
+        report.record({
+            pair,
+            facet: 'class.inherit',
+            ...compareFacet({ context, pair, facet: 'class.inherit' }),
+            requirement: { kind: 'class.inherit' },
+        });
+        compareAddedProperties({ context, pair, report });
+        for (const [key, method] of source.analysis.requirements)
+            if (!established.has(key))
+                established.set(key, method);
+        for (const [key, method] of target.analysis.requirements)
+            if (!source.analysis.requirements.has(key) && !imposed.has(key))
+                imposed.set(key, method);
+    }
+    for (const key of new Set([...established.keys(), ...imposed.keys()])) {
+        const added = imposed.get(key);
+        const method = established.get(key) ?? added;
+        const pair = context.pair(methodCoordinate(method.owner, method.name));
+        const comparison = established.has(key)
+            ? compareFacet({ context, pair, facet: 'method.inheritance' })
+            : undefined;
+        report.record(comparison !== undefined && (added === undefined || changed(comparison))
+            ? {
+                pair,
+                facet: 'method.inheritance',
+                ...comparison,
+                requirement: { kind: 'method.inheritance' },
+            }
+            : {
+                pair,
+                facet: 'method.inheritance',
+                after: methodInheritance(added),
+                requirement: { kind: 'method.inheritance', satisfied: false },
+            });
+    }
+}
+function changed({ before, after }) {
+    return (before === undefined ||
+        after === undefined ||
+        fingerprintMeaning(before) !== fingerprintMeaning(after));
+}

package/dist/v1/schema/diagnostic.d.ts

@@ -1,4 +1,4 @@
-export type SchemaDiagnosticCode = 'DM_MEMBER_ROOT_INVALID' | 'DM_DEPENDENCY_CONTEXT_INVALID' | 'DM_DEPENDENCY_NOT_RETAINED' | 'DM_MEANING_INCONSISTENT' | 'DM_MEMBER_ORIGIN_MISMATCH' | 'DV_ACCEPTANCE_CONTEXT' | 'DV_CALLABLE_AUTH' | 'DV_CALLABLE_IO' | 'DV_CALLABLE_POLICY_AUTH' | 'DV_CLASS_ABSTRACT' | 'DV_CLASS_ACYCLIC' | 'DV_CLASS_KIND' | 'DV_CORE_EDGE_CLASS' | 'DV_CORE_EDGE_CONSTRAINTS' | 'DV_CORE_EDGE_KEY' | 'DV_CORE_EDGE_PROPERTIES' | 'DV_CORE_NODE_CLASS' | 'DV_CORE_NODE_PROPERTIES' | 'DV_CORE_REF' | 'DV_DATA_COMPOSITION' | 'DV_DEPENDENCY_ACYCLIC' | 'DV_DEPENDENCY_DIRECT' | 'DV_DEPENDENCY_EXACT' | 'DV_DEPENDENCY_LIMITS' | 'DV_DEPENDENCY_REVISION_COHERENCE' | 'DV_DEPENDENCY_UNIQUE' | 'DV_EDGE_ACCEPTS' | 'DV_EDGE_CLASS_COMPOSITION' | 'DV_EDGE_CONSTRAINT' | 'DV_EDGE_ROLE' | 'DV_EDGE_UNDIRECTED' | 'DV_JSON_VALUE' | 'DV_METHOD_ABSTRACT' | 'DV_METHOD_COMPOSITION' | 'DV_PROPERTY_AUTO' | 'DV_PROPERTY_COMPOSITION' | 'DV_REF_RESOLVES' | 'DV_VALUE_SCHEMA' | 'DV_VIEW_TARGET' | 'PL_BUDGET' | 'PL_COMPOSITION' | 'PL_CONNECTIVITY' | 'PL_REF' | 'PL_REPEAT' | 'PL_TARGET' | 'PL_TYPING' | 'PL_USE' | 'PL_VARIABLE_SCOPE' | 'STRUCTURE_ABSTRACT_POLICY' | 'STRUCTURE_CALLABLE_POLICY_AUTH' | 'STRUCTURE_DUPLICATE_ITEM' | 'STRUCTURE_EDGE_ORIENTATION' | 'STRUCTURE_FORMAT' | 'STRUCTURE_INVALID' | 'STRUCTURE_KEY' | 'STRUCTURE_MAXIMUM' | 'STRUCTURE_MINIMUM' | 'STRUCTURE_MULTIPLE' | 'STRUCTURE_REQUIRED' | 'STRUCTURE_TYPE' | 'STRUCTURE_UNION' | 'STRUCTURE_UNKNOWN_FIELD' | 'STRUCTURE_VALUE' | 'UNSUPPORTED_DOCUMENT_FORMAT' | 'UNSUPPORTED_DSL_VERSION';
+export type SchemaDiagnosticCode = 'DM_CAPABILITY_INVALID' | 'DM_MEMBER_ROOT_INVALID' | 'DM_DEPENDENCY_CONTEXT_INVALID' | 'DM_DEPENDENCY_NOT_RETAINED' | 'DM_MEANING_INCONSISTENT' | 'DM_MEMBER_ORIGIN_MISMATCH' | 'DV_ACCEPTANCE_CONTEXT' | 'DV_CALLABLE_AUTH' | 'DV_CALLABLE_IO' | 'DV_CALLABLE_POLICY_AUTH' | 'DV_CLASS_ABSTRACT' | 'DV_CLASS_ACYCLIC' | 'DV_CLASS_KIND' | 'DV_CORE_EDGE_CLASS' | 'DV_CORE_EDGE_CONSTRAINTS' | 'DV_CORE_EDGE_KEY' | 'DV_CORE_EDGE_PROPERTIES' | 'DV_CORE_NODE_CLASS' | 'DV_CORE_NODE_PROPERTIES' | 'DV_CORE_REF' | 'DV_DATA_COMPOSITION' | 'DV_DEPENDENCY_ACYCLIC' | 'DV_DEPENDENCY_DIRECT' | 'DV_DEPENDENCY_EXACT' | 'DV_DEPENDENCY_LIMITS' | 'DV_DEPENDENCY_REVISION_COHERENCE' | 'DV_DEPENDENCY_UNIQUE' | 'DV_EDGE_ACCEPTS' | 'DV_EDGE_CLASS_COMPOSITION' | 'DV_EDGE_CONSTRAINT' | 'DV_EDGE_FOREIGN_MINIMUM' | 'DV_EDGE_ROLE' | 'DV_EDGE_UNDIRECTED' | 'DV_ENTRYPOINT' | 'DV_JSON_VALUE' | 'DV_METHOD_ABSTRACT' | 'DV_METHOD_COMPOSITION' | 'DV_PROPERTY_AUTO' | 'DV_PROPERTY_COMPOSITION' | 'DV_PROPERTY_IMMUTABLE' | 'DV_PROPERTY_STATE' | 'DV_REF_RESOLVES' | 'DV_VALUE_SCHEMA' | 'PL_BUDGET' | 'PL_COMPOSITION' | 'PL_CONNECTIVITY' | 'PL_REF' | 'PL_REPEAT' | 'PL_TARGET' | 'PL_TYPING' | 'PL_USE' | 'PL_VARIABLE_SCOPE' | 'STRUCTURE_ABSTRACT_POLICY' | 'STRUCTURE_CALLABLE_POLICY_AUTH' | 'STRUCTURE_DUPLICATE_ITEM' | 'STRUCTURE_EDGE_ORIENTATION' | 'STRUCTURE_FORMAT' | 'STRUCTURE_INVALID' | 'STRUCTURE_KEY' | 'STRUCTURE_MAXIMUM' | 'STRUCTURE_MINIMUM' | 'STRUCTURE_MULTIPLE' | 'STRUCTURE_REQUIRED' | 'STRUCTURE_TYPE' | 'STRUCTURE_UNION' | 'STRUCTURE_UNKNOWN_FIELD' | 'STRUCTURE_VALUE' | 'UNSUPPORTED_DOCUMENT_FORMAT' | 'UNSUPPORTED_DSL_VERSION';
 export interface SchemaDiagnostic<out Code extends SchemaDiagnosticCode = SchemaDiagnosticCode> {
     readonly code: Code;
     readonly pointer: string;

package/dist/v1/schema/fingerprint.d.ts

@@ -0,0 +1,2 @@
+export { callableFingerprint } from './compatibility/comparators/callables.js';
+export type { Fingerprint as MeaningFingerprint } from './compatibility/model.js';

package/dist/v1/schema/fingerprint.js

@@ -0,0 +1 @@
+export { callableFingerprint } from './compatibility/comparators/callables.js';

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

@@ -1,7 +1,7 @@
 /** Admit, encode, inspect, and semantically resolve canonical V1 DomainSchemas. */
 import type { SourceDomain } from '../domain/index.js';
 import type { DomainSchema } from './model/schema.js';
-export type { DomainSchema, DomainSchemaIR, DomainOfSchema as DomainOf, DomainSchemaInputOf as InputOf, } from './model/schema.js';
+export type { DomainSchema, DomainSchemaIR, DomainOfSchema as DomainOf } from './model/schema.js';
 export type ResolvedDomainOf<Schema extends DomainSchema> = SourceDomain<Schema>;
 export interface Resolve {
     <const Schema extends DomainSchema>(schema: Schema): ResolvedDomainOf<Schema>;
@@ -11,8 +11,9 @@ export type { SchemaDiagnosticCode as DiagnosticCode } from './diagnostic.js';
 export { acceptDomainSchema as accept } from './admission/accept.js';
 export { decodeDomainSchema as decode, encodeDomainSchema as encode, serializeDomainSchema as serialize, } from './codec/schema.js';
 export { revisionOfDomainSchema as revision } from './canonical/revision.js';
-export { compareDependencyMeaning, compareMemberMeaning } from './compatibility/meaning.js';
-export type { DependencyMeaningChange, DependencyMeaningChangeKind, DependencyMeaningComparison, MeaningFingerprint, } from './compatibility/meaning.js';
+export { ANNOTATION_KEYWORDS, FIELD_ROLES, callableFingerprint } from './compatibility/index.js';
+export type { FieldRole, MeaningDifference, MeaningFingerprint } from './compatibility/index.js';
+export * as compatibility from './compatibility/api.js';
 export { header } from './codec/header.js';
 export { DOMAIN_FORMAT as FORMAT, DOMAIN_VERSION as VERSION } from './model/format.js';
 export { compile, load } from '../compiled/index.js';

package/dist/v1/schema/index.js

@@ -4,7 +4,8 @@ export const resolve = resolveDomainSchema;
 export { acceptDomainSchema as accept } from './admission/accept.js';
 export { decodeDomainSchema as decode, encodeDomainSchema as encode, serializeDomainSchema as serialize, } from './codec/schema.js';
 export { revisionOfDomainSchema as revision } from './canonical/revision.js';
-export { compareDependencyMeaning, compareMemberMeaning } from './compatibility/meaning.js';
+export { ANNOTATION_KEYWORDS, FIELD_ROLES, callableFingerprint } from './compatibility/index.js';
+export * as compatibility from './compatibility/api.js';
 export { header } from './codec/header.js';
 export { DOMAIN_FORMAT as FORMAT, DOMAIN_VERSION as VERSION } from './model/format.js';
 export { compile, load } from '../compiled/index.js';

package/dist/v1/schema/model/schema.d.ts

@@ -1,5 +1,5 @@
 import type { Key } from '../../addressing/index.js';
-import type { DomainDependencyMap } from '../../addressing/index.js';
+import type { DomainDependencyMap, ViewRef } from '../../addressing/index.js';
 import type { Domain, DomainOfSource, DomainSource } from '../../domain/model/domain.js';
 import type { FunctionDefinition } from '../../language/callable/model/callable.js';
 import type { ClassDefinition } from '../../language/class/model/class.js';
@@ -10,6 +10,10 @@ export interface DomainSchemaIR {
     readonly format: 'astrale.dsl';
     readonly version: 'v1';
     readonly origin: Key.Origin;
+    /** Human-facing display name of the Domain, projected as its Domain Node `name`. */
+    readonly name: string;
+    /** The one View this Domain opens by default, projected as its `entrypoint` Edge. */
+    readonly entrypoint?: ViewRef;
     readonly dependencies: DomainDependencyMap;
     readonly classes: Readonly<Record<string, ClassDefinition>>;
     readonly functions: Readonly<Record<string, FunctionDefinition>>;
@@ -18,20 +22,13 @@ export interface DomainSchemaIR {
     readonly core: CoreContent;
 }
 declare const DOMAIN_SCHEMA_BRAND: unique symbol;
-declare const DOMAIN_SCHEMA_INPUT: unique symbol;
 /**
- * Accepted canonical schema retaining its exact builder input at the type level.
- *
- * The input marker never exists as a JavaScript property and therefore cannot
- * affect canonical JSON, bytes, or revision identity.
+ * Accepted canonical schema carrying its exact resolved Domain projection.
  */
-export type DomainSchema<Origin extends string = string, Input = unknown, Resolved extends Domain = Domain> = DomainSchemaIR & DomainSource<Resolved> & {
+export type DomainSchema<Origin extends string = string, Resolved extends Domain = Domain> = DomainSchemaIR & DomainSource<Resolved> & {
     readonly origin: Origin;
     readonly [DOMAIN_SCHEMA_BRAND]: true;
-    readonly [DOMAIN_SCHEMA_INPUT]: Input;
 };
-/** Recover the exact builder input retained by a locally defined schema. */
-export type DomainSchemaInputOf<Schema extends DomainSchema> = Schema[typeof DOMAIN_SCHEMA_INPUT];
 export type DomainOfSchema<Schema extends DomainSchema> = DomainOfSource<Schema>;
-export declare function asDomainSchema<Origin extends string = string, Input = unknown, Resolved extends Domain = Domain>(value: DomainSchemaIR): DomainSchema<Origin, Input, Resolved>;
+export declare function asDomainSchema<Origin extends string = string, Resolved extends Domain = Domain>(value: DomainSchemaIR): DomainSchema<Origin, Resolved>;
 export {};

package/dist/v1/schema/normalization/domain.js

@@ -1,6 +1,8 @@
 import { json } from '@astrale-os/kernel-dsl/value';
 import { compareDefinitionRefs, compareUnicode } from '../../addressing/ordering.js';
-import { normalizePolicyChecks, normalizePolicyExpression, } from '../../language/policy/normalization/normalize.js';
+import { isBinaryInput } from '../../language/callable/model/callable.js';
+import { normalizeClassRule, normalizePolicyChecks, normalizePolicyExpression, } from '../../language/policy/normalization/normalize.js';
+import { admitStateTopology } from '../../language/state/topology.js';
 import { canonicalizeValueSchema } from '../../language/value/profile/canonicalize.js';
 export function normalizeDomainSchema(schema) {
     const classes = mapRecord(schema.classes, canonicalizeClass);
@@ -11,6 +13,16 @@ export function normalizeDomainSchema(schema) {
         format: 'astrale.dsl',
         version: 'v1',
         origin: schema.origin,
+        name: schema.name,
+        ...(schema.entrypoint === undefined
+            ? {}
+            : {
+                entrypoint: {
+                    origin: schema.entrypoint.origin,
+                    kind: 'view',
+                    name: schema.entrypoint.name,
+                },
+            }),
         dependencies: mapRecord(schema.dependencies, (dependency) => ({ ...dependency })),
         classes,
         functions: mapRecord(schema.functions, canonicalizeFunction),
@@ -40,12 +52,7 @@ function canonicalizeView(value) {
     return {
         ref: value.ref,
         ...withDescription(value),
-        target: value.target.kind === 'domain'
-            ? { kind: 'domain' }
-            : {
-                kind: 'definition',
-                definitions: [...value.target.definitions].sort(compareDefinitionRefs),
-            },
+        target: { kind: 'domain' },
     };
 }
 function canonicalizeClass(value) {
@@ -63,7 +70,7 @@ function canonicalizeClass(value) {
             methods: mapRecord(value.methods, canonicalizeMethod),
             ...(value.data === undefined ? {} : { data: { mediaType: value.data.mediaType } }),
             ...(value.icon === undefined ? {} : { icon: value.icon }),
-            policies: value.policies,
+            policies: canonicalizeNodePolicies(value.policies),
         };
     }
     return value.orientation === 'directed'
@@ -82,6 +89,13 @@ function canonicalizeClass(value) {
             constraints: value.constraints,
         };
 }
+/** A rule keeps one spelling: normalized checks, or the Policy a lone `self` check names. */
+function canonicalizeNodePolicies(value) {
+    return {
+        ...(value.read === undefined ? {} : { read: normalizeClassRule(value.read) }),
+        ...(value.traverse === undefined ? {} : { traverse: normalizeClassRule(value.traverse) }),
+    };
+}
 function canonicalizeFunction(value) {
     return {
         ref: value.ref,
@@ -91,22 +105,35 @@ function canonicalizeFunction(value) {
 function canonicalizeCallable(value) {
     const base = {
         ...withDescription(value),
-        input: canonicalizeValueSchema(value.input, 'callable-input'),
+        input: isBinaryInput(value.input)
+            ? {
+                mode: 'binary',
+                metadata: canonicalizeValueSchema(value.input.metadata, 'callable-input'),
+                maximumBytes: value.input.maximumBytes,
+            }
+            : canonicalizeValueSchema(value.input, 'callable-input'),
         output: canonicalizeCallableOutput(value.output),
+        // Ordinary execution has one canonical form, so existing revisions never move.
+        ...(value.execution?.durable === true ? { execution: { durable: true } } : {}),
     };
     return value.auth === 'authorized'
         ? {
             ...base,
             auth: value.auth,
-            ...(value.policy === undefined ? {} : { policy: normalizePolicyChecks(value.policy) }),
+            ...(value.policy === undefined ? {} : { policy: canonicalizeCallablePolicy(value.policy) }),
         }
         : { ...base, auth: value.auth };
 }
+/** `true` has one spelling; Policy checks keep their normal form. */
+function canonicalizeCallablePolicy(value) {
+    return value === true ? true : normalizePolicyChecks(value);
+}
 function canonicalizeMethod(value) {
     return {
         ...canonicalizeCallable(value),
+        input: canonicalizeValueSchema(value.input, 'callable-input'),
         static: value.static,
-        inheritance: value.inheritance,
+        abstract: value.abstract,
     };
 }
 function canonicalizeCallableOutput(value) {
@@ -123,7 +150,6 @@ function canonicalizeProperty(value) {
     return {
         schema: canonicalizeValueSchema(value.schema, 'property-facet'),
         required: value.required,
-        visibility: value.visibility,
         ...(value.auto === undefined
             ? {}
             : {
@@ -132,7 +158,11 @@ function canonicalizeProperty(value) {
                     set: value.auto.set,
                 },
             }),
+        ...(value.immutable === undefined ? {} : { immutable: value.immutable }),
         ...(value.description === undefined ? {} : { description: value.description }),
+        ...(value.state === undefined
+            ? {}
+            : { state: admitStateTopology(value.state) }),
     };
 }
 function canonicalizeDirectedEndpoints(value) {
@@ -172,7 +202,21 @@ function compareCoreEndpoints(left, right) {
         return right.kind === 'domain' ? 0 : -1;
     if (right.kind === 'domain')
         return 1;
-    return compareDefinitionRefs(left, right);
+    const [a, b] = [coreEndpointOrder(left), coreEndpointOrder(right)];
+    return (compareUnicode(a.origin, b.origin) ||
+        compareUnicode(a.kind, b.kind) ||
+        compareUnicode(a.name, b.name) ||
+        compareUnicode(a.member, b.member));
+}
+/**
+ * A Method orders under its owner Class through the synthetic kind `method`; every other endpoint
+ * keeps the exact `compareDefinitionRefs` tuple with an empty member, so the canonical order of
+ * already-authored Core Edges — and therefore their revisions — never moves.
+ */
+function coreEndpointOrder(ref) {
+    return ref.kind === 'method'
+        ? { origin: ref.owner.origin, kind: ref.kind, name: ref.owner.name, member: ref.name }
+        : { origin: ref.origin, kind: ref.kind, name: ref.name, member: '' };
 }
 function compareBytes(left, right) {
     const encoder = new TextEncoder();

package/dist/v1/schema/resolution/definition.index.d.ts

@@ -1,4 +1,4 @@
-import type { ClassRef, DefinitionRef } from '../../addressing/index.js';
+import type { ClassRef } from '../../addressing/index.js';
 import type { ClassDefinition } from '../../language/class/model/class.js';
 import type { DomainSchemaIR } from '../model/schema.js';
 /** One exact Class declaration resolved within the retained Domain closure. */
@@ -18,4 +18,3 @@ export type IndexedClassDefinition = {
     }>;
 };
 export declare function indexSchemaDefinitions(schema: DomainSchemaIR): ReadonlyMap<string, IndexedClassDefinition>;
-export declare function resolveIndexedReference(indexes: ReadonlyMap<string, IndexedClassDefinition>, ref: DefinitionRef): IndexedClassDefinition | undefined;

package/dist/v1/schema/resolution/definition.index.js

@@ -12,6 +12,3 @@ export function indexSchemaDefinitions(schema) {
     }
     return result;
 }
-export function resolveIndexedReference(indexes, ref) {
-    return ref.kind === 'class' ? indexes.get(definitionRefIndex(ref)) : undefined;
-}

package/dist/v1/schema/resolution/domain.d.ts

@@ -1,4 +1,7 @@
 import type { SourceDomain } from '../../domain/model/domain.js';
 import type { DomainSchema } from '../model/schema.js';
-/** Resolve one accepted Schema through its exact retained source closure. */
+/**
+ * Resolve one accepted Schema through its exact retained source closure. Acceptance validated it
+ * against that closure, which is the only way a Schema retains one, so it is not validated again.
+ */
 export declare function resolve<const S extends DomainSchema>(schema: S): SourceDomain<S>;

package/dist/v1/schema/resolution/domain.js

@@ -2,18 +2,21 @@ import { Key, MethodKey, PropertyKey } from '../../addressing/index.js';
 import { compareUnicode } from '../../addressing/ordering.js';
 import { createDomain, createSourceDomain } from '../../domain/create.js';
 import { createDomainValidation, unknownInputField } from '../../domain/validation/create.js';
+import { isBinaryInput } from '../../language/callable/model/callable.js';
 import { inputFieldNodes } from '../../language/value/compile/fields.js';
 import { prepareValueSchema } from '../../language/value/evaluate/preparation.js';
 import { validateValueProgram } from '../../language/value/evaluate/program.js';
-import { validateJsonInstance } from '../../language/value/evaluate/validate.js';
-import { classifyOrdering } from '../../language/value/ordering.js';
+import { validateJsonInstance, validatePreparedInstance, } from '../../language/value/evaluate/validate.js';
+import { classifyPreparedOrdering } from '../../language/value/ordering.js';
 import { revisionOfDomainSchema } from '../canonical/revision.js';
-import { SchemaError } from '../diagnostic.js';
-import { validateDomainSchemaSemantics } from '../validation/domain.js';
 import { lookupForDomainClosure } from './closure.js';
+import { buildDomainResolutionContext } from './context.js';
 import { createDomainValueSchemaRegistry } from './value.registry.js';
 const resolvedSchemas = new WeakMap();
-/** Resolve one accepted Schema through its exact retained source closure. */
+/**
+ * Resolve one accepted Schema through its exact retained source closure. Acceptance validated it
+ * against that closure, which is the only way a Schema retains one, so it is not validated again.
+ */
 export function resolve(schema) {
     const cached = resolvedSchemas.get(schema);
     if (cached !== undefined)
@@ -23,10 +26,7 @@ export function resolve(schema) {
     return resolved;
 }
 function resolveWithLookup(schema, lookup) {
-    const validation = validateDomainSchemaSemantics(schema, lookup);
-    if (validation.diagnostics.length > 0)
-        throw new SchemaError(validation.diagnostics);
-    const closure = [schema, ...validation.context.dependencies.values()];
+    const closure = [schema, ...buildDomainResolutionContext(schema, lookup).dependencies.values()];
     const registries = new Map(closure.map((owner) => [owner.origin, createDomainValueSchemaRegistry(owner, lookup)]));
     const input = {
         root: Object.freeze({
@@ -51,15 +51,21 @@ function resolveWithLookup(schema, lookup) {
 function sourceValidation(closure, registries) {
     const properties = new Map();
     const callables = new Map();
+    const patterns = new Map();
     for (const owner of closure) {
         const registry = registries.get(owner.origin);
         if (registry === undefined)
             throw new TypeError(`No Value registry exists for ${owner.origin}.`);
         for (const definition of Object.values(owner.classes)) {
             for (const [name, property] of Object.entries(definition.properties)) {
+                const prepared = prepareValueSchema(property.schema, registry, '', patterns);
+                if (!prepared.compiled) {
+                    throw new TypeError(`Accepted Property cannot be prepared: ${prepared.message}`);
+                }
                 properties.set(PropertyKey.of(definition.ref, name), Object.freeze({
-                    ordering: classifyOrdering(property.schema, registry),
-                    validate: (input) => validateJsonInstance(property.schema, input, registry),
+                    ordering: classifyPreparedOrdering(prepared.value),
+                    validate: (input) => validatePreparedInstance(prepared.value, input),
+                    program: () => prepared.value.program(),
                 }));
             }
             if (definition.kind !== 'node')
@@ -69,21 +75,21 @@ function sourceValidation(closure, registries) {
                     ? undefined
                     : method.output.mode === 'value'
                         ? method.output.schema
-                        : method.output.item, registry));
+                        : method.output.item, registry, patterns));
             }
         }
         for (const definition of Object.values(owner.functions)) {
-            callables.set(Key.of(definition.ref), callableValidation(definition.input, definition.output.mode === 'binary'
+            callables.set(Key.of(definition.ref), callableValidation(isBinaryInput(definition.input) ? definition.input.metadata : definition.input, definition.output.mode === 'binary'
                 ? undefined
                 : definition.output.mode === 'value'
                     ? definition.output.schema
-                    : definition.output.item, registry));
+                    : definition.output.item, registry, patterns));
         }
     }
     return createDomainValidation(properties, callables);
 }
-function callableValidation(input, output, registry) {
-    const prepared = prepareValueSchema(input, registry, '');
+function callableValidation(input, output, registry, patterns) {
+    const prepared = prepareValueSchema(input, registry, '', patterns);
     if (!prepared.compiled) {
         throw new TypeError(`Accepted callable input cannot be prepared: ${prepared.message}`);
     }
@@ -91,14 +97,16 @@ function callableValidation(input, output, registry) {
     const fields = inputFieldNodes(inputProgram);
     return Object.freeze({
         ...(fields === undefined ? {} : { fields: Object.freeze(Object.keys(fields)) }),
-        validateInput: (value) => validateJsonInstance(input, value, registry),
+        validateInput: (value) => validatePreparedInstance(prepared.value, value),
         validateInputField(field, value) {
             const nodes = fields?.[field];
             return nodes === undefined
                 ? unknownInputField(field)
                 : validateValueProgram(inputProgram, value, nodes);
         },
-        validateOutput: (value) => output === undefined ? [] : validateJsonInstance(output, value, registry),
+        validateOutput: (value) => output === undefined
+            ? []
+            : validateJsonInstance(output, value, registry, '', patterns),
     });
 }
 function definitionsOf(schema) {

package/dist/v1/schema/resolution/origins.d.ts

@@ -1,14 +1,37 @@
-import type { DefinitionRef } from '../../addressing/index.js';
+import type { DefinitionRef, MethodAddress } from '../../addressing/index.js';
 import type { FunctionDefinition, MethodDefinition } from '../../language/callable/model/callable.js';
 import type { ClassDefinition } from '../../language/class/model/class.js';
+import type { CoreEndpointRef } from '../../language/core/model/core.js';
 import type { PolicyDefinition } from '../../language/policy/model/policy.js';
 import type { JsonSchema } from '../../language/value/model/schema.js';
 import type { DomainSchemaIR } from '../model/schema.js';
+/**
+ * Where one schema references a Definition. `extends` and `core` mean the schema inherits from or
+ * instantiates the Definition; every other site only refers to it. `pattern` is the Edge Class a
+ * Policy pattern matches, whose orientation and accepted endpoint Classes Policy typing reads.
+ */
+export type ReferenceSite = 'extends' | 'endpoint' | 'value' | 'policy' | 'pattern' | 'core';
+/**
+ * What a site names: a Definition, or the Class-owned Method a Policy object term names. A Policy
+ * keeps the Method itself, since it resolves that Method's own executable declaration; a collector
+ * that needs Definitions only takes its owner Class.
+ */
+export type ReferencedDefinition = DefinitionRef | MethodAddress;
+export type ReferenceCollector = (ref: ReferencedDefinition, site: ReferenceSite) => void;
 /** Collect only semantic refs, never strings or objects embedded as JSON data. */
 export declare function collectUsedForeignOrigins(schema: DomainSchemaIR): ReadonlySet<string>;
 /** Complete structured references in one schema, in canonical order. */
 export declare function collectDomainDefinitionRefs(schema: DomainSchemaIR): readonly DefinitionRef[];
-export declare function collectClassRefs(declaration: ClassDefinition, add: (ref: DefinitionRef) => void): void;
-export declare function collectCallableRefs(declaration: FunctionDefinition | MethodDefinition, add: (ref: DefinitionRef) => void): void;
-export declare function collectPolicyDefinitionRefs(declaration: PolicyDefinition, add: (ref: DefinitionRef) => void): void;
-export declare function collectValueDefinitionRefs(schema: JsonSchema, add: (ref: DefinitionRef) => void): void;
+export declare function collectCoreRefs(schema: DomainSchemaIR, add: ReferenceCollector): void;
+/** The owning Domain addresses no Definition, and a Method is addressed through its owner Class. */
+export declare function coreEndpointDefinitionRef(endpoint: CoreEndpointRef): DefinitionRef | undefined;
+export declare function collectClassRefs(declaration: ClassDefinition, add: ReferenceCollector): void;
+export declare function collectClassPolicyRefs(declaration: ClassDefinition, add: ReferenceCollector): void;
+export declare function collectEndpointRefs(declaration: Extract<ClassDefinition, {
+    readonly kind: 'edge';
+}>, add: ReferenceCollector): void;
+export declare function collectCallableRefs(declaration: FunctionDefinition | MethodDefinition, add: ReferenceCollector): void;
+/** References inside the contract a caller compiles against: the input and output value schemas. */
+export declare function collectCallableContractRefs(declaration: Pick<FunctionDefinition | MethodDefinition, 'input' | 'output'>, add: ReferenceCollector): void;
+export declare function collectPolicyDefinitionRefs(declaration: PolicyDefinition, add: ReferenceCollector): void;
+export declare function collectValueDefinitionRefs(schema: JsonSchema, add: ReferenceCollector): void;