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

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

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

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

@@ -0,0 +1,20 @@
+import type { ClassRef, CoreRef, DefinitionBase } from '../../../addressing/index.js';
+import type { PropertyValues } from '../../class/property-values.js';
+export interface DomainEndpointRef {
+    readonly kind: 'domain';
+}
+export type CoreEndpointRef = CoreRef | DomainEndpointRef;
+export interface CoreDefinition extends DefinitionBase<CoreRef> {
+    readonly class: ClassRef;
+    readonly properties: PropertyValues;
+}
+export interface CoreEdge {
+    readonly class: ClassRef;
+    readonly source: CoreEndpointRef;
+    readonly target: CoreEndpointRef;
+    readonly properties: PropertyValues;
+}
+export interface CoreContent {
+    readonly nodes: Readonly<Record<string, CoreDefinition>>;
+    readonly edges: readonly CoreEdge[];
+}

package/dist/v1/language/core/model/core.js

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

package/dist/v1/language/core/resolved.d.ts

@@ -0,0 +1,21 @@
+import type { DefinitionKey } from '../../addressing/index.js';
+import type { PropertyValues } from '../class/property-values.js';
+import type { ResolvedClass } from '../class/resolved.js';
+import type { CoreDefinition } from './model/core.js';
+export interface ResolvedCoreDefinition {
+    readonly ref: CoreDefinition['ref'];
+    readonly key: DefinitionKey<string, 'core'>;
+    readonly class: ResolvedClass<'node'>;
+    readonly properties: PropertyValues;
+    readonly definition: CoreDefinition;
+}
+export interface ResolvedDomainEndpoint {
+    readonly kind: 'domain';
+    readonly origin: string;
+}
+export interface ResolvedCoreEdge {
+    readonly class: ResolvedClass<'edge'>;
+    readonly source: ResolvedCoreDefinition | ResolvedDomainEndpoint;
+    readonly target: ResolvedCoreDefinition | ResolvedDomainEndpoint;
+    readonly properties: PropertyValues;
+}

package/dist/v1/language/core/resolved.js

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

package/dist/v1/{schema → language/definition}/metadata.d.ts

@@ -10,4 +10,3 @@ export declare const icon: Readonly<{
     readonly minLength: 1;
     readonly maxLength: 8000;
 }>;
-//# sourceMappingURL=metadata.d.ts.map

package/dist/v1/{schema → language/definition}/metadata.js

@@ -10,4 +10,3 @@ export const icon = Object.freeze({
     minLength: 1,
     maxLength: 8000,
 });
-//# sourceMappingURL=metadata.js.map

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

@@ -0,0 +1,7 @@
+import type { FunctionDefinition } from './callable/model/callable.js';
+import type { ClassDefinition } from './class/model/class.js';
+import type { CoreDefinition } from './core/model/core.js';
+import type { PolicyDefinition } from './policy/model/policy.js';
+import type { ViewDefinition } from './view/model/view.js';
+/** Every named V1 product Definition. Property and Method remain Class-owned members. */
+export type Definition = ClassDefinition | FunctionDefinition | PolicyDefinition | ViewDefinition | CoreDefinition;

package/dist/v1/language/definition.js

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

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

@@ -0,0 +1,25 @@
+export type { ClassRef, CoreRef, DefinitionBase, DefinitionKey, DefinitionRef, FunctionRef, MethodKey, PolicyRef, PropertyKey, ViewRef, } from '../addressing/index.js';
+export type { Value as PropertyValue } from '@astrale-os/kernel-dsl/value';
+export type { JsonSchema as ValueSchema, JsonSchemaObject as ValueSchemaObject, } from './value/model/schema.js';
+export type { OrderingKind } from './value/ordering.js';
+export { stateMachine } from './state/index.js';
+export type { EventOf, StateMachine, StateOf, StateTopology } from './state/index.js';
+export type * from './callable/model/callable.js';
+export type * from './callable/resolved.js';
+export type * from './class/model/class.js';
+export type { DataDefinition, DataFacet, MediaType } from './class/model/data.js';
+export type * from './class/model/edge.js';
+export type * from './class/model/property.js';
+export type * from './class/resolved.js';
+export type * from './class/facets.js';
+export { PropertyValues } from './class/property-values.js';
+export type { PropertyValuesOperations } from './class/property-values.js';
+export type * from './core/model/core.js';
+export type * from './core/resolved.js';
+export type { Definition } from './definition.js';
+export type { ResolvedDefinition, ResolvedDefinitionOf } from './resolved.js';
+export type { Diagnostic, DiagnosticCode } from './validation/diagnostic.js';
+export type * from './policy/model/policy.js';
+export type * from './policy/resolved.js';
+export type * from './view/model/view.js';
+export type * from './view/resolved.js';

package/dist/v1/language/index.js

@@ -0,0 +1,2 @@
+export { stateMachine } from './state/index.js';
+export { PropertyValues } from './class/property-values.js';

package/dist/v1/{schema/policy/validation → language/policy/analysis}/branches.d.ts

@@ -1,5 +1,5 @@
-import type { ClassRef } from '../../reference.js';
-import type { PolicyEdgePattern, PolicyPatternExpression, PolicyPatternTerm } from '../ast.js';
+import type { ClassRef } from '../../../addressing/index.js';
+import type { PolicyEdgePattern, PolicyPatternExpression, PolicyPatternTerm } from '../model/policy.js';
 export interface PatternBranch {
     readonly edges: readonly PatternEdgeUse[];
     readonly variables: ReadonlyMap<string, ClassRef>;
@@ -15,7 +15,5 @@ export declare function branchesOf(pattern: PolicyPatternExpression, namespace:
 export declare function branchProduct(children: readonly (readonly PatternBranch[])[]): readonly PatternBranch[];
 export declare function capBranches(values: readonly PatternBranch[]): readonly PatternBranch[];
 export declare function isConnected(branch: PatternBranch): boolean;
-/** A normalized branch targets either one object or both authored Edge endpoints, never a mixture. */
 export declare function targetMode(branch: PatternBranch): PolicyTargetMode | undefined;
 export declare function termKey(term: PolicyPatternTerm, namespace: string): string;
-//# sourceMappingURL=branches.d.ts.map

package/dist/v1/{schema/policy/validation → language/policy/analysis}/branches.js

@@ -25,7 +25,14 @@ export function isConnected(branch) {
     const mode = targetMode(branch);
     if (mode === undefined)
         return false;
-    const vertices = new Set(mode === 'object' ? ['subject', 'object'] : ['subject', 'source', 'target']);
+    const vertices = new Set(['subject']);
+    for (const edge of branch.edges) {
+        for (const term of [edge.pattern.source, edge.pattern.target]) {
+            if (term.kind === 'object' || term.kind === 'source' || term.kind === 'target') {
+                vertices.add(term.kind);
+            }
+        }
+    }
     for (const variable of branch.requiredVariables)
         vertices.add(variable);
     const union = new UnionFind(vertices);
@@ -39,7 +46,6 @@ export function isConnected(branch) {
     const root = union.find('subject');
     return [...vertices].every((vertex) => union.find(vertex) === root);
 }
-/** A normalized branch targets either one object or both authored Edge endpoints, never a mixture. */
 export function targetMode(branch) {
     let object = false;
     let source = false;
@@ -53,7 +59,7 @@ export function targetMode(branch) {
     }
     if (object && !source && !target)
         return 'object';
-    if (!object && source && target)
+    if (!object && (source || target))
         return 'edge';
     return undefined;
 }
@@ -61,15 +67,8 @@ export function termKey(term, namespace) {
     return term.kind === 'variable' ? variableKey(namespace, term.id) : term.kind;
 }
 function branchesForNode(pattern, namespace, variables) {
-    if (isEdge(pattern)) {
-        return [
-            {
-                edges: [{ pattern, namespace }],
-                variables,
-                requiredVariables: new Set(),
-                namespace,
-            },
-        ];
+    if ('source' in pattern) {
+        return [{ edges: [{ pattern, namespace }], variables, requiredVariables: new Set(), namespace }];
     }
     if ('exists' in pattern) {
         const direct = new Set(pattern.exists.nodes.map((node) => variableKey(namespace, node.variable.id)));
@@ -78,17 +77,11 @@ function branchesForNode(pattern, namespace, variables) {
             requiredVariables: new Set([...branch.requiredVariables, ...direct]),
         }));
     }
-    const { key, values } = patternOperands(pattern);
-    const children = values.map((child) => branchesForNode(child, namespace, variables));
-    return key === 'allOf' ? branchProduct(children) : capBranches(children.flat());
+    const children = ('allOf' in pattern ? pattern.allOf : pattern.anyOf).map((child) => branchesForNode(child, namespace, variables));
+    return 'allOf' in pattern ? branchProduct(children) : capBranches(children.flat());
 }
 function emptyBranch() {
-    return {
-        edges: [],
-        variables: new Map(),
-        requiredVariables: new Set(),
-        namespace: '$',
-    };
+    return { edges: [], variables: new Map(), requiredVariables: new Set(), namespace: '$' };
 }
 function mergeBranches(left, right) {
     return {
@@ -118,14 +111,6 @@ function collectVariableClasses(pattern, namespace) {
 function variableKey(namespace, id) {
     return `variable:${namespace}:${id}`;
 }
-function patternOperands(value) {
-    return 'allOf' in value
-        ? { key: 'allOf', values: value.allOf }
-        : { key: 'anyOf', values: value.anyOf };
-}
-function isEdge(value) {
-    return 'source' in value;
-}
 class UnionFind {
     #parents = new Map();
     constructor(values) {
@@ -152,4 +137,3 @@ class UnionFind {
             this.#parents.set(b, a);
     }
 }
-//# sourceMappingURL=branches.js.map

package/dist/v1/{schema/policy/validation → language/policy/analysis}/budgets.d.ts

@@ -1,5 +1,4 @@
-import type { PolicyCheckExpression } from '../ast.js';
-import type { PolicyValidationContext } from './context.js';
+import type { PolicyCheckExpression } from '../model/policy.js';
 export declare const MAX_PATTERN_DEPTH = 4;
 export declare const MAX_BRANCHES = 8;
 export declare const MAX_VARIABLES = 4;
@@ -14,6 +13,4 @@ export interface CheckMeasure {
     readonly branches: number;
     readonly leaves: number;
 }
-export declare function validatePolicyBudgets(context: PolicyValidationContext): void;
 export declare function measureChecks(expression: PolicyCheckExpression): CheckMeasure;
-//# sourceMappingURL=budgets.d.ts.map

package/dist/v1/language/policy/analysis/budgets.js

@@ -0,0 +1,25 @@
+export const MAX_PATTERN_DEPTH = 4;
+export const MAX_BRANCHES = 8;
+export const MAX_VARIABLES = 4;
+export const MAX_EDGES = 6;
+export const MAX_REPEAT = 3;
+export const MAX_DOMAINS = 4;
+export const MAX_CHECK_DEPTH = 4;
+export const MAX_CHECK_LEAVES = 8;
+export const BRANCH_OVERFLOW = MAX_BRANCHES + 1;
+export function measureChecks(expression) {
+    if ('check' in expression)
+        return { depth: 1, branches: 1, leaves: 1 };
+    const children = ('allOf' in expression ? expression.allOf : expression.anyOf).map(measureChecks);
+    const branches = 'allOf' in expression
+        ? children.reduce((value, child) => saturatingProduct(value, child.branches), 1)
+        : children.reduce((value, child) => Math.min(BRANCH_OVERFLOW, value + child.branches), 0);
+    return {
+        depth: 1 + Math.max(0, ...children.map((child) => child.depth)),
+        branches,
+        leaves: children.reduce((value, child) => value + child.leaves, 0),
+    };
+}
+function saturatingProduct(left, right) {
+    return Math.min(BRANCH_OVERFLOW, left * right);
+}

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

@@ -0,0 +1,3 @@
+export type * from './model/policy.js';
+export type * from './resolved.js';
+export * from './normalization/normalize.js';

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

@@ -0,0 +1 @@
+export * from './normalization/normalize.js';

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

@@ -1,4 +1,4 @@
-import type { CoreRef, ClassRef, DefinitionRef, FunctionRef, PolicyRef, ViewRef } from '../reference.js';
+import type { CoreRef, ClassRef, FunctionRef, PolicyRef, ViewRef, DefinitionBase } from '../../../addressing/index.js';
 export type PolicyPatternTerm = {
     readonly kind: 'subject';
 } | {
@@ -38,18 +38,19 @@ export type PolicyPatternExpression = PolicyEdgePattern | {
 } | {
     readonly anyOf: readonly PolicyPatternExpression[];
 };
-export type PolicyDeclaration = {
-    readonly description?: string;
+export type PolicyExpression = {
     readonly match: PolicyPatternExpression;
 } | {
-    readonly description?: string;
     readonly allOf: readonly PolicyRef[];
 } | {
-    readonly description?: string;
     readonly anyOf: readonly PolicyRef[];
 };
+export interface PolicyDefinition extends DefinitionBase<PolicyRef> {
+    readonly expression: PolicyExpression;
+    readonly description?: string;
+}
 /** Local Domain members whose installed projection resolves through one exact member Path. */
-export type PolicyObjectRef = DefinitionRef | FunctionRef | PolicyRef | ViewRef | CoreRef;
+export type PolicyObjectRef = ClassRef | FunctionRef | PolicyRef | ViewRef | CoreRef;
 export type PolicyCheckObject = {
     readonly kind: 'self';
 } | {
@@ -74,4 +75,3 @@ export type PolicyCheckExpression<Policy = PolicyRef, Object = PolicyCheckObject
         ...PolicyCheckExpression<Policy, Object>[]
     ];
 };
-//# sourceMappingURL=ast.d.ts.map

package/dist/v1/language/policy/model/policy.js

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

package/dist/v1/language/policy/normalization/normalize.d.ts

@@ -0,0 +1,4 @@
+import type { PolicyCheckExpression, PolicyExpression, PolicyPatternExpression } from '../model/policy.js';
+export declare function normalizePolicyExpression(value: PolicyExpression): PolicyExpression;
+export declare function normalizePolicyPattern(value: PolicyPatternExpression): PolicyPatternExpression;
+export declare function normalizePolicyChecks(value: PolicyCheckExpression): PolicyCheckExpression;

package/dist/v1/{schema/policy → language/policy/normalization}/normalize.js

@@ -1,14 +1,14 @@
 import { json } from '@astrale-os/kernel-dsl/value';
-import { schemaRefIndex, compareSchemaRefs } from '../reference.js';
+import { definitionRefIndex, compareDefinitionRefs } from '../../../addressing/ordering.js';
 const textEncoder = new TextEncoder();
-export function normalizePolicyDeclaration(value) {
+export function normalizePolicyExpression(value) {
     if ('match' in value) {
-        return withDescription(value, { match: normalizePolicyPattern(value.match) });
+        return { match: normalizePolicyPattern(value.match) };
     }
     if ('allOf' in value) {
-        return withDescription(value, { allOf: uniqueRefs(value.allOf) });
+        return { allOf: uniqueRefs(value.allOf) };
     }
-    return withDescription(value, { anyOf: uniqueRefs(value.anyOf) });
+    return { anyOf: uniqueRefs(value.anyOf) };
 }
 export function normalizePolicyPattern(value) {
     const rewritten = rewriteVariables(value, canonicalVariableIds(value));
@@ -101,7 +101,7 @@ function canonicalVariableIds(value) {
 function collectDeclarations(value, result) {
     if ('exists' in value) {
         for (const node of value.exists.nodes) {
-            result.set(node.variable.id, schemaRefIndex(node.class));
+            result.set(node.variable.id, definitionRefIndex(node.class));
         }
         collectDeclarations(value.exists.where, result);
         return;
@@ -116,10 +116,10 @@ function collectDeclarations(value, result) {
 function collectUses(value, target, colors, result) {
     if (isEdge(value)) {
         if (value.source.kind === 'variable' && value.source.id === target) {
-            result.push(`s:${schemaRefIndex(value.class)}:${termColor(value.target, colors)}`);
+            result.push(`s:${definitionRefIndex(value.class)}:${termColor(value.target, colors)}`);
         }
         if (value.target.kind === 'variable' && value.target.id === target) {
-            result.push(`t:${schemaRefIndex(value.class)}:${termColor(value.source, colors)}`);
+            result.push(`t:${definitionRefIndex(value.class)}:${termColor(value.source, colors)}`);
         }
         return;
     }
@@ -141,7 +141,7 @@ function collectFirstUseKeys(value, colors, result, prefix = '$') {
             ['target', value.target],
         ]) {
             if (term.kind === 'variable') {
-                const key = `${prefix}:${schemaRefIndex(value.class)}:${position}`;
+                const key = `${prefix}:${definitionRefIndex(value.class)}:${position}`;
                 const current = result.get(term.id);
                 if (current === undefined || key < current)
                     result.set(term.id, key);
@@ -160,7 +160,7 @@ function collectFirstUseKeys(value, colors, result, prefix = '$') {
 }
 function patternSignature(value, colors) {
     if (isEdge(value)) {
-        return `edge:${schemaRefIndex(value.class)}:${termColor(value.source, colors)}:${termColor(value.target, colors)}:${value.repeat?.min ?? 1}:${value.repeat?.max ?? 1}`;
+        return `edge:${definitionRefIndex(value.class)}:${termColor(value.source, colors)}:${termColor(value.target, colors)}:${value.repeat?.min ?? 1}:${value.repeat?.max ?? 1}`;
     }
     if ('exists' in value) {
         return `exists:${value.exists.nodes
@@ -202,8 +202,8 @@ function rewriteTerm(value, ids) {
     return value.kind === 'variable' ? { kind: 'variable', id: ids.get(value.id) ?? value.id } : value;
 }
 function uniqueRefs(values) {
-    const byKey = new Map(values.map((value) => [schemaRefIndex(value), value]));
-    return [...byKey.values()].sort(compareSchemaRefs);
+    const byKey = new Map(values.map((value) => [definitionRefIndex(value), value]));
+    return [...byKey.values()].sort(compareDefinitionRefs);
 }
 function uniqueJson(values) {
     const byEncoding = new Map(values.map((value) => [json.serialize(value), value]));
@@ -221,10 +221,6 @@ function compareUtf8Bytes(left, right) {
     }
     return a.length - b.length;
 }
-function withDescription(source, value) {
-    return source.description === undefined ? value : { description: source.description, ...value };
-}
 function isEdge(value) {
     return 'source' in value;
 }
-//# sourceMappingURL=normalize.js.map

package/dist/v1/language/policy/resolved.d.ts

@@ -0,0 +1,9 @@
+import type { DefinitionKey, PolicyRef } from '../../addressing/index.js';
+import type { PolicyDefinition } from './model/policy.js';
+export interface ResolvedPolicy {
+    readonly ref: PolicyRef;
+    readonly key: DefinitionKey<string, 'policy'>;
+    readonly expression: PolicyDefinition['expression'];
+    readonly description?: PolicyDefinition['description'];
+    readonly definition: PolicyDefinition;
+}

package/dist/v1/language/policy/resolved.js

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

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

@@ -0,0 +1,10 @@
+import type { DefinitionRef } from '../addressing/index.js';
+import type { ResolvedFunction } from './callable/resolved.js';
+import type { AnyResolvedClass } from './class/resolved.js';
+import type { ResolvedCoreDefinition } from './core/resolved.js';
+import type { ResolvedPolicy } from './policy/resolved.js';
+import type { ResolvedView } from './view/resolved.js';
+export type ResolvedDefinition = AnyResolvedClass | ResolvedFunction | ResolvedPolicy | ResolvedView | ResolvedCoreDefinition;
+export type ResolvedDefinitionOf<Kind extends DefinitionRef['kind']> = Extract<ResolvedDefinition, {
+    readonly ref: DefinitionRef<Kind>;
+}>;

package/dist/v1/language/resolved.js

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

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

@@ -0,0 +1,3 @@
+export { stateMachine } from './machine.js';
+export type { EventOf, StateMachine, StateOf } from './machine.js';
+export type { StateTopology } from './topology.js';

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>>;
+    readonly eventSchema: ZodType<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;