@getodk/xforms-engine 0.15.0 → 0.16.0

package/dist/instance/Attribute.d.ts

@@ -10,25 +10,24 @@ import { RuntimeValueSetter, RuntimeValueState } from '../lib/codecs/ValueCodec.
 import { CurrentState } from '../lib/reactivity/node-state/createCurrentState.ts';
 import { EngineState } from '../lib/reactivity/node-state/createEngineState.ts';
 import { SharedNodeState } from '../lib/reactivity/node-state/createSharedNodeState.ts';
+import { ReactiveScope } from '../lib/reactivity/scope.ts';
 import { SimpleAtomicState } from '../lib/reactivity/types.ts';
 import { AttributeDefinition } from '../parse/model/AttributeDefinition.ts';
-import { DescendantNodeSharedStateSpec } from './abstract/DescendantNode.ts';
-import { InstanceNode } from './abstract/InstanceNode.ts';
-import { AnyParentNode } from './hierarchy.ts';
+import { AnyChildNode, AnyNode } from './hierarchy.ts';
 import { AttributeContext } from './internal-api/AttributeContext.ts';
+import { InstanceConfig } from './internal-api/InstanceConfig.ts';
 import { DecodeInstanceValue } from './internal-api/InstanceValueContext.ts';
 import { ClientReactiveSerializableAttributeNode } from './internal-api/serialization/ClientReactiveSerializableAttributeNode.ts';
+import { PrimaryInstance } from './PrimaryInstance.ts';
 import { Root } from './Root.ts';
-export interface AttributeStateSpec extends DescendantNodeSharedStateSpec {
-    readonly children: null;
-    readonly attributes: null;
+export interface AttributeStateSpec {
     readonly value: SimpleAtomicState<string>;
     readonly instanceValue: Accessor<string>;
-    readonly label: null;
-    readonly hint: null;
-    readonly valueOptions: null;
+    readonly relevant: Accessor<boolean>;
 }
-export declare class Attribute extends InstanceNode<AttributeDefinition, AttributeStateSpec, AnyParentNode, null> implements AttributeNode, ClientReactiveSerializableAttributeNode, AttributeContext, XFormsXPathAttribute {
+export declare class Attribute implements AttributeNode, ClientReactiveSerializableAttributeNode, AttributeContext, XFormsXPathAttribute {
+    readonly owner: AnyNode;
+    readonly definition: AttributeDefinition;
     readonly instanceNode: StaticAttribute;
     readonly [XPathNodeKindKey] = "attribute";
     protected readonly state: SharedNodeState<AttributeStateSpec>;
@@ -46,13 +45,20 @@ export declare class Attribute extends InstanceNode<AttributeDefinition, Attribu
     protected readonly setValueState: RuntimeValueSetter<RuntimeInputValue<'string'>>;
     readonly evaluator: EngineXPathEvaluator;
     readonly getActiveLanguage: Accessor<ActiveLanguage>;
+    readonly contextNode: AnyNode;
+    readonly scope: ReactiveScope;
+    readonly rootDocument: PrimaryInstance;
+    readonly instanceConfig: InstanceConfig;
     readonly root: Root;
     readonly isRelevant: Accessor<boolean>;
     readonly isAttached: Accessor<boolean>;
     readonly isReadonly: Accessor<boolean>;
     readonly hasReadonlyAncestor: Accessor<boolean>;
     readonly hasNonRelevantAncestor: Accessor<boolean>;
-    constructor(parent: AnyParentNode, definition: AttributeDefinition, instanceNode: StaticAttribute);
+    readonly contextReference: () => string;
+    constructor(owner: AnyNode, definition: AttributeDefinition, instanceNode: StaticAttribute);
     setValue(value: string): Root;
     getChildren(): readonly [];
+    getXPathChildNodes(): readonly AnyChildNode[];
+    getXPathValue(): string;
 }

package/dist/instance/Group.d.ts

@@ -26,7 +26,6 @@ interface GroupStateSpec extends DescendantNodeSharedStateSpec {
 }
 export declare class Group extends DescendantNode<GroupDefinition, GroupStateSpec, GeneralParentNode, GeneralChildNode> implements GroupNode, XFormsXPathElement, EvaluationContext, ClientReactiveSerializableParentNode<GeneralChildNode> {
     private readonly childrenState;
-    private readonly attributeState;
     readonly [XPathNodeKindKey] = "element";
     protected readonly state: SharedNodeState<GroupStateSpec>;
     protected engineState: EngineState<GroupStateSpec>;
@@ -38,6 +37,5 @@ export declare class Group extends DescendantNode<GroupDefinition, GroupStateSpe
     readonly instanceState: InstanceState;
     constructor(parent: GeneralParentNode, instanceNode: StaticElement | null, definition: GroupDefinition);
     getChildren(): readonly GeneralChildNode[];
-    getAttributes(): readonly Attribute[];
 }
 export {};

package/dist/instance/InputControl.d.ts

@@ -10,6 +10,7 @@ import { CurrentState } from '../lib/reactivity/node-state/createCurrentState.ts
 import { EngineState } from '../lib/reactivity/node-state/createEngineState.ts';
 import { SharedNodeState } from '../lib/reactivity/node-state/createSharedNodeState.ts';
 import { ValueNode, ValueNodeStateSpec } from './abstract/ValueNode.ts';
+import { Attribute } from './Attribute.ts';
 import { GeneralParentNode } from './hierarchy.ts';
 import { EvaluationContext } from './internal-api/EvaluationContext.ts';
 import { ClientReactiveSerializableValueNode } from './internal-api/serialization/ClientReactiveSerializableValueNode.ts';
@@ -21,6 +22,7 @@ export type AnyInputDefinition = {
 interface InputControlStateSpec<V extends ValueType> extends ValueNodeStateSpec<RuntimeValue<V>> {
     readonly label: Accessor<TextRange<'label'> | null>;
     readonly hint: Accessor<TextRange<'hint'> | null>;
+    readonly attributes: Accessor<readonly Attribute[]>;
     readonly valueOptions: null;
 }
 export declare class InputControl<V extends ValueType = ValueType> extends ValueNode<V, InputDefinition<V>, RuntimeValue<V>, RuntimeInputValue<V>> implements InputNode<V>, XFormsXPathElement, EvaluationContext, ValidationContext, ClientReactiveSerializableValueNode {

package/dist/instance/PrimaryInstance.d.ts

@@ -87,7 +87,6 @@ export declare class PrimaryInstance<Mode extends FormInstanceInitializationMode
     readonly isAttached: Accessor<boolean>;
     readonly evaluator: EngineXPathEvaluator;
     readonly contextNode: this;
-    private readonly attributeState;
     constructor(options: PrimaryInstanceOptions<Mode>);
     /**
      * @todo Note that this method's signature is intentionally derived from
@@ -110,6 +109,5 @@ export declare class PrimaryInstance<Mode extends FormInstanceInitializationMode
      */
     setLanguage(language: FormLanguage): FormLanguage;
     prepareInstancePayload<PayloadType extends InstancePayloadType = 'monolithic'>(options?: InstancePayloadOptions<PayloadType>): Promise<InstancePayload<PayloadType>>;
-    getAttributes(): readonly Attribute[];
 }
 export {};

package/dist/instance/Root.d.ts

@@ -36,7 +36,6 @@ interface RootStateSpec {
 }
 export declare class Root extends DescendantNode<RootDefinition, RootStateSpec, PrimaryInstance, GeneralChildNode> implements RootNode, XFormsXPathElement, EvaluationContext, TranslationContext, ClientReactiveSerializableParentNode<GeneralChildNode> {
     private readonly childrenState;
-    private readonly attributeState;
     readonly [XPathNodeKindKey] = "element";
     protected readonly state: SharedNodeState<RootStateSpec>;
     protected readonly engineState: EngineState<RootStateSpec>;
@@ -57,7 +56,6 @@ export declare class Root extends DescendantNode<RootDefinition, RootStateSpec,
     readonly languages: FormLanguages;
     constructor(parent: PrimaryInstance);
     getChildren(): readonly GeneralChildNode[];
-    getAttributes(): readonly Attribute[];
     setLanguage(language: FormLanguage): Root;
     prepareInstancePayload<PayloadType extends InstancePayloadType = 'monolithic'>(options?: InstancePayloadOptions<PayloadType>): Promise<InstancePayload<PayloadType>>;
 }

package/dist/instance/UploadControl.d.ts

@@ -39,7 +39,6 @@ export declare class UploadControl extends DescendantNode<UploadDefinition<'bina
     static from(parent: GeneralParentNode, instanceNode: StaticLeafElement | null, definition: UploadDefinition): UploadControl;
     private readonly validation;
     private readonly instanceAttachment;
-    private readonly attributeState;
     readonly [XPathNodeKindKey] = "element";
     readonly getXPathValue: () => InstanceAttachmentFileName;
     protected readonly state: SharedNodeState<UploadControlStateSpec>;
@@ -57,6 +56,5 @@ export declare class UploadControl extends DescendantNode<UploadDefinition<'bina
     isBlank(): boolean;
     getChildren(): readonly [];
     setValue(value: InstanceAttachmentRuntimeValue): Root;
-    getAttributes(): readonly Attribute[];
 }
 export {};

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

@@ -124,11 +124,11 @@ export declare abstract class InstanceNode<Definition extends AnyNodeDefinition,
      * (though for those nodes it will always be empty). This affords consistency
      * and efficiency of interface for those internal uses.
      */
-    abstract getChildren(this: AnyInstanceNode): ReadonlyArray<Exclude<AnyChildNode, Attribute>>;
+    abstract getChildren(this: AnyInstanceNode): readonly AnyChildNode[];
     /**
      * @todo Values as text nodes(?)
      */
-    getXPathChildNodes(): ReadonlyArray<Exclude<AnyChildNode, Attribute>>;
+    getXPathChildNodes(): readonly AnyChildNode[];
     getXPathValue(): string;
 }
 export {};

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

@@ -14,6 +14,7 @@ import { SharedNodeState } from '../../lib/reactivity/node-state/createSharedNod
 import { SimpleAtomicState } from '../../lib/reactivity/types.ts';
 import { SharedValidationState } from '../../lib/reactivity/validation/createValidation.ts';
 import { LeafNodeDefinition } from '../../parse/model/LeafNodeDefinition.ts';
+import { Attribute } from '../Attribute.ts';
 import { GeneralParentNode } from '../hierarchy.ts';
 import { EvaluationContext } from '../internal-api/EvaluationContext.ts';
 import { DecodeInstanceValue, InstanceValueContext } from '../internal-api/InstanceValueContext.ts';
@@ -23,7 +24,7 @@ import { DescendantNodeStateSpec, DescendantNode } from './DescendantNode.ts';
 export type ValueNodeDefinition<V extends ValueType> = LeafNodeDefinition<V>;
 export interface ValueNodeStateSpec<RuntimeValue> extends DescendantNodeStateSpec<RuntimeValue> {
     readonly children: null;
-    readonly attributes: null;
+    readonly attributes: Accessor<readonly Attribute[]>;
     readonly value: SimpleAtomicState<RuntimeValue>;
     readonly instanceValue: Accessor<string>;
 }

package/dist/instance/attachments/buildAttributes.d.ts

@@ -1,3 +1,7 @@
 import { Attribute } from '../Attribute';
-import { AnyParentNode } from '../hierarchy';
-export declare function buildAttributes(parent: AnyParentNode): Attribute[];
+import { AnyNode } from '../hierarchy.ts';
+import { InputControl } from '../InputControl.ts';
+import { ModelValue } from '../ModelValue.ts';
+import { Note } from '../Note.ts';
+import { RangeControl } from '../RangeControl.ts';
+export declare function buildAttributes(owner: AnyNode | InputControl<any> | ModelValue<any> | Note<any> | RangeControl<any>): Attribute[];

package/dist/instance/hierarchy.d.ts

@@ -1,4 +1,3 @@
-import { Attribute } from './Attribute.ts';
 import { Group } from './Group.ts';
 import { AnyInputControl } from './InputControl.ts';
 import { AnyModelValue } from './ModelValue.ts';
@@ -17,6 +16,6 @@ export type RepeatRange = RepeatRangeControlled | RepeatRangeUncontrolled;
 export type AnyNode = PrimaryInstance | Root | Group | RepeatRange | RepeatInstance | AnyNote | AnyModelValue | AnyInputControl | AnyRangeControl | RankControl | SelectControl | TriggerControl | UploadControl;
 export type AnyParentNode = PrimaryInstance | Root | Group | RepeatRange | RepeatInstance;
 export type GeneralParentNode = Root | Group | RepeatInstance;
-export type AnyChildNode = Root | Group | RepeatRange | RepeatInstance | AnyModelValue | AnyNote | AnyInputControl | AnyRangeControl | RankControl | SelectControl | TriggerControl | UploadControl | Attribute;
+export type AnyChildNode = Root | Group | RepeatRange | RepeatInstance | AnyModelValue | AnyNote | AnyInputControl | AnyRangeControl | RankControl | SelectControl | TriggerControl | UploadControl;
 export type GeneralChildNode = Group | RepeatRange | AnyModelValue | AnyNote | AnyInputControl | AnyRangeControl | RankControl | SelectControl | TriggerControl | UploadControl;
 export type AnyValueNode = AnyModelValue | AnyNote | AnyInputControl | AnyRangeControl | RankControl | SelectControl | TriggerControl | UploadControl;

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

@@ -1,11 +1,15 @@
+import { Accessor } from 'solid-js';
 import { FormInstanceInitializationMode } from '../../client/index.ts';
 import { StaticAttribute } from '../../integration/xpath/static-dom/StaticAttribute.ts';
 import { ReactiveScope } from '../../lib/reactivity/scope.ts';
 import { BindComputationExpression } from '../../parse/expression/BindComputationExpression.ts';
 import { AnyBindPreloadDefinition } from '../../parse/model/BindPreloadDefinition.ts';
+import { ModelDefinition } from '../../parse/model/ModelDefinition.ts';
 import { EvaluationContext } from './EvaluationContext.ts';
+import { InstanceConfig } from './InstanceConfig.ts';
 export interface InstanceAttributeContextDocument {
     readonly initializationMode: FormInstanceInitializationMode;
+    readonly isAttached: Accessor<boolean>;
 }
 export type DecodeInstanceValue = (value: string) => string;
 interface InstanceAttributeContextDefinitionBind {
@@ -16,12 +20,14 @@ interface InstanceAttributeContextDefinitionBind {
 export interface InstanceAttributeContextDefinition {
     readonly bind: InstanceAttributeContextDefinitionBind;
     readonly template: StaticAttribute;
+    readonly model: ModelDefinition;
 }
 export interface AttributeContext extends EvaluationContext {
     readonly scope: ReactiveScope;
     readonly rootDocument: InstanceAttributeContextDocument;
     readonly definition: InstanceAttributeContextDefinition;
     readonly instanceNode: StaticAttribute;
+    readonly instanceConfig: InstanceConfig;
     readonly decodeInstanceValue: DecodeInstanceValue;
     isReadonly(): boolean;
     isRelevant(): boolean;

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

@@ -1,4 +1,5 @@
 import { InstanceAttachmentFileNameFactory } from '../../client/attachments/InstanceAttachmentsConfig.ts';
+import { PreloadProperties } from '../../client/form/FormInstanceConfig.ts';
 import { OpaqueReactiveObjectFactory } from '../../client/OpaqueReactiveObjectFactory.ts';
 export interface InstanceConfig {
     /**
@@ -6,4 +7,5 @@ export interface InstanceConfig {
      */
     readonly clientStateFactory: OpaqueReactiveObjectFactory;
     readonly computeAttachmentName: InstanceAttachmentFileNameFactory;
+    readonly preloadProperties: PreloadProperties;
 }

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

@@ -1,11 +1,15 @@
+import { Accessor } from 'solid-js';
 import { FormInstanceInitializationMode } from '../../client/index.ts';
 import { StaticLeafElement } from '../../integration/xpath/static-dom/StaticElement.ts';
 import { ReactiveScope } from '../../lib/reactivity/scope.ts';
 import { BindComputationExpression } from '../../parse/expression/BindComputationExpression.ts';
 import { AnyBindPreloadDefinition } from '../../parse/model/BindPreloadDefinition.ts';
+import { ModelDefinition } from '../../parse/model/ModelDefinition.ts';
 import { EvaluationContext } from './EvaluationContext.ts';
+import { InstanceConfig } from './InstanceConfig.ts';
 export interface InstanceValueContextDocument {
     readonly initializationMode: FormInstanceInitializationMode;
+    readonly isAttached: Accessor<boolean>;
 }
 export type DecodeInstanceValue = (value: string) => string;
 interface InstanceValueContextDefinitionBind {
@@ -16,12 +20,14 @@ interface InstanceValueContextDefinitionBind {
 export interface InstanceValueContextDefinition {
     readonly bind: InstanceValueContextDefinitionBind;
     readonly template: StaticLeafElement;
+    readonly model: ModelDefinition;
 }
 export interface InstanceValueContext extends EvaluationContext {
     readonly scope: ReactiveScope;
     readonly rootDocument: InstanceValueContextDocument;
     readonly definition: InstanceValueContextDefinition;
     readonly instanceNode: StaticLeafElement | null;
+    readonly instanceConfig: InstanceConfig;
     readonly decodeInstanceValue: DecodeInstanceValue;
     isReadonly(): boolean;
     isRelevant(): boolean;

package/dist/instance/internal-api/serialization/ClientReactiveSerializableAttributeNode.d.ts

@@ -2,7 +2,6 @@ import { InstanceState } from '../../../client/serialization/InstanceState.ts';
 import { QualifiedName } from '../../../lib/names/QualifiedName.ts';
 export type SerializedInstanceValue = string;
 interface ClientReactiveSerializableAttributeNodeCurrentState {
-    get relevant(): boolean;
     get instanceValue(): SerializedInstanceValue;
 }
 interface ClientReactiveSerializableAttributeNodeDefinition {

package/dist/instance/internal-api/serialization/ClientReactiveSerializableValueNode.d.ts

@@ -1,5 +1,7 @@
 import { InstanceState } from '../../../client/serialization/InstanceState.ts';
 import { QualifiedName } from '../../../lib/names/QualifiedName.ts';
+import { BindDefinition } from '../../../parse/model/BindDefinition.ts';
+import { Attribute } from '../../Attribute.ts';
 import { ClientReactiveSerializableChildNode, ClientReactiveSerializableParentNode } from './ClientReactiveSerializableParentNode.ts';
 export type SerializedInstanceValue = string;
 interface ClientReactiveSerializableValueNodeCurrentState {
@@ -8,9 +10,11 @@ interface ClientReactiveSerializableValueNodeCurrentState {
      * @todo Consider moving into {@link InstanceState}
      */
     get instanceValue(): SerializedInstanceValue;
+    get attributes(): readonly Attribute[];
 }
 interface ClientReactiveSerializableValueNodeDefinition {
     readonly qualifiedName: QualifiedName;
+    readonly bind: BindDefinition;
 }
 export interface ClientReactiveSerializableValueNode {
     readonly definition: ClientReactiveSerializableValueNodeDefinition;

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

@@ -30,7 +30,6 @@ interface RepeatInstanceOptions {
 export declare class RepeatInstance extends DescendantNode<AnyRepeatDefinition, RepeatInstanceStateSpec, RepeatRange, GeneralChildNode> implements RepeatInstanceNode, XFormsXPathElement, EvaluationContext, ClientReactiveSerializableTemplatedNode {
     readonly parent: RepeatRange;
     private readonly childrenState;
-    private readonly attributeState;
     private readonly currentIndex;
     readonly [XPathNodeKindKey] = "element";
     protected readonly state: SharedNodeState<RepeatInstanceStateSpec>;
@@ -67,6 +66,5 @@ export declare class RepeatInstance extends DescendantNode<AnyRepeatDefinition,
     readonly instanceState: InstanceState;
     constructor(parent: RepeatRange, instanceNode: StaticElement | null, options: RepeatInstanceOptions);
     getChildren(): readonly GeneralChildNode[];
-    getAttributes(): readonly Attribute[];
 }
 export {};

package/dist/lib/codecs/items/SingleValueItemCodec.d.ts

@@ -4,7 +4,7 @@ export type SingleValueSelectRuntimeValues = readonly [] | readonly [string];
 /**
  * @see {@link encodeValueFactory}
  */
-type SingleValueSelectCodecValues = SingleValueSelectRuntimeValues | readonly string[];
+type SingleValueSelectCodecValues = readonly string[];
 /**
  * Value codec implementation for `<select1>` controls.
  *

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

@@ -1,5 +1,7 @@
+import { AttributeContext } from '../../instance/internal-api/AttributeContext.ts';
 import { InstanceValueContext } from '../../instance/internal-api/InstanceValueContext.ts';
 import { SimpleAtomicState } from './types.ts';
+type ValueContext = AttributeContext | InstanceValueContext;
 export type InstanceValueState = SimpleAtomicState<string>;
 /**
  * Provides a consistent interface for value nodes of any type which:
@@ -12,4 +14,5 @@ export type InstanceValueState = SimpleAtomicState<string>;
  *   nodes defined with one
  * - prevents downstream writes to nodes in a readonly state
  */
-export declare const createInstanceValueState: (context: InstanceValueContext) => InstanceValueState;
+export declare const createInstanceValueState: (context: ValueContext) => InstanceValueState;
+export {};

package/dist/lib/reactivity/node-state/createSharedNodeState.d.ts

@@ -5,8 +5,8 @@ import { CurrentState } from './createCurrentState.ts';
 import { EngineState } from './createEngineState.ts';
 import { MutablePropertySpec, SpecifiedState, StateSpec } from './createSpecifiedState.ts';
 type MutableKeyOf<Spec extends StateSpec> = {
-    [K in string & keyof Spec]: Spec[K] extends MutablePropertySpec<any> ? K : never;
-}[string & keyof Spec];
+    [K in Extract<keyof Spec, string>]: Spec[K] extends MutablePropertySpec<any> ? K : never;
+}[Extract<keyof Spec, string>];
 type SetEnginePropertyState<Spec extends StateSpec> = <K extends MutableKeyOf<Spec>>(key: K, newValue: SpecifiedState<Spec>[K]) => SpecifiedState<Spec>[K];
 export interface SharedNodeState<Spec extends StateSpec> {
     readonly spec: Spec;

package/dist/lib/xml-serialization.d.ts

@@ -42,5 +42,5 @@ export type EscapedXMLText = string & {
 export declare const escapeXMLText: <Text extends string>(text: Exclude<Text, EscapedXMLText>, attr?: boolean) => EscapedXMLText;
 export declare const serializeAttributeXML: (qualifiedName: QualifiedName, xmlValue: EscapedXMLText) => string;
 export declare const serializeParentElementXML: (qualifiedName: QualifiedName, children: readonly GeneralChildNode[], attributes: readonly Attribute[], namespaceDeclarations?: NamespaceDeclarationMap) => string;
-export declare const serializeLeafElementXML: (qualifiedName: QualifiedName, xmlValue: EscapedXMLText, namespaceDeclarations?: NamespaceDeclarationMap) => string;
+export declare const serializeLeafElementXML: (qualifiedName: QualifiedName, xmlValue: EscapedXMLText, attributes: readonly Attribute[], namespaceDeclarations?: NamespaceDeclarationMap) => string;
 export {};

package/dist/parse/XFormDOM.d.ts

@@ -1,6 +1,8 @@
 import { KnownAttributeLocalNamedElement } from '../../../common/types/dom.ts';
 interface DOMBindElement extends KnownAttributeLocalNamedElement<'bind', 'nodeset'> {
 }
+interface DOMSetValueElement extends KnownAttributeLocalNamedElement<'setvalue', 'event'> {
+}
 export interface DOMItextTranslationElement extends KnownAttributeLocalNamedElement<'translation', 'lang'> {
 }
 export interface DOMSecondaryInstanceElement extends KnownAttributeLocalNamedElement<'instance', 'id'> {
@@ -23,6 +25,7 @@ export declare class XFormDOM {
     readonly title: Element;
     readonly model: Element;
     readonly binds: readonly DOMBindElement[];
+    readonly setValues: readonly DOMSetValueElement[];
     readonly primaryInstance: Element;
     readonly primaryInstanceRoot: Element;
     readonly itextTranslationElements: readonly DOMItextTranslationElement[];

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

@@ -0,0 +1,4 @@
+import { DependentExpression, DependentExpressionResultType } from './abstract/DependentExpression.ts';
+export declare class ActionComputationExpression<Type extends DependentExpressionResultType> extends DependentExpression<Type> {
+    constructor(resultType: Type, expression: string);
+}

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

@@ -0,0 +1,15 @@
+import { ActionComputationExpression } from '../expression/ActionComputationExpression.ts';
+import { XFormEvent } from './Event.ts';
+import { ModelDefinition } from './ModelDefinition.ts';
+export declare class ActionDefinition {
+    readonly element: Element;
+    static getRef(model: ModelDefinition, setValueElement: Element): string | null;
+    static getValue(element: Element): string;
+    static isKnownEvent: (event: XFormEvent) => event is XFormEvent;
+    static getEvents(element: Element): XFormEvent[];
+    readonly ref: string;
+    readonly events: XFormEvent[];
+    readonly computation: ActionComputationExpression<'string'>;
+    readonly source: string | undefined;
+    constructor(model: ModelDefinition, element: Element, source?: string);
+}

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

@@ -2,9 +2,11 @@ import { StaticAttribute } from '../../integration/xpath/static-dom/StaticAttrib
 import { NamespaceDeclarationMap, NamedNodeDefinition } from '../../lib/names/NamespaceDeclarationMap.ts';
 import { QualifiedName } from '../../lib/names/QualifiedName.ts';
 import { BindDefinition } from './BindDefinition.ts';
+import { ModelDefinition } from './ModelDefinition.ts';
 import { NodeDefinition } from './NodeDefinition.ts';
 import { RootDefinition } from './RootDefinition.ts';
 export declare class AttributeDefinition extends NodeDefinition<'attribute'> implements NamedNodeDefinition {
+    readonly model: ModelDefinition;
     readonly template: StaticAttribute;
     private readonly serializedXML;
     readonly value: string;
@@ -17,6 +19,6 @@ export declare class AttributeDefinition extends NodeDefinition<'attribute'> imp
     readonly children: null;
     readonly attributes: null;
     readonly qualifiedName: QualifiedName;
-    constructor(root: RootDefinition, bind: BindDefinition, template: StaticAttribute);
+    constructor(model: ModelDefinition, bind: BindDefinition, template: StaticAttribute);
     serializeAttributeXML(): string;
 }

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

@@ -1,6 +1,9 @@
 import { PartiallyKnownString } from '../../../../common/types/string/PartiallyKnownString.ts';
+import { AttributeContext } from '../../instance/internal-api/AttributeContext.ts';
+import { InstanceValueContext } from '../../instance/internal-api/InstanceValueContext.ts';
 import { BindElement } from './BindElement.ts';
-type PartiallyKnownPreloadParameter<Known extends string> = PartiallyKnownString<NonNullable<Known>> | Extract<Known, null>;
+import { XFormEvent } from './Event.ts';
+type PartiallyKnownPreloadParameter<Known extends string> = PartiallyKnownString<NonNullable<Known>>;
 interface PreloadParametersByType {
     readonly uid: string | null;
     readonly date: PartiallyKnownPreloadParameter<'today'>;
@@ -22,20 +25,13 @@ interface PreloadInput<Type extends PreloadType> {
  *
  * - {@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>;
+    readonly event: XFormEvent;
+    getValue(context: AttributeContext | InstanceValueContext): string | undefined;
     private constructor();
 }
 export type AnyBindPreloadDefinition = BindPreloadDefinition<'uid'> | BindPreloadDefinition<'timestamp'> | BindPreloadDefinition<'property'> | BindPreloadDefinition<string>;

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

@@ -0,0 +1,8 @@
+export declare const XFORM_EVENT: {
+    readonly odkInstanceLoad: "odk-instance-load";
+    readonly odkInstanceFirstLoad: "odk-instance-first-load";
+    readonly odkNewRepeat: "odk-new-repeat";
+    readonly xformsRevalidate: "xforms-revalidate";
+    readonly xformsValueChanged: "xforms-value-changed";
+};
+export type XFormEvent = (typeof XFORM_EVENT)[keyof typeof XFORM_EVENT];

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

@@ -3,17 +3,20 @@ import { StaticLeafElement } from '../../integration/xpath/static-dom/StaticElem
 import { NamespaceDeclarationMap, NamedSubtreeDefinition } from '../../lib/names/NamespaceDeclarationMap.ts';
 import { QualifiedName } from '../../lib/names/QualifiedName.ts';
 import { AnyBodyElementDefinition, ControlElementDefinition } from '../body/BodyDefinition.ts';
+import { AttributeDefinitionMap } from './AttributeDefinitionMap.ts';
 import { BindDefinition } from './BindDefinition.ts';
 import { DescendentNodeDefinition } from './DescendentNodeDefinition.ts';
+import { ModelDefinition } from './ModelDefinition.ts';
 import { ParentNodeDefinition } from './NodeDefinition.ts';
 export declare class LeafNodeDefinition<V extends ValueType = ValueType> extends DescendentNodeDefinition<'leaf-node', ControlElementDefinition | null> implements NamedSubtreeDefinition {
+    readonly model: ModelDefinition;
     readonly template: StaticLeafElement;
     readonly type = "leaf-node";
     readonly valueType: V;
     readonly namespaceDeclarations: NamespaceDeclarationMap;
     readonly qualifiedName: QualifiedName;
     readonly children: null;
-    readonly attributes: null;
-    constructor(parent: ParentNodeDefinition, bind: BindDefinition, bodyElement: AnyBodyElementDefinition | null, template: StaticLeafElement);
+    readonly attributes: AttributeDefinitionMap;
+    constructor(model: ModelDefinition, parent: ParentNodeDefinition, bind: BindDefinition, bodyElement: AnyBodyElementDefinition | null, template: StaticLeafElement);
     toJSON(): Omit<this, "parent" | "toJSON" | "bind" | "root" | "bodyElement">;
 }

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

@@ -0,0 +1,9 @@
+import { ActionDefinition } from './ActionDefinition.ts';
+import { ModelDefinition } from './ModelDefinition.ts';
+export declare class ModelActionMap extends Map<string, ActionDefinition> {
+    static fromModel(model: ModelDefinition): ModelActionMap;
+    static getKey(ref: string): string;
+    protected constructor(model: ModelDefinition);
+    get(ref: string): ActionDefinition | undefined;
+    add(action: ActionDefinition): void;
+}

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

@@ -4,21 +4,28 @@ import { TextChunkExpression } from '../expression/TextChunkExpression.ts';
 import { XFormDefinition } from '../XFormDefinition.ts';
 import { ChunkExpressionsByItextId } from './generateItextChunks.ts';
 import { ItextTranslationsDefinition } from './ItextTranslationsDefinition.ts';
+import { ModelActionMap } from './ModelActionMap.ts';
 import { ModelBindMap } from './ModelBindMap.ts';
 import { AnyNodeDefinition } from './NodeDefinition.ts';
 import { NodeDefinitionMap } from './nodeDefinitionMap.ts';
 import { RootDefinition } from './RootDefinition.ts';
+type XformsRevalidateListener = () => void;
 export declare class ModelDefinition {
     readonly form: XFormDefinition;
     readonly binds: ModelBindMap;
+    readonly actions: ModelActionMap;
     readonly root: RootDefinition;
     readonly nodes: NodeDefinitionMap;
     readonly instance: StaticDocument;
     readonly itextTranslations: ItextTranslationsDefinition;
     readonly itextChunks: Map<string, ChunkExpressionsByItextId>;
+    readonly xformsRevalidateListeners: Map<string, XformsRevalidateListener>;
     constructor(form: XFormDefinition);
     getNodeDefinition(nodeset: string): AnyNodeDefinition;
     getRootDefinition(instance: StaticDocument): RootDefinition;
-    toJSON(): Omit<this, "form" | "toJSON" | "getNodeDefinition" | "getRootDefinition" | "getTranslationChunks">;
+    registerXformsRevalidateListener(ref: string, listener: XformsRevalidateListener): void;
+    triggerXformsRevalidateListeners(): void;
     getTranslationChunks(itextId: string, activeLanguage: ActiveLanguage): ReadonlyArray<TextChunkExpression<'string'>>;
+    toJSON(): Omit<this, "form" | "toJSON" | "getNodeDefinition" | "getRootDefinition" | "registerXformsRevalidateListener" | "triggerXformsRevalidateListeners" | "getTranslationChunks">;
 }
+export {};

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

@@ -8,6 +8,7 @@ import { HintDefinition } from '../text/HintDefinition.ts';
 import { LabelDefinition } from '../text/LabelDefinition.ts';
 import { BindDefinition } from './BindDefinition.ts';
 import { LeafNodeDefinition } from './LeafNodeDefinition.ts';
+import { ModelDefinition } from './ModelDefinition.ts';
 import { ParentNodeDefinition } from './NodeDefinition.ts';
 export type NoteReadonlyDefinition = BindComputationExpression<'readonly'> & ConstantTruthyDependentExpression;
 export interface NoteBindDefinition<V extends ValueType> extends BindDefinition<V> {
@@ -27,6 +28,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: StaticLeafElement): NoteNodeDefinition<V> | null;
-    constructor(parent: ParentNodeDefinition, bind: NoteBindDefinition<V>, bodyElement: InputControlDefinition, noteTextDefinition: NoteTextDefinition, template: StaticLeafElement);
+    static from<V extends ValueType>(model: ModelDefinition, parent: ParentNodeDefinition, bind: BindDefinition<V>, bodyElement: AnyBodyElementDefinition | null, node: StaticLeafElement): NoteNodeDefinition<V> | null;
+    constructor(model: ModelDefinition, parent: ParentNodeDefinition, bind: NoteBindDefinition<V>, bodyElement: InputControlDefinition, noteTextDefinition: NoteTextDefinition, template: StaticLeafElement);
 }

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

@@ -4,6 +4,7 @@ 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 { ModelDefinition } from './ModelDefinition.ts';
 import { ParentNodeDefinition } from './NodeDefinition.ts';
 declare const RANGE_VALUE_TYPES: readonly ["decimal", "int"];
 export type RangeValueType = (typeof RANGE_VALUE_TYPES)[number];
@@ -34,7 +35,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: StaticLeafElement): RangeNodeDefinition<Extract<V, RangeValueType>>;
+    static from<V extends ValueType>(model: ModelDefinition, parent: ParentNodeDefinition, bind: BindDefinition<V>, bodyElement: RangeControlDefinition, node: StaticLeafElement): RangeNodeDefinition<Extract<V, RangeValueType>>;
     readonly bounds: RangeNodeBoundsDefinition<V>;
     private constructor();
 }

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

@@ -23,6 +23,7 @@ export declare class RootDefinition extends NodeDefinition<'root'> {
     readonly children: readonly ChildNodeDefinition[];
     readonly isTranslated = false;
     constructor(form: XFormDefinition, model: ModelDefinition, submission: SubmissionDefinition, classes: BodyClassList);
+    private mapActions;
     buildSubtree(parent: ParentNodeDefinition, node: StaticElement): readonly ChildNodeDefinition[];
     toJSON(): Omit<this, "form" | "toJSON" | "bind" | "model" | "root" | "bodyElement" | "buildSubtree">;
 }