@getodk/xforms-engine 0.5.0 → 0.6.0

package/dist/parse/body/BodyDefinition.d.ts

@@ -4,7 +4,7 @@ import { DependencyContext } from '../expression/abstract/DependencyContext.ts';
 import { InputControlDefinition } from './control/InputControlDefinition.ts';
 import { RangeControlDefinition } from './control/RangeControlDefinition.ts';
 import { RankControlDefinition } from './control/RankControlDefinition.ts';
-import { AnySelectDefinition } from './control/select/SelectDefinition.ts';
+import { AnySelectControlDefinition } from './control/SelectControlDefinition.ts';
 import { TriggerControlDefinition } from './control/TriggerControlDefinition.ts';
 import { UploadControlDefinition } from './control/UploadControlDefinition.ts';
 import { LogicalGroupDefinition } from './group/LogicalGroupDefinition.ts';
@@ -17,7 +17,7 @@ export interface BodyElementParentContext {
     readonly reference: string | null;
     readonly element: Element;
 }
-export type ControlElementDefinition = AnySelectDefinition | InputControlDefinition | RangeControlDefinition | RankControlDefinition | TriggerControlDefinition | UploadControlDefinition;
+export type ControlElementDefinition = AnySelectControlDefinition | InputControlDefinition | RangeControlDefinition | RankControlDefinition | TriggerControlDefinition | UploadControlDefinition;
 type SupportedBodyElementDefinition = RepeatElementDefinition | LogicalGroupDefinition | PresentationGroupDefinition | StructuralGroupDefinition | ControlElementDefinition;
 export type AnyBodyElementDefinition = SupportedBodyElementDefinition | UnsupportedBodyElementDefinition;
 export type BodyElementDefinitionArray = readonly AnyBodyElementDefinition[];

package/dist/parse/body/appearance/rangeAppearanceParser.d.ts

@@ -0,0 +1,3 @@
+import { ParsedTokenList, TokenListParser } from '../../../lib/TokenListParser.ts';
+export declare const rangeAppearanceParser: TokenListParser<"no-ticks" | "picker" | "rating" | "vertical", "no-ticks" | "picker" | "rating" | "vertical">;
+export type RangeAppearanceDefinition = ParsedTokenList<typeof rangeAppearanceParser>;

package/dist/parse/body/control/InputControlDefinition.d.ts

@@ -6,5 +6,8 @@ export declare class InputControlDefinition extends ControlDefinition<'input'> {
     static isCompatible(localName: string): boolean;
     readonly type = "input";
     readonly appearances: InputAppearanceDefinition;
+    readonly rows: number | null;
+    readonly accuracyThreshold: number | null;
+    readonly unacceptableAccuracyThreshold: number | null;
     constructor(form: XFormDefinition, parent: BodyElementParentContext, element: Element);
 }

package/dist/parse/body/control/ItemDefinition.d.ts

@@ -0,0 +1,14 @@
+import { ItemElement } from '../../../lib/dom/query.ts';
+import { ItemLabelDefinition } from '../../text/ItemLabelDefinition.ts';
+import { XFormDefinition } from '../../XFormDefinition.ts';
+import { BodyElementDefinition } from '../BodyElementDefinition.ts';
+import { AnySelectControlDefinition } from './SelectControlDefinition.ts';
+import { RankControlDefinition } from './RankControlDefinition.ts';
+export declare class ItemDefinition extends BodyElementDefinition<'item'> {
+    readonly parent: AnySelectControlDefinition | RankControlDefinition;
+    readonly category = "support";
+    readonly type = "item";
+    readonly label: ItemLabelDefinition | null;
+    readonly value: string;
+    constructor(form: XFormDefinition, parent: AnySelectControlDefinition | RankControlDefinition, element: ItemElement);
+}

package/dist/parse/body/control/ItemsetDefinition.d.ts

@@ -0,0 +1,18 @@
+import { 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 { XFormDefinition } from '../../XFormDefinition.ts';
+import { BodyElementDefinition } from '../BodyElementDefinition.ts';
+import { AnySelectControlDefinition } from './SelectControlDefinition.ts';
+import { RankControlDefinition } from './RankControlDefinition.ts';
+export declare class ItemsetDefinition extends BodyElementDefinition<'itemset'> {
+    readonly parent: AnySelectControlDefinition | RankControlDefinition;
+    readonly category = "support";
+    readonly type = "itemset";
+    readonly reference: string;
+    readonly label: ItemsetLabelDefinition | null;
+    readonly nodes: ItemsetNodesetExpression;
+    readonly value: ItemsetValueExpression;
+    constructor(form: XFormDefinition, parent: AnySelectControlDefinition | RankControlDefinition, element: ItemsetElement);
+}

package/dist/parse/body/control/RangeControlDefinition.d.ts

@@ -1,11 +1,40 @@
 import { XFormDefinition } from '../../XFormDefinition.ts';
-import { UnknownAppearanceDefinition } from '../appearance/unknownAppearanceParser.ts';
+import { RangeAppearanceDefinition } from '../appearance/rangeAppearanceParser.ts';
 import { BodyElementParentContext } from '../BodyDefinition.ts';
 import { ControlDefinition } from './ControlDefinition.ts';
+type NumericString = `${number}`;
+/**
+ * Per
+ * {@link https://getodk.github.io/xforms-spec/#body-elements | ODK XForms spec},
+ * the following attributes are required:
+ *
+ * - `start`
+ * - `end`
+ * - `step`
+ *
+ * While we also know that a `<range>` control is expected to have a bind type
+ * of either `decimal` or `int`, at this parsing stage we do not yet know which
+ * type is associated with the control. So we parse the attributes as strings,
+ * checking only that they appear to be numeric values. We also preserve the
+ * attributes' names here, for consistency with the spec.
+ *
+ * Downstream, we parse these to their appropriate numeric runtime types, and
+ * alias them to their more conventional names (i.e. "start" -> "min", "end" ->
+ * "max").
+ */
+export declare class RangeControlBoundsDefinition {
+    readonly start: NumericString;
+    readonly end: NumericString;
+    readonly step: NumericString;
+    static from(element: Element): RangeControlBoundsDefinition;
+    constructor(start: NumericString, end: NumericString, step: NumericString);
+}
 export declare class RangeControlDefinition extends ControlDefinition<'range'> {
     static isCompatible(localName: string): boolean;
     readonly type = "range";
-    readonly appearances: UnknownAppearanceDefinition;
+    readonly appearances: RangeAppearanceDefinition;
+    readonly bounds: RangeControlBoundsDefinition;
     constructor(form: XFormDefinition, parent: BodyElementParentContext, element: Element);
     toJSON(): object;
 }
+export {};

package/dist/parse/body/control/RankControlDefinition.d.ts

@@ -1,11 +1,15 @@
 import { XFormDefinition } from '../../XFormDefinition.ts';
-import { UnknownAppearanceDefinition } from '../appearance/unknownAppearanceParser.ts';
 import { BodyElementParentContext } from '../BodyDefinition.ts';
 import { ControlDefinition } from './ControlDefinition.ts';
+import { ItemsetDefinition } from './ItemsetDefinition.ts';
+import { ItemDefinition } from './ItemDefinition.ts';
+import { UnknownAppearanceDefinition } from '../appearance/unknownAppearanceParser.ts';
 export declare class RankControlDefinition extends ControlDefinition<'rank'> {
-    static isCompatible(localName: string, element: Element): boolean;
+    static isCompatible(localName: string): boolean;
     readonly type = "rank";
     readonly appearances: UnknownAppearanceDefinition;
+    readonly itemset: ItemsetDefinition | null;
+    readonly items: readonly ItemDefinition[];
     constructor(form: XFormDefinition, parent: BodyElementParentContext, element: Element);
-    toJSON(): object;
+    toJSON(): {};
 }

package/dist/parse/body/control/{select/SelectDefinition.d.ts → SelectControlDefinition.d.ts}

@@ -1,18 +1,18 @@
-import { CollectionValues } from '../../../../../../common/types/collections/CollectionValues.ts';
-import { LocalNamedElement } from '../../../../../../common/types/dom.ts';
-import { XFormDefinition } from '../../../XFormDefinition.ts';
-import { SelectAppearanceDefinition } from '../../appearance/selectAppearanceParser.ts';
-import { AnyBodyElementDefinition, BodyElementParentContext } from '../../BodyDefinition.ts';
-import { ControlDefinition } from '../ControlDefinition.ts';
+import { CollectionValues } from '../../../../../common/types/collections/CollectionValues.ts';
+import { LocalNamedElement } from '../../../../../common/types/dom.ts';
+import { XFormDefinition } from '../../XFormDefinition.ts';
+import { SelectAppearanceDefinition } from '../appearance/selectAppearanceParser.ts';
+import { AnyBodyElementDefinition, BodyElementParentContext } from '../BodyDefinition.ts';
+import { ControlDefinition } from './ControlDefinition.ts';
 import { ItemDefinition } from './ItemDefinition.ts';
 import { ItemsetDefinition } from './ItemsetDefinition.ts';
 declare const selectLocalNames: Set<"select" | "select1">;
 export type SelectType = CollectionValues<typeof selectLocalNames>;
 export interface SelectElement extends LocalNamedElement<SelectType> {
 }
-export declare class SelectDefinition<Type extends SelectType> extends ControlDefinition<Type> {
+export declare class SelectControlDefinition<Type extends SelectType> extends ControlDefinition<Type> {
     static isCompatible(localName: string, element: Element): boolean;
-    static isSelect(element: AnyBodyElementDefinition): element is AnySelectDefinition;
+    static isSelect(element: AnyBodyElementDefinition): element is AnySelectControlDefinition;
     readonly type: Type;
     readonly element: SelectElement;
     readonly appearances: SelectAppearanceDefinition;
@@ -21,5 +21,5 @@ export declare class SelectDefinition<Type extends SelectType> extends ControlDe
     constructor(form: XFormDefinition, parent: BodyElementParentContext, element: Element);
     toJSON(): {};
 }
-export type AnySelectDefinition = SelectDefinition<SelectType>;
+export type AnySelectControlDefinition = SelectControlDefinition<SelectType>;
 export {};

package/dist/parse/expression/ItemsetNodesetExpression.d.ts

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

package/dist/parse/expression/ItemsetValueExpression.d.ts

@@ -1,4 +1,4 @@
-import { ItemsetDefinition } from '../body/control/select/ItemsetDefinition.ts';
+import { ItemsetDefinition } from '../body/control/ItemsetDefinition.ts';
 import { DependentExpression } from './abstract/DependentExpression.ts';
 export declare class ItemsetValueExpression extends DependentExpression<'string'> {
     readonly itemset: ItemsetDefinition;

package/dist/parse/model/BindDefinition.d.ts

@@ -3,6 +3,7 @@ import { BindComputationExpression } from '../expression/BindComputationExpressi
 import { MessageDefinition } from '../text/MessageDefinition.ts';
 import { XFormDefinition } from '../XFormDefinition.ts';
 import { BindElement } from './BindElement.ts';
+import { AnyBindPreloadDefinition } from './BindPreloadDefinition.ts';
 import { BindType, BindTypeDefinition } from './BindTypeDefinition.ts';
 import { ModelDefinition } from './ModelDefinition.ts';
 export declare class BindDefinition<T extends BindType = BindType> extends DependencyContext {
@@ -12,6 +13,7 @@ export declare class BindDefinition<T extends BindType = BindType> extends Depen
     readonly bindElement: BindElement;
     readonly type: BindTypeDefinition<T>;
     readonly parentNodeset: string | null;
+    readonly preload: AnyBindPreloadDefinition | null;
     readonly calculate: BindComputationExpression<'calculate'> | null;
     readonly readonly: BindComputationExpression<'readonly'>;
     readonly relevant: BindComputationExpression<'relevant'>;
@@ -34,5 +36,5 @@ export declare class BindDefinition<T extends BindType = BindType> extends Depen
     get reference(): string;
     get parentReference(): string | null;
     constructor(form: XFormDefinition, model: ModelDefinition, nodeset: string, bindElement: BindElement);
-    toJSON(): Omit<this, "form" | "reference" | "toJSON" | "parentReference" | "isTranslated" | "model" | "bindElement" | "parentBind">;
+    toJSON(): Omit<this, "form" | "model" | "toJSON" | "reference" | "isTranslated" | "parentReference" | "bindElement" | "parentBind">;
 }

package/dist/parse/model/BindPreloadDefinition.d.ts

@@ -0,0 +1,42 @@
+import { PartiallyKnownString } from '../../../../common/types/string/PartiallyKnownString.ts';
+import { BindElement } from './BindElement.ts';
+type PartiallyKnownPreloadParameter<Known extends string> = PartiallyKnownString<NonNullable<Known>> | Extract<Known, null>;
+interface PreloadParametersByType {
+    readonly uid: string | null;
+    readonly date: PartiallyKnownPreloadParameter<'today'>;
+    readonly timestamp: PartiallyKnownPreloadParameter<'end' | 'start'>;
+    readonly property: PartiallyKnownPreloadParameter<'deviceid' | 'email' | 'phonenumber' | 'username'>;
+}
+type PreloadType = PartiallyKnownString<keyof PreloadParametersByType>;
+type PreloadParameter<Type extends PreloadType> = Type extends keyof PreloadParametersByType ? PreloadParametersByType[Type] : string | null;
+interface PreloadInput<Type extends PreloadType> {
+    readonly type: Type;
+    readonly parameter: PreloadParameter<Type>;
+}
+/**
+ * Parsed representation of
+ * {@link https://getodk.github.io/xforms-spec/#preload-attributes | Preload Attributes}.
+ * If specified on a
+ * {@link https://getodk.github.io/xforms-spec/#bindings | binding}, this will
+ * be parsed to define:
+ *
+ * - {@link type}, a `jr:preload`
+ * - {@link parameter}, an associated `jr:preloadParams` value
+ *
+ * @todo It would probably make sense for the _definition_ to also convey:
+ *
+ * 1. Which {@link https://getodk.github.io/xforms-spec/#events | event} the
+ *    preload is semantically associated with (noting that the spec may be a tad
+ *    overzealous about this association).
+ *
+ * 2. The constant XPath expression (or other computation?) expressed by the
+ *    combined {@link type} and {@link parameter}.
+ */
+export declare class BindPreloadDefinition<Type extends PreloadType> implements PreloadInput<Type> {
+    static from(bindElement: BindElement): AnyBindPreloadDefinition | null;
+    readonly type: Type;
+    readonly parameter: PreloadParameter<Type>;
+    private constructor();
+}
+export type AnyBindPreloadDefinition = BindPreloadDefinition<'uid'> | BindPreloadDefinition<'timestamp'> | BindPreloadDefinition<'property'> | BindPreloadDefinition<string>;
+export {};

package/dist/parse/model/DescendentNodeDefinition.d.ts

@@ -1,23 +1,14 @@
 import { AnyBodyElementDefinition } from '../body/BodyDefinition.ts';
 import { BindDefinition } from './BindDefinition.ts';
-import { ModelNode, NodeChildren, NodeDefaultValue, NodeDefinition, NodeDefinitionType, NodeInstances, NodeParent } from './NodeDefinition.ts';
+import { NodeDefinitionType, ParentNodeDefinition, NodeDefinition } from './NodeDefinition.ts';
 import { RootDefinition } from './RootDefinition.ts';
 export type DescendentNodeType = Exclude<NodeDefinitionType, 'root'>;
 type DescendentNodeBodyElement = AnyBodyElementDefinition;
-export declare abstract class DescendentNodeDefinition<Type extends DescendentNodeType, BodyElement extends DescendentNodeBodyElement | null = DescendentNodeBodyElement | null> implements NodeDefinition<Type> {
-    readonly parent: NodeParent<Type>;
-    readonly bind: BindDefinition;
+export declare abstract class DescendentNodeDefinition<Type extends DescendentNodeType, BodyElement extends DescendentNodeBodyElement | null = DescendentNodeBodyElement | null> extends NodeDefinition<Type> {
+    readonly parent: ParentNodeDefinition;
     readonly bodyElement: BodyElement;
-    abstract readonly type: Type;
-    abstract readonly children: NodeChildren<Type>;
-    abstract readonly instances: NodeInstances<Type>;
-    abstract readonly defaultValue: NodeDefaultValue<Type>;
-    abstract readonly node: ModelNode<Type>;
-    abstract readonly nodeName: string;
     readonly root: RootDefinition;
-    readonly nodeset: string;
     readonly isTranslated: boolean;
-    constructor(parent: NodeParent<Type>, bind: BindDefinition, bodyElement: BodyElement);
+    constructor(parent: ParentNodeDefinition, bind: BindDefinition, bodyElement: BodyElement);
 }
-export type AnyDescendantNodeDefinition = DescendentNodeDefinition<any, any>;
 export {};

package/dist/parse/model/ItextTranslation/ItextTranslationRootDefinition.d.ts

@@ -1,6 +1,7 @@
 import { XFormsItextTranslationElement, XFORMS_KNOWN_ATTRIBUTE, XFORMS_LOCAL_NAME } from '@getodk/xpath';
 import { StaticElement } from '../../../integration/xpath/static-dom/StaticElement.ts';
-export declare class ItextTranslationRootDefinition extends StaticElement implements XFormsItextTranslationElement<ItextTranslationRootDefinition> {
+import { ItextTranslationDefinition } from './ItextTranslationDefinition.ts';
+export declare class ItextTranslationRootDefinition extends StaticElement<ItextTranslationDefinition> implements XFormsItextTranslationElement<ItextTranslationRootDefinition> {
     readonly [XFORMS_LOCAL_NAME] = "translation";
     readonly [XFORMS_KNOWN_ATTRIBUTE] = "lang";
     getAttributeValue(localName: 'lang'): string;

package/dist/parse/model/LeafNodeDefinition.d.ts

@@ -1,16 +1,19 @@
 import { ValueType } from '../../client/ValueType.ts';
+import { NamespaceDeclarationMap, NamedSubtreeDefinition } from '../../lib/names/NamespaceDeclarationMap.ts';
+import { QualifiedName } from '../../lib/names/QualifiedName.ts';
 import { AnyBodyElementDefinition, ControlElementDefinition } from '../body/BodyDefinition.ts';
 import { BindDefinition } from './BindDefinition.ts';
 import { DescendentNodeDefinition } from './DescendentNodeDefinition.ts';
-import { NodeDefinition, ParentNodeDefinition } from './NodeDefinition.ts';
-export declare class LeafNodeDefinition<V extends ValueType = ValueType> extends DescendentNodeDefinition<'leaf-node', ControlElementDefinition | null> implements NodeDefinition<'leaf-node'> {
+import { ParentNodeDefinition } from './NodeDefinition.ts';
+export declare class LeafNodeDefinition<V extends ValueType = ValueType> extends DescendentNodeDefinition<'leaf-node', ControlElementDefinition | null> implements NamedSubtreeDefinition {
     readonly node: Element;
     readonly type = "leaf-node";
     readonly valueType: V;
-    readonly nodeName: string;
+    readonly namespaceDeclarations: NamespaceDeclarationMap;
+    readonly qualifiedName: QualifiedName;
     readonly children: null;
     readonly instances: null;
     readonly defaultValue: string;
     constructor(parent: ParentNodeDefinition, bind: BindDefinition, bodyElement: AnyBodyElementDefinition | null, node: Element);
-    toJSON(): Omit<this, "parent" | "toJSON" | "bind" | "root" | "bodyElement">;
+    toJSON(): Omit<this, "parent" | "bind" | "toJSON" | "root" | "bodyElement">;
 }

package/dist/parse/model/ModelBindMap.d.ts

@@ -10,6 +10,6 @@ export declare class ModelBindMap extends Map<BindNodeset, BindDefinition> {
     static fromModel(model: ModelDefinition): ModelBindMap;
     protected constructor(form: XFormDefinition, model: ModelDefinition);
     getOrCreateBindDefinition(nodeset: string): BindDefinition;
-    toJSON(): [string, BindDefinition<"string" | "boolean" | "time" | "int" | "decimal" | "date" | "dateTime" | "geopoint" | "geotrace" | "geoshape" | "binary" | "barcode" | "intent">][];
+    toJSON(): [string, BindDefinition<"string" | "boolean" | "time" | "barcode" | "binary" | "date" | "dateTime" | "decimal" | "geopoint" | "geoshape" | "geotrace" | "int" | "intent">][];
 }
 export {};

package/dist/parse/model/NodeDefinition.d.ts

@@ -1,3 +1,5 @@
+import { NamedSubtreeDefinition, NamespaceDeclarationMap } from '../../lib/names/NamespaceDeclarationMap.ts';
+import { QualifiedName } from '../../lib/names/QualifiedName.ts';
 import { AnyBodyElementDefinition } from '../body/BodyDefinition.ts';
 import { RepeatElementDefinition } from '../body/RepeatElementDefinition.ts';
 import { BindDefinition } from './BindDefinition.ts';
@@ -48,26 +50,21 @@ export type NodeDefinitionType = RootNodeType | RepeatRangeType | RepeatTemplate
 export type ParentNodeDefinition = RootDefinition | RepeatTemplateDefinition | RepeatInstanceDefinition | SubtreeDefinition;
 export type ChildNodeDefinition = AnyRepeatRangeDefinition | LeafNodeDefinition | SubtreeDefinition;
 export type ChildNodeInstanceDefinition = RepeatTemplateDefinition | RepeatInstanceDefinition | SubtreeDefinition | LeafNodeDefinition;
-export type NodeChildren<Type extends NodeDefinitionType> = Type extends ParentNodeDefinition['type'] ? readonly ChildNodeDefinition[] : null;
-export type NodeInstances<Type extends NodeDefinitionType> = Type extends 'repeat-range' ? readonly RepeatInstanceDefinition[] : null;
-export type NodeParent<Type extends NodeDefinitionType> = Type extends ChildNodeDefinition['type'] | ChildNodeInstanceDefinition['type'] ? ParentNodeDefinition : null;
-export type ModelNode<Type extends NodeDefinitionType> = Type extends 'repeat-range' ? null : Element;
-export type NodeDefaultValue<Type extends NodeDefinitionType> = Type extends 'leaf-node' ? string : null;
-export interface NodeDefinition<Type extends NodeDefinitionType> {
-    readonly type: Type;
+export declare abstract class NodeDefinition<Type extends NodeDefinitionType> implements NamedSubtreeDefinition {
     readonly bind: BindDefinition;
+    abstract readonly type: Type;
+    abstract readonly namespaceDeclarations: NamespaceDeclarationMap;
+    abstract readonly qualifiedName: QualifiedName;
+    abstract readonly bodyElement: AnyBodyElementDefinition | RepeatElementDefinition | null;
+    abstract readonly isTranslated: boolean;
+    abstract readonly root: RootDefinition;
+    abstract readonly parent: ParentNodeDefinition | null;
+    abstract readonly children: readonly ChildNodeDefinition[] | null;
+    abstract readonly instances: readonly RepeatInstanceDefinition[] | null;
+    abstract readonly defaultValue: string | null;
+    /** @todo leaf-node may be Attr */
+    abstract readonly node: Element | null;
     readonly nodeset: string;
-    readonly nodeName: string;
-    readonly bodyElement: AnyBodyElementDefinition | RepeatElementDefinition | null;
-    readonly isTranslated: boolean;
-    readonly root: RootDefinition;
-    readonly parent: NodeParent<Type>;
-    readonly children: NodeChildren<Type>;
-    readonly instances: NodeInstances<Type>;
-    readonly node: ModelNode<Type>;
-    readonly defaultValue: NodeDefaultValue<Type>;
+    constructor(bind: BindDefinition);
 }
 export type AnyNodeDefinition = RootDefinition | AnyRepeatRangeDefinition | RepeatTemplateDefinition | RepeatInstanceDefinition | SubtreeDefinition | LeafNodeDefinition;
-export type TypedNodeDefinition<Type> = Extract<AnyNodeDefinition, {
-    readonly type: Type;
-}>;

package/dist/parse/model/NoteNodeDefinition.d.ts

@@ -1,3 +1,4 @@
+import { ValueType } from '../../client/ValueType.ts';
 import { AnyBodyElementDefinition } from '../body/BodyDefinition.ts';
 import { InputControlDefinition } from '../body/control/InputControlDefinition.ts';
 import { BindComputationExpression } from '../expression/BindComputationExpression.ts';
@@ -8,7 +9,7 @@ import { BindDefinition } from './BindDefinition.ts';
 import { LeafNodeDefinition } from './LeafNodeDefinition.ts';
 import { ParentNodeDefinition } from './NodeDefinition.ts';
 export type NoteReadonlyDefinition = BindComputationExpression<'readonly'> & ConstantTruthyDependentExpression;
-export interface NoteBindDefinition extends BindDefinition {
+export interface NoteBindDefinition<V extends ValueType> extends BindDefinition<V> {
     readonly readonly: NoteReadonlyDefinition;
 }
 export type NoteTextDefinition = LabelDefinition | HintDefinition;
@@ -21,10 +22,10 @@ export type NoteTextDefinition = LabelDefinition | HintDefinition;
  * aspects of the node's interface (such as its {@link NoteNode.nodeType} and
  * distinct {@link NoteNode.currentState} types) to handle note-specific logic.
  */
-export declare class NoteNodeDefinition extends LeafNodeDefinition {
-    readonly bind: NoteBindDefinition;
+export declare class NoteNodeDefinition<V extends ValueType = ValueType> extends LeafNodeDefinition<V> {
+    readonly bind: NoteBindDefinition<V>;
     readonly bodyElement: InputControlDefinition;
     readonly noteTextDefinition: NoteTextDefinition;
-    static from(parent: ParentNodeDefinition, bind: BindDefinition, bodyElement: AnyBodyElementDefinition | null, node: Element): NoteNodeDefinition | null;
-    constructor(parent: ParentNodeDefinition, bind: NoteBindDefinition, bodyElement: InputControlDefinition, noteTextDefinition: NoteTextDefinition, node: Element);
+    static from<V extends ValueType>(parent: ParentNodeDefinition, bind: BindDefinition<V>, bodyElement: AnyBodyElementDefinition | null, node: Element): NoteNodeDefinition<V> | null;
+    constructor(parent: ParentNodeDefinition, bind: NoteBindDefinition<V>, bodyElement: InputControlDefinition, noteTextDefinition: NoteTextDefinition, node: Element);
 }

package/dist/parse/model/RangeNodeDefinition.d.ts

@@ -0,0 +1,41 @@
+import { ValueType } from '../../client/ValueType.ts';
+import { RuntimeValue } from '../../lib/codecs/getSharedValueCodec.ts';
+import { RangeControlBoundsDefinition, RangeControlDefinition } from '../body/control/RangeControlDefinition.ts';
+import { BindDefinition } from './BindDefinition.ts';
+import { LeafNodeDefinition } from './LeafNodeDefinition.ts';
+import { ParentNodeDefinition } from './NodeDefinition.ts';
+declare const RANGE_VALUE_TYPES: readonly ["decimal", "int"];
+export type RangeValueType = (typeof RANGE_VALUE_TYPES)[number];
+export interface RangeLeafNodeDefinition<V extends ValueType = ValueType> extends LeafNodeDefinition<V> {
+    readonly bodyElement: RangeControlDefinition;
+}
+declare class RangeNodeBoundsDefinition<V extends RangeValueType = RangeValueType> {
+    readonly min: NonNullable<RuntimeValue<V>>;
+    readonly max: NonNullable<RuntimeValue<V>>;
+    readonly step: NonNullable<RuntimeValue<V>>;
+    static from<V extends RangeValueType>(bounds: RangeControlBoundsDefinition, bind: BindDefinition<V>): RangeNodeBoundsDefinition<V>;
+    constructor(min: NonNullable<RuntimeValue<V>>, max: NonNullable<RuntimeValue<V>>, step: NonNullable<RuntimeValue<V>>);
+}
+/**
+ * @todo We should really consider making `LeafNodeDefinition` an abstract base
+ * class, and each node's definition an explicit concrete subclass of that. It
+ * would simplify a lot of things, reduce redundancy (and drift!) between
+ * various like `*Definition` types, and allow us to reason more clearly about
+ * what parse-product-input is used to construct each primary instance node.
+ * Furthermore, it would give us a great deal more flexibility to revisit some
+ * of the weaker parts of our current data model (e.g. splitting up selects).
+ *
+ * I explored this refactor as part of the prerequisite work to support range
+ * controls. I eventually backed out because it involved more churn than I felt
+ * comfortable with, but I do think we should keep an eye out for other
+ * opportunities to take on the churn.
+ */
+export declare class RangeNodeDefinition<V extends RangeValueType = RangeValueType> extends LeafNodeDefinition<V> implements RangeLeafNodeDefinition<V> {
+    readonly bind: BindDefinition<V>;
+    readonly bodyElement: RangeControlDefinition;
+    static from<V extends ValueType>(parent: ParentNodeDefinition, bind: BindDefinition<V>, bodyElement: RangeControlDefinition, node: Element): RangeNodeDefinition<Extract<V, RangeValueType>>;
+    readonly bounds: RangeNodeBoundsDefinition<V>;
+    private constructor();
+}
+export type AnyRangeNodeDefinition = RangeNodeDefinition<'decimal'> | RangeNodeDefinition<'int'>;
+export {};

package/dist/parse/model/RepeatInstanceDefinition.d.ts

@@ -1,14 +1,17 @@
+import { NamespaceDeclarationMap } from '../../lib/names/NamespaceDeclarationMap.ts';
+import { QualifiedName } from '../../lib/names/QualifiedName.ts';
 import { RepeatElementDefinition } from '../body/RepeatElementDefinition.ts';
 import { DescendentNodeDefinition } from './DescendentNodeDefinition.ts';
-import { ChildNodeDefinition, NodeDefinition } from './NodeDefinition.ts';
+import { ChildNodeDefinition } from './NodeDefinition.ts';
 import { AnyRepeatRangeDefinition } from './RepeatRangeDefinition.ts';
-export declare class RepeatInstanceDefinition extends DescendentNodeDefinition<'repeat-instance', RepeatElementDefinition> implements NodeDefinition<'repeat-instance'> {
+export declare class RepeatInstanceDefinition extends DescendentNodeDefinition<'repeat-instance', RepeatElementDefinition> {
     readonly node: Element;
     readonly type = "repeat-instance";
-    readonly nodeName: string;
+    readonly namespaceDeclarations: NamespaceDeclarationMap;
+    readonly qualifiedName: QualifiedName;
     readonly children: readonly ChildNodeDefinition[];
     readonly instances: null;
     readonly defaultValue: null;
     constructor(range: AnyRepeatRangeDefinition, node: Element);
-    toJSON(): Omit<this, "parent" | "toJSON" | "bind" | "root" | "bodyElement">;
+    toJSON(): Omit<this, "parent" | "bind" | "toJSON" | "root" | "bodyElement">;
 }

package/dist/parse/model/RepeatRangeDefinition.d.ts

@@ -1,8 +1,10 @@
+import { NamespaceDeclarationMap } from '../../lib/names/NamespaceDeclarationMap.ts';
+import { QualifiedName } from '../../lib/names/QualifiedName.ts';
 import { RepeatElementDefinition } from '../body/RepeatElementDefinition.ts';
 import { RepeatCountControlExpression } from '../expression/RepeatCountControlExpression.ts';
 import { BindDefinition } from './BindDefinition.ts';
 import { DescendentNodeDefinition } from './DescendentNodeDefinition.ts';
-import { NodeDefinition, ParentNodeDefinition } from './NodeDefinition.ts';
+import { ParentNodeDefinition } from './NodeDefinition.ts';
 import { RepeatInstanceDefinition } from './RepeatInstanceDefinition.ts';
 import { RepeatTemplateDefinition } from './RepeatTemplateDefinition.ts';
 export interface ControlledRepeatRangeDefinition extends RepeatRangeDefinition {
@@ -12,7 +14,7 @@ export interface UncontrolledRepeatRangeDefinition extends RepeatRangeDefinition
     readonly count: null;
 }
 export type AnyRepeatRangeDefinition = ControlledRepeatRangeDefinition | UncontrolledRepeatRangeDefinition;
-export declare class RepeatRangeDefinition extends DescendentNodeDefinition<'repeat-range', RepeatElementDefinition> implements NodeDefinition<'repeat-range'> {
+export declare class RepeatRangeDefinition extends DescendentNodeDefinition<'repeat-range', RepeatElementDefinition> {
     static from(parent: ParentNodeDefinition, bind: BindDefinition, bodyElement: RepeatElementDefinition, modelNodes: readonly [Element, ...Element[]]): AnyRepeatRangeDefinition;
     readonly type = "repeat-range";
     readonly template: RepeatTemplateDefinition;
@@ -20,10 +22,11 @@ export declare class RepeatRangeDefinition extends DescendentNodeDefinition<'rep
     readonly instances: RepeatInstanceDefinition[];
     readonly count: RepeatCountControlExpression | null;
     readonly node: null;
-    readonly nodeName: string;
+    readonly namespaceDeclarations: NamespaceDeclarationMap;
+    readonly qualifiedName: QualifiedName;
     readonly defaultValue: null;
     private constructor();
     isControlled(): this is ControlledRepeatRangeDefinition;
     isUncontrolled(): this is UncontrolledRepeatRangeDefinition;
-    toJSON(): Omit<this, "parent" | "toJSON" | "bind" | "root" | "bodyElement" | "isControlled" | "isUncontrolled">;
+    toJSON(): Omit<this, "parent" | "bind" | "toJSON" | "root" | "bodyElement" | "isControlled" | "isUncontrolled">;
 }

package/dist/parse/model/RepeatTemplateDefinition.d.ts

@@ -1,7 +1,9 @@
 import { JAVAROSA_NAMESPACE_URI } from '../../../../common/src/constants/xmlns.ts';
+import { NamespaceDeclarationMap } from '../../lib/names/NamespaceDeclarationMap.ts';
+import { QualifiedName } from '../../lib/names/QualifiedName.ts';
 import { RepeatElementDefinition } from '../body/RepeatElementDefinition.ts';
 import { DescendentNodeDefinition } from './DescendentNodeDefinition.ts';
-import { ChildNodeDefinition, NodeDefinition } from './NodeDefinition.ts';
+import { ChildNodeDefinition } from './NodeDefinition.ts';
 import { RepeatRangeDefinition } from './RepeatRangeDefinition.ts';
 interface ExplicitRepeatTemplateElement extends Element {
     getAttributeNS(namespaceURI: typeof JAVAROSA_NAMESPACE_URI, name: 'template'): string;
@@ -13,16 +15,17 @@ interface ParsedRepeatNodes {
     readonly template: RepeatTemplateDefinition;
     readonly instanceNodes: readonly Element[];
 }
-export declare class RepeatTemplateDefinition extends DescendentNodeDefinition<'repeat-template', RepeatElementDefinition> implements NodeDefinition<'repeat-template'> {
+export declare class RepeatTemplateDefinition extends DescendentNodeDefinition<'repeat-template', RepeatElementDefinition> {
     protected readonly templateNode: ExplicitRepeatTemplateElement;
     static parseModelNodes(range: RepeatRangeDefinition, modelNodes: readonly [Element, ...Element[]]): ParsedRepeatNodes;
     readonly type = "repeat-template";
     readonly node: Element;
-    readonly nodeName: string;
+    readonly namespaceDeclarations: NamespaceDeclarationMap;
+    readonly qualifiedName: QualifiedName;
     readonly children: readonly ChildNodeDefinition[];
     readonly instances: null;
     readonly defaultValue: null;
     protected constructor(range: RepeatRangeDefinition, templateNode: ExplicitRepeatTemplateElement);
-    toJSON(): Omit<this, "parent" | "toJSON" | "bind" | "root" | "bodyElement">;
+    toJSON(): Omit<this, "parent" | "bind" | "toJSON" | "root" | "bodyElement">;
 }
 export {};

package/dist/parse/model/RootAttributeDefinition.d.ts

@@ -0,0 +1,24 @@
+import { NamedNodeDefinition } from '../../lib/names/NamespaceDeclarationMap.ts';
+import { QualifiedName } from '../../lib/names/QualifiedName.ts';
+import { RootDefinition } from './RootDefinition.ts';
+interface RootAttributeSource {
+    readonly namespaceURI: string | null;
+    readonly nodeName: string;
+    readonly prefix: string | null;
+    readonly localName: string;
+    readonly value: string;
+}
+/**
+ * @todo This class is named and typed to emphasize its intentionally narrow
+ * usage and purpose. It **intentionally** avoids addressing the much broader
+ * set of concerns around modeling attributes in primary instance/submissions.
+ */
+export declare class RootAttributeDefinition implements NamedNodeDefinition {
+    private readonly serializedXML;
+    readonly parent: RootDefinition;
+    readonly qualifiedName: QualifiedName;
+    readonly value: string;
+    constructor(root: RootDefinition, source: RootAttributeSource);
+    serializeAttributeXML(): string;
+}
+export {};

package/dist/parse/model/RootAttributeMap.d.ts

@@ -0,0 +1,23 @@
+import { QualifiedName } from '../../lib/names/QualifiedName.ts';
+import { RootAttributeDefinition } from './RootAttributeDefinition.ts';
+import { RootDefinition } from './RootDefinition.ts';
+/**
+ * @todo This can be trivially expanded to a narrowly general case when we
+ * prioritize work to
+ * {@link https://github.com/getodk/web-forms/issues/285 | support attributes}
+ * (as modeled form nodes on par with elements). It's been deferred here to
+ * avoid expanding scope of an already fairly large yak shave.
+ *
+ * @todo There's a **much more expansive** general case just waiting for a good
+ * opportuntity to prioritize it. E.g. a `NamedNodeMap<T>`, where T is any
+ * generalized concept of a named node. This expansive generalization would have
+ * a ton of value in a variety of known performance optimization
+ * targets/solutions (i.e. optimizing the most redundant, suboptimal, frequently
+ * performed aspects of any typical XPath expression in a typical XForm).
+ *
+ * @see {@link QualifiedName} for more detail.
+ */
+export declare class RootAttributeMap extends Map<QualifiedName, RootAttributeDefinition> {
+    static from(root: RootDefinition, domRootSourceElement: Element): RootAttributeMap;
+    private constructor();
+}