@getodk/xforms-engine 0.2.0 → 0.4.0

package/dist/instance/{RepeatRange.d.ts → repeat/BaseRepeatRange.d.ts}

@@ -1,19 +1,19 @@
 import { Accessor } from 'solid-js';
-import { RepeatRangeNode, RepeatRangeNodeAppearances } from '../client/RepeatRangeNode.ts';
-import { MaterializedChildren } from '../lib/reactivity/materializeCurrentStateChildren.ts';
-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 { RepeatRangeDefinition } from '../model/RepeatRangeDefinition.ts';
-import { RepeatDefinition, RepeatInstance } from './RepeatInstance.ts';
-import { Root } from './Root.ts';
-import { DescendantNodeSharedStateSpec, DescendantNode } from './abstract/DescendantNode.ts';
-import { GeneralParentNode } from './hierarchy.ts';
-import { NodeID } from './identity.ts';
-import { EvaluationContext } from './internal-api/EvaluationContext.ts';
-import { SubscribableDependency } from './internal-api/SubscribableDependency.ts';
-import { TextRange } from './text/TextRange.ts';
-
+import { NodeAppearances } from '../../client/NodeAppearances.ts';
+import { BaseRepeatRangeNode } from '../../client/repeat/BaseRepeatRangeNode.ts';
+import { TextRange } from '../../client/TextRange.ts';
+import { AncestorNodeValidationState } from '../../client/validation.ts';
+import { ChildrenState } from '../../lib/reactivity/createChildrenState.ts';
+import { MaterializedChildren } from '../../lib/reactivity/materializeCurrentStateChildren.ts';
+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 { AnyRepeatRangeDefinition, ControlledRepeatRangeDefinition } from '../../parse/model/RepeatRangeDefinition.ts';
+import { DescendantNodeParent, DescendantNodeSharedStateSpec, DescendantNode } from '../abstract/DescendantNode.ts';
+import { NodeID } from '../identity.ts';
+import { EvaluationContext } from '../internal-api/EvaluationContext.ts';
+import { SubscribableDependency } from '../internal-api/SubscribableDependency.ts';
+import { RepeatInstance, RepeatDefinition } from './RepeatInstance.ts';
 interface RepeatRangeStateSpec extends DescendantNodeSharedStateSpec {
     readonly hint: null;
     readonly label: Accessor<TextRange<'label'> | null>;
@@ -21,7 +21,8 @@ interface RepeatRangeStateSpec extends DescendantNodeSharedStateSpec {
     readonly valueOptions: null;
     readonly value: null;
 }
-export declare class RepeatRange extends DescendantNode<RepeatRangeDefinition, RepeatRangeStateSpec, RepeatInstance> implements RepeatRangeNode, EvaluationContext, SubscribableDependency {
+type BaseRepeatRangeNodeType<Definition extends AnyRepeatRangeDefinition> = Definition extends ControlledRepeatRangeDefinition ? 'repeat-range:controlled' : 'repeat-range:uncontrolled';
+export declare abstract class BaseRepeatRange<Definition extends AnyRepeatRangeDefinition> extends DescendantNode<Definition, RepeatRangeStateSpec, RepeatInstance> implements BaseRepeatRangeNode, EvaluationContext, SubscribableDependency {
     /**
      * A repeat range doesn't have a corresponding primary instance element of its
      * own, and its instances are appended to the range's parent element. During
@@ -44,8 +45,27 @@ export declare class RepeatRange extends DescendantNode<RepeatRangeDefinition, R
      * {@link https://developer.mozilla.org/en-US/docs/Web/API/Range | DOM Range}
      * instead?
      */
-    private readonly anchorNode;
-    private readonly childrenState;
+    protected readonly anchorNode: Comment;
+    protected readonly childrenState: ChildrenState<RepeatInstance>;
+    /**
+     * Provides an {@link EvaluationContext} from which to evaluate expressions
+     * where some LocationPath sub-expressions may be **relative to the repeat
+     * range itself**. This is useful for evaluation of expressions where:
+     *
+     * - the expression is typically contextualized to any of its
+     *   {@link RepeatInstance} children, but it presently has none (i.e.
+     *   `relevant`)
+     *
+     * - the expression is conceptually intended to be evaluated in the context of
+     *   the repeat range itself (i.e. `jr:count`)
+     */
+    protected readonly selfEvaluationContext: EvaluationContext & {
+        readonly contextNode: Comment;
+    };
+    /**
+     * @see {@link isSelfRelevant}
+     */
+    protected readonly isEmptyRangeSelfRelevant: Accessor<boolean>;
     protected readonly state: SharedNodeState<RepeatRangeStateSpec>;
     protected engineState: EngineState<RepeatRangeStateSpec>;
     /**
@@ -55,11 +75,6 @@ export declare class RepeatRange extends DescendantNode<RepeatRangeDefinition, R
      * @see {@link isSelfRelevant}
      */
     isSelfReadonly: Accessor<boolean>;
-    private readonly emptyRangeEvaluationContext;
-    /**
-     * @see {@link isSelfRelevant}
-     */
-    private readonly isEmptyRangeSelfRelevant;
     /**
      * A repeat range does not exist in the primary instance tree. A `relevant`
      * expression applies to each {@link RepeatInstance} child of the repeat
@@ -94,7 +109,7 @@ export declare class RepeatRange extends DescendantNode<RepeatRangeDefinition, R
      * theory it could vary depending on form structure and runtime state).
      */
     readonly isSelfRelevant: Accessor<boolean>;
-    readonly nodeType = "repeat-range";
+    abstract readonly nodeType: BaseRepeatRangeNodeType<Definition>;
     /**
      * @todo RepeatRange*, RepeatInstance* (and RepeatTemplate*) all share the
      * same body element, and thus all share the same definition `bodyElement`. As
@@ -128,31 +143,16 @@ export declare class RepeatRange extends DescendantNode<RepeatRangeDefinition, R
      * All of the above creates considerable ambiguity about where "repeat
      * appearances" should apply, under which circumstances.
      */
-    readonly appearances: RepeatRangeNodeAppearances;
+    abstract readonly appearances: NodeAppearances<Definition>;
     readonly currentState: MaterializedChildren<CurrentState<RepeatRangeStateSpec>, RepeatInstance>;
-    constructor(parent: GeneralParentNode, definition: RepeatRangeDefinition);
-    private getLastIndex;
+    abstract readonly validationState: AncestorNodeValidationState;
+    constructor(parent: DescendantNodeParent<Definition>, definition: Definition);
+    protected getLastIndex(): number;
     protected initializeContextNode(parentContextNode: Element): Element;
     getInstanceIndex(instance: RepeatInstance): number;
-    addInstances(afterIndex?: number, count?: number, definition?: RepeatDefinition): Root;
-    /**
-     * Removes the {@link RepeatInstance}s corresponding to the specified range of
-     * indexes, and then removes those repeat instances from the repeat range's
-     * own children state in that order:
-     *
-     * 1. Identify the set of {@link RepeatInstance}s to be removed.
-     *
-     * 2. For each {@link RepeatInstance} pending removal, perform that node's
-     *    removal logic. @see {@link RepeatInstance.remove} for more detail.
-     *
-     * 3. Finalize update to the repeat range's own {@link childrenState},
-     *    omitting those {@link RepeatInstance}s which were removed.
-     *
-     * This ordering ensures a consistent representation of state is established
-     * prior to any downstream reactive updates, and ensures that removed nodes'
-     * reactivity is cleaned up.
-     */
-    removeInstances(startIndex: number, count?: number): Root;
+    private createChildren;
+    protected addChildren(afterIndex: number, definitions: readonly RepeatDefinition[]): readonly RepeatInstance[];
+    protected removeChildren(startIndex: number, count: number): readonly RepeatInstance[];
     subscribe(): void;
     getChildren(): readonly RepeatInstance[];
 }

package/dist/instance/{RepeatInstance.d.ts → repeat/RepeatInstance.d.ts}

@@ -1,17 +1,16 @@
 import { Accessor } from 'solid-js';
-import { RepeatDefinition, RepeatInstanceNode, RepeatInstanceNodeAppearances } from '../client/RepeatInstanceNode.ts';
-import { TextRange } from '../index.ts';
-import { MaterializedChildren } from '../lib/reactivity/materializeCurrentStateChildren.ts';
-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 { RepeatRange } from './RepeatRange.ts';
-import { DescendantNodeSharedStateSpec, DescendantNode } from './abstract/DescendantNode.ts';
-import { AnyChildNode, GeneralChildNode } from './hierarchy.ts';
-import { NodeID } from './identity.ts';
-import { EvaluationContext } from './internal-api/EvaluationContext.ts';
-import { SubscribableDependency } from './internal-api/SubscribableDependency.ts';
-
+import { RepeatDefinition, RepeatInstanceNode, RepeatInstanceNodeAppearances } from '../../client/repeat/RepeatInstanceNode.ts';
+import { TextRange } from '../../client/TextRange.ts';
+import { AncestorNodeValidationState } from '../../client/validation.ts';
+import { MaterializedChildren } from '../../lib/reactivity/materializeCurrentStateChildren.ts';
+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 { DescendantNodeSharedStateSpec, DescendantNode } from '../abstract/DescendantNode.ts';
+import { AnyChildNode, GeneralChildNode, RepeatRange } from '../hierarchy.ts';
+import { NodeID } from '../identity.ts';
+import { EvaluationContext } from '../internal-api/EvaluationContext.ts';
+import { SubscribableDependency } from '../internal-api/SubscribableDependency.ts';
 export type { RepeatDefinition };
 interface RepeatInstanceStateSpec extends DescendantNodeSharedStateSpec {
     readonly label: Accessor<TextRange<'label'> | null>;
@@ -57,6 +56,7 @@ export declare class RepeatInstance extends DescendantNode<RepeatDefinition, Rep
      */
     readonly appearances: RepeatInstanceNodeAppearances;
     readonly currentState: MaterializedChildren<CurrentState<RepeatInstanceStateSpec>, GeneralChildNode>;
+    readonly validationState: AncestorNodeValidationState;
     constructor(parent: RepeatRange, definition: RepeatDefinition, options: RepeatInstanceOptions);
     protected initializeContextNode(parentContextNode: Element, nodeName: string): Element;
     subscribe(): void;

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

@@ -0,0 +1,15 @@
+import { RepeatRangeNodeAppearances } from '../../client/repeat/BaseRepeatRangeNode.ts';
+import { RepeatRangeControlledNode } from '../../client/repeat/RepeatRangeControlledNode.ts';
+import { AncestorNodeValidationState } from '../../client/validation.ts';
+import { ControlledRepeatRangeDefinition } from '../../parse/model/RepeatRangeDefinition.ts';
+import { GeneralParentNode } from '../hierarchy.ts';
+import { EvaluationContext } from '../internal-api/EvaluationContext.ts';
+import { SubscribableDependency } from '../internal-api/SubscribableDependency.ts';
+import { BaseRepeatRange } from './BaseRepeatRange.ts';
+export declare class RepeatRangeControlled extends BaseRepeatRange<ControlledRepeatRangeDefinition> implements RepeatRangeControlledNode, EvaluationContext, SubscribableDependency {
+    readonly nodeType = "repeat-range:controlled";
+    readonly appearances: RepeatRangeNodeAppearances;
+    readonly validationState: AncestorNodeValidationState;
+    constructor(parent: GeneralParentNode, definition: ControlledRepeatRangeDefinition);
+    private initializeControlledChildrenState;
+}

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

@@ -0,0 +1,34 @@
+import { RepeatRangeNodeAppearances } from '../../client/repeat/BaseRepeatRangeNode.ts';
+import { RepeatRangeUncontrolledNode } from '../../client/repeat/RepeatRangeUncontrolledNode.ts';
+import { AncestorNodeValidationState } from '../../client/validation.ts';
+import { UncontrolledRepeatRangeDefinition } from '../../parse/model/RepeatRangeDefinition.ts';
+import { GeneralParentNode } from '../hierarchy.ts';
+import { EvaluationContext } from '../internal-api/EvaluationContext.ts';
+import { SubscribableDependency } from '../internal-api/SubscribableDependency.ts';
+import { Root } from '../Root.ts';
+import { BaseRepeatRange } from './BaseRepeatRange.ts';
+export declare class RepeatRangeUncontrolled extends BaseRepeatRange<UncontrolledRepeatRangeDefinition> implements RepeatRangeUncontrolledNode, EvaluationContext, SubscribableDependency {
+    readonly nodeType = "repeat-range:uncontrolled";
+    readonly appearances: RepeatRangeNodeAppearances;
+    readonly validationState: AncestorNodeValidationState;
+    constructor(parent: GeneralParentNode, definition: UncontrolledRepeatRangeDefinition);
+    addInstances(afterIndex?: number, count?: number): Root;
+    /**
+     * Removes the {@link RepeatInstance}s corresponding to the specified range of
+     * indexes, and then removes those repeat instances from the repeat range's
+     * own children state in that order:
+     *
+     * 1. Identify the set of {@link RepeatInstance}s to be removed.
+     *
+     * 2. For each {@link RepeatInstance} pending removal, perform that node's
+     *    removal logic. @see {@link RepeatInstance.remove} for more detail.
+     *
+     * 3. Finalize update to the repeat range's own {@link childrenState},
+     *    omitting those {@link RepeatInstance}s which were removed.
+     *
+     * This ordering ensures a consistent representation of state is established
+     * prior to any downstream reactive updates, and ensures that removed nodes'
+     * reactivity is cleaned up.
+     */
+    removeInstances(startIndex: number, count?: number): Root;
+}

package/dist/instance/resource.d.ts

@@ -1,6 +1,5 @@
 import { FetchResource, FetchResourceResponse } from '../client/EngineConfig.ts';
 import { FormResource } from '../client/index.ts';
-
 export type { FetchResource, FetchResourceResponse, FormResource };
 export interface ResourceOptions {
     readonly fetchResource: FetchResource;

package/dist/instance/text/TextChunk.d.ts

@@ -1,7 +1,6 @@
 import { ActiveLanguage } from '../../client/FormLanguage.ts';
 import { TextChunk as ClientTextChunk, TextChunkSource } from '../../client/TextRange.ts';
 import { TranslationContext } from '../internal-api/TranslationContext.ts';
-
 export declare class TextChunk implements ClientTextChunk {
     readonly context: TranslationContext;
     readonly source: TextChunkSource;

package/dist/instance/text/TextRange.d.ts

@@ -1,11 +1,10 @@
-import { TextRange as ClientTextRange, TextChunk } from '../../client/TextRange.ts';
-
-export type TextRole = 'hint' | 'label';
-export declare class TextRange<Role extends TextRole> implements ClientTextRange<Role> {
+import { TextRange as ClientTextRange, TextChunk, TextOrigin, TextRole } from '../../client/TextRange.ts';
+export declare class TextRange<Role extends TextRole, Origin extends TextOrigin> implements ClientTextRange<Role, Origin> {
+    readonly origin: Origin;
     readonly role: Role;
     protected readonly chunks: readonly TextChunk[];
     [Symbol.iterator](): Generator<TextChunk, void, undefined>;
     get formatted(): Record<PropertyKey, unknown>;
     get asString(): string;
-    constructor(role: Role, chunks: readonly TextChunk[]);
+    constructor(origin: Origin, role: Role, chunks: readonly TextChunk[]);
 }

package/dist/instance/unsupported/RangeControl.d.ts

@@ -0,0 +1,4 @@
+import { UnsupportedControl } from '../abstract/UnsupportedControl.ts';
+export declare class RangeControl extends UnsupportedControl<'range'> {
+    readonly nodeType = "range";
+}

package/dist/instance/unsupported/RankControl.d.ts

@@ -0,0 +1,4 @@
+import { UnsupportedControl } from '../abstract/UnsupportedControl.ts';
+export declare class RankControl extends UnsupportedControl<'rank'> {
+    readonly nodeType = "rank";
+}

package/dist/instance/unsupported/UploadControl.d.ts

@@ -0,0 +1,4 @@
+import { UnsupportedControl } from '../abstract/UnsupportedControl.ts';
+export declare class UploadControl extends UnsupportedControl<'upload'> {
+    readonly nodeType = "upload";
+}

package/dist/lib/TokenListParser.d.ts

@@ -1,12 +1,12 @@
 import { PartiallyKnownString } from '../../../common/types/string/PartiallyKnownString.ts';
-
 type SymbolIterator = typeof Symbol.iterator;
 type TokenListKey<CanonicalToken extends string> = PartiallyKnownString<CanonicalToken> | SymbolIterator;
 type TokenListIterator<CanonicalToken extends string> = IterableIterator<PartiallyKnownString<CanonicalToken>>;
+type PassthroughTokenList = Readonly<Record<string, boolean>>;
 /**
  * @see {@link TokenListParser}
  */
-export type TokenList<CanonicalToken extends string = string> = {
+export type TokenList<CanonicalToken extends string = string> = PassthroughTokenList & {
     readonly [Key in TokenListKey<CanonicalToken>]: Key extends SymbolIterator ? () => TokenListIterator<CanonicalToken> : boolean;
 };
 interface TokenListAlias<CanonicalToken extends string> {
@@ -77,7 +77,7 @@ type TokenListAttributeName = PartiallyKnownString<'appearance' | 'class'>;
 export declare class TokenListParser<CanonicalToken extends string, TokenAlias extends CanonicalToken = CanonicalToken> {
     readonly canonicalTokens: readonly CanonicalToken[];
     private readonly aliases;
-    constructor(canonicalTokens: readonly CanonicalToken[], options?: TokenListParserOptions<TokenAlias>);
+    constructor(canonicalTokens?: readonly CanonicalToken[], options?: TokenListParserOptions<TokenAlias>);
     parseFrom(element: Element, attributeName: TokenListAttributeName): TokenList<CanonicalToken>;
 }
 export type ParsedTokenList<Parser extends TokenListParser<any>> = Parser extends TokenListParser<infer CanonicalToken> ? TokenList<CanonicalToken> : never;

package/dist/lib/dom/query.d.ts

@@ -1,6 +1,5 @@
 import { KnownAttributeLocalNamedElement, LocalNamedElement } from '../../../../common/types/dom.ts';
-import { SelectElement } from '../../body/control/select/SelectDefinition';
-
+import { SelectElement } from '../../parse/body/control/select/SelectDefinition';
 export interface HintElement extends LocalNamedElement<'hint'> {
 }
 export interface ItemElement extends LocalNamedElement<'item'> {

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

@@ -1,7 +1,6 @@
 import { Accessor, Setter, Signal } from 'solid-js';
 import { AnyChildNode, AnyParentNode } from '../../instance/hierarchy.ts';
 import { NodeID } from '../../instance/identity.ts';
-
 export interface ChildrenState<Child extends AnyChildNode> {
     readonly children: Signal<readonly Child[]>;
     readonly getChildren: Accessor<readonly Child[]>;

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

@@ -1,13 +1,17 @@
 import { Accessor } from 'solid-js';
-import { DependentExpression, DependentExpressionResultType } from '../../expression/DependentExpression.ts';
 import { EvaluationContext } from '../../instance/internal-api/EvaluationContext.ts';
-
+import { SubscribableDependency } from '../../instance/internal-api/SubscribableDependency.ts';
+import { DependentExpression, DependentExpressionResultType } from '../../parse/expression/abstract/DependentExpression.ts';
 interface ComputedExpressionResults {
     readonly boolean: boolean;
     readonly nodes: Node[];
+    readonly number: number;
     readonly string: string;
 }
 type EvaluatedExpression<Type extends DependentExpressionResultType> = ComputedExpressionResults[Type];
 type ComputedExpression<Type extends DependentExpressionResultType> = Accessor<EvaluatedExpression<Type>>;
-export declare const createComputedExpression: <Type extends "string" | "boolean" | "nodes">(context: EvaluationContext, dependentExpression: DependentExpression<Type>) => ComputedExpression<Type>;
+interface CreateComputedExpressionOptions {
+    readonly arbitraryDependencies?: readonly SubscribableDependency[];
+}
+export declare const createComputedExpression: <Type extends DependentExpressionResultType>(context: EvaluationContext, dependentExpression: DependentExpression<Type>, options?: CreateComputedExpressionOptions) => ComputedExpression<Type>;
 export {};

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

@@ -0,0 +1,4 @@
+import { Accessor } from 'solid-js';
+import { EvaluationContext } from '../../instance/internal-api/EvaluationContext.ts';
+import { BindComputationExpression } from '../../parse/expression/BindComputationExpression.ts';
+export declare const createNoteReadonlyThunk: (context: EvaluationContext, readonlyDefinition: BindComputationExpression<"readonly">) => Accessor<true>;

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

@@ -1,7 +1,6 @@
 import { Accessor } from 'solid-js';
 import { SelectItem } from '../../index.ts';
 import { SelectField } from '../../instance/SelectField.ts';
-
 /**
  * Creates a reactive computation of a {@link SelectField}'s
  * {@link SelectItem}s, in support of the field's `valueOptions`.

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

@@ -1,6 +1,5 @@
 import { ValueContext } from '../../instance/internal-api/ValueContext.ts';
 import { SimpleAtomicState } from './types.ts';
-
 type InitialValueSource = 'FORM_DEFAULT' | 'PRIMARY_INSTANCE';
 export interface ValueStateOptions {
     /**

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

@@ -2,7 +2,6 @@ import { AnyChildNode } from '../../instance/hierarchy.ts';
 import { NodeID } from '../../instance/identity.ts';
 import { ChildrenState } from './createChildrenState.ts';
 import { ReactiveScope } from './scope.ts';
-
 export interface EncodedParentState {
     readonly children: readonly NodeID[];
 }

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

@@ -4,7 +4,6 @@ import { ReactiveScope } from '../scope.ts';
 import { EngineState } from './createEngineState.ts';
 import { SpecifiedState, StateSpec } from './createSpecifiedState.ts';
 import { InternalClientRepresentation } from './representations.ts';
-
 export type SpecifiedClientStateFactory<Factory extends OpaqueReactiveObjectFactory, Spec extends StateSpec> = ShallowMutable<SpecifiedState<Spec>> extends Parameters<Factory>[0] ? Factory : never;
 export type ClientState<Spec extends StateSpec> = InternalClientRepresentation<SpecifiedState<Spec>>;
 export declare const createClientState: <Factory extends OpaqueReactiveObjectFactory, Spec extends StateSpec>(scope: ReactiveScope, engineState: EngineState<Spec>, clientStateFactory: SpecifiedClientStateFactory<Factory, Spec>) => ClientState<Spec>;

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

@@ -2,6 +2,5 @@ import { ReactiveScope } from '../scope.ts';
 import { ClientState } from './createClientState.ts';
 import { SpecifiedState, StateSpec } from './createSpecifiedState.ts';
 import { ReadonlyClientRepresentation } from './representations.ts';
-
 export type CurrentState<Spec extends StateSpec> = ReadonlyClientRepresentation<SpecifiedState<Spec>>;
 export declare const createCurrentState: <Spec extends StateSpec>(scope: ReactiveScope, clientState: ClientState<Spec>) => CurrentState<Spec>;

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

@@ -1,6 +1,5 @@
 import { ReactiveScope } from '../scope.ts';
 import { SpecifiedState, StateSpec } from './createSpecifiedState.ts';
 import { EngineRepresentation } from './representations.ts';
-
 export type EngineState<Spec extends StateSpec> = EngineRepresentation<SpecifiedState<Spec>>;
 export declare const createEngineState: <Spec extends StateSpec>(scope: ReactiveScope, spec: Spec) => EngineState<Spec>;

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

@@ -4,7 +4,6 @@ import { ClientState, SpecifiedClientStateFactory } from './createClientState.ts
 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];
@@ -16,7 +15,7 @@ export interface SharedNodeState<Spec extends StateSpec> {
     readonly currentState: CurrentState<Spec>;
     readonly setProperty: SetEnginePropertyState<Spec>;
 }
-interface SharedNodeStateOptions<Factory extends OpaqueReactiveObjectFactory, Spec extends StateSpec> {
+export interface SharedNodeStateOptions<Factory extends OpaqueReactiveObjectFactory, Spec extends StateSpec> {
     readonly clientStateFactory: SpecifiedClientStateFactory<Factory, Spec>;
 }
 export declare const createSharedNodeState: <Factory extends OpaqueReactiveObjectFactory, Spec extends StateSpec>(scope: ReactiveScope, spec: Spec, options: SharedNodeStateOptions<Factory, Spec>) => SharedNodeState<Spec>;

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

@@ -1,5 +1,4 @@
 import { StatePropertySpec } from './createSpecifiedState.ts';
-
 export interface SpecifiedPropertyDescriptor<T = any> extends TypedPropertyDescriptor<T> {
     readonly configurable: true;
     readonly enumerable: true;

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

@@ -1,6 +1,5 @@
 import { Accessor, Signal } from 'solid-js';
 import { SimpleAtomicState } from '../types.ts';
-
 /**
  * Specifies a state object's property as mutable. Basic usage:
  *
@@ -110,7 +109,7 @@ export type StaticPropertySpec<T> = Exclude<T, NonStaticValue>;
 export type StatePropertySpec<T = any> = MutablePropertySpec<T> | ComputedPropertySpec<T> | StaticPropertySpec<T>;
 export declare const isMutablePropertySpec: <T>(propertySpec: StatePropertySpec<T>) => propertySpec is MutablePropertySpec<T>;
 export declare const isComputedPropertySpec: <T>(propertySpec: StatePropertySpec<T>) => propertySpec is ComputedPropertySpec<T>;
-export declare const isStaticPropertySpec: <T>(propertySpec: StatePropertySpec<T>) => propertySpec is Exclude<T, NonStaticValue>;
+export declare const isStaticPropertySpec: <T>(propertySpec: StatePropertySpec<T>) => propertySpec is StaticPropertySpec<T>;
 export type StateSpec = Record<string, StatePropertySpec>;
 type SpecifiedStatePropertyValue<PropertySpec extends StatePropertySpec> = PropertySpec extends StatePropertySpec<infer T> ? T : never;
 type DerivedMutableKeys<Spec extends StateSpec> = {

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

@@ -1,5 +1,4 @@
 import { ShallowMutable } from '../../../../../common/types/helpers.js';
-
 declare const ENGINE_REPRESENTATION: unique symbol;
 type ENGINE_REPRESENTATION = typeof ENGINE_REPRESENTATION;
 declare const INTERNAL_CLIENT_REPRESENTATION: unique symbol;

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

@@ -1,5 +1,4 @@
 import { Owner } from 'solid-js';
-
 type ReactiveScopeTask<T> = (scope: ReactiveScope) => T;
 type RunReactiveScopeTask = <T>(task: ReactiveScopeTask<T>) => T;
 export interface ReactiveScope {

package/dist/lib/reactivity/text/createFieldHint.d.ts

@@ -1,6 +1,5 @@
 import { Accessor } from 'solid-js';
+import { TextRange } from '../../../client/TextRange.ts';
 import { EvaluationContext } from '../../../instance/internal-api/EvaluationContext.ts';
-import { TextRange } from '../../../instance/text/TextRange.ts';
-import { ValueNodeDefinition } from '../../../model/ValueNodeDefinition.ts';
-
-export declare const createFieldHint: (context: EvaluationContext, definition: ValueNodeDefinition) => Accessor<TextRange<'hint'> | null>;
+import { LeafNodeDefinition } from '../../../parse/model/LeafNodeDefinition.ts';
+export declare const createFieldHint: (context: EvaluationContext, definition: LeafNodeDefinition) => Accessor<TextRange<"hint", "form"> | null>;

package/dist/lib/reactivity/text/createNodeLabel.d.ts

@@ -1,6 +1,5 @@
 import { Accessor } from 'solid-js';
+import { TextRange } from '../../../client/TextRange.ts';
 import { EvaluationContext } from '../../../instance/internal-api/EvaluationContext.ts';
-import { TextRange } from '../../../instance/text/TextRange.ts';
-import { AnyNodeDefinition } from '../../../model/NodeDefinition.ts';
-
-export declare const createNodeLabel: (context: EvaluationContext, definition: AnyNodeDefinition) => Accessor<TextRange<'label'> | null>;
+import { AnyNodeDefinition } from '../../../parse/model/NodeDefinition.ts';
+export declare const createNodeLabel: (context: EvaluationContext, definition: AnyNodeDefinition) => Accessor<TextRange<"label", "form"> | null>;

package/dist/lib/reactivity/text/createNoteText.d.ts

@@ -0,0 +1,24 @@
+import { Accessor } from 'solid-js';
+import { TextRange } from '../../../client/TextRange.ts';
+import { EvaluationContext } from '../../../instance/internal-api/EvaluationContext.ts';
+import { NoteTextDefinition } from '../../../parse/model/NoteNodeDefinition.ts';
+export type NoteTextRole = 'label' | 'hint';
+export type ComputedNoteText<Role extends NoteTextRole = NoteTextRole> = Accessor<TextRange<Role, 'form'>>;
+interface BaseNoteText {
+    readonly role: NoteTextRole;
+    readonly label: ComputedNoteText<'label'> | null;
+    readonly hint: ComputedNoteText<'hint'> | null;
+}
+interface LabelNoteText extends BaseNoteText {
+    readonly role: 'label';
+    readonly label: ComputedNoteText<'label'>;
+    readonly hint: null;
+}
+interface HintNoteText extends BaseNoteText {
+    readonly role: 'hint';
+    readonly label: null;
+    readonly hint: ComputedNoteText<'hint'>;
+}
+export type NoteTextComputation = LabelNoteText | HintNoteText;
+export declare const createNoteText: (context: EvaluationContext, noteTextDefinition: NoteTextDefinition) => NoteTextComputation;
+export {};

package/dist/lib/reactivity/text/createTextRange.d.ts

@@ -1,12 +1,9 @@
 import { Accessor } from 'solid-js';
-import { TextElementDefinition } from '../../../body/text/TextElementDefinition.ts';
+import { TextRole } from '../../../client/TextRange.ts';
 import { EvaluationContext } from '../../../instance/internal-api/EvaluationContext.ts';
-import { TextRange, TextRole } from '../../../instance/text/TextRange.ts';
-
-interface CreateTextRangeOptions<FallbackValue extends string | null> {
-    readonly fallbackValue?: FallbackValue;
-}
-type ComputedTextRange<Role extends TextRole, Definition extends TextElementDefinition<Role> | null, FallbackValue extends string | null> = Accessor<Definition extends null ? FallbackValue extends null ? TextRange<Role> | null : TextRange<Role> : TextRange<Role>>;
+import { TextRange } from '../../../instance/text/TextRange.ts';
+import { TextRangeDefinition } from '../../../parse/text/abstract/TextRangeDefinition.ts';
+type ComputedFormTextRange<Role extends TextRole> = Accessor<TextRange<Role, 'form'>>;
 /**
  * Creates a text range (e.g. label or hint) from the provided definition,
  * reactive to:
@@ -16,5 +13,5 @@ type ComputedTextRange<Role extends TextRole, Definition extends TextElementDefi
  *
  * @todo This does not yet handle itext translations **with** outputs!
  */
-export declare const createTextRange: <Role extends TextRole, Definition extends TextElementDefinition<Role> | null, FallbackValue extends string | null = null>(context: EvaluationContext, role: Role, definition: Definition, options?: CreateTextRangeOptions<FallbackValue>) => ComputedTextRange<Role, Definition, FallbackValue>;
+export declare const createTextRange: <Role extends TextRole>(context: EvaluationContext, role: Role, definition: TextRangeDefinition<Role>) => ComputedFormTextRange<Role>;
 export {};

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

@@ -1,5 +1,4 @@
 import { Accessor, Setter } from 'solid-js';
-
 /**
  * A write interface to reactive atomic state. This type is intended to be used
  * as a relaxed version of {@link Setter}, where its callback form isn't

package/dist/lib/reactivity/validation/createAggregatedViolations.d.ts

@@ -0,0 +1,8 @@
+import { OpaqueReactiveObjectFactory } from '../../../client/OpaqueReactiveObjectFactory.ts';
+import { AncestorNodeValidationState } from '../../../client/validation.ts';
+import { AnyParentNode } from '../../../instance/hierarchy.ts';
+interface AggregatedViolationsOptions {
+    readonly clientStateFactory: OpaqueReactiveObjectFactory<AncestorNodeValidationState>;
+}
+export declare const createAggregatedViolations: (context: AnyParentNode, options: AggregatedViolationsOptions) => AncestorNodeValidationState;
+export {};

package/dist/lib/reactivity/validation/createValidation.d.ts

@@ -0,0 +1,17 @@
+import { Accessor } from 'solid-js';
+import { OpaqueReactiveObjectFactory } from '../../../client/OpaqueReactiveObjectFactory.ts';
+import { AnyViolation, ConditionValidation, ValidationCondition } from '../../../client/validation.ts';
+import { ValidationContext } from '../../../instance/internal-api/ValidationContext.ts';
+import { SharedNodeState, SharedNodeStateOptions } from '../node-state/createSharedNodeState.ts';
+type ComputedConditionValidation<Condition extends ValidationCondition> = Accessor<ConditionValidation<Condition>>;
+type ComputedViolation = Accessor<AnyViolation | null>;
+interface ValidationStateSpec {
+    readonly constraint: ComputedConditionValidation<'constraint'>;
+    readonly required: ComputedConditionValidation<'required'>;
+    readonly violation: ComputedViolation;
+}
+export type SharedValidationState = SharedNodeState<ValidationStateSpec>;
+interface ValidationStateOptions<Factory extends OpaqueReactiveObjectFactory> extends SharedNodeStateOptions<Factory, ValidationStateSpec> {
+}
+export declare const createValidationState: <Factory extends OpaqueReactiveObjectFactory>(context: ValidationContext, options: ValidationStateOptions<Factory>) => SharedValidationState;
+export {};

package/dist/{XFormDOM.d.ts → parse/XFormDOM.d.ts}

@@ -1,5 +1,4 @@
 import { XFormsXPathEvaluator } from '@getodk/xpath';
-
 interface XFormDOMNormalizationOptions {
     readonly isNormalized: boolean;
 }
@@ -19,7 +18,7 @@ export declare class XFormDOM {
     readonly body: Element;
     protected constructor(sourceXML: string, options: XFormDOMNormalizationOptions);
     createInstance(): XFormDOM;
-    toJSON(): Omit<this, "xformDocument" | "html" | "rootEvaluator" | "primaryInstanceEvaluator" | "head" | "title" | "model" | "primaryInstance" | "primaryInstanceRoot" | "createInstance" | "toJSON"> & {
+    toJSON(): Omit<this, "head" | "html" | "title" | "toJSON" | "model" | "primaryInstanceRoot" | "xformDocument" | "rootEvaluator" | "primaryInstanceEvaluator" | "primaryInstance" | "createInstance"> & {
         xformDocument: string;
         html: string;
         head: string;

package/dist/{XFormDataType.d.ts → parse/XFormDataType.d.ts}

@@ -1,5 +1,4 @@
-import { CollectionValues } from '../../common/types/collections/CollectionValues.ts';
-
+import { CollectionValues } from '../../../common/types/collections/CollectionValues.ts';
 /**
  * Like JavaRosa. Presumably for explicit types which aren't impelemnted?
  */
@@ -8,8 +7,7 @@ export type UnsupportedDataType = typeof UNSUPPORTED_DATA_TYPE;
 /**
  * Like JavaRosa. Presumably for e.g. groups with explicit binds (`relevant` etc)?
  */
-declare const NULL_DATA_TYPE = "NULL";
-export type NullDataType = typeof NULL_DATA_TYPE;
+export type NullDataType = 'NULL';
 /**
  * As in ODK XForms Spec.
  *