@getodk/xforms-engine 0.6.0 → 0.8.0

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

@@ -1,11 +1,6 @@
 import { XPathNodeKind } from '@getodk/xpath';
-import { AnyChildNode, AnyNode, AnyParentNode, AnyValueNode } from '../../../instance/hierarchy.ts';
-import { ValueContext } from '../../../instance/internal-api/ValueContext.ts';
+import { AnyChildNode, AnyNode, AnyParentNode } from '../../../instance/hierarchy.ts';
 import { PrimaryInstance } from '../../../instance/PrimaryInstance.ts';
-import { ItextTranslationDefinition } from '../../../parse/model/ItextTranslation/ItextTranslationDefinition.ts';
-import { ItextTranslationRootDefinition } from '../../../parse/model/ItextTranslation/ItextTranslationRootDefinition.ts';
-import { SecondaryInstanceDefinition } from '../../../parse/model/SecondaryInstance/SecondaryInstanceDefinition.ts';
-import { SecondaryInstanceRootDefinition } from '../../../parse/model/SecondaryInstance/SecondaryInstanceRootDefinition.ts';
 import { StaticAttribute } from '../static-dom/StaticAttribute.ts';
 import { StaticDocument } from '../static-dom/StaticDocument.ts';
 import { StaticElement } from '../static-dom/StaticElement.ts';
@@ -15,16 +10,15 @@ export type PrimaryInstanceXPathNode = Extract<AnyNode, XFormsXPathPrimaryInstan
 export type PrimaryInstanceXPathElement = Extract<AnyChildNode, XFormsXPathElement>;
 export type PrimaryInstanceXPathComment = Extract<AnyChildNode, XFormsXPathComment>;
 export type PrimaryInstanceXPathChildNode = PrimaryInstanceXPathElement | PrimaryInstanceXPathComment;
-export type PrimaryInstanceXPathValueElement<Value> = AnyValueNode & ValueContext<Value> & XFormsXPathElement;
-export type EngineXPathDocument = PrimaryInstance | ItextTranslationDefinition | SecondaryInstanceDefinition | StaticDocument;
-export type EngineXPathElement = PrimaryInstanceXPathElement | ItextTranslationRootDefinition | SecondaryInstanceRootDefinition | StaticElement;
+export type EngineXPathDocument = PrimaryInstance | StaticDocument;
+export type EngineXPathElement = PrimaryInstanceXPathElement | StaticElement;
 export type EngineXPathComment = PrimaryInstanceXPathComment;
 export type EngineXPathAttribute = StaticAttribute;
 export type EngineXPathText = StaticText;
 export type XFormsXPathChildNode = EngineXPathElement | EngineXPathText | EngineXPathComment;
 type XPathAdapterParentNode = XFormsXPathDocument | XFormsXPathElement;
 type PrimaryInstanceXPathParentNode = Extract<AnyParentNode, XPathAdapterParentNode>;
-export type EngineXPathParentNode = PrimaryInstanceXPathParentNode | ItextTranslationDefinition | SecondaryInstanceDefinition | ItextTranslationRootDefinition | SecondaryInstanceRootDefinition | StaticDocument | StaticElement;
+export type EngineXPathParentNode = PrimaryInstanceXPathParentNode | StaticDocument | StaticElement;
 export type EngineXPathNode = EngineXPathDocument | EngineXPathElement | EngineXPathAttribute | EngineXPathText | EngineXPathComment;
 export declare const isEngineXPathNode: (value: unknown) => value is EngineXPathNode;
 export declare const getEngineXPathNodeKind: (node: EngineXPathNode) => XPathNodeKind;

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

@@ -4,10 +4,9 @@ import { XFormsXPathAttribute } from '../adapter/XFormsXPathNode.ts';
 import { StaticDocument } from './StaticDocument.ts';
 import { StaticElement } from './StaticElement.ts';
 import { StaticNode } from './StaticNode.ts';
-interface StaticAttributeOptions {
-    readonly namespaceURI: string | null;
-    readonly prefix?: string | null;
-    readonly localName: string;
+import { StaticNodeNameSource } from './staticNodeName.ts';
+export interface StaticAttributeOptions {
+    readonly name: StaticNodeNameSource;
     readonly value: string;
 }
 export declare class StaticAttribute extends StaticNode<'attribute'> implements XFormsXPathAttribute {
@@ -17,10 +16,10 @@ export declare class StaticAttribute extends StaticNode<'attribute'> implements
     readonly rootDocument: StaticDocument;
     readonly root: StaticElement;
     readonly qualifiedName: QualifiedName;
+    readonly nodeset: string;
     readonly attributes: readonly [];
     readonly children: null;
     readonly value: string;
     constructor(parent: StaticElement, options: StaticAttributeOptions);
     getXPathValue(): string;
 }
-export {};

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

@@ -1,15 +1,18 @@
-import { XPathNodeKindKey } from '@getodk/xpath';
 import { XFormsXPathDocument } from '../adapter/XFormsXPathNode.ts';
-import { StaticElement } from './StaticElement.ts';
-import { StaticNode } from './StaticNode.ts';
-export type StaticDocumentRootFactory<T extends StaticDocument, Root extends StaticElement> = (staticDocument: T) => Root;
-export declare abstract class StaticDocument<DocumentRoot extends StaticElement = StaticElement> extends StaticNode<'document'> implements XFormsXPathDocument {
-    readonly [XPathNodeKindKey] = "document";
-    readonly nodeType = "static-document";
+import { StaticElementOptions, StaticElement } from './StaticElement.ts';
+import { StaticParentNode } from './StaticParentNode.ts';
+interface StaticDocumentOptions {
+    readonly documentRoot: StaticElementOptions;
+    readonly nodesetPrefix?: string;
+}
+export declare class StaticDocument extends StaticParentNode<'document'> implements XFormsXPathDocument {
     readonly rootDocument: StaticDocument;
-    readonly root: DocumentRoot;
+    readonly root: StaticElement;
     readonly parent: null;
-    readonly children: readonly [root: DocumentRoot];
-    constructor(rootFactory: StaticDocumentRootFactory<StaticDocument<DocumentRoot>, DocumentRoot>);
+    readonly nodeset: string;
+    readonly children: readonly [root: StaticElement];
+    readonly childElements: readonly [root: StaticElement];
+    constructor(options: StaticDocumentOptions);
     getXPathValue(): string;
 }
+export {};

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/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/createInstanceAttachment.d.ts

@@ -0,0 +1,8 @@
+import { InstanceAttachmentFileName, InstanceAttachment } from '../../instance/attachments/InstanceAttachment.ts';
+import { InstanceAttachmentContext } from '../../instance/internal-api/InstanceAttachmentContext.ts';
+export type InstanceAttachmentRuntimeValue = File | null;
+export type InstanceAttachmentFormDataEntry = readonly [
+    key: InstanceAttachmentFileName,
+    value: NonNullable<InstanceAttachmentRuntimeValue>
+];
+export declare const createInstanceAttachment: (context: InstanceAttachmentContext) => InstanceAttachment;

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/lib/resource-helpers.d.ts

@@ -0,0 +1,2 @@
+import { FetchResourceResponse } from '../client/resources.ts';
+export declare const getResponseContentType: (response: FetchResourceResponse) => string | null;

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/body/BodyDefinition.d.ts

@@ -69,7 +69,8 @@ export declare class BodyDefinition extends DependencyContext implements BodyEle
     readonly reference: string;
     constructor(form: XFormDefinition);
     getBodyElement(reference: string): AnyBodyElementDefinition | null;
+    getBodyElementType(reference: BodyElementReference): AnyBodyElementType | null;
     getChildElementDefinitions(form: XFormDefinition, parent: BodyElementParentContext, parentElement: Element, children?: readonly Element[]): readonly AnyBodyElementDefinition[];
-    toJSON(): Omit<this, "form" | "toJSON" | "isTranslated" | "getBodyElement" | "getChildElementDefinitions">;
+    toJSON(): Omit<this, "form" | "toJSON" | "isTranslated" | "getBodyElement" | "getBodyElementType" | "getChildElementDefinitions">;
 }
 export {};

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

@@ -1,3 +1,4 @@
+import { UploadNodeOptions } from '../../../client/UploadNode.ts';
 import { XFormDefinition } from '../../XFormDefinition.ts';
 import { UnknownAppearanceDefinition } from '../appearance/unknownAppearanceParser.ts';
 import { BodyElementParentContext } from '../BodyDefinition.ts';
@@ -6,6 +7,7 @@ export declare class UploadControlDefinition extends ControlDefinition<'upload'>
     static isCompatible(localName: string): boolean;
     readonly type = "upload";
     readonly appearances: UnknownAppearanceDefinition;
+    readonly options: UploadNodeOptions;
     constructor(form: XFormDefinition, parent: BodyElementParentContext, element: Element);
     toJSON(): object;
 }

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/BindTypeDefinition.d.ts

@@ -1,9 +1,5 @@
+import { XFormDefinition } from '../XFormDefinition.ts';
 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}
  */
@@ -13,8 +9,7 @@ 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();
+    static from<T extends BindType>(form: XFormDefinition, nodeset: string, bindElement: BindElement): BindTypeDefinition<T>;
     private constructor();
 }
 export {};

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();
 }