@getodk/xforms-engine 0.2.0 → 0.4.0

package/src/parse/body/control/select/ItemsetDefinition.ts

@@ -0,0 +1,53 @@
+import { getValueElement, type ItemsetElement } from '../../../../lib/dom/query.ts';
+import { ItemsetNodesetExpression } from '../../../expression/ItemsetNodesetExpression.ts';
+import { ItemsetValueExpression } from '../../../expression/ItemsetValueExpression.ts';
+import { ItemsetLabelDefinition } from '../../../text/ItemsetLabelDefinition.ts';
+import type { XFormDefinition } from '../../../XFormDefinition.ts';
+import { parseNodesetReference } from '../../../xpath/reference-parsing.ts';
+import { BodyElementDefinition } from '../../BodyElementDefinition.ts';
+import type { AnySelectDefinition } from './SelectDefinition.ts';
+
+export class ItemsetDefinition extends BodyElementDefinition<'itemset'> {
+	override readonly category = 'support';
+	readonly type = 'itemset';
+
+	override readonly reference: string;
+	override readonly label: ItemsetLabelDefinition | null;
+
+	readonly nodes: ItemsetNodesetExpression;
+	readonly value: ItemsetValueExpression;
+
+	constructor(
+		form: XFormDefinition,
+		override readonly parent: AnySelectDefinition,
+		element: ItemsetElement
+	) {
+		super(form, parent, element);
+
+		const nodesetExpression = parseNodesetReference(parent, element, 'nodeset');
+
+		this.nodes = new ItemsetNodesetExpression(this, nodesetExpression);
+		this.reference = nodesetExpression;
+
+		const valueElement = getValueElement(element);
+
+		if (valueElement == null) {
+			throw new Error('<itemset> has no <value>');
+		}
+
+		const valueExpression = parseNodesetReference(
+			{
+				reference: null,
+			},
+			valueElement,
+			'ref'
+		);
+
+		if (valueExpression == null) {
+			throw new Error(`<itemset> has no <value>`);
+		}
+
+		this.value = new ItemsetValueExpression(this, valueExpression);
+		this.label = ItemsetLabelDefinition.from(form, this);
+	}
+}

package/src/{body → parse/body}/control/select/ItemsetNodesetContext.ts

@@ -1,5 +1,5 @@
-import { DependencyContext } from '../../../expression/DependencyContext.ts';
-import type { AnyDependentExpression } from '../../../expression/DependentExpression.ts';
+import { DependencyContext } from '../../../expression/abstract/DependencyContext.ts';
+import type { AnyDependentExpression } from '../../../expression/abstract/DependentExpression.ts';
 import type { ItemsetDefinition } from './ItemsetDefinition.ts';
 
 export class ItemsetNodesetContext extends DependencyContext {

package/src/{body → parse/body}/control/select/SelectDefinition.ts

@@ -1,23 +1,15 @@
 import type { CollectionValues } from '@getodk/common/types/collections/CollectionValues.ts';
 import type { LocalNamedElement } from '@getodk/common/types/dom.ts';
+import { getItemElements, getItemsetElement } from '../../../../lib/dom/query.ts';
 import type { XFormDefinition } from '../../../XFormDefinition.ts';
-import { getItemElements, getItemsetElement } from '../../../lib/dom/query.ts';
-import type { AnyBodyElementDefinition, BodyElementParentContext } from '../../BodyDefinition.ts';
 import type { SelectAppearanceDefinition } from '../../appearance/selectAppearanceParser.ts';
 import { selectAppearanceParser } from '../../appearance/selectAppearanceParser.ts';
+import type { AnyBodyElementDefinition, BodyElementParentContext } from '../../BodyDefinition.ts';
 import { ControlDefinition } from '../ControlDefinition.ts';
 import { ItemDefinition } from './ItemDefinition.ts';
 import { ItemsetDefinition } from './ItemsetDefinition.ts';
 
-/**
- * @todo We were previously a bit overzealous about introducing `<rank>` support
- * here. It'll likely still fit, but we should approach it with more intention.
- *
- * @todo `<trigger>` is *almost* reasonable to support here too. The main
- * hesitation is that its single, implicit "item" does not have a distinct
- * <label>, and presumably has different UX **and translation** considerations.
- */
-const selectLocalNames = new Set([/* 'rank', */ 'select', 'select1'] as const);
+const selectLocalNames = new Set(['select', 'select1'] as const);
 
 export type SelectType = CollectionValues<typeof selectLocalNames>;
 

package/src/{body → parse/body}/group/BaseGroupDefinition.ts

@@ -1,15 +1,15 @@
 import { UpsertableMap } from '@getodk/common/lib/collections/UpsertableMap.ts';
+import { getLabelElement } from '../../../lib/dom/query.ts';
+import { LabelDefinition } from '../../text/LabelDefinition.ts';
 import type { XFormDefinition } from '../../XFormDefinition.ts';
-import { getLabelElement } from '../../lib/dom/query.ts';
+import { parseNodesetReference } from '../../xpath/reference-parsing.ts';
+import type { StructureElementAppearanceDefinition } from '../appearance/structureElementAppearanceParser.ts';
+import { structureElementAppearanceParser } from '../appearance/structureElementAppearanceParser.ts';
 import {
-	BodyDefinition,
 	type BodyElementDefinitionArray,
 	type BodyElementParentContext,
 } from '../BodyDefinition.ts';
 import { BodyElementDefinition } from '../BodyElementDefinition.ts';
-import type { StructureElementAppearanceDefinition } from '../appearance/structureElementAppearanceParser.ts';
-import { structureElementAppearanceParser } from '../appearance/structureElementAppearanceParser.ts';
-import { LabelDefinition } from '../text/LabelDefinition.ts';
 
 /**
  * These type names are derived from **and expand upon** the language used in
@@ -72,28 +72,18 @@ export abstract class BaseGroupDefinition<
 	readonly appearances: StructureElementAppearanceDefinition;
 	override readonly label: LabelDefinition | null;
 
-	constructor(
-		form: XFormDefinition,
-		parent: BodyElementParentContext,
-		element: Element,
-		children?: BodyElementDefinitionArray
-	) {
+	constructor(form: XFormDefinition, parent: BodyElementParentContext, element: Element) {
 		super(form, parent, element);
 
-		this.children = children ?? this.getChildren(element);
-		this.reference = element.getAttribute('ref');
-		this.appearances = structureElementAppearanceParser.parseFrom(element, 'appearance');
-		this.label = LabelDefinition.forGroup(form, this);
-	}
-
-	getChildren(element: Element): BodyElementDefinitionArray {
-		const { form } = this;
-		const children = Array.from(element.children).filter((child) => {
+		const childElements = Array.from(element.children).filter((child) => {
 			const childName = child.localName;
 
 			return childName !== 'label';
 		});
 
-		return BodyDefinition.getChildElementDefinitions(form, this, element, children);
+		this.children = this.body.getChildElementDefinitions(form, this, element, childElements);
+		this.reference = parseNodesetReference(parent, element, 'ref');
+		this.appearances = structureElementAppearanceParser.parseFrom(element, 'appearance');
+		this.label = LabelDefinition.forGroup(form, this);
 	}
 }

package/src/{body → parse/body}/group/PresentationGroupDefinition.ts

@@ -1,6 +1,6 @@
+import { LabelDefinition } from '../../text/LabelDefinition.ts';
 import type { XFormDefinition } from '../../XFormDefinition.ts';
 import type { BodyElementParentContext } from '../BodyDefinition.ts';
-import { LabelDefinition } from '../text/LabelDefinition.ts';
 import { BaseGroupDefinition } from './BaseGroupDefinition.ts';
 
 export class PresentationGroupDefinition extends BaseGroupDefinition<'presentation-group'> {

package/src/{model/BindComputation.ts → parse/expression/BindComputationExpression.ts}

@@ -1,5 +1,5 @@
-import { DependentExpression } from '../expression/DependentExpression.ts';
-import type { BindDefinition } from './BindDefinition.ts';
+import type { BindDefinition } from '../model/BindDefinition.ts';
+import { DependentExpression } from './abstract/DependentExpression.ts';
 
 const defaultBindComputationExpressions = {
 	calculate: null,
@@ -16,8 +16,8 @@ export type BindComputationType = keyof DefaultBindComputationExpressions;
 
 type BindComputationFactoryResult<Type extends BindComputationType> =
 	DefaultBindComputationExpressions[Type] extends null
-		? BindComputation<Type> | null
-		: BindComputation<Type>;
+		? BindComputationExpression<Type> | null
+		: BindComputationExpression<Type>;
 
 const bindComputationResultTypes = {
 	calculate: 'string',
@@ -33,10 +33,10 @@ type BindComputationResultTypes = typeof bindComputationResultTypes;
 export type BindComputationResultType<Computation extends BindComputationType> =
 	BindComputationResultTypes[Computation];
 
-export class BindComputation<Computation extends BindComputationType> extends DependentExpression<
-	BindComputationResultType<Computation>
-> {
-	static forExpression<Type extends BindComputationType>(
+export class BindComputationExpression<
+	Computation extends BindComputationType,
+> extends DependentExpression<BindComputationResultType<Computation>> {
+	static forComputation<Type extends BindComputationType>(
 		bind: BindDefinition,
 		computation: Type
 	): BindComputationFactoryResult<Type> {
@@ -57,7 +57,6 @@ export class BindComputation<Computation extends BindComputationType> extends De
 		readonly computation: Computation,
 		expression: string | null
 	) {
-		const isInherited = computation === 'readonly' || computation === 'relevant';
 		const ignoreContextReference = computation === 'constraint';
 
 		let isDefaultExpression: boolean;
@@ -78,9 +77,6 @@ export class BindComputation<Computation extends BindComputationType> extends De
 
 		super(bind, bindComputationResultTypes[computation], resolvedExpression, {
 			ignoreContextReference,
-			semanticDependencies: {
-				parentContext: isInherited,
-			},
 		});
 
 		this.isDefaultExpression = isDefaultExpression;

package/src/parse/expression/ItemsetNodesetExpression.ts

@@ -0,0 +1,8 @@
+import type { ItemsetDefinition } from '../body/control/select/ItemsetDefinition.ts';
+import { DependentExpression } from './abstract/DependentExpression.ts';
+
+export class ItemsetNodesetExpression extends DependentExpression<'nodes'> {
+	constructor(itemset: ItemsetDefinition, nodesetExpression: string) {
+		super(itemset.parent, 'nodes', nodesetExpression);
+	}
+}

package/src/{body/control/select → parse/expression}/ItemsetValueExpression.ts

@@ -1,5 +1,5 @@
-import { DependentExpression } from '../../../expression/DependentExpression.ts';
-import type { ItemsetDefinition } from './ItemsetDefinition.ts';
+import type { ItemsetDefinition } from '../body/control/select/ItemsetDefinition.ts';
+import { DependentExpression } from './abstract/DependentExpression.ts';
 
 export class ItemsetValueExpression extends DependentExpression<'string'> {
 	constructor(

package/src/parse/expression/RepeatCountControlExpression.ts

@@ -0,0 +1,44 @@
+import type { RepeatRangeControlledNode } from '../../client/repeat/RepeatRangeControlledNode.ts';
+import { RepeatElementDefinition } from '../body/RepeatElementDefinition.ts';
+import { isConstantTruthyExpression } from '../xpath/semantic-analysis.ts';
+import { DependentExpression } from './abstract/DependentExpression.ts';
+
+/**
+ * Represents either of these
+ * {@link https://getodk.github.io/xforms-spec/#body-attributes | body attributes}:
+ *
+ * - `jr:count`
+ * - `jr:noAddRemove`
+ *
+ * In both cases, the downstream effect is that the engine is responsible for
+ * controlling the count of a repeat range's instances. Representing both cases
+ * should simplify client usage, as well as implementation of the internal
+ * representation of {@link RepeatRangeControlledNode}.
+ */
+export class RepeatCountControlExpression extends DependentExpression<'number'> {
+	static from(
+		bodyElement: RepeatElementDefinition,
+		initialCount: number
+	): RepeatCountControlExpression | null {
+		const { countExpression, noAddRemoveExpression } = bodyElement;
+
+		if (countExpression != null) {
+			return new this(bodyElement, countExpression);
+		}
+
+		if (noAddRemoveExpression != null && isConstantTruthyExpression(noAddRemoveExpression)) {
+			// Assumption: `noAddRemove` with no form-defined repeat instances has no
+			// purpose. Infer intent as a single repeat instance, as defined by the
+			// repeat's template.
+			const fixedCountExpression = String(Math.max(initialCount, 1));
+
+			return new this(bodyElement, fixedCountExpression);
+		}
+
+		return null;
+	}
+
+	private constructor(context: RepeatElementDefinition, expression: string) {
+		super(context, 'number', expression);
+	}
+}

package/src/parse/expression/TextLiteralExpression.ts

@@ -0,0 +1,19 @@
+import type { AnyTextRangeDefinition } from '../text/abstract/TextRangeDefinition.ts';
+import { TextChunkExpression } from './abstract/TextChunkExpression.ts';
+
+export type TextLiteralSourceNode = Attr | Text;
+
+export class TextLiteralExpression extends TextChunkExpression<'literal'> {
+	static from(context: AnyTextRangeDefinition, stringValue: string): TextLiteralExpression {
+		return new this(context, stringValue);
+	}
+
+	readonly source = 'literal';
+
+	private constructor(
+		context: AnyTextRangeDefinition,
+		override readonly stringValue: string
+	) {
+		super(context, 'null');
+	}
+}

package/src/parse/expression/TextOutputExpression.ts

@@ -0,0 +1,25 @@
+import type { KnownAttributeLocalNamedElement } from '@getodk/common/types/dom.ts';
+import type { AnyTextRangeDefinition } from '../text/abstract/TextRangeDefinition.ts';
+import { TextChunkExpression } from './abstract/TextChunkExpression.ts';
+
+interface OutputElement extends KnownAttributeLocalNamedElement<'output', 'value'> {}
+
+const isOutputElement = (element: Element): element is OutputElement => {
+	return element.localName === 'output' && element.hasAttribute('value');
+};
+
+export class TextOutputExpression extends TextChunkExpression<'output'> {
+	static from(context: AnyTextRangeDefinition, element: Element): TextOutputExpression | null {
+		if (isOutputElement(element)) {
+			return new this(context, element);
+		}
+
+		return null;
+	}
+
+	readonly source = 'output';
+
+	private constructor(context: AnyTextRangeDefinition, element: OutputElement) {
+		super(context, element.getAttribute('value'));
+	}
+}

package/src/parse/expression/TextReferenceExpression.ts

@@ -0,0 +1,14 @@
+import type { AnyTextRangeDefinition } from '../text/abstract/TextRangeDefinition.ts';
+import { TextChunkExpression } from './abstract/TextChunkExpression.ts';
+
+export class TextReferenceExpression extends TextChunkExpression<'reference'> {
+	static from(context: AnyTextRangeDefinition, refExpression: string): TextReferenceExpression {
+		return new this(context, refExpression);
+	}
+
+	readonly source = 'reference';
+
+	private constructor(context: AnyTextRangeDefinition, refExpression: string) {
+		super(context, refExpression);
+	}
+}

package/src/parse/expression/TextTranslationExpression.ts

@@ -0,0 +1,38 @@
+import { expressionParser } from '@getodk/xpath/expressionParser.js';
+import type { AnyTextRangeDefinition } from '../text/abstract/TextRangeDefinition.ts';
+import type { TranslationExpression } from '../xpath/semantic-analysis.ts';
+import { isTranslationExpression } from '../xpath/semantic-analysis.ts';
+import { TextChunkExpression } from './abstract/TextChunkExpression.ts';
+
+export class TextTranslationExpression extends TextChunkExpression<'translation'> {
+	static fromMessage(
+		context: AnyTextRangeDefinition,
+		maybeExpression: string
+	): TextTranslationExpression | null {
+		try {
+			expressionParser.parse(maybeExpression);
+		} catch {
+			return null;
+		}
+
+		if (isTranslationExpression(maybeExpression)) {
+			return new this(context, maybeExpression);
+		}
+
+		return null;
+	}
+
+	static from(context: AnyTextRangeDefinition, maybeExpression: string) {
+		if (isTranslationExpression(maybeExpression)) {
+			return new this(context, maybeExpression);
+		}
+
+		return null;
+	}
+
+	readonly source = 'translation';
+
+	private constructor(context: AnyTextRangeDefinition, expression: TranslationExpression) {
+		super(context, expression, { isTranslated: true });
+	}
+}

package/src/{expression → parse/expression/abstract}/DependentExpression.ts

@@ -1,10 +1,20 @@
 import type { XFormsXPathEvaluator } from '@getodk/xpath';
-import { getNodesetDependencies, isItextFunctionCalled } from '../lib/xpath/analysis.ts';
+import { resolveDependencyNodesets } from '../../xpath/dependency-analysis.ts';
+import type {
+	ConstantExpression,
+	ConstantTruthyExpression,
+} from '../../xpath/semantic-analysis.ts';
+import {
+	isConstantExpression,
+	isConstantTruthyExpression,
+	isTranslationExpression,
+} from '../../xpath/semantic-analysis.ts';
 import type { DependencyContext } from './DependencyContext.ts';
 
 const evaluatorMethodsByResultType = {
 	boolean: 'evaluateBoolean',
 	nodes: 'evaluateNodes',
+	number: 'evaluateNumber',
 	string: 'evaluateString',
 } as const;
 
@@ -20,11 +30,6 @@ export type DependentExpressionResult<Type extends DependentExpressionResultType
 >;
 
 interface SemanticDependencyOptions {
-	/**
-	 * @default false
-	 */
-	readonly parentContext?: boolean | undefined;
-
 	/**
 	 * @default false
 	 */
@@ -37,18 +42,24 @@ interface DependentExpressionOptions {
 	 */
 	readonly ignoreContextReference?: boolean;
 
-	/**
-	 * @default true
-	 */
-	readonly ignoreNullExpressions?: boolean;
-
 	readonly semanticDependencies?: SemanticDependencyOptions;
 }
 
-export class DependentExpression<Type extends DependentExpressionResultType> {
+export interface ConstantDependentExpression<Type extends DependentExpressionResultType>
+	extends DependentExpression<Type> {
+	readonly expression: ConstantExpression;
+}
+
+export interface ConstantTruthyDependentExpression extends ConstantDependentExpression<'boolean'> {
+	readonly expression: ConstantTruthyExpression;
+}
+
+export abstract class DependentExpression<Type extends DependentExpressionResultType> {
 	readonly dependencyReferences: ReadonlySet<string> = new Set();
 	readonly isTranslated: boolean = false;
 	readonly evaluatorMethod: DependentExpressionEvaluatorMethod<Type>;
+	readonly constantExpression: ConstantExpression | null;
+	readonly constantTruthyExpression: ConstantTruthyExpression | null;
 
 	constructor(
 		context: DependencyContext,
@@ -56,34 +67,33 @@ export class DependentExpression<Type extends DependentExpressionResultType> {
 		readonly expression: string,
 		options: DependentExpressionOptions = {}
 	) {
+		if (resultType === 'boolean' && isConstantTruthyExpression(expression)) {
+			this.constantTruthyExpression = expression;
+			this.constantExpression = expression;
+		} else if (isConstantExpression(expression)) {
+			this.constantTruthyExpression = null;
+			this.constantExpression = expression;
+		} else {
+			this.constantTruthyExpression = null;
+			this.constantExpression = null;
+		}
+
 		this.evaluatorMethod = evaluatorMethodsByResultType[resultType];
 
 		const {
 			ignoreContextReference = false,
-			ignoreNullExpressions = true,
 			semanticDependencies = {
-				parentContext: false,
 				translations: false,
 			},
 		} = options;
 
-		const dependencyReferences = new Set<string>(
-			getNodesetDependencies(expression, {
-				contextReference: context.reference,
-				ignoreContextReference,
-				ignoreNullExpressions,
+		this.dependencyReferences = new Set(
+			resolveDependencyNodesets(context.reference, expression, {
+				ignoreReferenceToContextPath: ignoreContextReference,
 			})
 		);
 
-		const parentDependency = semanticDependencies.parentContext ? context.parentReference : null;
-
-		if (parentDependency != null) {
-			dependencyReferences.add(parentDependency);
-		}
-
-		this.dependencyReferences = dependencyReferences;
-
-		const isTranslated = semanticDependencies.translations && isItextFunctionCalled(expression);
+		const isTranslated = semanticDependencies.translations && isTranslationExpression(expression);
 
 		if (isTranslated) {
 			this.isTranslated = true;
@@ -93,6 +103,14 @@ export class DependentExpression<Type extends DependentExpressionResultType> {
 		context.registerDependentExpression(this);
 	}
 
+	isConstantExpression(): this is ConstantDependentExpression<Type> {
+		return this.constantExpression != null;
+	}
+
+	isConstantTruthyExpression(): this is ConstantTruthyDependentExpression {
+		return this.resultType === 'boolean' && this.constantTruthyExpression != null;
+	}
+
 	toString(): string | null {
 		return this.expression;
 	}

package/src/parse/expression/abstract/TextChunkExpression.ts

@@ -0,0 +1,38 @@
+import type { TextChunkSource } from '../../../client/TextRange.ts';
+import type { AnyTextRangeDefinition } from '../../text/abstract/TextRangeDefinition.ts';
+import type { TextLiteralExpression } from '../TextLiteralExpression.ts';
+import type { TextOutputExpression } from '../TextOutputExpression.ts';
+import type { TextReferenceExpression } from '../TextReferenceExpression.ts';
+import type { TextTranslationExpression } from '../TextTranslationExpression.ts';
+import { DependentExpression } from './DependentExpression.ts';
+
+interface TextChunkExpressionOptions {
+	readonly isTranslated?: true;
+}
+
+export abstract class TextChunkExpression<
+	Source extends TextChunkSource,
+> extends DependentExpression<'string'> {
+	abstract readonly source: Source;
+	readonly stringValue?: string;
+
+	constructor(
+		context: AnyTextRangeDefinition,
+		expression: string,
+		options: TextChunkExpressionOptions = {}
+	) {
+		super(context, 'string', expression, {
+			semanticDependencies: {
+				translations: options.isTranslated,
+			},
+			ignoreContextReference: true,
+		});
+	}
+}
+
+// prettier-ignore
+export type AnyTextChunkExpression =
+	| TextLiteralExpression
+	| TextOutputExpression
+	| TextReferenceExpression
+	| TextTranslationExpression;

package/src/{model → parse/model}/BindDefinition.ts

@@ -1,9 +1,10 @@
+import { DependencyContext } from '../expression/abstract/DependencyContext.ts';
+import type { DependentExpression } from '../expression/abstract/DependentExpression.ts';
+import { BindComputationExpression } from '../expression/BindComputationExpression.ts';
+import { MessageDefinition } from '../text/MessageDefinition.ts';
 import type { XFormDataType } from '../XFormDataType.ts';
 import { bindDataType } from '../XFormDataType.ts';
 import type { XFormDefinition } from '../XFormDefinition.ts';
-import { DependencyContext } from '../expression/DependencyContext.ts';
-import type { DependentExpression } from '../expression/DependentExpression.ts';
-import { BindComputation } from './BindComputation.ts';
 import type { BindElement } from './BindElement.ts';
 import type { ModelDefinition } from './ModelDefinition.ts';
 
@@ -12,28 +13,30 @@ export class BindDefinition extends DependencyContext {
 	readonly dataType: XFormDataType;
 	readonly parentNodeset: string | null;
 
-	readonly calculate: BindComputation<'calculate'> | null;
-	readonly readonly: BindComputation<'readonly'>;
-	readonly relevant: BindComputation<'relevant'>;
-	readonly required: BindComputation<'required'>;
+	readonly calculate: BindComputationExpression<'calculate'> | null;
+	readonly readonly: BindComputationExpression<'readonly'>;
+	readonly relevant: BindComputationExpression<'relevant'>;
+	readonly required: BindComputationExpression<'required'>;
 
-	// According to
-	//
-	// this is not stored in the DAG. In contrast, we do compute constraint
-	// dependencies, but self-references are ignored (handled by `BindComputation`
-	// and its `DependentExpression` parent class).
 	/**
-	 * Diverges from {@link https://github.com/getodk/javarosa/blob/059321160e6f8dbb3e81d9add61d68dd35b13cc8/dag.md | JavaRosa's}, which excludes `constraint` expressions. We compute `constraint` dependencies like the other <bind> computation expressions, but explicitly ignore self-references (this is currently handled by {@link BindComputation}, via its {@link DependentExpression} parent class).
+	 * Diverges from
+	 * {@link https://github.com/getodk/javarosa/blob/059321160e6f8dbb3e81d9add61d68dd35b13cc8/dag.md | JavaRosa's},
+	 * which excludes `constraint` expressions. We compute `constraint`
+	 * dependencies like the other <bind> computation expressions, but explicitly
+	 * ignore self-references (this is currently handled by
+	 * {@link BindComputationExpression}, via its {@link DependentExpression}
+	 * super class).
 	 */
-	readonly constraint: BindComputation<'constraint'> & DependentExpression<'boolean'>;
+	readonly constraint: BindComputationExpression<'constraint'>;
+
+	readonly constraintMsg: MessageDefinition<'constraintMsg'> | null;
+	readonly requiredMsg: MessageDefinition<'requiredMsg'> | null;
 
 	// TODO: it is unclear whether this will need to be supported.
 	// https://github.com/getodk/collect/issues/3758 mentions deprecation.
-	readonly saveIncomplete: BindComputation<'saveIncomplete'>;
+	readonly saveIncomplete: BindComputationExpression<'saveIncomplete'>;
 
-	// TODO: these are deferred just to put off sharing namespace stuff
-	// readonly requiredMsg: string | null;
-	// readonly constraintMsg: string | null;
+	// TODO: these are deferred until prioritized
 	// readonly preload: string | null;
 	// readonly preloadParams: string | null;
 	// readonly 'max-pixels': string | null;
@@ -82,15 +85,15 @@ export class BindDefinition extends DependencyContext {
 		const parentNodeset = nodeset.replace(/\/[^/]+$/, '');
 
 		this.parentNodeset = parentNodeset.length > 1 ? parentNodeset : null;
-		this.calculate = BindComputation.forExpression(this, 'calculate');
-		this.readonly = BindComputation.forExpression(this, 'readonly');
-		this.relevant = BindComputation.forExpression(this, 'relevant');
-		this.required = BindComputation.forExpression(this, 'required');
-		this.constraint = BindComputation.forExpression(this, 'constraint');
-		this.saveIncomplete = BindComputation.forExpression(this, 'saveIncomplete');
-
-		// this.requiredMsg = BindComputation.forExpression(this, 'requiredMsg');
-		// this.constraintMsg = BindComputation.forExpression(this, 'constraintMsg');
+		this.calculate = BindComputationExpression.forComputation(this, 'calculate');
+		this.readonly = BindComputationExpression.forComputation(this, 'readonly');
+		this.relevant = BindComputationExpression.forComputation(this, 'relevant');
+		this.required = BindComputationExpression.forComputation(this, 'required');
+		this.constraint = BindComputationExpression.forComputation(this, 'constraint');
+		this.saveIncomplete = BindComputationExpression.forComputation(this, 'saveIncomplete');
+		this.constraintMsg = MessageDefinition.from(this, 'constraintMsg');
+		this.requiredMsg = MessageDefinition.from(this, 'requiredMsg');
+
 		// this.preload = BindComputation.forExpression(this, 'preload');
 		// this.preloadParams = BindComputation.forExpression(this, 'preloadParams');
 		// this['max-pixels'] = BindComputation.forExpression(this, 'max-pixels');

package/src/{model → parse/model}/BindElement.ts

@@ -5,4 +5,5 @@ export interface BindElement {
 
 	getAttribute(name: 'nodeset'): BindNodeset;
 	getAttribute(name: string): string | null;
+	getAttributeNS(namespaceURI: string | null, localName: string): string | null;
 }

package/src/{model/ValueNodeDefinition.ts → parse/model/LeafNodeDefinition.ts}

@@ -3,11 +3,11 @@ import type { BindDefinition } from './BindDefinition.ts';
 import { DescendentNodeDefinition } from './DescendentNodeDefinition.ts';
 import type { NodeDefinition, ParentNodeDefinition } from './NodeDefinition.ts';
 
-export class ValueNodeDefinition
-	extends DescendentNodeDefinition<'value-node', ControlElementDefinition | null>
-	implements NodeDefinition<'value-node'>
+export class LeafNodeDefinition
+	extends DescendentNodeDefinition<'leaf-node', ControlElementDefinition | null>
+	implements NodeDefinition<'leaf-node'>
 {
-	readonly type = 'value-node';
+	readonly type = 'leaf-node';
 
 	readonly nodeName: string;
 	readonly children = null;