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

package/dist/v1/compiled/admission/semantics/policy/typing.js

@@ -1,206 +1,24 @@
 import { Key } from '../../../../addressing/index.js';
-import { compareUnicode } from '../../../../addressing/ordering.js';
-import { branchesOf, branchProduct, capBranches, targetMode, termKey, } from '../../../../language/policy/analysis/branches.js';
+import { PolicyTyping } from '../../../../language/policy/analysis/typing.js';
 import {} from '../../../../language/policy/model/policy.js';
 import {} from '../../../model/schema.js';
-import { classSatisfiesAny } from '../context.js';
-import { compiledTargetContract, callableObjectContracts, } from './contracts.js';
-import { CompiledUnionFind } from './equality.js';
-import { compiledEdgeAlternatives } from './variants.js';
+import { isCompiledEdge } from '../context.js';
+import { referenceContract } from './contracts.js';
 /** Types one entry's Policies against the Node Classes of its own closure, as source admission. */
-export class CompiledPolicyTyping {
-    context;
-    entry;
-    normalized;
-    allNodeClasses;
-    concreteNodeClasses;
-    constructor(context, entry, normalized, origins) {
-        this.context = context;
-        this.entry = entry;
-        this.normalized = normalized;
-        const nodeClasses = [...context.classes.values()].filter(({ value }) => value.kind === 'node' && origins.has(value.ref.origin));
-        this.allNodeClasses = nodeClasses.map(({ value }) => value.ref);
-        this.concreteNodeClasses = nodeClasses
-            .filter(({ value }) => !value.abstract)
-            .map(({ value }) => value.ref);
-    }
-    expandedBranches(name, visiting, namespace) {
-        if (visiting.has(name))
-            return undefined;
-        const declaration = this.normalized.get(name);
-        if (declaration === undefined)
-            return undefined;
-        if ('match' in declaration)
-            return branchesOf(declaration.match, namespace);
-        const nested = new Set(visiting);
-        nested.add(name);
-        const refs = 'allOf' in declaration ? declaration.allOf : declaration.anyOf;
-        const children = [];
-        for (const [index, ref] of refs.entries()) {
-            if (ref.origin !== this.entry.origin || ref.kind !== 'policy')
-                return undefined;
-            const expanded = this.expandedBranches(ref.name, nested, `${namespace}/${index}:${ref.name}`);
-            if (expanded === undefined)
-                return undefined;
-            children.push(expanded);
-        }
-        return 'allOf' in declaration ? branchProduct(children) : capBranches(children.flat());
-    }
-    policyAccepts(name, object) {
-        return this.policyBranchTyping(name, object)?.every(Boolean) ?? false;
-    }
-    policyBranchTyping(name, object) {
-        const branches = this.expandedBranches(name, new Set(), `$use:${name}`);
-        return branches?.map((branch) => this.branchIsTyped(branch, { kind: 'object', object }));
-    }
-    policyAcceptsEdge(name, source, target) {
-        const branches = this.expandedBranches(name, new Set(), `$edge-use:${name}`);
-        return (branches !== undefined &&
-            branches.every((branch) => this.branchIsTyped(branch, { kind: 'edge', source, target })));
-    }
-    concreteEndpointClasses(accepts) {
-        return this.concreteNodeClasses.filter((candidate) => classSatisfiesAny(this.context, candidate, accepts));
-    }
-    endpointsOverlap(left, right) {
-        const seed = [{ kind: 'open', requirements: [] }];
-        return this.applyEndpoint(this.applyEndpoint(seed, left), right).length > 0;
-    }
-    branchIsTyped(branch, use) {
-        if (targetMode(branch) !== use.kind)
-            return false;
-        return compiledEdgeAlternatives(branch.edges, this).some((variants) => this.constraintsSatisfiable(branch, variants, use));
-    }
-    constraintsSatisfiable(branch, variants, use) {
-        const terms = new Set(use.kind === 'object' ? ['subject', 'object'] : ['subject', 'source', 'target']);
-        for (const key of branch.variables.keys())
-            terms.add(key);
-        for (const key of branch.terms.keys())
-            terms.add(key);
-        for (const edge of branch.edges) {
-            terms.add(termKey(edge.pattern.source, edge.namespace));
-            terms.add(termKey(edge.pattern.target, edge.namespace));
-        }
-        const union = new CompiledUnionFind(terms);
-        for (const [left, right] of branch.equalities)
-            union.join(left, right);
-        for (const variant of variants)
-            for (const [left, right] of variant.equalities)
-                union.join(left, right);
-        const constraints = new Map();
-        for (const variant of variants) {
-            for (const [term, accepts] of variant.constraints) {
-                const root = union.find(term);
-                const values = constraints.get(root) ?? [];
-                values.push(accepts);
-                constraints.set(root, values);
-            }
-        }
-        const groups = new Map();
-        for (const term of terms) {
-            const root = union.find(term);
-            const values = groups.get(root) ?? [];
-            values.push(term);
-            groups.set(root, values);
-        }
-        for (const [root, members] of groups) {
-            let candidates = [{ kind: 'open', requirements: [] }];
-            for (const member of members) {
-                candidates = this.applyInitial(candidates, member, branch, use);
-                if (candidates.length === 0)
-                    return false;
-            }
-            for (const endpoint of constraints.get(root) ?? []) {
-                candidates = this.applyEndpoint(candidates, endpoint);
-                if (candidates.length === 0)
-                    return false;
-            }
-        }
-        return true;
-    }
-    applyInitial(candidates, term, branch, use) {
-        if (term === 'subject')
-            return this.applyAnyNodeClass(candidates);
-        const contract = compiledTargetContract(term, use);
-        if (contract !== undefined) {
-            return contract.kind === 'exact'
-                ? this.applyExact(candidates, contract.ref)
-                : uniqueCompiledCandidates(this.allNodeClasses.flatMap((ref) => this.applyExact(candidates, ref)));
-        }
-        const referenced = branch.terms.get(term);
-        if (referenced?.kind === 'ref') {
-            const contract = callableObjectContracts(this.context, this.entry, 0, undefined, referenced)?.[0];
-            return contract?.kind === 'exact' ? this.applyExact(candidates, contract.ref) : [];
-        }
-        const selector = branch.variables.get(term);
-        if (selector === undefined)
-            return [];
-        if (selector.kind === 'exact')
-            return this.applyExact(candidates, selector.class);
-        if (selector.kind === 'any')
-            return candidates;
-        return this.applyRequirement(candidates, selector.class);
-    }
-    applyExact(candidates, exact) {
-        return uniqueCompiledCandidates(candidates.flatMap((candidate) => {
-            if (candidate.kind === 'exact')
-                return Key.of(candidate.ref) === Key.of(exact) ? [candidate] : [];
-            return candidate.requirements.every((required) => classSatisfiesAny(this.context, exact, [required]))
-                ? [{ kind: 'exact', ref: exact }]
-                : [];
-        }));
-    }
-    applyAnyNodeClass(candidates) {
-        return uniqueCompiledCandidates(candidates.flatMap((candidate) => candidate.kind === 'exact'
-            ? [candidate]
-            : this.allNodeClasses
-                .filter((ref) => candidate.requirements.every((required) => classSatisfiesAny(this.context, ref, [required])))
-                .map((ref) => ({ kind: 'exact', ref }))));
-    }
-    applyRequirement(candidates, required) {
-        const result = [];
-        for (const candidate of candidates) {
-            if (candidate.kind === 'exact') {
-                if (classSatisfiesAny(this.context, candidate.ref, [required]))
-                    result.push(candidate);
-            }
-            else {
-                result.push({
-                    kind: 'open',
-                    requirements: uniqueClassRefs([...candidate.requirements, required]),
-                });
-            }
-        }
-        return uniqueCompiledCandidates(result);
-    }
-    applyEndpoint(candidates, accepts) {
-        const result = [];
-        for (const candidate of candidates) {
-            if (candidate.kind === 'exact') {
-                if (classSatisfiesAny(this.context, candidate.ref, accepts))
-                    result.push(candidate);
-            }
-            else {
-                for (const accept of accepts) {
-                    result.push({
-                        kind: 'open',
-                        requirements: uniqueClassRefs([...candidate.requirements, accept]),
-                    });
-                }
-            }
-        }
-        return uniqueCompiledCandidates(result);
-    }
-}
-function uniqueCompiledCandidates(values) {
-    const result = new Map();
-    for (const value of values) {
-        const key = value.kind === 'exact'
-            ? `exact:${Key.of(value.ref)}`
-            : `open:${value.requirements.map(Key.of).sort(compareUnicode).join('|')}`;
-        result.set(key, value);
-    }
-    return [...result.values()];
-}
-function uniqueClassRefs(values) {
-    return [...new Map(values.map((value) => [Key.of(value), value])).values()];
+export function compiledPolicyTyping(context, entry, normalized, origins) {
+    const nodeClasses = [...context.classes.values()]
+        .map(({ value }) => value)
+        .filter((value) => value.kind === 'node' && origins.has(value.ref.origin));
+    return new PolicyTyping({
+        normalized,
+        allNodeClasses: nodeClasses.map((value) => value.ref),
+        concreteNodeClasses: nodeClasses.filter((value) => !value.abstract).map((value) => value.ref),
+        isLocalPolicy: (ref) => ref.origin === entry.origin && ref.kind === 'policy',
+        resolveClass: (ref) => context.classes.get(Key.of(ref))?.value,
+        edgeDeclaration: (ref) => {
+            const value = context.classes.get(Key.of(ref))?.value;
+            return value !== undefined && isCompiledEdge(value) ? value : undefined;
+        },
+        referenceContract: (ref) => referenceContract(context, ref),
+    });
 }

package/dist/v1/compiled/admission/wire/callable.js

@@ -1,4 +1,5 @@
 import {} from '@astrale-os/kernel-dsl/value';
+import { isAdmissionMaxAge } from '../../../language/callable/admission.js';
 import {} from '../../model/schema.js';
 import { invalid, pointer } from '../diagnostic.js';
 import { callablePolicy } from './policy.js';
@@ -16,7 +17,7 @@ export function compiledCallable(input, values, method, path) {
     const value = object(input, 'Compiled Callable', path);
     exact(value, method
         ? ['name', 'auth', 'static', 'abstract', 'input', 'output']
-        : ['ref', 'auth', 'input', 'output'], 'Compiled Callable', path, ['policy', 'description', 'execution', 'fields']);
+        : ['ref', 'auth', 'input', 'output'], 'Compiled Callable', path, ['policy', 'description', 'execution', 'admission', 'fields']);
     if (method) {
         memberName(value.name, 'Method name', `${path}/name`);
         boolean(value.static, 'Method static', `${path}/static`);
@@ -87,4 +88,13 @@ export function compiledCallable(input, values, method, path) {
             invalid('durable Callable output', 'COMPILED_SOURCE_INVALID', `${outputPath}/mode`);
         }
     }
+    if (value.admission !== undefined) {
+        const admissionPath = `${path}/admission`;
+        const admission = object(value.admission, 'Callable admission', admissionPath);
+        exact(admission, ['maxAge'], 'Callable admission', admissionPath);
+        // An absent admission age is the only spelling of a call admitted afresh.
+        if (!isAdmissionMaxAge(admission.maxAge)) {
+            invalid('Callable admission age', 'COMPILED_SOURCE_INVALID', `${admissionPath}/maxAge`);
+        }
+    }
 }

package/dist/v1/compiled/admission/wire/class.js

@@ -1,6 +1,8 @@
 import {} from '@astrale-os/kernel-dsl/value';
 import { Key } from '../../../addressing/index.js';
 import { MEDIA_TYPE_PATTERN } from '../../../language/class/model/data.js';
+import { compareEdgeUniqueTuples, compareNodeUniqueTuples, edgeUniqueTuple, nodeUniqueTuple, } from '../../../language/class/unique.js';
+import { CLASS_OPERATIONS, isClassObservation } from '../../../language/policy/model/policy.js';
 import {} from '../../model/schema.js';
 import { invalid } from '../diagnostic.js';
 import { compiledCallable } from './callable.js';
@@ -25,9 +27,15 @@ export function compiledClass(input, values, path) {
             'constraints',
             'properties',
             'policies',
-        ], 'Compiled Class', path, value.kind === 'node' ? ['data', 'description', 'icon'] : ['description']);
+        ], 'Compiled Class', path, value.kind === 'node'
+        ? ['data', 'description', 'icon', 'inheritance', 'unique']
+        : ['description', 'inheritance', 'unique']);
     definitionRef(value.ref, 'class', 'Class ref', `${path}/ref`);
     boolean(value.abstract, 'Class abstract', `${path}/abstract`);
+    if (value.inheritance !== undefined &&
+        value.inheritance !== 'open' &&
+        value.inheritance !== 'final')
+        invalid('Class inheritance', undefined, `${path}/inheritance`);
     description(value.description, 'Class description', `${path}/description`);
     const extendsPath = `${path}/extends`;
     const parents = array(value.extends, 'Class extends', extendsPath).map((parent, index) => definitionRef(parent, 'class', 'Class parent', `${extendsPath}/${index}`));
@@ -40,6 +48,8 @@ export function compiledClass(input, values, path) {
             dataDefinition(value.data, `${path}/data`);
         boundedString(value.icon, 1, 8000, 'Class icon', `${path}/icon`);
         classPolicies(value.policies, 'node', `${path}/policies`);
+        if (value.unique !== undefined)
+            nodeUniqueTuples(value.unique, `${path}/unique`);
         const methodsPath = `${path}/methods`;
         const methods = array(value.methods, 'Class methods', methodsPath);
         for (const [index, method] of methods.entries())
@@ -54,26 +64,30 @@ export function compiledClass(input, values, path) {
 }
 function classPolicies(input, kind, path) {
     const value = object(input, 'Class Policies', path);
-    exact(value, [], 'Class Policies', path, ['read', 'traverse']);
-    if (value.read !== undefined)
-        classPolicy(value.read, kind, 'Class read Policy', `${path}/read`);
-    if (value.traverse !== undefined)
-        classPolicy(value.traverse, kind, 'Class traverse Policy', `${path}/traverse`);
+    exact(value, [], 'Class Policies', path, CLASS_OPERATIONS);
+    for (const operation of CLASS_OPERATIONS) {
+        const policy = value[operation];
+        if (policy === undefined)
+            continue;
+        const label = `Class ${operation} Policy`;
+        const slot = `${path}/${operation}`;
+        if (isRuleChecks(policy)) {
+            classRuleChecks(policy, slot, kind === 'node' && operation === 'create' ? 'create' : 'class');
+            continue;
+        }
+        // Each slot spells one constant, and a Node create rule has no Node for a named Policy alone.
+        if (policy === !isClassObservation(operation))
+            continue;
+        if (kind === 'node' && operation === 'create')
+            invalid(label, undefined, slot);
+        definitionRef(policy, 'policy', label, slot);
+    }
 }
-/**
- * Check one observation slot: `false`, the rule no caller satisfies, a named Policy, or, on a Node
- * Class only, Policy checks over the observed Node.
- */
-function classPolicy(input, kind, label, path) {
-    if (kind === 'node' &&
-        input !== null &&
+/** Policy checks, as opposed to a constant or a named Policy. */
+function isRuleChecks(input) {
+    return (input !== null &&
         typeof input === 'object' &&
-        ['check', 'sameNode', 'allOf', 'anyOf'].some((key) => Object.hasOwn(input, key))) {
-        classRuleChecks(input, path);
-        return;
-    }
-    if (input !== false)
-        definitionRef(input, 'policy', label, path);
+        ['check', 'sameNode', 'allOf', 'anyOf'].some((key) => Object.hasOwn(input, key)));
 }
 function edgeContract(value, path) {
     const constraintsPath = `${path}/constraints`;
@@ -93,9 +107,13 @@ function edgeContract(value, path) {
             object(endpoints.target, 'directed Edge target', `${endpointsPath}/target`).role) {
             invalid('Edge endpoint roles', undefined, endpointsPath);
         }
+        if (value.unique !== undefined)
+            uniqueTuples(value.unique, `${path}/unique`);
         return;
     }
-    if (value.orientation !== 'undirected' || constraints.acyclic !== undefined) {
+    if (value.orientation !== 'undirected' ||
+        constraints.acyclic !== undefined ||
+        value.unique !== undefined) {
         invalid('Edge orientation', undefined, `${path}/orientation`);
     }
     const endpointsPath = `${path}/endpoints`;
@@ -109,9 +127,41 @@ function edgeContract(value, path) {
         invalid('Edge endpoint roles', undefined, endpointsPath);
     }
 }
+/** A nonempty list of canonical tuples (`edgeUniqueTuple`), distinct and in canonical order. */
+function uniqueTuples(input, path) {
+    const tuples = array(input, 'Edge unique tuples', path);
+    if (tuples.length === 0)
+        invalid('Edge unique tuples', undefined, path);
+    const known = tuples.map((tuple, index) => {
+        const fields = edgeUniqueTuple(array(tuple, 'Edge unique tuple', `${path}/${index}`));
+        if (fields === undefined)
+            invalid('Edge unique tuple', undefined, `${path}/${index}`);
+        return fields;
+    });
+    for (const [index, tuple] of known.entries()) {
+        if (index > 0 && compareEdgeUniqueTuples(known[index - 1], tuple) >= 0)
+            invalid('Edge unique tuples', undefined, `${path}/${index}`);
+    }
+}
+/** A nonempty list of canonical Node tuples (`nodeUniqueTuple`), distinct and in canonical order. */
+function nodeUniqueTuples(input, path) {
+    const tuples = array(input, 'Node unique tuples', path);
+    if (tuples.length === 0)
+        invalid('Node unique tuples', undefined, path);
+    const known = tuples.map((tuple, index) => {
+        const keys = nodeUniqueTuple(array(tuple, 'Node unique tuple', `${path}/${index}`));
+        if (keys === undefined)
+            invalid('Node unique tuple', undefined, `${path}/${index}`);
+        return keys;
+    });
+    for (const [index, tuple] of known.entries()) {
+        if (index > 0 && compareNodeUniqueTuples(known[index - 1], tuple) >= 0)
+            invalid('Node unique tuples', undefined, `${path}/${index}`);
+    }
+}
 function edgeEndpoint(input, count, label, path) {
     const value = object(input, label, path);
-    exact(value, ['role', 'accepts', count], label, path);
+    exact(value, ['role', 'accepts', count], label, path, ['onDelete']);
     memberName(value.role, `${label} role`, `${path}/role`);
     const acceptsPath = `${path}/accepts`;
     const accepts = array(value.accepts, `${label} accepts`, acceptsPath).map((item, index) => definitionRef(item, 'class', `${label} accepted Class`, `${acceptsPath}/${index}`));
@@ -124,6 +174,8 @@ function edgeEndpoint(input, count, label, path) {
         value[count] !== '1') {
         invalid(`${label} ${count}`, undefined, `${path}/${count}`);
     }
+    if (value.onDelete !== undefined && value.onDelete !== 'restrict' && value.onDelete !== 'detach')
+        invalid(`${label} onDelete`, undefined, `${path}/onDelete`);
 }
 function dataDefinition(input, path) {
     const value = object(input, 'Class data', path);

package/dist/v1/compiled/admission/wire/policy.d.ts

@@ -4,7 +4,8 @@ export declare function compiledPolicy(input: JsonValue, path: string): never;
 /** Check one callable's caller rule: `true`, the rule every caller satisfies, or Policy checks. */
 export declare function callablePolicy(input: JsonValue | undefined, path: string): void;
 /**
- * Check one Node Class rule: Policy checks over `self` and `ref` objects only, in their one
- * spelling. A lone check of `self` is spelled as the Policy reference itself.
+ * Check one Class rule: Policy checks over `self` and `ref` objects only, or, in a Node create
+ * rule, `ref` objects only, in their one spelling. A lone check of `self` is spelled as the Policy
+ * reference itself.
  */
-export declare function classRuleChecks(input: JsonValue, path: string): void;
+export declare function classRuleChecks(input: JsonValue, path: string, site: 'class' | 'create'): void;

package/dist/v1/compiled/admission/wire/policy.js

@@ -130,17 +130,18 @@ export function callablePolicy(input, path) {
         policyCheck(input, 0, path);
 }
 /**
- * Check one Node Class rule: Policy checks over `self` and `ref` objects only, in their one
- * spelling. A lone check of `self` is spelled as the Policy reference itself.
+ * Check one Class rule: Policy checks over `self` and `ref` objects only, or, in a Node create
+ * rule, `ref` objects only, in their one spelling. A lone check of `self` is spelled as the Policy
+ * reference itself.
  */
-export function classRuleChecks(input, path) {
-    policyCheck(input, 0, path, 'class');
+export function classRuleChecks(input, path, site) {
+    policyCheck(input, 0, path, site);
     const rule = input;
     if (json.serialize(normalizeClassRule(rule)) !== json.serialize(rule))
         invalid('Class rule spelling', undefined, path);
 }
 /** What a site calls its checks in a refusal. */
-const SITE = { callable: 'Callable Policy', class: 'Class rule' };
+const SITE = { callable: 'Callable Policy', class: 'Class rule', create: 'Create rule' };
 /** Check the recursive Policy check wire grammar of one use site. */
 function policyCheck(input, depth, path, site = 'callable') {
     const name = SITE[site];
@@ -148,7 +149,7 @@ function policyCheck(input, depth, path, site = 'callable') {
         invalid(`${name} depth`, undefined, path);
     const value = object(input, name, path);
     if (Object.hasOwn(value, 'sameNode')) {
-        const equality = site === 'class' ? 'Class rule equality' : 'Callable equality';
+        const equality = site === 'callable' ? 'Callable equality' : `${name} equality`;
         exact(value, ['sameNode'], equality, path);
         const pair = object(value.sameNode, equality, `${path}/sameNode`);
         exact(pair, ['left', 'right'], `${equality} operands`, `${path}/sameNode`);
@@ -174,7 +175,7 @@ function policyCheck(input, depth, path, site = 'callable') {
 function policyCheckObject(input, objectPath, site) {
     const name = SITE[site];
     const target = object(input, `${name} object`, objectPath);
-    if (target.kind === 'self')
+    if (target.kind === 'self' && site !== 'create')
         exact(target, ['kind'], `${name} self`, objectPath);
     else if (target.kind === 'input' && site === 'callable') {
         exact(target, ['kind', 'field'], `${name} input`, objectPath);

package/dist/v1/compiled/compiler/compile.js

@@ -1,3 +1,4 @@
+import { compareCodeUnits } from '../../addressing/ordering.js';
 import { isBinaryInput } from '../../language/callable/model/callable.js';
 import { inputFieldNodes } from '../../language/value/compile/fields.js';
 import { prepareValueSchema } from '../../language/value/evaluate/preparation.js';
@@ -13,7 +14,7 @@ export function compile(schema) {
         ...requireDomainClosure(schema).map(({ schema: dependency }) => dependency),
     ]
         .filter((value, index, all) => all.findIndex(({ origin }) => origin === value.origin) === index)
-        .sort((left, right) => compare(left.origin, right.origin));
+        .sort((left, right) => compareCodeUnits(left.origin, right.origin));
     const closure = Object.freeze(sources.map((source) => compileEntry(source, lookup)));
     return Object.freeze({
         format: 'astrale.dsl.compiled-schema',
@@ -46,7 +47,7 @@ function compileEntry(schema, lookup) {
     };
     const add = (contract, pointer) => addProgram(prepare(contract, pointer).program());
     const properties = (definition, pointer) => Object.entries(definition.properties)
-        .sort(([left], [right]) => compare(left, right))
+        .sort(([left], [right]) => compareCodeUnits(left, right))
         .map(([name, property]) => {
         const prepared = prepare(property.schema, `${pointer}/properties/${name}/schema`);
         const ordering = classifyPreparedOrdering(prepared);
@@ -68,7 +69,7 @@ function compileEntry(schema, lookup) {
             value: add(value.mode === 'value' ? value.schema : value.item, pointer),
         };
     const classes = Object.values(schema.classes)
-        .sort((left, right) => compare(left.ref.name, right.ref.name))
+        .sort((left, right) => compareCodeUnits(left.ref.name, right.ref.name))
         .map((definition) => {
         const pointer = `/classes/${definition.ref.name}`;
         if (definition.kind === 'edge') {
@@ -77,7 +78,7 @@ function compileEntry(schema, lookup) {
         }
         const { properties: _, methods: __, ...rest } = definition;
         const methods = Object.entries(definition.methods)
-            .sort(([left], [right]) => compare(left, right))
+            .sort(([left], [right]) => compareCodeUnits(left, right))
             .map(([name, method]) => {
             const input = add(method.input, `${pointer}/methods/${name}/input`);
             const fields = inputFieldNodes(values[input]);
@@ -89,6 +90,7 @@ function compileEntry(schema, lookup) {
                 static: method.static,
                 abstract: method.abstract,
                 ...(method.execution === undefined ? {} : { execution: method.execution }),
+                ...(method.admission === undefined ? {} : { admission: method.admission }),
                 input,
                 ...(fields === undefined ? {} : { fields }),
                 output: output(method.output, `${pointer}/methods/${name}/output`),
@@ -97,7 +99,7 @@ function compileEntry(schema, lookup) {
         return { ...rest, properties: properties(definition, pointer), methods };
     });
     const functions = Object.values(schema.functions)
-        .sort((left, right) => compare(left.ref.name, right.ref.name))
+        .sort((left, right) => compareCodeUnits(left.ref.name, right.ref.name))
         .map((definition) => {
         const binary = isBinaryInput(definition.input);
         const inputIndex = add(binary ? definition.input.metadata : definition.input, binary
@@ -117,6 +119,7 @@ function compileEntry(schema, lookup) {
             ...(definition.policy === undefined ? {} : { policy: definition.policy }),
             ...(definition.description === undefined ? {} : { description: definition.description }),
             ...(definition.execution === undefined ? {} : { execution: definition.execution }),
+            ...(definition.admission === undefined ? {} : { admission: definition.admission }),
             input,
             ...(fields === undefined ? {} : { fields }),
             output: output(definition.output, `/functions/${definition.ref.name}/output`),
@@ -140,6 +143,3 @@ function compileEntry(schema, lookup) {
         patterns: Object.freeze([...patternIndices.keys()]),
     });
 }
-function compare(left, right) {
-    return left < right ? -1 : left > right ? 1 : 0;
-}

package/dist/v1/compiled/diagnostic.js

@@ -1,9 +1,8 @@
+import { formatDiagnostics } from '../language/validation/diagnostic.js';
 export class CompiledSchemaError extends Error {
     diagnostics;
     constructor(diagnostics, options) {
-        super(diagnostics
-            .map(({ code, pointer, message }) => `${pointer || '/'} [${code}] ${message}`)
-            .join('\n'), options);
+        super(formatDiagnostics(diagnostics), options);
         this.name = 'CompiledSchemaError';
         this.diagnostics = Object.freeze([...diagnostics]);
     }

package/dist/v1/compiled/loader/load.d.ts

@@ -1,9 +1,10 @@
+import type { Domain } from '../../domain/model/domain.js';
 import type { CompiledSchema, DomainOfCompiled } from '../model/schema.js';
 /** Load admitted compiled data through the one resolved Domain constructor. */
 export declare function load<const Input extends CompiledSchema>(input: Input): DomainOfCompiled<Input>;
-export declare function load(input: unknown): import('../../domain/model/domain.js').Domain;
+export declare function load(input: unknown): Domain;
 /**
  * Realize compiled material whose exact embedded bytes were already proven by generated build code.
  * External bytes and caller-provided values must continue through {@link load}.
  */
-export declare function realize(compiled: CompiledSchema): import('../../domain/model/domain.js').Domain;
+export declare function realize(compiled: CompiledSchema): Domain;