@getodk/xforms-engine 0.13.0 → 0.15.0

package/dist/instance/Attribute.d.ts

@@ -0,0 +1,58 @@
+import { XPathNodeKindKey } from '@getodk/xpath';
+import { Accessor } from 'solid-js';
+import { AttributeNode } from '../client/AttributeNode.ts';
+import { ActiveLanguage, InstanceState, NullValidationState } from '../client/index.ts';
+import { XFormsXPathAttribute } from '../integration/xpath/adapter/XFormsXPathNode.ts';
+import { EngineXPathEvaluator } from '../integration/xpath/EngineXPathEvaluator.ts';
+import { StaticAttribute } from '../integration/xpath/static-dom/StaticAttribute.ts';
+import { RuntimeInputValue, RuntimeValue } from '../lib/codecs/getSharedValueCodec.ts';
+import { RuntimeValueSetter, RuntimeValueState } from '../lib/codecs/ValueCodec.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 { 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 { AttributeContext } from './internal-api/AttributeContext.ts';
+import { DecodeInstanceValue } from './internal-api/InstanceValueContext.ts';
+import { ClientReactiveSerializableAttributeNode } from './internal-api/serialization/ClientReactiveSerializableAttributeNode.ts';
+import { Root } from './Root.ts';
+export interface AttributeStateSpec extends DescendantNodeSharedStateSpec {
+    readonly children: null;
+    readonly attributes: null;
+    readonly value: SimpleAtomicState<string>;
+    readonly instanceValue: Accessor<string>;
+    readonly label: null;
+    readonly hint: null;
+    readonly valueOptions: null;
+}
+export declare class Attribute extends InstanceNode<AttributeDefinition, AttributeStateSpec, AnyParentNode, null> implements AttributeNode, ClientReactiveSerializableAttributeNode, AttributeContext, XFormsXPathAttribute {
+    readonly instanceNode: StaticAttribute;
+    readonly [XPathNodeKindKey] = "attribute";
+    protected readonly state: SharedNodeState<AttributeStateSpec>;
+    protected readonly engineState: EngineState<AttributeStateSpec>;
+    readonly validationState: NullValidationState;
+    readonly nodeType = "attribute";
+    readonly currentState: CurrentState<AttributeStateSpec>;
+    readonly instanceState: InstanceState;
+    readonly appearances: null;
+    readonly nodeOptions: null;
+    readonly valueType: string;
+    readonly decodeInstanceValue: DecodeInstanceValue;
+    protected readonly getInstanceValue: Accessor<string>;
+    protected readonly valueState: RuntimeValueState<RuntimeValue<'string'>>;
+    protected readonly setValueState: RuntimeValueSetter<RuntimeInputValue<'string'>>;
+    readonly evaluator: EngineXPathEvaluator;
+    readonly getActiveLanguage: Accessor<ActiveLanguage>;
+    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);
+    setValue(value: string): Root;
+    getChildren(): readonly [];
+}

package/dist/instance/Group.d.ts

@@ -12,6 +12,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 { DescendantNodeSharedStateSpec, DescendantNode } from './abstract/DescendantNode.ts';
+import { Attribute } from './Attribute.ts';
 import { GeneralChildNode, GeneralParentNode } from './hierarchy.ts';
 import { EvaluationContext } from './internal-api/EvaluationContext.ts';
 import { ClientReactiveSerializableParentNode } from './internal-api/serialization/ClientReactiveSerializableParentNode.ts';
@@ -19,11 +20,13 @@ interface GroupStateSpec extends DescendantNodeSharedStateSpec {
     readonly label: Accessor<TextRange<'label'> | null>;
     readonly hint: null;
     readonly children: Accessor<readonly FormNodeID[]>;
+    readonly attributes: Accessor<readonly Attribute[]>;
     readonly valueOptions: null;
     readonly value: null;
 }
 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>;
@@ -35,5 +38,6 @@ 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/PrimaryInstance.d.ts

@@ -21,6 +21,7 @@ import { RootDefinition } from '../parse/model/RootDefinition.ts';
 import { SecondaryInstancesDefinition } from '../parse/model/SecondaryInstance/SecondaryInstancesDefinition.ts';
 import { InstanceNode } from './abstract/InstanceNode.ts';
 import { InstanceAttachmentsState } from './attachments/InstanceAttachmentsState.ts';
+import { Attribute } from './Attribute.ts';
 import { InitialInstanceState } from './input/InitialInstanceState.ts';
 import { EvaluationContext } from './internal-api/EvaluationContext.ts';
 import { InstanceConfig } from './internal-api/InstanceConfig.ts';
@@ -36,6 +37,7 @@ interface PrimaryInstanceStateSpec {
     readonly label: null;
     readonly hint: null;
     readonly children: Accessor<readonly FormNodeID[]>;
+    readonly attributes: Accessor<readonly Attribute[]>;
     readonly valueOptions: null;
     readonly value: null;
     readonly activeLanguage: Accessor<ActiveLanguage>;
@@ -85,6 +87,7 @@ 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
@@ -107,5 +110,6 @@ 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

@@ -15,6 +15,7 @@ import { SharedNodeState } from '../lib/reactivity/node-state/createSharedNodeSt
 import { BodyClassList } from '../parse/body/BodyDefinition.ts';
 import { RootDefinition } from '../parse/model/RootDefinition.ts';
 import { DescendantNode } from './abstract/DescendantNode.ts';
+import { Attribute } from './Attribute.ts';
 import { GeneralChildNode } from './hierarchy.ts';
 import { EvaluationContext } from './internal-api/EvaluationContext.ts';
 import { ClientReactiveSerializableParentNode } from './internal-api/serialization/ClientReactiveSerializableParentNode.ts';
@@ -28,12 +29,14 @@ interface RootStateSpec {
     readonly label: null;
     readonly hint: null;
     readonly children: Accessor<readonly FormNodeID[]>;
+    readonly attributes: Accessor<readonly Attribute[]>;
     readonly valueOptions: null;
     readonly value: null;
     readonly activeLanguage: Accessor<ActiveLanguage>;
 }
 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>;
@@ -54,6 +57,7 @@ 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

@@ -12,6 +12,7 @@ import { EngineState } from '../lib/reactivity/node-state/createEngineState.ts';
 import { SharedNodeState } from '../lib/reactivity/node-state/createSharedNodeState.ts';
 import { SimpleAtomicState } from '../lib/reactivity/types.ts';
 import { UnknownAppearanceDefinition } from '../parse/body/appearance/unknownAppearanceParser.ts';
+import { Attribute } from './Attribute.ts';
 import { Root } from './Root.ts';
 import { DescendantNodeStateSpec, DescendantNode } from './abstract/DescendantNode.ts';
 import { InstanceAttachmentRuntimeValue } from './attachments/InstanceAttachment.ts';
@@ -28,6 +29,7 @@ interface UploadControlStateSpec extends DescendantNodeStateSpec<InstanceAttachm
     readonly label: Accessor<TextRange<'label'> | null>;
     readonly hint: Accessor<TextRange<'hint'> | null>;
     readonly children: null;
+    readonly attributes: Accessor<readonly Attribute[]>;
     readonly valueOptions: null;
     readonly value: SimpleAtomicState<InstanceAttachmentRuntimeValue>;
     readonly instanceValue: Accessor<InstanceAttachmentFileName>;
@@ -37,6 +39,7 @@ 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>;
@@ -54,5 +57,6 @@ 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

@@ -10,6 +10,7 @@ import { ActiveLanguage, TextRange } from '../../index.ts';
 import { EngineXPathEvaluator } from '../../integration/xpath/EngineXPathEvaluator.ts';
 import { XFormsXPathPrimaryInstanceNode, XFormsXPathPrimaryInstanceNodeKind } from '../../integration/xpath/adapter/XFormsXPathNode.ts';
 import { PrimaryInstanceXPathNode } from '../../integration/xpath/adapter/kind.ts';
+import { StaticAttribute } from '../../integration/xpath/static-dom/StaticAttribute.ts';
 import { StaticDocument } from '../../integration/xpath/static-dom/StaticDocument.ts';
 import { StaticElement } from '../../integration/xpath/static-dom/StaticElement.ts';
 import { CurrentState } from '../../lib/reactivity/node-state/createCurrentState.ts';
@@ -18,6 +19,7 @@ import { SharedNodeState } from '../../lib/reactivity/node-state/createSharedNod
 import { ReactiveScope } from '../../lib/reactivity/scope.ts';
 import { SimpleAtomicState } from '../../lib/reactivity/types.ts';
 import { AnyNodeDefinition } from '../../parse/model/NodeDefinition.ts';
+import { Attribute } from '../Attribute.ts';
 import { PrimaryInstance } from '../PrimaryInstance.ts';
 import { Root } from '../Root.ts';
 import { AnyChildNode, AnyParentNode } from '../hierarchy.ts';
@@ -36,6 +38,7 @@ export interface InstanceNodeStateSpec<Value = never> {
     readonly label: Accessor<TextRange<'label'> | null> | null;
     readonly hint: Accessor<TextRange<'hint'> | null> | null;
     readonly children: Accessor<readonly FormNodeID[]> | null;
+    readonly attributes: Accessor<readonly Attribute[]> | null;
     readonly valueOptions: InstanceNodeValueOptionsStateSpec;
     readonly value: Signal<Value> | SimpleAtomicState<Value> | null;
 }
@@ -59,7 +62,7 @@ export interface InstanceNodeOptions {
 export declare abstract class InstanceNode<Definition extends AnyNodeDefinition, Spec extends InstanceNodeStateSpec<any>, Parent extends AnyParentNode | null, Child extends AnyChildNode | null = null> implements BaseEngineNode, XFormsXPathPrimaryInstanceNode, EvaluationContext {
     readonly instanceConfig: InstanceConfig;
     readonly parent: Parent;
-    readonly instanceNode: StaticDocument | StaticElement | null;
+    readonly instanceNode: StaticAttribute | StaticDocument | StaticElement | null;
     readonly definition: Definition;
     protected abstract readonly state: SharedNodeState<Spec>;
     protected abstract readonly engineState: EngineState<Spec>;
@@ -106,7 +109,7 @@ export declare abstract class InstanceNode<Definition extends AnyNodeDefinition,
      * constrain) their more specific `this` type.
      */
     readonly contextNode: PrimaryInstanceXPathNode;
-    constructor(instanceConfig: InstanceConfig, parent: Parent, instanceNode: StaticDocument | StaticElement | null, definition: Definition, options?: InstanceNodeOptions);
+    constructor(instanceConfig: InstanceConfig, parent: Parent, instanceNode: StaticAttribute | StaticDocument | StaticElement | null, definition: Definition, options?: InstanceNodeOptions);
     /** @package */
     isPrimaryInstance(): this is PrimaryInstance;
     /** @package */
@@ -121,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): readonly AnyChildNode[];
+    abstract getChildren(this: AnyInstanceNode): ReadonlyArray<Exclude<AnyChildNode, Attribute>>;
     /**
      * @todo Values as text nodes(?)
      */
-    getXPathChildNodes(): readonly AnyChildNode[];
+    getXPathChildNodes(): ReadonlyArray<Exclude<AnyChildNode, Attribute>>;
     getXPathValue(): string;
 }
 export {};

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

@@ -23,6 +23,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 value: SimpleAtomicState<RuntimeValue>;
     readonly instanceValue: Accessor<string>;
 }

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

@@ -0,0 +1,3 @@
+import { Attribute } from '../Attribute';
+import { AnyParentNode } from '../hierarchy';
+export declare function buildAttributes(parent: AnyParentNode): Attribute[];

package/dist/instance/hierarchy.d.ts

@@ -1,3 +1,4 @@
+import { Attribute } from './Attribute.ts';
 import { Group } from './Group.ts';
 import { AnyInputControl } from './InputControl.ts';
 import { AnyModelValue } from './ModelValue.ts';
@@ -10,13 +11,12 @@ import { RepeatRangeControlled } from './repeat/RepeatRangeControlled.ts';
 import { RepeatRangeUncontrolled } from './repeat/RepeatRangeUncontrolled.ts';
 import { Root } from './Root.ts';
 import { SelectControl } from './SelectControl.ts';
-import { Subtree } from './Subtree.ts';
 import { TriggerControl } from './TriggerControl.ts';
 import { UploadControl } from './UploadControl.ts';
 export type RepeatRange = RepeatRangeControlled | RepeatRangeUncontrolled;
-export type AnyNode = PrimaryInstance | Root | Group | Subtree | RepeatRange | RepeatInstance | AnyNote | AnyModelValue | AnyInputControl | AnyRangeControl | RankControl | SelectControl | TriggerControl | UploadControl;
-export type AnyParentNode = PrimaryInstance | Root | Group | Subtree | RepeatRange | RepeatInstance;
-export type GeneralParentNode = Root | Group | Subtree | RepeatInstance;
-export type AnyChildNode = Root | Group | Subtree | RepeatRange | RepeatInstance | AnyModelValue | AnyNote | AnyInputControl | AnyRangeControl | RankControl | SelectControl | TriggerControl | UploadControl;
-export type GeneralChildNode = Group | Subtree | RepeatRange | AnyModelValue | AnyNote | AnyInputControl | AnyRangeControl | RankControl | SelectControl | TriggerControl | UploadControl;
+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 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

@@ -0,0 +1,29 @@
+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 { EvaluationContext } from './EvaluationContext.ts';
+export interface InstanceAttributeContextDocument {
+    readonly initializationMode: FormInstanceInitializationMode;
+}
+export type DecodeInstanceValue = (value: string) => string;
+interface InstanceAttributeContextDefinitionBind {
+    readonly preload: AnyBindPreloadDefinition | null;
+    readonly calculate: BindComputationExpression<'calculate'> | null;
+    readonly readonly: BindComputationExpression<'readonly'>;
+}
+export interface InstanceAttributeContextDefinition {
+    readonly bind: InstanceAttributeContextDefinitionBind;
+    readonly template: StaticAttribute;
+}
+export interface AttributeContext extends EvaluationContext {
+    readonly scope: ReactiveScope;
+    readonly rootDocument: InstanceAttributeContextDocument;
+    readonly definition: InstanceAttributeContextDefinition;
+    readonly instanceNode: StaticAttribute;
+    readonly decodeInstanceValue: DecodeInstanceValue;
+    isReadonly(): boolean;
+    isRelevant(): boolean;
+}
+export {};

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

@@ -0,0 +1,16 @@
+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 {
+    readonly qualifiedName: QualifiedName;
+}
+export interface ClientReactiveSerializableAttributeNode {
+    readonly definition: ClientReactiveSerializableAttributeNodeDefinition;
+    readonly currentState: ClientReactiveSerializableAttributeNodeCurrentState;
+    readonly instanceState: InstanceState;
+}
+export {};

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

@@ -1,11 +1,13 @@
 import { InstanceState } from '../../../client/serialization/InstanceState.ts';
 import { QualifiedName } from '../../../lib/names/QualifiedName.ts';
+import { Attribute } from '../../Attribute.ts';
 export interface ClientReactiveSerializableChildNode {
     readonly instanceState: InstanceState;
 }
 export interface ClientReactiveSerializableParentNodeCurrentState<Child extends ClientReactiveSerializableChildNode> {
     get relevant(): boolean;
     get children(): readonly Child[];
+    get attributes(): readonly Attribute[];
 }
 export interface ClientReactiveSerializableParentNodeDefinition {
     readonly qualifiedName: QualifiedName;

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

@@ -1,9 +1,9 @@
 import { StaticElement } from '../../../integration/xpath/static-dom/StaticElement.ts';
+import { Attribute } from '../../Attribute.ts';
 import { GeneralChildNode } from '../../hierarchy.ts';
 import { ClientReactiveSerializableParentNode, ClientReactiveSerializableParentNodeCurrentState, ClientReactiveSerializableParentNodeDefinition } from './ClientReactiveSerializableParentNode.ts';
 export interface ClientReactiveSerializableTemplatedNodeCurrentState extends ClientReactiveSerializableParentNodeCurrentState<GeneralChildNode> {
-    /** @see {@link TemplatedNodeAttributeSerializationError} */
-    get attributes(): unknown;
+    get attributes(): readonly Attribute[];
 }
 export interface ClientReactiveSerializableTemplatedNodeDefinition extends ClientReactiveSerializableParentNodeDefinition {
     readonly template: StaticElement;

package/dist/instance/markdown/MarkdownNode.d.ts

@@ -0,0 +1,75 @@
+import { AnchorMarkdownNode, ChildMarkdownNode as ClientChildMarkdownNode, HtmlMarkdownNode as ClientHtmlMarkdownNode, ParentMarkdownNode as ClientParentMarkdownNode, StyledMarkdownNode as ClientStyledMarkdownNode, ElementName, MarkdownNode, MarkdownProperty } from '../../client';
+declare abstract class ParentMarkdownNode implements ClientParentMarkdownNode {
+    readonly children: MarkdownNode[];
+    readonly role = "parent";
+    abstract elementName: ElementName;
+    constructor(children: MarkdownNode[]);
+}
+export declare class Heading1 extends ParentMarkdownNode {
+    readonly elementName = "h1";
+}
+export declare class Heading2 extends ParentMarkdownNode {
+    readonly elementName = "h2";
+}
+export declare class Heading3 extends ParentMarkdownNode {
+    readonly elementName = "h3";
+}
+export declare class Heading4 extends ParentMarkdownNode {
+    readonly elementName = "h4";
+}
+export declare class Heading5 extends ParentMarkdownNode {
+    readonly elementName = "h5";
+}
+export declare class Heading6 extends ParentMarkdownNode {
+    readonly elementName = "h6";
+}
+export declare class Strong extends ParentMarkdownNode {
+    readonly elementName = "strong";
+}
+export declare class Underline extends ParentMarkdownNode {
+    readonly elementName = "u";
+}
+export declare class Emphasis extends ParentMarkdownNode {
+    readonly elementName = "em";
+}
+export declare class OrderedList extends ParentMarkdownNode {
+    readonly elementName = "ol";
+}
+export declare class UnorderedList extends ParentMarkdownNode {
+    readonly elementName = "ul";
+}
+export declare class ListItem extends ParentMarkdownNode {
+    readonly elementName = "li";
+}
+export declare class Anchor extends ParentMarkdownNode implements AnchorMarkdownNode {
+    readonly elementName = "a";
+    readonly url: string;
+    constructor(children: MarkdownNode[], url: string);
+}
+declare abstract class StyledMarkdownNode implements ClientParentMarkdownNode {
+    readonly children: MarkdownNode[];
+    readonly role = "parent";
+    abstract elementName: ElementName;
+    readonly properties: MarkdownProperty | undefined;
+    constructor(children: MarkdownNode[], properties: MarkdownProperty | undefined);
+}
+export declare class Paragraph extends StyledMarkdownNode implements ClientStyledMarkdownNode {
+    readonly elementName = "p";
+}
+export declare class Span extends StyledMarkdownNode implements ClientStyledMarkdownNode {
+    readonly elementName = "span";
+}
+export declare class Div extends StyledMarkdownNode implements ClientStyledMarkdownNode {
+    readonly elementName = "div";
+}
+export declare class ChildMarkdownNode implements ClientChildMarkdownNode {
+    readonly role = "child";
+    readonly value: string;
+    constructor(value: string);
+}
+export declare class Html implements ClientHtmlMarkdownNode {
+    readonly role = "html";
+    readonly unsafeHtml: string;
+    constructor(unsafeHtml: string);
+}
+export {};

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

@@ -9,6 +9,7 @@ import { TextRange } from '../../client/TextRange.ts';
 import { AncestorNodeValidationState } from '../../client/validation.ts';
 import { XFormsXPathNodeRange, XFormsXPathNodeRangeKind } from '../../integration/xpath/adapter/XFormsXPathNode.ts';
 import { StaticElement } from '../../integration/xpath/static-dom/StaticElement.ts';
+import { AttributeState } from '../../lib/reactivity/createAttributeState.ts';
 import { ChildrenState } from '../../lib/reactivity/createChildrenState.ts';
 import { MaterializedChildren } from '../../lib/reactivity/materializeCurrentStateChildren.ts';
 import { CurrentState } from '../../lib/reactivity/node-state/createCurrentState.ts';
@@ -16,6 +17,7 @@ import { EngineState } from '../../lib/reactivity/node-state/createEngineState.t
 import { SharedNodeState } from '../../lib/reactivity/node-state/createSharedNodeState.ts';
 import { ControlledRepeatDefinition } from '../../parse/model/RepeatDefinition.ts';
 import { DescendantNodeSharedStateSpec, DescendantNode } from '../abstract/DescendantNode.ts';
+import { Attribute } from '../Attribute.ts';
 import { GeneralParentNode } from '../hierarchy.ts';
 import { EvaluationContext } from '../internal-api/EvaluationContext.ts';
 import { ClientReactiveSerializableParentNode } from '../internal-api/serialization/ClientReactiveSerializableParentNode.ts';
@@ -24,12 +26,14 @@ interface RepeatRangeStateSpec extends DescendantNodeSharedStateSpec {
     readonly hint: null;
     readonly label: Accessor<TextRange<'label'> | null>;
     readonly children: Accessor<readonly FormNodeID[]>;
+    readonly attributes: Accessor<readonly Attribute[]>;
     readonly valueOptions: null;
     readonly value: null;
 }
 type BaseRepeatRangeNodeType<Definition extends AnyRepeatDefinition> = Definition extends ControlledRepeatDefinition ? 'repeat-range:controlled' : 'repeat-range:uncontrolled';
 export declare abstract class BaseRepeatRange<Definition extends AnyRepeatDefinition> extends DescendantNode<Definition, RepeatRangeStateSpec, GeneralParentNode, RepeatInstance> implements BaseRepeatRangeNode, XFormsXPathNodeRange, EvaluationContext, ClientReactiveSerializableParentNode<RepeatInstance> {
     protected readonly childrenState: ChildrenState<RepeatInstance>;
+    protected readonly attributeState: AttributeState;
     /**
      * A repeat range doesn't have a corresponding primary instance element of its
      * own. It is represented in the following ways:
@@ -114,5 +118,6 @@ export declare abstract class BaseRepeatRange<Definition extends AnyRepeatDefini
     protected addChildren(afterIndex: number, instanceNodes: readonly StaticElement[]): readonly RepeatInstance[];
     protected removeChildren(startIndex: number, count: number): readonly RepeatInstance[];
     getChildren(): readonly RepeatInstance[];
+    getAttributes(): readonly Attribute[];
 }
 export {};

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

@@ -12,14 +12,14 @@ import { CurrentState } from '../../lib/reactivity/node-state/createCurrentState
 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 { Attribute } from '../Attribute.ts';
 import { GeneralChildNode, RepeatRange } from '../hierarchy.ts';
 import { EvaluationContext } from '../internal-api/EvaluationContext.ts';
 import { ClientReactiveSerializableTemplatedNode } from '../internal-api/serialization/ClientReactiveSerializableTemplatedNode.ts';
 interface RepeatInstanceStateSpec extends DescendantNodeSharedStateSpec {
     readonly label: Accessor<TextRange<'label'> | null>;
     readonly hint: null;
-    /** @see {@link TemplatedNodeAttributeSerializationError} */
-    readonly attributes: null;
+    readonly attributes: Accessor<readonly Attribute[]>;
     readonly children: Accessor<readonly FormNodeID[]>;
     readonly valueOptions: null;
     readonly value: null;
@@ -30,6 +30,7 @@ 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>;
@@ -66,5 +67,6 @@ 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/instance/text/TextChunk.d.ts

@@ -5,7 +5,6 @@ export declare class TextChunk implements ClientTextChunk {
     readonly context: TranslationContext;
     readonly source: TextChunkSource;
     readonly asString: string;
-    get formatted(): Record<PropertyKey, unknown>;
     get language(): ActiveLanguage;
     constructor(context: TranslationContext, source: TextChunkSource, asString: string);
 }

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

@@ -1,4 +1,5 @@
 import { JRResourceURL } from '../../../../common/src/jr-resources/JRResourceURL.ts';
+import { MarkdownNode } from '../../client/MarkdownNode.ts';
 import { TextRange as ClientTextRange, TextChunk, TextOrigin, TextRole } from '../../client/TextRange.ts';
 export interface MediaSources {
     image?: JRResourceURL;
@@ -11,7 +12,7 @@ export declare class TextRange<Role extends TextRole, Origin extends TextOrigin>
     protected readonly chunks: readonly TextChunk[];
     protected readonly mediaSources?: MediaSources | undefined;
     [Symbol.iterator](): Generator<TextChunk, void, unknown>;
-    get formatted(): Record<PropertyKey, unknown>;
+    get formatted(): MarkdownNode[];
     get asString(): string;
     get imageSource(): JRResourceURL | undefined;
     get audioSource(): JRResourceURL | undefined;

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

@@ -0,0 +1,3 @@
+import { MarkdownNode } from '../../client';
+import { TextChunk } from '../../client/TextRange.ts';
+export declare function format(chunks: readonly TextChunk[]): MarkdownNode[];

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

@@ -56,11 +56,11 @@ export type XPathNamedNodeKind = XPathElementKind | XPathAttributeKind;
 export interface XFormsXPathNamedNode extends XFormsXPathNode {
     readonly [XPathNodeKindKey]: XPathNamedNodeKind;
 }
-export type XFormsXPathDescendantNodeKind = XFormsXPathNodeRangeKind | XPathElementKind | XPathTextKind | XPathCommentKind;
+export type XFormsXPathDescendantNodeKind = XFormsXPathNodeRangeKind | XPathElementKind | XPathTextKind | XPathCommentKind | XPathAttributeKind;
 export interface XFormsXPathDescendantNode extends XFormsXPathNode {
     readonly [XPathNodeKindKey]: XFormsXPathDescendantNodeKind;
 }
-export type XFormsXPathPrimaryInstanceNodeKind = XPathDocumentKind | XFormsXPathNodeRangeKind | XPathElementKind | XPathTextKind;
+export type XFormsXPathPrimaryInstanceNodeKind = XPathDocumentKind | XFormsXPathNodeRangeKind | XPathElementKind | XPathAttributeKind | XPathTextKind;
 export interface XFormsXPathPrimaryInstanceNode extends XFormsXPathNode {
     readonly [XPathNodeKindKey]: XFormsXPathPrimaryInstanceNodeKind;
 }

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

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

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

@@ -1,6 +1,3 @@
 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/names/NamespaceDeclarationMap.d.ts

@@ -7,7 +7,7 @@ type NamedNodeDefinitionMap = ReadonlyMap<QualifiedName, NamedNodeDefinition>;
 export interface NamedSubtreeDefinition extends NamedNodeDefinition {
     readonly namespaceDeclarations: NamespaceDeclarationMap;
     readonly parent: NamedSubtreeDefinition | null;
-    readonly attributes?: NamedNodeDefinitionMap;
+    readonly attributes: NamedNodeDefinitionMap | null;
 }
 /**
  * @todo This is a bit of a code style experiment! Responsive to

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

@@ -0,0 +1,16 @@
+import { Accessor, Setter, Signal } from 'solid-js';
+import { Attribute } from '../../instance/Attribute.ts';
+import { ReactiveScope } from './scope.ts';
+export interface AttributeState {
+    readonly attributes: Signal<readonly Attribute[]>;
+    readonly getAttributes: Accessor<readonly Attribute[]>;
+    readonly setAttributes: Setter<readonly Attribute[]>;
+}
+/**
+ * Creates attributes state suitable for all node types
+ *
+ * The produced {@link AttributeState.attributes} (and its get/set convenience
+ * methods) signal is intended to be used to store the engine's attribute state,
+ * and update that state when appropriate.
+ */
+export declare const createAttributeState: (scope: ReactiveScope) => AttributeState;

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

@@ -0,0 +1,15 @@
+import { AttributeContext } from '../../instance/internal-api/AttributeContext.ts';
+import { SimpleAtomicState } from './types.ts';
+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 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 createAttributeValueState: (context: AttributeContext) => InstanceValueState;

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

@@ -1,13 +1,11 @@
 import { Accessor } from 'solid-js';
-import { SelectItem } from '../../client/SelectNode.ts';
-import { RankItem } from '../../client/RankNode.ts';
-import { SelectControl } from '../../instance/SelectControl.ts';
+import { BaseItem } from '../../client/BaseItem.ts';
 import { RankControl } from '../../instance/RankControl.ts';
-export type ItemCollectionControl = RankControl | SelectControl;
-type Item = RankItem | SelectItem;
+import { SelectControl } from '../../instance/SelectControl.ts';
+type ItemCollectionControl = RankControl | SelectControl;
 /**
  * Creates a reactive computation of a {@link ItemCollectionControl}'s
- * {@link Item}s, in support of the field's `valueOptions`.
+ * {@link BaseItem}s, in support of the field's `valueOptions`.
  *
  * - The control defined with static `<item>`s will compute to an corresponding
  *   static list of items.
@@ -17,5 +15,5 @@ type Item = RankItem | SelectItem;
  *   their appropriate dependencies (whether relative to the itemset item node,
  *   referencing a form's `itext` translations, etc).
  */
-export declare const createItemCollection: (control: ItemCollectionControl) => Accessor<readonly Item[]>;
+export declare const createItemCollection: (control: ItemCollectionControl) => Accessor<readonly BaseItem[]>;
 export {};