@astrale-os/kernel-dsl 0.2.0-beta.37 → 0.2.0-beta.39

package/dist/v1/schema/compatibility/report.js

@@ -0,0 +1,100 @@
+import { json } from '@astrale-os/kernel-dsl/value';
+import { compareUnicode } from '../../addressing/ordering.js';
+import { deepFreeze } from '../canonical/freeze.js';
+import { fingerprintMeaning } from './comparators/values.js';
+import { differences } from './diff.js';
+import { schemaIdentity } from './references.js';
+import { identityOf } from './subjects.js';
+/** Mutable collection is local to one analysis; callers only receive frozen completed reports. */
+export function createReport() {
+    const usages = new Map();
+    const entries = new Map();
+    const assessments = new Map();
+    return {
+        note({ coordinate, usage }) {
+            const values = usages.get(coordinate.key) ?? [];
+            values.push(usage);
+            usages.set(coordinate.key, values);
+        },
+        record(fact) {
+            const { pair, facet, before, after } = fact;
+            const id = `${pair.coordinate.key}#${facet}`;
+            const entry = entries.get(pair.coordinate.key) ?? {
+                pair,
+                observations: new Map(),
+            };
+            const observation = entry.observations.get(id) ??
+                deepFreeze({
+                    id,
+                    facet,
+                    state: before === undefined
+                        ? 'added'
+                        : after === undefined
+                            ? 'missing'
+                            : fingerprintMeaning(before) === fingerprintMeaning(after)
+                                ? 'equal'
+                                : 'changed',
+                    ...(before === undefined ? {} : { before }),
+                    ...(after === undefined ? {} : { after }),
+                    differences: before === undefined || after === undefined ? [] : differences(before, after),
+                });
+            entry.observations.set(id, observation);
+            entries.set(pair.coordinate.key, entry);
+            if (fact.requirement !== undefined) {
+                assessments.set(`${id}:${fact.requirement.kind}`, {
+                    pair,
+                    requirement: fact.requirement,
+                    observation,
+                });
+            }
+        },
+        finish() {
+            const completed = [...entries.values()]
+                .map(({ pair, observations }) => Object.freeze({
+                subject: identityOf(pair.coordinate),
+                ...(pair.source === undefined ? {} : { source: schemaIdentity(pair.source.schema) }),
+                ...(pair.target === undefined ? {} : { target: schemaIdentity(pair.target.schema) }),
+                usages: uniqueUsages(usages.get(pair.coordinate.key) ?? []),
+                observations: Object.freeze([...observations.values()].sort((a, b) => compareUnicode(a.id, b.id))),
+            }))
+                .sort((a, b) => compareUnicode(a.subject.key, b.subject.key));
+            return Object.freeze({
+                entries: Object.freeze(completed),
+                assessments: Object.freeze([...assessments.values()]
+                    .map(({ pair, requirement, observation }) => deepFreeze({
+                    subject: identityOf(pair.coordinate),
+                    observation,
+                    requirement: { kind: requirement.kind },
+                    satisfied: requirement.satisfied ?? observation.state === 'equal',
+                }))
+                    .sort((a, b) => compareUnicode(a.observation.id, b.observation.id) ||
+                    compareUnicode(a.requirement.kind, b.requirement.kind))),
+            });
+        },
+    };
+}
+/** Full comparison merges facts; it never reclassifies the two analyses' conclusions. */
+export function mergeEntries(...groups) {
+    const merged = new Map();
+    for (const entry of groups.flat()) {
+        const previous = merged.get(entry.subject.key);
+        merged.set(entry.subject.key, previous === undefined
+            ? entry
+            : Object.freeze({
+                ...entry,
+                usages: uniqueUsages([...previous.usages, ...entry.usages]),
+                observations: Object.freeze([
+                    ...new Map([...previous.observations, ...entry.observations].map((value) => [
+                        value.id,
+                        value,
+                    ])).values(),
+                ].sort((a, b) => compareUnicode(a.id, b.id))),
+            }));
+    }
+    return Object.freeze([...merged.values()].sort((a, b) => compareUnicode(a.subject.key, b.subject.key)));
+}
+function uniqueUsages(values) {
+    return Object.freeze([...new Map(values.map((value) => [json.serialize(value), value])).entries()]
+        .sort(([a], [b]) => compareUnicode(a, b))
+        .map(([, value]) => value));
+}

package/dist/v1/schema/compatibility/scope.d.ts

@@ -0,0 +1,27 @@
+import type { Key } from '../../addressing/index.js';
+import type { DomainSchema } from '../model/schema.js';
+import type { Context } from './context.js';
+import type { Coordinate } from './coordinate.js';
+import type { ComparisonRequest, ComparisonScope } from './model.js';
+import type { Reference } from './references.js';
+import type { ResolvedSubject } from './subjects.js';
+export interface SubjectPair {
+    readonly coordinate: Coordinate;
+    readonly source: ResolvedSubject | undefined;
+    readonly target: ResolvedSubject | undefined;
+}
+export interface ComparisonContext {
+    readonly scope: ComparisonScope;
+    readonly source: DomainSchema;
+    readonly target: DomainSchema;
+    readonly dependent?: DomainSchema;
+    readonly before: Context;
+    readonly after: Context;
+    readonly roots: readonly Reference[];
+    pair(coordinate: Coordinate): SubjectPair;
+}
+export declare function prepare(request: ComparisonRequest): ComparisonContext;
+export declare function retainedContext(dependent: DomainSchema, origin: Key.Origin, path: '/target/origin' | '/origin'): {
+    source: DomainSchema;
+    context: Context;
+};

package/dist/v1/schema/compatibility/scope.js

@@ -0,0 +1,78 @@
+import { compareUnicode } from '../../addressing/ordering.js';
+import { SchemaError, diagnostic } from '../diagnostic.js';
+import { knownDomainClosure } from '../resolution/closure.js';
+import { resolve } from '../resolution/domain.js';
+import { contextOf } from './context.js';
+import { rootReferences, schemaIdentity, usageOf } from './references.js';
+import { coordinateForKey, resolveSubject } from './subjects.js';
+export function prepare(request) {
+    const { target } = request;
+    let source;
+    let before;
+    let roots;
+    const dependent = request.scope.kind === 'dependency' ? request.scope.dependent : undefined;
+    if (request.scope.kind === 'dependency') {
+        const retained = retainedContext(request.scope.dependent, target.origin, '/target/origin');
+        source = retained.source;
+        before = retained.context;
+        roots = rootReferences(request.scope.dependent);
+    }
+    else {
+        source = request.scope.source;
+        if (source.origin !== target.origin)
+            throw new SchemaError([
+                diagnostic('DM_MEMBER_ORIGIN_MISMATCH', '/target/origin', `Member comparison target ${target.origin} does not match source ${source.origin}.`),
+            ]);
+        const keys = request.scope.roots;
+        if (!Array.isArray(keys) || keys.length === 0 || new Set(keys).size !== keys.length) {
+            throw new SchemaError([
+                diagnostic('DM_MEMBER_ROOT_INVALID', '/roots', 'Member comparison roots must be one non-empty duplicate-free Key set.'),
+            ]);
+        }
+        resolve(source);
+        before = contextOf(source);
+        roots = keys.map((key, index) => ({
+            coordinate: coordinateForKey(before, source, key, index),
+            usage: usageOf(source, 'selection', key),
+        }));
+    }
+    resolve(target);
+    const after = contextOf(target);
+    const pairs = new Map();
+    return {
+        source,
+        target,
+        dependent,
+        before,
+        after,
+        roots,
+        scope: Object.freeze({
+            kind: request.scope.kind,
+            source: schemaIdentity(source),
+            target: schemaIdentity(target),
+            ...(dependent === undefined ? {} : { dependent: schemaIdentity(dependent) }),
+            roots: Object.freeze([...new Set(roots.map(({ coordinate }) => coordinate.key))].sort(compareUnicode)),
+        }),
+        pair(coordinate) {
+            let pair = pairs.get(coordinate.key);
+            if (pair === undefined) {
+                pair = {
+                    coordinate,
+                    source: resolveSubject({ context: before, coordinate }),
+                    target: resolveSubject({ context: after, coordinate }),
+                };
+                pairs.set(coordinate.key, pair);
+            }
+            return pair;
+        },
+    };
+}
+export function retainedContext(dependent, origin, path) {
+    resolve(dependent);
+    const source = (knownDomainClosure(dependent) ?? []).find((entry) => entry.schema.origin === origin)?.schema;
+    if (source === undefined)
+        throw new SchemaError([
+            diagnostic('DM_DEPENDENCY_NOT_RETAINED', path, `Domain ${dependent.origin} was not admitted with a dependency at ${origin}.`),
+        ]);
+    return { source, context: contextOf(dependent) };
+}

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

@@ -0,0 +1,3 @@
+import type { StructureComparison } from '../model.js';
+import type { ComparisonContext } from '../scope.js';
+export declare function analyzeStructure(context: ComparisonContext): StructureComparison;

package/dist/v1/schema/compatibility/structure/index.js

@@ -0,0 +1,16 @@
+import { evidenceOf } from '../evidence.js';
+import { createReport } from '../report.js';
+import { compareInheritance } from './inheritance.js';
+import { compareRequirements } from './requirements.js';
+export function analyzeStructure(context) {
+    const report = createReport();
+    compareRequirements({ context, report });
+    compareInheritance({ context, report });
+    const result = { scope: context.scope, ...report.finish() };
+    return Object.freeze({
+        kind: 'structure',
+        ...result,
+        compatible: result.assessments.every(({ satisfied }) => satisfied),
+        evidence: evidenceOf({ kind: 'structure', ...result }),
+    });
+}

package/dist/v1/schema/compatibility/structure/inheritance.d.ts

@@ -0,0 +1,7 @@
+import type { Report } from '../report.js';
+import type { ComparisonContext } from '../scope.js';
+/** Recompose retained descendants using the same obligations as source and compiled admission. */
+export declare function compareInheritance({ context, report, }: {
+    readonly context: ComparisonContext;
+    readonly report: Report;
+}): void;

package/dist/v1/schema/compatibility/structure/inheritance.js

@@ -0,0 +1,68 @@
+import { json } from '@astrale-os/kernel-dsl/value';
+import { compareUnicode, definitionRefIndex } from '../../../addressing/ordering.js';
+import { composeMethods } from '../../../language/callable/composition.js';
+import { sameMethodSignature } from '../../analysis/class.js';
+import { methodInheritance } from '../comparators/callables.js';
+import { effectiveDefinition, requireOwner } from '../context.js';
+import { classCoordinate, keyForDefinitionRef } from '../coordinate.js';
+import { inherits, usageOf } from '../references.js';
+import { resolveSubject } from '../subjects.js';
+/** Recompose retained descendants using the same obligations as source and compiled admission. */
+export function compareInheritance({ context, report, }) {
+    if (context.dependent === undefined)
+        return;
+    const memo = new Map();
+    const visit = (ref) => {
+        const index = definitionRefIndex(ref);
+        const retained = memo.get(index);
+        if (retained !== undefined)
+            return retained;
+        const owner = requireOwner(context.before, ref, keyForDefinitionRef(ref));
+        const original = effectiveDefinition(context.before, owner, ref);
+        if (ref.origin === context.target.origin) {
+            const replacement = effectiveDefinition(context.after, context.target, ref);
+            return { composition: replacement ?? original, affected: replacement !== undefined };
+        }
+        const parents = original.declaration.extends.map(visit);
+        if (!parents.some((parent) => parent.affected)) {
+            const unchanged = { composition: original, affected: false };
+            memo.set(index, unchanged);
+            return unchanged;
+        }
+        const declaration = original.declaration;
+        const own = new Map(Object.keys(declaration.kind === 'node' ? declaration.methods : {}).map((name) => [
+            name,
+            original.methods.get(name),
+        ]));
+        const issues = [];
+        const composition = composeMethods(parents.map((parent) => parent.composition), own, declaration.abstract, (left, right) => sameMethodSignature(left.declaration, right.declaration), (_message, issue) => issues.push(issue));
+        const coordinate = classCoordinate(ref);
+        const subject = resolveSubject({ context: context.before, coordinate });
+        report.note({ coordinate, usage: usageOf(owner, 'extends', coordinate.key) });
+        report.record({
+            pair: { coordinate, source: subject, target: subject },
+            facet: 'class.composition',
+            before: compositionValue(original, []),
+            after: compositionValue(composition, issues),
+            requirement: { kind: 'class.composition', satisfied: issues.length === 0 },
+        });
+        const result = { composition, affected: true };
+        memo.set(index, result);
+        return result;
+    };
+    for (const declaration of Object.values(context.dependent.classes))
+        visit(declaration.ref);
+    for (const root of context.roots) {
+        if (root.coordinate.kind === 'class' && inherits(root.usage))
+            visit(root.coordinate.ref);
+    }
+}
+function compositionValue(composition, issues) {
+    return {
+        requirements: [...composition.requirements.values()]
+            .sort((a, b) => compareUnicode(a.key, b.key))
+            .map(methodInheritance),
+        frontier: [...composition.frontier.keys()].sort(compareUnicode),
+        issues: [...issues].sort((a, b) => compareUnicode(json.serialize(a), json.serialize(b))),
+    };
+}

package/dist/v1/schema/compatibility/structure/requirements.d.ts

@@ -0,0 +1,7 @@
+import type { Report } from '../report.js';
+import type { ComparisonContext } from '../scope.js';
+/** Structure follows data and abstract obligations; concrete IO never expands its requirements. */
+export declare function compareRequirements({ context, report, }: {
+    readonly context: ComparisonContext;
+    readonly report: Report;
+}): void;

package/dist/v1/schema/compatibility/structure/requirements.js

@@ -0,0 +1,70 @@
+import { Key } from '../../../addressing/index.js';
+import { compareAddedProperties } from '../comparators/classes.js';
+import { compareFacet } from '../comparators/index.js';
+import { contextInvalid } from '../context.js';
+import { methodCoordinate } from '../coordinate.js';
+import { callableReferences, classReferences, inherits, memberReferences, usageOf, valueReferences, } from '../references.js';
+/** Structure follows data and abstract obligations; concrete IO never expands its requirements. */
+export function compareRequirements({ context, report, }) {
+    const queue = [...context.roots];
+    const visited = new Set();
+    for (const reference of queue) {
+        report.note(reference);
+        const { coordinate, usage } = reference;
+        const visit = `${coordinate.key}:${usage.relation}`;
+        if (visited.has(visit))
+            continue;
+        visited.add(visit);
+        const pair = context.pair(coordinate);
+        const subject = pair.source;
+        if (subject === undefined)
+            throw contextInvalid(`Retained acceptance context has no meaning for ${coordinate.key}.`, coordinate.key);
+        let facet;
+        switch (subject.kind) {
+            case 'class': {
+                facet = inherits(usage) ? 'class.inherit' : 'class.reference';
+                queue.push(...classReferences(subject, false));
+                if (inherits(usage)) {
+                    queue.push(...classReferences(subject, true));
+                    for (const method of subject.analysis.requirements.values())
+                        queue.push({
+                            coordinate: methodCoordinate(method.owner, method.name),
+                            usage: usageOf(subject.schema, 'abstract', coordinate.key),
+                        });
+                }
+                break;
+            }
+            case 'property':
+                facet = 'property';
+                queue.push(...valueReferences(subject));
+                break;
+            case 'method': {
+                facet = usage.relation === 'abstract' ? 'method.inheritance' : 'method.existence';
+                if (facet === 'method.inheritance')
+                    queue.push(...callableReferences(subject));
+                break;
+            }
+            case 'member': {
+                facet =
+                    subject.coordinate.ref.kind === 'function'
+                        ? 'function.existence'
+                        : subject.coordinate.ref.kind;
+                if (facet !== 'function.existence')
+                    queue.push(...memberReferences(subject));
+            }
+        }
+        if (Key.origin(coordinate.key) !== context.source.origin)
+            continue;
+        // Class membership does not establish an invocation dependency. Explicit member selection
+        // and inherited abstract obligations do establish requirements; call tracking can add others.
+        const required = facet !== 'method.existence' || usage.relation === 'selection';
+        report.record({
+            pair,
+            facet,
+            ...compareFacet({ context, pair, facet }),
+            ...(required ? { requirement: { kind: facet } } : {}),
+        });
+        if (facet === 'class.inherit')
+            compareAddedProperties({ context, pair, report });
+    }
+}

package/dist/v1/schema/compatibility/subjects.d.ts

@@ -0,0 +1,34 @@
+import type { Key as SemanticKey } from '../../addressing/index.js';
+import type { DefinitionAnalysis, EffectiveField, EffectiveMethod } from '../analysis/class.js';
+import type { DomainSchema } from '../model/schema.js';
+import type { Context } from './context.js';
+import type { ClassCoordinate, Coordinate, MemberCoordinate, MethodCoordinate, PropertyCoordinate } from './coordinate.js';
+import type { Subject } from './model.js';
+export type ResolvedSubject = {
+    readonly kind: 'class';
+    readonly coordinate: ClassCoordinate;
+    readonly schema: DomainSchema;
+    readonly analysis: DefinitionAnalysis;
+} | {
+    readonly kind: 'property';
+    readonly coordinate: PropertyCoordinate;
+    readonly schema: DomainSchema;
+    readonly field: EffectiveField;
+} | {
+    readonly kind: 'method';
+    readonly coordinate: MethodCoordinate;
+    readonly schema: DomainSchema;
+    readonly method: EffectiveMethod;
+} | {
+    readonly kind: 'member';
+    readonly coordinate: MemberCoordinate;
+    readonly schema: DomainSchema;
+};
+/** Resolve a trusted coordinate within one exact accepted closure. */
+export declare function resolveSubject({ context, coordinate, }: {
+    readonly context: Context;
+    readonly coordinate: Coordinate;
+}): ResolvedSubject | undefined;
+export declare function identityOf(coordinate: Coordinate): Subject;
+/** Resolve one caller-supplied Key of the source into an exact coordinate that exists there. */
+export declare function coordinateForKey(context: Context, source: DomainSchema, input: SemanticKey, index: number): Coordinate;

package/dist/v1/schema/compatibility/subjects.js

@@ -0,0 +1,86 @@
+import { Key } from '../../addressing/index.js';
+import { SchemaError, diagnostic } from '../diagnostic.js';
+import { effectiveDefinition, effectiveMethod } from './context.js';
+import { classCoordinate, keyReference, memberCoordinate, methodCoordinate, propertyCoordinate, } from './coordinate.js';
+/** Resolve a trusted coordinate within one exact accepted closure. */
+export function resolveSubject({ context, coordinate, }) {
+    const schema = context.schemas.get(Key.origin(coordinate.key));
+    if (schema === undefined)
+        return undefined;
+    if (coordinate.kind === 'member') {
+        const { ref } = coordinate;
+        const declaration = ref.kind === 'function'
+            ? schema.functions[ref.name]
+            : ref.kind === 'policy'
+                ? schema.policies[ref.name]
+                : ref.kind === 'view'
+                    ? schema.views[ref.name]
+                    : schema.core.nodes[ref.name];
+        return declaration === undefined ? undefined : { kind: 'member', coordinate, schema };
+    }
+    const analysis = effectiveDefinition(context, schema, coordinate.kind === 'class' ? coordinate.ref : coordinate.owner);
+    if (analysis === undefined)
+        return undefined;
+    if (coordinate.kind === 'class')
+        return { kind: 'class', coordinate, schema, analysis };
+    if (coordinate.kind === 'property') {
+        const field = analysis.properties.get(coordinate.key);
+        return field === undefined ? undefined : { kind: 'property', coordinate, schema, field };
+    }
+    const method = effectiveMethod(analysis, coordinate.key);
+    return method === undefined ? undefined : { kind: 'method', coordinate, schema, method };
+}
+export function identityOf(coordinate) {
+    return Object.freeze({
+        key: coordinate.key,
+        kind: coordinate.kind === 'member' ? coordinate.ref.kind : coordinate.kind,
+    });
+}
+/** Resolve one caller-supplied Key of the source into an exact coordinate that exists there. */
+export function coordinateForKey(context, source, input, index) {
+    let key;
+    try {
+        key = Key(input);
+    }
+    catch {
+        return invalidMemberRoot(input, index, 'is not a canonical semantic Key');
+    }
+    if (Key.origin(key) !== source.origin) {
+        return invalidMemberRoot(key, index, `belongs to ${Key.origin(key)}, not source ${source.origin}`);
+    }
+    const reference = keyReference(key);
+    let coordinate;
+    if (reference.member !== undefined && reference.ownerName !== undefined) {
+        if (source.classes[reference.ownerName] === undefined) {
+            return invalidMemberRoot(key, index, 'has no exact owning Definition');
+        }
+        const owner = { origin: source.origin, kind: 'class', name: reference.ownerName };
+        coordinate =
+            reference.member === 'property'
+                ? propertyCoordinate(owner, reference.name)
+                : methodCoordinate(owner, reference.name);
+    }
+    else if (reference.kind === 'class') {
+        if (source.classes[reference.name] === undefined) {
+            return invalidMemberRoot(key, index, 'does not exist in the source');
+        }
+        // Explicit Class selection compares its surface without inferring inheritance.
+        coordinate = classCoordinate({ origin: source.origin, kind: 'class', name: reference.name });
+    }
+    else {
+        coordinate = memberCoordinate({
+            origin: source.origin,
+            kind: reference.kind,
+            name: reference.name,
+        });
+    }
+    if (resolveSubject({ context, coordinate }) === undefined) {
+        return invalidMemberRoot(key, index, 'does not exist in the source');
+    }
+    return coordinate;
+}
+function invalidMemberRoot(key, index, reason) {
+    throw new SchemaError([
+        diagnostic('DM_MEMBER_ROOT_INVALID', `/roots/${index}`, `Key ${JSON.stringify(key)} ${reason}.`, typeof key === 'string' ? key : undefined),
+    ]);
+}

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

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

package/dist/v1/schema/fingerprint.js

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

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

@@ -13,6 +13,7 @@ export { decodeDomainSchema as decode, encodeDomainSchema as encode, serializeDo
 export { revisionOfDomainSchema as revision } from './canonical/revision.js';
 export { ANNOTATION_KEYWORDS, FIELD_ROLES, callableFingerprint, compareDependencyMeaning, compareMemberMeaning, describeMeaningChange, footprintOf, meaningOf, } from './compatibility/index.js';
 export type { DependencyMeaningChange, DependencyMeaningChangeKind, DependencyMeaningComparison, DependencyMeaningLevel, FieldRole, FootprintEntry, 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';
@@ -24,3 +25,5 @@ export type { DomainSchemaHeader as Header } from './codec/header.js';
 export type { DomainDependency } from '../addressing/index.js';
 /** The versioned value-schema grammar embedded in declarations. */
 export * as values from './validation/value-api.js';
+export { compareDependencyStructure } from './compatibility/index.js';
+export type { DependencyStructureComparison } from './compatibility/index.js';

package/dist/v1/schema/index.js

@@ -5,9 +5,11 @@ 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 { ANNOTATION_KEYWORDS, FIELD_ROLES, callableFingerprint, compareDependencyMeaning, compareMemberMeaning, describeMeaningChange, footprintOf, meaningOf, } 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';
 export { SchemaError as Error } from './diagnostic.js';
 /** The versioned value-schema grammar embedded in declarations. */
 export * as values from './validation/value-api.js';
+export { compareDependencyStructure } from './compatibility/index.js';

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

@@ -175,7 +175,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/domain.js

@@ -5,8 +5,8 @@ import { createDomainValidation, unknownInputField } from '../../domain/validati
 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';
@@ -51,15 +51,20 @@ 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),
                 }));
             }
             if (definition.kind !== 'node')
@@ -69,7 +74,7 @@ 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)) {
@@ -77,13 +82,13 @@ function sourceValidation(closure, registries) {
                 ? 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 +96,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) {