@getodk/xforms-engine 0.1.1 → 0.3.0

package/src/instance/text/TextRange.ts

@@ -1,9 +1,14 @@
-import type { TextRange as ClientTextRange, TextChunk } from '../../client/TextRange.ts';
+import type {
+	TextRange as ClientTextRange,
+	TextChunk,
+	TextOrigin,
+	TextRole,
+} from '../../client/TextRange.ts';
 import { FormattedTextStub } from './FormattedTextStub.ts';
 
-export type TextRole = 'hint' | 'label';
-
-export class TextRange<Role extends TextRole> implements ClientTextRange<Role> {
+export class TextRange<Role extends TextRole, Origin extends TextOrigin>
+	implements ClientTextRange<Role, Origin>
+{
 	*[Symbol.iterator]() {
 		yield* this.chunks;
 	}
@@ -17,6 +22,7 @@ export class TextRange<Role extends TextRole> implements ClientTextRange<Role> {
 	}
 
 	constructor(
+		readonly origin: Origin,
 		readonly role: Role,
 		protected readonly chunks: readonly TextChunk[]
 	) {}

package/src/lib/TokenListParser.ts

@@ -0,0 +1,156 @@
+import { xmlXPathWhitespaceSeparatedList } from '@getodk/common/lib/string/whitespace.ts';
+import type { PartiallyKnownString } from '@getodk/common/types/string/PartiallyKnownString.ts';
+
+type SymbolIterator = typeof Symbol.iterator;
+
+type TokenListKey<CanonicalToken extends string> =
+	| PartiallyKnownString<CanonicalToken>
+	| SymbolIterator;
+
+type TokenListIterator<CanonicalToken extends string> = IterableIterator<
+	PartiallyKnownString<CanonicalToken>
+>;
+
+/**
+ * @see {@link TokenListParser}
+ */
+// prettier-ignore
+export type TokenList<CanonicalToken extends string = string> = {
+	readonly [Key in TokenListKey<CanonicalToken>]:
+		Key extends SymbolIterator
+			? () => TokenListIterator<CanonicalToken>
+			: boolean;
+};
+
+interface TokenListAlias<CanonicalToken extends string> {
+	readonly fromAlias: string;
+	readonly toCanonical: CanonicalToken;
+}
+
+type TokenAliases<CanonicalToken extends string> = ReadonlyArray<TokenListAlias<CanonicalToken>>;
+
+interface TokenListParserOptions<CanonicalToken extends string> {
+	readonly aliases?: TokenAliases<CanonicalToken>;
+}
+
+type TokenListAttributeName = PartiallyKnownString<'appearance' | 'class'>;
+
+/**
+ * Intended primarily for use in parsing these features:
+ *
+ * - {@link https://getodk.github.io/xforms-spec/#appearances | appearances} ({@link https://xlsform.org/en/#appearance | additional documentation})
+ *
+ * - {@link https://getodk.github.io/xforms-spec/#body-attributes | body `class` attribute}
+ *
+ * This class is named as a reference to {@link DOMTokenList}
+ * ({@link https://developer.mozilla.org/en-US/docs/Web/API/DOMTokenList | MDN}),
+ * with these similarities:
+ *
+ * - Represents a value whose serialization is a space-separated list.
+ * - Each member ("token") is a string (without whitespace).
+ * - Provides set-like semantics to determine presence of members.
+ * - Provides ordering semantics as determined by the serialization.
+ *
+ * This class differs from that prior art in that:
+ *
+ * - It provides a notion of "canonical" members. This is _mostly_ (but not
+ *   entirely) intended as a convenience to client developers, automatically
+ *   populating canonical/known tokens for a given parser type in
+ *   editor-provided autocomplete, etc. **Importantly**, non-canonical tokens
+ *   _are not ignored_ in either the {@link TokenList}'s types or runtime
+ *   values.
+ *
+ * - Provided "canonical" members may also be used to specify
+ *   {@link TokenListParserOptions.aliases | optional aliases}. (Example: when
+ *   parsing "appearances", an alias might map an older deprecated appearance to
+ *   a newer canonical equivalent.) **Importantly**, when a token matches an
+ *   alias, both that alias _and the token as-specified_ will be present in the
+ *   produced {@link TokenList}.
+ *
+ * - As a parser, it is intended to be read-only. The serialized format which it
+ *   parses is _generally_ the source of truth (excepting e.g. aliases).
+ *   Notably, and as mentioned above, ordering is determined by:
+ *
+ *     - Iterating each member, as provided by the serialized representation
+ *
+ *     - If that member corresponds to an alias, that alias is yielded first
+ *
+ *     - Regardless of whether the member corresponds to an alias, the member is
+ *       yielded as-specified
+ *
+ * - A parsed {@link TokenList} is intended to maximize convenience of read-only
+ *   access. Despite many _conceptual similarities_, most of the
+ *   {@link DOMTokenList} **interface** is eschewed in favor of two (mutually
+ *   equivalent) access mechanisms:
+ *
+ *     - `Iterable<Token>`, with the ordering semantics described above
+ *     - `Record<Token, boolean>`
+ *
+ * \* This may change, as we refine requirements. In the future, we may
+ * introduce a notion of mutually exclusive tokens (e.g. "appearances" which
+ * cannot be used together), which may in turn utilize instance-defined ordering
+ * as part of that mechanism.
+ */
+export class TokenListParser<
+	CanonicalToken extends string,
+	// Note: this is a separate type parameter so that specifying an alias does
+	// not cause it to be mistakenly inferred as a `CanonicalToken` which was
+	// not otherwise specified.
+	TokenAlias extends CanonicalToken = CanonicalToken,
+> {
+	private readonly aliases: ReadonlyMap<string, CanonicalToken>;
+
+	constructor(
+		readonly canonicalTokens: readonly CanonicalToken[],
+		options?: TokenListParserOptions<TokenAlias>
+	) {
+		this.aliases = new Map(
+			(options?.aliases ?? []).map(({ fromAlias, toCanonical }) => {
+				return [fromAlias, toCanonical];
+			})
+		);
+	}
+
+	parseFrom(element: Element, attributeName: TokenListAttributeName): TokenList<CanonicalToken> {
+		const serialized = element.getAttribute(attributeName) ?? '';
+		const specified = xmlXPathWhitespaceSeparatedList(serialized, {
+			ignoreEmpty: true,
+		});
+		const { aliases } = this;
+		const resolved = specified.flatMap((token) => {
+			const alias = aliases.get(token);
+
+			if (alias == null) {
+				return token;
+			}
+
+			return [alias, token];
+		});
+		const tokens = new Set(resolved);
+
+		return new Proxy(
+			{
+				[Symbol.iterator]() {
+					return resolved.values();
+				},
+			} satisfies TokenList<string> as TokenList<CanonicalToken>,
+			{
+				get(target, property, receiver) {
+					if (typeof property === 'symbol') {
+						return Reflect.get(target, property, receiver);
+					}
+
+					return tokens.has(property);
+				},
+
+				set() {
+					return false;
+				},
+			}
+		);
+	}
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type ParsedTokenList<Parser extends TokenListParser<any>> =
+	Parser extends TokenListParser<infer CanonicalToken> ? TokenList<CanonicalToken> : never;

package/src/lib/dom/query.ts

@@ -9,6 +9,10 @@ const hintLookup = new ScopedElementLookup(':scope > hint', 'hint');
 const itemLookup = new ScopedElementLookup(':scope > item', 'item');
 const itemsetLookup = new ScopedElementLookup(':scope > itemset[nodeset]', 'itemset[nodeset]');
 const labelLookup = new ScopedElementLookup(':scope > label', 'label');
+const repeatGroupLabelLookup = new ScopedElementLookup(
+	':scope > label[form-definition-source="repeat-group"]',
+	'label[form-definition-source="repeat-group"]'
+);
 const repeatLookup = new ScopedElementLookup(':scope > repeat[nodeset]', 'repeat[nodeset]');
 const valueLookup = new ScopedElementLookup(':scope > value', 'value');
 
@@ -20,6 +24,11 @@ export interface ItemsetElement extends KnownAttributeLocalNamedElement<'itemset
 
 export interface LabelElement extends LocalNamedElement<'label'> {}
 
+export interface RepeatGroupLabelElement extends LabelElement {
+	getAttribute(name: 'form-definition-source'): 'repeat-group';
+	getAttribute(name: string): string;
+}
+
 export interface RepeatElement extends KnownAttributeLocalNamedElement<'repeat', 'nodeset'> {}
 
 export interface ValueElement extends LocalNamedElement<'value'> {}
@@ -40,6 +49,10 @@ export const getLabelElement = (parent: Element): LabelElement | null => {
 	return labelLookup.getElement<LabelElement>(parent);
 };
 
+export const getRepeatGroupLabelElement = (parent: Element): RepeatGroupLabelElement | null => {
+	return repeatGroupLabelLookup.getElement<RepeatGroupLabelElement>(parent);
+};
+
 export const getRepeatElement = (parent: Element): RepeatElement | null => {
 	return repeatLookup.getElement<RepeatElement>(parent);
 };

package/src/lib/reactivity/createChildrenState.ts

@@ -1,4 +1,5 @@
-import { createMemo, createSignal, type Accessor, type Setter, type Signal } from 'solid-js';
+import type { Accessor, Setter, Signal } from 'solid-js';
+import { createSignal } from 'solid-js';
 import type { OpaqueReactiveObjectFactory } from '../../index.ts';
 import type { AnyChildNode, AnyParentNode } from '../../instance/hierarchy.ts';
 import type { NodeID } from '../../instance/identity.ts';
@@ -44,11 +45,55 @@ export const createChildrenState = <Parent extends AnyParentNode, Child extends
 	parent: Parent
 ): ChildrenState<Child> => {
 	return parent.scope.runTask(() => {
-		const children = createSignal<readonly Child[]>([]);
-		const [getChildren, setChildren] = children;
-		const childIds = createMemo((): readonly NodeID[] => {
-			return getChildren().map((child) => child.nodeId);
-		});
+		const baseState = createSignal<readonly Child[]>([]);
+		const [getChildren, baseSetChildren] = baseState;
+
+		/**
+		 * Note: this is clearly derived state. It would be obvious to use
+		 * `createMemo`, which is exactly what a previous iteration did. This caused
+		 * mysterious issues when clients:
+		 *
+		 * - Also used Solid-based reactivity
+		 * - Accessed node children state within their own `createMemo` calls
+		 *
+		 * It's quite likely that there's a more robust and general solution, which
+		 * may be applicable if we also generalize this approach to
+		 * encode/materialize shared structured state (e.g. it may be applicable for
+		 * select values, form language, probably much more in coming features).
+		 *
+		 * In the meantime, while this approach is marginally more complex, it is
+		 * likely also slightly more efficient. We can revisit the tradeoff if/when
+		 * those hypothetical generalizations become a priority.
+		 */
+		const ids = createSignal<readonly NodeID[]>([]);
+		const [childIds, setChildIds] = ids;
+
+		type ChildrenSetterCallback = (prev: readonly Child[]) => readonly Child[];
+		type ChildrenOrSetterCallback = ChildrenSetterCallback | readonly Child[];
+
+		const setChildren: Setter<readonly Child[]> = (
+			valueOrSetterCallback: ChildrenOrSetterCallback
+		) => {
+			let setterCallback: ChildrenSetterCallback;
+
+			if (typeof valueOrSetterCallback === 'function') {
+				setterCallback = valueOrSetterCallback;
+			} else {
+				setterCallback = (_) => valueOrSetterCallback;
+			}
+
+			return baseSetChildren((prev) => {
+				const result = setterCallback(prev);
+
+				setChildIds(() => {
+					return result.map((child) => child.nodeId);
+				});
+
+				return result;
+			});
+		};
+
+		const children: Signal<readonly Child[]> = [getChildren, setChildren];
 
 		return {
 			children,

package/src/lib/reactivity/createComputedExpression.ts

@@ -8,10 +8,12 @@ import type {
 } from '../../expression/DependentExpression.ts';
 import type { EvaluationContext } from '../../instance/internal-api/EvaluationContext.ts';
 import type { SubscribableDependency } from '../../instance/internal-api/SubscribableDependency.ts';
+import { isConstantExpression } from '../../parse/xpath/semantic-analysis.ts';
 
 interface ComputedExpressionResults {
 	readonly boolean: boolean;
 	readonly nodes: Node[];
+	readonly number: number;
 	readonly string: string;
 }
 
@@ -44,6 +46,11 @@ const expressionEvaluator = <Type extends DependentExpressionResultType>(
 				return evaluator.evaluateNodes(expression, options);
 			}) as ExpressionEvaluator<Type>;
 
+		case 'number':
+			return (() => {
+				return evaluator.evaluateNumber(expression, options);
+			}) as ExpressionEvaluator<Type>;
+
 		case 'string':
 			return (() => {
 				return evaluator.evaluateString(expression, options);
@@ -54,26 +61,19 @@ const expressionEvaluator = <Type extends DependentExpressionResultType>(
 	}
 };
 
-/**
- * Determines if an XPath expression will always produce the same value.
- *
- * @todo There are quite a few more cases than this, and it also likely belongs
- * in another `lib` module.
- */
-const isConstantExpression = (expression: string): boolean => {
-	const normalized = expression.replaceAll(/\s/g, '');
-
-	return normalized === 'true()' || normalized === 'false()';
-};
-
 // prettier-ignore
 type ComputedExpression<Type extends DependentExpressionResultType> = Accessor<
 	EvaluatedExpression<Type>
 >;
 
+interface CreateComputedExpressionOptions {
+	readonly arbitraryDependencies?: readonly SubscribableDependency[];
+}
+
 export const createComputedExpression = <Type extends DependentExpressionResultType>(
 	context: EvaluationContext,
-	dependentExpression: DependentExpression<Type>
+	dependentExpression: DependentExpression<Type>,
+	options: CreateComputedExpressionOptions = {}
 ): ComputedExpression<Type> => {
 	const { contextNode, evaluator, root, scope } = context;
 	const { expression, isTranslated, resultType } = dependentExpression;
@@ -85,26 +85,24 @@ export const createComputedExpression = <Type extends DependentExpressionResultT
 			return createMemo(evaluateExpression);
 		}
 
+		const { arbitraryDependencies = [] } = options;
+
 		const getReferencedDependencies = createMemo(() => {
 			return dependencyReferences.flatMap((reference) => {
-				return context.getSubscribableDependencyByReference(reference) ?? [];
+				return context.getSubscribableDependenciesByReference(reference) ?? [];
 			});
 		});
 
-		let getDependencies: Accessor<readonly SubscribableDependency[]>;
+		return createMemo(() => {
+			if (isTranslated) {
+				root.subscribe();
+			}
 
-		if (isTranslated) {
-			getDependencies = createMemo(() => {
-				return [root, ...getReferencedDependencies()];
+			arbitraryDependencies.forEach((dependency) => {
+				dependency.subscribe();
 			});
-		} else {
-			getDependencies = getReferencedDependencies;
-		}
-
-		return createMemo(() => {
-			const dependencies = getDependencies();
 
-			dependencies.forEach((dependency) => {
+			getReferencedDependencies().forEach((dependency) => {
 				dependency.subscribe();
 			});
 

package/src/lib/reactivity/createNoteReadonlyThunk.ts

@@ -0,0 +1,33 @@
+import type { Accessor } from 'solid-js';
+import type { EvaluationContext } from '../../instance/internal-api/EvaluationContext.ts';
+import type { BindComputation } from '../../model/BindComputation.ts';
+import { createComputedExpression } from './createComputedExpression.ts';
+
+export const createNoteReadonlyThunk = (
+	context: EvaluationContext,
+	readonlyDefinition: BindComputation<'readonly'>
+): Accessor<true> => {
+	if (!readonlyDefinition.isConstantTruthyExpression()) {
+		throw new Error('Expected a static readonly expression');
+	}
+
+	let result = true;
+
+	if (import.meta.env.DEV) {
+		const { expression } = readonlyDefinition;
+
+		if (readonlyDefinition.dependencyReferences.size > 0) {
+			throw new Error(`Expected expression ${expression} to have no dependencies`);
+		}
+
+		const computedExpression = createComputedExpression(context, readonlyDefinition);
+
+		result = computedExpression();
+
+		if (result !== true) {
+			throw new Error(`Expected expression ${readonlyDefinition.expression} to return true`);
+		}
+	}
+
+	return () => result;
+};

package/src/lib/reactivity/createSelectItems.ts

@@ -4,6 +4,7 @@ import type { Accessor } from 'solid-js';
 import { createMemo } from 'solid-js';
 import type { ItemDefinition } from '../../body/control/select/ItemDefinition.ts';
 import type { ItemsetDefinition } from '../../body/control/select/ItemsetDefinition.ts';
+import type { TextRange as ClientTextRange } from '../../client/TextRange.ts';
 import type { SelectItem } from '../../index.ts';
 import type { SelectField } from '../../instance/SelectField.ts';
 import type {
@@ -11,20 +12,31 @@ import type {
 	EvaluationContextRoot,
 } from '../../instance/internal-api/EvaluationContext.ts';
 import type { SubscribableDependency } from '../../instance/internal-api/SubscribableDependency.ts';
-import type { TextRange } from '../../instance/text/TextRange.ts';
+import { TextChunk } from '../../instance/text/TextChunk.ts';
+import { TextRange } from '../../instance/text/TextRange.ts';
 import { createComputedExpression } from './createComputedExpression.ts';
 import type { ReactiveScope } from './scope.ts';
 import { createTextRange } from './text/createTextRange.ts';
 
+type DerivedItemLabel = ClientTextRange<'item-label', 'form-derived'>;
+
+const derivedItemLabel = (context: EvaluationContext, value: string): DerivedItemLabel => {
+	const chunk = new TextChunk(context.root, 'static', value);
+
+	return new TextRange('form-derived', 'item-label', [chunk]);
+};
+
 const createSelectItemLabel = (
 	context: EvaluationContext,
 	definition: ItemDefinition
-): Accessor<TextRange<'label'>> => {
+): Accessor<ClientTextRange<'item-label'>> => {
 	const { label, value } = definition;
 
-	return createTextRange(context, 'label', label, {
-		fallbackValue: value,
-	});
+	if (label == null) {
+		return () => derivedItemLabel(context, value);
+	}
+
+	return createTextRange(context, 'item-label', label);
 };
 
 const createTranslatedStaticSelectItems = (
@@ -52,10 +64,7 @@ class ItemsetItemEvaluationContext implements EvaluationContext {
 	readonly scope: ReactiveScope;
 	readonly evaluator: XFormsXPathEvaluator;
 	readonly root: EvaluationContextRoot;
-
-	get contextReference(): string {
-		return this.selectField.contextReference;
-	}
+	readonly contextReference: Accessor<string>;
 
 	constructor(
 		private readonly selectField: SelectField,
@@ -64,10 +73,11 @@ class ItemsetItemEvaluationContext implements EvaluationContext {
 		this.scope = selectField.scope;
 		this.evaluator = selectField.evaluator;
 		this.root = selectField.root;
+		this.contextReference = selectField.contextReference;
 	}
 
-	getSubscribableDependencyByReference(reference: string): SubscribableDependency | null {
-		return this.selectField.getSubscribableDependencyByReference(reference);
+	getSubscribableDependenciesByReference(reference: string): readonly SubscribableDependency[] {
+		return this.selectField.getSubscribableDependenciesByReference(reference);
 	}
 }
 
@@ -75,25 +85,20 @@ const createSelectItemsetItemLabel = (
 	context: EvaluationContext,
 	definition: ItemsetDefinition,
 	itemValue: Accessor<string>
-): Accessor<TextRange<'label'>> => {
+): Accessor<ClientTextRange<'item-label'>> => {
 	const { label } = definition;
 
 	if (label == null) {
 		return createMemo(() => {
-			const value = itemValue();
-			const staticValueLabel = createTextRange(context, 'label', label, {
-				fallbackValue: value,
-			});
-
-			return staticValueLabel();
+			return derivedItemLabel(context, itemValue());
 		});
 	}
 
-	return createTextRange(context, 'label', label);
+	return createTextRange(context, 'item-label', label);
 };
 
 interface ItemsetItem {
-	label(): TextRange<'label'>;
+	label(): ClientTextRange<'item-label'>;
 	value(): string;
 }
 

package/src/lib/reactivity/createValueState.ts

@@ -72,7 +72,7 @@ const createPrimaryInstanceValueState = <RuntimeValue>(
 
 		const persistedValueState = createSignal<PersistedValueState>(
 			{
-				isRelevant: context.isRelevant,
+				isRelevant: context.isRelevant(),
 				value: initialValue,
 			},
 			{
@@ -91,7 +91,7 @@ const createPrimaryInstanceValueState = <RuntimeValue>(
 		const [persistedValue, setValueForPersistence] = persistedValueState;
 
 		createComputed(() => {
-			const isRelevant = context.isRelevant;
+			const isRelevant = context.isRelevant();
 
 			setValueForPersistence((persisted) => {
 				return {
@@ -122,7 +122,7 @@ const createPrimaryInstanceValueState = <RuntimeValue>(
 		const setPrimaryInstanceValue: SimpleAtomicStateSetter<string> = (value) => {
 			// TODO: Check (error?) for non-relevant value change?
 			const persisted = setValueForPersistence({
-				isRelevant: context.isRelevant,
+				isRelevant: context.isRelevant(),
 				value,
 			});
 
@@ -189,8 +189,8 @@ const guardDownstreamReadonlyWrites = <RuntimeValue>(
 	const [getValue, baseSetValue] = baseState;
 
 	const setValue: SimpleAtomicStateSetter<RuntimeValue> = (value) => {
-		if (context.isReadonly) {
-			const reference = untrack(() => context.contextReference);
+		if (context.isReadonly()) {
+			const reference = untrack(() => context.contextReference());
 
 			throw new Error(`Cannot write to readonly field: ${reference}`);
 		}
@@ -215,7 +215,7 @@ const createCalculation = <RuntimeValue>(
 		const calculate = createComputedExpression(context, calculateDefinition);
 
 		createComputed(() => {
-			if (context.isRelevant) {
+			if (context.isRelevant()) {
 				const calculated = calculate();
 				const value = context.decodeValue(calculated);
 

package/src/lib/reactivity/materializeCurrentStateChildren.ts

@@ -3,6 +3,7 @@ import type { NodeID } from '../../instance/identity.ts';
 import type { ChildrenState, createChildrenState } from './createChildrenState.ts';
 import type { ClientState } from './node-state/createClientState.ts';
 import type { CurrentState } from './node-state/createCurrentState.ts';
+import type { ReactiveScope } from './scope.ts';
 
 interface InconsistentChildrenStateDetails {
 	readonly missingIds: readonly NodeID[];
@@ -96,6 +97,7 @@ export const materializeCurrentStateChildren = <
 	Child extends AnyChildNode,
 	ParentState extends EncodedParentState,
 >(
+	scope: ReactiveScope,
 	currentState: ParentState,
 	childrenState: ChildrenState<Child>
 ): MaterializedChildren<ParentState, Child> => {
@@ -105,7 +107,7 @@ export const materializeCurrentStateChildren = <
 	return new Proxy(proxyTarget, {
 		get(_, key) {
 			if (key === 'children') {
-				const expectedChildIDs = currentState.children;
+				const expectedChildIDs = scope.runTask(() => currentState.children);
 				const children = childrenState.getChildren();
 
 				if (import.meta.env.DEV) {

package/src/lib/reactivity/node-state/createSharedNodeState.ts

@@ -31,7 +31,7 @@ export interface SharedNodeState<Spec extends StateSpec> {
 	readonly setProperty: SetEnginePropertyState<Spec>;
 }
 
-interface SharedNodeStateOptions<
+export interface SharedNodeStateOptions<
 	Factory extends OpaqueReactiveObjectFactory,
 	Spec extends StateSpec,
 > {

package/src/lib/reactivity/text/createFieldHint.ts

@@ -1,16 +1,18 @@
 import { type Accessor } from 'solid-js';
+import type { TextRange } from '../../../client/TextRange.ts';
 import type { EvaluationContext } from '../../../instance/internal-api/EvaluationContext.ts';
-import { TextRange } from '../../../instance/text/TextRange.ts';
-import type { ValueNodeDefinition } from '../../../model/ValueNodeDefinition.ts';
+import type { LeafNodeDefinition } from '../../../model/LeafNodeDefinition.ts';
 import { createTextRange } from './createTextRange.ts';
 
 export const createFieldHint = (
 	context: EvaluationContext,
-	definition: ValueNodeDefinition
-): Accessor<TextRange<'hint'> | null> => {
+	definition: LeafNodeDefinition
+): Accessor<TextRange<'hint', 'form'> | null> => {
 	const hintDefinition = definition.bodyElement?.hint ?? null;
 
-	return createTextRange(context, 'hint', hintDefinition, {
-		fallbackValue: null,
-	});
+	if (hintDefinition == null) {
+		return () => null;
+	}
+
+	return createTextRange(context, 'hint', hintDefinition);
 };

package/src/lib/reactivity/text/createNodeLabel.ts

@@ -1,16 +1,18 @@
 import { type Accessor } from 'solid-js';
+import type { TextRange } from '../../../client/TextRange.ts';
 import type { EvaluationContext } from '../../../instance/internal-api/EvaluationContext.ts';
-import { TextRange } from '../../../instance/text/TextRange.ts';
 import type { AnyNodeDefinition } from '../../../model/NodeDefinition.ts';
 import { createTextRange } from './createTextRange.ts';
 
 export const createNodeLabel = (
 	context: EvaluationContext,
 	definition: AnyNodeDefinition
-): Accessor<TextRange<'label'> | null> => {
+): Accessor<TextRange<'label', 'form'> | null> => {
 	const labelDefinition = definition.bodyElement?.label ?? null;
 
-	return createTextRange(context, 'label', labelDefinition, {
-		fallbackValue: null,
-	});
+	if (labelDefinition == null) {
+		return () => null;
+	}
+
+	return createTextRange(context, 'label', labelDefinition);
 };