diff --git a/.changeset/cool-dragons-divide.md b/.changeset/cool-dragons-divide.md
new file mode 100644
index 000000000..827f7eb3f
--- /dev/null
+++ b/.changeset/cool-dragons-divide.md
@@ -0,0 +1,7 @@
+---
+"@getodk/xforms-engine": minor
+"@getodk/web-forms": minor
+"@getodk/xpath": minor
+---
+
+Improved error messages for invalid forms.
diff --git a/packages/web-forms/locales/strings_en.json b/packages/web-forms/locales/strings_en.json
index 38914c2ff..4055a1963 100644
--- a/packages/web-forms/locales/strings_en.json
+++ b/packages/web-forms/locales/strings_en.json
@@ -19,9 +19,13 @@
     "string": "Next",
     "developer_comment": "Label for the button that moves to the next page in a paginated form."
   },
+  "odk_web_forms.evaluation.error": {
+    "string": "Error found while evaluating this form. Error message: \"{message}\". Reported by {count, plural, one {field} other {fields}}: {fields}. Please contact the person who sent you the form link.",
+    "developer_comment": "Form error banner message. {message} is the raw error message. {fields} is a string naming the fields affected. {count} is the number of fields reporting the error."
+  },
   "odk_web_forms.validation.error": {
     "string": "{count, plural, one {# question with error} other {# questions with errors}}",
-    "developer_comment": "Error banner message. {count} is the number of validation violations."
+    "developer_comment": "Validation error banner message. {count} is the number of validation issues."
   },
   "odk_web_forms.validation.view.label": {
     "string": "View",
diff --git a/packages/web-forms/src/components/OdkWebForm.i18n.json b/packages/web-forms/src/components/OdkWebForm.i18n.json
index 9078fa858..65e116087 100644
--- a/packages/web-forms/src/components/OdkWebForm.i18n.json
+++ b/packages/web-forms/src/components/OdkWebForm.i18n.json
@@ -11,9 +11,13 @@
     "string": "Next",
     "developer_comment": "Label for the button that moves to the next page in a paginated form."
   },
+  "odk_web_forms.evaluation.error": {
+    "string": "Error found while evaluating this form. Error message: \"{message}\". Reported by {count, plural, one {field} other {fields}}: {fields}. Please contact the person who sent you the form link.",
+    "developer_comment": "Form error banner message. {message} is the raw error message. {fields} is a string naming the fields affected. {count} is the number of fields reporting the error."
+  },
   "odk_web_forms.validation.error": {
     "string": "{count, plural, one {# question with error} other {# questions with errors}}",
-    "developer_comment": "Error banner message. {count} is the number of validation violations."
+    "developer_comment": "Validation error banner message. {count} is the number of validation issues."
   },
   "odk_web_forms.validation.view.label": {
     "string": "View",
diff --git a/packages/web-forms/src/components/OdkWebForm.vue b/packages/web-forms/src/components/OdkWebForm.vue
index c00fa2d63..1117a1d97 100644
--- a/packages/web-forms/src/components/OdkWebForm.vue
+++ b/packages/web-forms/src/components/OdkWebForm.vue
@@ -322,10 +322,28 @@ provide(REVEAL_VIOLATIONS, revealViolations);
 // It returns violations for questions the user has seen.
 const revealedViolations = computed(() => {
 	const violations = state.value.root?.validationState.violations ?? [];
+	const nonErrorViolations = violations.filter((violation) => violation.violation.condition !== 'error');
 	if (submitPressed.value) {
-		return violations;
+		return nonErrorViolations;
 	}
-	return violations.filter(({ nodeId }) => touchedQuestions.has(nodeId));
+	return nonErrorViolations.filter((violation) => touchedQuestions.has(violation.nodeId));
+});
+
+const errorViolations = computed(() => {
+	const violations = state.value.root?.validationState.violations ?? [];
+	const grouped = new Map<string, string[]>();
+	violations.forEach(error => {
+		const key = error.violation.condition === 'error' && error.violation.message;
+		if (!key) {
+			return;
+		}
+		const fieldReferences = grouped.get(key) ?? [];
+		const rootNodeName = state.value.root?.definition.nodeset;
+		const fieldReference = error.reference.replace(rootNodeName + '/', '');
+		fieldReferences.push(fieldReference);
+		grouped.set(key, fieldReferences);
+	});
+	return grouped;
 });
 
 const validationErrorMessage = computed(() => {
@@ -339,7 +357,11 @@ const showValidationError = computed(() => {
 	if (errorBannerDismissed.value) {
 		return false;
 	}
-	return !!(validationErrorMessage.value.length || geolocationErrorMessage.value?.length);
+	return (
+		!!validationErrorMessage.value.length ||
+		!!geolocationErrorMessage.value?.length ||
+		!!errorViolations.value.size
+	);
 });
 
 onUnmounted(() => {
@@ -389,6 +411,13 @@ onUnmounted(() => {
 			>
 				<IconSVG name="mdiAlertCircleOutline" variant="error" />
 				<ul class="form-error-text-wrap">
+					<li v-for="[message, references] in errorViolations" :key="message">
+						{{ t('odk_web_forms.evaluation.error', {
+							message,
+							fields: references.join(', '),
+							count: references.length
+						}) }}
+					</li>
 					<li v-if="validationErrorMessage?.length">
 						{{ validationErrorMessage }}
 					</li>
diff --git a/packages/web-forms/src/components/common/ValidationMessage.vue b/packages/web-forms/src/components/common/ValidationMessage.vue
index 6895ff22a..53634c687 100644
--- a/packages/web-forms/src/components/common/ValidationMessage.vue
+++ b/packages/web-forms/src/components/common/ValidationMessage.vue
@@ -39,7 +39,12 @@ const defaultMessage = computed(() => {
 	<div :class="{ 'validation-placeholder': addPlaceholder }">
 		<span v-show="showMessage" class="validation-message">
 			<template v-if="violation?.message">
-				<MarkdownBlock v-for="elem in violation.message.formatted" :key="elem.id" :elem="elem" />
+				<template v-if="violation?.condition === 'error'">
+					<span>{{ violation.message }}</span>
+				</template>
+				<template v-else>
+					<MarkdownBlock v-for="elem in violation.message.formatted" :key="elem.id" :elem="elem" />
+				</template>
 			</template>
 			<template v-else-if="defaultMessage">{{ defaultMessage }}</template>
 		</span>
diff --git a/packages/web-forms/tests/components/OdkWebForm.test.ts b/packages/web-forms/tests/components/OdkWebForm.test.ts
index d5878d2ed..974b0d3b4 100644
--- a/packages/web-forms/tests/components/OdkWebForm.test.ts
+++ b/packages/web-forms/tests/components/OdkWebForm.test.ts
@@ -332,24 +332,16 @@ describe('OdkWebForm', () => {
       expect(component.get('.form-load-failure-dialog').isVisible()).toBe(true);
     });
 
-    // TODO: tests failure which is currently produced by throwing a string.
-    // Checking the text content here is intended to ensure we are actually
-    // presenting the message to a user.
     it('presents an error message when failing to load a form with a computation referencing an unknown XPath function', async () => {
       const xpathUnknownFunctionFormXML = await getWebFormsTestFixture(
         'xpath-unknown-function.xml'
       );
       const component = mountComponent(xpathUnknownFunctionFormXML);
-
       await flushPromises();
-
-      const formLoadFailureDialog = component.get('.form-load-failure-dialog');
-
-      expect(formLoadFailureDialog.isVisible()).toBe(true);
-
-      const message = formLoadFailureDialog.get('.message');
-
-      expect(message.text()).toMatch(/\bnope\b/);
+      expectErrorBanner(
+        component,
+        'Error found while evaluating this form. Error message: "Unknown function in form definition: \'nope\'". Reported by field: first-question. Please contact the person who sent you the form link.'
+      );
     });
   });
 
diff --git a/packages/xforms-engine/src/client/TextRange.ts b/packages/xforms-engine/src/client/TextRange.ts
index 75281d020..1fbe8b595 100644
--- a/packages/xforms-engine/src/client/TextRange.ts
+++ b/packages/xforms-engine/src/client/TextRange.ts
@@ -79,7 +79,7 @@ export interface TextChunk {
 // eslint-disable-next-line @typescript-eslint/sort-type-constituents
 export type ElementTextRole = 'hint' | 'label' | 'item-label';
 export type ValidationTextRole = 'constraintMsg' | 'requiredMsg';
-export type TextRole = ElementTextRole | ValidationTextRole;
+export type TextRole = ElementTextRole | ValidationTextRole | 'errorMsg';
 
 /**
  * Represents aspects of a form which produce text, which _might_ be:
diff --git a/packages/xforms-engine/src/client/validation.ts b/packages/xforms-engine/src/client/validation.ts
index 5841cf359..c712a61ef 100644
--- a/packages/xforms-engine/src/client/validation.ts
+++ b/packages/xforms-engine/src/client/validation.ts
@@ -1,10 +1,14 @@
+import type { Attribute } from '../instance/Attribute.ts';
 import type { BaseNode, BaseNodeState } from './BaseNode.ts';
+import type { AnyNode } from './hierarchy.ts';
 import type { FormNodeID } from './identity.ts';
 import type { OpaqueReactiveObjectFactory } from './OpaqueReactiveObjectFactory.ts';
 import type { TextRange } from './TextRange.ts';
 
 // This interface exists so that extensions can share JSDoc for `valid`.
-interface BaseValidity {
+interface BaseValidity<Condition> {
+  readonly condition: Condition;
+
   /**
    * Specifies the unambiguous validity state for each validity condition of a
    * given node, or for the derived validity of any parent node whose descendants
@@ -24,6 +28,9 @@ interface BaseValidity {
    * - \* = default (expression not defined)
    * - ✅ = `valid: true`
    * - ❌ = `valid: false`
+   *
+   * `error` condition represents an invalid state, for example, if an xpath expression
+   * cannot be parsed.
    */
   readonly valid: boolean;
 }
@@ -33,11 +40,12 @@ interface BaseValidity {
  *
  * @see {@link https://getodk.github.io/xforms-spec/#bind-attributes | `constraint` and `required` bind attributes}
  */
-export type ValidationCondition = 'constraint' | 'required';
+export type ValidationCondition = 'constraint' | 'error' | 'required';
 
 interface ValidationConditionMessageRoles {
   readonly constraint: 'constraintMsg';
   readonly required: 'requiredMsg';
+  readonly error: 'errorMsg';
 }
 
 export type ValidationConditionMessageRole<Condition extends ValidationCondition> =
@@ -48,8 +56,8 @@ export type ValidationConditionMessageRole<Condition extends ValidationCondition
  * or `jr:requiredMsg`. The text may be translated ({@link https://getodk.github.io/xforms-spec/#fn:jr:itext | `jr:itext`})
  * and dynamic (via {@link https://getodk.github.io/xforms-spec/#body-elements | `<output>`}).
  *
- * When absent, {@link ConditionViolation.message} is `null` and clients are expected to provide
- * their own default messaging (e.g. a translated fallback).
+ * When absent, the `message` of {@link ConstraintViolation} or {@link RequiredViolation} is `null`
+ * and clients are expected to provide their own default messaging (e.g. a translated fallback).
  */
 export interface ViolationMessage<Condition extends ValidationCondition> extends TextRange<
   ValidationConditionMessageRole<Condition>
@@ -57,23 +65,33 @@ export interface ViolationMessage<Condition extends ValidationCondition> extends
   get asString(): string;
 }
 
-export interface ConditionSatisfied<Condition extends ValidationCondition> extends BaseValidity {
-  readonly condition: Condition;
+export interface ConditionSatisfied<
+  Condition extends ValidationCondition,
+> extends BaseValidity<Condition> {
   readonly valid: true;
   readonly message: null;
 }
 
-export interface ConditionViolation<Condition extends ValidationCondition> extends BaseValidity {
-  readonly condition: Condition;
+export interface ConstraintViolation extends BaseValidity<'constraint'> {
+  readonly valid: false;
+  readonly message: ViolationMessage<'constraint'> | null;
+}
+
+export interface RequiredViolation extends BaseValidity<'required'> {
   readonly valid: false;
-  readonly message: ViolationMessage<Condition> | null;
+  readonly message: ViolationMessage<'required'> | null;
+}
+
+export interface ErrorViolation extends BaseValidity<'error'> {
+  readonly valid: false;
+  readonly message: string | null;
 }
 
 export type ConditionValidation<Condition extends ValidationCondition> =
-  | ConditionSatisfied<Condition>
-  | ConditionViolation<Condition>;
+  | AnyViolation
+  | ConditionSatisfied<Condition>;
 
-export type AnyViolation = ConditionViolation<ValidationCondition>;
+export type AnyViolation = ConstraintViolation | ErrorViolation | RequiredViolation;
 
 /**
  * Represents the validation state of a leaf (or value) node.
@@ -129,6 +147,7 @@ export interface LeafNodeValidationState {
 export interface DescendantNodeViolationReference {
   readonly nodeId: FormNodeID;
 
+  get node(): AnyNode | Attribute;
   get reference(): string;
   get violation(): AnyViolation;
 }
@@ -150,15 +169,7 @@ export interface AncestorNodeValidationState {
   get violations(): readonly DescendantNodeViolationReference[];
 }
 
-/**
- * Convenience interface for nodes that cannot be invalid.
- */
-export interface NullValidationState {
-  get violations(): readonly [];
-}
-
 // prettier-ignore
 export type NodeValidationState =
 	| AncestorNodeValidationState
-	| LeafNodeValidationState
-	| NullValidationState;
+	| LeafNodeValidationState;
diff --git a/packages/xforms-engine/src/instance/Attribute.ts b/packages/xforms-engine/src/instance/Attribute.ts
index 1ab054934..0abb4f6c8 100644
--- a/packages/xforms-engine/src/instance/Attribute.ts
+++ b/packages/xforms-engine/src/instance/Attribute.ts
@@ -1,7 +1,7 @@
 import { XPathNodeKindKey } from '@getodk/xpath';
 import type { Accessor } from 'solid-js';
 import type { AttributeNode } from '../client/AttributeNode.ts';
-import type { InstanceState, NullValidationState } from '../client/index.ts';
+import type { AncestorNodeValidationState, InstanceState } from '../client/index.ts';
 import type { XFormsXPathAttribute } from '../integration/xpath/adapter/XFormsXPathNode.ts';
 import type { StaticAttribute } from '../integration/xpath/static-dom/StaticAttribute.ts';
 import { createAttributeNodeInstanceState } from '../lib/client-reactivity/instance-state/createAttributeNodeInstanceState.ts';
@@ -51,7 +51,7 @@ export class Attribute
 
   protected readonly state: SharedNodeState<AttributeStateSpec>;
   protected readonly engineState: EngineState<AttributeStateSpec>;
-  readonly validationState: NullValidationState;
+  readonly validationState: AncestorNodeValidationState;
 
   readonly nodeType = 'attribute';
   readonly currentState: CurrentState<AttributeStateSpec>;
@@ -146,6 +146,10 @@ export class Attribute
     };
   }
 
+  protected override canReportViolation(): boolean {
+    return true;
+  }
+
   setValue(value: string): Root {
     this.setValueState(value);
 
diff --git a/packages/xforms-engine/src/instance/PrimaryInstance.ts b/packages/xforms-engine/src/instance/PrimaryInstance.ts
index 20e3bb35e..a6ba52304 100644
--- a/packages/xforms-engine/src/instance/PrimaryInstance.ts
+++ b/packages/xforms-engine/src/instance/PrimaryInstance.ts
@@ -323,4 +323,8 @@ export class PrimaryInstance<
     const location = await this.geolocationProvider.getLocation();
     return location ?? '';
   }
+
+  override registerExpressionError(): void {
+    // should not happen
+  }
 }
diff --git a/packages/xforms-engine/src/instance/Root.ts b/packages/xforms-engine/src/instance/Root.ts
index 73812f8da..e82af87b1 100644
--- a/packages/xforms-engine/src/instance/Root.ts
+++ b/packages/xforms-engine/src/instance/Root.ts
@@ -12,7 +12,11 @@ import type {
   InstancePayloadType,
 } from '../client/serialization/InstancePayloadOptions.ts';
 import type { InstanceState } from '../client/serialization/InstanceState.ts';
-import type { AncestorNodeValidationState, BlockingViolations } from '../client/validation.ts';
+import type {
+  AncestorNodeValidationState,
+  BlockingViolations,
+  DescendantNodeViolationReference,
+} from '../client/validation.ts';
 import type { XFormsXPathElement } from '../integration/xpath/adapter/XFormsXPathNode.ts';
 import { createRootInstanceState } from '../lib/client-reactivity/instance-state/createRootInstanceState.ts';
 import {
@@ -34,10 +38,11 @@ import { createAggregatedViolations } from '../lib/reactivity/validation/createA
 import type { BodyClassList } from '../parse/body/BodyDefinition.ts';
 import type { RootDefinition } from '../parse/model/RootDefinition.ts';
 import { DescendantNode } from './abstract/DescendantNode.ts';
+import { ValueNode } from './abstract/ValueNode.ts';
 import { buildAttributes } from './buildAttributes.ts';
 import { Attribute } from './Attribute.ts';
 import { buildChildren } from './children/buildChildren.ts';
-import type { GeneralChildNode } from './hierarchy.ts';
+import type { AnyControlInstanceNode, GeneralChildNode } from './hierarchy.ts';
 import type { EvaluationContext } from './internal-api/EvaluationContext.ts';
 import type { ClientReactiveSerializableParentNode } from './internal-api/serialization/ClientReactiveSerializableParentNode.ts';
 import type { TranslationContext } from './internal-api/TranslationContext.ts';
@@ -73,6 +78,17 @@ interface RootStateSpec {
   readonly navigationTarget: Accessor<FormNodeID | null>;
 }
 
+const findViolationControl = (
+  reference: DescendantNodeViolationReference
+): AnyControlInstanceNode | null => {
+  const { node } = reference;
+  const target = node.nodeType === 'attribute' ? node.owner : node;
+  if (target instanceof ValueNode && target.nodeType !== 'model-value') {
+    return target;
+  }
+  return null;
+};
+
 export class Root
   extends DescendantNode<RootDefinition, RootStateSpec, PrimaryInstance, GeneralChildNode>
   implements
@@ -221,15 +237,20 @@ export class Root
     return [];
   }
 
-  // Nodes without a page (model-only values) have no leaf page id, so they never block.
+  private isViolationOnPage(reference: DescendantNodeViolationReference, page: PageBoundary) {
+    const control = findViolationControl(reference);
+    return control != null && this.pagination.getLeafPageId(control.nodeId) === page;
+  }
+
+  // Only violations of controls block, other nodes (groups, model-only values) have no page.
   getBlockingViolations(): BlockingViolations {
     const currentPage = this.pageNavigation.currentPage();
     if (currentPage == null) {
       return [];
     }
 
-    return this.validationState.violations.filter(({ nodeId }) => {
-      return this.pagination.getLeafPageId(nodeId) === currentPage;
+    return this.validationState.violations.filter((reference) => {
+      return this.isViolationOnPage(reference, currentPage);
     });
   }
 
@@ -242,17 +263,19 @@ export class Root
   }
 
   navigateToFirstViolation(): void {
-    const violation = this.validationState.violations?.[0];
-    if (violation == null) {
+    const control = this.validationState.violations
+      .map((reference) => findViolationControl(reference))
+      .find((violationControl) => violationControl != null);
+    if (control == null) {
       return;
     }
 
     batch(() => {
-      const page = this.pagination.getLeafPageId(violation.nodeId);
+      const page = this.pagination.getLeafPageId(control.nodeId);
       if (page != null) {
         this.setCurrentPage(page);
       }
-      this.setNavigationTarget(violation.nodeId);
+      this.setNavigationTarget(control.nodeId);
     });
   }
 
diff --git a/packages/xforms-engine/src/instance/abstract/DescendantNode.ts b/packages/xforms-engine/src/instance/abstract/DescendantNode.ts
index 660afeee5..b4f1f0bb8 100644
--- a/packages/xforms-engine/src/instance/abstract/DescendantNode.ts
+++ b/packages/xforms-engine/src/instance/abstract/DescendantNode.ts
@@ -1,6 +1,6 @@
 import { XPathNodeKindKey } from '@getodk/xpath';
 import type { Accessor } from 'solid-js';
-import { createMemo } from 'solid-js';
+import { createMemo, createSignal, untrack } from 'solid-js';
 import type { BaseNode } from '../../client/BaseNode.ts';
 import type { ActiveLanguage } from '../../client/FormLanguage.ts';
 import type { InstanceNodeType } from '../../client/node-types.ts';
@@ -22,11 +22,22 @@ import type { EvaluationContext } from '../internal-api/EvaluationContext.ts';
 import type { RepeatInstance } from '../repeat/RepeatInstance.ts';
 import type { Root } from '../Root.ts';
 import type { InstanceNodeStateSpec } from './InstanceNode.ts';
+import type { AnyViolation } from '../../client/validation.ts';
+import type { Attribute } from '../Attribute.ts';
 import { InstanceNode } from './InstanceNode.ts';
 import { ActionDefinition } from '../../parse/model/ActionDefinition.ts';
 import { SET_GEOPOINT_LOCAL_NAME, SET_VALUE_LOCAL_NAME } from '../../parse/XFormDOM.ts';
 import { XFORM_EVENT } from '../../parse/model/Event.ts';
 
+interface TextErrorState {
+  readonly label?: { readonly error: Error | null } | null;
+  readonly hint?: { readonly error: Error | null } | null;
+}
+
+const isSameViolation = (previous: AnyViolation | null, current: AnyViolation | null) => {
+  return previous?.condition === current?.condition && previous?.message === current?.message;
+};
+
 export interface DescendantNodeSharedStateSpec {
   readonly reference: Accessor<string>;
   readonly readonly: Accessor<boolean>;
@@ -193,6 +204,10 @@ export abstract class DescendantNode<
     this as AnyDescendantNode as PrimaryInstanceXPathChildNode;
   readonly getActiveLanguage: Accessor<ActiveLanguage>;
   readonly valueChangedActions: ActionDefinition[];
+  private readonly expressionErrors: Array<Accessor<Error | null>> = [];
+  private violation: Accessor<AnyViolation | null> | null = null;
+  private staticAttributes: readonly Attribute[] | null = null;
+  private readonly actionError = createSignal<Error | null>(null);
 
   constructor(
     override readonly parent: Parent,
@@ -244,9 +259,10 @@ export abstract class DescendantNode<
     this.isSelfReadonly = createComputedExpression(this, readonly, {
       defaultValue: true,
     });
-    this.isSelfRelevant = createComputedExpression(this, relevant, {
-      defaultValue: false,
+    const isSelfRelevant = createComputedExpression(this, relevant, {
+      defaultValue: true,
     });
+    this.isSelfRelevant = isSelfRelevant;
     this.isRequired = createComputedExpression(this, required, {
       defaultValue: false,
     });
@@ -264,6 +280,71 @@ export abstract class DescendantNode<
       .filter((node) => !!node);
   }
 
+  setActionError(error: Error | null): void {
+    const [, setError] = this.actionError;
+    setError(() => error);
+  }
+
+  registerExpressionError(error: Accessor<Error | null>): void {
+    this.expressionErrors.push(error);
+  }
+
+  protected getTextError(): Error | null {
+    const { label, hint } = this.engineState as TextErrorState;
+    return label?.error ?? hint?.error ?? null;
+  }
+
+  protected getValidationViolation(): AnyViolation | null {
+    return null;
+  }
+
+  private getExpressionError(): Error | null {
+    const errors = this.expressionErrors.map((expressionError) => expressionError());
+    return errors.find((error) => error != null) ?? null;
+  }
+
+  private getReportedError(): Error | null {
+    if (!this.isRelevant()) {
+      return null;
+    }
+    const [getActionError] = this.actionError;
+    return this.getExpressionError() ?? getActionError() ?? this.getTextError();
+  }
+
+  private computeViolation(): AnyViolation | null {
+    const error = this.getReportedError();
+    if (error) {
+      return { condition: 'error', valid: false, message: error.message };
+    }
+    return this.getValidationViolation();
+  }
+
+  // Attributes never change once the node is built, so they are read without tracking.
+  getStaticAttributes(): readonly Attribute[] {
+    this.staticAttributes ??= untrack(() => this.getAttributes());
+    return this.staticAttributes;
+  }
+
+  private hasText(): boolean {
+    const { label, hint } = this.engineState as TextErrorState;
+    return label != null || hint != null;
+  }
+
+  // Whether a node has text never changes, so it is read without tracking the text itself.
+  protected canReportViolation(): boolean {
+    return this.expressionErrors.length > 0 || untrack(() => this.hasText());
+  }
+
+  getViolation(): AnyViolation | null {
+    if (!this.canReportViolation()) {
+      return null;
+    }
+    this.violation ??= this.scope.runTask(() => {
+      return createMemo(() => this.computeViolation(), undefined, { equals: isSameViolation });
+    });
+    return this.violation();
+  }
+
   /**
    * @package
    *
diff --git a/packages/xforms-engine/src/instance/abstract/InstanceNode.ts b/packages/xforms-engine/src/instance/abstract/InstanceNode.ts
index fda020162..07b901eec 100644
--- a/packages/xforms-engine/src/instance/abstract/InstanceNode.ts
+++ b/packages/xforms-engine/src/instance/abstract/InstanceNode.ts
@@ -282,4 +282,5 @@ export abstract class InstanceNode<
   }
 
   abstract getAttributes(): readonly Attribute[];
+  abstract registerExpressionError(error: Accessor<Error | null>): void;
 }
diff --git a/packages/xforms-engine/src/instance/abstract/ValueNode.ts b/packages/xforms-engine/src/instance/abstract/ValueNode.ts
index 485013be6..0f3e4e627 100644
--- a/packages/xforms-engine/src/instance/abstract/ValueNode.ts
+++ b/packages/xforms-engine/src/instance/abstract/ValueNode.ts
@@ -32,6 +32,7 @@ import type { ClientReactiveSerializableValueNode } from '../internal-api/serial
 import type { ValidationContext } from '../internal-api/ValidationContext.ts';
 import type { DescendantNodeStateSpec } from './DescendantNode.ts';
 import { DescendantNode } from './DescendantNode.ts';
+import { TextRange } from '../text/TextRange.ts';
 
 export type ValueNodeDefinition<V extends ValueType> = LeafNodeDefinition<V>;
 
@@ -129,11 +130,21 @@ export abstract class ValueNode<
     };
   }
 
-  // ValidationContext
-  getViolation(): AnyViolation | null {
+  protected override canReportViolation(): boolean {
+    return true;
+  }
+
+  protected override getValidationViolation(): AnyViolation | null {
     return this.validation.engineState.violation;
   }
 
+  override getTextError() {
+    const message = this.validation.engineState.violation?.message;
+    const messageError = message instanceof TextRange ? message.error : null;
+    return super.getTextError() ?? messageError;
+  }
+
+  // ValidationContext
   isBlank(): boolean {
     return this.getInstanceValue() === '';
   }
diff --git a/packages/xforms-engine/src/instance/internal-api/AttributeContext.ts b/packages/xforms-engine/src/instance/internal-api/AttributeContext.ts
index 2109554c7..21265f9f5 100644
--- a/packages/xforms-engine/src/instance/internal-api/AttributeContext.ts
+++ b/packages/xforms-engine/src/instance/internal-api/AttributeContext.ts
@@ -40,4 +40,5 @@ export interface AttributeContext extends EvaluationContext {
 
   isReadonly(): boolean;
   isRelevant(): boolean;
+  setActionError(error: Error | null): void;
 }
diff --git a/packages/xforms-engine/src/instance/internal-api/EvaluationContext.ts b/packages/xforms-engine/src/instance/internal-api/EvaluationContext.ts
index 70482019a..e8e62b119 100644
--- a/packages/xforms-engine/src/instance/internal-api/EvaluationContext.ts
+++ b/packages/xforms-engine/src/instance/internal-api/EvaluationContext.ts
@@ -84,4 +84,6 @@ export interface EvaluationContext extends TranslationContext {
    *   context (itemsets being a prominent example).
    */
   readonly contextNode: EngineXPathNode;
+
+  registerExpressionError(error: Accessor<Error | null>): void;
 }
diff --git a/packages/xforms-engine/src/instance/internal-api/InstanceValueContext.ts b/packages/xforms-engine/src/instance/internal-api/InstanceValueContext.ts
index e6a514e35..5bfad34df 100644
--- a/packages/xforms-engine/src/instance/internal-api/InstanceValueContext.ts
+++ b/packages/xforms-engine/src/instance/internal-api/InstanceValueContext.ts
@@ -40,4 +40,5 @@ export interface InstanceValueContext extends EvaluationContext {
 
   isReadonly(): boolean;
   isRelevant(): boolean;
+  setActionError(error: Error | null): void;
 }
diff --git a/packages/xforms-engine/src/instance/repeat/BaseRepeatRange.ts b/packages/xforms-engine/src/instance/repeat/BaseRepeatRange.ts
index 31e2ffbdf..4f1d9cada 100644
--- a/packages/xforms-engine/src/instance/repeat/BaseRepeatRange.ts
+++ b/packages/xforms-engine/src/instance/repeat/BaseRepeatRange.ts
@@ -290,6 +290,15 @@ export abstract class BaseRepeatRange<Definition extends AnyRepeatDefinition>
     });
   }
 
+  private getInstanceLabelError(): Error | null {
+    const errors = this.getChildren().map((instance) => instance.getLabelError());
+    return errors.find((error) => error != null) ?? null;
+  }
+
+  protected override getTextError(): Error | null {
+    return super.getTextError() ?? this.getInstanceLabelError();
+  }
+
   getChildren(): readonly RepeatInstance[] {
     return this.childrenState.getChildren();
   }
diff --git a/packages/xforms-engine/src/instance/repeat/RepeatInstance.ts b/packages/xforms-engine/src/instance/repeat/RepeatInstance.ts
index ec47c5aed..600303e85 100644
--- a/packages/xforms-engine/src/instance/repeat/RepeatInstance.ts
+++ b/packages/xforms-engine/src/instance/repeat/RepeatInstance.ts
@@ -195,6 +195,15 @@ export class RepeatInstance
     this.instanceState = createTemplatedNodeInstanceState(this);
   }
 
+  getLabelError(): Error | null {
+    return super.getTextError();
+  }
+
+  // The label error is reported once, by the repeat range.
+  protected override getTextError(): Error | null {
+    return null;
+  }
+
   getChildren(): readonly GeneralChildNode[] {
     return this.childrenState.getChildren();
   }
diff --git a/packages/xforms-engine/src/instance/repeat/RepeatRangeControlled.ts b/packages/xforms-engine/src/instance/repeat/RepeatRangeControlled.ts
index d5a3ebd9e..a9705a362 100644
--- a/packages/xforms-engine/src/instance/repeat/RepeatRangeControlled.ts
+++ b/packages/xforms-engine/src/instance/repeat/RepeatRangeControlled.ts
@@ -54,11 +54,9 @@ export class RepeatRangeControlled
       );
 
       const computeCount = createComputedExpression(this, count, { defaultValue: 0 });
-      createComputed(
-        (previousCount: number) =>
-          this.applyCountChange(previousCount, computeCount(), savedNodes, template),
-        seededCount
-      );
+      createComputed((previousCount: number) => {
+        return this.applyCountChange(previousCount, computeCount(), savedNodes, template);
+      }, seededCount);
     });
   }
 
diff --git a/packages/xforms-engine/src/instance/text/TextRange.ts b/packages/xforms-engine/src/instance/text/TextRange.ts
index dbd25d25a..6b80ce885 100644
--- a/packages/xforms-engine/src/instance/text/TextRange.ts
+++ b/packages/xforms-engine/src/instance/text/TextRange.ts
@@ -38,6 +38,7 @@ export class TextRange<Role extends TextRole> implements ClientTextRange<Role> {
   constructor(
     readonly role: Role,
     protected readonly chunks: readonly TextChunk[],
-    protected readonly mediaSources?: MediaSources
+    protected readonly mediaSources?: MediaSources,
+    readonly error: Error | null = null
   ) {}
 }
diff --git a/packages/xforms-engine/src/integration/xpath/EngineXPathEvaluator.ts b/packages/xforms-engine/src/integration/xpath/EngineXPathEvaluator.ts
index 54baf0f06..dfc4d492d 100644
--- a/packages/xforms-engine/src/integration/xpath/EngineXPathEvaluator.ts
+++ b/packages/xforms-engine/src/integration/xpath/EngineXPathEvaluator.ts
@@ -1,10 +1,16 @@
-import type { XFormsItextTranslationMap, XFormsSecondaryInstanceMap } from '@getodk/xpath';
+import type {
+  EvaluatorConvenienceMethodOptions,
+  XFormsItextTranslationLanguage,
+  XFormsItextTranslationMap,
+  XFormsSecondaryInstanceMap,
+} from '@getodk/xpath';
 import { XFormsXPathEvaluator } from '@getodk/xpath';
 import type { PrimaryInstance } from '../../instance/PrimaryInstance.ts';
 import type { ItextTranslationRootDefinition } from '../../parse/model/ItextTranslationsDefinition.ts';
 import type { SecondaryInstanceRootDefinition } from '../../parse/model/SecondaryInstance/SecondaryInstancesDefinition.ts';
 import { engineDOMAdapter } from './adapter/engineDOMAdapter.ts';
 import type { EngineXPathNode } from './adapter/kind.ts';
+import type { DependentExpressionResultType } from '../../parse/expression/abstract/DependentExpression.ts';
 
 interface EngineXPathEvaluatorOptions {
   readonly rootNode: PrimaryInstance;
@@ -12,11 +18,111 @@ interface EngineXPathEvaluatorOptions {
   readonly secondaryInstancesById: XFormsSecondaryInstanceMap<SecondaryInstanceRootDefinition>;
 }
 
-export class EngineXPathEvaluator extends XFormsXPathEvaluator<EngineXPathNode> {
+export interface ComputedExpressionResults {
+  readonly boolean: boolean;
+  readonly nodes: EngineXPathNode[];
+  readonly number: number;
+  readonly string: string;
+}
+
+export interface Result<Type extends DependentExpressionResultType> {
+  readonly success: boolean;
+  readonly value: ComputedExpressionResults[Type] | null;
+  readonly error: Error | null;
+}
+
+export class Success<Type extends DependentExpressionResultType> implements Result<Type> {
+  readonly success = true;
+  readonly value: ComputedExpressionResults[Type];
+  readonly error = null;
+
+  constructor(value: ComputedExpressionResults[Type]) {
+    this.value = value;
+  }
+}
+
+export class Failure<Type extends DependentExpressionResultType> implements Result<Type> {
+  readonly success = false;
+  readonly value = null;
+  readonly error: Error;
+
+  constructor(error: Error) {
+    this.error = error;
+  }
+}
+
+/**
+ * A wrapper around the xpath Evaluator that returns Result objects instead of values and errors.
+ */
+export class EngineXPathEvaluator {
+  readonly xpathEvaluator: XFormsXPathEvaluator<EngineXPathNode>;
+
   constructor(options: EngineXPathEvaluatorOptions) {
-    super({
+    this.xpathEvaluator = new XFormsXPathEvaluator({
       domAdapter: engineDOMAdapter,
       ...options,
     });
   }
+
+  evaluateString(
+    expression: string,
+    options?: EvaluatorConvenienceMethodOptions<EngineXPathNode>
+  ): Result<'string'> {
+    try {
+      return new Success<'string'>(this.xpathEvaluator.evaluateString(expression, options));
+    } catch (e) {
+      return new Failure(e as Error);
+    }
+  }
+
+  evaluateNumber(
+    expression: string,
+    options?: EvaluatorConvenienceMethodOptions<EngineXPathNode>
+  ): Result<'number'> {
+    try {
+      return new Success<'number'>(this.xpathEvaluator.evaluateNumber(expression, options));
+    } catch (e) {
+      return new Failure(e as Error);
+    }
+  }
+
+  evaluateNodes(
+    expression: string,
+    options?: EvaluatorConvenienceMethodOptions<EngineXPathNode>
+  ): Result<'nodes'> {
+    try {
+      return new Success<'nodes'>(this.xpathEvaluator.evaluateNodes(expression, options));
+    } catch (e) {
+      return new Failure(e as Error);
+    }
+  }
+
+  evaluateBoolean(
+    expression: string,
+    options?: EvaluatorConvenienceMethodOptions<EngineXPathNode>
+  ): Result<'boolean'> {
+    try {
+      return new Success<'boolean'>(this.xpathEvaluator.evaluateBoolean(expression, options));
+    } catch (e) {
+      return new Failure(e as Error);
+    }
+  }
+
+  setActiveLanguage(
+    language: XFormsItextTranslationLanguage | null
+  ): XFormsItextTranslationLanguage | null {
+    return this.xpathEvaluator.setActiveLanguage(language);
+  }
+
+  getActiveLanguage(): XFormsItextTranslationLanguage | null {
+    return this.xpathEvaluator.getActiveLanguage();
+  }
+
+  getExplicitDefaultLanguage(): XFormsItextTranslationLanguage | null {
+    return this.xpathEvaluator.getExplicitDefaultLanguage();
+  }
+
+  getLanguages(): readonly XFormsItextTranslationLanguage[] {
+    return this.xpathEvaluator.getLanguages();
+  }
 }
diff --git a/packages/xforms-engine/src/lib/reactivity/createComputedExpression.ts b/packages/xforms-engine/src/lib/reactivity/createComputedExpression.ts
index e923995ef..d33d9f102 100644
--- a/packages/xforms-engine/src/lib/reactivity/createComputedExpression.ts
+++ b/packages/xforms-engine/src/lib/reactivity/createComputedExpression.ts
@@ -3,7 +3,7 @@ import type { Accessor } from 'solid-js';
 import { createMemo } from 'solid-js';
 import type { EvaluationContext } from '../../instance/internal-api/EvaluationContext.ts';
 import type { EngineXPathNode } from '../../integration/xpath/adapter/kind.ts';
-import type { EngineXPathEvaluator } from '../../integration/xpath/EngineXPathEvaluator.ts';
+import type { EngineXPathEvaluator, Result } from '../../integration/xpath/EngineXPathEvaluator.ts';
 import type {
   DependentExpression,
   DependentExpressionResultType,
@@ -17,15 +17,12 @@ interface ComputedExpressionResults {
   readonly string: string;
 }
 
-// prettier-ignore
-type EvaluatedExpression<
-	Type extends DependentExpressionResultType
-> = ComputedExpressionResults[Type];
+type EvaluatedExpression<Type extends DependentExpressionResultType> =
+  ComputedExpressionResults[Type];
 
-// prettier-ignore
-type ExpressionEvaluator<
-	Type extends DependentExpressionResultType
-> = (defaultValue?: EvaluatedExpression<Type>) => EvaluatedExpression<Type>;
+type ExpressionEvaluator<Type extends DependentExpressionResultType> = (
+  defaultValue?: EvaluatedExpression<Type>
+) => Result<Type>;
 
 interface ExpressionEvaluatorOptions {
   get contextNode(): EngineXPathNode;
@@ -83,11 +80,36 @@ const defaultEvaluationsByType: DefaultEvaluationsByType = {
   string: DEFAULT_STRING_EVALUATION,
 };
 
-// prettier-ignore
-type ComputedExpression<Type extends DependentExpressionResultType> = Accessor<
-	EvaluatedExpression<Type>
+export type ComputedExpression<Type extends DependentExpressionResultType> = Accessor<
+  EvaluatedExpression<Type>
 >;
 
+const isSameEvaluation = <Type extends DependentExpressionResultType>(
+  previous: Result<Type>,
+  current: Result<Type>
+): boolean => {
+  return previous.value === current.value && previous.error?.message === current.error?.message;
+};
+
+const evaluateOrFallback = <Type extends DependentExpressionResultType>(
+  evaluate: ExpressionEvaluator<Type>,
+  fallback: EvaluatedExpression<Type>,
+  isAttached: boolean
+): Result<Type> => {
+  if (isAttached) {
+    const result = evaluate();
+    if (result.success) {
+      return { success: true, value: result.value, error: null };
+    }
+    return { success: false, value: fallback, error: result.error };
+  }
+  const fallbackResult = evaluate(fallback);
+  if (fallbackResult.success) {
+    return { success: true, value: fallbackResult.value, error: null };
+  }
+  return { success: true, value: fallback, error: null };
+};
+
 interface CreateComputedExpressionOptions<Type extends DependentExpressionResultType> {
   /**
    * If a default value is provided, {@link createComputedExpression} will
@@ -105,36 +127,71 @@ interface CreateComputedExpressionOptions<Type extends DependentExpressionResult
   readonly defaultValue?: EvaluatedExpression<Type>;
 }
 
+const createConstantExpression = <Type extends DependentExpressionResultType>(
+  context: EvaluationContext,
+  evaluation: Result<Type>
+): ComputedExpression<Type> => {
+  const error = () => evaluation.error;
+  if (evaluation.error) {
+    context.registerExpressionError(error);
+  }
+  return () => evaluation.value!;
+};
+
+const evaluateInContext = <Type extends DependentExpressionResultType>(
+  context: EvaluationContext,
+  dependentExpression: DependentExpression<Type>,
+  options: CreateComputedExpressionOptions<Type>
+): Result<Type> => {
+  const { contextNode, evaluator } = context;
+  const { expression, isTranslated, resultType } = dependentExpression;
+  const evaluate = expressionEvaluator(evaluator, resultType, expression, { contextNode });
+  const fallback = options.defaultValue ?? defaultEvaluationsByType[resultType];
+
+  if (isConstantExpression(expression)) {
+    return evaluateOrFallback(evaluate, fallback, true);
+  }
+  if (isTranslated) {
+    context.getActiveLanguage();
+  }
+  return evaluateOrFallback(evaluate, fallback, context.isAttached());
+};
+
+// Evaluates in the computation of the caller, which tracks the dependencies and reads the error.
+export const evaluateExpression = <Type extends DependentExpressionResultType>(
+  context: EvaluationContext,
+  dependentExpression: DependentExpression<Type>
+): Result<Type> => {
+  return evaluateInContext(context, dependentExpression, {});
+};
+
+const createReactiveExpression = <Type extends DependentExpressionResultType>(
+  context: EvaluationContext,
+  dependentExpression: DependentExpression<Type>,
+  options: CreateComputedExpressionOptions<Type>
+): ComputedExpression<Type> => {
+  const evaluation = createMemo(
+    () => evaluateInContext(context, dependentExpression, options),
+    undefined,
+    { equals: isSameEvaluation }
+  );
+  const error = () => evaluation().error;
+  context.registerExpressionError(error);
+
+  return () => evaluation().value!;
+};
+
 export const createComputedExpression = <Type extends DependentExpressionResultType>(
   context: EvaluationContext,
   dependentExpression: DependentExpression<Type>,
   options: CreateComputedExpressionOptions<Type> = {}
 ): ComputedExpression<Type> => {
-  return context.scope.runTask(() => {
-    const { contextNode, evaluator } = context;
-    const { expression, isTranslated, resultType } = dependentExpression;
-    const evaluateExpression = expressionEvaluator(evaluator, resultType, expression, {
-      contextNode,
-    });
-
-    if (isConstantExpression(expression)) {
-      return createMemo(() => evaluateExpression());
-    }
+  if (isConstantExpression(dependentExpression.expression)) {
+    const evaluation = evaluateInContext(context, dependentExpression, options);
+    return createConstantExpression(context, evaluation);
+  }
 
-    return createMemo(() => {
-      if (isTranslated) {
-        context.getActiveLanguage();
-      }
-      if (context.isAttached()) {
-        return evaluateExpression();
-      }
-      const defaultValue = options?.defaultValue ?? defaultEvaluationsByType[resultType];
-      try {
-        return evaluateExpression(defaultValue);
-      } catch {
-        // likely because it's not yet attached - try again later
-        return defaultValue;
-      }
-    });
+  return context.scope.runTask(() => {
+    return createReactiveExpression(context, dependentExpression, options);
   });
 };
diff --git a/packages/xforms-engine/src/lib/reactivity/createInstanceValueState.ts b/packages/xforms-engine/src/lib/reactivity/createInstanceValueState.ts
index 042b35117..091a279de 100644
--- a/packages/xforms-engine/src/lib/reactivity/createInstanceValueState.ts
+++ b/packages/xforms-engine/src/lib/reactivity/createInstanceValueState.ts
@@ -13,6 +13,7 @@ import type { SimpleAtomicState, SimpleAtomicStateSetter } from './types.ts';
 import { ValueNode } from '../../instance/abstract/ValueNode.ts';
 import { Attribute } from '../../instance/Attribute.ts';
 import type { AnyValueNode } from '../../instance/hierarchy.ts';
+import type { EvaluationContext } from '../../instance/internal-api/EvaluationContext.ts';
 import { getInstanceDefaultValue } from '../instance-defaults.ts';
 
 const REPEAT_INDEX_REGEX = /([^[]*)(\[[0-9]+\])/g;
@@ -73,7 +74,7 @@ const createRelevantValueState = (
 };
 
 /**
- * Rejects downstream (client/user) writes while the field is in a `readonly` state.
+ * Ignores downstream (client/user) writes while the field is in a `readonly` state.
  * Engine writes (`calculate` computations, preloads, `setvalue` actions) never pass through this guard.
  */
 const guardDownstreamReadonlyWrites = (
@@ -90,9 +91,7 @@ const guardDownstreamReadonlyWrites = (
 
   const setValue: SimpleAtomicStateSetter<string> = (value) => {
     if (context.isReadonly()) {
-      const reference = untrack(() => context.contextReference());
-
-      throw new Error(`Cannot write to readonly field: ${reference}`);
+      return untrack(() => getValue());
     }
 
     return baseSetValue(value);
@@ -101,6 +100,20 @@ const guardDownstreamReadonlyWrites = (
   return [getValue, setValue];
 };
 
+const clearActionErrorOnClientWrite = (
+  context: ValueContext,
+  baseState: SimpleAtomicState<string>
+): SimpleAtomicState<string> => {
+  const [getValue, baseSetValue] = baseState;
+
+  const setValue: SimpleAtomicStateSetter<string> = (value) => {
+    context.setActionError(null);
+    return baseSetValue(value);
+  };
+
+  return [getValue, setValue];
+};
+
 const setValueIfPreloadDefined = (
   context: ValueContext,
   setValue: SimpleAtomicStateSetter<string>,
@@ -148,9 +161,13 @@ const preloadValue = (context: ValueContext, setValue: SimpleAtomicStateSetter<s
 };
 
 const referencesCurrentNode = (context: ValueContext, ref: string): boolean => {
-  const nodes = context.evaluator.evaluateNodes(ref, {
+  const result = context.evaluator.evaluateNodes(ref, {
     contextNode: context.contextNode,
   });
+  if (result.error) {
+    throw result.error;
+  }
+  const nodes = result.value!;
   if (nodes.length > 1) {
     throw new Error(
       'You are trying to target a repeated field. Currently you may only target a field in a specific repeat instance. XPath nodeset has more than one node.'
@@ -196,6 +213,16 @@ const createCalculation = (
   });
 };
 
+const computeActionValue = (
+  target: ValueContext,
+  expression: string,
+  evaluationContext: EvaluationContext
+): string => {
+  const result = untrack(() => target.evaluator.evaluateString(expression, evaluationContext));
+  target.setActionError(result.error);
+  return result.value ?? '';
+};
+
 /**
  * Runs the computation without maintaining a reactive listener, so
  * actions that should run only at a specific time are not triggered
@@ -213,9 +240,7 @@ const createActionCalculation = (
       if (!relevant) {
         return;
       }
-      const calculated = untrack(() => {
-        return context.evaluator.evaluateString(computation.expression, context);
-      });
+      const calculated = computeActionValue(context, computation.expression, context);
       const value = context.decodeInstanceValue(calculated);
       setRelevantValue(value);
     }
@@ -280,9 +305,14 @@ const registerValueChangedActions = (context: ValueContext, getValue: Accessor<s
     const sourceValue = getValue();
     context.valueChangedActions.forEach((action) => {
       const ref = bindRefToRepeatInstance(context, action.ref);
-      const destinationNodes = context.evaluator.evaluateNodes(ref, {
+      const result = context.evaluator.evaluateNodes(ref, {
         contextNode: context.contextNode,
       });
+      if (result.error) {
+        context.setActionError(result.error);
+        return;
+      }
+      const destinationNodes = result.value!;
       if (!destinationNodes.length) {
         return;
       }
@@ -300,12 +330,11 @@ const registerValueChangedActions = (context: ValueContext, getValue: Accessor<s
           if (action.type === 'geopoint') {
             getGeopointValue(context, (point) => destinationNode.setEncodedValue(point, true));
           } else {
-            const value = untrack(() => {
-              return context.evaluator.evaluateString(
-                action.computation.expression,
-                destinationNode
-              );
-            });
+            const value = computeActionValue(
+              destinationNode,
+              action.computation.expression,
+              destinationNode
+            );
             destinationNode.setEncodedValue(value, true);
           }
         }
@@ -316,7 +345,7 @@ const registerValueChangedActions = (context: ValueContext, getValue: Accessor<s
 };
 
 export interface InstanceValueState {
-  // The node's instance value. The setter rejects client writes while readonly.
+  // The node's instance value. The setter ignores client writes while readonly.
   readonly valueState: SimpleAtomicState<string>;
   // Unguarded setter for the same value, used by `xforms-value-changed` actions writing to this node.
   readonly setValueFromAction: SimpleAtomicStateSetter<string>;
@@ -353,7 +382,10 @@ export const createInstanceValueState = (context: ValueContext): InstanceValueSt
     registerSetValueActions(context, setValue);
 
     return {
-      valueState: guardDownstreamReadonlyWrites(context, relevantValueState),
+      valueState: guardDownstreamReadonlyWrites(
+        context,
+        clearActionErrorOnClientWrite(context, relevantValueState)
+      ),
       setValueFromAction: setValue,
     };
   });
diff --git a/packages/xforms-engine/src/lib/reactivity/createItemCollection.ts b/packages/xforms-engine/src/lib/reactivity/createItemCollection.ts
index a6f023b66..6e24dc0f0 100644
--- a/packages/xforms-engine/src/lib/reactivity/createItemCollection.ts
+++ b/packages/xforms-engine/src/lib/reactivity/createItemCollection.ts
@@ -14,11 +14,28 @@ import type { EngineXPathNode } from '../../integration/xpath/adapter/kind.ts';
 import type { EngineXPathEvaluator } from '../../integration/xpath/EngineXPathEvaluator.ts';
 import type { ItemDefinition } from '../../parse/body/control/ItemDefinition.ts';
 import type { ItemsetDefinition } from '../../parse/body/control/ItemsetDefinition.ts';
-import { createComputedExpression } from './createComputedExpression.ts';
+import { createComputedExpression, type ComputedExpression } from './createComputedExpression.ts';
 import type { ReactiveScope } from './scope.ts';
 import { createTextRange } from './text/createTextRange.ts';
 
 type ItemCollectionControl = RankControl | SelectControl;
+
+const contextError = (context: ItemsetItemEvaluationContext): Error | null => {
+  return context.expressionErrors.map((error) => error()).find(Boolean) ?? null;
+};
+
+const labelError = (label: ClientTextRange<'item-label'>): Error | null => {
+  return label instanceof TextRange ? label.error : null;
+};
+
+type ItemProperty = [string, ComputedExpression<'string'>];
+
+const registerItemsError = (
+  control: ItemCollectionControl,
+  errors: Accessor<Array<Error | null>>
+) => {
+  control.registerExpressionError(createMemo(() => errors().find(Boolean) ?? null));
+};
 type DerivedItemLabel = ClientTextRange<'item-label'>;
 
 const derivedItemLabel = (context: TranslationContext, value: string): DerivedItemLabel => {
@@ -56,9 +73,12 @@ const createTranslatedStaticItems = (
       });
     });
 
-    return createMemo(() => {
+    const computedItems = createMemo(() => {
       return labeledItems.map((item) => item());
     });
+    registerItemsError(control, () => computedItems().map((item) => labelError(item.label)));
+
+    return computedItems;
   });
 };
 
@@ -68,9 +88,10 @@ class ItemsetItemEvaluationContext implements EvaluationContext {
   readonly evaluator: EngineXPathEvaluator;
   readonly contextReference: Accessor<string>;
   readonly getActiveLanguage: Accessor<ActiveLanguage>;
+  readonly expressionErrors: Array<Accessor<Error | null>> = [];
 
   constructor(
-    control: ItemCollectionControl,
+    readonly control: ItemCollectionControl,
     readonly contextNode: EngineXPathNode
   ) {
     this.isAttached = control.isAttached;
@@ -79,6 +100,10 @@ class ItemsetItemEvaluationContext implements EvaluationContext {
     this.contextReference = control.contextReference;
     this.getActiveLanguage = control.getActiveLanguage;
   }
+
+  registerExpressionError(error: Accessor<Error | null>) {
+    this.expressionErrors.push(error);
+  }
 }
 
 const createItemsetItemLabel = (
@@ -101,6 +126,7 @@ interface ItemsetItem {
   label(): ClientTextRange<'item-label'>;
   value(): string;
   properties: Array<[string, () => string]>;
+  context: ItemsetItemEvaluationContext;
 }
 
 const MAX_CHANGES_PER_UPDATE = 100;
@@ -161,16 +187,16 @@ const createItemsetItems = (
             .getXPathChildNodes()
             .filter((node) => node.nodeType === 'static-element');
           const properties = itemset.getPropertiesExpressions(nodeElements).map((expression) => {
-            return [expression.toString(), createComputedExpression(context, expression)] as [
-              string,
-              () => string,
-            ];
+            return [
+              expression.toString(),
+              createComputedExpression(context, expression),
+            ] as ItemProperty;
           });
-
           return {
             label,
             value,
             properties,
+            context,
           };
         });
       });
@@ -180,12 +206,11 @@ const createItemsetItems = (
 
 const createItemset = (
   control: ItemCollectionControl,
-  itemset: ItemsetDefinition
+  definition: ItemsetDefinition
 ): Accessor<readonly BaseItem[]> => {
   return control.scope.runTask(() => {
-    const itemsetItems = createItemsetItems(control, itemset);
-
-    return createMemo(() => {
+    const itemsetItems = createItemsetItems(control, definition);
+    const itemset = createMemo(() => {
       return itemsetItems().map((item) => {
         return {
           label: item.label(),
@@ -196,6 +221,10 @@ const createItemset = (
         };
       });
     });
+    registerItemsError(control, () => {
+      return itemsetItems().map((item) => labelError(item.label()) ?? contextError(item.context));
+    });
+    return itemset;
   });
 };
 
diff --git a/packages/xforms-engine/src/lib/reactivity/createNoteReadonlyThunk.ts b/packages/xforms-engine/src/lib/reactivity/createNoteReadonlyThunk.ts
index f630c1074..d795b9c15 100644
--- a/packages/xforms-engine/src/lib/reactivity/createNoteReadonlyThunk.ts
+++ b/packages/xforms-engine/src/lib/reactivity/createNoteReadonlyThunk.ts
@@ -15,8 +15,6 @@ export const createNoteReadonlyThunk = (
     throw new Error('Expected a static readonly expression');
   }
 
-  let result = true;
-
   if (import.meta.env.DEV) {
     const { expression } = readonly;
     const dependencyReferences = resolveDependencyNodesets(reference, expression);
@@ -27,12 +25,10 @@ export const createNoteReadonlyThunk = (
 
     const computedExpression = createComputedExpression(context, readonly);
 
-    result = computedExpression();
-
-    if (result !== true) {
+    if (computedExpression() !== true) {
       throw new Error(`Expected expression ${readonly.expression} to return true`);
     }
   }
 
-  return () => result;
+  return () => true;
 };
diff --git a/packages/xforms-engine/src/lib/reactivity/materializeCurrentStateChildren.ts b/packages/xforms-engine/src/lib/reactivity/materializeCurrentStateChildren.ts
index 3ce0f3899..a1b3663ac 100644
--- a/packages/xforms-engine/src/lib/reactivity/materializeCurrentStateChildren.ts
+++ b/packages/xforms-engine/src/lib/reactivity/materializeCurrentStateChildren.ts
@@ -107,7 +107,7 @@ export const materializeCurrentStateChildren = <
   return new Proxy(proxyTarget, {
     get(_, key) {
       if (key === 'children') {
-        const expectedChildIDs = scope.runTask(() => currentState.children);
+        const expectedChildIDs = scope.runTask(() => currentState.children); // side effect: registers reactive updates
         const children = childrenState.getChildren();
 
         if (import.meta.env.DEV) {
diff --git a/packages/xforms-engine/src/lib/reactivity/text/createTextRange.ts b/packages/xforms-engine/src/lib/reactivity/text/createTextRange.ts
index 29b6b305b..181ebfcfb 100644
--- a/packages/xforms-engine/src/lib/reactivity/text/createTextRange.ts
+++ b/packages/xforms-engine/src/lib/reactivity/text/createTextRange.ts
@@ -13,20 +13,47 @@ import { TextChunk } from '../../../instance/text/TextChunk.ts';
 import { TextRange, type MediaSources } from '../../../instance/text/TextRange.ts';
 import { TextChunkExpression } from '../../../parse/expression/TextChunkExpression.ts';
 import type { TextRangeDefinition } from '../../../parse/text/abstract/TextRangeDefinition.ts';
-import { createComputedExpression } from '../createComputedExpression.ts';
+import { evaluateExpression } from '../createComputedExpression.ts';
 
 interface ChunksAndMedia {
   chunks: readonly TextChunk[];
   mediaSources: MediaSources;
+  error: Error | null;
 }
 
-const generateResourceChunk = (context: EvaluationContext, child: Element, type: ResourceType) => {
+const computeChunk = (
+  context: EvaluationContext,
+  expression: TextChunkExpression<'string'>,
+  errors: Error[]
+): string => {
+  const { value, error } = evaluateExpression(context, expression);
+  if (error) {
+    errors.push(error);
+  }
+  return value!;
+};
+
+const computeItextId = (context: EvaluationContext, expression: string, errors: Error[]) => {
+  const result = context.evaluator.evaluateString(expression, { contextNode: context.contextNode });
+  if (result.error) {
+    errors.push(result.error);
+    return null;
+  }
+  return result.value;
+};
+
+const generateResourceChunk = (
+  context: EvaluationContext,
+  child: Element,
+  type: ResourceType,
+  errors: Error[]
+) => {
   const parts = [];
   for (const grandchild of child.childNodes) {
     if (isElementNode(grandchild)) {
       const expression = TextChunkExpression.fromOutput(grandchild);
       if (expression) {
-        parts.push(createComputedExpression(context, expression)());
+        parts.push(computeChunk(context, expression, errors));
       }
     } else if (isTextNode(grandchild)) {
       parts.push(grandchild.data);
@@ -48,13 +75,14 @@ const generateChunk = (node: Node): TextChunkExpression<'string'> | null => {
 
 const generateChunksForTranslation = (
   context: EvaluationContext,
-  textElement: Element
+  textElement: Element,
+  errors: Error[]
 ): Array<TextChunkExpression<'string'>> => {
   const chunks = [];
   for (const child of textElement.children) {
     const formAttribute = child.getAttribute('form') as ResourceType;
     if (isResourceType(formAttribute)) {
-      chunks.push(generateResourceChunk(context, child, formAttribute));
+      chunks.push(generateResourceChunk(context, child, formAttribute, errors));
     } else {
       for (const grandchild of child.childNodes) {
         const chunk = generateChunk(grandchild);
@@ -69,18 +97,20 @@ const generateChunksForTranslation = (
 
 const getChunkExpressions = <Role extends TextRole>(
   context: EvaluationContext,
-  definition: TextRangeDefinition<Role>
+  definition: TextRangeDefinition<Role>,
+  errors: Error[]
 ): ReadonlyArray<TextChunkExpression<'string'>> => {
   if (definition.chunks[0]?.source !== 'translation') {
     // only translations have 'nodes' chunks
     return definition.chunks as Array<TextChunkExpression<'string'>>;
   }
-  const itextId = context.evaluator.evaluateString(definition.chunks[0].toString()!, {
-    contextNode: context.contextNode,
-  });
+  const itextId = computeItextId(context, definition.chunks[0].toString()!, errors);
+  if (itextId == null) {
+    return [];
+  }
   const lang = context.getActiveLanguage();
   const elem = definition.form.model.getItextElement(lang, itextId);
-  return elem ? generateChunksForTranslation(context, elem) : [];
+  return elem ? generateChunksForTranslation(context, elem, errors) : [];
 };
 
 /**
@@ -98,7 +128,8 @@ const createTextChunks = <Role extends TextRole>(
 ): ChunksAndMedia => {
   const chunks: TextChunk[] = [];
   const mediaSources: MediaSources = {};
-  const chunkExpressions = getChunkExpressions(context, definition);
+  const errors: Error[] = [];
+  const chunkExpressions = getChunkExpressions(context, definition, errors);
   chunkExpressions.forEach((chunkExpression) => {
     if (chunkExpression.resourceType) {
       const url = chunkExpression.stringValue?.trim();
@@ -113,10 +144,10 @@ const createTextChunks = <Role extends TextRole>(
       return;
     }
 
-    const computed = createComputedExpression(context, chunkExpression)();
+    const computed = computeChunk(context, chunkExpression, errors);
     chunks.push(new TextChunk(context, chunkExpression.source, computed));
   });
-  return { chunks, mediaSources };
+  return { chunks, mediaSources, error: errors[0] ?? null };
 };
 
 type ComputedFormTextRange<Role extends TextRole> = Accessor<TextRange<Role>>;
@@ -135,7 +166,7 @@ export const createTextRange = <Role extends TextRole>(
   return context.scope.runTask(() => {
     return createMemo(() => {
       const chunks = createTextChunks(context, definition);
-      return new TextRange(role, chunks.chunks, chunks.mediaSources);
+      return new TextRange(role, chunks.chunks, chunks.mediaSources, chunks.error);
     });
   });
 };
diff --git a/packages/xforms-engine/src/lib/reactivity/validation/createAggregatedViolations.ts b/packages/xforms-engine/src/lib/reactivity/validation/createAggregatedViolations.ts
index 475a354f9..af1c52c75 100644
--- a/packages/xforms-engine/src/lib/reactivity/validation/createAggregatedViolations.ts
+++ b/packages/xforms-engine/src/lib/reactivity/validation/createAggregatedViolations.ts
@@ -4,53 +4,47 @@ import type {
   AncestorNodeValidationState,
   DescendantNodeViolationReference,
 } from '../../../client/validation.ts';
-import type { AnyParentNode, AnyValueNode } from '../../../instance/hierarchy.ts';
+import type { Attribute } from '../../../instance/Attribute.ts';
+import type { PrimaryInstance } from '../../../instance/PrimaryInstance.ts';
+import type { AnyChildNode, AnyParentNode } from '../../../instance/hierarchy.ts';
 import { createSharedNodeState } from '../node-state/createSharedNodeState.ts';
 
-const violationReference = (node: AnyValueNode): DescendantNodeViolationReference | null => {
-  const violation = node.getViolation();
+type ViolationReferences = DescendantNodeViolationReference[];
 
-  if (violation == null) {
-    return null;
-  }
+type ReportingNode = Exclude<AnyChildNode | AnyParentNode, PrimaryInstance>;
 
-  const { nodeId } = node;
+const addViolation = (node: Attribute | ReportingNode, references: ViolationReferences): void => {
+  const violation = node.getViolation();
+  if (!violation) {
+    return;
+  }
 
-  return {
-    nodeId,
+  references.push({
+    nodeId: node.nodeId,
+    get node() {
+      return node;
+    },
     get reference() {
       return node.currentState.reference;
     },
     violation,
-  };
+  });
 };
 
-const collectViolationReferences = (
-  context: AnyParentNode
-): readonly DescendantNodeViolationReference[] => {
-  return context.getChildren().flatMap((child) => {
-    switch (child.nodeType) {
-      case 'model-value':
-      case 'input':
-      case 'note':
-      case 'select':
-      case 'range':
-      case 'rank':
-      case 'trigger':
-      case 'upload': {
-        const reference = violationReference(child);
-
-        if (reference == null) {
-          return [];
-        }
-
-        return [reference];
-      }
+const addViolations = (node: ReportingNode, references: ViolationReferences): void => {
+  addViolation(node, references);
+  node.getStaticAttributes().forEach((attribute) => addViolation(attribute, references));
+  node.getChildren().forEach((child) => addViolations(child, references));
+};
 
-      default:
-        return collectViolationReferences(child);
-    }
-  });
+const collectViolationReferences = (context: AnyParentNode): ViolationReferences => {
+  const references: ViolationReferences = [];
+  if (context.nodeType === 'primary-instance') {
+    context.getChildren().forEach((child) => addViolations(child, references));
+  } else {
+    addViolations(context, references);
+  }
+  return references;
 };
 
 interface AggregatedViolationsOptions {
diff --git a/packages/xforms-engine/src/lib/reactivity/validation/createValidation.ts b/packages/xforms-engine/src/lib/reactivity/validation/createValidation.ts
index f3163f65f..9e9ac7cf6 100644
--- a/packages/xforms-engine/src/lib/reactivity/validation/createValidation.ts
+++ b/packages/xforms-engine/src/lib/reactivity/validation/createValidation.ts
@@ -5,7 +5,6 @@ import type {
   AnyViolation,
   ConditionSatisfied,
   ConditionValidation,
-  ConditionViolation,
   ValidationCondition,
 } from '../../../client/validation.ts';
 import type { ValidationContext } from '../../../instance/internal-api/ValidationContext.ts';
@@ -102,13 +101,10 @@ const createRequiredValidation = (
   });
 };
 
-type OptionalViolation<Condition extends ValidationCondition> =
-  Accessor<ConditionViolation<Condition> | null>;
-
 const createComputedViolation = <Condition extends ValidationCondition>(
   scope: ReactiveScope,
   validateCondition: ComputedConditionValidation<Condition>
-): OptionalViolation<Condition> => {
+): Accessor<AnyViolation | null> => {
   return scope.runTask(() => {
     return createMemo(() => {
       const validation = validateCondition();
diff --git a/packages/xforms-engine/src/parse/model/BindPreloadDefinition.ts b/packages/xforms-engine/src/parse/model/BindPreloadDefinition.ts
index 9e0269666..531018e16 100644
--- a/packages/xforms-engine/src/parse/model/BindPreloadDefinition.ts
+++ b/packages/xforms-engine/src/parse/model/BindPreloadDefinition.ts
@@ -5,6 +5,7 @@ import type { InstanceValueContext } from '../../instance/internal-api/InstanceV
 import type { BindDefinition } from './BindDefinition.ts';
 import type { BindElement } from './BindElement.ts';
 import { XFORM_EVENT, type XFormEvent } from './Event.ts';
+import { Success } from '../../integration/xpath/EngineXPathEvaluator.ts';
 
 /**
  * Per {@link https://getodk.github.io/xforms-spec/#preload-attributes:~:text=concatenation%20of%20%E2%80%98uuid%3A%E2%80%99%20and%20uuid()}
@@ -61,6 +62,17 @@ const getPreloadInput = (bindElement: BindElement): AnyPreloadInput | null => {
   };
 };
 
+const safeStringEvaluation = (
+  context: AttributeContext | InstanceValueContext,
+  expression: string
+): string => {
+  const result = context.evaluator.evaluateString(expression);
+  if (result instanceof Success) {
+    return result.value as string;
+  }
+  throw result.error!;
+};
+
 /**
  * Parsed representation of
  * {@link https://getodk.github.io/xforms-spec/#preload-attributes | Preload Attributes}.
@@ -97,13 +109,13 @@ export class BindPreloadDefinition<Type extends PreloadType> implements PreloadI
 
   getValue(context: AttributeContext | InstanceValueContext): string | undefined {
     if (this.type === 'uid') {
-      return context.evaluator.evaluateString(PRELOAD_UID_EXPRESSION);
+      return safeStringEvaluation(context, PRELOAD_UID_EXPRESSION);
     }
     if (this.type === 'timestamp') {
-      return context.evaluator.evaluateString('now()');
+      return safeStringEvaluation(context, 'now()');
     }
     if (this.type === 'date') {
-      return context.evaluator.evaluateString('today()');
+      return safeStringEvaluation(context, 'today()');
     }
     if (this.type === 'property') {
       const properties = context.instanceConfig.preloadProperties;
diff --git a/packages/xforms-engine/src/parse/text/abstract/TextRangeDefinition.ts b/packages/xforms-engine/src/parse/text/abstract/TextRangeDefinition.ts
index 3f33ed290..a1f559254 100644
--- a/packages/xforms-engine/src/parse/text/abstract/TextRangeDefinition.ts
+++ b/packages/xforms-engine/src/parse/text/abstract/TextRangeDefinition.ts
@@ -15,6 +15,7 @@ interface TextSourceNodes {
   readonly label: LocalNamedElement<'label'>;
   readonly 'item-label': LocalNamedElement<'label'>;
   readonly requiredMsg: null;
+  readonly errorMsg: null;
 }
 
 export type TextSourceNode<Type extends TextRole> = TextSourceNodes[Type];
diff --git a/packages/xforms-engine/test/helpers/pagination.ts b/packages/xforms-engine/test/helpers/pagination.ts
index 50e6c287c..074bfc683 100644
--- a/packages/xforms-engine/test/helpers/pagination.ts
+++ b/packages/xforms-engine/test/helpers/pagination.ts
@@ -62,11 +62,14 @@ export const setupPaginationForms = (): ((form: XFormsElement) => Promise<Root>)
 };
 
 const getNodeByReference = (root: Root, reference: string): AnyNode => {
-  const node = root.evaluator.evaluateNode<AnyNode>(reference);
-  if (node == null) {
+  const result = root.evaluator.evaluateNodes(reference);
+  if (result.error) {
+    throw result.error;
+  }
+  if (result.value!.length == null) {
     throw new Error(`No node for reference: ${reference}`);
   }
-  return node;
+  return result.value![0] as AnyNode;
 };
 
 const CONTROL_NODE_TYPES: ReadonlySet<AnyNode['nodeType']> = new Set([
diff --git a/packages/xforms-engine/test/instance/instance.test.ts b/packages/xforms-engine/test/instance/instance.test.ts
index 8bbecdbb3..0679fccbf 100644
--- a/packages/xforms-engine/test/instance/instance.test.ts
+++ b/packages/xforms-engine/test/instance/instance.test.ts
@@ -17,7 +17,6 @@ import { createInstance } from '../../src/entrypoints/createInstance.ts';
 import type { AnyInputNode, AnyNode, RootNode } from '../../src/index.ts';
 import { Root } from '../../src/instance/Root.ts';
 import { InstanceNode } from '../../src/instance/abstract/InstanceNode.ts';
-import type { AnyNode as AnyPrimaryInstanceNode } from '../../src/instance/hierarchy.ts';
 
 interface IntializedTestForm {
   readonly dispose: VoidFunction;
@@ -62,9 +61,11 @@ describe('Form instance state', () => {
   let testForm: IntializedTestForm;
 
   const getNodeByReference = (reference: string): AnyNode | null => {
-    return testForm.internalRoot.evaluator.evaluateNode<Extract<AnyPrimaryInstanceNode, AnyNode>>(
-      reference
-    );
+    const result = testForm.internalRoot.evaluator.evaluateNodes(reference);
+    if (result.error) {
+      throw result.error;
+    }
+    return result.value![0] as AnyNode;
   };
 
   const getInputNode = (reference: string): AnyInputNode => {
diff --git a/packages/xforms-engine/test/integration/actions-events/set-value-action.test.ts b/packages/xforms-engine/test/integration/actions-events/set-value-action.test.ts
index 724d032ab..5a34f346a 100644
--- a/packages/xforms-engine/test/integration/actions-events/set-value-action.test.ts
+++ b/packages/xforms-engine/test/integration/actions-events/set-value-action.test.ts
@@ -20,6 +20,7 @@ import { describe, expect, it, vi } from 'vitest';
 import { intAnswer } from '../../scenario/answer/ExpectedIntAnswer.ts';
 import { stringAnswer } from '../../scenario/answer/ExpectedStringAnswer.ts';
 import { Scenario } from '../../scenario/jr/Scenario.ts';
+import { ANSWER_OK } from '../../scenario/jr/validation/ValidateOutcome.ts';
 
 describe('setvalue action', () => {
   describe('when trigger node is updated', () => {
@@ -464,7 +465,7 @@ describe('setvalue action', () => {
           expect.fail('Expected multiple node target to fail');
         };
 
-        expect(answer).toThrowError('has more than one node');
+        expect(answer).toThrow('has more than one node');
       });
     });
 
@@ -1252,7 +1253,7 @@ describe('setvalue action', () => {
       expect(scenario.getInstanceNode('/data/destination')).toBeReadonly();
     });
 
-    it('rejects client writes while the field is `readonly` but allows setValue action', async () => {
+    it('ignores client writes while the field is `readonly` but allows setValue action', async () => {
       const scenario = await Scenario.init(
         'Setvalue readonly write permissions',
         html(
@@ -1286,10 +1287,9 @@ describe('setvalue action', () => {
       scenario.answer('/data/source', 'abc');
       expect(scenario.answerOf('/data/destination')).toEqualAnswer(intAnswer(6));
 
-      expect(() => scenario.answer('/data/destination', 12)).toThrowError(
-        'Cannot write to readonly field: /data/destination'
-      );
+      scenario.answer('/data/destination', 12);
       expect(scenario.answerOf('/data/destination')).toEqualAnswer(intAnswer(6));
+      expect(scenario.getValidationOutcome().outcome).toBe(ANSWER_OK);
 
       scenario.answer('/data/lock', 'no');
       expect(scenario.getInstanceNode('/data/destination')).toBeEnabled();
diff --git a/packages/xforms-engine/test/integration/choice-name.test.ts b/packages/xforms-engine/test/integration/choice-name.test.ts
index df9f5232a..13ff5e492 100644
--- a/packages/xforms-engine/test/integration/choice-name.test.ts
+++ b/packages/xforms-engine/test/integration/choice-name.test.ts
@@ -16,6 +16,7 @@ import { stringAnswer } from '../scenario/answer/ExpectedStringAnswer.ts';
 import { Scenario } from '../scenario/jr/Scenario.ts';
 
 import jrChoiceName from '../scenario/fixtures/test-javarosa/resources/jr-choice-name.xml?raw';
+import { ANSWER_CALCULATION_ERROR } from '../scenario/jr/validation/ValidateOutcome.ts';
 
 // Ported as of https://github.com/getodk/javarosa/commit/5ae68946c47419b83e7d28290132d846e457eea6
 describe('JavaRosa ports: ChoiceNameTest.java', () => {
@@ -186,51 +187,51 @@ describe('JavaRosa ports: ChoiceNameTest.java', () => {
 
   describe('error conditions', () => {
     it('throws on unknown element', async () => {
-      await expect(async () => {
-        await Scenario.init(
-          'Simplest',
-          html(
-            head(
-              title('Simplest'),
-              model(
-                mainInstance(t('data id="simplest"', t('a'), t('select_one'))),
-                bind('/data/a')
-                  .type('string')
-                  .calculate("jr:choice-name('choice2', ' /data/NOT_FOUND ')")
-              )
-            ),
-            body(
-              select1(
-                '/data/select_one',
-                item('choice1', 'Choice 1 label'),
-                item('choice2', 'Choice 2 label')
-              )
+      const scenario = await Scenario.init(
+        'Simplest',
+        html(
+          head(
+            title('Simplest'),
+            model(
+              mainInstance(t('data id="simplest"', t('a'), t('select_one'))),
+              bind('/data/a')
+                .type('string')
+                .calculate("jr:choice-name('choice2', ' /data/NOT_FOUND ')")
+            )
+          ),
+          body(
+            select1(
+              '/data/select_one',
+              item('choice1', 'Choice 1 label'),
+              item('choice2', 'Choice 2 label')
             )
           )
-        );
-      }).rejects.toThrow("No element found by evaluating ' /data/NOT_FOUND '");
+        )
+      );
+      const validate = scenario.getValidationOutcome();
+      expect(validate.failedPrompt).toBe(scenario.indexOf('/data/a'));
+      expect(validate.outcome).toBe(ANSWER_CALCULATION_ERROR);
     });
 
     it('throws when value is invalid element type', async () => {
-      await expect(async () => {
-        await Scenario.init(
-          'Simplest',
-          html(
-            head(
-              title('Simplest'),
-              model(
-                mainInstance(t('data id="simplest"', t('a'), t('select_one'))),
-                bind('/data/a')
-                  .type('string')
-                  .calculate("jr:choice-name('choice2', ' /data/select_one ')")
-              )
-            ),
-            body(input('/data/select_one'))
-          )
-        );
-      }).rejects.toThrow(
-        "Evaluating 'jr:choice-name' on element ' /data/select_one ' which has no possible choices."
+      const scenario = await Scenario.init(
+        'Simplest',
+        html(
+          head(
+            title('Simplest'),
+            model(
+              mainInstance(t('data id="simplest"', t('a'), t('select_one'))),
+              bind('/data/a')
+                .type('string')
+                .calculate("jr:choice-name('choice2', ' /data/select_one ')")
+            )
+          ),
+          body(input('/data/select_one'))
+        )
       );
+      const validate = scenario.getValidationOutcome();
+      expect(validate.failedPrompt).toBe(scenario.indexOf('/data/a'));
+      expect(validate.outcome).toBe(ANSWER_CALCULATION_ERROR);
     });
   });
 });
diff --git a/packages/xforms-engine/test/integration/instance-attachments/calculate-setvalue.test.ts b/packages/xforms-engine/test/integration/instance-attachments/calculate-setvalue.test.ts
index 4a2b2558d..a4b8a5e85 100644
--- a/packages/xforms-engine/test/integration/instance-attachments/calculate-setvalue.test.ts
+++ b/packages/xforms-engine/test/integration/instance-attachments/calculate-setvalue.test.ts
@@ -24,6 +24,7 @@ import { constants as ENGINE_CONSTANTS } from '@getodk/xforms-engine';
 import { afterEach, assert, beforeEach, describe, expect, it } from 'vitest';
 import { JRResource } from '../../scenario/fixtures/JRResource.ts';
 import { JRResourceService } from '../../scenario/fixtures/JRResourceService.ts';
+import { ANSWER_OK } from '../../scenario/jr/validation/ValidateOutcome.ts';
 import { ReactiveScenario } from '../../scenario/reactive/ReactiveScenario.ts';
 
 describe('Instance attachments with calculate and setvalue', () => {
@@ -321,7 +322,7 @@ describe('Instance attachments with calculate and setvalue', () => {
   });
 
   describe('readonly', () => {
-    it('accepts the calculation and rejects client writes', async () => {
+    it('accepts the calculation and ignores client writes', async () => {
       const scenario = await ReactiveScenario.init(
         'Readonly photo',
         animalPhotoForm(
@@ -333,10 +334,9 @@ describe('Instance attachments with calculate and setvalue', () => {
       await settle(scenario, photo);
 
       expect(photo.currentState.instanceValue).toBe(KOALA_URL);
-      expect(() => {
-        scenario.answer('/data/photo', new File(['mine'], 'mine.jpg', { type: 'image/jpeg' }));
-      }).toThrow('Cannot write to readonly field');
+      scenario.answer('/data/photo', new File(['mine'], 'mine.jpg', { type: 'image/jpeg' }));
       expect(photo.currentState.instanceValue).toBe(KOALA_URL);
+      expect(scenario.getValidationOutcome().outcome).toBe(ANSWER_OK);
     });
   });
 
diff --git a/packages/xforms-engine/test/integration/markdown.test.ts b/packages/xforms-engine/test/integration/markdown.test.ts
index 24a8b20f1..d0cb8e195 100644
--- a/packages/xforms-engine/test/integration/markdown.test.ts
+++ b/packages/xforms-engine/test/integration/markdown.test.ts
@@ -13,6 +13,7 @@ import {
 } from '@getodk/common/test-utils/xform-dsl/index.ts';
 import { describe, expect, it } from 'vitest';
 import { Scenario } from '../scenario/jr/Scenario.ts';
+import { type RequiredViolation } from '@getodk/xforms-engine';
 
 describe('Markdown', () => {
   const run = async (given: string, expected: object[]) => {
@@ -642,7 +643,8 @@ double line break`;
       )
     );
     const result = scenario.answerOf('/data/required-input');
-    const formatted = result.node.validationState.required.message?.formatted ?? [];
+    const formatted =
+      (result.node.validationState.required as RequiredViolation).message?.formatted ?? [];
     expect(formatted).toMatchObject([
       { value: 'Field is ' },
       {
diff --git a/packages/xforms-engine/test/integration/message-output.test.ts b/packages/xforms-engine/test/integration/message-output.test.ts
index 9a62487c5..6874f83d8 100644
--- a/packages/xforms-engine/test/integration/message-output.test.ts
+++ b/packages/xforms-engine/test/integration/message-output.test.ts
@@ -10,7 +10,7 @@ import {
   t,
   title,
 } from '@getodk/common/test-utils/xform-dsl/index.ts';
-import type { LeafNodeValidationState } from '@getodk/xforms-engine';
+import type { LeafNodeValidationState, RequiredViolation } from '@getodk/xforms-engine';
 import { describe, expect, it } from 'vitest';
 import { AnswerResult, Scenario } from '../scenario/jr/Scenario.ts';
 import { ANSWER_REQUIRED_BUT_EMPTY } from '../scenario/jr/validation/ValidateOutcome.ts';
@@ -77,6 +77,8 @@ describe('Translation text can contain `<output>`', () => {
 
     let result;
     let validate;
+    let node;
+    let validationState;
 
     scenario.next('/data/name');
     scenario.answer('Alice');
@@ -89,11 +91,13 @@ describe('Translation text can contain `<output>`', () => {
     expect(result).toHaveValidityStatus(AnswerResult.OK);
 
     validate = scenario.getValidationOutcome();
-    expect(validate.failedPrompt?.node?.currentState.reference).toBe('/data/date');
-    expect(
-      (validate.failedPrompt?.node?.validationState as LeafNodeValidationState).required.message
-        ?.asString
-    ).toBe('Dear Alice, please fill me in');
+
+    node = validate.failedPrompt?.node;
+    expect(node?.currentState.reference).toBe('/data/date');
+    validationState = node?.validationState as LeafNodeValidationState;
+    expect((validationState.required as RequiredViolation).message?.asString).toBe(
+      'Dear Alice, please fill me in'
+    );
     expect(validate.outcome).toBe(ANSWER_REQUIRED_BUT_EMPTY);
 
     scenario.setLanguage('fr');
@@ -105,11 +109,12 @@ describe('Translation text can contain `<output>`', () => {
     expect(result).toHaveValidityStatus(AnswerResult.OK);
 
     validate = scenario.getValidationOutcome();
-    expect(validate.failedPrompt?.node?.currentState.reference).toBe('/data/date');
-    expect(
-      (validate.failedPrompt?.node?.validationState as LeafNodeValidationState).required.message
-        ?.asString
-    ).toBe(`Cher Alice, s'il te plaît, renseigne-moi`);
+    node = validate.failedPrompt?.node;
+    expect(node?.currentState.reference).toBe('/data/date');
+    validationState = node?.validationState as LeafNodeValidationState;
+    expect((validationState.required as RequiredViolation).message?.asString).toBe(
+      `Cher Alice, s'il te plaît, renseigne-moi`
+    );
     expect(validate.outcome).toBe(ANSWER_REQUIRED_BUT_EMPTY);
   });
 });
diff --git a/packages/xforms-engine/test/integration/xpath/functions/distance.test.ts b/packages/xforms-engine/test/integration/xpath/functions/distance.test.ts
index b70fc7cf5..e4b8c9f4d 100644
--- a/packages/xforms-engine/test/integration/xpath/functions/distance.test.ts
+++ b/packages/xforms-engine/test/integration/xpath/functions/distance.test.ts
@@ -12,6 +12,7 @@ import {
 import { describe, expect, it } from 'vitest';
 import { expectedDistance } from '../../../scenario/answer/ExpectedApproximateUOMAnswer.ts';
 import { Scenario } from '../../../scenario/jr/Scenario.ts';
+import { ANSWER_CALCULATION_ERROR } from '../../../scenario/jr/validation/ValidateOutcome.ts';
 
 /**
  * **PORTING NOTES**
@@ -81,35 +82,26 @@ describe('XPath function support: `distance`', () => {
      *
      * Adapts JavaRosa's use of `try`/`catch` to typical Web Forms error
      * condition assertion style.
-     *
-     * @todo The shape of this test may change (like many others) when we
-     * address error production broadly.
      */
     // JR: distance_throwsForNonPoint
     it('produces an error when the string value is not a valid point', async () => {
-      const init = async () => {
-        // prettier-ignore
-        await Scenario.init('string distance', html(
-						head(
-							title('String distance'),
-							model(
-								mainInstance(t('data id="string-distance"',
-									t('distance')
-								)),
-								bind('/data/distance').type('decimal').calculate("distance('foo')")
-							)),
-						body(
-							input('distance')
-						)
-				));
-      };
-
-      // **PORTING NOTES**
-      //
-      // We've currently copied this error message verbatim.
-      await expect(init).rejects.toThrowError(
-        "The function 'distance' received a value that does not represent GPS coordinates"
+      const scenario = await Scenario.init(
+        'string distance',
+        html(
+          head(
+            title('String distance'),
+            model(
+              mainInstance(t('data id="string-distance"', t('distance'))),
+              bind('/data/distance').type('decimal').calculate("distance('foo')")
+            )
+          ),
+          body(input('distance'))
+        )
       );
+
+      const validate = scenario.getValidationOutcome();
+      expect(validate.failedPrompt).toBe(scenario.indexOf('/data/distance'));
+      expect(validate.outcome).toBe(ANSWER_CALCULATION_ERROR);
     });
 
     /**
@@ -191,36 +183,34 @@ describe('XPath function support: `distance`', () => {
 
   describe('multiple arguments, mixed value types', () => {
     it('produces an error for a non-geopoint value in a multiple argument call', async () => {
-      const init = async () => {
-        await Scenario.init(
-          'geoshape distance',
-          html(
-            head(
-              title('Geoshape distance'),
-              model(
-                mainInstance(
-                  t(
-                    'data id="geoshape-distance"',
-                    t('polygon-start-trace', '0 1 0 0; 0 91 0 0;'),
-                    t('polygon-close-point', '0 1 0 0'),
-                    t('distance')
-                  )
-                ),
-                bind('/data/polygon-start-trace').type('geotrace'),
-                bind('/data/polygon-close-point').type('geopoint'),
-                bind('/data/distance')
-                  .type('decimal')
-                  .calculate('distance(/data/polygon-start-trace, /data/polygon-close-point)')
-              )
-            ),
-            body(input('/data/polygon-start-trace'), input('/data/polygon-close-point'))
-          )
-        );
-      };
-
-      await expect(init).rejects.toThrowError(
-        "The function 'distance' received a value that does not represent GPS coordinates"
+      const scenario = await Scenario.init(
+        'geoshape distance',
+        html(
+          head(
+            title('Geoshape distance'),
+            model(
+              mainInstance(
+                t(
+                  'data id="geoshape-distance"',
+                  t('polygon-start-trace', '0 1 0 0; 0 91 0 0;'),
+                  t('polygon-close-point', '0 1 0 0'),
+                  t('distance')
+                )
+              ),
+              bind('/data/polygon-start-trace').type('geotrace'),
+              bind('/data/polygon-close-point').type('geopoint'),
+              bind('/data/distance')
+                .type('decimal')
+                .calculate('distance(/data/polygon-start-trace, /data/polygon-close-point)')
+            )
+          ),
+          body(input('/data/polygon-start-trace'), input('/data/polygon-close-point'))
+        )
       );
+
+      const validate = scenario.getValidationOutcome();
+      expect(validate.failedPrompt).toBe(scenario.indexOf('/data/distance'));
+      expect(validate.outcome).toBe(ANSWER_CALCULATION_ERROR);
     });
   });
 });
diff --git a/packages/xforms-engine/test/integration/xpath/functions/extract-signed.test.ts b/packages/xforms-engine/test/integration/xpath/functions/extract-signed.test.ts
index 3dcbe06b6..70fa0febf 100644
--- a/packages/xforms-engine/test/integration/xpath/functions/extract-signed.test.ts
+++ b/packages/xforms-engine/test/integration/xpath/functions/extract-signed.test.ts
@@ -12,6 +12,7 @@ import {
 import { describe, expect, it } from 'vitest';
 import { stringAnswer } from '../../../scenario/answer/ExpectedStringAnswer.ts';
 import { Scenario } from '../../../scenario/jr/Scenario.ts';
+import { ANSWER_CALCULATION_ERROR } from '../../../scenario/jr/validation/ValidateOutcome.ts';
 
 /**
  * **PORTING NOTES**
@@ -320,25 +321,23 @@ describe('`extract-signed`', () => {
        * Result type) and less specific error assertion.
        */
       it('[produces an error] throws exception', async () => {
-        const init = async () => {
-          return Scenario.init(
-            'extract signed form',
-            html(
-              head(
-                title('extract signed form'),
-                model(
-                  mainInstance(
-                    t('data id="extract-signed"', t('contents', 'blah'), t('extracted'))
-                  ),
-                  bind('/data/extracted').type('string').calculate('extract-signed()')
-                )
-              ),
-              body(input('/data/contents'))
-            )
-          );
-        };
+        const scenario = await Scenario.init(
+          'extract signed form',
+          html(
+            head(
+              title('extract signed form'),
+              model(
+                mainInstance(t('data id="extract-signed"', t('contents', 'blah'), t('extracted'))),
+                bind('/data/extracted').type('string').calculate('extract-signed()')
+              )
+            ),
+            body(input('/data/contents'))
+          )
+        );
 
-        await expect(init).rejects.toThrowError();
+        const validate = scenario.getValidationOutcome();
+        expect(validate.failedPrompt).toBe(scenario.indexOf('/data/extracted'));
+        expect(validate.outcome).toBe(ANSWER_CALCULATION_ERROR);
       });
     });
 
diff --git a/packages/xforms-engine/test/lib/reactivity/createAggregatedViolations.test.ts b/packages/xforms-engine/test/lib/reactivity/createAggregatedViolations.test.ts
index 4b4666a15..12d3c497a 100644
--- a/packages/xforms-engine/test/lib/reactivity/createAggregatedViolations.test.ts
+++ b/packages/xforms-engine/test/lib/reactivity/createAggregatedViolations.test.ts
@@ -6,11 +6,14 @@ import {
   head,
   html,
   input,
+  instance,
   item,
   label,
   mainInstance,
   model,
+  repeat,
   select1,
+  setvalue,
   t,
   title,
 } from '@getodk/common/test-utils/xform-dsl/index.ts';
@@ -18,6 +21,7 @@ import { beforeEach, describe, expect, it } from 'vitest';
 import type { ValidationCondition, ViolationMessage } from '../../../src/client/validation.ts';
 import { createInstance } from '../../../src/entrypoints/createInstance.ts';
 import { reactiveTestScope } from '../../helpers/reactive/internal.ts';
+import type { RootNode } from '@getodk/xforms-engine';
 
 describe('createAggregatedViolations - reactive aggregated `constraint` and `required` validation violations on ancestor nodes', () => {
   let definition: HtmlXFormsElement;
@@ -51,10 +55,10 @@ describe('createAggregatedViolations - reactive aggregated `constraint` and `req
 					'/data/contactdetails',
 					label('Household'),
 
-					input("/data/contactdetails/residentialAddress",
+					input('/data/contactdetails/residentialAddress',
 						label('Residential address')),
 
-					group("/data/contactdetails/phone",
+					group('/data/contactdetails/phone',
 						label('Phone numbers'),
 
 						input('/data/contactdetails/phone/home',
@@ -80,7 +84,7 @@ describe('createAggregatedViolations - reactive aggregated `constraint` and `req
   interface SimplifiedViolation {
     readonly condition: ValidationCondition;
     readonly valid: false;
-    readonly message: ViolationMessage<ValidationCondition> | null;
+    readonly message: ViolationMessage<ValidationCondition> | string | null;
   }
 
   interface SimplifiedViolationReference {
@@ -582,4 +586,428 @@ describe('createAggregatedViolations - reactive aggregated `constraint` and `req
       ]);
     });
   });
+
+  describe('error violations', () => {
+    interface ViolationExpectation {
+      reference: string;
+      message: string;
+    }
+
+    const expectViolations = (root: RootNode, expected: ViolationExpectation[]) => {
+      const actual = root.validationState.violations;
+      expect(actual.length).toEqual(expected.length);
+      actual.forEach((actualItem, i) => {
+        const expectedItem = expected[i]!;
+        expect(actualItem.reference).toEqual(expectedItem.reference);
+        expect(actualItem.violation.message).toEqual(expectedItem.message);
+      });
+    };
+
+    const setInput = (root: RootNode, reference: string, value: string) => {
+      const inputNode = root.currentState.children[0];
+      if (inputNode?.nodeType !== 'input' || inputNode.currentState.reference !== reference) {
+        throw new Error(`Expected input ${reference}`);
+      }
+      inputNode.setValue(value);
+    };
+
+    it('violations are not shown when not relevant', async () => {
+      definition = html(
+        head(
+          title('Validation Form'),
+          model(
+            mainInstance(t('data id="validation"', t('show'), t('phone'))),
+            bind('/data/show'),
+            bind('/data/phone').relevant("/data/show != ''").constraint('unknown()')
+          )
+        ),
+        body(input('/data/show'), input('/data/phone'))
+      );
+      const { root } = await createInstance(definition.asXml());
+
+      expectViolations(root, []);
+      setInput(root, '/data/show', 'abc');
+      expectViolations(root, [
+        {
+          reference: '/data/phone',
+          message: "Unknown function in form definition: 'unknown'",
+        },
+      ]);
+    });
+
+    it('violations are shown when error on the relevant expression', async () => {
+      definition = html(
+        head(
+          title('Validation Form'),
+          model(
+            mainInstance(t('data id="validation"', t('phone'))),
+            bind('/data/phone').relevant('unknown()')
+          )
+        ),
+        body(input('/data/phone'))
+      );
+      const { root } = await createInstance(definition.asXml());
+      expectViolations(root, [
+        {
+          reference: '/data/phone',
+          message: "Unknown function in form definition: 'unknown'",
+        },
+      ]);
+    });
+
+    it('violations on groups', async () => {
+      definition = html(
+        head(
+          title('Validation Form'),
+          model(
+            mainInstance(
+              t(
+                'data id="validation"',
+                t('contactdetails', t('residentialAddress'), t('phone', t('home'))),
+                t('meta', t('instanceID'))
+              )
+            ),
+            bind('/data/contactdetails').relevant('unknownfunction()'),
+            bind('/data/contactdetails/residentialAddress'),
+            bind('/data/contactdetails/phone/home')
+          )
+        ),
+        body(
+          group(
+            '/data/contactdetails',
+            label('Household'),
+
+            input('/data/contactdetails/residentialAddress', label('Residential address')),
+
+            group(
+              '/data/contactdetails/phone',
+              label('Phone numbers'),
+
+              input('/data/contactdetails/phone/home', label('Home phone no.'))
+            )
+          )
+        )
+      );
+      const { root } = await createInstance(definition.asXml());
+      expectViolations(root, [
+        {
+          reference: '/data/contactdetails',
+          message: "Unknown function in form definition: 'unknownfunction'",
+        },
+      ]);
+    });
+
+    it('violations on repeats', async () => {
+      definition = html(
+        head(
+          title('invalid jr:count'),
+          model(
+            mainInstance(
+              t(
+                'data id="cast-fractional-value-to-int"',
+                t('repeat-count jr:template=""', t('anything'))
+              )
+            )
+          )
+        ),
+        body(repeat('/data/repeat-count', 'somerandomnumber()'))
+      );
+      const { root } = await createInstance(definition.asXml());
+      expectViolations(root, [
+        {
+          reference: '/data/repeat-count',
+          message: "Unknown function in form definition: 'somerandomnumber'",
+        },
+      ]);
+    });
+
+    it('violations on attributes', async () => {
+      definition = html(
+        head(
+          title('Bind attributes'),
+          model(
+            mainInstance(t('root id="bind-attributes" version=""', t('version'))),
+            bind('/root/version').type('string'),
+            bind('/root/@version')
+              .type('string')
+              .calculate('invalidrandomfunction()')
+              .readonly('true()')
+          )
+        ),
+        body(input('/root/version'))
+      );
+      const { root } = await createInstance(definition.asXml());
+      expectViolations(root, [
+        {
+          reference: '/root/@version',
+          message: "Unknown function in form definition: 'invalidrandomfunction'",
+        },
+      ]);
+    });
+
+    it('violations on itemsets', async () => {
+      definition = html(
+        head(
+          title('itemsets'),
+          model(
+            mainInstance(t('root id="itemsets" version=""', t('sel'))),
+            bind('/root/sel').type('string')
+          )
+        ),
+        body(
+          select1(
+            '/root/sel',
+            t('itemset nodeset="isnt()"', t('label ref="itextId"'), t('value ref="value"'))
+          )
+        )
+      );
+      const { root } = await createInstance(definition.asXml());
+      expectViolations(root, [
+        {
+          reference: '/root/sel',
+          message: "Unknown function in form definition: 'isnt'",
+        },
+      ]);
+    });
+
+    it('violations on itemset value', async () => {
+      definition = html(
+        head(
+          title('itemset value'),
+          model(
+            mainInstance(t('root id="itemsets" version=""', t('sel'))),
+            instance(
+              'sec',
+              t('item', t('itextId', 'choices-0'), t('name', 'a')),
+              t('item', t('itextId', 'choices-1'), t('name', 'b')),
+              t('item', t('itextId', 'choices-2'), t('name', 'c'))
+            ),
+            bind('/root/sel').type('string')
+          )
+        ),
+        body(
+          select1(
+            '/root/sel',
+            t(
+              'itemset nodeset="instance(\'sec\')"',
+              t('value ref="rndom()"'),
+              t('label ref="itextId"')
+            )
+          )
+        )
+      );
+      const { root } = await createInstance(definition.asXml());
+      expectViolations(root, [
+        {
+          reference: '/root/sel',
+          message: "Unknown function in form definition: 'rndom'",
+        },
+      ]);
+    });
+
+    it('violations on itemset value are cleared when itemset items are filtered out', async () => {
+      definition = html(
+        head(
+          title('itemset filter'),
+          model(
+            mainInstance(t('root id="itemsets" version=""', t('show'), t('sel'))),
+            instance(
+              'sec',
+              t('item', t('itextId', 'choices-0'), t('name', 'a')),
+              t('item', t('itextId', 'choices-1'), t('name', 'b')),
+              t('item', t('itextId', 'choices-2'), t('name', 'c'))
+            ),
+            bind('/root/show').type('string'),
+            bind('/root/sel').type('string')
+          )
+        ),
+        body(
+          input('/root/show'),
+          select1(
+            '/root/sel',
+            t(
+              `itemset nodeset="instance('sec')/root/item[/root/show != '']"`,
+              t('value ref="rndom()"'),
+              t('label ref="itextId"')
+            )
+          )
+        )
+      );
+      const { root } = await createInstance(definition.asXml());
+
+      expectViolations(root, []);
+      setInput(root, '/root/show', 'abc');
+      expectViolations(root, [
+        {
+          reference: '/root/sel',
+          message: "Unknown function in form definition: 'rndom'",
+        },
+      ]);
+      setInput(root, '/root/show', '');
+      expectViolations(root, []);
+    });
+
+    it('violations on itemset value are cleared when not relevant', async () => {
+      definition = html(
+        head(
+          title('itemset value'),
+          model(
+            mainInstance(t('root id="itemsets" version=""', t('show'), t('sel'))),
+            instance(
+              'sec',
+              t('item', t('itextId', 'choices-0'), t('name', 'a')),
+              t('item', t('itextId', 'choices-1'), t('name', 'b')),
+              t('item', t('itextId', 'choices-2'), t('name', 'c'))
+            ),
+            bind('/root/show').type('string'),
+            bind('/root/sel').type('string').relevant("/root/show != ''")
+          )
+        ),
+        body(
+          input('/root/show'),
+          select1(
+            '/root/sel',
+            t(
+              'itemset nodeset="instance(\'sec\')"',
+              t('value ref="rndom()"'),
+              t('label ref="itextId"')
+            )
+          )
+        )
+      );
+      const { root } = await createInstance(definition.asXml());
+
+      expectViolations(root, []);
+      setInput(root, '/root/show', 'abc');
+      expectViolations(root, [
+        {
+          reference: '/root/sel',
+          message: "Unknown function in form definition: 'rndom'",
+        },
+      ]);
+      setInput(root, '/root/show', '');
+      expectViolations(root, []);
+    });
+
+    it('violations on itemset label', async () => {
+      definition = html(
+        head(
+          title('itemset label'),
+          model(
+            mainInstance(t('root id="itemsets" version=""', t('sel'))),
+            instance(
+              'sec',
+              t('item', t('itextId', 'choices-0'), t('name', 'a')),
+              t('item', t('itextId', 'choices-1'), t('name', 'b')),
+              t('item', t('itextId', 'choices-2'), t('name', 'c'))
+            ),
+            bind('/root/sel').type('string')
+          )
+        ),
+        body(
+          select1(
+            '/root/sel',
+            t(
+              'itemset nodeset="instance(\'sec\')"',
+              t('label ref="concat(label, nofun())"'),
+              t('value ref="name"')
+            )
+          )
+        )
+      );
+      const { root } = await createInstance(definition.asXml());
+      expectViolations(root, [
+        {
+          reference: '/root/sel',
+          message: "Unknown function in form definition: 'nofun'",
+        },
+      ]);
+    });
+
+    it('violations on setvalue actions', async () => {
+      definition = html(
+        head(
+          title('setvalue'),
+          model(
+            mainInstance(t('root id="setvalue" version=""', t('sel'))),
+            bind('/root/sel').type('string'),
+            setvalue('odk-instance-load', '/root/sel', 'rnd()')
+          )
+        ),
+        body(input('/root/sel'))
+      );
+      const { root } = await createInstance(definition.asXml());
+      expectViolations(root, [
+        {
+          reference: '/root/sel',
+          message: "Unknown function in form definition: 'rnd'",
+        },
+      ]);
+    });
+
+    it('violations on value changed actions', async () => {
+      definition = html(
+        head(
+          title('value changed'),
+          model(
+            mainInstance(t('root id="valuechanged" version=""', t('src'), t('dest'))),
+            bind('/root/src').type('string'),
+            bind('/root/dest').type('string')
+          )
+        ),
+        body(input('/root/src', setvalue('xforms-value-changed', '/root/dest', 'bah()')))
+      );
+      const { root } = await createInstance(definition.asXml());
+      expectViolations(root, []);
+      setInput(root, '/root/src', 'abc');
+      expectViolations(root, [
+        {
+          reference: '/root/dest',
+          message: "Unknown function in form definition: 'bah'",
+        },
+      ]);
+    });
+
+    it('violations errors thrown in required constraint messages', async () => {
+      definition = html(
+        head(
+          title('value changed'),
+          model(
+            t(
+              'itext',
+              t(
+                'translation lang="default"',
+                t('text id="/data/src:jr:requiredMsg"', t('value', '<output value="nofun()" />'))
+              )
+            ),
+            mainInstance(t('root id="required-message" version=""', t('src'))),
+            bind('/root/src')
+              .type('string')
+              .required()
+              .withAttribute('jr', 'requiredMsg', "jr:itext('/data/src:jr:requiredMsg')")
+          )
+        ),
+        body(input('/root/src'))
+      );
+      const { root } = await createInstance(definition.asXml());
+      expectViolations(root, [
+        {
+          reference: '/root/src',
+          message: "Unknown function in form definition: 'nofun'",
+        },
+      ]);
+    });
+  });
+
+  describe('violation node reference', () => {
+    it('references the violating node itself', async () => {
+      const { root } = await createInstance(definition.asXml());
+      const violations = root.validationState.violations;
+
+      expect(violations.length).toBeGreaterThan(0);
+      expect(violations.map(({ node }) => node.nodeId)).toEqual(
+        violations.map(({ nodeId }) => nodeId)
+      );
+    });
+  });
 });
diff --git a/packages/xforms-engine/test/scenario/assertion/extensions/answers.ts b/packages/xforms-engine/test/scenario/assertion/extensions/answers.ts
index d07c360ba..a32cb457b 100644
--- a/packages/xforms-engine/test/scenario/assertion/extensions/answers.ts
+++ b/packages/xforms-engine/test/scenario/assertion/extensions/answers.ts
@@ -1,6 +1,10 @@
 import { UnreachableError } from '@getodk/common/lib/error/UnreachableError.ts';
 import { getBlobText } from '@getodk/common/lib/web-compat/blob.ts';
-import { type ValidationCondition } from '@getodk/xforms-engine';
+import {
+  type ConstraintViolation,
+  type RequiredViolation,
+  type ValidationCondition,
+} from '@getodk/xforms-engine';
 import { assert, expect } from 'vitest';
 import { ComparableAnswer } from '../../answer/ComparableAnswer.ts';
 import { ExpectedApproximateUOMAnswer } from '../../answer/ExpectedApproximateUOMAnswer.ts';
@@ -139,7 +143,8 @@ export const answerExtensions = extendExpect(expect, {
     assertValueNodeAnswer,
     assertNullableString,
     (actual, expected) => {
-      const { asString = null } = actual.node.validationState.constraint?.message ?? {};
+      const { asString = null } =
+        (actual.node.validationState.constraint as ConstraintViolation)?.message ?? {};
       const pass = asString === expected;
 
       return pass || new InspectableComparisonError(asString, expected, 'to be message');
@@ -150,7 +155,8 @@ export const answerExtensions = extendExpect(expect, {
     assertValueNodeAnswer,
     assertNullableString,
     (actual, expected) => {
-      const { asString = null } = actual.node.validationState.required?.message ?? {};
+      const { asString = null } =
+        (actual.node.validationState.required as RequiredViolation)?.message ?? {};
       const pass = asString === expected;
 
       return pass || new InspectableComparisonError(asString, expected, 'to be message');
@@ -161,7 +167,15 @@ export const answerExtensions = extendExpect(expect, {
     assertValueNodeAnswer,
     assertNullableString,
     (actual, expected) => {
-      const { asString = null } = actual.node.validationState.violation?.message ?? {};
+      const violation = actual.node.validationState.violation;
+      let asString;
+      if (!violation) {
+        asString = null;
+      } else if (violation.condition === 'error') {
+        asString = violation.message;
+      } else {
+        asString = violation.message?.asString;
+      }
       const pass = asString === expected;
 
       return pass || new InspectableComparisonError(asString, expected, 'to be message');
diff --git a/packages/xforms-engine/test/scenario/jr/validation/ValidateOutcome.ts b/packages/xforms-engine/test/scenario/jr/validation/ValidateOutcome.ts
index 3176e5c3d..ef178e500 100644
--- a/packages/xforms-engine/test/scenario/jr/validation/ValidateOutcome.ts
+++ b/packages/xforms-engine/test/scenario/jr/validation/ValidateOutcome.ts
@@ -4,11 +4,13 @@ import type { AnyPositionalEvent } from '../event/getPositionalEvents.ts';
 export const ANSWER_OK = 'ANSWER_OK';
 export const ANSWER_REQUIRED_BUT_EMPTY = 'ANSWER_REQUIRED_BUT_EMPTY';
 export const ANSWER_CONSTRAINT_VIOLATED = 'ANSWER_CONSTRAINT_VIOLATED';
+export const ANSWER_CALCULATION_ERROR = 'ANSWER_CALCULATION_ERROR';
 
 const ValidationOutcomeStatus = {
   ANSWER_OK,
   ANSWER_REQUIRED_BUT_EMPTY,
   ANSWER_CONSTRAINT_VIOLATED,
+  ANSWER_CALCULATION_ERROR,
 } as const;
 
 type ValidationOutcomeStatuses = typeof ValidationOutcomeStatus;
@@ -34,6 +36,10 @@ export class ValidateOutcome {
         this.outcome = 'ANSWER_REQUIRED_BUT_EMPTY';
         break;
 
+      case 'error':
+        this.outcome = 'ANSWER_CALCULATION_ERROR';
+        break;
+
       default:
         this.outcome = 'ANSWER_OK';
     }
diff --git a/packages/xpath/src/error/TooFewArgumentsError.ts b/packages/xpath/src/error/TooFewArgumentsError.ts
index 4a1d337c7..d5226c095 100644
--- a/packages/xpath/src/error/TooFewArgumentsError.ts
+++ b/packages/xpath/src/error/TooFewArgumentsError.ts
@@ -3,7 +3,7 @@ import { FormDesignError } from './FormDesignError';
 export class TooFewArgumentsError extends FormDesignError {
   constructor(functionName: string, given: number, expected: number) {
     super(
-      `Function "${functionName}" requires a minimum of ${expected} parameters but was called with ${given}`
+      `Function '${functionName}' requires a minimum of ${expected} parameters but was called with ${given}`
     );
   }
 }
diff --git a/packages/xpath/src/error/TooManyArgumentsError.ts b/packages/xpath/src/error/TooManyArgumentsError.ts
index 34f639c18..2d934da41 100644
--- a/packages/xpath/src/error/TooManyArgumentsError.ts
+++ b/packages/xpath/src/error/TooManyArgumentsError.ts
@@ -3,7 +3,7 @@ import { FormDesignError } from './FormDesignError';
 export class TooManyArgumentsError extends FormDesignError {
   constructor(functionName: string, given: number, expected: number) {
     super(
-      `Function "${functionName}" has a maximum of ${expected} parameters but was called with ${given}`
+      `Function '${functionName}' has a maximum of ${expected} parameters but was called with ${given}`
     );
   }
 }
diff --git a/packages/xpath/src/error/UnknownFunctionError.ts b/packages/xpath/src/error/UnknownFunctionError.ts
index 89ad7ca01..bf87bf848 100644
--- a/packages/xpath/src/error/UnknownFunctionError.ts
+++ b/packages/xpath/src/error/UnknownFunctionError.ts
@@ -2,6 +2,6 @@ import { FormDesignError } from './FormDesignError';
 
 export class UnknownFunctionError extends FormDesignError {
   constructor(functionName: string) {
-    super(`Unknown function in form definition: "${functionName}"`);
+    super(`Unknown function in form definition: '${functionName}'`);
   }
 }
diff --git a/packages/xpath/src/lib/datetime/coercion.ts b/packages/xpath/src/lib/datetime/coercion.ts
index e63fa2955..ca056f0dd 100644
--- a/packages/xpath/src/lib/datetime/coercion.ts
+++ b/packages/xpath/src/lib/datetime/coercion.ts
@@ -19,14 +19,10 @@ export const dateTimeFromString = (
     return null;
   }
 
-  try {
-    if (value.endsWith('Z') || TIMEZONE_OFFSET_PATTERN.test(value)) {
-      return Temporal.Instant.from(value).toZonedDateTimeISO(timeZone);
-    }
-    return Temporal.PlainDateTime.from(value).toZonedDateTime(timeZone);
-  } catch {
-    return null;
+  if (value.endsWith('Z') || TIMEZONE_OFFSET_PATTERN.test(value)) {
+    return Temporal.Instant.from(value).toZonedDateTimeISO(timeZone);
   }
+  return Temporal.PlainDateTime.from(value).toZonedDateTime(timeZone);
 };
 
 const toNanoseconds = (milliseconds: number): bigint => {
diff --git a/packages/xpath/test/xforms/format-date.test.ts b/packages/xpath/test/xforms/format-date.test.ts
index a3a177dd2..e5127e5f7 100644
--- a/packages/xpath/test/xforms/format-date.test.ts
+++ b/packages/xpath/test/xforms/format-date.test.ts
@@ -1,4 +1,4 @@
-import { beforeEach, describe, it } from 'vitest';
+import { beforeEach, describe, it, expect } from 'vitest';
 import type { XFormsTestContext } from '../helpers.ts';
 import { createXFormsTestContext } from '../helpers.ts';
 
@@ -91,14 +91,23 @@ describe('#format-date()', () => {
 
   describe('invalid dates', () => {
     [
-      "format-date('invalid', '%e | %a' )",
       "format-date('2026-12-01T25:00:00.000Z', '%e | %a' )", // 25 hours
       "format-date('2026-12-01T25:00:00.000+10:00', '%e | %a' )", // 25 hours
       "format-date('2026-13-01', '%e | %a' )", // 13 months
-      "format-date(number('invalid'), '%Y-%m-%d')", // not a number
       "format-date('2026-04-31T23:00:00+12:00', '%Y-%m-%d')", // there aren't 31 days in April
       "format-date-time('2026-02-29T10:00:00Z', '%Y-%m-%d %H:%M')", // there aren't 29 days in February non leap year
       "format-date('2026-12-01T24:00:00Z', '%Y-%m-%d')", // there aren't 24 hours in a day
+    ].forEach((expr) => {
+      it(`"${expr}" throws`, () => {
+        expect(() => {
+          testContext.evaluate(expr);
+        }).toThrow();
+      });
+    });
+
+    [
+      "format-date('invalid', '%e | %a' )",
+      "format-date(number('invalid'), '%Y-%m-%d')", // not a number
       "format-date('26-12-12', '%Y-%m-%d')", // ambiguous year
     ].forEach((expr) => {
       it(`handles ${expr}`, () => {