@getodk/xforms-engine 0.3.0 → 0.4.0

package/src/instance/TriggerControl.ts

@@ -0,0 +1,134 @@
+import type { Accessor } from 'solid-js';
+import type { TextRange } from '../client/TextRange.ts';
+import type { TriggerNode, TriggerNodeDefinition } from '../client/TriggerNode.ts';
+import type { AnyViolation, LeafNodeValidationState } from '../client/validation.ts';
+import { createValueState } from '../lib/reactivity/createValueState.ts';
+import type { CurrentState } from '../lib/reactivity/node-state/createCurrentState.ts';
+import type { EngineState } from '../lib/reactivity/node-state/createEngineState.ts';
+import type { SharedNodeState } from '../lib/reactivity/node-state/createSharedNodeState.ts';
+import { createSharedNodeState } from '../lib/reactivity/node-state/createSharedNodeState.ts';
+import { createFieldHint } from '../lib/reactivity/text/createFieldHint.ts';
+import { createNodeLabel } from '../lib/reactivity/text/createNodeLabel.ts';
+import type { SimpleAtomicState } from '../lib/reactivity/types.ts';
+import type { SharedValidationState } from '../lib/reactivity/validation/createValidation.ts';
+import { createValidationState } from '../lib/reactivity/validation/createValidation.ts';
+import type { UnknownAppearanceDefinition } from '../parse/body/appearance/unknownAppearanceParser.ts';
+import type { Root } from './Root.ts';
+import type { DescendantNodeStateSpec } from './abstract/DescendantNode.ts';
+import { DescendantNode } from './abstract/DescendantNode.ts';
+import type { GeneralParentNode } from './hierarchy.ts';
+import type { EvaluationContext } from './internal-api/EvaluationContext.ts';
+import type { SubscribableDependency } from './internal-api/SubscribableDependency.ts';
+import type { ValidationContext } from './internal-api/ValidationContext.ts';
+import type { ValueContext } from './internal-api/ValueContext.ts';
+
+interface TriggerControlStateSpec extends DescendantNodeStateSpec<boolean> {
+	readonly label: Accessor<TextRange<'label'> | null>;
+	readonly hint: Accessor<TextRange<'hint'> | null>;
+	readonly children: null;
+	readonly value: SimpleAtomicState<boolean>;
+	readonly valueOptions: null;
+}
+
+const TRIGGER_ASSIGNED_VALUE = 'OK';
+
+export class TriggerControl
+	extends DescendantNode<TriggerNodeDefinition, TriggerControlStateSpec, null>
+	implements
+		TriggerNode,
+		EvaluationContext,
+		SubscribableDependency,
+		ValidationContext,
+		ValueContext<boolean>
+{
+	private readonly validation: SharedValidationState;
+	protected readonly state: SharedNodeState<TriggerControlStateSpec>;
+
+	// InstanceNode
+	protected engineState: EngineState<TriggerControlStateSpec>;
+
+	// TriggerNode
+	readonly nodeType = 'trigger';
+	readonly appearances: UnknownAppearanceDefinition;
+	readonly currentState: CurrentState<TriggerControlStateSpec>;
+
+	get validationState(): LeafNodeValidationState {
+		return this.validation.currentState;
+	}
+
+	// ValueContext
+	readonly encodeValue: (runtimeValue: boolean) => string;
+	readonly decodeValue: (instanceValue: string) => boolean;
+
+	constructor(parent: GeneralParentNode, definition: TriggerNodeDefinition) {
+		super(parent, definition);
+
+		this.appearances = definition.bodyElement.appearances;
+		this.encodeValue = (runtimeValue) => {
+			return runtimeValue ? TRIGGER_ASSIGNED_VALUE : '';
+		};
+		this.decodeValue = (instanceValue) => {
+			const value = instanceValue.trim();
+
+			switch (value) {
+				case TRIGGER_ASSIGNED_VALUE:
+					return true;
+
+				case '':
+					return false;
+
+				// TODO (robustness principle): Case insensitivity? Handle
+				// XPath-semantic booleans?? Other known/common equivalents?
+				default:
+					throw new Error(`Unexpected trigger value: ${value}`);
+			}
+		};
+
+		const sharedStateOptions = {
+			clientStateFactory: this.engineConfig.stateFactory,
+		};
+
+		const state = createSharedNodeState(
+			this.scope,
+			{
+				reference: this.contextReference,
+				readonly: this.isReadonly,
+				relevant: this.isRelevant,
+				required: this.isRequired,
+
+				label: createNodeLabel(this, definition),
+				hint: createFieldHint(this, definition),
+				children: null,
+				valueOptions: null,
+				value: createValueState(this),
+			},
+			sharedStateOptions
+		);
+
+		this.state = state;
+		this.engineState = state.engineState;
+		this.currentState = state.currentState;
+		this.validation = createValidationState(this, sharedStateOptions);
+	}
+
+	// ValidationContext
+	getViolation(): AnyViolation | null {
+		return this.validation.engineState.violation;
+	}
+
+	isBlank(): boolean {
+		return this.engineState.value == null;
+	}
+
+	// InstanceNode
+	getChildren(): readonly [] {
+		return [];
+	}
+
+	// TriggerNode
+	setValue(value: boolean): Root {
+		this.state.setProperty('value', value);
+
+		return this.root;
+	}
+}

package/src/instance/abstract/DescendantNode.ts

@@ -3,10 +3,10 @@ import type { Accessor } from 'solid-js';
 import type { BaseNode } from '../../client/BaseNode.ts';
 import { createComputedExpression } from '../../lib/reactivity/createComputedExpression.ts';
 import type { ReactiveScope } from '../../lib/reactivity/scope.ts';
-import type { AnyDescendantNodeDefinition } from '../../model/DescendentNodeDefinition.ts';
-import type { LeafNodeDefinition } from '../../model/LeafNodeDefinition.ts';
-import type { AnyNodeDefinition } from '../../model/NodeDefinition.ts';
-import type { RepeatInstanceDefinition } from '../../model/RepeatInstanceDefinition.ts';
+import type { AnyDescendantNodeDefinition } from '../../parse/model/DescendentNodeDefinition.ts';
+import type { LeafNodeDefinition } from '../../parse/model/LeafNodeDefinition.ts';
+import type { AnyNodeDefinition } from '../../parse/model/NodeDefinition.ts';
+import type { RepeatInstanceDefinition } from '../../parse/model/RepeatInstanceDefinition.ts';
 import type { AnyChildNode, GeneralParentNode, RepeatRange } from '../hierarchy.ts';
 import type { EvaluationContext } from '../internal-api/EvaluationContext.ts';
 import type { SubscribableDependency } from '../internal-api/SubscribableDependency.ts';

package/src/instance/abstract/InstanceNode.ts

@@ -12,7 +12,7 @@ import type { SharedNodeState } from '../../lib/reactivity/node-state/createShar
 import type { ReactiveScope } from '../../lib/reactivity/scope.ts';
 import { createReactiveScope } from '../../lib/reactivity/scope.ts';
 import type { SimpleAtomicState } from '../../lib/reactivity/types.ts';
-import type { AnyNodeDefinition } from '../../model/NodeDefinition.ts';
+import type { AnyNodeDefinition } from '../../parse/model/NodeDefinition.ts';
 import type { Root } from '../Root.ts';
 import type { AnyChildNode, AnyNode, AnyParentNode } from '../hierarchy.ts';
 import type { NodeID } from '../identity.ts';
@@ -246,9 +246,17 @@ export abstract class InstanceNode<
 		// subscriptions would be established by evaluation of the expressions
 		// themselves (as they traverse instance state and access values), rather
 		// than this safer/less focused approach.
+
+		// TODO: typescript-eslint is right to object to these! We should _at least_
+		// make internal reactive reads obvious, i.e. function calls.
+
+		// eslint-disable-next-line @typescript-eslint/no-unused-expressions
 		engineState.reference;
+		// eslint-disable-next-line @typescript-eslint/no-unused-expressions
 		engineState.relevant;
+		// eslint-disable-next-line @typescript-eslint/no-unused-expressions
 		engineState.children;
+		// eslint-disable-next-line @typescript-eslint/no-unused-expressions
 		engineState.value;
 	}
 }

package/src/instance/abstract/UnsupportedControl.ts

@@ -0,0 +1,151 @@
+import { identity } from '@getodk/common/lib/identity.ts';
+import type { Accessor } from 'solid-js';
+import type { UnsupportedControlNodeType } from '../../client/node-types.ts';
+import type { TextRange } from '../../client/TextRange.ts';
+import type {
+	UnsupportedControlDefinition,
+	UnsupportedControlElementDefinition,
+	UnsupportedControlNode,
+} from '../../client/unsupported/UnsupportedControlNode.ts';
+import type { AnyViolation, LeafNodeValidationState } from '../../client/validation.ts';
+import { createValueState } from '../../lib/reactivity/createValueState.ts';
+import type { CurrentState } from '../../lib/reactivity/node-state/createCurrentState.ts';
+import type { EngineState } from '../../lib/reactivity/node-state/createEngineState.ts';
+import {
+	createSharedNodeState,
+	type SharedNodeState,
+} from '../../lib/reactivity/node-state/createSharedNodeState.ts';
+import { createFieldHint } from '../../lib/reactivity/text/createFieldHint.ts';
+import { createNodeLabel } from '../../lib/reactivity/text/createNodeLabel.ts';
+import type { SimpleAtomicState } from '../../lib/reactivity/types.ts';
+import {
+	createValidationState,
+	type SharedValidationState,
+} from '../../lib/reactivity/validation/createValidation.ts';
+import type { UnknownAppearanceDefinition } from '../../parse/body/appearance/unknownAppearanceParser.ts';
+import type { GeneralParentNode } from '../hierarchy.ts';
+import type { EvaluationContext } from '../internal-api/EvaluationContext.ts';
+import type { SubscribableDependency } from '../internal-api/SubscribableDependency.ts';
+import type { ValidationContext } from '../internal-api/ValidationContext.ts';
+import type { ValueContext } from '../internal-api/ValueContext.ts';
+import { DescendantNode, type DescendantNodeStateSpec } from './DescendantNode.ts';
+
+type TypedUnsupportedControlElementDefinition<Type extends UnsupportedControlNodeType> = Extract<
+	UnsupportedControlElementDefinition,
+	{ readonly type: Type }
+>;
+
+interface TypedUnsupportedControlDefinition<Type extends UnsupportedControlNodeType>
+	extends UnsupportedControlDefinition {
+	readonly bodyElement: TypedUnsupportedControlElementDefinition<Type>;
+}
+
+interface UnsupportedControlStateSpec extends DescendantNodeStateSpec<unknown> {
+	readonly label: Accessor<TextRange<'label'> | null>;
+	readonly hint: Accessor<TextRange<'hint'> | null>;
+	readonly children: null;
+	readonly value: SimpleAtomicState<unknown>;
+	readonly valueOptions: never;
+}
+
+class UnsupportedControlValueEncodeError extends Error {
+	constructor(type: UnsupportedControlNodeType) {
+		super(`Cannot encode state for node (type: ${type}) - not implemented`);
+	}
+}
+
+class UnsupportedControlWriteError extends Error {
+	constructor(type: UnsupportedControlNodeType) {
+		super(`Cannot write state for node (type: ${type}) - not implemented`);
+	}
+}
+
+export abstract class UnsupportedControl<Type extends UnsupportedControlNodeType>
+	extends DescendantNode<TypedUnsupportedControlDefinition<Type>, UnsupportedControlStateSpec, null>
+	implements
+		UnsupportedControlNode,
+		EvaluationContext,
+		SubscribableDependency,
+		ValidationContext,
+		ValueContext<unknown>
+{
+	private readonly validation: SharedValidationState;
+	protected readonly state: SharedNodeState<UnsupportedControlStateSpec>;
+
+	// InstanceNode
+	protected readonly engineState: EngineState<UnsupportedControlStateSpec>;
+
+	// UnsupportedControlNode
+	abstract override readonly nodeType: Type;
+
+	readonly appearances: UnknownAppearanceDefinition;
+	readonly currentState: CurrentState<UnsupportedControlStateSpec>;
+
+	get validationState(): LeafNodeValidationState {
+		return this.validation.currentState;
+	}
+
+	// ValueContext
+	readonly encodeValue = (instanceValue: unknown): string => {
+		const encoded = instanceValue;
+
+		if (typeof encoded === 'string') {
+			return encoded;
+		}
+
+		throw new UnsupportedControlValueEncodeError(this.nodeType);
+	};
+
+	readonly decodeValue = (instanceValue: unknown): unknown => {
+		return identity(instanceValue);
+	};
+
+	constructor(parent: GeneralParentNode, definition: TypedUnsupportedControlDefinition<Type>) {
+		super(parent, definition);
+
+		this.appearances = definition.bodyElement.appearances;
+
+		const sharedStateOptions = {
+			clientStateFactory: this.engineConfig.stateFactory,
+		};
+
+		const stateSpec: UnsupportedControlStateSpec = {
+			reference: this.contextReference,
+			readonly: this.isReadonly,
+			relevant: this.isRelevant,
+			required: this.isRequired,
+
+			label: createNodeLabel(this, definition),
+			hint: createFieldHint(this, definition),
+			children: null,
+			valueOptions: null as never,
+			value: createValueState<unknown>(this),
+		};
+
+		const state = createSharedNodeState(this.scope, stateSpec, sharedStateOptions);
+
+		this.state = state;
+		this.engineState = state.engineState;
+		this.currentState = state.currentState;
+		this.validation = createValidationState(this, sharedStateOptions);
+	}
+
+	// ValidationContext
+	getViolation(): AnyViolation | null {
+		return this.validation.engineState.violation;
+	}
+
+	isBlank(): boolean {
+		return this.engineState.value === '';
+	}
+
+	// InstanceNode
+	getChildren(): readonly [] {
+		return [];
+	}
+
+	// UnsupportedControlNode
+	setValue(_: never): never {
+		throw new UnsupportedControlWriteError(this.nodeType);
+	}
+}

package/src/instance/children.ts

@@ -1,9 +1,14 @@
 import { UnreachableError } from '@getodk/common/lib/error/UnreachableError.ts';
 import type { GroupDefinition } from '../client/GroupNode.ts';
 import type { SubtreeDefinition } from '../client/SubtreeNode.ts';
-import type { LeafNodeDefinition } from '../model/LeafNodeDefinition.ts';
-import type { SubtreeDefinition as ModelSubtreeDefinition } from '../model/SubtreeDefinition.ts';
-import { NoteNodeDefinition } from '../parse/NoteNodeDefinition.ts';
+import type { TriggerNodeDefinition } from '../client/TriggerNode.ts';
+import type { RangeNodeDefinition } from '../client/unsupported/RangeNode.ts';
+import type { RankNodeDefinition } from '../client/unsupported/RankNode.ts';
+import type { UnsupportedControlDefinition } from '../client/unsupported/UnsupportedControlNode.ts';
+import type { UploadNodeDefinition } from '../client/unsupported/UploadNode.ts';
+import type { LeafNodeDefinition } from '../parse/model/LeafNodeDefinition.ts';
+import { NoteNodeDefinition } from '../parse/model/NoteNodeDefinition.ts';
+import type { SubtreeDefinition as ModelSubtreeDefinition } from '../parse/model/SubtreeDefinition.ts';
 import { Group } from './Group.ts';
 import type { GeneralChildNode, GeneralParentNode } from './hierarchy.ts';
 import { ModelValue, type ModelValueDefinition } from './ModelValue.ts';
@@ -15,6 +20,10 @@ import { SelectField } from './SelectField.ts';
 import type { StringFieldDefinition } from './StringField.ts';
 import { StringField } from './StringField.ts';
 import { Subtree } from './Subtree.ts';
+import { TriggerControl } from './TriggerControl.ts';
+import { RangeControl } from './unsupported/RangeControl.ts';
+import { RankControl } from './unsupported/RankControl.ts';
+import { UploadControl } from './unsupported/UploadControl.ts';
 
 const isSubtreeDefinition = (
 	definition: ModelSubtreeDefinition
@@ -22,7 +31,18 @@ const isSubtreeDefinition = (
 	return definition.bodyElement == null;
 };
 
-type ControlNodeDefinition = SelectFieldDefinition | StringFieldDefinition;
+type AnyUnsupportedControlDefinition =
+	| RangeNodeDefinition
+	| RankNodeDefinition
+	| UploadNodeDefinition;
+
+// prettier-ignore
+type ControlNodeDefinition =
+	// eslint-disable-next-line @typescript-eslint/sort-type-constituents
+	| SelectFieldDefinition
+	| StringFieldDefinition
+	| TriggerNodeDefinition
+	| AnyUnsupportedControlDefinition;
 
 type AnyLeafNodeDefinition = ControlNodeDefinition | ModelValueDefinition;
 
@@ -38,6 +58,36 @@ const isStringFieldDefinition = (
 	return definition.bodyElement.type === 'input';
 };
 
+const isSelectFieldDefinition = (
+	definition: ControlNodeDefinition
+): definition is SelectFieldDefinition => {
+	return definition.bodyElement.type === 'select' || definition.bodyElement.type === 'select1';
+};
+
+const isRangeNodeDefinition = (
+	definition: UnsupportedControlDefinition
+): definition is RangeNodeDefinition => {
+	return definition.bodyElement.type === 'range';
+};
+
+const isRankNodeDefinition = (
+	definition: UnsupportedControlDefinition
+): definition is RankNodeDefinition => {
+	return definition.bodyElement.type === 'rank';
+};
+
+const isTriggerNodeDefinition = (
+	definition: ControlNodeDefinition
+): definition is TriggerNodeDefinition => {
+	return definition.bodyElement.type === 'trigger';
+};
+
+const isUploadNodeDefinition = (
+	definition: ControlNodeDefinition
+): definition is UploadNodeDefinition => {
+	return definition.bodyElement.type === 'upload';
+};
+
 export const buildChildren = (parent: GeneralParentNode): GeneralChildNode[] => {
 	const { children } = parent.definition;
 
@@ -78,7 +128,27 @@ export const buildChildren = (parent: GeneralParentNode): GeneralChildNode[] =>
 					return new StringField(parent, leafChild);
 				}
 
-				return new SelectField(parent, leafChild);
+				if (isSelectFieldDefinition(leafChild)) {
+					return new SelectField(parent, leafChild);
+				}
+
+				if (isTriggerNodeDefinition(leafChild)) {
+					return new TriggerControl(parent, leafChild);
+				}
+
+				if (isRangeNodeDefinition(leafChild)) {
+					return new RangeControl(parent, leafChild);
+				}
+
+				if (isRankNodeDefinition(leafChild)) {
+					return new RankControl(parent, leafChild);
+				}
+
+				if (isUploadNodeDefinition(leafChild)) {
+					return new UploadControl(parent, leafChild);
+				}
+
+				throw new UnreachableError(leafChild);
 			}
 
 			default: {

package/src/instance/hierarchy.ts

@@ -8,9 +8,19 @@ import type { Root } from './Root.ts';
 import type { SelectField } from './SelectField.ts';
 import type { StringField } from './StringField.ts';
 import type { Subtree } from './Subtree.ts';
+import type { TriggerControl } from './TriggerControl.ts';
+import type { RangeControl } from './unsupported/RangeControl.ts';
+import type { RankControl } from './unsupported/RankControl.ts';
+import type { UploadControl } from './unsupported/UploadControl.ts';
 
 export type RepeatRange = RepeatRangeControlled | RepeatRangeUncontrolled;
 
+// prettier-ignore
+export type UnsupportedControl =
+	| RangeControl
+	| RankControl
+	| UploadControl;
+
 // prettier-ignore
 export type AnyNode =
 	// eslint-disable-next-line @typescript-eslint/sort-type-constituents
@@ -22,7 +32,9 @@ export type AnyNode =
 	| Note
 	| ModelValue
 	| StringField
-	| SelectField;
+	| SelectField
+	| TriggerControl
+	| UnsupportedControl;
 
 // prettier-ignore
 export type AnyParentNode =
@@ -51,7 +63,9 @@ export type AnyChildNode =
 	| ModelValue
 	| Note
 	| StringField
-	| SelectField;
+	| SelectField
+	| TriggerControl
+	| UnsupportedControl;
 
 // prettier-ignore
 export type GeneralChildNode =
@@ -62,7 +76,9 @@ export type GeneralChildNode =
 	| ModelValue
 	| Note
 	| StringField
-	| SelectField;
+	| SelectField
+	| TriggerControl
+	| UnsupportedControl;
 
 // prettier-ignore
 export type AnyValueNode =
@@ -70,4 +86,6 @@ export type AnyValueNode =
 	| ModelValue
 	| Note
 	| StringField
-	| SelectField;
+	| SelectField
+	| TriggerControl
+	| UnsupportedControl;

package/src/instance/index.ts

@@ -1,5 +1,4 @@
 import { identity } from '@getodk/common/lib/identity.ts';
-import { XFormDefinition } from '../XFormDefinition.ts';
 import type { RootNode } from '../client/RootNode.ts';
 import type {
 	InitializeFormOptions as BaseInitializeFormOptions,
@@ -8,6 +7,7 @@ import type {
 } from '../client/index.ts';
 import { retrieveSourceXMLResource } from '../instance/resource.ts';
 import { createUniqueId } from '../lib/unique-id.ts';
+import { XFormDefinition } from '../parse/XFormDefinition.ts';
 import { Root } from './Root.ts';
 import type { InstanceConfig } from './internal-api/InstanceConfig.ts';
 

package/src/instance/internal-api/EvaluationContext.ts

@@ -1,7 +1,7 @@
 import type { XFormsXPathEvaluator } from '@getodk/xpath';
 import type { Accessor } from 'solid-js';
-import type { DependentExpression } from '../../expression/DependentExpression.ts';
 import type { ReactiveScope } from '../../lib/reactivity/scope.ts';
+import type { DependentExpression } from '../../parse/expression/abstract/DependentExpression.ts';
 import type { SubscribableDependency } from './SubscribableDependency.ts';
 import type { TranslationContext } from './TranslationContext.ts';
 

package/src/instance/internal-api/ValidationContext.ts

@@ -1,12 +1,18 @@
-import type { BindComputation } from '../../model/BindComputation.ts';
+import type { AnyViolation } from '../../client/validation.ts';
+import type { BindComputationExpression } from '../../parse/expression/BindComputationExpression.ts';
 import type { MessageDefinition } from '../../parse/text/MessageDefinition.ts';
+import type { NodeID } from '../identity.ts';
 import type { EvaluationContext } from './EvaluationContext.ts';
 import type { SubscribableDependency } from './SubscribableDependency.ts';
 
+interface ValidationContextCurrentState {
+	get reference(): string;
+}
+
 interface ValidationContextDefinitionBind {
-	readonly constraint: BindComputation<'constraint'>;
+	readonly constraint: BindComputationExpression<'constraint'>;
 	readonly constraintMsg: MessageDefinition<'constraintMsg'> | null;
-	readonly required: BindComputation<'required'>;
+	readonly required: BindComputationExpression<'required'>;
 	readonly requiredMsg: MessageDefinition<'requiredMsg'> | null;
 }
 
@@ -15,8 +21,11 @@ interface ValidationContextDefinition {
 }
 
 export interface ValidationContext extends EvaluationContext, SubscribableDependency {
+	readonly nodeId: NodeID;
 	readonly definition: ValidationContextDefinition;
+	readonly currentState: ValidationContextCurrentState;
 
+	getViolation(): AnyViolation | null;
 	isRelevant(): boolean;
 	isRequired(): boolean;
 	isBlank(): boolean;

package/src/instance/internal-api/ValueContext.ts

@@ -1,12 +1,12 @@
 import type { ReactiveScope } from '../../lib/reactivity/scope.ts';
-import type { BindComputation } from '../../model/BindComputation.ts';
+import type { BindComputationExpression } from '../../parse/expression/BindComputationExpression.ts';
 import type { EvaluationContext } from './EvaluationContext.ts';
 
 export type InstanceValue = string;
 
 interface ValueContextDefinitionBind {
-	readonly calculate: BindComputation<'calculate'> | null;
-	readonly readonly: BindComputation<'readonly'>;
+	readonly calculate: BindComputationExpression<'calculate'> | null;
+	readonly readonly: BindComputationExpression<'readonly'>;
 }
 
 export interface ValueContextDefinition {

package/src/instance/repeat/BaseRepeatRange.ts

@@ -17,7 +17,7 @@ import { createNodeLabel } from '../../lib/reactivity/text/createNodeLabel.ts';
 import type {
 	AnyRepeatRangeDefinition,
 	ControlledRepeatRangeDefinition,
-} from '../../model/RepeatRangeDefinition.ts';
+} from '../../parse/model/RepeatRangeDefinition.ts';
 import type {
 	AnyDescendantNode,
 	DescendantNodeParent,

package/src/instance/repeat/RepeatRangeControlled.ts

@@ -4,7 +4,7 @@ import type { RepeatRangeControlledNode } from '../../client/repeat/RepeatRangeC
 import type { AncestorNodeValidationState } from '../../client/validation.ts';
 import { createComputedExpression } from '../../lib/reactivity/createComputedExpression.ts';
 import { createAggregatedViolations } from '../../lib/reactivity/validation/createAggregatedViolations.ts';
-import type { ControlledRepeatRangeDefinition } from '../../model/RepeatRangeDefinition.ts';
+import type { ControlledRepeatRangeDefinition } from '../../parse/model/RepeatRangeDefinition.ts';
 import type { GeneralParentNode } from '../hierarchy.ts';
 import type { EvaluationContext } from '../internal-api/EvaluationContext.ts';
 import type { SubscribableDependency } from '../internal-api/SubscribableDependency.ts';

package/src/instance/repeat/RepeatRangeUncontrolled.ts

@@ -2,7 +2,7 @@ import type { RepeatRangeNodeAppearances } from '../../client/repeat/BaseRepeatR
 import type { RepeatRangeUncontrolledNode } from '../../client/repeat/RepeatRangeUncontrolledNode.ts';
 import type { AncestorNodeValidationState } from '../../client/validation.ts';
 import { createAggregatedViolations } from '../../lib/reactivity/validation/createAggregatedViolations.ts';
-import type { UncontrolledRepeatRangeDefinition } from '../../model/RepeatRangeDefinition.ts';
+import type { UncontrolledRepeatRangeDefinition } from '../../parse/model/RepeatRangeDefinition.ts';
 import type { GeneralParentNode } from '../hierarchy.ts';
 import type { EvaluationContext } from '../internal-api/EvaluationContext.ts';
 import type { SubscribableDependency } from '../internal-api/SubscribableDependency.ts';

package/src/instance/unsupported/RangeControl.ts

@@ -0,0 +1,5 @@
+import { UnsupportedControl } from '../abstract/UnsupportedControl.ts';
+
+export class RangeControl extends UnsupportedControl<'range'> {
+	readonly nodeType = 'range';
+}

package/src/instance/unsupported/RankControl.ts

@@ -0,0 +1,5 @@
+import { UnsupportedControl } from '../abstract/UnsupportedControl.ts';
+
+export class RankControl extends UnsupportedControl<'rank'> {
+	readonly nodeType = 'rank';
+}

package/src/instance/unsupported/UploadControl.ts

@@ -0,0 +1,5 @@
+import { UnsupportedControl } from '../abstract/UnsupportedControl.ts';
+
+export class UploadControl extends UnsupportedControl<'upload'> {
+	readonly nodeType = 'upload';
+}

package/src/lib/TokenListParser.ts

@@ -11,16 +11,20 @@ type TokenListIterator<CanonicalToken extends string> = IterableIterator<
 	PartiallyKnownString<CanonicalToken>
 >;
 
+type PassthroughTokenList = Readonly<Record<string, boolean>>;
+
 /**
  * @see {@link TokenListParser}
  */
 // prettier-ignore
-export type TokenList<CanonicalToken extends string = string> = {
-	readonly [Key in TokenListKey<CanonicalToken>]:
-		Key extends SymbolIterator
-			? () => TokenListIterator<CanonicalToken>
-			: boolean;
-};
+export type TokenList<CanonicalToken extends string = string> =
+	& PassthroughTokenList
+	& {
+		readonly [Key in TokenListKey<CanonicalToken>]:
+			Key extends SymbolIterator
+				? () => TokenListIterator<CanonicalToken>
+				: boolean;
+	};
 
 interface TokenListAlias<CanonicalToken extends string> {
 	readonly fromAlias: string;
@@ -101,7 +105,7 @@ export class TokenListParser<
 	private readonly aliases: ReadonlyMap<string, CanonicalToken>;
 
 	constructor(
-		readonly canonicalTokens: readonly CanonicalToken[],
+		readonly canonicalTokens: readonly CanonicalToken[] = [],
 		options?: TokenListParserOptions<TokenAlias>
 	) {
 		this.aliases = new Map(