@cynodia/axiom-runtime 0.4.0-alpha.1 → 0.4.1-alpha.1

package/dist/mutation/transaction.d.ts

@@ -16,6 +16,12 @@ export interface RuntimeTransaction {
 export interface TransactionManager {
     begin(): RuntimeTransaction;
     currentId(): string | undefined;
+    /**
+     * Committed state as it was immediately before the outermost open transaction began —
+     * what a transition rule means by "previous". Not the previous operation, not the
+     * previous iteration.
+     */
+    entrySnapshot(): unknown;
 }
 export declare function createTransactionManager(store: StoreSnapshot, nextId: () => string): TransactionManager;
 //# sourceMappingURL=transaction.d.ts.map

package/dist/mutation/transaction.js

@@ -2,6 +2,7 @@ export function createTransactionManager(store, nextId) {
     const open = [];
     return {
         currentId: () => open[0]?.id,
+        entrySnapshot: () => open[0]?.snapshot,
         begin() {
             const isRoot = open.length === 0;
             const id = isRoot ? nextId() : open[0].id;

package/dist/mutation/values.d.ts

@@ -1,3 +1,13 @@
+/**
+ * Raised when an expression cannot be evaluated — a collection operator applied to
+ * something that is not a collection, an aggregation over non-numeric data, a reference
+ * that does not resolve. Failing loudly is deliberate: an expression must never return a
+ * plausible-looking value and report a failure at the same time.
+ */
+export declare class ExpressionEvaluationError extends Error {
+    readonly details: Record<string, unknown>;
+    constructor(message: string, details?: Record<string, unknown>);
+}
 /**
  * Value helpers shared by the runtime and the mutation subsystem.
  *
@@ -12,8 +22,13 @@
 export declare function cloneValue<T>(value: T): T;
 export declare function deepFreeze<T>(value: T): T;
 export declare function isRecord(value: unknown): value is Record<string, unknown>;
-/** Presence semantics used by `required` — distinct from boolean coercion. */
+/**
+ * Presence answers one question: does a value exist? It says nothing about whether the
+ * value is empty. An empty collection, an empty string, zero and false are all present.
+ */
 export declare function isPresent(value: unknown): boolean;
+/** Emptiness of a collection or a string. Anything else is never empty. */
+export declare function isEmptyValue(value: unknown): boolean;
 export declare function toBoolean(value: unknown): boolean;
 export declare function toText(value: unknown): string;
 export declare function compareValues(left: unknown, right: unknown): number;

package/dist/mutation/values.js

@@ -1,3 +1,17 @@
+/**
+ * Raised when an expression cannot be evaluated — a collection operator applied to
+ * something that is not a collection, an aggregation over non-numeric data, a reference
+ * that does not resolve. Failing loudly is deliberate: an expression must never return a
+ * plausible-looking value and report a failure at the same time.
+ */
+export class ExpressionEvaluationError extends Error {
+    details;
+    constructor(message, details = {}) {
+        super(message);
+        this.name = 'ExpressionEvaluationError';
+        this.details = details;
+    }
+}
 /**
  * Value helpers shared by the runtime and the mutation subsystem.
  *
@@ -24,18 +38,25 @@ export function deepFreeze(value) {
 export function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
-/** Presence semantics used by `required` — distinct from boolean coercion. */
+/**
+ * Presence answers one question: does a value exist? It says nothing about whether the
+ * value is empty. An empty collection, an empty string, zero and false are all present.
+ */
 export function isPresent(value) {
+    return value !== null && value !== undefined;
+}
+/** Emptiness of a collection or a string. Anything else is never empty. */
+export function isEmptyValue(value) {
     if (value === null || value === undefined) {
-        return false;
+        return true;
     }
     if (typeof value === 'string') {
-        return value.trim().length > 0;
+        return value.trim().length === 0;
     }
     if (Array.isArray(value)) {
-        return value.length > 0;
+        return value.length === 0;
     }
-    return true;
+    return false;
 }
 export function toBoolean(value) {
     if (Array.isArray(value)) {
@@ -63,6 +84,19 @@ export function compareValues(left, right) {
     const rightText = toText(right);
     return leftText === rightText ? 0 : leftText < rightText ? -1 : 1;
 }
+/** A stable serialization, so record comparison does not depend on key order. */
+function canonical(value) {
+    if (value === null || typeof value !== 'object') {
+        return JSON.stringify(value) ?? 'null';
+    }
+    if (Array.isArray(value)) {
+        return `[${value.map(canonical).join(',')}]`;
+    }
+    const entries = Object.entries(value)
+        .filter(([, entry]) => entry !== undefined)
+        .sort(([left], [right]) => (left < right ? -1 : left > right ? 1 : 0));
+    return `{${entries.map(([key, entry]) => `${JSON.stringify(key)}:${canonical(entry)}`).join(',')}}`;
+}
 export function valuesEqual(left, right) {
     if (left === right) {
         return true;
@@ -71,7 +105,7 @@ export function valuesEqual(left, right) {
         return (left ?? null) === (right ?? null);
     }
     if (typeof left === 'object' || typeof right === 'object') {
-        return JSON.stringify(left) === JSON.stringify(right);
+        return canonical(left) === canonical(right);
     }
     return false;
 }

package/dist/runtime.d.ts

@@ -20,6 +20,7 @@ export declare const RUNTIME_DIAGNOSTIC_CODES: {
     readonly MUTATION_FAILED: "MUTATION_FAILED";
     readonly DERIVED_STATE_WRITE: "DERIVED_STATE_WRITE";
     readonly UNKNOWN_STATE: "UNKNOWN_STATE";
+    readonly TRANSITION_CONSTRAINT_VIOLATION: "TRANSITION_CONSTRAINT_VIOLATION";
     readonly UNSUPPORTED_EXPRESSION: "UNSUPPORTED_EXPRESSION";
     readonly UNSUPPORTED_OPERATION: "UNSUPPORTED_OPERATION";
     readonly ROUTE_NOT_FOUND: "ROUTE_NOT_FOUND";
@@ -69,7 +70,14 @@ export interface AxiomRuntime {
     start(): void;
     render(): void;
     getState(id: NodeId): unknown;
-    setState(id: NodeId, value: unknown): void;
+    /**
+     * Replaces a state value outright, for hosts, tests and seeding.
+     *
+     * This is an administrative facility, not a semantic write: it does not evaluate
+     * preconditions, entity constraints or transition constraints. Application behaviour
+     * belongs in actions and input bindings, which are governed.
+     */
+    hydrateState(id: NodeId, value: unknown): void;
     invokeAction(id: NodeId, args?: Record<string, unknown>): ActionResult;
     navigate(path: string): void;
     currentRoute(): RouteMatch | null;

package/dist/runtime.js

@@ -2,7 +2,7 @@ import { createMutationEngine } from './mutation/mutation-engine.js';
 import { LocationResolutionError, resolveLocation } from './mutation/resolve-location.js';
 import { createStateStore } from './mutation/store.js';
 import { createTransactionManager } from './mutation/transaction.js';
-import { cloneValue, compareValues, deepFreeze, isPresent, isRecord, toBoolean, toText, valuesEqual, } from './mutation/values.js';
+import { ExpressionEvaluationError, cloneValue, compareValues, deepFreeze, isEmptyValue, isPresent, isRecord, toBoolean, toText, valuesEqual, } from './mutation/values.js';
 /**
  * The diagnostics a runtime can report. Agents match on the code rather than parsing the
  * message, so this vocabulary is part of the public contract.
@@ -22,6 +22,7 @@ export const RUNTIME_DIAGNOSTIC_CODES = {
     MUTATION_FAILED: 'MUTATION_FAILED',
     DERIVED_STATE_WRITE: 'DERIVED_STATE_WRITE',
     UNKNOWN_STATE: 'UNKNOWN_STATE',
+    TRANSITION_CONSTRAINT_VIOLATION: 'TRANSITION_CONSTRAINT_VIOLATION',
     UNSUPPORTED_EXPRESSION: 'UNSUPPORTED_EXPRESSION',
     UNSUPPORTED_OPERATION: 'UNSUPPORTED_OPERATION',
     ROUTE_NOT_FOUND: 'ROUTE_NOT_FOUND',
@@ -58,6 +59,17 @@ function defaultForType(type) {
             return null;
     }
 }
+/**
+ * Collection operators are strict about their source: `null` means a missing or invalid
+ * collection, and an empty collection means an empty collection. Conflating the two is
+ * what made 0.4 hard to reason about.
+ */
+function requireCollection(value, operator) {
+    if (!Array.isArray(value)) {
+        throw new ExpressionEvaluationError(`${operator} expects a collection but received ${describeValue(value)}`, { operator, received: value });
+    }
+    return value;
+}
 /** A short, structured description of a runtime value, for diagnostics. */
 function describeValue(value) {
     if (value === null || value === undefined) {
@@ -172,9 +184,16 @@ export function createAxiomRuntime(options) {
                 return derivedCache.get(stateId);
             }
             derivedCache.set(stateId, null);
-            const value = deepFreeze(cloneValue(evaluate(state.derivation, rootScope())));
-            derivedCache.set(stateId, value);
-            return value;
+            try {
+                const value = deepFreeze(cloneValue(evaluate(state.derivation, rootScope())));
+                derivedCache.set(stateId, value);
+                return value;
+            }
+            catch (error) {
+                report(evaluationFailure(error, { nodeId: state.id, stateId: state.id }));
+                derivedCache.set(stateId, null);
+                return null;
+            }
         }
         return store.read(stateId);
     }
@@ -245,6 +264,28 @@ export function createAxiomRuntime(options) {
             }
         }
     }
+    /** Turns an evaluation failure into a diagnostic instead of letting it escape. */
+    function evaluationFailure(error, context = {}) {
+        if (error instanceof ExpressionEvaluationError) {
+            return {
+                code: RUNTIME_DIAGNOSTIC_CODES.EXPRESSION_EVALUATION_FAILED,
+                message: error.message,
+                severity: 'error',
+                ...context,
+                details: { ...error.details, ...(context.details ?? {}) },
+            };
+        }
+        throw error;
+    }
+    /** Evaluates an expression, reporting rather than throwing if it cannot be evaluated. */
+    function tryEvaluate(expression, scope, context = {}) {
+        try {
+            return { ok: true, value: evaluate(expression, scope) };
+        }
+        catch (error) {
+            return { ok: false, diagnostic: evaluationFailure(error, context) };
+        }
+    }
     /** Applies a mutation inside the current transaction and reports resolution failures. */
     function mutate(apply, context, failures) {
         try {
@@ -298,13 +339,7 @@ export function createAxiomRuntime(options) {
                 if (statesById.has(expression.targetId)) {
                     return readState(expression.targetId);
                 }
-                report({
-                    code: RUNTIME_DIAGNOSTIC_CODES.UNRESOLVED_REFERENCE,
-                    message: `Reference ${expression.targetId} could not be resolved`,
-                    severity: 'error',
-                    nodeId: expression.targetId,
-                });
-                return null;
+                throw new ExpressionEvaluationError(`Reference ${expression.targetId} could not be resolved`, { targetId: expression.targetId });
             }
             case 'field': {
                 const source = evaluate(expression.source, scope);
@@ -330,53 +365,42 @@ export function createAxiomRuntime(options) {
             case 'call':
                 return evaluateCall(expression.function, expression.arguments, scope);
             case 'filter': {
-                const source = evaluate(expression.source, scope);
-                if (!Array.isArray(source)) {
-                    return [];
-                }
+                const source = requireCollection(evaluate(expression.source, scope), 'filter');
                 return source.filter((item) => toBoolean(evaluate(expression.predicate, childScope(scope, expression.scopeId, item))));
             }
             case 'map': {
-                const source = evaluate(expression.source, scope);
-                if (!Array.isArray(source)) {
-                    report({
-                        code: RUNTIME_DIAGNOSTIC_CODES.EXPRESSION_EVALUATION_FAILED,
-                        message: `map expects a collection but received ${describeValue(source)}`,
-                        severity: 'error',
-                    });
-                    return [];
-                }
+                const source = requireCollection(evaluate(expression.source, scope), 'map');
                 return source.map((item) => evaluate(expression.projection, childScope(scope, expression.scopeId, item)));
             }
             case 'sort': {
-                const source = evaluate(expression.source, scope);
-                if (!Array.isArray(source)) {
-                    report({
-                        code: RUNTIME_DIAGNOSTIC_CODES.EXPRESSION_EVALUATION_FAILED,
-                        message: `sort expects a collection but received ${describeValue(source)}`,
-                        severity: 'error',
-                    });
-                    return [];
-                }
+                const source = requireCollection(evaluate(expression.source, scope), 'sort');
                 const direction = expression.direction === 'desc' ? -1 : 1;
                 const key = (item) => evaluate(expression.by, childScope(scope, expression.scopeId, item));
                 return [...source].sort((left, right) => direction * compareValues(key(left), key(right)));
             }
+            case 'every': {
+                const source = requireCollection(evaluate(expression.source, scope), 'every');
+                return source.every((item) => toBoolean(evaluate(expression.predicate, childScope(scope, expression.scopeId, item))));
+            }
+            case 'some': {
+                const source = requireCollection(evaluate(expression.source, scope), 'some');
+                return source.some((item) => toBoolean(evaluate(expression.predicate, childScope(scope, expression.scopeId, item))));
+            }
+            case 'flatten': {
+                const source = requireCollection(evaluate(expression.source, scope), 'flatten');
+                return source.flatMap((member) => requireCollection(member, 'flatten'));
+            }
+            case 'conditional':
+                return toBoolean(evaluate(expression.condition, scope))
+                    ? evaluate(expression.whenTrue, scope)
+                    : evaluate(expression.whenFalse, scope);
             case 'find': {
-                const source = evaluate(expression.source, scope);
-                if (!Array.isArray(source)) {
-                    return null;
-                }
+                const source = requireCollection(evaluate(expression.source, scope), 'find');
                 const found = source.find((item) => toBoolean(evaluate(expression.predicate, childScope(scope, expression.scopeId, item))));
                 return found === undefined ? null : found;
             }
             default:
-                report({
-                    code: RUNTIME_DIAGNOSTIC_CODES.UNSUPPORTED_EXPRESSION,
-                    message: `Unknown expression kind "${expression.kind}"`,
-                    severity: 'error',
-                });
-                return null;
+                throw new ExpressionEvaluationError(`Unknown expression kind "${expression.kind}"`, { kind: expression.kind });
         }
     }
     function evaluateBinary(operator, leftExpression, rightExpression, scope) {
@@ -412,44 +436,31 @@ export function createAxiomRuntime(options) {
                 return divisor === 0 ? null : Number(left ?? 0) / divisor;
             }
             default:
-                report({ code: RUNTIME_DIAGNOSTIC_CODES.UNSUPPORTED_EXPRESSION, message: `Unknown operator "${operator}"`, severity: 'error' });
-                return null;
+                throw new ExpressionEvaluationError(`Unknown operator "${operator}"`, { operator });
         }
     }
     function evaluateCall(fn, args, scope) {
         const values = args.map((argument) => evaluate(argument, scope));
         switch (fn) {
             case 'required':
+                // Presence only: an empty collection or string exists, and so does 0 and false.
                 return isPresent(values[0]);
             case 'is-empty':
-                return !isPresent(values[0]);
+                return isEmptyValue(values[0]);
+            case 'non-empty':
+                return !isEmptyValue(values[0]);
             case 'length':
                 return Array.isArray(values[0]) ? values[0].length : toText(values[0]).length;
             case 'count':
-                return Array.isArray(values[0]) ? values[0].length : 0;
+                return requireCollection(values[0], 'count').length;
             case 'sum': {
-                // An aggregation that cannot be computed must not quietly produce a value that
-                // makes a guard pass. It reports, and yields a number no comparison accepts.
-                const source = values[0];
-                if (!Array.isArray(source)) {
-                    report({
-                        code: RUNTIME_DIAGNOSTIC_CODES.EXPRESSION_EVALUATION_FAILED,
-                        message: `sum expects a collection of numbers but received ${describeValue(source)}`,
-                        severity: 'error',
-                        details: { received: source },
-                    });
-                    return Number.NaN;
-                }
+                // An aggregation that cannot be computed fails; it never returns a number that
+                // would quietly satisfy a guard.
+                const source = requireCollection(values[0], 'sum');
                 let total = 0;
                 for (const member of source) {
                     if (typeof member !== 'number' || !Number.isFinite(member)) {
-                        report({
-                            code: RUNTIME_DIAGNOSTIC_CODES.EXPRESSION_EVALUATION_FAILED,
-                            message: `sum encountered ${describeValue(member)} where a number was required`,
-                            severity: 'error',
-                            details: { member },
-                        });
-                        return Number.NaN;
+                        throw new ExpressionEvaluationError(`sum encountered ${describeValue(member)} where a number was required`, { member });
                     }
                     total += member;
                 }
@@ -465,6 +476,7 @@ export function createAxiomRuntime(options) {
             case 'concat':
                 return values.map(toText).join('');
             case 'coalesce':
+                // Nullish, not "non-empty": falling back to an empty collection has to be possible.
                 return values.find((value) => isPresent(value)) ?? null;
             case 'one-of':
                 return values.slice(1).some((option) => valuesEqual(option, values[0]));
@@ -477,8 +489,7 @@ export function createAxiomRuntime(options) {
             case 'uuid':
                 return host.uuid();
             default:
-                report({ code: RUNTIME_DIAGNOSTIC_CODES.UNSUPPORTED_EXPRESSION, message: `Unknown function "${fn}"`, severity: 'error' });
-                return null;
+                throw new ExpressionEvaluationError(`Unknown function "${fn}"`, { function: fn });
         }
     }
     // -------------------------------------------------------------- validation
@@ -495,7 +506,7 @@ export function createAxiomRuntime(options) {
      * their declared types. Entities nested inside collections and inside other entities
      * are reached recursively, so their constraints apply wherever they actually live.
      */
-    function collectInstances() {
+    function collectInstances(read = readState) {
         const found = new Map();
         const visit = (value, type) => {
             const resolved = unwrapType(type);
@@ -523,10 +534,69 @@ export function createAxiomRuntime(options) {
             if (state.draft || state.derivation) {
                 continue;
             }
-            visit(readState(state.id), state.valueType);
+            visit(read(state.id), state.valueType);
         }
         return found;
     }
+    /**
+     * Transition rules, evaluated against the state the transaction started from and the
+     * state it now proposes. Every governed mutation path runs this before committing, so a
+     * rule holds regardless of which path attempted the write.
+     */
+    function evaluateTransitions() {
+        const snapshot = transactions.entrySnapshot();
+        if (!snapshot || ir.transitionConstraints.length === 0) {
+            return [];
+        }
+        const previousInstances = collectInstances((stateId) => snapshot.get(stateId));
+        const proposedInstances = collectInstances();
+        const failures = [];
+        for (const rule of ir.transitionConstraints) {
+            const entity = entitiesById.get(rule.entityId);
+            const identity = entity?.identityFieldId;
+            if (!identity) {
+                continue;
+            }
+            const identify = (instance) => (isRecord(instance) ? instance[identity] : undefined);
+            const proposedByIdentity = new Map();
+            for (const instance of proposedInstances.get(rule.entityId) ?? []) {
+                proposedByIdentity.set(toText(identify(instance)), instance);
+            }
+            for (const previous of previousInstances.get(rule.entityId) ?? []) {
+                const key = toText(identify(previous));
+                // A removed instance is a transition too: its proposed form is nothing.
+                const proposed = proposedByIdentity.get(key) ?? null;
+                if (proposed !== null && valuesEqual(previous, proposed)) {
+                    continue;
+                }
+                const scope = childScope(childScope(rootScope(), rule.previousScopeId, previous), rule.proposedScopeId, proposed);
+                const outcome = tryEvaluate(rule.expression, scope, {
+                    nodeId: rule.id,
+                    constraintId: rule.id,
+                });
+                if (outcome.ok && toBoolean(outcome.value)) {
+                    continue;
+                }
+                failures.push(outcome.ok
+                    ? {
+                        code: RUNTIME_DIAGNOSTIC_CODES.TRANSITION_CONSTRAINT_VIOLATION,
+                        message: rule.message ?? `Transition ${rule.name ?? rule.id} is not allowed`,
+                        severity: rule.severity ?? 'error',
+                        nodeId: rule.id,
+                        constraintId: rule.id,
+                        details: {
+                            transitionConstraintId: rule.id,
+                            entityId: rule.entityId,
+                            identity: identify(previous),
+                            previousValue: previous,
+                            proposedValue: proposed,
+                        },
+                    }
+                    : outcome.diagnostic);
+            }
+        }
+        return failures;
+    }
     function instancesOf(entityId) {
         return collectInstances().get(entityId) ?? [];
     }
@@ -653,15 +723,26 @@ export function createAxiomRuntime(options) {
                 ...(constraint.entityId ? { details: { entityId: constraint.entityId, instance } } : {}),
             });
         };
+        /** A constraint that cannot be evaluated counts as violated, never as satisfied. */
+        const holds = (scope) => {
+            const outcome = tryEvaluate(constraint.expression, scope, {
+                nodeId: constraint.id,
+                constraintId: constraint.id,
+            });
+            if (!outcome.ok) {
+                failures.push(outcome.diagnostic);
+                return false;
+            }
+            return toBoolean(outcome.value);
+        };
         if (!constraint.entityId) {
-            if (!toBoolean(evaluate(constraint.expression, rootScope()))) {
+            if (!holds(rootScope())) {
                 record();
             }
             return failures;
         }
         for (const instance of instances.get(constraint.entityId) ?? []) {
-            const scope = childScope(rootScope(), constraint.entityId, instance);
-            if (!toBoolean(evaluate(constraint.expression, scope))) {
+            if (!holds(childScope(rootScope(), constraint.entityId, instance))) {
                 record(instance);
             }
         }
@@ -669,6 +750,17 @@ export function createAxiomRuntime(options) {
     }
     // --------------------------------------------------------------- behaviour
     function executeOperation(operation, scope, context, result) {
+        try {
+            executeOperationUnguarded(operation, scope, context, result);
+        }
+        catch (error) {
+            result.push(evaluationFailure(error, {
+                ...(context.sourceNodeId ? { nodeId: context.sourceNodeId, actionId: context.sourceNodeId } : {}),
+                ...(context.transactionId ? { transactionId: context.transactionId } : {}),
+            }));
+        }
+    }
+    function executeOperationUnguarded(operation, scope, context, result) {
         switch (operation.kind) {
             case 'set':
             case 'insert':
@@ -680,16 +772,7 @@ export function createAxiomRuntime(options) {
                 // walks the collection as it stood when the operation began. Nothing here opens
                 // a transaction: these mutations belong to the action's own transaction, and a
                 // failure in any iteration rolls back every iteration with it.
-                const members = evaluate(operation.collection, scope);
-                if (!Array.isArray(members)) {
-                    result.push({
-                        code: RUNTIME_DIAGNOSTIC_CODES.EXPRESSION_EVALUATION_FAILED,
-                        message: `for-each expects a collection but received ${describeValue(members)}`,
-                        severity: 'error',
-                        ...(context.sourceNodeId ? { actionId: context.sourceNodeId } : {}),
-                    });
-                    return;
-                }
+                const members = requireCollection(evaluate(operation.collection, scope), 'for-each');
                 for (const member of members) {
                     const iteration = childScope(scope, operation.scopeId, member);
                     for (const nested of operation.operations ?? []) {
@@ -794,7 +877,12 @@ export function createAxiomRuntime(options) {
         // Failure modes line up with preconditions by position, so a refusal says which
         // condition was not met rather than always naming the first one.
         for (const [index, precondition] of (action.preconditions ?? []).entries()) {
-            if (toBoolean(evaluate(precondition, scope))) {
+            const outcome = tryEvaluate(precondition, scope, { nodeId: action.id, actionId: action.id });
+            if (!outcome.ok) {
+                report(outcome.diagnostic);
+                return { ok: false, diagnostics: [...collected] };
+            }
+            if (toBoolean(outcome.value)) {
                 continue;
             }
             const mode = action.failureModes?.[index];
@@ -831,9 +919,14 @@ export function createAxiomRuntime(options) {
             ...operationDiagnostics.filter((diagnostic) => diagnostic.severity === 'error'),
             ...collected.slice(reportedBefore).filter((diagnostic) => diagnostic.severity === 'error'),
             ...evaluateInvariants().filter((diagnostic) => diagnostic.severity === 'error'),
+            ...evaluateTransitions().filter((diagnostic) => diagnostic.severity === 'error'),
         ];
         for (const postcondition of action.postconditions ?? []) {
-            if (!toBoolean(evaluate(postcondition, scope))) {
+            const outcome = tryEvaluate(postcondition, scope, { nodeId: action.id, actionId: action.id });
+            if (!outcome.ok || !toBoolean(outcome.value)) {
+                if (!outcome.ok) {
+                    violations.push(outcome.diagnostic);
+                }
                 violations.push({
                     code: RUNTIME_DIAGNOSTIC_CODES.POSTCONDITION_FAILED,
                     message: `A postcondition of ${action.name ?? action.id} was not satisfied`,
@@ -1016,6 +1109,15 @@ export function createAxiomRuntime(options) {
         return raw;
     }
     function renderNode(id, scope) {
+        try {
+            return renderNodeUnguarded(id, scope);
+        }
+        catch (error) {
+            report(evaluationFailure(error, { nodeId: id }));
+            return null;
+        }
+    }
+    function renderNodeUnguarded(id, scope) {
         const node = ir.uiNodes[id];
         if (!node) {
             report({
@@ -1161,15 +1263,21 @@ export function createAxiomRuntime(options) {
                         failures.forEach(report);
                     }
                     else {
-                        const introduced = before ? violationsIntroducedSince(before) : [];
-                        if (introduced.length > 0) {
+                        // A transition rule always applies: it compares against the state this
+                        // mutation started from, so it can never be a pre-existing violation.
+                        const rejected = [
+                            ...(before ? violationsIntroducedSince(before) : []),
+                            ...evaluateTransitions().filter((diagnostic) => diagnostic.severity === 'error'),
+                        ];
+                        if (rejected.length > 0) {
                             settle(transaction, 'rolled-back');
-                            introduced.forEach(report);
+                            rejected.forEach((diagnostic) => report({ ...diagnostic, details: { ...diagnostic.details, source: 'input', nodeId: node.id } }));
                             report({
                                 code: RUNTIME_DIAGNOSTIC_CODES.INPUT_REJECTED,
-                                message: `${node.label ?? node.id} kept its previous value: ${introduced[0].message}`,
+                                message: `${node.label ?? node.id} kept its previous value: ${rejected[0].message}`,
                                 severity: 'warning',
                                 nodeId: node.id,
+                                details: { source: 'input' },
                             });
                         }
                         else {
@@ -1271,7 +1379,7 @@ export function createAxiomRuntime(options) {
         getState(id) {
             return cloneValue(readState(id));
         },
-        setState(id, value) {
+        hydrateState(id, value) {
             const transaction = transactions.begin();
             const failures = [];
             const context = { source: 'system', transactionId: transaction.id };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cynodia/axiom-runtime",
-  "version": "0.4.0-alpha.1",
+  "version": "0.4.1-alpha.1",
   "description": "Domain-independent runtime that executes an Axiom application graph.",
   "license": "MIT",
   "author": "AskTech AS",
@@ -31,7 +31,7 @@
     }
   },
   "dependencies": {
-    "@cynodia/axiom-core": "0.4.0-alpha.1"
+    "@cynodia/axiom-core": "0.4.1-alpha.1"
   },
   "scripts": {
     "build": "tsc -b tsconfig.json tsconfig.test.json",