@getodk/xforms-engine 0.4.0 → 0.6.0

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/expression/abstract/DependencyContext.d.ts

@@ -1,12 +1,7 @@
-import { AnyDependentExpression } from './DependentExpression.ts';
 export declare abstract class DependencyContext {
     abstract get parentReference(): string | null;
     abstract get reference(): string | null;
-    protected readonly dependentExpressions: Set<AnyDependentExpression>;
-    protected dependencyExpressionsCache: ReadonlySet<string> | null;
-    get dependencyExpressions(): ReadonlySet<string>;
     get isTranslated(): boolean;
     set isTranslated(value: true);
     protected _isTranslated: boolean;
-    registerDependentExpression(expression: AnyDependentExpression): void;
 }

package/dist/parse/expression/abstract/DependentExpression.d.ts

@@ -1,4 +1,4 @@
-import { XFormsXPathEvaluator } from '@getodk/xpath';
+import { EngineXPathEvaluator } from '../../../integration/xpath/EngineXPathEvaluator.ts';
 import { ConstantExpression, ConstantTruthyExpression } from '../../xpath/semantic-analysis.ts';
 import { DependencyContext } from './DependencyContext.ts';
 declare const evaluatorMethodsByResultType: {
@@ -10,7 +10,7 @@ declare const evaluatorMethodsByResultType: {
 type EvaluatorMethodsByResultType = typeof evaluatorMethodsByResultType;
 export type DependentExpressionResultType = keyof EvaluatorMethodsByResultType;
 export type DependentExpressionEvaluatorMethod<Type extends DependentExpressionResultType> = EvaluatorMethodsByResultType[Type];
-export type DependentExpressionResult<Type extends DependentExpressionResultType> = ReturnType<XFormsXPathEvaluator[DependentExpressionEvaluatorMethod<Type>]>;
+export type DependentExpressionResult<Type extends DependentExpressionResultType> = ReturnType<EngineXPathEvaluator[DependentExpressionEvaluatorMethod<Type>]>;
 interface SemanticDependencyOptions {
     /**
      * @default false
@@ -33,7 +33,6 @@ export interface ConstantTruthyDependentExpression extends ConstantDependentExpr
 export declare abstract class DependentExpression<Type extends DependentExpressionResultType> {
     readonly resultType: Type;
     readonly expression: string;
-    readonly dependencyReferences: ReadonlySet<string>;
     readonly isTranslated: boolean;
     readonly evaluatorMethod: DependentExpressionEvaluatorMethod<Type>;
     readonly constantExpression: ConstantExpression | null;

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

@@ -1,18 +1,19 @@
 import { DependencyContext } from '../expression/abstract/DependencyContext.ts';
 import { BindComputationExpression } from '../expression/BindComputationExpression.ts';
 import { MessageDefinition } from '../text/MessageDefinition.ts';
-import { XFormDataType } from '../XFormDataType.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 extends DependencyContext {
+export declare class BindDefinition<T extends BindType = BindType> extends DependencyContext {
     readonly form: XFormDefinition;
     protected readonly model: ModelDefinition;
     readonly nodeset: string;
     readonly bindElement: BindElement;
-    readonly bindType: string | null;
-    readonly dataType: XFormDataType;
+    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'>;
@@ -35,5 +36,5 @@ export declare class BindDefinition extends DependencyContext {
     get reference(): string;
     get parentReference(): string | null;
     constructor(form: XFormDefinition, model: ModelDefinition, nodeset: string, bindElement: BindElement);
-    toJSON(): Omit<this, "reference" | "form" | "isTranslated" | "parentReference" | "toJSON" | "dependencyExpressions" | "registerDependentExpression" | "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/BindTypeDefinition.d.ts

@@ -0,0 +1,20 @@
+import { BindElement } from './BindElement.ts';
+/**
+ * As specified by {@link https://getodk.github.io/xforms-spec/#bind-attributes}
+ */
+export declare const DEFAULT_BIND_TYPE = "string";
+export type DefaultBindType = typeof DEFAULT_BIND_TYPE;
+/**
+ * As specified by {@link https://getodk.github.io/xforms-spec/#data-types}
+ */
+declare const BIND_TYPES: readonly ["string", "int", "boolean", "decimal", "date", "time", "dateTime", "geopoint", "geotrace", "geoshape", "binary", "barcode", "intent"];
+type BindTypes = typeof BIND_TYPES;
+export type BindType = BindTypes[number];
+export declare class BindTypeDefinition<T extends BindType = BindType> {
+    readonly source: string | null;
+    readonly resolved: T;
+    static from<T extends BindType>(bindElement: BindElement): BindTypeDefinition<T>;
+    private constructor();
+    private constructor();
+}
+export {};

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

@@ -1,24 +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 dependencyExpressions: ReadonlySet<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/FormSubmissionDefinition.d.ts

@@ -0,0 +1,8 @@
+import { SubmissionDefinition } from '../../client/submission/SubmissionDefinition.ts';
+import { XFormDOM } from '../XFormDOM.ts';
+export declare class FormSubmissionDefinition implements SubmissionDefinition {
+    readonly submissionAction: URL | null;
+    readonly submissionMethod = "post";
+    readonly encryptionKey: string | null;
+    constructor(xformDOM: XFormDOM);
+}

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

@@ -0,0 +1,4 @@
+import { StaticDocument } from '../../../integration/xpath/static-dom/StaticDocument.ts';
+import { ItextTranslationRootDefinition } from './ItextTranslationRootDefinition.ts';
+export declare class ItextTranslationDefinition extends StaticDocument<ItextTranslationRootDefinition> {
+}

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

@@ -0,0 +1,9 @@
+import { XFormsItextTranslationElement, XFORMS_KNOWN_ATTRIBUTE, XFORMS_LOCAL_NAME } from '@getodk/xpath';
+import { StaticElement } from '../../../integration/xpath/static-dom/StaticElement.ts';
+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;
+    getAttributeValue(localName: string): string | null;
+}

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

@@ -0,0 +1,8 @@
+import { XFormsItextTranslationMap } from '@getodk/xpath';
+import { EngineXPathNode } from '../../../integration/xpath/adapter/kind.ts';
+import { XFormDOM } from '../../XFormDOM.ts';
+import { ItextTranslationRootDefinition } from './ItextTranslationRootDefinition.ts';
+export declare class ItextTranslationsDefinition extends Map<string, ItextTranslationRootDefinition> implements XFormsItextTranslationMap<EngineXPathNode> {
+    static from(xformDOM: XFormDOM): ItextTranslationsDefinition;
+    private constructor();
+}

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

@@ -1,14 +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 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 nodeName: string;
+    readonly valueType: V;
+    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][];
+    toJSON(): [string, BindDefinition<"string" | "boolean" | "time" | "barcode" | "binary" | "date" | "dateTime" | "decimal" | "geopoint" | "geoshape" | "geotrace" | "int" | "intent">][];
 }
 export {};

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

@@ -1,10 +1,12 @@
 import { XFormDefinition } from '../XFormDefinition.ts';
+import { ItextTranslationsDefinition } from './ItextTranslation/ItextTranslationsDefinition.ts';
 import { ModelBindMap } from './ModelBindMap.ts';
 import { RootDefinition } from './RootDefinition.ts';
 export declare class ModelDefinition {
     readonly form: XFormDefinition;
     readonly binds: ModelBindMap;
     readonly root: RootDefinition;
+    readonly itextTranslations: ItextTranslationsDefinition;
     constructor(form: XFormDefinition);
     toJSON(): Omit<this, "form" | "toJSON">;
 }

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,27 +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 dependencyExpressions: ReadonlySet<string>;
-    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,5 +1,6 @@
+import { ValueType } from '../../client/ValueType.ts';
 import { AnyBodyElementDefinition } from '../body/BodyDefinition.ts';
-import { InputDefinition } from '../body/control/InputDefinition.ts';
+import { InputControlDefinition } from '../body/control/InputControlDefinition.ts';
 import { BindComputationExpression } from '../expression/BindComputationExpression.ts';
 import { ConstantTruthyDependentExpression } from '../expression/abstract/DependentExpression.ts';
 import { HintDefinition } from '../text/HintDefinition.ts';
@@ -8,23 +9,23 @@ 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;
 /**
  * @package This class is used internally, both in static types and at runtime,
  * to guard and guide the distinction between instance state nodes for 'note'
- * and 'string' node types. It is intentionally package-private! The less
+ * and 'input' node types. It is intentionally package-private! The less
  * specific {@link NoteNode.definition} type, if it has any client value at all,
  * should be more than sufficient. Clients are otherwise expected to use other
  * 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;
-    readonly bodyElement: InputDefinition;
+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: InputDefinition, 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();
+}