@astrale-os/kernel-dsl 1.0.0-beta.4 → 1.0.0-beta.6

package/dist/v1/language/class/model/class.d.ts

@@ -5,6 +5,11 @@ import type { DataFacet } from './data.js';
 import type { EdgeContract } from './edge.js';
 import type { PropertyFacet } from './property.js';
 export type ClassKind = 'node' | 'edge';
+/**
+ * Which Classes may extend a Class: `'open'`, those of its Domain and of every Domain that depends
+ * on that Domain; `'internal'`, those of its Domain only; `'final'`, none.
+ */
+export type Inheritance = 'open' | 'internal' | 'final';
 /** An absent observation rule admits every caller; a delegation is still scoped by its ceiling. */
 export interface NodeClassPolicies {
     readonly read?: NodeClassPolicy;
@@ -18,6 +23,8 @@ export interface EdgeClassPolicies {
 export interface NodeClassDefinition extends DefinitionBase<ClassRef>, PropertyFacet, DataFacet {
     readonly kind: 'node';
     readonly abstract: boolean;
+    /** Absent when `'internal'`, the default, so a Class that keeps the default keeps its revision. */
+    readonly inheritance?: Exclude<Inheritance, 'internal'>;
     readonly description?: string;
     readonly extends: readonly ClassRef[];
     readonly methods: MethodRecord;
@@ -27,6 +34,8 @@ export interface NodeClassDefinition extends DefinitionBase<ClassRef>, PropertyF
 export type EdgeClassDefinition = DefinitionBase<ClassRef> & PropertyFacet & EdgeContract & {
     readonly kind: 'edge';
     readonly abstract: boolean;
+    /** Absent when `'internal'`, the default, so a Class that keeps the default keeps its revision. */
+    readonly inheritance?: Exclude<Inheritance, 'internal'>;
     readonly description?: string;
     readonly extends: readonly ClassRef[];
     readonly policies: EdgeClassPolicies;

package/dist/v1/language/class/model/edge.d.ts

@@ -22,6 +22,11 @@ export interface UndirectedEdgeConstraints {
     readonly noSelf?: true;
     readonly acyclic?: never;
 }
+/**
+ * The fields one uniqueness tuple of a directed Edge Class names, which no two Edges of the Classes
+ * it covers share: its source endpoint and its slug.
+ */
+export type EdgeUniqueTuple = readonly ['source', 'slug'];
 export interface DirectedEdgeContract {
     readonly orientation: 'directed';
     readonly endpoints: {
@@ -29,10 +34,16 @@ export interface DirectedEdgeContract {
         readonly target: DirectedTargetEndpoint;
     };
     readonly constraints: DirectedEdgeConstraints;
+    /**
+     * The tuples no two Edges of this Class and of its active concrete descendants share. Absent
+     * when the Class declares none, so a Class without one keeps its revision; never empty.
+     */
+    readonly unique?: readonly EdgeUniqueTuple[];
 }
 export interface UndirectedEdgeContract {
     readonly orientation: 'undirected';
     readonly endpoints: readonly [IncidentEndpoint, IncidentEndpoint];
     readonly constraints: UndirectedEdgeConstraints;
+    readonly unique?: never;
 }
 export type EdgeContract = DirectedEdgeContract | UndirectedEdgeContract;

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

@@ -1,3 +1,4 @@
+export { admissionInputFields, isAdmissionMaxAge, MAXIMUM_ADMISSION_AGE_SECONDS, } from './callable/admission.js';
 export { isMethodExecutable } from './callable/executable.js';
 export { isBinaryInput } from './callable/model/callable.js';
 export type { ClassRef, CoreRef, DefinitionBase, DefinitionKey, DefinitionRef, FunctionRef, MethodKey, PolicyRef, PropertyKey, ViewRef, } from '../addressing/index.js';
@@ -13,6 +14,7 @@ export type * from './callable/resolved.js';
 export type * from './class/model/class.js';
 export type { DataDefinition, DataFacet, MediaType } from './class/model/data.js';
 export type * from './class/model/edge.js';
+export { inheritanceOf } from './class/inheritance.js';
 export { edgeLifetimes } from './class/lifetime.js';
 export type { EdgeLifetime } from './class/lifetime.js';
 export type * from './class/model/property.js';

package/dist/v1/language/index.js

@@ -1,7 +1,9 @@
+export { admissionInputFields, isAdmissionMaxAge, MAXIMUM_ADMISSION_AGE_SECONDS, } from './callable/admission.js';
 export { isMethodExecutable } from './callable/executable.js';
 export { isBinaryInput } from './callable/model/callable.js';
 export { valueProgramIncludes } from './value/inclusion/includes.js';
 export { stateMachine } from './state/index.js';
+export { inheritanceOf } from './class/inheritance.js';
 export { edgeLifetimes } from './class/lifetime.js';
 export { PropertyValues } from './class/property-values.js';
 export { isClassRuleChecks, policyVariableClass, policyVariableSelector, policyObjectKey, policyObjectOrigin, projectedMemberClass, } from './policy/model/policy.js';

package/dist/v1/language/value/evaluate/validate.js

@@ -2,6 +2,7 @@ import { diagnostic } from '../../validation/diagnostic.js';
 import { validateCanonicalJsonDomain } from '../profile/json.validate.js';
 import { evaluateInstance } from './evaluator.js';
 import { prepareValueSchema, } from './preparation.js';
+import { satisfies } from './validity.optimization.js';
 const validatorCache = new WeakMap();
 /**
  * Validate one complete portable value with the admitted V1 Draft 2020-12 profile.
@@ -30,6 +31,9 @@ export function validatePreparedInstance(compiled, value) {
         : instanceDiagnostics(compiled, value, '');
 }
 function instanceDiagnostics(compiled, value, pointer) {
+    // A value the compiled check finds valid has nothing to report; any other is evaluated.
+    if (satisfies(compiled, value) === true)
+        return [];
     const result = evaluateInstance(compiled, value);
     if (result.valid)
         return [];

package/dist/v1/language/value/evaluate/validity.optimization.d.ts

@@ -0,0 +1,14 @@
+import type { Value as JsonValue } from '@astrale-os/kernel-dsl/value';
+import type { CompiledInstanceSchema } from './types.js';
+/**
+ * Whether a value satisfies its prepared schema, as the evaluator decides it, without building a
+ * failure, an instance pointer or an annotation: the evaluator's verdict, or undefined when this
+ * check cannot give it. Only the evaluator reports why a value fails, so a caller keeps it for
+ * every value this check does not find valid.
+ *
+ * Each schema location is compiled once into a closure over its keywords, retained with the
+ * prepared schema. A schema whose closure holds an annotation-dependent keyword
+ * (`unevaluatedItems`, `unevaluatedProperties`) is left to the evaluator, as is a value nested
+ * deeper than this check follows, and any value whose check throws.
+ */
+export declare function satisfies(compiled: CompiledInstanceSchema, value: JsonValue): boolean | undefined;

package/dist/v1/language/value/evaluate/validity.optimization.js

@@ -0,0 +1,342 @@
+import { isCanonicalBlobRef } from '../model/blob.js';
+import { isInstantValue } from '../model/instant.js';
+import { isValueObject as isJsonObject } from '../model/object.js';
+import { codePointLength, isMultipleOf, jsonEqual, matchesType, unique } from './assertions.js';
+/**
+ * Whether a value satisfies its prepared schema, as the evaluator decides it, without building a
+ * failure, an instance pointer or an annotation: the evaluator's verdict, or undefined when this
+ * check cannot give it. Only the evaluator reports why a value fails, so a caller keeps it for
+ * every value this check does not find valid.
+ *
+ * Each schema location is compiled once into a closure over its keywords, retained with the
+ * prepared schema. A schema whose closure holds an annotation-dependent keyword
+ * (`unevaluatedItems`, `unevaluatedProperties`) is left to the evaluator, as is a value nested
+ * deeper than this check follows, and any value whose check throws.
+ */
+export function satisfies(compiled, value) {
+    let checks = compilations.get(compiled);
+    if (checks === undefined) {
+        checks = annotationFree(compiled) ? new Map() : null;
+        compilations.set(compiled, checks);
+    }
+    if (checks === null)
+        return undefined;
+    const outer = verdicts;
+    verdicts = new Map();
+    try {
+        return checkOf(compiled, checks, compiled.root)(value, 0);
+    }
+    catch {
+        return undefined;
+    }
+    finally {
+        verdicts = outer;
+    }
+}
+/** Per prepared schema: its checks by location, or null when its closure needs annotations. */
+const compilations = new WeakMap();
+/** Locations one evaluation follows before leaving the value to the evaluator. */
+const MAXIMUM_DEPTH = 1_024;
+const UNDECIDED = new Error('The value is left to the evaluator.');
+/**
+ * The verdicts of the current evaluation by referenced location and value. Only a reference reaches
+ * one location from several places, so each referenced location is checked once per value, as the
+ * evaluator memoizes it, and a schema that references a location twice per level stays linear. A
+ * location entered again on the same value is a cycle, left to the evaluator.
+ */
+let verdicts = new Map();
+function annotationFree(compiled) {
+    for (const { schema } of compiled.locations.values()) {
+        if (isJsonObject(schema) &&
+            (Object.hasOwn(schema, 'unevaluatedItems') || Object.hasOwn(schema, 'unevaluatedProperties'))) {
+            return false;
+        }
+    }
+    return true;
+}
+/** The check of one location, compiled on its first use so that references may recur. */
+function checkOf(compiled, checks, location) {
+    let check = checks.get(location);
+    if (check === undefined) {
+        let body;
+        check = (value, depth) => {
+            if (depth > MAXIMUM_DEPTH)
+                throw UNDECIDED;
+            body ??= compileLocation(compiled, checks, location);
+            return body(value, depth);
+        };
+        checks.set(location, check);
+    }
+    return check;
+}
+/**
+ * The conjunction of the location's keywords, each as the evaluator applies it: an applicator
+ * checks the same value at its child location, a keyword of one type passes every other type.
+ */
+function compileLocation(compiled, checks, location) {
+    const schema = location.schema;
+    if (schema === true)
+        return () => true;
+    if (schema === false)
+        return () => false;
+    const child = (keyword, member) => checkOf(compiled, checks, compiled.child(location, keyword, member));
+    const parts = [];
+    if (Object.hasOwn(schema, '$ref')) {
+        const target = compiled.reference(location);
+        if (target === undefined)
+            throw UNDECIDED;
+        const check = checkOf(compiled, checks, target);
+        parts.push((value, depth) => {
+            let byValue = verdicts.get(target);
+            if (byValue === undefined)
+                verdicts.set(target, (byValue = new Map()));
+            const known = byValue.get(value);
+            if (known === null)
+                throw UNDECIDED;
+            if (known !== undefined)
+                return known;
+            byValue.set(value, null);
+            const verdict = check(value, depth + 1);
+            byValue.set(value, verdict);
+            return verdict;
+        });
+    }
+    compileCompositions(schema, child, parts);
+    compileCommon(schema, parts);
+    compileNumber(schema, parts);
+    compileString(compiled, schema, parts);
+    compileArray(schema, child, parts);
+    compileObject(compiled, schema, child, parts);
+    if (parts.length === 0)
+        return () => true;
+    if (parts.length === 1)
+        return parts[0];
+    return (value, depth) => {
+        for (const part of parts)
+            if (!part(value, depth))
+                return false;
+        return true;
+    };
+}
+function compileCompositions(schema, child, parts) {
+    const allOf = schemaList(schema.allOf)?.map((_, index) => child('allOf', index));
+    if (allOf !== undefined) {
+        parts.push((value, depth) => allOf.every((check) => check(value, depth + 1)));
+    }
+    const anyOf = schemaList(schema.anyOf)?.map((_, index) => child('anyOf', index));
+    if (anyOf !== undefined) {
+        parts.push((value, depth) => anyOf.some((check) => check(value, depth + 1)));
+    }
+    const oneOf = schemaList(schema.oneOf)?.map((_, index) => child('oneOf', index));
+    if (oneOf !== undefined) {
+        parts.push((value, depth) => {
+            let admitted = 0;
+            for (const check of oneOf)
+                if (check(value, depth + 1) && ++admitted > 1)
+                    return false;
+            return admitted === 1;
+        });
+    }
+    if (isSchema(schema.not)) {
+        const not = child('not');
+        parts.push((value, depth) => !not(value, depth + 1));
+    }
+    if (isSchema(schema.if)) {
+        const condition = child('if');
+        const then = isSchema(schema.then) ? child('then') : undefined;
+        const otherwise = isSchema(schema.else) ? child('else') : undefined;
+        parts.push((value, depth) => {
+            const branch = condition(value, depth + 1) ? then : otherwise;
+            return branch === undefined || branch(value, depth + 1);
+        });
+    }
+}
+function compileCommon(schema, parts) {
+    const kind = schema['x-astrale-value-kind'];
+    if (kind === 'instant')
+        parts.push((value) => isInstantValue(value));
+    if (kind === 'blob')
+        parts.push((value) => isCanonicalBlobRef(value));
+    const type = schema.type;
+    if (typeof type === 'string')
+        parts.push((value) => matchesType(type, value));
+    else if (Array.isArray(type)) {
+        const types = type.filter((candidate) => typeof candidate === 'string');
+        parts.push((value) => types.some((candidate) => matchesType(candidate, value)));
+    }
+    if (Object.hasOwn(schema, 'const')) {
+        const expected = schema.const;
+        parts.push((value) => jsonEqual(value, expected));
+    }
+    const choices = schema.enum;
+    if (Array.isArray(choices)) {
+        parts.push((value) => choices.some((candidate) => jsonEqual(value, candidate)));
+    }
+}
+function compileNumber(schema, parts) {
+    const { multipleOf, maximum, exclusiveMaximum, minimum, exclusiveMinimum } = schema;
+    const bounded = typeof multipleOf === 'number' ||
+        typeof maximum === 'number' ||
+        typeof exclusiveMaximum === 'number' ||
+        typeof minimum === 'number' ||
+        typeof exclusiveMinimum === 'number';
+    if (!bounded)
+        return;
+    parts.push((value) => typeof value !== 'number' ||
+        ((typeof multipleOf !== 'number' || isMultipleOf(value, multipleOf)) &&
+            (typeof maximum !== 'number' || value <= maximum) &&
+            (typeof exclusiveMaximum !== 'number' || value < exclusiveMaximum) &&
+            (typeof minimum !== 'number' || value >= minimum) &&
+            (typeof exclusiveMinimum !== 'number' || value > exclusiveMinimum)));
+}
+function compileString(compiled, schema, parts) {
+    const { maxLength, minLength, pattern, fullMatch } = schema;
+    if (typeof maxLength === 'number' || typeof minLength === 'number') {
+        // For n UTF-16 units, ceil(n / 2) <= code points <= n: count only when the bounds cannot
+        // decide, as the evaluator does.
+        parts.push((value) => {
+            if (typeof value !== 'string')
+                return true;
+            if ((typeof maxLength !== 'number' || value.length <= maxLength) &&
+                (typeof minLength !== 'number' || Math.ceil(value.length / 2) >= minLength)) {
+                return true;
+            }
+            const length = codePointLength(value);
+            return ((typeof maxLength !== 'number' || length <= maxLength) &&
+                (typeof minLength !== 'number' || length >= minLength));
+        });
+    }
+    if (typeof pattern === 'string') {
+        const matcher = compiled.matcher(pattern);
+        parts.push((value) => typeof value !== 'string' || matcher.test(value));
+    }
+    if (typeof fullMatch === 'string') {
+        const matcher = compiled.matcher(fullMatch);
+        parts.push((value) => typeof value !== 'string' || matcher.matches(value));
+    }
+}
+function compileArray(schema, child, parts) {
+    const { maxItems, minItems } = schema;
+    if (typeof maxItems === 'number' || typeof minItems === 'number' || schema.uniqueItems === true) {
+        const distinct = schema.uniqueItems === true;
+        parts.push((value) => !Array.isArray(value) ||
+            ((typeof maxItems !== 'number' || value.length <= maxItems) &&
+                (typeof minItems !== 'number' || value.length >= minItems) &&
+                (!distinct || unique(value))));
+    }
+    const prefix = schemaList(schema.prefixItems)?.map((_, index) => child('prefixItems', index));
+    const items = isSchema(schema.items) ? child('items') : undefined;
+    if (prefix !== undefined || items !== undefined) {
+        const leading = prefix ?? [];
+        parts.push((value, depth) => {
+            if (!Array.isArray(value))
+                return true;
+            for (let index = 0; index < value.length; index++) {
+                const check = index < leading.length ? leading[index] : items;
+                if (check !== undefined && !check(value[index], depth + 1))
+                    return false;
+            }
+            return true;
+        });
+    }
+    if (isSchema(schema.contains)) {
+        const contains = child('contains');
+        const least = typeof schema.minContains === 'number' ? schema.minContains : 1;
+        const most = typeof schema.maxContains === 'number' ? schema.maxContains : Number.POSITIVE_INFINITY;
+        parts.push((value, depth) => {
+            if (!Array.isArray(value))
+                return true;
+            let matches = 0;
+            for (const item of value)
+                if (contains(item, depth + 1))
+                    matches++;
+            return matches >= least && matches <= most;
+        });
+    }
+}
+function compileObject(compiled, schema, child, parts) {
+    const { maxProperties, minProperties } = schema;
+    const required = Array.isArray(schema.required)
+        ? schema.required.filter((name) => typeof name === 'string')
+        : [];
+    const dependentRequired = isJsonObject(schema.dependentRequired)
+        ? Object.entries(schema.dependentRequired).flatMap(([name, names]) => Array.isArray(names)
+            ? [[name, names.filter((other) => typeof other === 'string')]]
+            : [])
+        : [];
+    if (typeof maxProperties === 'number' ||
+        typeof minProperties === 'number' ||
+        required.length > 0 ||
+        dependentRequired.length > 0) {
+        parts.push((value) => {
+            if (!isJsonObject(value))
+                return true;
+            if (typeof maxProperties === 'number' || typeof minProperties === 'number') {
+                const count = Object.keys(value).length;
+                if (typeof maxProperties === 'number' && count > maxProperties)
+                    return false;
+                if (typeof minProperties === 'number' && count < minProperties)
+                    return false;
+            }
+            for (const name of required)
+                if (!Object.hasOwn(value, name))
+                    return false;
+            for (const [name, names] of dependentRequired) {
+                if (Object.hasOwn(value, name) && !names.every((other) => Object.hasOwn(value, other))) {
+                    return false;
+                }
+            }
+            return true;
+        });
+    }
+    // Each member is checked by every pattern it matches, by its declared schema, and by the
+    // additional schema when neither declares it.
+    const declared = isJsonObject(schema.properties) ? schema.properties : {};
+    const properties = new Map(Object.keys(declared).map((name) => [name, child('properties', name)]));
+    const patterns = isJsonObject(schema.patternProperties)
+        ? Object.keys(schema.patternProperties).map((source) => [compiled.matcher(source), child('patternProperties', source)])
+        : [];
+    const additional = isSchema(schema.additionalProperties)
+        ? child('additionalProperties')
+        : undefined;
+    const names = isSchema(schema.propertyNames) ? child('propertyNames') : undefined;
+    if (properties.size > 0 || patterns.length > 0 || additional !== undefined || names) {
+        parts.push((value, depth) => {
+            if (!isJsonObject(value))
+                return true;
+            for (const name of Object.keys(value)) {
+                const member = value[name];
+                let matched = false;
+                for (const [matcher, check] of patterns) {
+                    if (!matcher.test(name))
+                        continue;
+                    matched = true;
+                    if (!check(member, depth + 1))
+                        return false;
+                }
+                const check = Object.hasOwn(declared, name) ? properties.get(name) : undefined;
+                if (check !== undefined) {
+                    if (!check(member, depth + 1))
+                        return false;
+                }
+                else if (!matched && additional !== undefined && !additional(member, depth + 1)) {
+                    return false;
+                }
+                if (names !== undefined && !names(name, depth + 1))
+                    return false;
+            }
+            return true;
+        });
+    }
+    if (isJsonObject(schema.dependentSchemas)) {
+        const dependent = Object.keys(schema.dependentSchemas).map((name) => [name, child('dependentSchemas', name)]);
+        parts.push((value, depth) => !isJsonObject(value) ||
+            dependent.every(([name, check]) => !Object.hasOwn(value, name) || check(value, depth + 1)));
+    }
+}
+function schemaList(input) {
+    return Array.isArray(input) ? input : undefined;
+}
+function isSchema(input) {
+    return typeof input === 'boolean' || isJsonObject(input);
+}

package/dist/v1/language/value/profile/canonicalize.js

@@ -7,10 +7,11 @@ const TYPE_RANK = new Map(TYPE_ORDER.map((name, index) => [name, index]));
 const encoder = new TextEncoder();
 /** Canonicalizes syntax without rewriting the schema's algebra. Validate first. */
 export function canonicalizeValueSchema(schema, context, registry) {
+    void context;
     void registry;
-    return canonicalizeSchema(schema, true, context);
+    return canonicalizeSchema(schema, true);
 }
-function canonicalizeSchema(schema, root, context) {
+function canonicalizeSchema(schema, root) {
     if (typeof schema === 'boolean')
         return schema;
     const result = {};
@@ -39,17 +40,17 @@ function canonicalizeSchema(schema, root, context) {
             result[keyword] = canonicalizePathAnnotation(value);
         }
         else if (SCHEMA_SINGLE_KEYWORDS.has(keyword) && isJsonSchema(value)) {
-            result[keyword] = canonicalizeSchema(value, false, context);
+            result[keyword] = canonicalizeSchema(value, false);
         }
         else if (SCHEMA_ARRAY_KEYWORDS.has(keyword) && Array.isArray(value)) {
-            result[keyword] = value.map((entry) => isJsonSchema(entry) ? canonicalizeSchema(entry, false, context) : canonicalizeJson(entry));
+            result[keyword] = value.map((entry) => isJsonSchema(entry) ? canonicalizeSchema(entry, false) : canonicalizeJson(entry));
         }
         else if (SCHEMA_MAP_KEYWORDS.has(keyword) && isJsonObject(value)) {
             const schemas = {};
             for (const name of Object.keys(value).sort()) {
                 const entry = value[name];
                 schemas[name] = isJsonSchema(entry)
-                    ? canonicalizeSchema(entry, false, context)
+                    ? canonicalizeSchema(entry, false)
                     : canonicalizeJson(entry);
             }
             result[keyword] = schemas;

package/dist/v1/schema/compatibility/comparators/classes.d.ts

@@ -1,5 +1,6 @@
 import type { Value as JsonValue } from '@astrale-os/kernel-dsl/value';
 import type { Key as SemanticKey } from '../../../addressing/index.js';
+import type { Inheritance } from '../../../language/class/model/class.js';
 import type { EffectiveField } from '../../analysis/class.js';
 import type { Context } from '../context.js';
 import type { ClassCoordinate } from '../coordinate.js';
@@ -38,6 +39,8 @@ export declare function compareLostProperties({ pair, report, }: {
     readonly pair: SubjectPair;
     readonly report: Report;
 }): void;
+/** Which Classes may extend a Class, as an extension facet compares it. */
+export declare function inheritanceMeaning(inheritance: Inheritance): JsonValue;
 /** Newly required data is an obligation even though it was absent from the source footprint. */
 export declare function compareAddedProperties({ context, pair, report, }: {
     readonly context: ComparisonContext;

package/dist/v1/schema/compatibility/comparators/classes.js

@@ -139,6 +139,10 @@ function propertyIdentities(identities) {
         properties: Object.fromEntries(identities.map((identity) => [identity, true])),
     });
 }
+/** Which Classes may extend a Class, as an extension facet compares it. */
+export function inheritanceMeaning(inheritance) {
+    return deepFreeze({ coordinate: 'class', inheritance });
+}
 /** Newly required data is an obligation even though it was absent from the source footprint. */
 export function compareAddedProperties({ context, pair, report, }) {
     if (pair.source?.kind !== 'class' || pair.target?.kind !== 'class')

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

@@ -5,7 +5,7 @@ import type { ComparisonContext, SubjectPair } from '../scope.js';
 export declare function compareFacet({ context, pair, facet, }: {
     readonly context: ComparisonContext;
     readonly pair: SubjectPair;
-    readonly facet: Exclude<Facet, 'class.composition' | 'class.properties' | 'property.required'>;
+    readonly facet: Exclude<Facet, 'class.composition' | 'class.properties' | 'class.inheritance' | 'property.required'>;
 }): {
     readonly before?: Value;
     readonly after?: Value;

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

@@ -15,7 +15,7 @@ export type DependencyMeaningLevel = 'reference' | 'inherit';
  * compile until it is classified, so meaning can only be narrowed by an explicit decision.
  */
 export type FieldRole = 'always' | 'inherit' | 'members' | {
-    readonly excluded: 'identity' | 'annotation' | 'authorization' | 'presentation';
+    readonly excluded: 'identity' | 'annotation' | 'authorization' | 'extension' | 'presentation';
 };
 /** The coordinate Key already names the declaration; its `ref` is never repeated in the meaning. */
 export declare const CLASS_FIELDS: Readonly<{
@@ -24,12 +24,16 @@ export declare const CLASS_FIELDS: Readonly<{
     }>;
     kind: "always";
     abstract: "always";
+    inheritance: Readonly<{
+        excluded: 'extension';
+    }>;
     orientation: "always";
     extends: "inherit";
     policies: "inherit";
     data: "inherit";
     endpoints: "inherit";
     constraints: "inherit";
+    unique: "always";
     properties: "members";
     methods: "members";
     description: Readonly<{
@@ -50,9 +54,11 @@ export declare const PROPERTY_FIELDS: Readonly<{
     }>;
 }>;
 /**
- * The auth level and Policy check are decided by the Runtime at invocation, never compiled against.
- * The execution modifier decides what an invocation returns; an accepted Schema carries it only
- * when durable, so ordinary callables keep their meaning unchanged.
+ * The auth level, the Policy check and the admission age are authorization: decided by the Runtime
+ * at invocation, never compiled against. The admission age only bounds how old the admission a
+ * destination decides a call under may be. The execution modifier decides what an invocation
+ * returns; an accepted Schema carries it only when durable, so ordinary callables keep their meaning
+ * unchanged.
  */
 export declare const CALLABLE_FIELDS: Readonly<{
     ref: Readonly<{
@@ -63,6 +69,9 @@ export declare const CALLABLE_FIELDS: Readonly<{
     static: "always";
     abstract: "always";
     execution: "always";
+    admission: Readonly<{
+        excluded: 'authorization';
+    }>;
     auth: Readonly<{
         excluded: 'authorization';
     }>;
@@ -114,12 +123,16 @@ export declare const FIELD_ROLES: Readonly<{
         }>;
         kind: "always";
         abstract: "always";
+        inheritance: Readonly<{
+            excluded: 'extension';
+        }>;
         orientation: "always";
         extends: "inherit";
         policies: "inherit";
         data: "inherit";
         endpoints: "inherit";
         constraints: "inherit";
+        unique: "always";
         properties: "members";
         methods: "members";
         description: Readonly<{
@@ -148,6 +161,9 @@ export declare const FIELD_ROLES: Readonly<{
         static: "always";
         abstract: "always";
         execution: "always";
+        admission: Readonly<{
+            excluded: 'authorization';
+        }>;
         auth: Readonly<{
             excluded: 'authorization';
         }>;

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

@@ -1,18 +1,24 @@
 const IDENTITY = Object.freeze({ excluded: 'identity' });
 const ANNOTATION = Object.freeze({ excluded: 'annotation' });
 const AUTHORIZATION = Object.freeze({ excluded: 'authorization' });
+/** Who may extend a Class is no meaning a dependent compiles against. */
+const EXTENSION = Object.freeze({ excluded: 'extension' });
 const PRESENTATION = Object.freeze({ excluded: 'presentation' });
 /** The coordinate Key already names the declaration; its `ref` is never repeated in the meaning. */
 export const CLASS_FIELDS = Object.freeze({
     ref: IDENTITY,
     kind: 'always',
     abstract: 'always',
+    inheritance: EXTENSION,
     orientation: 'always',
     extends: 'inherit',
     policies: 'inherit',
     data: 'inherit',
     endpoints: 'inherit',
     constraints: 'inherit',
+    // A uniqueness tuple bounds every write of the Classes it covers and what a step through them
+    // reaches, so every dependent that names the Class relies on it, not only one that extends it.
+    unique: 'always',
     properties: 'members',
     methods: 'members',
     description: ANNOTATION,
@@ -27,9 +33,11 @@ export const PROPERTY_FIELDS = Object.freeze({
     description: ANNOTATION,
 });
 /**
- * The auth level and Policy check are decided by the Runtime at invocation, never compiled against.
- * The execution modifier decides what an invocation returns; an accepted Schema carries it only
- * when durable, so ordinary callables keep their meaning unchanged.
+ * The auth level, the Policy check and the admission age are authorization: decided by the Runtime
+ * at invocation, never compiled against. The admission age only bounds how old the admission a
+ * destination decides a call under may be. The execution modifier decides what an invocation
+ * returns; an accepted Schema carries it only when durable, so ordinary callables keep their meaning
+ * unchanged.
  */
 export const CALLABLE_FIELDS = Object.freeze({
     ref: IDENTITY,
@@ -38,6 +46,7 @@ export const CALLABLE_FIELDS = Object.freeze({
     static: 'always',
     abstract: 'always',
     execution: 'always',
+    admission: AUTHORIZATION,
     auth: AUTHORIZATION,
     policy: AUTHORIZATION,
     description: ANNOTATION,