@getodk/xforms-engine 0.6.0 → 0.7.0

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

@@ -1,32 +1,29 @@
-import { XFORMS_KNOWN_ATTRIBUTE, XFORMS_LOCAL_NAME, XPathNodeKindKey } from '@getodk/xpath';
-import { QualifiedName } from '../../../lib/names/QualifiedName.ts';
+import { QualifiedNameSource, QualifiedName } from '../../../lib/names/QualifiedName.ts';
 import { XFormsXPathElement } from '../adapter/XFormsXPathNode.ts';
-import { StaticAttribute } from './StaticAttribute.ts';
+import { StaticAttributeOptions, StaticAttribute } from './StaticAttribute.ts';
 import { StaticDocument } from './StaticDocument.ts';
-import { StaticChildNode, StaticParentNode, StaticNode } from './StaticNode.ts';
-export type StaticElementAttributesFactory = (element: StaticElement) => readonly StaticAttribute[];
-export type StaticElementChildNodesFactory = (element: StaticElement) => readonly StaticChildNode[];
+import { StaticChildNode } from './StaticNode.ts';
+import { StaticParentNode } from './StaticParentNode.ts';
+export type StaticElementChildOption = StaticElementOptions | string;
 export interface StaticElementOptions {
-    readonly namespaceURI: string | null;
-    readonly prefix?: string | null;
-    readonly localName: string;
+    readonly name: QualifiedNameSource | string;
+    readonly attributes?: readonly StaticAttributeOptions[];
+    readonly children?: readonly StaticElementChildOption[];
 }
-type StaticElementKnownAttributeValue<T extends StaticElement, LocalName extends string> = T extends {
-    readonly [XFORMS_KNOWN_ATTRIBUTE]: LocalName;
-} ? string : string | null;
-export declare class StaticElement<Parent extends StaticParentNode = StaticParentNode> extends StaticNode<'element'> implements XFormsXPathElement {
-    readonly parent: Parent;
-    readonly [XFORMS_LOCAL_NAME]?: string;
-    readonly [XFORMS_KNOWN_ATTRIBUTE]?: string;
-    readonly [XPathNodeKindKey] = "element";
-    readonly nodeType = "static-element";
+export declare class StaticElement extends StaticParentNode<'element'> implements XFormsXPathElement {
+    readonly parent: StaticDocument | StaticElement;
+    private computedValue;
     readonly rootDocument: StaticDocument;
     readonly root: StaticElement;
     readonly qualifiedName: QualifiedName;
+    readonly nodeset: string;
     readonly attributes: readonly StaticAttribute[];
     readonly children: readonly StaticChildNode[];
-    readonly value: null;
-    constructor(parent: Parent, attributesFactory: StaticElementAttributesFactory, childNodesFactory: StaticElementChildNodesFactory, options: StaticElementOptions);
+    readonly childElements: readonly StaticElement[];
+    readonly value: string | null;
+    constructor(parent: StaticDocument | StaticElement, options: StaticElementOptions);
+    isLeafElement(): this is StaticLeafElement;
+    assertLeafElement(): asserts this is StaticLeafElement;
     /**
      * @todo Generalize this, incorporate into {@link EngineDOMAdapter}
      * @todo Namespaced lookup
@@ -42,7 +39,9 @@ export declare class StaticElement<Parent extends StaticParentNode = StaticParen
      * up. (This was put off because the types are already plenty complex as it
      * is.)
      */
-    getAttributeValue<This extends StaticElement, LocalName extends string>(this: This, localName: LocalName): StaticElementKnownAttributeValue<This, LocalName>;
+    getAttributeValue(localName: string): string | null;
     getXPathValue(): string;
 }
-export {};
+export interface StaticLeafElement extends StaticElement {
+    readonly value: string;
+}

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

@@ -29,5 +29,5 @@ export declare abstract class StaticNode<Kind extends StaticNodeKind> implements
     abstract getXPathValue(): string;
 }
 export type AnyStaticNode = StaticDocument | StaticElement | StaticAttribute | StaticText;
-export type StaticParentNode = StaticDocument | StaticElement;
+export type StaticNodeParent = StaticDocument | StaticElement;
 export type StaticChildNode = StaticElement | StaticText;

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

@@ -0,0 +1,13 @@
+import { XPathNodeKindKey } from '@getodk/xpath';
+import { StaticElement } from './StaticElement.ts';
+import { StaticNode, StaticChildNode } from './StaticNode.ts';
+type StaticParentNodeKind = 'document' | 'element';
+type StaticParentNodeType<Kind extends StaticParentNodeKind> = `static-${Kind}`;
+export declare abstract class StaticParentNode<Kind extends StaticParentNodeKind> extends StaticNode<Kind> {
+    abstract readonly children: readonly StaticChildNode[];
+    abstract readonly childElements: readonly StaticElement[];
+    readonly [XPathNodeKindKey]: Kind;
+    readonly nodeType: StaticParentNodeType<Kind>;
+    constructor(kind: Kind);
+}
+export {};

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

@@ -0,0 +1,3 @@
+import { QualifiedName, QualifiedNameSource } from '../../../lib/names/QualifiedName.ts';
+export type StaticNodeNameSource = QualifiedName | QualifiedNameSource | string;
+export declare const staticNodeName: (source: StaticNodeNameSource) => QualifiedName;

package/dist/lib/client-reactivity/instance-state/createNodeRangeInstanceState.d.ts

@@ -0,0 +1,4 @@
+import { InstanceState } from '../../../client/serialization/InstanceState.ts';
+import { ClientReactiveSerializableParentNode } from '../../../instance/internal-api/serialization/ClientReactiveSerializableParentNode.ts';
+import { RepeatInstance } from '../../../instance/repeat/RepeatInstance.ts';
+export declare const createNodeRangeInstanceState: (node: ClientReactiveSerializableParentNode<RepeatInstance>) => InstanceState;

package/dist/lib/client-reactivity/instance-state/createParentNodeInstanceState.d.ts

@@ -0,0 +1,4 @@
+import { InstanceState } from '../../../client/serialization/InstanceState.ts';
+import { GeneralChildNode } from '../../../instance/hierarchy.ts';
+import { ClientReactiveSerializableParentNode } from '../../../instance/internal-api/serialization/ClientReactiveSerializableParentNode.ts';
+export declare const createParentNodeInstanceState: (node: ClientReactiveSerializableParentNode<GeneralChildNode>) => InstanceState;

package/dist/lib/client-reactivity/instance-state/createPrimaryInstanceState.d.ts

@@ -0,0 +1,3 @@
+import { InstanceState } from '../../../client/serialization/InstanceState.ts';
+import { ClientReactiveSerializableInstance } from '../../../instance/internal-api/serialization/ClientReactiveSerializableInstance.ts';
+export declare const createPrimaryInstanceState: (node: ClientReactiveSerializableInstance) => InstanceState;

package/dist/lib/client-reactivity/instance-state/createRootInstanceState.d.ts

@@ -0,0 +1,3 @@
+import { InstanceState } from '../../../client/serialization/InstanceState.ts';
+import { Root } from '../../../instance/Root.ts';
+export declare const createRootInstanceState: (node: Root) => InstanceState;

package/dist/lib/client-reactivity/instance-state/createTemplatedNodeInstanceState.d.ts

@@ -0,0 +1,6 @@
+import { InstanceState } from '../../../client/serialization/InstanceState.ts';
+import { ClientReactiveSerializableTemplatedNode } from '../../../instance/internal-api/serialization/ClientReactiveSerializableTemplatedNode.ts';
+/**
+ * @see {@link TemplatedNodeAttributeSerializationError}
+ */
+export declare const createTemplatedNodeInstanceState: (node: ClientReactiveSerializableTemplatedNode) => InstanceState;

package/dist/lib/client-reactivity/instance-state/createValueNodeInstanceState.d.ts

@@ -0,0 +1,3 @@
+import { InstanceState } from '../../../client/serialization/InstanceState.ts';
+import { ClientReactiveSerializableValueNode } from '../../../instance/internal-api/serialization/ClientReactiveSerializableValueNode.ts';
+export declare const createValueNodeInstanceState: (node: ClientReactiveSerializableValueNode) => InstanceState;

package/dist/lib/client-reactivity/instance-state/prepareInstancePayload.d.ts

@@ -0,0 +1,8 @@
+import { InstancePayload } from '../../../client/serialization/InstancePayload.ts';
+import { InstancePayloadType } from '../../../client/serialization/InstancePayloadOptions.ts';
+import { ClientReactiveSerializableInstance } from '../../../instance/internal-api/serialization/ClientReactiveSerializableInstance.ts';
+export interface PrepareInstancePayloadOptions<PayloadType extends InstancePayloadType> {
+    readonly payloadType: PayloadType;
+    readonly maxSize: number;
+}
+export declare const prepareInstancePayload: <PayloadType extends InstancePayloadType>(instanceRoot: ClientReactiveSerializableInstance, options: PrepareInstancePayloadOptions<PayloadType>) => InstancePayload<PayloadType>;

package/dist/lib/codecs/TempUnsupportedControlCodec.d.ts

@@ -0,0 +1,7 @@
+import { ValueType } from '../../client/ValueType.ts';
+import { ValueCodec } from './ValueCodec.ts';
+export type TempUnsupportedRuntimeValue = unknown;
+export type TempUnsupportedInputValue = unknown;
+export declare class TempUnsupportedControlCodec<V extends ValueType> extends ValueCodec<V, TempUnsupportedRuntimeValue, TempUnsupportedInputValue> {
+    constructor(valueType: V);
+}

package/dist/lib/names/UnprefixedXFormsName.d.ts

@@ -0,0 +1,4 @@
+import { QualifiedName } from './QualifiedName.ts';
+export declare class UnprefixedXFormsName extends QualifiedName {
+    constructor(localName: string);
+}

package/dist/lib/reactivity/createInstanceValueState.d.ts

@@ -1,40 +1,15 @@
 import { InstanceValueContext } from '../../instance/internal-api/InstanceValueContext.ts';
 import { SimpleAtomicState } from './types.ts';
-type InitialValueSource = 'FORM_DEFAULT' | 'PRIMARY_INSTANCE';
-export interface InstanceValueStateOptions {
-    /**
-     * Specifies the source of a {@link createInstanceValueState} signal's initial
-     * value state, where:
-     *
-     * - 'FORM_DEFAULT': Derives the initial state from the form's definition of
-     *   the node itself. This is the default option, appropriate when
-     *   initializing a form without additional primary instance data. In other
-     *   words, this value should not be used for edits.
-     *
-     * - 'PRIMARY_INSTANCE': Derives the initial state from the current text
-     *   content of the {@link ValueNode.contextNode}. This option should be
-     *   specified when initializing a form with existing primary instance data,
-     *   such as when editing a previous submission.
-     *
-     * @default 'FORM_DEFAULT'
-     *
-     * Specifies whether a {@link createInstanceValueState} signal's initial state
-     * should be derived from the current text content of the
-     * {@link ValueNode.contextNode | primary instance DOM state}.
-     */
-    readonly initialValueSource?: InitialValueSource;
-}
 export type InstanceValueState = SimpleAtomicState<string>;
 /**
  * Provides a consistent interface for value nodes of any type which:
  *
  * - derives initial state from either an existing instance (e.g. for edits) or
- *   the node's definition (e.g. initializing a new submission)
+ *   the node's definition (e.g. initializing a new instance)
  * - decodes current primary instance state into the value node's runtime type
  * - encodes updated runtime values to store updated instance state
  * - initializes reactive computation of `calculate` bind expressions for those
  *   nodes defined with one
  * - prevents downstream writes to nodes in a readonly state
  */
-export declare const createInstanceValueState: (context: InstanceValueContext, options?: InstanceValueStateOptions) => InstanceValueState;
-export {};
+export declare const createInstanceValueState: (context: InstanceValueContext) => InstanceValueState;

package/dist/parse/XFormDOM.d.ts

@@ -29,7 +29,7 @@ export declare class XFormDOM {
     readonly secondaryInstanceElements: readonly DOMSecondaryInstanceElement[];
     readonly body: Element;
     protected constructor(sourceXML: string, options: XFormDOMOptions);
-    toJSON(): Omit<this, "head" | "html" | "title" | "primaryInstance" | "model" | "primaryInstanceRoot" | "xformDocument" | "toJSON"> & {
+    toJSON(): Omit<this, "head" | "html" | "title" | "toJSON" | "model" | "primaryInstance" | "primaryInstanceRoot" | "xformDocument"> & {
         xformDocument: string;
         html: string;
         head: string;

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

@@ -36,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" | "model" | "toJSON" | "reference" | "isTranslated" | "parentReference" | "bindElement" | "parentBind">;
+    toJSON(): Omit<this, "form" | "reference" | "parentReference" | "toJSON" | "isTranslated" | "model" | "bindElement" | "parentBind">;
 }

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

@@ -0,0 +1,18 @@
+import { XFORMS_KNOWN_ATTRIBUTE, XFORMS_LOCAL_NAME, XFormsItextTranslationMap } from '@getodk/xpath';
+import { StaticDocument } from '../../integration/xpath/static-dom/StaticDocument.ts';
+import { StaticElement } from '../../integration/xpath/static-dom/StaticElement.ts';
+import { XFormDOM } from '../XFormDOM.ts';
+export interface ItextTranslationDefinition extends StaticDocument {
+    readonly rootDocument: ItextTranslationDefinition;
+    readonly root: ItextTranslationRootDefinition;
+}
+export interface ItextTranslationRootDefinition extends StaticElement {
+    readonly [XFORMS_LOCAL_NAME]: 'translation';
+    readonly [XFORMS_KNOWN_ATTRIBUTE]: 'lang';
+    readonly root: ItextTranslationRootDefinition;
+    readonly rootDocument: ItextTranslationDefinition;
+}
+export declare class ItextTranslationsDefinition extends Map<string, ItextTranslationRootDefinition> implements XFormsItextTranslationMap<ItextTranslationRootDefinition> {
+    static from(xformDOM: XFormDOM): ItextTranslationsDefinition;
+    private constructor();
+}

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

@@ -1,4 +1,5 @@
 import { ValueType } from '../../client/ValueType.ts';
+import { StaticLeafElement } from '../../integration/xpath/static-dom/StaticElement.ts';
 import { NamespaceDeclarationMap, NamedSubtreeDefinition } from '../../lib/names/NamespaceDeclarationMap.ts';
 import { QualifiedName } from '../../lib/names/QualifiedName.ts';
 import { AnyBodyElementDefinition, ControlElementDefinition } from '../body/BodyDefinition.ts';
@@ -6,14 +7,12 @@ import { BindDefinition } from './BindDefinition.ts';
 import { DescendentNodeDefinition } from './DescendentNodeDefinition.ts';
 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 template: StaticLeafElement;
     readonly type = "leaf-node";
     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" | "bind" | "toJSON" | "root" | "bodyElement">;
+    constructor(parent: ParentNodeDefinition, bind: BindDefinition, bodyElement: AnyBodyElementDefinition | null, template: StaticLeafElement);
+    toJSON(): Omit<this, "parent" | "toJSON" | "bind" | "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" | "barcode" | "binary" | "date" | "dateTime" | "decimal" | "geopoint" | "geoshape" | "geotrace" | "int" | "intent">][];
+    toJSON(): [string, BindDefinition<"string" | "boolean" | "time" | "int" | "decimal" | "date" | "dateTime" | "geopoint" | "geotrace" | "geoshape" | "binary" | "barcode" | "intent">][];
 }
 export {};

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

@@ -1,12 +1,19 @@
+import { StaticDocument } from '../../integration/xpath/static-dom/StaticDocument.ts';
 import { XFormDefinition } from '../XFormDefinition.ts';
-import { ItextTranslationsDefinition } from './ItextTranslation/ItextTranslationsDefinition.ts';
+import { ItextTranslationsDefinition } from './ItextTranslationsDefinition.ts';
 import { ModelBindMap } from './ModelBindMap.ts';
+import { AnyNodeDefinition } from './NodeDefinition.ts';
+import { NodeDefinitionMap } from './nodeDefinitionMap.ts';
 import { RootDefinition } from './RootDefinition.ts';
 export declare class ModelDefinition {
     readonly form: XFormDefinition;
     readonly binds: ModelBindMap;
     readonly root: RootDefinition;
+    readonly nodes: NodeDefinitionMap;
+    readonly instance: StaticDocument;
     readonly itextTranslations: ItextTranslationsDefinition;
     constructor(form: XFormDefinition);
-    toJSON(): Omit<this, "form" | "toJSON">;
+    getNodeDefinition(nodeset: string): AnyNodeDefinition;
+    getRootDefinition(instance: StaticDocument): RootDefinition;
+    toJSON(): Omit<this, "form" | "toJSON" | "getNodeDefinition" | "getRootDefinition">;
 }

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

@@ -1,55 +1,46 @@
+import { StaticElement } from '../../integration/xpath/static-dom/StaticElement.ts';
 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';
 import { LeafNodeDefinition } from './LeafNodeDefinition.ts';
-import { RepeatInstanceDefinition } from './RepeatInstanceDefinition.ts';
-import { AnyRepeatRangeDefinition } from './RepeatRangeDefinition.ts';
-import { RepeatTemplateDefinition } from './RepeatTemplateDefinition.ts';
+import { AnyRepeatDefinition } from './RepeatDefinition.ts';
 import { RootDefinition } from './RootDefinition.ts';
 import { SubtreeDefinition } from './SubtreeDefinition.ts';
 /**
- * Corresponds to the model/entry DOM root node, i.e.:
+ * Corresponds to a model instance root node, i.e.:
  *
  * - the element matching `/*` in primary instance expressions, a.k.a.
  * - `/h:html/h:head/xf:model/xf:instance[1]/*`
  */
 export type RootNodeType = 'root';
 /**
- * Corresponds to a range/sequence of model/entry DOM subtrees which in turn
- * corresponds to a <repeat> in the form body definition.
- */
-export type RepeatRangeType = 'repeat-range';
-/**
- * Corresponds to a template definition for a repeat range, which either has
- * an explicit `jr:template=""` attribute in the form definition or is inferred
- * as a template from the form's first element matched by a <repeat nodeset>.
- */
-export type RepeatTemplateType = 'repeat-template';
-/**
- * Corresponds to a single instance of a model/entry DOM subtree which
- * in turn corresponds to a <repeat> in the form body definition, and a
- * 'repeat-range' definition.
+ * Corresponds to the combined concepts defining a "repeat".
+ *
+ * @see {@link RepeatDefinition} for details on these concepts and how they are used to produce a "repeat definition", as such.
+ *
+ * , including or
+ * referencing all of the following:
+ *
  */
-export type RepeatInstanceType = 'repeat-instance';
+export type RepeatType = 'repeat';
 /**
- * Corresponds to a model/entry DOM subtree which **does not** correspond to a
+ * Corresponds to a model instance subtree which **does not** correspond to a
  * <repeat> in the form definition. This will typically correspond to a <group>,
  * but this is not strictly necessary per spec (hence the distinct name).
  */
 export type SubtreeNodeType = 'subtree';
 /**
- * Corresponds to a model/entry DOM leaf node, i.e. one of:
+ * Corresponds to a model instance leaf node, i.e. one of:
  *
  * - An element with no child elements
  * - Any attribute corresponding to a bind's `nodeset` expression
  */
 export type LeafNodeType = 'leaf-node';
-export type NodeDefinitionType = RootNodeType | RepeatRangeType | RepeatTemplateType | RepeatInstanceType | SubtreeNodeType | LeafNodeType;
-export type ParentNodeDefinition = RootDefinition | RepeatTemplateDefinition | RepeatInstanceDefinition | SubtreeDefinition;
-export type ChildNodeDefinition = AnyRepeatRangeDefinition | LeafNodeDefinition | SubtreeDefinition;
-export type ChildNodeInstanceDefinition = RepeatTemplateDefinition | RepeatInstanceDefinition | SubtreeDefinition | LeafNodeDefinition;
+export type NodeDefinitionType = RootNodeType | RepeatType | SubtreeNodeType | LeafNodeType;
+export type ParentNodeDefinition = RootDefinition | AnyRepeatDefinition | SubtreeDefinition;
+export type ChildNodeDefinition = AnyRepeatDefinition | LeafNodeDefinition | SubtreeDefinition;
 export declare abstract class NodeDefinition<Type extends NodeDefinitionType> implements NamedSubtreeDefinition {
     readonly bind: BindDefinition;
     abstract readonly type: Type;
@@ -59,12 +50,9 @@ export declare abstract class NodeDefinition<Type extends NodeDefinitionType> im
     abstract readonly isTranslated: boolean;
     abstract readonly root: RootDefinition;
     abstract readonly parent: ParentNodeDefinition | null;
+    abstract readonly template: StaticElement;
     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;
     constructor(bind: BindDefinition);
 }
-export type AnyNodeDefinition = RootDefinition | AnyRepeatRangeDefinition | RepeatTemplateDefinition | RepeatInstanceDefinition | SubtreeDefinition | LeafNodeDefinition;
+export type AnyNodeDefinition = RootDefinition | AnyRepeatDefinition | SubtreeDefinition | LeafNodeDefinition;

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

@@ -1,4 +1,5 @@
 import { ValueType } from '../../client/ValueType.ts';
+import { StaticLeafElement } from '../../integration/xpath/static-dom/StaticElement.ts';
 import { AnyBodyElementDefinition } from '../body/BodyDefinition.ts';
 import { InputControlDefinition } from '../body/control/InputControlDefinition.ts';
 import { BindComputationExpression } from '../expression/BindComputationExpression.ts';
@@ -26,6 +27,6 @@ export declare class NoteNodeDefinition<V extends ValueType = ValueType> extends
     readonly bind: NoteBindDefinition<V>;
     readonly bodyElement: InputControlDefinition;
     readonly noteTextDefinition: NoteTextDefinition;
-    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);
+    static from<V extends ValueType>(parent: ParentNodeDefinition, bind: BindDefinition<V>, bodyElement: AnyBodyElementDefinition | null, node: StaticLeafElement): NoteNodeDefinition<V> | null;
+    constructor(parent: ParentNodeDefinition, bind: NoteBindDefinition<V>, bodyElement: InputControlDefinition, noteTextDefinition: NoteTextDefinition, template: StaticLeafElement);
 }

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

@@ -1,4 +1,5 @@
 import { ValueType } from '../../client/ValueType.ts';
+import { StaticLeafElement } from '../../integration/xpath/static-dom/StaticElement.ts';
 import { RuntimeValue } from '../../lib/codecs/getSharedValueCodec.ts';
 import { RangeControlBoundsDefinition, RangeControlDefinition } from '../body/control/RangeControlDefinition.ts';
 import { BindDefinition } from './BindDefinition.ts';
@@ -33,7 +34,7 @@ declare class RangeNodeBoundsDefinition<V extends RangeValueType = RangeValueTyp
 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>>;
+    static from<V extends ValueType>(parent: ParentNodeDefinition, bind: BindDefinition<V>, bodyElement: RangeControlDefinition, node: StaticLeafElement): RangeNodeDefinition<Extract<V, RangeValueType>>;
     readonly bounds: RangeNodeBoundsDefinition<V>;
     private constructor();
 }

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

@@ -0,0 +1,62 @@
+import { StaticElement } from '../../integration/xpath/static-dom/StaticElement.ts';
+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 { ChildNodeDefinition, ParentNodeDefinition } from './NodeDefinition.ts';
+export type RepeatInstanceNodes = readonly [StaticElement, ...StaticElement[]];
+export interface ControlledRepeatDefinition extends RepeatDefinition {
+    readonly count: RepeatCountControlExpression;
+}
+export interface UncontrolledRepeatDefinition extends RepeatDefinition {
+    readonly count: null;
+}
+/**
+ * Represents a definition of the combined concepts colloquially called a
+ * "repeat", as defined by a form, where those concepts include:
+ *
+ * - A {@link RepeatElementDefinition}—corresponding to a `<repeat>` {@link https://getodk.github.io/xforms-spec/#body-elements | body element}—which is associated with the nodeset referencing the "repeat template" and
+ *   all "repeat instances" (see below points describing both concepts in more detail). The presence of such a body element determines whether to produce a repeat definition (rather than e.g. a {@link SubtreeDefinition}).
+ *
+ * - A "repeat template", defined by a form either
+ *   explicitly,
+ *   or derived from the structure of the first form-defined "repeat instance"
+ *   (as described in the next point).
+ *
+ * - A sequence of one or more model instance nodes, each representing a "repeat instance"
+ *   defined by the form. These nodes contribute to the definition in the following ways:
+ *
+ *   - If an explicit "repeat template" is not defined for
+ *   the "repeat", one is derived from the **structure** (but not the values!)
+ *   of the first such model instance node.
+ *
+ *   - If the "repeat" is {@link ControlledRepeatDefinition | controlled} (i.e. by either a `jr:count` or `jr:noAddRemove` {@link https://getodk.github.io/xforms-spec/#body-attributes | attribute} on the associated {@link RepeatElementDefinition}
+ *
+ * (For construction of this
+ * definition, all other referenced instance nodes are **consumed** in the
+ * process of building the repeat definition's subtree of a
+ * {@link RootDefinition}, ensuring that one repeat definition is produced for
+ * all applicable nodes; they are later referenced for construction of a
+ * form's {@link PrimaryInstance | instance state}.)
+ *
+ * Combined, these concepts produce the details required to instantiate the
+ * {@link RepeatRange} and {@link RepeatInstance} instance state nodes
+ * associated with a defined repeat.
+ */
+export declare class RepeatDefinition extends DescendentNodeDefinition<'repeat', RepeatElementDefinition> {
+    static from(parent: ParentNodeDefinition, bind: BindDefinition, bodyElement: RepeatElementDefinition, instanceNodes: RepeatInstanceNodes): AnyRepeatDefinition;
+    readonly type = "repeat";
+    readonly children: readonly ChildNodeDefinition[];
+    readonly count: RepeatCountControlExpression | null;
+    readonly template: StaticElement;
+    readonly namespaceDeclarations: NamespaceDeclarationMap;
+    readonly qualifiedName: QualifiedName;
+    private constructor();
+    isControlled(): this is ControlledRepeatDefinition;
+    isUncontrolled(): this is UncontrolledRepeatDefinition;
+    omitTemplate(instanceNodes: readonly StaticElement[]): readonly StaticElement[];
+    toJSON(): object;
+}
+export type AnyRepeatDefinition = ControlledRepeatDefinition | UncontrolledRepeatDefinition;

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

@@ -2,10 +2,7 @@ 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 qualifiedName: QualifiedName;
     readonly value: string;
 }
 /**

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

@@ -1,3 +1,4 @@
+import { StaticElement } from '../../integration/xpath/static-dom/StaticElement.ts';
 import { QualifiedName } from '../../lib/names/QualifiedName.ts';
 import { RootAttributeDefinition } from './RootAttributeDefinition.ts';
 import { RootDefinition } from './RootDefinition.ts';
@@ -18,6 +19,6 @@ import { RootDefinition } from './RootDefinition.ts';
  * @see {@link QualifiedName} for more detail.
  */
 export declare class RootAttributeMap extends Map<QualifiedName, RootAttributeDefinition> {
-    static from(root: RootDefinition, domRootSourceElement: Element): RootAttributeMap;
+    static from(root: RootDefinition, instanceNode: StaticElement): RootAttributeMap;
     private constructor();
 }

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

@@ -1,29 +1,28 @@
+import { StaticElement } from '../../integration/xpath/static-dom/StaticElement.ts';
 import { NamespaceDeclarationMap } from '../../lib/names/NamespaceDeclarationMap.ts';
 import { QualifiedName } from '../../lib/names/QualifiedName.ts';
 import { BodyClassList } from '../body/BodyDefinition.ts';
 import { XFormDefinition } from '../XFormDefinition.ts';
-import { FormSubmissionDefinition } from './FormSubmissionDefinition.ts';
 import { ModelDefinition } from './ModelDefinition.ts';
 import { ChildNodeDefinition, ParentNodeDefinition, NodeDefinition } from './NodeDefinition.ts';
 import { RootAttributeMap } from './RootAttributeMap.ts';
+import { SubmissionDefinition } from './SubmissionDefinition.ts';
 export declare class RootDefinition extends NodeDefinition<'root'> {
     protected readonly form: XFormDefinition;
     protected readonly model: ModelDefinition;
-    readonly submission: FormSubmissionDefinition;
+    readonly submission: SubmissionDefinition;
     readonly classes: BodyClassList;
     readonly type = "root";
     readonly qualifiedName: QualifiedName;
     readonly bodyElement: null;
     readonly root: this;
     readonly parent: null;
+    readonly template: StaticElement;
     readonly namespaceDeclarations: NamespaceDeclarationMap;
     readonly attributes: RootAttributeMap;
     readonly children: readonly ChildNodeDefinition[];
-    readonly instances: null;
-    readonly node: Element;
-    readonly defaultValue: null;
     readonly isTranslated = false;
-    constructor(form: XFormDefinition, model: ModelDefinition, submission: FormSubmissionDefinition, classes: BodyClassList);
-    buildSubtree(parent: ParentNodeDefinition): readonly ChildNodeDefinition[];
-    toJSON(): Omit<this, "form" | "bind" | "model" | "toJSON" | "root" | "bodyElement" | "buildSubtree">;
+    constructor(form: XFormDefinition, model: ModelDefinition, submission: SubmissionDefinition, classes: BodyClassList);
+    buildSubtree(parent: ParentNodeDefinition, node: StaticElement): readonly ChildNodeDefinition[];
+    toJSON(): Omit<this, "form" | "toJSON" | "bind" | "root" | "model" | "bodyElement" | "buildSubtree">;
 }

package/dist/parse/model/SecondaryInstance/SecondaryInstancesDefinition.d.ts

@@ -1,8 +1,21 @@
-import { XFormsSecondaryInstanceMap } from '@getodk/xpath';
+import { XFORMS_KNOWN_ATTRIBUTE, XFORMS_LOCAL_NAME, XFormsSecondaryInstanceMap } from '@getodk/xpath';
 import { EngineXPathNode } from '../../../integration/xpath/adapter/kind.ts';
+import { StaticDocument } from '../../../integration/xpath/static-dom/StaticDocument.ts';
+import { StaticElement } from '../../../integration/xpath/static-dom/StaticElement.ts';
 import { XFormDOM } from '../../XFormDOM.ts';
-import { SecondaryInstanceRootDefinition } from './SecondaryInstanceRootDefinition.ts';
 import { ExternalSecondaryInstanceResourceLoadOptions } from './sources/ExternalSecondaryInstanceResource.ts';
+export interface SecondaryInstanceDefinition extends StaticDocument {
+    readonly rootDocument: SecondaryInstanceDefinition;
+    readonly root: SecondaryInstanceRootDefinition;
+}
+export interface SecondaryInstanceRootDefinition extends StaticElement {
+    readonly [XFORMS_LOCAL_NAME]: 'instance';
+    readonly [XFORMS_KNOWN_ATTRIBUTE]: 'id';
+    readonly rootDocument: SecondaryInstanceDefinition;
+    readonly root: SecondaryInstanceRootDefinition;
+    getAttributeValue(localName: 'id'): string;
+    getAttributeValue(localName: string): string | null;
+}
 export declare class SecondaryInstancesDefinition extends Map<string, SecondaryInstanceRootDefinition> implements XFormsSecondaryInstanceMap<EngineXPathNode> {
     /**
      * @package Only to be used for testing

package/dist/parse/model/SecondaryInstance/assertSecondaryInstanceDefinition.d.ts

@@ -0,0 +1,5 @@
+import { StaticDocument } from '../../../integration/xpath/static-dom/StaticDocument.ts';
+import { SecondaryInstanceDefinition } from './SecondaryInstancesDefinition.ts';
+type AssertSecondaryInstanceDefinition = (doc: StaticDocument) => asserts doc is SecondaryInstanceDefinition;
+export declare const assertSecondaryInstanceDefinition: AssertSecondaryInstanceDefinition;
+export {};

package/dist/parse/model/SecondaryInstance/defineSecondaryInstance.d.ts

@@ -0,0 +1,5 @@
+import { StaticElementOptions } from '../../../integration/xpath/static-dom/StaticElement.ts';
+import { SecondaryInstanceDefinition } from './SecondaryInstancesDefinition.ts';
+type SecondaryInstanceRoot = StaticElementOptions | '';
+export declare const defineSecondaryInstance: (instanceId: string, secondaryInstanceRoot: SecondaryInstanceRoot) => SecondaryInstanceDefinition;
+export {};

package/dist/parse/model/SecondaryInstance/sources/BlankSecondaryInstanceSource.d.ts

@@ -1,14 +1,8 @@
 import { JRResourceURL } from '../../../../../../common/src/jr-resources/JRResourceURL.ts';
 import { DOMSecondaryInstanceElement } from '../../../XFormDOM.ts';
-import { SecondaryInstanceDefinition } from '../SecondaryInstanceDefinition.ts';
+import { SecondaryInstanceDefinition } from '../SecondaryInstancesDefinition.ts';
 import { SecondaryInstanceSource } from './SecondaryInstanceSource.ts';
 export declare class BlankSecondaryInstanceSource extends SecondaryInstanceSource<'blank'> {
     constructor(instanceId: string, resourceURL: JRResourceURL, domElement: DOMSecondaryInstanceElement);
-    /**
-     * @todo there is really no sense in using the DOM for this, other than it was
-     * quicker/more ergonomic than constructing the requisite {@link StaticNode}
-     * structures directly. Pretty good sign those constructor signatures could
-     * use some TLC!
-     */
     parseDefinition(): SecondaryInstanceDefinition;
 }

package/dist/parse/model/SecondaryInstance/sources/CSVExternalSecondaryInstance.d.ts

@@ -1,4 +1,4 @@
-import { SecondaryInstanceDefinition } from '../SecondaryInstanceDefinition.ts';
+import { SecondaryInstanceDefinition } from '../SecondaryInstancesDefinition.ts';
 import { ExternalSecondaryInstanceSource } from './ExternalSecondaryInstanceSource.ts';
 export declare class CSVExternalSecondaryInstanceSource extends ExternalSecondaryInstanceSource<'csv'> {
     /**

package/dist/parse/model/SecondaryInstance/sources/GeoJSONExternalSecondaryInstance.d.ts

@@ -1,4 +1,4 @@
-import { SecondaryInstanceDefinition } from '../SecondaryInstanceDefinition.ts';
+import { SecondaryInstanceDefinition } from '../SecondaryInstancesDefinition.ts';
 import { ExternalSecondaryInstanceSource } from './ExternalSecondaryInstanceSource.ts';
 export declare class GeoJSONExternalSecondaryInstanceSource extends ExternalSecondaryInstanceSource<'geojson'> {
     parseDefinition(): SecondaryInstanceDefinition;