@getodk/xforms-engine 0.5.0 → 0.6.0

package/dist/instance/Group.d.ts

@@ -28,6 +28,7 @@ export declare class Group extends DescendantNode<GroupDefinition, GroupStateSpe
     protected engineState: EngineState<GroupStateSpec>;
     readonly nodeType = "group";
     readonly appearances: GroupNodeAppearances;
+    readonly nodeOptions: null;
     readonly currentState: MaterializedChildren<CurrentState<GroupStateSpec>, GeneralChildNode>;
     readonly validationState: AncestorNodeValidationState;
     readonly submissionState: SubmissionState;

package/dist/instance/InputControl.d.ts

@@ -1,6 +1,6 @@
 import { XPathNodeKindKey } from '@getodk/xpath';
 import { Accessor } from 'solid-js';
-import { InputDefinition, InputNode, InputNodeAppearances, InputNodeInputValue } from '../client/InputNode.ts';
+import { InputDefinition, InputNode, InputNodeAppearances, InputNodeInputValue, InputNodeOptions } from '../client/InputNode.ts';
 import { TextRange } from '../client/TextRange.ts';
 import { ValueType } from '../client/ValueType.ts';
 import { XFormsXPathElement } from '../integration/xpath/adapter/XFormsXPathNode.ts';
@@ -8,18 +8,19 @@ import { RuntimeInputValue, RuntimeValue } from '../lib/codecs/getSharedValueCod
 import { CurrentState } from '../lib/reactivity/node-state/createCurrentState.ts';
 import { EngineState } from '../lib/reactivity/node-state/createEngineState.ts';
 import { SharedNodeState } from '../lib/reactivity/node-state/createSharedNodeState.ts';
-import { Root } from './Root.ts';
 import { ValueNode, ValueNodeStateSpec } from './abstract/ValueNode.ts';
 import { GeneralParentNode } from './hierarchy.ts';
 import { EvaluationContext } from './internal-api/EvaluationContext.ts';
-import { ValidationContext } from './internal-api/ValidationContext.ts';
 import { ClientReactiveSubmittableValueNode } from './internal-api/submission/ClientReactiveSubmittableValueNode.ts';
+import { ValidationContext } from './internal-api/ValidationContext.ts';
+import { Root } from './Root.ts';
 export type AnyInputDefinition = {
     [V in ValueType]: InputDefinition<V>;
 }[ValueType];
 interface InputControlStateSpec<V extends ValueType> extends ValueNodeStateSpec<RuntimeValue<V>> {
     readonly label: Accessor<TextRange<'label'> | null>;
     readonly hint: Accessor<TextRange<'hint'> | null>;
+    readonly valueOptions: null;
 }
 export declare class InputControl<V extends ValueType = ValueType> extends ValueNode<V, InputDefinition<V>, RuntimeValue<V>, RuntimeInputValue<V>> implements InputNode<V>, XFormsXPathElement, EvaluationContext, ValidationContext, ClientReactiveSubmittableValueNode {
     static from(parent: GeneralParentNode, definition: InputDefinition): AnyInputControl;
@@ -28,6 +29,7 @@ export declare class InputControl<V extends ValueType = ValueType> extends Value
     protected readonly engineState: EngineState<InputControlStateSpec<V>>;
     readonly nodeType = "input";
     readonly appearances: InputNodeAppearances;
+    readonly nodeOptions: InputNodeOptions<V>;
     readonly currentState: CurrentState<InputControlStateSpec<V>>;
     constructor(parent: GeneralParentNode, definition: InputDefinition<V>);
     setValue(value: InputNodeInputValue<V>): Root;

package/dist/instance/ModelValue.d.ts

@@ -14,6 +14,7 @@ import { ClientReactiveSubmittableValueNode } from './internal-api/submission/Cl
 interface ModelValueStateSpec<V extends ValueType> extends ValueNodeStateSpec<RuntimeValue<V>> {
     readonly label: null;
     readonly hint: null;
+    readonly valueOptions: null;
 }
 export declare class ModelValue<V extends ValueType = ValueType> extends ValueNode<V, ModelValueDefinition<V>, RuntimeValue<V>, RuntimeInputValue<V>> implements ModelValueNode<V>, XFormsXPathElement, EvaluationContext, ValidationContext, ClientReactiveSubmittableValueNode {
     static from(parent: GeneralParentNode, definition: ModelValueDefinition): AnyModelValue;
@@ -22,6 +23,7 @@ export declare class ModelValue<V extends ValueType = ValueType> extends ValueNo
     protected readonly engineState: EngineState<ModelValueStateSpec<V>>;
     readonly nodeType = "model-value";
     readonly appearances: null;
+    readonly nodeOptions: null;
     readonly currentState: CurrentState<ModelValueStateSpec<V>>;
     constructor(parent: GeneralParentNode, definition: ModelValueDefinition<V>);
 }

package/dist/instance/Note.d.ts

@@ -1,48 +1,36 @@
 import { XPathNodeKindKey } from '@getodk/xpath';
 import { Accessor } from 'solid-js';
-import { NoteNode, NoteNodeAppearances } from '../client/NoteNode.ts';
-import { SubmissionState } from '../client/submission/SubmissionState.ts';
+import { NoteNode, NoteNodeAppearances, NoteValue } from '../client/NoteNode.ts';
 import { TextRange } from '../client/TextRange.ts';
-import { AnyViolation, LeafNodeValidationState } from '../client/validation.ts';
+import { ValueType } from '../client/ValueType.ts';
 import { XFormsXPathElement } from '../integration/xpath/adapter/XFormsXPathNode.ts';
+import { NoteInputValue, NoteRuntimeValue } from '../lib/codecs/NoteCodec.ts';
 import { CurrentState } from '../lib/reactivity/node-state/createCurrentState.ts';
 import { EngineState } from '../lib/reactivity/node-state/createEngineState.ts';
 import { SharedNodeState } from '../lib/reactivity/node-state/createSharedNodeState.ts';
 import { ComputedNoteText } from '../lib/reactivity/text/createNoteText.ts';
-import { SimpleAtomicState } from '../lib/reactivity/types.ts';
 import { NoteNodeDefinition } from '../parse/model/NoteNodeDefinition.ts';
-import { DescendantNodeStateSpec, DescendantNode } from './abstract/DescendantNode.ts';
+import { ValueNode, ValueNodeStateSpec } from './abstract/ValueNode.ts';
 import { GeneralParentNode } from './hierarchy.ts';
 import { EvaluationContext } from './internal-api/EvaluationContext.ts';
-import { ClientReactiveSubmittableLeafNode } from './internal-api/submission/ClientReactiveSubmittableLeafNode.ts';
+import { ClientReactiveSubmittableValueNode } from './internal-api/submission/ClientReactiveSubmittableValueNode.ts';
 import { ValidationContext } from './internal-api/ValidationContext.ts';
-import { ValueContext } from './internal-api/ValueContext.ts';
-interface NoteStateSpec extends DescendantNodeStateSpec<string> {
+interface NoteStateSpec<V extends ValueType> extends ValueNodeStateSpec<NoteValue<V>> {
     readonly readonly: Accessor<true>;
     readonly noteText: ComputedNoteText;
     readonly label: Accessor<TextRange<'label', 'form'> | null>;
     readonly hint: Accessor<TextRange<'hint', 'form'> | null>;
-    readonly children: null;
-    readonly value: SimpleAtomicState<string>;
     readonly valueOptions: null;
 }
-export declare class Note extends DescendantNode<NoteNodeDefinition, NoteStateSpec, GeneralParentNode, null> implements NoteNode, XFormsXPathElement, EvaluationContext, ValidationContext, ValueContext<string>, ClientReactiveSubmittableLeafNode<string> {
-    private readonly validation;
+export declare class Note<V extends ValueType = ValueType> extends ValueNode<V, NoteNodeDefinition<V>, NoteRuntimeValue<V>, NoteInputValue<V>> implements NoteNode, XFormsXPathElement, EvaluationContext, ValidationContext, ClientReactiveSubmittableValueNode {
     readonly [XPathNodeKindKey] = "element";
-    protected readonly state: SharedNodeState<NoteStateSpec>;
-    protected readonly engineState: EngineState<NoteStateSpec>;
+    protected readonly state: SharedNodeState<NoteStateSpec<V>>;
+    protected readonly engineState: EngineState<NoteStateSpec<V>>;
     readonly nodeType = "note";
     readonly appearances: NoteNodeAppearances;
-    readonly currentState: CurrentState<NoteStateSpec>;
-    get validationState(): LeafNodeValidationState;
-    readonly submissionState: SubmissionState;
-    readonly contextNode: this;
-    readonly encodeValue: (value: string) => string;
-    readonly decodeValue: (value: string) => string;
-    constructor(parent: GeneralParentNode, definition: NoteNodeDefinition);
-    getXPathValue(): string;
-    getViolation(): AnyViolation | null;
-    isBlank(): boolean;
-    getChildren(): readonly [];
+    readonly nodeOptions: null;
+    readonly currentState: CurrentState<NoteStateSpec<V>>;
+    constructor(parent: GeneralParentNode, definition: NoteNodeDefinition<V>);
 }
+export type AnyNote = Note<'barcode'> | Note<'binary'> | Note<'boolean'> | Note<'date'> | Note<'dateTime'> | Note<'decimal'> | Note<'geopoint'> | Note<'geoshape'> | Note<'geotrace'> | Note<'int'> | Note<'intent'> | Note<'string'> | Note<'time'>;
 export {};

package/dist/instance/PrimaryInstance.d.ts

@@ -48,6 +48,7 @@ export declare class PrimaryInstance extends InstanceNode<RootDefinition, Primar
     readonly [XPathNodeKindKey] = "document";
     readonly nodeType = "primary-instance";
     readonly appearances: null;
+    readonly nodeOptions: null;
     readonly classes: BodyClassList;
     readonly root: Root;
     readonly currentState: MaterializedChildren<CurrentState<PrimaryInstanceStateSpec>, Root>;

package/dist/instance/RangeControl.d.ts

@@ -0,0 +1,34 @@
+import { XPathNodeKindKey } from '@getodk/xpath';
+import { Accessor } from 'solid-js';
+import { RangeInputValue, RangeNode, RangeNodeAppearances, RangeValue } from '../client/RangeNode.ts';
+import { TextRange } from '../client/TextRange.ts';
+import { XFormsXPathElement } from '../integration/xpath/adapter/XFormsXPathNode.ts';
+import { CurrentState } from '../lib/reactivity/node-state/createCurrentState.ts';
+import { EngineState } from '../lib/reactivity/node-state/createEngineState.ts';
+import { SharedNodeState } from '../lib/reactivity/node-state/createSharedNodeState.ts';
+import { AnyRangeNodeDefinition, RangeNodeDefinition, RangeValueType } from '../parse/model/RangeNodeDefinition.ts';
+import { Root } from './Root.ts';
+import { ValueNode, ValueNodeStateSpec } from './abstract/ValueNode.ts';
+import { GeneralParentNode } from './hierarchy.ts';
+import { EvaluationContext } from './internal-api/EvaluationContext.ts';
+import { ValidationContext } from './internal-api/ValidationContext.ts';
+import { ClientReactiveSubmittableValueNode } from './internal-api/submission/ClientReactiveSubmittableValueNode.ts';
+interface RangeControlStateSpec<V extends RangeValueType> extends ValueNodeStateSpec<RangeValue<V>> {
+    readonly label: Accessor<TextRange<'label'> | null>;
+    readonly hint: Accessor<TextRange<'hint'> | null>;
+    readonly valueOptions: null;
+}
+export declare class RangeControl<V extends RangeValueType = RangeValueType> extends ValueNode<V, RangeNodeDefinition<V>, RangeValue<V>, RangeInputValue<V>> implements RangeNode<V>, XFormsXPathElement, EvaluationContext, ValidationContext, ClientReactiveSubmittableValueNode {
+    static from(parent: GeneralParentNode, definition: AnyRangeNodeDefinition): AnyRangeControl;
+    readonly [XPathNodeKindKey] = "element";
+    protected readonly state: SharedNodeState<RangeControlStateSpec<V>>;
+    protected readonly engineState: EngineState<RangeControlStateSpec<V>>;
+    readonly nodeType = "range";
+    readonly appearances: RangeNodeAppearances;
+    readonly nodeOptions: null;
+    readonly currentState: CurrentState<RangeControlStateSpec<V>>;
+    constructor(parent: GeneralParentNode, definition: RangeNodeDefinition<V>);
+    setValue(value: RangeInputValue<V>): Root;
+}
+export type AnyRangeControl = RangeControl<'decimal'> | RangeControl<'int'>;
+export {};

package/dist/instance/RankControl.d.ts

@@ -0,0 +1,40 @@
+import { XPathNodeKindKey } from '@getodk/xpath';
+import { Accessor } from 'solid-js';
+import { RankDefinition, RankNode, RankValueOptions } from '../client/RankNode.ts';
+import { TextRange } from '../client/TextRange.ts';
+import { XFormsXPathElement } from '../integration/xpath/adapter/XFormsXPathNode.ts';
+import { CurrentState } from '../lib/reactivity/node-state/createCurrentState.ts';
+import { EngineState } from '../lib/reactivity/node-state/createEngineState.ts';
+import { SharedNodeState } from '../lib/reactivity/node-state/createSharedNodeState.ts';
+import { Root } from './Root.ts';
+import { ValueNodeStateSpec, ValueNode } from './abstract/ValueNode.ts';
+import { GeneralParentNode } from './hierarchy.ts';
+import { EvaluationContext } from './internal-api/EvaluationContext.ts';
+import { ValidationContext } from './internal-api/ValidationContext.ts';
+import { ClientReactiveSubmittableValueNode } from './internal-api/submission/ClientReactiveSubmittableValueNode.ts';
+import { UnknownAppearanceDefinition } from '../parse/body/appearance/unknownAppearanceParser.ts';
+import { ValueType } from '../client/ValueType.ts';
+export type AnyRankDefinition = {
+    [V in ValueType]: RankDefinition<V>;
+}[ValueType];
+interface RankControlStateSpec extends ValueNodeStateSpec<readonly string[]> {
+    readonly label: Accessor<TextRange<'label'> | null>;
+    readonly hint: Accessor<TextRange<'hint'> | null>;
+    readonly valueOptions: Accessor<RankValueOptions>;
+}
+export declare class RankControl extends ValueNode<'string', RankDefinition<'string'>, readonly string[], readonly string[]> implements RankNode, XFormsXPathElement, EvaluationContext, ValidationContext, ClientReactiveSubmittableValueNode {
+    static from(parent: GeneralParentNode, definition: RankDefinition): RankControl;
+    private readonly mapOptionsByValue;
+    protected readonly getInstanceValue: Accessor<string>;
+    readonly [XPathNodeKindKey] = "element";
+    protected readonly state: SharedNodeState<RankControlStateSpec>;
+    protected readonly engineState: EngineState<RankControlStateSpec>;
+    readonly nodeType = "rank";
+    readonly appearances: UnknownAppearanceDefinition;
+    readonly nodeOptions: null;
+    readonly currentState: CurrentState<RankControlStateSpec>;
+    private constructor();
+    getValueLabel(value: string): TextRange<'item-label'> | null;
+    setValues(valuesInOrder: readonly string[]): Root;
+}
+export {};

package/dist/instance/Root.d.ts

@@ -47,6 +47,7 @@ export declare class Root extends DescendantNode<RootDefinition, RootStateSpec,
     readonly isRequired: () => boolean;
     readonly nodeType = "root";
     readonly appearances: null;
+    readonly nodeOptions: null;
     readonly classes: BodyClassList;
     readonly currentState: MaterializedChildren<CurrentState<RootStateSpec>, GeneralChildNode>;
     readonly validationState: AncestorNodeValidationState;

package/dist/instance/SelectControl.d.ts

@@ -0,0 +1,66 @@
+import { XPathNodeKindKey } from '@getodk/xpath';
+import { Accessor } from 'solid-js';
+import { SelectDefinition, SelectItem, SelectNode, SelectNodeAppearances, SelectValueOptions } from '../client/SelectNode.ts';
+import { TextRange } from '../client/TextRange.ts';
+import { ValueType } from '../client/ValueType.ts';
+import { XFormsXPathElement } from '../integration/xpath/adapter/XFormsXPathNode.ts';
+import { CurrentState } from '../lib/reactivity/node-state/createCurrentState.ts';
+import { EngineState } from '../lib/reactivity/node-state/createEngineState.ts';
+import { SharedNodeState } from '../lib/reactivity/node-state/createSharedNodeState.ts';
+import { SelectType } from '../parse/body/control/SelectControlDefinition.ts';
+import { Root } from './Root.ts';
+import { ValueNodeStateSpec, ValueNode } from './abstract/ValueNode.ts';
+import { GeneralParentNode } from './hierarchy.ts';
+import { EvaluationContext } from './internal-api/EvaluationContext.ts';
+import { ValidationContext } from './internal-api/ValidationContext.ts';
+import { ClientReactiveSubmittableValueNode } from './internal-api/submission/ClientReactiveSubmittableValueNode.ts';
+export type AnySelectDefinition = {
+    [V in ValueType]: SelectDefinition<V>;
+}[ValueType];
+interface SelectControlStateSpec extends ValueNodeStateSpec<readonly string[]> {
+    readonly label: Accessor<TextRange<'label'> | null>;
+    readonly hint: Accessor<TextRange<'hint'> | null>;
+    readonly valueOptions: Accessor<SelectValueOptions>;
+}
+export declare class SelectControl extends ValueNode<'string', SelectDefinition<'string'>, readonly string[], readonly string[]> implements SelectNode, XFormsXPathElement, EvaluationContext, ValidationContext, ClientReactiveSubmittableValueNode {
+    static from(parent: GeneralParentNode, definition: SelectDefinition): SelectControl;
+    private readonly mapOptionsByValue;
+    protected readonly getInstanceValue: Accessor<string>;
+    readonly [XPathNodeKindKey] = "element";
+    protected readonly state: SharedNodeState<SelectControlStateSpec>;
+    protected readonly engineState: EngineState<SelectControlStateSpec>;
+    readonly nodeType = "select";
+    readonly selectType: SelectType;
+    readonly appearances: SelectNodeAppearances;
+    readonly nodeOptions: null;
+    readonly currentState: CurrentState<SelectControlStateSpec>;
+    private constructor();
+    /**
+     * Filters {@link values} to include only those values which are currently
+     * available in the mapping produced by {@link mapOptionsByValue}, i.e. within
+     * a potentially filtered itemset.
+     *
+     * Note: this method effectively produces an intersection of
+     * {@link sourceValues} and {@link values}. **Importantly**, ordering of the
+     * results is deterministic, preserving the order of values as yielded _by
+     * {@link sourceValues}_.
+     *
+     * At time of writing, there are several tests (in `@getodk/scenario`, ported
+     * from JavaRosa) which expect the values of a `<select>` to match the order
+     * they appear in the control's (potentially filtered) `<itemset>` (or list of
+     * `<item>`s, for forms defining those inline).
+     *
+     * @todo The `<odk:rank>` control, having semantics very similar to
+     * `<select>`, will likely perform similar filtering logic. However, one of
+     * the important distinctions between these controls is that `<odk:rank>`
+     * exists explicitly to control the order of values. It's quite likely that
+     * would be achieved by invoking the same logic with the parameter order
+     * reversed.
+     */
+    private filterValues;
+    getValueOption(value: string): SelectItem | null;
+    isSelected(value: string): boolean;
+    selectValue(value: string | null): Root;
+    selectValues(values: readonly string[]): Root;
+}
+export {};

package/dist/instance/Subtree.d.ts

@@ -27,6 +27,7 @@ export declare class Subtree extends DescendantNode<SubtreeDefinition, SubtreeSt
     protected readonly engineState: EngineState<SubtreeStateSpec>;
     readonly nodeType = "subtree";
     readonly appearances: null;
+    readonly nodeOptions: null;
     readonly currentState: MaterializedChildren<CurrentState<SubtreeStateSpec>, GeneralChildNode>;
     readonly validationState: AncestorNodeValidationState;
     readonly submissionState: SubmissionState;

package/dist/instance/TriggerControl.d.ts

@@ -2,46 +2,33 @@ import { XPathNodeKindKey } from '@getodk/xpath';
 import { Accessor } from 'solid-js';
 import { TextRange } from '../client/TextRange.ts';
 import { TriggerNode, TriggerNodeDefinition } from '../client/TriggerNode.ts';
-import { SubmissionState } from '../client/submission/SubmissionState.ts';
-import { AnyViolation, LeafNodeValidationState } from '../client/validation.ts';
 import { XFormsXPathElement } from '../integration/xpath/adapter/XFormsXPathNode.ts';
+import { TriggerInputValue, TriggerRuntimeValue } from '../lib/codecs/TriggerCodec.ts';
 import { CurrentState } from '../lib/reactivity/node-state/createCurrentState.ts';
 import { EngineState } from '../lib/reactivity/node-state/createEngineState.ts';
 import { SharedNodeState } from '../lib/reactivity/node-state/createSharedNodeState.ts';
-import { SimpleAtomicState } from '../lib/reactivity/types.ts';
 import { UnknownAppearanceDefinition } from '../parse/body/appearance/unknownAppearanceParser.ts';
 import { Root } from './Root.ts';
-import { DescendantNodeStateSpec, DescendantNode } from './abstract/DescendantNode.ts';
+import { ValueNode, ValueNodeStateSpec } from './abstract/ValueNode.ts';
 import { GeneralParentNode } from './hierarchy.ts';
 import { EvaluationContext } from './internal-api/EvaluationContext.ts';
 import { ValidationContext } from './internal-api/ValidationContext.ts';
-import { ValueContext } from './internal-api/ValueContext.ts';
-import { ClientReactiveSubmittableLeafNode } from './internal-api/submission/ClientReactiveSubmittableLeafNode.ts';
-interface TriggerControlStateSpec extends DescendantNodeStateSpec<boolean> {
+import { ClientReactiveSubmittableValueNode } from './internal-api/submission/ClientReactiveSubmittableValueNode.ts';
+interface TriggerControlStateSpec extends ValueNodeStateSpec<TriggerRuntimeValue> {
     readonly label: Accessor<TextRange<'label'> | null>;
     readonly hint: Accessor<TextRange<'hint'> | null>;
-    readonly children: null;
-    readonly value: SimpleAtomicState<boolean>;
     readonly valueOptions: null;
 }
-export declare class TriggerControl extends DescendantNode<TriggerNodeDefinition, TriggerControlStateSpec, GeneralParentNode, null> implements TriggerNode, XFormsXPathElement, EvaluationContext, ValidationContext, ValueContext<boolean>, ClientReactiveSubmittableLeafNode<boolean> {
-    private readonly validation;
+export declare class TriggerControl extends ValueNode<'string', TriggerNodeDefinition<'string'>, TriggerRuntimeValue, TriggerInputValue> implements TriggerNode, XFormsXPathElement, EvaluationContext, ValidationContext, ClientReactiveSubmittableValueNode {
+    static from(parent: GeneralParentNode, definition: TriggerNodeDefinition): TriggerControl;
     readonly [XPathNodeKindKey] = "element";
     protected readonly state: SharedNodeState<TriggerControlStateSpec>;
     protected readonly engineState: EngineState<TriggerControlStateSpec>;
     readonly nodeType = "trigger";
     readonly appearances: UnknownAppearanceDefinition;
+    readonly nodeOptions: null;
     readonly currentState: CurrentState<TriggerControlStateSpec>;
-    get validationState(): LeafNodeValidationState;
-    readonly submissionState: SubmissionState;
-    readonly contextNode: this;
-    readonly encodeValue: (runtimeValue: boolean) => string;
-    readonly decodeValue: (instanceValue: string) => boolean;
-    constructor(parent: GeneralParentNode, definition: TriggerNodeDefinition);
-    getXPathValue(): string;
-    getViolation(): AnyViolation | null;
-    isBlank(): boolean;
-    getChildren(): readonly [];
-    setValue(value: boolean): Root;
+    private constructor();
+    setValue(value: TriggerInputValue): Root;
 }
 export {};

package/dist/instance/abstract/DescendantNode.d.ts

@@ -6,7 +6,6 @@ import { InstanceNodeType } from '../../client/node-types.ts';
 import { PrimaryInstanceXPathChildNode } from '../../integration/xpath/adapter/kind.ts';
 import { XFormsXPathPrimaryInstanceDescendantNode, XFormsXPathPrimaryInstanceDescendantNodeKind } from '../../integration/xpath/adapter/XFormsXPathNode.ts';
 import { EngineXPathEvaluator } from '../../integration/xpath/EngineXPathEvaluator.ts';
-import { AnyDescendantNodeDefinition } from '../../parse/model/DescendentNodeDefinition.ts';
 import { AnyNodeDefinition } from '../../parse/model/NodeDefinition.ts';
 import { AnyChildNode, AnyParentNode } from '../hierarchy.ts';
 import { EvaluationContext } from '../internal-api/EvaluationContext.ts';
@@ -19,7 +18,7 @@ export interface DescendantNodeSharedStateSpec {
     readonly required: Accessor<boolean>;
 }
 export type DescendantNodeStateSpec<Value = never> = InstanceNodeStateSpec<Value> & DescendantNodeSharedStateSpec;
-export type DescendantNodeDefinition = Extract<AnyNodeDefinition, AnyDescendantNodeDefinition>;
+export type DescendantNodeDefinition = AnyNodeDefinition;
 export type AnyDescendantNode = DescendantNode<DescendantNodeDefinition, DescendantNodeStateSpec<any>, any, any>;
 interface DescendantNodeOptions {
     readonly computeReference?: Accessor<string>;

package/dist/instance/abstract/InstanceNode.d.ts

@@ -25,6 +25,7 @@ export type EngineInstanceNodeType = ClientInstanceNodeType | 'primary-instance'
 export interface BaseEngineNode extends Omit<BaseNode, 'nodeType'> {
     readonly nodeType: EngineInstanceNodeType;
 }
+export type InstanceNodeValueOptionsStateSpec = Accessor<null> | Accessor<readonly unknown[]> | null;
 export interface InstanceNodeStateSpec<Value = never> {
     readonly reference: Accessor<string> | string;
     readonly readonly: Accessor<boolean> | boolean;
@@ -33,7 +34,7 @@ export interface InstanceNodeStateSpec<Value = never> {
     readonly label: Accessor<TextRange<'label'> | null> | null;
     readonly hint: Accessor<TextRange<'hint'> | null> | null;
     readonly children: Accessor<readonly FormNodeID[]> | null;
-    readonly valueOptions: Accessor<null> | Accessor<readonly unknown[]> | null;
+    readonly valueOptions: InstanceNodeValueOptionsStateSpec;
     readonly value: Signal<Value> | SimpleAtomicState<Value> | null;
 }
 type AnyInstanceNode = InstanceNode<AnyNodeDefinition, InstanceNodeStateSpec<any>, any>;
@@ -85,6 +86,7 @@ export declare abstract class InstanceNode<Definition extends AnyNodeDefinition,
     readonly nodeId: FormNodeID;
     abstract readonly nodeType: EngineInstanceNodeType;
     abstract readonly appearances: NodeAppearances<Definition>;
+    abstract readonly nodeOptions: object | null;
     abstract readonly currentState: InstanceNodeCurrentState<Spec, Child>;
     abstract readonly validationState: NodeValidationState;
     abstract readonly submissionState: SubmissionState;

package/dist/instance/abstract/UnsupportedControl.d.ts

@@ -37,6 +37,7 @@ export declare abstract class UnsupportedControl<Type extends UnsupportedControl
     protected readonly engineState: EngineState<UnsupportedControlStateSpec>;
     abstract readonly nodeType: Type;
     readonly appearances: UnknownAppearanceDefinition;
+    readonly nodeOptions: null;
     readonly currentState: CurrentState<UnsupportedControlStateSpec>;
     get validationState(): LeafNodeValidationState;
     readonly submissionState: SubmissionState;

package/dist/instance/abstract/ValueNode.d.ts

@@ -22,7 +22,6 @@ import { DescendantNodeStateSpec, DescendantNode } from './DescendantNode.ts';
 export type ValueNodeDefinition<V extends ValueType> = LeafNodeDefinition<V>;
 export interface ValueNodeStateSpec<RuntimeValue> extends DescendantNodeStateSpec<RuntimeValue> {
     readonly children: null;
-    readonly valueOptions: null;
     readonly value: SimpleAtomicState<RuntimeValue>;
     readonly instanceValue: Accessor<string>;
 }

package/dist/instance/hierarchy.d.ts

@@ -1,23 +1,23 @@
 import { Group } from './Group.ts';
 import { AnyInputControl } from './InputControl.ts';
 import { AnyModelValue } from './ModelValue.ts';
-import { Note } from './Note.ts';
+import { AnyNote } from './Note.ts';
 import { PrimaryInstance } from './PrimaryInstance.ts';
+import { AnyRangeControl } from './RangeControl.ts';
 import { RepeatInstance } from './repeat/RepeatInstance.ts';
 import { RepeatRangeControlled } from './repeat/RepeatRangeControlled.ts';
 import { RepeatRangeUncontrolled } from './repeat/RepeatRangeUncontrolled.ts';
 import { Root } from './Root.ts';
-import { SelectField } from './SelectField.ts';
+import { SelectControl } from './SelectControl.ts';
 import { Subtree } from './Subtree.ts';
 import { TriggerControl } from './TriggerControl.ts';
-import { RangeControl } from './unsupported/RangeControl.ts';
-import { RankControl } from './unsupported/RankControl.ts';
+import { RankControl } from './RankControl.ts';
 import { UploadControl } from './unsupported/UploadControl.ts';
 export type RepeatRange = RepeatRangeControlled | RepeatRangeUncontrolled;
-export type AnyUnsupportedControl = RangeControl | RankControl | UploadControl;
-export type AnyNode = PrimaryInstance | Root | Group | Subtree | RepeatRange | RepeatInstance | Note | AnyModelValue | AnyInputControl | SelectField | TriggerControl | AnyUnsupportedControl;
+export type AnyUnsupportedControl = UploadControl;
+export type AnyNode = PrimaryInstance | Root | Group | Subtree | RepeatRange | RepeatInstance | AnyNote | AnyModelValue | AnyInputControl | AnyRangeControl | RankControl | SelectControl | TriggerControl | AnyUnsupportedControl;
 export type AnyParentNode = PrimaryInstance | Root | Group | Subtree | RepeatRange | RepeatInstance;
 export type GeneralParentNode = Root | Group | Subtree | RepeatInstance;
-export type AnyChildNode = Root | Group | Subtree | RepeatRange | RepeatInstance | AnyModelValue | Note | AnyInputControl | SelectField | TriggerControl | AnyUnsupportedControl;
-export type GeneralChildNode = Group | Subtree | RepeatRange | AnyModelValue | Note | AnyInputControl | SelectField | TriggerControl | AnyUnsupportedControl;
-export type AnyValueNode = AnyModelValue | Note | AnyInputControl | SelectField | TriggerControl | AnyUnsupportedControl;
+export type AnyChildNode = Root | Group | Subtree | RepeatRange | RepeatInstance | AnyModelValue | AnyNote | AnyInputControl | AnyRangeControl | RankControl | SelectControl | TriggerControl | AnyUnsupportedControl;
+export type GeneralChildNode = Group | Subtree | RepeatRange | AnyModelValue | AnyNote | AnyInputControl | AnyRangeControl | RankControl | SelectControl | TriggerControl | AnyUnsupportedControl;
+export type AnyValueNode = AnyModelValue | AnyNote | AnyInputControl | AnyRangeControl | RankControl | SelectControl | TriggerControl | AnyUnsupportedControl;

package/dist/instance/internal-api/InstanceValueContext.d.ts

@@ -1,8 +1,10 @@
 import { ReactiveScope } from '../../lib/reactivity/scope.ts';
 import { BindComputationExpression } from '../../parse/expression/BindComputationExpression.ts';
+import { AnyBindPreloadDefinition } from '../../parse/model/BindPreloadDefinition.ts';
 import { EvaluationContext } from './EvaluationContext.ts';
 export type DecodeInstanceValue = (value: string) => string;
 interface InstanceValueContextDefinitionBind {
+    readonly preload: AnyBindPreloadDefinition | null;
     readonly calculate: BindComputationExpression<'calculate'> | null;
     readonly readonly: BindComputationExpression<'readonly'>;
 }

package/dist/instance/internal-api/submission/ClientReactiveSubmittableLeafNode.d.ts

@@ -1,4 +1,5 @@
 import { SubmissionState } from '../../../client/submission/SubmissionState.ts';
+import { QualifiedName } from '../../../lib/names/QualifiedName.ts';
 import { EscapedXMLText } from '../../../lib/xml-serialization.ts';
 import { ClientReactiveSubmittableChildNode, ClientReactiveSubmittableParentNode } from './ClientReactiveSubmittableParentNode.ts';
 interface ClientReactiveSubmittableLeafNodeCurrentState<RuntimeValue> {
@@ -7,7 +8,7 @@ interface ClientReactiveSubmittableLeafNodeCurrentState<RuntimeValue> {
 }
 export type SerializedSubmissionValue = string;
 interface ClientReactiveSubmittableLeafNodeDefinition {
-    readonly nodeName: string;
+    readonly qualifiedName: QualifiedName;
 }
 export interface ClientReactiveSubmittableLeafNode<RuntimeValue> {
     readonly definition: ClientReactiveSubmittableLeafNodeDefinition;

package/dist/instance/internal-api/submission/ClientReactiveSubmittableParentNode.d.ts

@@ -1,4 +1,5 @@
 import { SubmissionState } from '../../../client/submission/SubmissionState.ts';
+import { QualifiedName } from '../../../lib/names/QualifiedName.ts';
 export interface ClientReactiveSubmittableChildNode {
     readonly submissionState: SubmissionState;
 }
@@ -7,7 +8,7 @@ interface ClientReactiveSubmittableParentNodeCurrentState<Child extends ClientRe
     get children(): readonly Child[];
 }
 export interface ClientReactiveSubmittableParentNodeDefinition {
-    readonly nodeName: string;
+    readonly qualifiedName: QualifiedName;
 }
 export interface ClientReactiveSubmittableParentNode<Child extends ClientReactiveSubmittableChildNode> {
     readonly definition: ClientReactiveSubmittableParentNodeDefinition;

package/dist/instance/internal-api/submission/ClientReactiveSubmittableValueNode.d.ts

@@ -1,4 +1,5 @@
 import { SubmissionState } from '../../../client/submission/SubmissionState.ts';
+import { QualifiedName } from '../../../lib/names/QualifiedName.ts';
 import { ClientReactiveSubmittableChildNode, ClientReactiveSubmittableParentNode } from './ClientReactiveSubmittableParentNode.ts';
 interface ClientReactiveSubmittableValueNodeCurrentState {
     get relevant(): boolean;
@@ -6,7 +7,7 @@ interface ClientReactiveSubmittableValueNodeCurrentState {
 }
 export type SerializedSubmissionValue = string;
 interface ClientReactiveSubmittableValueNodeDefinition {
-    readonly nodeName: string;
+    readonly qualifiedName: QualifiedName;
 }
 export interface ClientReactiveSubmittableValueNode {
     readonly definition: ClientReactiveSubmittableValueNodeDefinition;

package/dist/instance/repeat/BaseRepeatRange.d.ts

@@ -101,6 +101,7 @@ export declare abstract class BaseRepeatRange<Definition extends AnyRepeatRangeD
      * appearances" should apply, under which circumstances.
      */
     abstract readonly appearances: NodeAppearances<Definition>;
+    readonly nodeOptions: null;
     readonly currentState: MaterializedChildren<CurrentState<RepeatRangeStateSpec>, RepeatInstance>;
     abstract readonly validationState: AncestorNodeValidationState;
     readonly submissionState: SubmissionState;

package/dist/instance/repeat/RepeatInstance.d.ts

@@ -58,6 +58,7 @@ export declare class RepeatInstance extends DescendantNode<RepeatDefinition, Rep
      * @see {@link RepeatRange.appearances}
      */
     readonly appearances: RepeatInstanceNodeAppearances;
+    readonly nodeOptions: null;
     readonly currentState: MaterializedChildren<CurrentState<RepeatInstanceStateSpec>, GeneralChildNode>;
     readonly validationState: AncestorNodeValidationState;
     readonly submissionState: SubmissionState;

package/dist/integration/xpath/adapter/names.d.ts

@@ -1,16 +1,6 @@
 import { EngineXPathNode } from './kind.ts';
 export declare const getEngineXPathNodeNamespaceURI: (node: EngineXPathNode) => string | null;
-/**
- * @todo currently, neither {@link InstanceNode} nor {@link StaticNode} account
- * for prefixes in qualified names. This was already a general enough gap that
- * it makes sense to defer to a broader solution as it becomes a priority
- * (likely prompted by a bug report about unexpected behavior of the XPath
- * `name` function).
- */
 export declare const getEngineXPathNodeQualifiedName: (node: EngineXPathNode) => string;
 export declare const getEngineXPathNodeLocalName: (node: EngineXPathNode) => string;
 export declare const getEngineProcessingInstructionName: () => never;
-/**
- * @todo @see {@link getNamespaceDeclarations}
- */
-export declare const resolveEngineXPathNodeNamespaceURI: (_: EngineXPathNode, prefix: string | null) => "http://www.w3.org/1999/xhtml" | "http://www.w3.org/2005/xpath-functions" | "http://openrosa.org/javarosa" | "http://www.opendatakit.org/xforms" | "http://openrosa.org/xforms" | "http://www.w3.org/2002/xforms" | "http://enketo.org/xforms" | null;
+export declare const resolveEngineXPathNodeNamespaceURI: (node: EngineXPathNode, prefix: string | null) => string | null;

package/dist/integration/xpath/adapter/traversal.d.ts

@@ -2,16 +2,17 @@ import { EngineXPathAttribute, EngineXPathDocument, EngineXPathElement, EngineXP
 export declare const getContainingEngineXPathDocument: (node: EngineXPathNode) => EngineXPathDocument;
 export declare const getEngineXPathAttributes: (node: EngineXPathNode) => Iterable<EngineXPathAttribute>;
 /**
- * @todo XML XForms may actually define explicit namespace declarations on
- * non-root elements (i.e. elements other than the form definition's `h:html`,
- * itext `translation`, secondary `instance`). Expressions defined in such forms
- * may also expect to use those namespace declarations. It would even seem
- * likely! Why declare namespaces on a subtree if you don't intend to use them?
- * We don't currently capture namespace declarations below `h:html` in the parse
- * stage (which, if we intend to support the use case, is where we should
- * start).
+ * @todo We've now laid most of the groundwork necessary to implement this
+ * properly. At time of writing it has still been deferred because:
  *
- * @todo At the very least, we should probably produce a set of default namespace declarations. At least for `h:html`, maybe for other "root" nodes.
+ * 1. The scope of changes enabling it is already a fairly large yak shave.
+ * 2. It is only used to support XPath LocationPath Steps whose AxisName is
+ *    `namespace`. If we _ever_ support this, it would probably be for extremely
+ *    niche use cases!
+ *
+ * @todo Since we've consciously deferred implementing this (twice now!), should
+ * it throw? It might be nice to be alerted if the assumptions in point 2 above
+ * are somehow wrong (or become wrong).
  */
 export declare const getNamespaceDeclarations: () => Iterable<never>;
 export declare const getParentNode: (node: EngineXPathNode) => EngineXPathParentNode | null;

package/dist/integration/xpath/static-dom/StaticAttribute.d.ts

@@ -1,15 +1,22 @@
 import { XPathNodeKindKey } from '@getodk/xpath';
+import { QualifiedName } from '../../../lib/names/QualifiedName.ts';
 import { XFormsXPathAttribute } from '../adapter/XFormsXPathNode.ts';
+import { StaticDocument } from './StaticDocument.ts';
 import { StaticElement } from './StaticElement.ts';
-import { StaticNamedNodeOptions, StaticNamedNode } from './StaticNamedNode.ts';
-interface StaticAttributeOptions extends StaticNamedNodeOptions {
+import { StaticNode } from './StaticNode.ts';
+interface StaticAttributeOptions {
+    readonly namespaceURI: string | null;
+    readonly prefix?: string | null;
+    readonly localName: string;
     readonly value: string;
 }
-export declare class StaticAttribute extends StaticNamedNode<'attribute'> implements XFormsXPathAttribute {
+export declare class StaticAttribute extends StaticNode<'attribute'> implements XFormsXPathAttribute {
     readonly parent: StaticElement;
     readonly [XPathNodeKindKey] = "attribute";
     readonly nodeType = "static-attribute";
+    readonly rootDocument: StaticDocument;
     readonly root: StaticElement;
+    readonly qualifiedName: QualifiedName;
     readonly attributes: readonly [];
     readonly children: null;
     readonly value: string;

package/dist/integration/xpath/static-dom/StaticDocument.d.ts

@@ -8,7 +8,6 @@ export declare abstract class StaticDocument<DocumentRoot extends StaticElement
     readonly nodeType = "static-document";
     readonly rootDocument: StaticDocument;
     readonly root: DocumentRoot;
-    readonly isXFormsNamespace: boolean;
     readonly parent: null;
     readonly children: readonly [root: DocumentRoot];
     constructor(rootFactory: StaticDocumentRootFactory<StaticDocument<DocumentRoot>, DocumentRoot>);