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

package/dist/v1/schema/compatibility/meaning/footprint.js

@@ -0,0 +1,59 @@
+import { Key } from '../../../addressing/index.js';
+import { compareAddedProperties, compareLostProperties } from '../comparators/classes.js';
+import { compareFacet } from '../comparators/index.js';
+import { contextInvalid } from '../context.js';
+import { callableReferences, classReferences, inherits, memberReferences, valueReferences, } from '../references.js';
+/** Meaning follows complete callable contracts through the exact authored reference closure. */
+export function compareFootprint({ 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));
+                break;
+            }
+            case 'property':
+                facet = 'property';
+                queue.push(...valueReferences(subject));
+                break;
+            case 'method':
+                facet = 'method.signature';
+                queue.push(...callableReferences(subject));
+                break;
+            case 'member': {
+                facet =
+                    subject.coordinate.ref.kind === 'function'
+                        ? 'function.signature'
+                        : subject.coordinate.ref.kind;
+                queue.push(...memberReferences(subject));
+            }
+        }
+        if (Key.origin(coordinate.key) !== context.source.origin)
+            continue;
+        report.record({
+            pair,
+            facet,
+            ...compareFacet({ context, pair, facet }),
+            requirement: { kind: facet },
+        });
+        if (facet === 'class.inherit')
+            compareAddedProperties({ context, pair, report });
+        if (subject.kind === 'class')
+            compareLostProperties({ pair, report });
+    }
+}

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

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

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

@@ -0,0 +1,16 @@
+import { evidenceOf, losesProperties } from '../evidence.js';
+import { createReport } from '../report.js';
+import { compareFootprint } from './footprint.js';
+export function analyzeMeaning(context) {
+    const report = createReport();
+    compareFootprint({ context, report });
+    const result = { scope: context.scope, ...report.finish() };
+    return Object.freeze({
+        kind: 'meaning',
+        ...result,
+        equivalent: result.assessments.every(({ satisfied }) => satisfied),
+        // Version 2 adds a referenced or inherited Class that lost an effective Property; without it,
+        // version 1.
+        evidence: evidenceOf({ kind: 'meaning', version: losesProperties(result) ? 2 : 1, ...result }),
+    });
+}

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

@@ -0,0 +1,131 @@
+import type { Value } from '@astrale-os/kernel-dsl/value';
+import type { Definition, Key, Revision } from '../../addressing/index.js';
+import type { DomainSchema } from '../model/schema.js';
+import type { ReferenceSite } from '../resolution/origins.js';
+import type { MeaningDifference } from './diff.js';
+export type Fingerprint = `sha256:${string}`;
+/** Inputs carry accepted schemas; a dependency's source is always its retained exact context. */
+export interface ComparisonRequest {
+    readonly scope: {
+        readonly kind: 'dependency';
+        readonly dependent: DomainSchema;
+        /**
+         * Function, Method and Class Keys the dependent declares as capability requirements outside
+         * its schema. Keys of the target origin become roots with relation `capability`: a Function
+         * or Method requires its existence and dispatch, a Class its reference meaning and effective
+         * Property surface. Keys of other origins are ignored; a value that is not a Key list, or an
+         * unresolvable or unsupported Key of the target origin, is rejected with DM_CAPABILITY_INVALID.
+         */
+        readonly capabilities?: readonly Key[];
+    } | {
+        readonly kind: 'members';
+        readonly source: DomainSchema;
+        readonly roots: readonly [Key, ...Key[]];
+    };
+    readonly target: DomainSchema;
+}
+export interface SchemaIdentity {
+    readonly origin: Key.Origin;
+    readonly revision: Revision;
+}
+export interface ComparisonScope {
+    readonly kind: ComparisonRequest['scope']['kind'];
+    readonly source: SchemaIdentity;
+    readonly target: SchemaIdentity;
+    readonly dependent?: SchemaIdentity;
+    readonly roots: readonly Key[];
+}
+/** Identity contains no requirement or usage level. */
+export interface Subject {
+    readonly key: Key;
+    readonly kind: Definition.Kind | 'property' | 'method';
+}
+/** Immediate provenance, retained even when several paths impose the same requirement. */
+export interface Usage {
+    readonly source: SchemaIdentity;
+    readonly key?: Key;
+    readonly relation: ReferenceSite | 'member' | 'abstract' | 'selection' | 'capability';
+}
+export type Facet = 'class.reference' | 'class.inherit' | 'class.composition' | 'class.properties' | 'class.endpoints' | 'property' | 'property.required' | 'method.existence' | 'method.object' | 'method.inheritance' | 'method.signature' | 'function.existence' | 'function.signature' | 'policy' | 'view' | 'core';
+/** A fact about a compared facet, including unchanged facets. No admission decision is implied. */
+export interface Observation {
+    readonly id: string;
+    readonly facet: Facet;
+    readonly state: 'equal' | 'changed' | 'missing' | 'added';
+    readonly before?: Value;
+    readonly after?: Value;
+    readonly differences: readonly MeaningDifference[];
+}
+export interface ComparisonEntry {
+    readonly subject: Subject;
+    readonly source?: SchemaIdentity;
+    readonly target?: SchemaIdentity;
+    readonly usages: readonly Usage[];
+    readonly observations: readonly Observation[];
+}
+/** An established requirement; observations without one remain visible but do not affect the conclusion. */
+export interface Assessment {
+    readonly subject: Subject;
+    readonly observation: Observation;
+    readonly requirement: {
+        readonly kind: Facet;
+    };
+    readonly satisfied: boolean;
+}
+/**
+ * Evidence is a semantic projection; presentation/provenance never enters its digest. Versions are
+ * per kind, and a comparison names the oldest policy that yields its facts. Meaning is version 1.
+ * Structure is version 2, or version 3 when declared capabilities are among its roots, so a
+ * comparison without them keeps the version-2 bytes. Capability Keys join the root Key set of both
+ * digests: one that is not already a root changes the meaning fingerprint, never its version, and
+ * meaning evidence never records whether capabilities were declared. A referenced or inherited Class
+ * that loses an effective Property (`class.properties`) raises structure to version 4 and meaning to
+ * version 2, and structure is version 4 too when it records that a dependent Policy lost what it
+ * relies on (`method.object`, `class.endpoints`). Those facts are recorded only on such a loss, so
+ * every other comparison, every compatible one included, keeps its bytes.
+ */
+export interface ComparisonEvidence {
+    readonly kind: 'structure' | 'meaning';
+    readonly version: 1 | 2 | 3 | 4;
+    readonly fingerprint: Fingerprint;
+}
+export interface Analysis {
+    readonly scope: ComparisonScope;
+    readonly entries: readonly ComparisonEntry[];
+    readonly assessments: readonly Assessment[];
+    readonly evidence: ComparisonEvidence;
+}
+export interface StructureComparison extends Analysis {
+    readonly kind: 'structure';
+    readonly compatible: boolean;
+}
+export interface MeaningComparison extends Analysis {
+    readonly kind: 'meaning';
+    readonly equivalent: boolean;
+}
+export interface Comparison {
+    readonly scope: ComparisonScope;
+    readonly entries: readonly ComparisonEntry[];
+    readonly structure: StructureComparison;
+    readonly meaning: MeaningComparison;
+    readonly evidence: {
+        readonly structure: ComparisonEvidence;
+        readonly meaning: ComparisonEvidence;
+    };
+}
+/** The semantic level a schema change requires at minimum; version numbers stay with the caller. */
+export type Bump = 'patch' | 'minor' | 'major';
+/** One non-equal observation between two versions of one Domain, with the level it alone requires. */
+export interface VersionChange {
+    readonly subject: Subject;
+    readonly observation: Observation;
+    readonly bump: Bump;
+}
+/** The floor `next` sets over `previous`: the highest level among its changes, patch without any. */
+export interface RequiredBump {
+    readonly level: Bump;
+    readonly previous: SchemaIdentity;
+    readonly next: SchemaIdentity;
+    /** Every non-equal observation, ordered by subject Key then observation id; empty for equal revisions. */
+    readonly changes: readonly VersionChange[];
+}

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,38 @@
+import type { DomainSchema } from '../model/schema.js';
+import type { Coordinate } from './coordinate.js';
+import type { Usage } from './model.js';
+import type { ResolvedSubject } from './subjects.js';
+import { Key } from '../../addressing/index.js';
+export interface Reference {
+    readonly coordinate: Coordinate;
+    readonly usage: Usage;
+}
+export declare function schemaIdentity(schema: DomainSchema): Readonly<{
+    origin: string;
+    revision: import("../../addressing/revision.js").Revision;
+}>;
+export declare function usageOf(schema: DomainSchema, relation: Usage['relation'], key?: Key): Usage;
+/** References keep their declaring member and relation; no strongest-usage collapse happens here. */
+export declare function rootReferences(schema: DomainSchema): readonly Reference[];
+/**
+ * What the dependent's own Policies rely on in one origin beyond naming a Definition: each Method a
+ * Policy object term names, in a callable's checks or a Node Class rule, which the Policy resolves
+ * as its owner's own executable declaration, and each Edge Class a Policy pattern matches, whose
+ * orientation and accepted endpoint Classes Policy typing reads. Policies the dependent reaches in
+ * a dependency are that dependency's own.
+ */
+export declare function policyReliance(schema: DomainSchema, origin: Key.Origin): readonly Reference[];
+/** Existing DSL collectors own reference syntax. These functions attach comparison provenance. */
+export declare function valueReferences(subject: Extract<ResolvedSubject, {
+    kind: 'property';
+}>): readonly Reference[];
+export declare function callableReferences(subject: Extract<ResolvedSubject, {
+    kind: 'method';
+}>): readonly Reference[];
+export declare function classReferences(subject: Extract<ResolvedSubject, {
+    kind: 'class';
+}>, inherit: boolean): readonly Reference[];
+export declare function memberReferences(subject: Extract<ResolvedSubject, {
+    kind: 'member';
+}>): readonly Reference[];
+export declare function inherits(usage: Usage): boolean;

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

@@ -0,0 +1,149 @@
+import { Key } from '../../addressing/index.js';
+import { revisionOfDomainSchema } from '../canonical/revision.js';
+import { collectCallableContractRefs, collectCallableRefs, collectClassPolicyRefs, collectCoreRefs, collectEndpointRefs, collectPolicyDefinitionRefs, collectValueDefinitionRefs, coreEndpointDefinitionRef, } from '../resolution/origins.js';
+import { classCoordinate, keyForDefinitionRef, memberCoordinate, methodCoordinate, propertyCoordinate, } from './coordinate.js';
+export function schemaIdentity(schema) {
+    return Object.freeze({ origin: schema.origin, revision: revisionOfDomainSchema(schema) });
+}
+export function usageOf(schema, relation, key) {
+    return Object.freeze({
+        source: schemaIdentity(schema),
+        relation,
+        ...(key === undefined ? {} : { key }),
+    });
+}
+/** A Method a Policy names stays a reference to its owner Class; `policyReliance` keeps the Method. */
+function collector(schema, result, key) {
+    return (ref, relation) => {
+        const definition = ref.kind === 'method' ? ref.owner : ref;
+        result.push({
+            coordinate: definition.kind === 'class'
+                ? classCoordinate(definition)
+                : memberCoordinate(definition),
+            usage: usageOf(schema, relation, key),
+        });
+    };
+}
+/** References keep their declaring member and relation; no strongest-usage collapse happens here. */
+export function rootReferences(schema) {
+    const result = [];
+    for (const declaration of Object.values(schema.classes)) {
+        const key = keyForDefinitionRef(declaration.ref);
+        const add = collector(schema, result, key);
+        declaration.extends.forEach((ref) => add(ref, 'extends'));
+        for (const [name, field] of Object.entries(declaration.properties)) {
+            collectValueDefinitionRefs(field.schema, collector(schema, result, propertyCoordinate(declaration.ref, name).key));
+        }
+        collectClassPolicyRefs(declaration, add);
+        if (declaration.kind === 'edge')
+            collectEndpointRefs(declaration, add);
+        else
+            for (const [name, method] of Object.entries(declaration.methods)) {
+                collectCallableRefs(method, collector(schema, result, methodCoordinate(declaration.ref, name).key));
+            }
+    }
+    for (const declaration of Object.values(schema.functions))
+        collectCallableRefs(declaration, collector(schema, result, keyForDefinitionRef(declaration.ref)));
+    for (const declaration of Object.values(schema.policies))
+        collectPolicyDefinitionRefs(declaration, collector(schema, result, keyForDefinitionRef(declaration.ref)));
+    collectCoreRefs(schema, collector(schema, result));
+    return result;
+}
+/**
+ * What the dependent's own Policies rely on in one origin beyond naming a Definition: each Method a
+ * Policy object term names, in a callable's checks or a Node Class rule, which the Policy resolves
+ * as its owner's own executable declaration, and each Edge Class a Policy pattern matches, whose
+ * orientation and accepted endpoint Classes Policy typing reads. Policies the dependent reaches in
+ * a dependency are that dependency's own.
+ */
+export function policyReliance(schema, origin) {
+    const result = new Map();
+    const collect = (key) => (ref, site) => {
+        const coordinate = ref.kind === 'method'
+            ? methodCoordinate(ref.owner, ref.name)
+            : site === 'pattern'
+                ? classCoordinate(ref)
+                : undefined;
+        if (coordinate === undefined || Key.origin(coordinate.key) !== origin)
+            return;
+        result.set(`${coordinate.key}:${site}`, { coordinate, usage: usageOf(schema, site, key) });
+    };
+    for (const declaration of Object.values(schema.classes)) {
+        collectClassPolicyRefs(declaration, collect(keyForDefinitionRef(declaration.ref)));
+        if (declaration.kind === 'node')
+            for (const [name, method] of Object.entries(declaration.methods))
+                collectCallableRefs(method, collect(methodCoordinate(declaration.ref, name).key));
+    }
+    for (const declaration of Object.values(schema.functions))
+        collectCallableRefs(declaration, collect(keyForDefinitionRef(declaration.ref)));
+    for (const declaration of Object.values(schema.policies))
+        collectPolicyDefinitionRefs(declaration, collect(keyForDefinitionRef(declaration.ref)));
+    return [...result.values()];
+}
+/** Existing DSL collectors own reference syntax. These functions attach comparison provenance. */
+export function valueReferences(subject) {
+    const result = [];
+    collectValueDefinitionRefs(subject.field.schema, collector(subject.schema, result, subject.coordinate.key));
+    return result;
+}
+export function callableReferences(subject) {
+    const result = [];
+    collectCallableContractRefs(subject.method.declaration, collector(subject.schema, result, subject.coordinate.key));
+    return result;
+}
+export function classReferences(subject, inherit) {
+    const result = [];
+    const add = collector(subject.schema, result, subject.coordinate.key);
+    if (inherit) {
+        subject.analysis.declaration.extends.forEach((ref) => add(ref, 'extends'));
+        if (subject.analysis.declaration.kind === 'edge')
+            collectEndpointRefs(subject.analysis.declaration, add);
+    }
+    else {
+        for (const field of subject.analysis.properties.values())
+            result.push({
+                coordinate: propertyCoordinate(field.owner, field.name),
+                usage: usageOf(subject.schema, 'member', subject.coordinate.key),
+            });
+        for (const method of subject.analysis.methods.values())
+            result.push({
+                coordinate: methodCoordinate(method.owner, method.name),
+                usage: usageOf(subject.schema, 'member', subject.coordinate.key),
+            });
+        collectClassPolicyRefs(subject.analysis.declaration, add);
+    }
+    return result;
+}
+export function memberReferences(subject) {
+    const result = [];
+    const { schema, coordinate: { ref, key }, } = subject;
+    const add = collector(schema, result, key);
+    switch (ref.kind) {
+        case 'function':
+            collectCallableRefs(schema.functions[ref.name], add);
+            break;
+        case 'policy':
+            collectPolicyDefinitionRefs(schema.policies[ref.name], add);
+            break;
+        case 'view':
+            break;
+        case 'core': {
+            add(schema.core.nodes[ref.name].class, 'endpoint');
+            for (const edge of schema.core.edges) {
+                if (!((edge.source.kind === 'core' && edge.source.name === ref.name) ||
+                    (edge.target.kind === 'core' && edge.target.name === ref.name)))
+                    continue;
+                add(edge.class, 'endpoint');
+                for (const endpoint of [edge.source, edge.target]) {
+                    const ref = coreEndpointDefinitionRef(endpoint);
+                    if (ref !== undefined)
+                        add(ref, 'endpoint');
+                }
+            }
+        }
+    }
+    return result;
+}
+export function inherits(usage) {
+    return usage.relation === 'extends' || usage.relation === 'core';
+}

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

@@ -0,0 +1,27 @@
+import type { Value } from '@astrale-os/kernel-dsl/value';
+import type { Assessment, ComparisonEntry, Facet } from './model.js';
+import type { Reference } from './references.js';
+import type { SubjectPair } from './scope.js';
+interface ComparisonFact {
+    readonly pair: SubjectPair;
+    readonly facet: Facet;
+    readonly before?: Value;
+    readonly after?: Value;
+    readonly requirement?: {
+        readonly kind: Assessment['requirement']['kind'];
+        readonly satisfied?: boolean;
+    };
+}
+/** Mutable collection is local to one analysis; callers only receive frozen completed reports. */
+export declare function createReport(): {
+    note({ coordinate, usage }: Reference): void;
+    record(fact: ComparisonFact): void;
+    finish(): Readonly<{
+        entries: readonly ComparisonEntry[];
+        assessments: readonly Assessment[];
+    }>;
+};
+export type Report = ReturnType<typeof createReport>;
+/** Full comparison merges facts; it never reclassifies the two analyses' conclusions. */
+export declare function mergeEntries(...groups: readonly (readonly ComparisonEntry[])[]): readonly ComparisonEntry[];
+export {};

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,36 @@
+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[];
+    /** Roots the dependent declares as capabilities on the compared origin; also in `roots`. */
+    readonly capabilities: readonly Reference[];
+    /**
+     * What the dependent's own Policies rely on in the compared origin (`policyReliance`). Not roots:
+     * structure records them only when they fail, so a compatible comparison keeps its bytes.
+     */
+    readonly reliance: readonly Reference[];
+    pair(coordinate: Coordinate): SubjectPair;
+}
+export declare function prepare(request: ComparisonRequest): ComparisonContext;
+/**
+ * Select distinct Keys of the source against a target the caller checked to be of the same origin.
+ * The selection may be empty, which a public request cannot be: `requiredBump` selects every member
+ * of a version that may declare none.
+ */
+export declare function selectMembers(source: DomainSchema, target: DomainSchema, keys: readonly Key[]): ComparisonContext;