@astrale-os/kernel-dsl 1.0.0-beta.12 → 1.0.0-beta.14

package/dist/v1/addressing/definition-ref.js

@@ -8,55 +8,39 @@ const DEFINITION_KINDS = new Set([
 ]);
 /** Admit and detach one canonical DefinitionRef from an untrusted value. */
 export function acceptDefinitionRef(input) {
-    if (input === null || typeof input !== 'object' || Array.isArray(input)) {
-        invalid(input);
-    }
+    return readDefinitionRef(input) ?? invalid(input);
+}
+/** Identify a canonical DefinitionRef-shaped value without retaining caller state. */
+export function isDefinitionRef(input) {
+    return readDefinitionRef(input) !== undefined;
+}
+/** Compare exact Definition coordinates, independent of object identity. */
+export function equalDefinitionRefs(left, right) {
+    return left.origin === right.origin && left.kind === right.kind && left.name === right.name;
+}
+function invalid(input) {
+    throw new TypeError(`Invalid DefinitionRef: ${JSON.stringify(input)}.`);
+}
+/** A detached copy of the canonical DefinitionRef `input` holds, reading each field once. */
+function readDefinitionRef(input) {
+    if (input === null || typeof input !== 'object' || Array.isArray(input))
+        return undefined;
     const value = input;
     const keys = Reflect.ownKeys(value);
     if (keys.length !== 3 ||
         !keys.every((key) => key === 'origin' || key === 'kind' || key === 'name')) {
-        invalid(input);
+        return undefined;
     }
-    const origin = value.origin;
-    const kind = value.kind;
-    const name = value.name;
+    const { origin, kind, name } = value;
     if (typeof origin !== 'string' ||
         !DOMAIN_ORIGIN_PATTERN.test(origin) ||
         typeof kind !== 'string' ||
         !DEFINITION_KINDS.has(kind) ||
         typeof name !== 'string' ||
         !definitionNameMatches(kind, name)) {
-        invalid(input);
+        return undefined;
     }
-    return Object.freeze({
-        origin,
-        kind: kind,
-        name,
-    });
-}
-/** Identify a canonical DefinitionRef-shaped value without retaining caller state. */
-export function isDefinitionRef(input) {
-    if (input === null || typeof input !== 'object' || Array.isArray(input))
-        return false;
-    const value = input;
-    const keys = Reflect.ownKeys(value);
-    if (keys.length !== 3 ||
-        !keys.every((key) => key === 'origin' || key === 'kind' || key === 'name')) {
-        return false;
-    }
-    return (typeof value.origin === 'string' &&
-        DOMAIN_ORIGIN_PATTERN.test(value.origin) &&
-        typeof value.kind === 'string' &&
-        DEFINITION_KINDS.has(value.kind) &&
-        typeof value.name === 'string' &&
-        definitionNameMatches(value.kind, value.name));
-}
-/** Compare exact Definition coordinates, independent of object identity. */
-export function equalDefinitionRefs(left, right) {
-    return left.origin === right.origin && left.kind === right.kind && left.name === right.name;
-}
-function invalid(input) {
-    throw new TypeError(`Invalid DefinitionRef: ${JSON.stringify(input)}.`);
+    return Object.freeze({ origin, kind: kind, name });
 }
 function definitionNameMatches(kind, name) {
     return kind === 'core' ? CORE_SLUG_PATTERN.test(name) : MEMBER_NAME_PATTERN.test(name);

package/dist/v1/addressing/key.js

@@ -1,7 +1,8 @@
 import { acceptDefinitionRef, } from './definition-ref.js';
 import { DOMAIN_ORIGIN_PATTERN } from './patterns.js';
 const DEFINITION_KEY = /^(?:class|function|policy|view)\.([A-Za-z][A-Za-z0-9_]*)$/u;
-const CORE_KEY = /^core\.([a-z][a-z0-9-]{0,99})$/u;
+// The slug is the whole rest of the coordinate, its own `.` included: no member follows a Core key.
+const CORE_KEY = /^core\.((?=.{1,100}$)[a-z][a-z0-9-]*(?:\.[a-z][a-z0-9-]*)*)$/u;
 const MEMBER_KEY = /^class\.([A-Za-z][A-Za-z0-9_]*)\.(property|method)\.([A-Za-z][A-Za-z0-9_]*)$/u;
 /** The keys of frozen Definition coordinates, derived once each. */
 const derived = new WeakMap();

package/dist/v1/addressing/ordering.d.ts

@@ -4,3 +4,5 @@ export declare function definitionRefIndex(ref: DefinitionRef): string;
 export declare function compareDefinitionRefs(left: DefinitionRef, right: DefinitionRef): number;
 /** Locale-independent Unicode code-point ordering for canonical DSL values. */
 export declare function compareUnicode(left: string, right: string): number;
+/** Order strings by UTF-16 code unit, the order `<` gives strings. */
+export declare function compareCodeUnits(left: string, right: string): number;

package/dist/v1/addressing/ordering.js

@@ -18,3 +18,7 @@ export function compareUnicode(left, right) {
     }
     return a.length - b.length;
 }
+/** Order strings by UTF-16 code unit, the order `<` gives strings. */
+export function compareCodeUnits(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}

package/dist/v1/addressing/patterns.d.ts

@@ -3,6 +3,7 @@ export type DomainOrigin = string;
 export declare const DOMAIN_ORIGIN_PATTERN: RegExp;
 export declare const MEMBER_NAME_PATTERN: RegExp;
 export declare const DEPENDENCY_ALIAS_PATTERN: RegExp;
+/** Labels of `[a-z][a-z0-9-]*` joined by `.`, 100 code points at most: `graph.reader`. */
 export declare const CORE_SLUG_PATTERN: RegExp;
 export declare const DOMAIN_REVISION_PATTERN: RegExp;
 export declare const PROPERTY_KEY_PATTERN: RegExp;
@@ -19,4 +20,3 @@ export declare const patterns: Readonly<{
     revision: RegExp;
     revisionFullMatch: "sha256:[0-9a-f]{64}";
 }>;
-export declare function assertMemberName(name: string): void;

package/dist/v1/addressing/patterns.js

@@ -1,7 +1,8 @@
 export const DOMAIN_ORIGIN_PATTERN = /^(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/u;
 export const MEMBER_NAME_PATTERN = /^[A-Za-z][A-Za-z0-9_]*$/u;
 export const DEPENDENCY_ALIAS_PATTERN = /^[a-z][A-Za-z0-9]*$/u;
-export const CORE_SLUG_PATTERN = /^[a-z][a-z0-9-]{0,99}$/u;
+/** Labels of `[a-z][a-z0-9-]*` joined by `.`, 100 code points at most: `graph.reader`. */
+export const CORE_SLUG_PATTERN = /^(?=.{1,100}$)[a-z][a-z0-9-]*(?:\.[a-z][a-z0-9-]*)*$/u;
 export const DOMAIN_REVISION_PATTERN = /^sha256:[0-9a-f]{64}$/u;
 const DOMAIN_REVISION_FULL_MATCH = 'sha256:[0-9a-f]{64}';
 const DOMAIN_ORIGIN_FULL_MATCH = '([a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?\\.)+[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?';
@@ -22,8 +23,3 @@ export const patterns = Object.freeze({
     revision: DOMAIN_REVISION_PATTERN,
     revisionFullMatch: DOMAIN_REVISION_FULL_MATCH,
 });
-export function assertMemberName(name) {
-    if (!MEMBER_NAME_PATTERN.test(name)) {
-        throw new TypeError(`Invalid member name: ${JSON.stringify(name)}.`);
-    }
-}

package/dist/v1/builder/class/authoring.js

@@ -59,7 +59,7 @@ export const edgeClass = Object.freeze({
         validateDirectedSourceInput(input.source);
         validateDirectedTargetInput(input.target);
         const { source, target, unique, ...options } = input;
-        validateEdgeClassOptions(options);
+        validateEdgeClassOptions(options, ['noSelf', 'acyclic']);
         const value = authoringValue('definition', {
             kind: 'edge',
             orientation: 'directed',
@@ -94,7 +94,7 @@ export const edgeClass = Object.freeze({
         validateIncidentEndpointInput(input.endpoints[0]);
         validateIncidentEndpointInput(input.endpoints[1]);
         const { endpoints, ...options } = input;
-        validateUndirectedEdgeClassOptions(options);
+        validateEdgeClassOptions(options, ['noSelf']);
         const value = authoringValue('definition', {
             kind: 'edge',
             orientation: 'undirected',
@@ -122,33 +122,10 @@ function validateDirectedTargetInput(value) {
 function validateIncidentEndpointInput(value) {
     assertKnownKeys(value, ['as', 'accepts', 'incident', 'onDelete']);
 }
-function validateEdgeClassOptions(value) {
-    assertKnownKeys(value, [
-        'abstract',
-        'inheritance',
-        'description',
-        'extends',
-        'properties',
-        'policies',
-        'constraints',
-    ]);
-    if (value.policies !== undefined)
-        assertKnownKeys(value.policies, ['read', 'traverse']);
-    if (value.constraints !== undefined)
-        assertKnownKeys(value.constraints, ['noSelf', 'acyclic']);
-}
-function validateUndirectedEdgeClassOptions(value) {
-    assertKnownKeys(value, [
-        'abstract',
-        'inheritance',
-        'description',
-        'extends',
-        'properties',
-        'policies',
-        'constraints',
-    ]);
+/** Check the nested Edge Class options; the caller has checked the option keys themselves. */
+function validateEdgeClassOptions(value, constraints) {
     if (value.policies !== undefined)
         assertKnownKeys(value.policies, ['read', 'traverse']);
     if (value.constraints !== undefined)
-        assertKnownKeys(value.constraints, ['noSelf']);
+        assertKnownKeys(value.constraints, constraints);
 }

package/dist/v1/builder/class/property.d.ts

@@ -1,5 +1,5 @@
 import type { z } from 'zod';
-import type { AutoEvent, AutoSet, PropertyImmutability } from '../../language/class/model/property.js';
+import type { AutoEvent, AutoSet, PropertyAuto, PropertyImmutability } from '../../language/class/model/property.js';
 import type { StateMachine } from '../../language/state/index.js';
 import type { JsonSchema } from '../../language/value/model/schema.js';
 import type { AUTHORING } from '../schema/handle.js';
@@ -31,10 +31,7 @@ export interface AutoProperty<out PropertyValue extends Property = Property> {
     readonly [AUTHORING]: 'auto';
     readonly [AUTO_INPUT]: {
         readonly property: PropertyValue;
-        readonly options: {
-            readonly on: readonly AutoEvent[];
-            readonly set: AutoSet;
-        };
+        readonly options: PropertyAuto;
     };
 }
 type PropertyAuthoringInput<Value extends Property> = Value extends Property<infer Schema, infer Options, infer Machine> ? {
@@ -45,10 +42,7 @@ type PropertyAuthoringInput<Value extends Property> = Value extends Property<inf
 export declare function propertyAuthoringInput<const Value extends Property>(value: Value): PropertyAuthoringInput<Value>;
 export declare function autoPropertyAuthoringInput<const Value extends AutoProperty>(value: Value): Value extends AutoProperty<infer Property> ? {
     readonly property: Property;
-    readonly options: {
-        readonly on: readonly AutoEvent[];
-        readonly set: AutoSet;
-    };
+    readonly options: PropertyAuto;
 } : never;
 export type PropertyFieldInput = ValueSchemaInput | Property | AutoProperty;
 export type PropertyRecordInput = Readonly<Record<string, PropertyFieldInput>>;

package/dist/v1/builder/class/property.js

@@ -59,6 +59,7 @@ export function auto(property, options) {
     return authoringValue('auto', {
         [AUTO_INPUT]: {
             property,
+            // `events` holds at least the one authored event.
             options: { on: Object.freeze(events), set: options.set },
         },
     });

package/dist/v1/builder/lowering/class.js

@@ -48,6 +48,7 @@ export class V1DefinitionCompiler {
     }
     edgeClass(value, name, pointer) {
         const input = classConfiguration(value);
+        // The authoring types give an Edge no State Property; the structure refuses an erased one.
         const facet = this.values.properties(input.properties, `${pointer}/properties`);
         const contract = (() => {
             if (value.orientation === 'directed') {
@@ -63,7 +64,9 @@ export class V1DefinitionCompiler {
                     // against the Class's effective Properties, once every Class is lowered.
                     ...(directed.unique === undefined
                         ? {}
-                        : { unique: directed.unique }),
+                        : {
+                            unique: directed.unique,
+                        }),
                 };
             }
             const undirected = classConfiguration(value);
@@ -135,6 +138,7 @@ export class V1DefinitionCompiler {
     endpointBase(value, pointer) {
         return {
             role: value.as,
+            // An empty list stays as authored: the structure refuses it when it judges the candidate.
             accepts: value.accepts
                 .map((entry, index) => this.context.resolveNodeClass(entry, `${pointer}/accepts/${index}`))
                 .sort(compareDefinitionRefs),

package/dist/v1/builder/lowering/policy.js

@@ -14,6 +14,7 @@ export class V1PolicyCompiler {
         const input = policyDeclaration(value);
         const ref = { origin: this.context.origin, kind: 'policy', name };
         if ('operator' in input) {
+            // One ref for each Policy of a non-empty composition.
             const refs = input.policies.map((policy, index) => this.context.resolvePolicy(policy, `${pointer}/${input.operator}/${index}`));
             return {
                 ref,

package/dist/v1/builder/lowering/schema/context.js

@@ -4,6 +4,7 @@ import { isMethodExecutable } from '../../../language/callable/executable.js';
 import { admitsForeignSubclass, inheritanceOf } from '../../../language/class/inheritance.js';
 import { policyObjectKey, policyObjectOrigin } from '../../../language/index.js';
 import { graphNodePathSchema } from '../../../language/value/syntax/node-path/schema.js';
+import { escapePointerToken } from '../../../language/value/syntax/pointer.js';
 import { revisionOfDomainSchema } from '../../../schema/canonical/revision.js';
 import { requireDomainClosure } from '../../../schema/resolution/closure.js';
 import { collectUsedForeignOrigins } from '../../../schema/resolution/origins.js';
@@ -23,7 +24,7 @@ export class BuilderContext {
     constructor(origin, dependencies) {
         this.origin = origin;
         for (const [alias, schema] of Object.entries(dependencies)) {
-            const pointer = `/dependencies/${escapePointer(alias)}`;
+            const pointer = `/dependencies/${escapePointerToken(alias)}`;
             if (!DEPENDENCY_ALIAS_PATTERN.test(alias)) {
                 fail('BUILDER_DEPENDENCY_ALIAS', pointer, `Dependency alias ${JSON.stringify(alias)} must be an ASCII lower-camel identifier.`);
             }
@@ -223,9 +224,6 @@ export class BuilderContext {
         this.policyObjectRefs.add(policyObjectKey(ref));
     }
 }
-function escapePointer(value) {
-    return value.replaceAll('~', '~0').replaceAll('/', '~1');
-}
 function isResolvedClass(value) {
     if (typeof value !== 'object' || value === null)
         return false;

package/dist/v1/builder/lowering/value/path.js

@@ -1,9 +1,10 @@
+import { escapePointerToken } from '../../../language/value/syntax/pointer.js';
 import { pathAccepts } from '../../value/path-metadata.js';
 export function lowerPathSchema(context, resolveAccepts, pointer) {
     const inputs = pathAccepts(context.zodSchema);
     if (inputs === undefined)
         return;
-    const location = context.path.reduce((current, segment) => `${current}/${escapeToken(String(segment))}`, pointer);
+    const location = context.path.reduce((current, segment) => `${current}/${escapePointerToken(String(segment))}`, pointer);
     for (const key of Object.keys(context.jsonSchema))
         delete context.jsonSchema[key];
     Object.assign(context.jsonSchema, {
@@ -15,6 +16,3 @@ export function lowerPathSchema(context, resolveAccepts, pointer) {
         },
     });
 }
-function escapeToken(value) {
-    return value.replaceAll('~', '~0').replaceAll('/', '~1');
-}

package/dist/v1/builder/lowering/value/zod.js

@@ -4,6 +4,7 @@ import { canonicalizeValueSchema } from '../../../language/value/profile/canonic
 import { validateValueSchema } from '../../../language/value/profile/validate.js';
 import { isIRegexp } from '../../../language/value/regexp/syntax.js';
 import { fullMatchSource } from '../../../language/value/syntax/full-match.js';
+import { escapePointerToken } from '../../../language/value/syntax/pointer.js';
 import { diagnostic } from '../../schema/diagnostic.js';
 /**
  * Converts only Zod contracts whose JSON-value acceptance is represented
@@ -289,9 +290,6 @@ function getCheckDefinition(value) {
 function isZodType(value) {
     return value instanceof ZodType;
 }
-function escapePointerToken(value) {
-    return value.replaceAll('~', '~0').replaceAll('/', '~1');
-}
 function isPlainRecord(value) {
     return value !== null && typeof value === 'object' && !Array.isArray(value);
 }

package/dist/v1/builder/policy/authoring.js

@@ -86,10 +86,11 @@ export function createPatternContext(options) {
             });
             Object.freeze(node);
             const where = build({ node });
-            if (nodes.length === 0) {
+            const [first, ...rest] = nodes;
+            if (first === undefined) {
                 fail('BUILDER_POLICY_EMPTY_EXISTS', `${options.pointer}/match/exists/nodes`, 'exists(...) must declare at least one variable Node.');
             }
-            return { exists: { nodes, where } };
+            return { exists: { nodes: [first, ...rest], where } };
         },
         allOf(...expressions) {
             nonEmpty(expressions, `${options.pointer}/match/allOf`);

package/dist/v1/builder/schema/define.d.ts

@@ -2,7 +2,6 @@ import type { Domain } from '../../domain/model/domain.js';
 import type { DomainSchema } from '../../schema/model/schema.js';
 import type { DomainSchemaInput, EntrypointOf } from './input.js';
 import type { ResolvedDomainOfInput } from './projection.js';
-export type { DomainSchemaInput } from './input.js';
 /** Exact named Schema produced from one authored input. */
 export interface DefinedSchema<Origin extends string, Resolved extends Domain> extends DomainSchema<Origin, Resolved> {
 }

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

@@ -1,4 +1,6 @@
 import type { DiagnosticCode as LanguageDiagnosticCode } from '../../language/validation/diagnostic.js';
+import { escapePointerToken as escapeToken } from '../../language/value/syntax/pointer.js';
+export { escapeToken };
 export type BuilderDiagnosticCode = LanguageDiagnosticCode | 'BUILDER_ABSTRACT_POLICY' | 'BUILDER_AMBIGUOUS_OWNERSHIP' | 'BUILDER_AUTO_EVENT_INVALID' | 'BUILDER_AUTO_IMMUTABLE' | 'BUILDER_AUTO_NESTED' | 'BUILDER_AUTO_SET_INVALID' | 'BUILDER_CALLABLE_AUTH' | 'BUILDER_CALLABLE_PLACEMENT' | 'BUILDER_CALLABLE_POLICY_AUTH' | 'BUILDER_CLASS_INHERITANCE' | 'BUILDER_CORE_CLASS' | 'BUILDER_CORE_EDGE' | 'BUILDER_CORE_NODE' | 'BUILDER_CORE_PROPERTY' | 'BUILDER_CORE_REF' | 'BUILDER_DEFINITION' | 'BUILDER_DEPENDENCY_CONFLICT' | 'BUILDER_DEPENDENCY_ALIAS' | 'BUILDER_DEPENDENCY_DIRECT' | 'BUILDER_DUPLICATE_MEMBER' | 'BUILDER_EDGE_LIFETIME' | 'BUILDER_FOREIGN_POLICY' | 'BUILDER_FULL_MATCH_INVALID' | 'BUILDER_FUNCTION' | 'BUILDER_METHOD' | 'BUILDER_PATH_DUPLICATE' | 'BUILDER_PATH_EMPTY' | 'BUILDER_POLICY' | 'BUILDER_POLICY_COMPOSITION' | 'BUILDER_POLICY_CYCLE' | 'BUILDER_POLICY_EMPTY_COMPOSITION' | 'BUILDER_POLICY_EMPTY_EXISTS' | 'BUILDER_POLICY_INPUT' | 'BUILDER_POLICY_REF' | 'BUILDER_POLICY_SELF' | 'BUILDER_PROPERTY_IMMUTABLE_INVALID' | 'BUILDER_REFERENCE_CYCLE' | 'BUILDER_REFERENCE_KIND' | 'BUILDER_REFERENCE_MISSING' | 'BUILDER_UNIQUE_PROPERTY' | 'BUILDER_UNKNOWN_FIELD' | 'BUILDER_UNOWNED_REFERENCE' | 'BUILDER_VIEW' | 'ZOD_SCHEMA_NOT_LOSSLESS';
 export interface BuilderDiagnostic<out Code extends BuilderDiagnosticCode = BuilderDiagnosticCode> {
     readonly code: Code;
@@ -13,4 +15,3 @@ export declare class BuilderError extends Error {
 }
 export declare function assertKnownKeys(value: object, allowed: readonly string[], pointer?: string): void;
 export declare function fail(code: BuilderDiagnosticCode, pointer: string, message: string): never;
-export declare function escapeToken(value: string): string;

package/dist/v1/builder/schema/diagnostic.js

@@ -1,16 +1,14 @@
-import { compareUnicode } from '../../addressing/ordering.js';
+import { formatDiagnostics, orderDiagnostics } from '../../language/validation/diagnostic.js';
+import { escapePointerToken as escapeToken } from '../../language/value/syntax/pointer.js';
+export { escapeToken };
 export function diagnostic(code, pointer, message, ref) {
     return Object.freeze({ code, pointer, message, ...(ref === undefined ? {} : { ref }) });
 }
 export class BuilderError extends Error {
     diagnostics;
     constructor(diagnostics) {
-        const ordered = [...diagnostics].sort((left, right) => compareUnicode(left.pointer, right.pointer) ||
-            compareUnicode(left.code, right.code) ||
-            compareUnicode(left.message, right.message));
-        super(ordered
-            .map(({ code, pointer, message }) => `${pointer || '/'} [${code}] ${message}`)
-            .join('\n'));
+        const ordered = orderDiagnostics(diagnostics);
+        super(formatDiagnostics(ordered));
         this.name = 'BuilderError';
         this.diagnostics = Object.freeze(ordered);
     }
@@ -26,6 +24,3 @@ export function assertKnownKeys(value, allowed, pointer = '') {
 export function fail(code, pointer, message) {
     throw new BuilderError([diagnostic(code, pointer, message)]);
 }
-export function escapeToken(value) {
-    return value.replaceAll('~', '~0').replaceAll('/', '~1');
-}

package/dist/v1/builder/schema/projection.d.ts

@@ -1,4 +1,4 @@
-export type { PropertyProjection, MethodProjection, FunctionProjection, ClassProjection, DomainProjection, } from './projection/model.js';
+export type { PropertyProjection, MethodProjection, FunctionProjection, ClassProjection, } from './projection/model.js';
 export type { ResolvedDomainOfInput } from './projection/domain.js';
 export type { CoreNamedPropertyInput, CorePropertyInput } from './projection/core-input.js';
 export type { ClassProjectionOfResolved } from './projection/resolved-class.js';

package/dist/v1/builder/value/full-match.d.ts

@@ -1,4 +1,3 @@
 import { type FullMatch } from '../../language/value/syntax/full-match.js';
-export { fullMatchSource, type FullMatch } from '../../language/value/syntax/full-match.js';
 /** Authoring facade preserving the Builder-owned diagnostic for invalid source syntax. */
 export declare function fullMatch(source: string): FullMatch;

package/dist/v1/builder/value/full-match.js

@@ -1,7 +1,6 @@
 import { refuseIRegexp, stateBudgetMessage } from '../../language/value/regexp/syntax.js';
 import { fullMatch as languageFullMatch, } from '../../language/value/syntax/full-match.js';
 import { fail } from '../schema/diagnostic.js';
-export { fullMatchSource } from '../../language/value/syntax/full-match.js';
 /** Authoring facade preserving the Builder-owned diagnostic for invalid source syntax. */
 export function fullMatch(source) {
     const refusal = refuseIRegexp(source);

package/dist/v1/bundle/codec.js

@@ -1,17 +1,15 @@
 import { accept as acceptJsonValue, BoundaryError as JsonBoundaryError, json, } from '@astrale-os/kernel-dsl/value';
 import { dependencyLimits } from '../addressing/domain-dependency.js';
 import { compareUnicode } from '../addressing/ordering.js';
+import { escapePointerToken } from '../language/value/syntax/pointer.js';
 import { acceptDomainSchema } from '../schema/admission/accept.js';
 import { canonicalDomainSchemaAfterValidation } from '../schema/canonical/revision.js';
 import { revisionOfDomainSchema } from '../schema/canonical/revision.js';
 import { MemoryDomainSchemaLookup } from '../schema/dependency/lookup.js';
 import { SchemaError } from '../schema/diagnostic.js';
-import { BundleError, diagnostic } from './diagnostic.js';
+import { BundleError, diagnostic, schemaDiagnosticAt } from './diagnostic.js';
 import { asDomainSchemaBundle, } from './model.js';
 import { parseDomainSchemaBundleStructure } from './structure.js';
-function escapeToken(value) {
-    return value.replaceAll('~', '~0').replaceAll('/', '~1');
-}
 export function acceptDomainSchemaBundle(input) {
     let admitted;
     try {
@@ -101,7 +99,7 @@ function acceptBundleValue(input) {
         catch (error) {
             if (!(error instanceof SchemaError))
                 throw error;
-            throw new BundleError(error.diagnostics.map((item) => diagnostic(item.code, `${entry.pointer}${item.pointer}`, item.message, item.ref)));
+            throw new BundleError(error.diagnostics.map((item) => schemaDiagnosticAt(entry.pointer, item)));
         }
     };
     for (const entry of candidates.values()) {
@@ -136,7 +134,7 @@ function collectReachable(current, root, candidates, reachable, active, revision
         return;
     }
     for (const [alias, dependency] of Object.entries(current.schema.dependencies)) {
-        const pointer = `${current.pointer}/dependencies/${escapeToken(alias)}`;
+        const pointer = `${current.pointer}/dependencies/${escapePointerToken(alias)}`;
         const dependencyKey = keyOf(dependency.origin, dependency.revision);
         if (dependencyKey === root.key) {
             diagnostics.push(diagnostic('BUNDLE_CLOSURE_CYCLE', pointer, 'Bundle dependency closure returns to its root.'));

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

@@ -4,6 +4,8 @@ export type BundleDiagnostic<Code extends BundleDiagnosticCode = BundleDiagnosti
     readonly code: Code;
 };
 export declare function diagnostic<const Code extends BundleDiagnosticCode>(code: Code, pointer: string, message: string, ref?: string): BundleDiagnostic<Code>;
+/** A refusal of one bundled schema, its pointer rebased under the schema's place in the bundle. */
+export declare function schemaDiagnosticAt(pointer: string, refusal: SchemaDiagnostic): BundleDiagnostic;
 export declare class BundleError extends Error {
     readonly diagnostics: readonly BundleDiagnostic[];
     constructor(diagnostics: readonly BundleDiagnostic[]);

package/dist/v1/bundle/diagnostic.js

@@ -1,16 +1,18 @@
-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 refusal of one bundled schema, its pointer rebased under the schema's place in the bundle. */
+export function schemaDiagnosticAt(pointer, refusal) {
+    // Acceptance refuses a document with Schema codes only, never with comparison request codes.
+    const code = refusal.code;
+    return Object.freeze({ ...refusal, code, pointer: `${pointer}${refusal.pointer}` });
+}
 export class BundleError extends Error {
     diagnostics;
     constructor(diagnostics) {
-        const ordered = [...diagnostics].sort((left, right) => compareUnicode(left.pointer, right.pointer) ||
-            compareUnicode(left.code, right.code) ||
-            compareUnicode(left.message, right.message));
-        super(ordered
-            .map(({ code, pointer, message }) => `${pointer || '/'} [${code}] ${message}`)
-            .join('\n'));
+        const ordered = orderDiagnostics(diagnostics);
+        super(formatDiagnostics(ordered));
         this.name = 'BundleError';
         this.diagnostics = Object.freeze(ordered);
     }

package/dist/v1/bundle/structure.js

@@ -1,6 +1,7 @@
+import { escapePointerToken } from '../language/value/syntax/pointer.js';
 import { SchemaError } from '../schema/diagnostic.js';
 import { routeDomainSchema } from '../schema/validation/domain.route.js';
-import { BundleError, diagnostic } from './diagnostic.js';
+import { BundleError, diagnostic, schemaDiagnosticAt } from './diagnostic.js';
 import { DOMAIN_BUNDLE_FORMAT, DOMAIN_BUNDLE_VERSION } from './model.js';
 export function parseDomainSchemaBundleStructure(input) {
     if (!isObject(input)) {
@@ -12,7 +13,7 @@ export function parseDomainSchemaBundleStructure(input) {
     const expected = new Set(['format', 'version', 'root', 'closure']);
     for (const key of Object.keys(input)) {
         if (!expected.has(key)) {
-            diagnostics.push(diagnostic('BUNDLE_STRUCTURE', `/${escapeToken(key)}`, `Unknown bundle field ${key}.`));
+            diagnostics.push(diagnostic('BUNDLE_STRUCTURE', `/${escapePointerToken(key)}`, `Unknown bundle field ${key}.`));
         }
     }
     for (const key of expected) {
@@ -56,7 +57,7 @@ function routeAt(value, pointer, diagnostics) {
     catch (error) {
         if (!(error instanceof SchemaError))
             throw error;
-        diagnostics.push(...error.diagnostics.map((entry) => diagnostic(entry.code, `${pointer}${entry.pointer}`, entry.message, entry.ref)));
+        diagnostics.push(...error.diagnostics.map((entry) => schemaDiagnosticAt(pointer, entry)));
         return undefined;
     }
 }
@@ -66,6 +67,3 @@ function isObject(value) {
 function describe(value) {
     return value === undefined ? '(missing)' : JSON.stringify(value);
 }
-function escapeToken(value) {
-    return value.replaceAll('~', '~0').replaceAll('/', '~1');
-}

package/dist/v1/compiled/admission/diagnostic.d.ts

@@ -1,6 +1,6 @@
 import { type CompiledDiagnosticCode } from '../diagnostic.js';
 /** Append one escaped JSON Pointer segment. */
-export declare function pointer(parent: string, member: string | number): string;
+export { appendPointer as pointer } from '../../language/value/syntax/pointer.js';
 /** Report a structural compiled-input violation with its stable diagnostic code. */
 export declare function invalid(label: string, code?: CompiledDiagnosticCode, path?: string): never;
 /** Report a contextual compiled-language violation at its original source pointer. */

package/dist/v1/compiled/admission/diagnostic.js

@@ -1,8 +1,6 @@
 import { invalidCompiled } from '../diagnostic.js';
 /** Append one escaped JSON Pointer segment. */
-export function pointer(parent, member) {
-    return `${parent}/${String(member).replaceAll('~', '~0').replaceAll('/', '~1')}`;
-}
+export { appendPointer as pointer } from '../../language/value/syntax/pointer.js';
 /** Report a structural compiled-input violation with its stable diagnostic code. */
 export function invalid(label, code = 'COMPILED_STRUCTURE_INVALID', path = '') {
     return invalidCompiled(code, `Invalid compiled Schema ${label}.`, path);

package/dist/v1/compiled/admission/revision.d.ts

@@ -1,4 +1,12 @@
 import type { Revision } from '../../addressing/index.js';
-import type { CompiledSchemaEntry } from '../model/schema.js';
+import type { FunctionDefinition, MethodDefinition } from '../../language/callable/model/callable.js';
+import type { JsonSchema } from '../../language/value/model/schema.js';
+import type { CompiledFunction, CompiledMethod, CompiledSchemaEntry } from '../model/schema.js';
 /** Derive the exact canonical source-revision preimage without constructing an authored Schema. */
 export declare function revisionOfCompiledEntry(entry: CompiledSchemaEntry): Revision;
+/** The source definition of a compiled Method: its value programs back to their schemas. */
+export declare function sourceMethod(entry: CompiledSchemaEntry, method: CompiledMethod): MethodDefinition;
+/** The source definition of a compiled Function: its value programs back to their schemas. */
+export declare function sourceFunction(entry: CompiledSchemaEntry, definition: CompiledFunction): FunctionDefinition;
+/** The schema of the root node of the entry's value program `index`. */
+export declare function schemaOf(entry: CompiledSchemaEntry, index: number): JsonSchema;

package/dist/v1/compiled/admission/revision.js

@@ -44,7 +44,8 @@ function sourceClass(entry, definition) {
         methods: Object.fromEntries(methods.map((method) => [method.name, sourceMethod(entry, method)])),
     };
 }
-function sourceMethod(entry, method) {
+/** The source definition of a compiled Method: its value programs back to their schemas. */
+export function sourceMethod(entry, method) {
     const { name: _, input, fields: __, output, ...rest } = method;
     return {
         ...rest,
@@ -52,7 +53,8 @@ function sourceMethod(entry, method) {
         output: sourceOutput(entry, output),
     };
 }
-function sourceFunction(entry, definition) {
+/** The source definition of a compiled Function: its value programs back to their schemas. */
+export function sourceFunction(entry, definition) {
     const { input, fields: _, output, ...rest } = definition;
     return {
         ...rest,
@@ -72,7 +74,8 @@ function sourceOutput(entry, output) {
     const schema = schemaOf(entry, output.value);
     return output.mode === 'value' ? { mode: 'value', schema } : { mode: 'stream', item: schema };
 }
-function schemaOf(entry, index) {
+/** The schema of the root node of the entry's value program `index`. */
+export function schemaOf(entry, index) {
     const program = entry.values[index];
     const root = program?.nodes[program.root];
     if (root === undefined)

package/dist/v1/compiled/admission/semantics/class.d.ts

@@ -1,5 +1,8 @@
 import { type Located, type CompiledClass, type ClassAnalysis, type SemanticIndex } from './context.js';
-/** Compose inherited Properties, Methods and Data ownership once per Class. */
+/**
+ * Compose inherited Properties, Methods and Data ownership once per Class. The closure check has
+ * already proved every parent present and the inheritance graph acyclic.
+ */
 export declare function analyzeClasses(classes: ReadonlyMap<string, Located<CompiledClass>>): ReadonlyMap<string, ClassAnalysis>;
 /** Check automatic Properties, immutability and abstract Class obligations. */
 export declare function validateClassFacets(context: SemanticIndex): void;