@astrale-os/kernel-dsl 0.2.0-beta.3 → 0.2.0-beta.31

package/dist/v1/language/state/index.js

@@ -0,0 +1 @@
+export { stateMachine } from './machine.js';

package/dist/v1/language/state/machine.d.ts

@@ -0,0 +1,28 @@
+import { type ZodType } from 'zod';
+import type { EventName, StateName, StateTopology, TransitionRelation, ValidTransitionRelation } from './topology.js';
+export interface StateMachine<Transitions extends TransitionRelation = any, Initial extends StateName<Transitions> = StateName<Transitions>> extends StateTopology<Transitions, Initial> {
+    readonly stateSchema: ZodType<StateName<Transitions>, StateName<Transitions>>;
+    readonly eventSchema: ZodType<EventName<Transitions>, EventName<Transitions>>;
+    eventsFrom<State extends StateName<Transitions>>(state: State): readonly EventName<Transitions, State>[];
+    decide<State extends StateName<Transitions>, Event extends EventName<Transitions>>(state: State, event: Event): TransitionDecision<Transitions, State, Event>;
+}
+export type StateOf<Machine extends StateMachine> = StateName<Machine['transitions']>;
+export type EventOf<Machine extends StateMachine, State extends StateOf<Machine> = StateOf<Machine>> = EventName<Machine['transitions'], State>;
+type TransitionDecision<Transitions extends TransitionRelation, State extends StateName<Transitions>, Event extends EventName<Transitions>> = State extends StateName<Transitions> ? Event extends EventName<Transitions> ? Event extends keyof Transitions[State] ? Readonly<{
+    kind: 'allowed';
+    transition: Readonly<{
+        from: State;
+        event: Event;
+        to: Transitions[State][Event];
+    }>;
+}> : Readonly<{
+    kind: 'rejected';
+    code: 'STATE_TRANSITION_ILLEGAL';
+    from: State;
+    event: Event;
+}> : never : never;
+export declare function stateMachine<const Transitions extends TransitionRelation, const Initial extends StateName<Transitions>>(input: Readonly<{
+    initial: Initial;
+    transitions: Transitions & ValidTransitionRelation<Transitions>;
+}>): StateMachine<Transitions, Initial>;
+export {};

package/dist/v1/language/state/machine.js

@@ -0,0 +1,40 @@
+import { enum as enumeration } from 'zod';
+import { compareUnicode } from '../../addressing/ordering.js';
+import { admitStateTopology } from './topology.js';
+export function stateMachine(input) {
+    const topology = admitStateTopology(input);
+    const states = Object.keys(topology.transitions);
+    const events = [
+        ...new Set(states.flatMap((state) => Object.keys(topology.transitions[state]))),
+    ].sort(compareUnicode);
+    const stateSet = new Set(states);
+    const eventSet = new Set(events);
+    return Object.freeze({
+        ...topology,
+        stateSchema: enumeration(states),
+        eventSchema: enumeration(events),
+        eventsFrom(state) {
+            admitState(state, stateSet);
+            return Object.freeze(Object.keys(topology.transitions[state]));
+        },
+        decide(state, event) {
+            admitState(state, stateSet);
+            admitEvent(event, eventSet);
+            const target = topology.transitions[state][event];
+            return target === undefined
+                ? Object.freeze({ kind: 'rejected', code: 'STATE_TRANSITION_ILLEGAL', from: state, event })
+                : Object.freeze({
+                    kind: 'allowed',
+                    transition: Object.freeze({ from: state, event, to: target }),
+                });
+        },
+    });
+}
+function admitState(state, states) {
+    if (!states.has(state))
+        throw new TypeError(`State machine does not declare state "${state}".`);
+}
+function admitEvent(event, events) {
+    if (!events.has(event))
+        throw new TypeError(`State machine does not declare event "${event}".`);
+}

package/dist/v1/language/state/topology.d.ts

@@ -0,0 +1,14 @@
+export type TransitionRelation = Readonly<Record<string, Readonly<Record<string, string>>>>;
+export type StateName<Transitions extends TransitionRelation> = Extract<keyof Transitions, string>;
+export type EventName<Transitions extends TransitionRelation, State extends StateName<Transitions> = StateName<Transitions>> = State extends StateName<Transitions> ? Extract<keyof Transitions[State], string> : never;
+export type ValidTransitionRelation<Transitions extends TransitionRelation> = Readonly<{
+    [State in StateName<Transitions>]: Readonly<{
+        [Event in keyof Transitions[State]]: string extends StateName<Transitions> ? string : Exclude<StateName<Transitions>, State>;
+    }>;
+}>;
+export interface StateTopology<Transitions extends TransitionRelation = TransitionRelation, Initial extends StateName<Transitions> = StateName<Transitions>> {
+    readonly initial: Initial;
+    readonly transitions: Transitions;
+}
+export type StateTopologyOf<Value> = Value extends StateTopology<infer Transitions, infer Initial> ? StateTopology<Transitions, Initial> : undefined;
+export declare function admitStateTopology(input: unknown): StateTopology;

package/dist/v1/language/state/topology.js

@@ -0,0 +1,69 @@
+import { compareUnicode } from '../../addressing/ordering.js';
+export function admitStateTopology(input) {
+    if (!isRecord(input) || !exactKeys(input, ['initial', 'transitions']))
+        invalidInput();
+    const initial = input.initial;
+    const authored = input.transitions;
+    if (typeof initial !== 'string' || initial.length === 0 || !isRecord(authored))
+        invalidInput();
+    const states = Object.keys(authored);
+    if (states.length === 0)
+        throw new TypeError('State topology requires at least one state.');
+    if (states.includes(''))
+        throw new TypeError('State topology has an empty state name.');
+    if (!states.includes(initial)) {
+        throw new TypeError(`State topology initial state "${initial}" is not declared.`);
+    }
+    const declared = new Set(states);
+    const transitions = Object.create(null);
+    let transitionCount = 0;
+    for (const state of states.sort(compareUnicode)) {
+        const outgoing = authored[state];
+        if (!isRecord(outgoing))
+            throw new TypeError(`State "${state}" transitions must be an object.`);
+        const accepted = Object.create(null);
+        for (const event of Object.keys(outgoing).sort(compareUnicode)) {
+            const target = outgoing[event];
+            if (event.length === 0)
+                throw new TypeError(`State "${state}" has an empty event name.`);
+            if (typeof target !== 'string' || !declared.has(target)) {
+                throw new TypeError(`State "${state}" event "${event}" targets undeclared state "${String(target)}".`);
+            }
+            if (target === state) {
+                throw new TypeError(`State "${state}" event "${event}" is a self-transition.`);
+            }
+            accepted[event] = target;
+            transitionCount += 1;
+        }
+        transitions[state] = Object.freeze(accepted);
+    }
+    if (transitionCount === 0)
+        throw new TypeError('State topology requires at least one transition.');
+    const reachable = new Set([initial]);
+    const pending = [initial];
+    while (pending.length > 0) {
+        const state = pending.shift();
+        for (const target of Object.values(transitions[state])) {
+            if (reachable.has(target))
+                continue;
+            reachable.add(target);
+            pending.push(target);
+        }
+    }
+    for (const state of states) {
+        if (!reachable.has(state)) {
+            throw new TypeError(`State "${state}" is unreachable from initial "${initial}".`);
+        }
+    }
+    return Object.freeze({ initial, transitions: Object.freeze(transitions) });
+}
+function invalidInput() {
+    throw new TypeError('State topology must contain exactly initial and transitions.');
+}
+function isRecord(input) {
+    return input !== null && typeof input === 'object' && !Array.isArray(input);
+}
+function exactKeys(input, expected) {
+    const keys = Reflect.ownKeys(input);
+    return keys.length === expected.length && keys.every((key) => expected.includes(String(key)));
+}

package/dist/v1/language/validation/diagnostic.d.ts

@@ -0,0 +1,8 @@
+export type DiagnosticCode = 'CALLABLE_INPUT_FIELD_UNKNOWN' | 'DOMAIN_CLASS_ABSTRACT' | 'DOMAIN_PROPERTY_INPUT_INVALID' | 'DOMAIN_PROPERTY_REQUIRED' | 'DOMAIN_PROPERTY_UNKNOWN' | 'DOMAIN_VALIDATION_TARGET_UNKNOWN' | 'VALUE_SCHEMA_INSTANCE_INVALID' | 'VS_DIALECT' | 'VS_DYNAMIC_FORBIDDEN' | 'VS_KEYWORD_CLOSED' | 'VS_META_SCHEMA' | 'VS_NUMBER_DOMAIN' | 'VS_PATH_EXTENSION' | 'VS_RECURSION_PRODUCTIVE' | 'VS_REFERENCE_FORM' | 'VS_REFERENCE_RESOLUTION' | 'VS_REGEX_PORTABLE' | 'VS_RESOURCE_ID' | 'VS_VALUE_KIND';
+export interface Diagnostic<out Code extends DiagnosticCode = DiagnosticCode> {
+    readonly code: Code;
+    readonly pointer: string;
+    readonly message: string;
+    readonly ref?: string;
+}
+export declare function diagnostic<const Code extends DiagnosticCode>(code: Code, pointer: string, message: string, ref?: string): Diagnostic<Code>;

package/dist/v1/language/validation/diagnostic.js

@@ -0,0 +1,3 @@
+export function diagnostic(code, pointer, message, ref) {
+    return Object.freeze({ code, pointer, message, ...(ref === undefined ? {} : { ref }) });
+}

package/dist/v1/language/value/compile/fields.d.ts

@@ -0,0 +1,3 @@
+import type { ValueProgram } from './model.js';
+/** Exact field constraints available for independent scalar route validation. */
+export declare function inputFieldNodes(program: ValueProgram): Readonly<Record<string, readonly number[]>> | undefined;

package/dist/v1/language/value/compile/fields.js

@@ -0,0 +1,60 @@
+/** Exact field constraints available for independent scalar route validation. */
+export function inputFieldNodes(program) {
+    const fields = new Map();
+    const visited = new Set();
+    let closed = false;
+    let unsupported = false;
+    const visit = (index) => {
+        if (visited.has(index))
+            return;
+        visited.add(index);
+        const node = program.nodes[index];
+        if (node === undefined ||
+            node.schema === null ||
+            typeof node.schema !== 'object' ||
+            Array.isArray(node.schema))
+            return;
+        const schema = node.schema;
+        if (schema.additionalProperties === false || schema.unevaluatedProperties === false)
+            closed = true;
+        if (schema.anyOf !== undefined || schema.oneOf !== undefined || schema.if !== undefined)
+            unsupported = true;
+        if (node.reference !== undefined)
+            visit(node.reference);
+        if (Array.isArray(schema.allOf)) {
+            schema.allOf.forEach((_, position) => {
+                const child = node.children[`allOf/${position}`];
+                if (child === undefined)
+                    throw new TypeError('Compiled input allOf branch is absent.');
+                visit(child);
+            });
+        }
+        if (schema.properties === null ||
+            typeof schema.properties !== 'object' ||
+            Array.isArray(schema.properties))
+            return;
+        for (const name of Object.keys(schema.properties)) {
+            const child = node.children[`properties/${escapePointer(name)}`];
+            if (child === undefined)
+                throw new TypeError(`Compiled input field ${name} is absent.`);
+            const constraints = fields.get(name) ?? new Set();
+            constraints.add(child);
+            fields.set(name, constraints);
+        }
+    };
+    visit(program.root);
+    if (!closed || unsupported)
+        return undefined;
+    return Object.freeze(Object.fromEntries([...fields]
+        .sort(([left], [right]) => compare(left, right))
+        .map(([name, nodes]) => [
+        name,
+        Object.freeze([...nodes].sort((left, right) => left - right)),
+    ])));
+}
+function escapePointer(value) {
+    return value.replaceAll('~', '~0').replaceAll('/', '~1');
+}
+function compare(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}

package/dist/v1/{schema/compiled/program.d.ts → language/value/compile/load.d.ts}

@@ -1,5 +1,4 @@
-import type { CompiledInstanceSchema } from '../value/instance/types.js';
+import type { CompiledInstanceSchema } from '../evaluate/types.js';
 import type { ValueProgram } from './model.js';
 /** Bind admitted portable indices to the canonical instance evaluator. */
 export declare function loadValueProgram(program: ValueProgram): CompiledInstanceSchema;
-//# sourceMappingURL=program.d.ts.map

package/dist/v1/{schema/compiled/program.js → language/value/compile/load.js}

@@ -1,5 +1,5 @@
-import { appendPointer } from '../value/location/pointer.js';
-import { loadPattern } from '../value/regexp/matcher.js';
+import { loadPattern } from '../regexp/matcher.js';
+import { appendPointer } from '../syntax/pointer.js';
 /** Bind admitted portable indices to the canonical instance evaluator. */
 export function loadValueProgram(program) {
     const resource = { key: 'compiled', schema: true, ownerOrigin: 'compiled' };
@@ -39,4 +39,3 @@ export function loadValueProgram(program) {
         },
     };
 }
-//# sourceMappingURL=program.js.map

package/dist/v1/language/value/compile/model.d.ts

@@ -0,0 +1,27 @@
+import type { Value as JsonValue } from '@astrale-os/kernel-dsl/value';
+export type ScalarRange = readonly [minimum: number, maximum: number];
+export interface PatternTransition {
+    readonly to: number;
+    readonly ranges: readonly ScalarRange[];
+}
+export interface PatternState {
+    readonly epsilon: readonly number[];
+    readonly transitions: readonly PatternTransition[];
+    readonly accepting?: true;
+}
+export interface Pattern {
+    readonly source: string;
+    readonly start: number;
+    readonly states: readonly PatternState[];
+}
+export interface ValueNode {
+    readonly schema: JsonValue;
+    readonly children: Readonly<Record<string, number>>;
+    readonly reference?: number;
+}
+/** Portable, JSON-safe evaluation program for one admitted ValueSchema. */
+export interface ValueProgram {
+    readonly root: number;
+    readonly nodes: readonly ValueNode[];
+    readonly patterns: readonly Pattern[];
+}

package/dist/v1/language/value/compile/model.js

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

package/dist/v1/{schema/value/instance → language/value/evaluate}/assertions.d.ts

@@ -4,4 +4,3 @@ export declare function jsonEqual(left: JsonValue, right: JsonValue): boolean;
 export declare function unique(values: readonly JsonValue[]): boolean;
 /** Compare finite JSON numbers as their exact ECMAScript decimal spellings. */
 export declare function isMultipleOf(value: number, divisor: number): boolean;
-//# sourceMappingURL=assertions.d.ts.map

package/dist/v1/{schema/value/instance → language/value/evaluate}/assertions.js

@@ -1,5 +1,5 @@
 import { equal, json } from '@astrale-os/kernel-dsl/value';
-import { isValueObject as isJsonObject } from '../object.js';
+import { isValueObject as isJsonObject } from '../model/object.js';
 export function matchesType(input, value) {
     switch (input) {
         case 'null':
@@ -56,4 +56,3 @@ function decimalInteger(input) {
 function powerOfTen(exponent) {
     return 10n ** BigInt(exponent);
 }
-//# sourceMappingURL=assertions.js.map

package/dist/v1/{schema/value/instance → language/value/evaluate}/evaluator.d.ts

@@ -2,4 +2,3 @@ import type { Value as JsonValue } from '@astrale-os/kernel-dsl/value';
 import type { CompiledInstanceSchema, Evaluation } from './types.js';
 /** Evaluate complete Draft 2020-12 acceptance without dynamic source generation. */
 export declare function evaluateInstance(compiled: CompiledInstanceSchema, input: JsonValue): Evaluation;
-//# sourceMappingURL=evaluator.d.ts.map

package/dist/v1/{schema/value/instance → language/value/evaluate}/evaluator.js

@@ -1,6 +1,6 @@
-import { isInstantValue } from '../instant.js';
-import { appendPointer } from '../location/pointer.js';
-import { isValueObject as isJsonObject } from '../object.js';
+import { isInstantValue } from '../model/instant.js';
+import { isValueObject as isJsonObject } from '../model/object.js';
+import { appendPointer } from '../syntax/pointer.js';
 import { isMultipleOf, jsonEqual, matchesType, unique } from './assertions.js';
 import { evaluation, mergeAnnotations } from './types.js';
 /** Evaluate complete Draft 2020-12 acceptance without dynamic source generation. */
@@ -359,4 +359,3 @@ function isSchema(input) {
 function invalid(instancePointer, keyword, message) {
     return { instancePointer, keyword, message };
 }
-//# sourceMappingURL=evaluator.js.map

package/dist/v1/{schema/value/instance → language/value/evaluate}/preparation.d.ts

@@ -1,5 +1,5 @@
-import type { ValueSchemaRegistry } from '../registry.js';
-import type { JsonSchema } from '../schema.js';
+import type { JsonSchema } from '../model/schema.js';
+import type { ValueSchemaRegistry } from '../reference/registry.js';
 import type { CompiledInstanceSchema } from './types.js';
 export type InstanceSchemaCompilation = {
     readonly compiled: true;
@@ -11,4 +11,3 @@ export type InstanceSchemaCompilation = {
 /** Prepare reference and linear-regexp state without generating executable source. */
 export declare function prepareValueSchema(schema: JsonSchema, registry: ValueSchemaRegistry, pointer: string): InstanceSchemaCompilation;
 export declare function childKey(pointer: string): string;
-//# sourceMappingURL=preparation.d.ts.map

package/dist/v1/{schema/value/instance → language/value/evaluate}/preparation.js

@@ -1,17 +1,16 @@
-import { appendPointer } from '../location/pointer.js';
-import { walkSchema } from '../location/walk.js';
-import { isValueObject as isJsonObject } from '../object.js';
+import { isValueObject as isJsonObject } from '../model/object.js';
+import { collectResourceClosure, locationKey, } from '../reference/closure.js';
+import { indexRegistry } from '../reference/registry.index.js';
 import { compilePattern } from '../regexp/compile.js';
 import { loadPattern } from '../regexp/matcher.js';
-import { collectResourceClosure, locationKey, } from '../resources/closure.js';
-import { indexRegistry, inferNamedTypePlacement } from '../resources/registry.index.js';
+import { appendPointer } from '../syntax/pointer.js';
+import { walkSchema } from '../syntax/walk.js';
 /** Prepare reference and linear-regexp state without generating executable source. */
 export function prepareValueSchema(schema, registry, pointer) {
     const indexed = indexRegistry(registry, pointer);
     if (indexed.diagnostics.length > 0)
         return failed(indexed.diagnostics);
-    const namedType = inferNamedTypePlacement(schema, indexed.index, pointer);
-    const closure = collectResourceClosure(schema, namedType === undefined ? 'callable-input' : 'named-type', indexed.index, pointer, namedType);
+    const closure = collectResourceClosure(schema, 'callable-input', indexed.index, pointer);
     if (closure.diagnostics.length > 0)
         return failed(closure.diagnostics);
     const locations = new Map();
@@ -134,4 +133,3 @@ function failed(diagnostics) {
         message: diagnostics.map(({ code, message }) => `${code}: ${message}`).join('; '),
     };
 }
-//# sourceMappingURL=preparation.js.map

package/dist/v1/language/value/evaluate/program.d.ts

@@ -0,0 +1,3 @@
+import type { Diagnostic } from '../../validation/diagnostic.js';
+import type { ValueProgram } from '../compile/model.js';
+export declare function validateValueProgram(program: ValueProgram, input: unknown, roots?: readonly number[]): readonly Diagnostic[];

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

@@ -0,0 +1,16 @@
+import { loadValueProgram } from '../compile/load.js';
+import { validateCanonicalJsonDomain } from '../profile/json.validate.js';
+import { evaluateInstance } from './evaluator.js';
+export function validateValueProgram(program, input, roots = [program.root]) {
+    const canonical = validateCanonicalJsonDomain(input, '');
+    if (canonical.length > 0)
+        return canonical;
+    return roots.flatMap((root) => {
+        const result = evaluateInstance(loadValueProgram({ ...program, root }), input);
+        return result.failures.map((failure) => ({
+            code: 'VALUE_SCHEMA_INSTANCE_INVALID',
+            pointer: failure.instancePointer,
+            message: `Value does not satisfy its complete V1 schema at ${failure.keyword}: ${failure.message}`,
+        }));
+    });
+}

package/dist/v1/{schema/value/instance → language/value/evaluate}/types.d.ts

@@ -1,8 +1,8 @@
 import type { Value as JsonValue } from '@astrale-os/kernel-dsl/value';
-import type { ValueProgram } from '../../compiled/model.js';
+import type { ValueProgram } from '../compile/model.js';
+import type { JsonSchema } from '../model/schema.js';
+import type { ResolvedAddressReference, SchemaResource } from '../reference/references.js';
 import type { IRegexpMatcher } from '../regexp/matcher.js';
-import type { ResolvedSchemaReference, SchemaResource } from '../resources/references.js';
-import type { JsonSchema } from '../schema.js';
 export interface InstanceFailure {
     readonly instancePointer: string;
     readonly keyword: string;
@@ -17,7 +17,7 @@ export interface SchemaLocation {
 export interface CompiledInstanceSchema {
     readonly root: SchemaLocation;
     readonly locations: ReadonlyMap<string, SchemaLocation>;
-    readonly resolutions: ReadonlyMap<string, ResolvedSchemaReference>;
+    readonly resolutions: ReadonlyMap<string, ResolvedAddressReference>;
     program(): ValueProgram;
     child(location: SchemaLocation, keyword: string, member?: string | number): SchemaLocation;
     reference(location: SchemaLocation): SchemaLocation | undefined;
@@ -34,4 +34,3 @@ export interface Evaluation {
 export type Instance = JsonValue;
 export declare function evaluation(failures?: readonly InstanceFailure[], properties?: ReadonlySet<string>, items?: ReadonlySet<number>): Evaluation;
 export declare function mergeAnnotations(targetProperties: Set<string>, targetItems: Set<number>, source: Pick<Evaluation, 'properties' | 'items'>): void;
-//# sourceMappingURL=types.d.ts.map

package/dist/v1/{schema/value/instance → language/value/evaluate}/types.js

@@ -7,4 +7,3 @@ export function mergeAnnotations(targetProperties, targetItems, source) {
     for (const item of source.items)
         targetItems.add(item);
 }
-//# sourceMappingURL=types.js.map

package/dist/v1/{schema/value/instance.validate.d.ts → language/value/evaluate/validate.d.ts}

@@ -1,7 +1,7 @@
 import type { Value as JsonValue } from '@astrale-os/kernel-dsl/value';
-import type { DomainDiagnostic } from '../diagnostic.js';
-import type { ValueSchemaRegistry } from './registry.js';
-import type { JsonSchema } from './schema.js';
+import type { Diagnostic } from '../../validation/diagnostic.js';
+import type { JsonSchema } from '../model/schema.js';
+import type { ValueSchemaRegistry } from '../reference/registry.js';
 /**
  * Validate one complete portable value with the admitted V1 Draft 2020-12 profile.
  *
@@ -9,5 +9,4 @@ import type { JsonSchema } from './schema.js';
  * resolution or dynamic source generation, and every admitted I-Regexp executes through RE2JS.
  * `format` remains annotation-only; the graph NodePath codec performs its separate locator check.
  */
-export declare function validateJsonInstance(schema: JsonSchema, value: JsonValue, registry: ValueSchemaRegistry, pointer?: string): DomainDiagnostic[];
-//# sourceMappingURL=instance.validate.d.ts.map
+export declare function validateJsonInstance(schema: JsonSchema, value: JsonValue, registry: ValueSchemaRegistry, pointer?: string): Diagnostic[];

package/dist/v1/{schema/value/instance.validate.js → language/value/evaluate/validate.js}

@@ -1,7 +1,7 @@
-import { diagnostic } from '../diagnostic.js';
-import { evaluateInstance } from './instance/evaluator.js';
-import { prepareValueSchema } from './instance/preparation.js';
-import { validateCanonicalJsonDomain } from './profile/json.validate.js';
+import { diagnostic } from '../../validation/diagnostic.js';
+import { validateCanonicalJsonDomain } from '../profile/json.validate.js';
+import { evaluateInstance } from './evaluator.js';
+import { prepareValueSchema } from './preparation.js';
 const validatorCache = new WeakMap();
 /**
  * Validate one complete portable value with the admitted V1 Draft 2020-12 profile.
@@ -41,4 +41,3 @@ function preparedInstanceValidator(schema, registry, pointer) {
     bySchema.set(schema, prepared);
     return prepared;
 }
-//# sourceMappingURL=instance.validate.js.map

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

@@ -0,0 +1,11 @@
+/** Complete V1 inline value language. Named Type Definitions do not exist. */
+export type { JsonSchema as ValueSchema, JsonSchemaObject as ValueSchemaObject, PathAnnotation, PropertyObjectSchema, ValueSchemaContext, } from './model/schema.js';
+export { JSON_SCHEMA_DIALECT, VALUE_SCHEMA_DIALECT, VALUE_SCHEMA_VOCABULARY, } from './model/schema.js';
+export { instant, isInstantValue } from './model/instant.js';
+export { classifyOrdering, type OrderingKind } from './ordering.js';
+export { canonicalizeValueSchema } from './profile/canonicalize.js';
+export { validateValueSchema } from './profile/validate.js';
+export { validateJsonInstance } from './evaluate/validate.js';
+export { prepareValueSchema, type InstanceSchemaCompilation } from './evaluate/preparation.js';
+export type { ValueProgram } from './compile/model.js';
+export type { ValueSchemaRegistry, ValueSchemaDomainRegistry } from './reference/registry.js';

package/dist/v1/language/value/index.js

@@ -0,0 +1,8 @@
+/** Complete V1 inline value language. Named Type Definitions do not exist. */
+export { JSON_SCHEMA_DIALECT, VALUE_SCHEMA_DIALECT, VALUE_SCHEMA_VOCABULARY, } from './model/schema.js';
+export { instant, isInstantValue } from './model/instant.js';
+export { classifyOrdering } from './ordering.js';
+export { canonicalizeValueSchema } from './profile/canonicalize.js';
+export { validateValueSchema } from './profile/validate.js';
+export { validateJsonInstance } from './evaluate/validate.js';
+export { prepareValueSchema } from './evaluate/preparation.js';

package/dist/v1/{schema/value → language/value/model}/instant.d.ts

@@ -1,4 +1,5 @@
 /** Exact portable UTC millisecond Instant used by the V1 value-schema dialect. */
+/** Canonical value-language annotation for an Instant string. */
 export declare const INSTANT_VALUE_KIND: 'instant';
 export declare const instant: Readonly<{
     readonly type: 'string';
@@ -6,4 +7,3 @@ export declare const instant: Readonly<{
 }>;
 /** Test the exact proleptic-Gregorian V1 Instant lexical and calendar domain. */
 export declare function isInstantValue(input: unknown): input is string;
-//# sourceMappingURL=instant.d.ts.map

package/dist/v1/{schema/value → language/value/model}/instant.js

@@ -1,4 +1,5 @@
 /** Exact portable UTC millisecond Instant used by the V1 value-schema dialect. */
+/** Canonical value-language annotation for an Instant string. */
 export const INSTANT_VALUE_KIND = 'instant';
 export const instant = Object.freeze({
     type: 'string',
@@ -34,4 +35,3 @@ function daysInMonth(year, month) {
 function isLeapYear(year) {
     return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
 }
-//# sourceMappingURL=instant.js.map

package/dist/v1/{schema/value → language/value/model}/object.d.ts

@@ -1,5 +1,5 @@
 import type { Object as ValueObject, Value } from '@astrale-os/kernel-dsl/value';
 /** Internal shape refinement for values that have already crossed portable-value admission. */
+/** Return whether an unknown value is a portable JSON object. */
 export declare function isValueObject(value: unknown): value is ValueObject;
 export declare function isValueObject(value: Value): value is ValueObject;
-//# sourceMappingURL=object.d.ts.map

package/dist/v1/{schema/value → language/value/model}/object.js

@@ -1,4 +1,3 @@
 export function isValueObject(value) {
     return value !== null && typeof value === 'object' && !Array.isArray(value);
 }
-//# sourceMappingURL=object.js.map

package/dist/v1/{schema/value → language/value/model}/schema.d.ts

@@ -1,5 +1,5 @@
 import type { Object as JsonObject, Value as JsonValue } from '@astrale-os/kernel-dsl/value';
-import type { DefinitionRef } from '../reference.js';
+import type { ClassRef } from '../../../addressing/index.js';
 /** Standard dialect on which the Astrale value-schema dialect is based. */
 export declare const JSON_SCHEMA_DIALECT: 'https://json-schema.org/draft/2020-12/schema';
 /** Required V1 dialect for every embedded Astrale value schema. */
@@ -19,8 +19,7 @@ export interface PropertyObjectSchema extends JsonSchemaObject {
 export interface PathAnnotation {
     readonly target: 'node';
     readonly cardinality: 'one';
-    readonly accepts: readonly DefinitionRef[];
+    readonly accepts: readonly ClassRef[];
 }
-export declare const VALUE_SCHEMA_CONTEXTS: readonly ['named-type', 'property-facet', 'callable-input', 'callable-output'];
+export declare const VALUE_SCHEMA_CONTEXTS: readonly ['property-facet', 'callable-input', 'callable-output'];
 export type ValueSchemaContext = (typeof VALUE_SCHEMA_CONTEXTS)[number];
-//# sourceMappingURL=schema.d.ts.map

package/dist/v1/{schema/value → language/value/model}/schema.js

@@ -5,9 +5,7 @@ export const VALUE_SCHEMA_DIALECT = 'https://schemas.astrale.ai/dsl/v1/value-sch
 /** Required vocabulary carried by the V1 value-schema dialect. */
 export const VALUE_SCHEMA_VOCABULARY = 'https://schemas.astrale.ai/dsl/v1/value-schema/vocabulary';
 export const VALUE_SCHEMA_CONTEXTS = [
-    'named-type',
     'property-facet',
     'callable-input',
     'callable-output',
 ];
-//# sourceMappingURL=schema.js.map

package/dist/v1/{schema → language}/value/ordering.d.ts

@@ -1,5 +1,6 @@
-import type { ValueSchemaRegistry } from './registry.js';
-import type { JsonSchema } from './schema.js';
+import type { ValueProgram } from './compile/model.js';
+import type { JsonSchema } from './model/schema.js';
+import type { ValueSchemaRegistry } from './reference/registry.js';
 export type OrderingKind = 'boolean' | 'number' | 'string' | 'instant';
 /**
  * Classify a schema only when every value it can admit belongs to one sortable scalar domain.
@@ -8,4 +9,5 @@ export type OrderingKind = 'boolean' | 'number' | 'string' | 'instant';
  * instead of guessing from annotations, examples, formats, or current data.
  */
 export declare function classifyOrdering(contract: JsonSchema, registry: ValueSchemaRegistry): OrderingKind | undefined;
-//# sourceMappingURL=ordering.d.ts.map
+/** Recompute the scalar ordering classification from one admitted portable value program. */
+export declare function classifyValueProgramOrdering(program: ValueProgram): OrderingKind | undefined;