@astrale-os/kernel-dsl 1.0.0-beta.2 → 1.0.0-beta.20

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

@@ -1,18 +1,25 @@
 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.
+    // The meaning holds every tuple covering the Class, an ancestor's included (`classMeaning`).
+    unique: 'always',
     properties: 'members',
     methods: 'members',
     description: ANNOTATION,
@@ -27,9 +34,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 +47,7 @@ export const CALLABLE_FIELDS = Object.freeze({
     static: 'always',
     abstract: 'always',
     execution: 'always',
+    admission: AUTHORIZATION,
     auth: AUTHORIZATION,
     policy: AUTHORIZATION,
     description: ANNOTATION,

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

@@ -1,59 +1,25 @@
-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';
+import { walkReferences } from '../walk.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;
+    walkReferences({ context, report }, (subject, { usage }, reach) => {
         switch (subject.kind) {
-            case 'class': {
-                facet = inherits(usage) ? 'class.inherit' : 'class.reference';
-                queue.push(...classReferences(subject, false));
+            case 'class':
+                reach(...classReferences(subject, false));
                 if (inherits(usage))
-                    queue.push(...classReferences(subject, true));
-                break;
-            }
+                    reach(...classReferences(subject, true));
+                return inherits(usage) ? 'class.inherit' : 'class.reference';
             case 'property':
-                facet = 'property';
-                queue.push(...valueReferences(subject));
-                break;
+                reach(...valueReferences(subject));
+                return 'property';
             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));
-            }
+                reach(...callableReferences(subject));
+                return 'method.signature';
+            case 'member':
+                reach(...memberReferences(subject));
+                return subject.coordinate.ref.kind === 'function'
+                    ? 'function.signature'
+                    : subject.coordinate.ref.kind;
         }
-        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/model.d.ts

@@ -1,9 +1,13 @@
 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}`;
+/**
+ * The codes a comparison request is refused with: the request, not a Schema, is invalid. A
+ * `schema.Error` carries them beside the codes of a refused Schema document.
+ */
+export type DiagnosticCode = 'DM_CAPABILITY_INVALID' | 'DM_DEPENDENCY_CONTEXT_INVALID' | 'DM_DEPENDENCY_NOT_RETAINED' | 'DM_MEMBER_ORIGIN_MISMATCH' | 'DM_MEMBER_ROOT_INVALID';
 /** Inputs carry accepted schemas; a dependency's source is always its retained exact context. */
 export interface ComparisonRequest {
     readonly scope: {
@@ -17,6 +21,13 @@ export interface ComparisonRequest {
          * unresolvable or unsupported Key of the target origin, is rejected with DM_CAPABILITY_INVALID.
          */
         readonly capabilities?: readonly Key[];
+        /**
+         * `true` when the dependent already holds its binding to the target, as the installer holds
+         * one a Domain was installed with: the Classes of the target origin it extends are then not
+         * judged for inheritance (DM-CLASS-INHERITANCE). Otherwise each must be `'open'` in the
+         * target. It enters no evidence: a held comparison has the facts of a compatible judged one.
+         */
+        readonly held?: boolean;
     } | {
         readonly kind: 'members';
         readonly source: DomainSchema;
@@ -44,9 +55,9 @@ export interface Subject {
 export interface Usage {
     readonly source: SchemaIdentity;
     readonly key?: Key;
-    readonly relation: ReferenceSite | 'member' | 'abstract' | 'selection' | 'capability';
+    readonly relation: 'extends' | 'core' | 'endpoint' | 'value' | 'policy' | 'pattern' | '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';
+export type Facet = 'class.reference' | 'class.inherit' | 'class.composition' | 'class.properties' | 'class.endpoints' | 'class.inheritance' | '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;
@@ -81,8 +92,9 @@ export interface Assessment {
  * 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.
+ * relies on (`method.object`, `class.endpoints`) or that a Class the dependent extends became final
+ * (`class.inheritance`). 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';

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

@@ -1,6 +1,6 @@
 import { json } from '@astrale-os/kernel-dsl/value';
 import { compareUnicode } from '../../addressing/ordering.js';
-import { deepFreeze } from '../canonical/freeze.js';
+import { deepFreeze } from '../../language/freeze.js';
 import { fingerprintMeaning } from './comparators/values.js';
 import { differences } from './diff.js';
 import { schemaIdentity } from './references.js';

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

@@ -25,6 +25,8 @@ export interface ComparisonContext {
      * structure records them only when they fail, so a compatible comparison keeps its bytes.
      */
     readonly reliance: readonly Reference[];
+    /** Whether the dependent holds its binding to the target, so its extensions are not judged. */
+    readonly held: boolean;
     pair(coordinate: Coordinate): SubjectPair;
 }
 export declare function prepare(request: ComparisonRequest): ComparisonContext;

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

@@ -42,6 +42,7 @@ export function prepare(request) {
         roots: [...rootReferences(dependent), ...capabilities],
         capabilities,
         reliance: policyReliance(dependent, source.origin),
+        held: scope.held === true,
     });
 }
 /**
@@ -63,9 +64,10 @@ export function selectMembers(source, target, keys) {
         })),
         capabilities: [],
         reliance: [],
+        held: false,
     });
 }
-function comparisonContext({ kind, source, target, dependent, before, roots, capabilities, reliance, }) {
+function comparisonContext({ kind, source, target, dependent, before, roots, capabilities, reliance, held, }) {
     resolve(target);
     const after = contextOf(target);
     const pairs = new Map();
@@ -78,6 +80,7 @@ function comparisonContext({ kind, source, target, dependent, before, roots, cap
         roots,
         capabilities,
         reliance,
+        held,
         scope: Object.freeze({
             kind,
             source: schemaIdentity(source),

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

@@ -12,8 +12,9 @@ export function analyzeStructure(context) {
         ...result,
         compatible: result.assessments.every(({ satisfied }) => satisfied),
         // Each version adds one requirement policy and applies only when its fact is present: 3 a
-        // declared capability root, 4 a lost effective Property of a reached Class or a failed Policy
-        // reliance, facts recorded only when they fail. Without one, evidence keeps its version-2 bytes.
+        // declared capability root, 4 a lost effective Property of a reached Class, a failed Policy
+        // reliance or a refused extension, facts recorded only when they fail. Without one, evidence
+        // keeps its version-2 bytes.
         evidence: evidenceOf({
             kind: 'structure',
             version: recordsFailureOnlyFact(result.assessments)
@@ -27,13 +28,14 @@ export function analyzeStructure(context) {
 }
 /**
  * The facts structure records only when they fail: a referenced or inherited Class that lost an
- * effective Property, and what a dependent Policy relies on (a Method object, a matched Edge's
- * endpoints).
+ * effective Property, what a dependent Policy relies on (a Method object, a matched Edge's
+ * endpoints), and a Class the dependent extends that became final.
  */
 const FAILURE_ONLY_FACETS = new Set([
     'class.properties',
     'method.object',
     'class.endpoints',
+    'class.inheritance',
 ]);
 function recordsFailureOnlyFact(assessments) {
     return assessments.some(({ requirement }) => FAILURE_ONLY_FACETS.has(requirement.kind));

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

@@ -1,78 +1,49 @@
-import { Key } from '../../../addressing/index.js';
-import { compareAddedProperties, compareLostProperties } from '../comparators/classes.js';
+import { inheritanceOf } from '../../../language/class/inheritance.js';
+import { inheritanceMeaning } from '../comparators/classes.js';
 import { compareFacet } from '../comparators/index.js';
 import { fingerprintMeaning } from '../comparators/values.js';
 import { contextInvalid } from '../context.js';
 import { methodCoordinate } from '../coordinate.js';
+import { closedParents } from '../extension.js';
 import { callableReferences, classReferences, inherits, memberReferences, usageOf, valueReferences, } from '../references.js';
+import { walkReferences } from '../walk.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;
+    walkReferences({ context, report }, (subject, { coordinate, usage }, reach) => {
         switch (subject.kind) {
-            case 'class': {
-                facet = inherits(usage) ? 'class.inherit' : 'class.reference';
-                queue.push(...classReferences(subject, false));
+            case 'class':
+                reach(...classReferences(subject, false));
                 if (inherits(usage)) {
-                    queue.push(...classReferences(subject, true));
+                    reach(...classReferences(subject, true));
                     for (const method of subject.analysis.requirements.values())
-                        queue.push({
+                        reach({
                             coordinate: methodCoordinate(method.owner, method.name),
                             usage: usageOf(subject.schema, 'abstract', coordinate.key),
                         });
                 }
-                break;
-            }
+                return inherits(usage) ? 'class.inherit' : 'class.reference';
             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));
-            }
+                reach(...valueReferences(subject));
+                return 'property';
+            case 'method':
+                if (usage.relation !== 'abstract')
+                    return 'method.existence';
+                reach(...callableReferences(subject));
+                return 'method.inheritance';
+            case 'member':
+                if (subject.coordinate.ref.kind === 'function')
+                    return 'function.existence';
+                reach(...memberReferences(subject));
+                return subject.coordinate.ref.kind;
         }
-        if (Key.origin(coordinate.key) !== context.source.origin)
-            continue;
-        // Class membership does not establish an invocation dependency. Explicit member selection,
-        // a Method the dependent declares as a capability, and inherited abstract obligations do.
-        const required = facet !== 'method.existence' ||
-            usage.relation === 'selection' ||
-            usage.relation === 'capability';
-        report.record({
-            pair,
-            facet,
-            ...compareFacet({ context, pair, facet }),
-            ...(required ? { requirement: { kind: facet } } : {}),
-        });
-        if (facet === 'class.inherit')
-            compareAddedProperties({ context, pair, report });
-        if (subject.kind === 'class')
-            compareLostProperties({ pair, report });
-    }
+    }, 
+    // Class membership does not establish an invocation dependency. Explicit member selection,
+    // a Method the dependent declares as a capability, and inherited abstract obligations do.
+    (facet, usage) => facet !== 'method.existence' ||
+        usage.relation === 'selection' ||
+        usage.relation === 'capability');
     compareReliance({ context, report });
+    compareExtension({ context, report });
 }
 /**
  * What a dependent Policy relies on is recorded only when it fails: a Method it names that is gone
@@ -95,3 +66,31 @@ function compareReliance({ context, report, }) {
         report.record({ pair, facet, before, after, requirement: { kind: facet } });
     }
 }
+/**
+ * A Class of the compared origin one of the dependent's own Classes extends must be `'open'` in the
+ * target, unless the dependent holds its binding to that target. The fact is recorded only when it
+ * fails, like a Policy reliance, so a compatible comparison keeps its evidence bytes: `'open'`, what
+ * a subclass of another Domain requires, before, and the target's inheritance after.
+ */
+function compareExtension({ context, report, }) {
+    if (context.held || context.dependent === undefined)
+        return;
+    const closed = new Set(closedParents({ dependent: context.dependent, target: context.target }));
+    if (closed.size === 0)
+        return;
+    for (const reference of context.roots) {
+        if (reference.usage.relation !== 'extends' || !closed.has(reference.coordinate.key))
+            continue;
+        const pair = context.pair(reference.coordinate);
+        if (pair.target?.kind !== 'class')
+            continue;
+        report.note(reference);
+        report.record({
+            pair,
+            facet: 'class.inheritance',
+            before: inheritanceMeaning('open'),
+            after: inheritanceMeaning(inheritanceOf(pair.target.analysis.declaration)),
+            requirement: { kind: 'class.inheritance' },
+        });
+    }
+}

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

@@ -1,4 +1,4 @@
-import { deepFreeze } from '../../canonical/freeze.js';
+import { deepFreeze } from '../../../language/freeze.js';
 import { SchemaError, diagnostic } from '../../diagnostic.js';
 import { compareFootprint } from '../meaning/footprint.js';
 import { schemaIdentity } from '../references.js';

package/dist/v1/schema/compatibility/versioning/surface.d.ts

@@ -1,7 +1,7 @@
 import type { Report } from '../report.js';
 import type { ComparisonContext } from '../scope.js';
 /**
- * Compare inherited contracts and newly imposed obligations on existing Classes.
+ * Compare inherited contracts, newly imposed obligations and who may extend 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.
  */

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

@@ -1,10 +1,11 @@
+import { admitsForeignSubclass, inheritanceOf } from '../../../language/class/inheritance.js';
 import { methodInheritance } from '../comparators/callables.js';
-import { compareAddedProperties } from '../comparators/classes.js';
+import { compareAddedProperties, inheritanceMeaning } 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.
+ * Compare inherited contracts, newly imposed obligations and who may extend 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.
  */
@@ -25,6 +26,7 @@ export function compareSurface({ context, report, }) {
             requirement: { kind: 'class.inherit' },
         });
         compareAddedProperties({ context, pair, report });
+        compareExtension({ pair, report });
         for (const [key, method] of source.analysis.requirements)
             if (!established.has(key))
                 established.set(key, method);
@@ -54,6 +56,32 @@ export function compareSurface({ context, report, }) {
             });
     }
 }
+/**
+ * A changed inheritance is observed on its Class, and is major when an `'open'` Class stops being
+ * open: only an `'open'` Class admits a subclass of another Domain (DM-CLASS-INHERITANCE). Closing
+ * or finalizing a Class no other Domain may extend takes nothing from a dependent; opening one
+ * grants an extension, which the floor, counting added members only, leaves at a patch.
+ */
+function compareExtension({ pair, report, }) {
+    if (pair.source?.kind !== 'class' || pair.target?.kind !== 'class')
+        return;
+    const source = pair.source.analysis.declaration;
+    const target = pair.target.analysis.declaration;
+    const before = inheritanceOf(source);
+    const after = inheritanceOf(target);
+    if (before === after)
+        return;
+    report.record({
+        pair,
+        facet: 'class.inheritance',
+        before: inheritanceMeaning(before),
+        after: inheritanceMeaning(after),
+        requirement: {
+            kind: 'class.inheritance',
+            satisfied: !admitsForeignSubclass(source) || admitsForeignSubclass(target),
+        },
+    });
+}
 function changed({ before, after }) {
     return (before === undefined ||
         after === undefined ||

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

@@ -0,0 +1,17 @@
+import type { Usage } from './model.js';
+import type { Reference } from './references.js';
+import type { Report } from './report.js';
+import type { ComparisonContext } from './scope.js';
+import type { ResolvedSubject } from './subjects.js';
+import { compareFacet } from './comparators/index.js';
+type WalkedFacet = Parameters<typeof compareFacet>[0]['facet'];
+/**
+ * Follow the reference closure from the roots once per coordinate and usage relation. `expand`
+ * names the facet a reached subject is compared under and `reach`es what it references; a subject
+ * of the compared origin is then recorded, as a requirement when `required` says so.
+ */
+export declare function walkReferences({ context, report }: {
+    readonly context: ComparisonContext;
+    readonly report: Report;
+}, expand: (subject: ResolvedSubject, reference: Reference, reach: (...references: readonly Reference[]) => void) => WalkedFacet, required?: (facet: WalkedFacet, usage: Usage) => boolean): void;
+export {};

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

@@ -0,0 +1,41 @@
+import { Key } from '../../addressing/index.js';
+import { compareAddedProperties, compareLostProperties } from './comparators/classes.js';
+import { compareFacet } from './comparators/index.js';
+import { contextInvalid } from './context.js';
+/**
+ * Follow the reference closure from the roots once per coordinate and usage relation. `expand`
+ * names the facet a reached subject is compared under and `reach`es what it references; a subject
+ * of the compared origin is then recorded, as a requirement when `required` says so.
+ */
+export function walkReferences({ context, report }, expand, required = () => true) {
+    const queue = [...context.roots];
+    const reach = (...references) => {
+        queue.push(...references);
+    };
+    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);
+        const facet = expand(subject, reference, reach);
+        if (Key.origin(coordinate.key) !== context.source.origin)
+            continue;
+        report.record({
+            pair,
+            facet,
+            ...compareFacet({ context, pair, facet }),
+            ...(required(facet, usage) ? { requirement: { kind: facet } } : {}),
+        });
+        if (facet === 'class.inherit')
+            compareAddedProperties({ context, pair, report });
+        if (subject.kind === 'class')
+            compareLostProperties({ pair, report });
+    }
+}

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

@@ -1,11 +1,25 @@
-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> {
+import type { DiagnosticCode as LanguageDiagnosticCode } from '../language/validation/diagnostic.js';
+import type { Diagnostic as LanguageDiagnostic } from '../language/validation/diagnostic.js';
+import type { DiagnosticCode as CompatibilityDiagnosticCode } from './compatibility/model.js';
+/** The codes a Schema document is refused with, one per rule of `RULES`. */
+export type SchemaDiagnosticCode = 'DV_ACCEPTANCE_CONTEXT' | 'DV_CALLABLE_ADMISSION' | 'DV_CALLABLE_AUTH' | 'DV_CALLABLE_IO' | 'DV_CLASS_ABSTRACT' | 'DV_CLASS_ACYCLIC' | 'DV_CLASS_INHERITANCE' | 'DV_CLASS_KIND' | 'DV_CORE_EDGE_CLASS' | 'DV_CORE_EDGE_CONSTRAINTS' | 'DV_CORE_EDGE_KEY' | 'DV_CORE_EDGE_PROPERTIES' | 'DV_CORE_EDGE_UNIQUE' | 'DV_CORE_NODE_CLASS' | 'DV_CORE_NODE_PROPERTIES' | 'DV_CORE_NODE_UNIQUE' | '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_FOREIGN_MINIMUM' | 'DV_EDGE_LIFETIME' | 'DV_EDGE_ROLE' | 'DV_EDGE_UNIQUE' | 'DV_ENTRYPOINT' | 'DV_JSON_VALUE' | 'DV_METHOD_ABSTRACT' | 'DV_METHOD_COMPOSITION' | 'DV_NODE_UNIQUE' | 'DV_PROPERTY_AUTO' | '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_BINARY_INPUT' | 'STRUCTURE_CALLABLE_POLICY_AUTH' | 'STRUCTURE_DEPENDENCY_ALIAS' | 'STRUCTURE_DOMAIN_NAME' | 'STRUCTURE_DUPLICATE_ITEM' | 'STRUCTURE_EDGE_BLOB' | 'STRUCTURE_EDGE_ORIENTATION' | 'STRUCTURE_FORMAT' | 'STRUCTURE_KEY' | 'STRUCTURE_MAXIMUM' | 'STRUCTURE_MINIMUM' | 'STRUCTURE_PROPERTY_KEY' | 'STRUCTURE_PROTO_KEY' | 'STRUCTURE_REQUIRED' | 'STRUCTURE_STATE_TRANSITIONS' | 'STRUCTURE_TYPE' | 'STRUCTURE_UNION' | 'STRUCTURE_UNKNOWN_FIELD' | 'STRUCTURE_VALUE' | 'UNSUPPORTED_DOCUMENT_FORMAT' | 'UNSUPPORTED_DSL_VERSION';
+/**
+ * A Schema refuses a document with its own codes, and a comparison request with the
+ * compatibility codes. `pointer` names the position the refused rule applies to, in the document
+ * or in the request; it is empty, the root, only when text does not parse or the document is not
+ * an object.
+ */
+export interface SchemaDiagnostic<out Code extends SchemaDiagnosticCode | CompatibilityDiagnosticCode = SchemaDiagnosticCode | CompatibilityDiagnosticCode> {
     readonly code: Code;
     readonly pointer: string;
     readonly message: string;
     readonly ref?: string;
+    /** The code of the value-language refusal the diagnostic carries; its message is the message. */
+    readonly valueCode?: LanguageDiagnosticCode;
 }
-export declare function diagnostic<const Code extends SchemaDiagnosticCode>(code: Code, pointer: string, message: string, ref?: string): SchemaDiagnostic<Code>;
+export declare function diagnostic<const Code extends SchemaDiagnosticCode | CompatibilityDiagnosticCode>(code: Code, pointer: string, message: string, ref?: string): SchemaDiagnostic<Code>;
+/** A Schema diagnostic carrying one value-language refusal, at its position and with its code. */
+export declare function valueDiagnostic<const Code extends SchemaDiagnosticCode>(code: Code, refusal: LanguageDiagnostic): SchemaDiagnostic<Code>;
 export declare class SchemaError extends Error {
     readonly diagnostics: readonly SchemaDiagnostic[];
     constructor(diagnostics: readonly SchemaDiagnostic[]);

package/dist/v1/schema/diagnostic.js

@@ -1,21 +1,24 @@
-import { compareUnicode } from '../addressing/ordering.js';
+import { formatDiagnostics, orderDiagnostics } from '../language/validation/diagnostic.js';
 export function diagnostic(code, pointer, message, ref) {
     return Object.freeze({ code, pointer, message, ...(ref === undefined ? {} : { ref }) });
 }
+/** A Schema diagnostic carrying one value-language refusal, at its position and with its code. */
+export function valueDiagnostic(code, refusal) {
+    const { pointer, message, ref } = refusal;
+    return Object.freeze({
+        code,
+        pointer,
+        message,
+        ...(ref === undefined ? {} : { ref }),
+        valueCode: refusal.code,
+    });
+}
 export class SchemaError extends Error {
     diagnostics;
     constructor(diagnostics) {
-        const ordered = [...diagnostics].sort(compareDiagnostic);
-        super(ordered.map(formatDiagnostic).join('\n'));
+        const ordered = orderDiagnostics(diagnostics);
+        super(formatDiagnostics(ordered));
         this.name = 'SchemaError';
         this.diagnostics = Object.freeze(ordered);
     }
 }
-function compareDiagnostic(left, right) {
-    return (compareUnicode(left.pointer, right.pointer) ||
-        compareUnicode(left.code, right.code) ||
-        compareUnicode(left.message, right.message));
-}
-function formatDiagnostic(value) {
-    return `${value.pointer || '/'} [${value.code}] ${value.message}`;
-}

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 } from './model/schema.js';
+export type { DomainSchema, DomainSchemaIR, DomainSchemaDocument as Document, 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>;
@@ -9,6 +9,8 @@ export interface Resolve {
 export declare const resolve: Resolve;
 export type { SchemaDiagnosticCode as DiagnosticCode } from './diagnostic.js';
 export { acceptDomainSchema as accept } from './admission/accept.js';
+export { acceptCallable } from './admission/callable.js';
+export type { AcceptedCallable } from './admission/callable.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 } from './compatibility/index.js';
@@ -20,6 +22,13 @@ export { compile, load } from '../compiled/index.js';
 export type { CompiledSchema, DomainOfCompiled } from '../compiled/index.js';
 export { SchemaError as Error } from './diagnostic.js';
 export type { SchemaDiagnostic as Diagnostic } from './diagnostic.js';
+export { RULES } from './rule.js';
+export type { SchemaRule as Rule, SchemaRuleStage as RuleStage } from './rule.js';
+export { limits } from '../language/limits.js';
+export type { LimitKey } from '../language/limits.js';
+export { measurePolicies } from './validation/policy/budgets.js';
+export type { PolicyMeasures } from './validation/policy/budgets.js';
+export type { CheckMeasure, PolicyMeasure } from '../language/policy/analysis/budgets.js';
 export type { DomainSchemaLookup as Lookup } from './dependency/lookup.js';
 export type { DomainSchemaHeader as Header } from './codec/header.js';
 export type { DomainDependency } from '../addressing/index.js';