@getodk/xforms-engine 0.1.0 → 0.2.0

package/dist/.vite/manifest.json

@@ -1,6 +1,7 @@
 {
   "src/index.ts": {
     "file": "solid.js",
+    "name": "solid",
     "src": "src/index.ts",
     "isEntry": true
   }

package/dist/XFormDOM.d.ts

@@ -1,4 +1,5 @@
 import { XFormsXPathEvaluator } from '@getodk/xpath';
+
 interface XFormDOMNormalizationOptions {
     readonly isNormalized: boolean;
 }

package/dist/XFormDataType.d.ts

@@ -1,4 +1,5 @@
-import type { 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?
  */

package/dist/XFormDefinition.d.ts

@@ -1,6 +1,7 @@
 import { XFormDOM } from './XFormDOM.ts';
 import { BodyDefinition } from './body/BodyDefinition.ts';
 import { ModelDefinition } from './model/ModelDefinition.ts';
+
 export declare class XFormDefinition {
     readonly sourceXML: string;
     readonly xformDOM: XFormDOM;

package/dist/body/BodyDefinition.d.ts

@@ -1,26 +1,26 @@
-import type { XFormDefinition } from '../XFormDefinition.ts';
+import { XFormDefinition } from '../XFormDefinition.ts';
 import { DependencyContext } from '../expression/DependencyContext.ts';
+import { ParsedTokenList, TokenListParser } from '../lib/TokenListParser.ts';
+import { RepeatElementDefinition } from './RepeatElementDefinition.ts';
 import { UnsupportedBodyElementDefinition } from './UnsupportedBodyElementDefinition.ts';
 import { InputDefinition } from './control/InputDefinition.ts';
-import type { AnySelectDefinition } from './control/select/SelectDefinition.ts';
+import { AnySelectDefinition } from './control/select/SelectDefinition.ts';
 import { LogicalGroupDefinition } from './group/LogicalGroupDefinition.ts';
 import { PresentationGroupDefinition } from './group/PresentationGroupDefinition.ts';
-import { RepeatGroupDefinition } from './group/RepeatGroupDefinition.ts';
 import { StructuralGroupDefinition } from './group/StructuralGroupDefinition.ts';
+
 export interface BodyElementParentContext {
     readonly reference: string | null;
     readonly element: Element;
 }
-type SupportedBodyElementDefinition = RepeatGroupDefinition | LogicalGroupDefinition | PresentationGroupDefinition | StructuralGroupDefinition | InputDefinition | AnySelectDefinition;
+export type ControlElementDefinition = AnySelectDefinition | InputDefinition;
+type SupportedBodyElementDefinition = RepeatElementDefinition | LogicalGroupDefinition | PresentationGroupDefinition | StructuralGroupDefinition | ControlElementDefinition;
 export type AnyBodyElementDefinition = SupportedBodyElementDefinition | UnsupportedBodyElementDefinition;
 export type BodyElementDefinitionArray = readonly AnyBodyElementDefinition[];
 export type AnyBodyElementType = AnyBodyElementDefinition['type'];
 export type AnyGroupElementDefinition = Extract<AnyBodyElementDefinition, {
     readonly type: `${string}-group`;
 }>;
-export type NonRepeatGroupElementDefinition = Exclude<AnyGroupElementDefinition, {
-    readonly type: 'repeat-group';
-}>;
 export declare const groupElementDefinition: (element: AnyBodyElementDefinition) => AnyGroupElementDefinition | null;
 export type AnyControlElementDefinition = Extract<AnyBodyElementDefinition, {
     readonly category: 'control';
@@ -36,17 +36,35 @@ declare class BodyElementMap extends Map<BodyElementReference, AnyBodyElementDef
         [k: string]: AnyBodyElementDefinition;
     };
 }
+declare const bodyClassParser: TokenListParser<"pages", "pages">;
+export type BodyClassList = ParsedTokenList<typeof bodyClassParser>;
 export declare class BodyDefinition extends DependencyContext {
     protected readonly form: XFormDefinition;
     static getChildElementDefinitions(form: XFormDefinition, parent: BodyElementParentContext, parentElement: Element, children?: readonly Element[]): readonly AnyBodyElementDefinition[];
     readonly element: Element;
+    /**
+     * @todo this class is already an oddity in that it's **like** an element
+     * definition, but it isn't one itself. Adding this property here emphasizes
+     * that awkwardness. It also extends the applicable scope where instances of
+     * this class are accessed. While it's still ephemeral, it's anticipated that
+     * this extension might cause some disomfort. If so, the most plausible
+     * alternative is an additional refactor to:
+     *
+     * 1. Introduce a `BodyElementDefinition` sublass for `<h:body>`.
+     * 2. Disambiguate the respective names of those, in some reasonable way.
+     * 3. Add a layer of indirection between this class and that new body element
+     *    definition's class.
+     * 4. At that point, we may as well prioritize the little bit of grunt work to
+     *    pass the `BodyDefinition` instance by reference rather than assigning it
+     *    to anything.
+     */
+    readonly classes: BodyClassList;
     readonly elements: readonly AnyBodyElementDefinition[];
     protected readonly elementsByReference: BodyElementMap;
     readonly parentReference: null;
     readonly reference: string;
     constructor(form: XFormDefinition);
     getBodyElement(reference: string): AnyBodyElementDefinition | null;
-    getRepeatGroup(reference: string): RepeatGroupDefinition | null;
-    toJSON(): Omit<this, "toJSON" | "form" | "isTranslated" | "registerDependentExpression" | "dependencyExpressions" | "getBodyElement" | "getRepeatGroup">;
+    toJSON(): Omit<this, "toJSON" | "form" | "isTranslated" | "registerDependentExpression" | "dependencyExpressions" | "getBodyElement">;
 }
 export {};

package/dist/body/BodyElementDefinition.d.ts

@@ -1,8 +1,9 @@
-import type { XFormDefinition } from '../XFormDefinition.ts';
+import { XFormDefinition } from '../XFormDefinition.ts';
 import { DependencyContext } from '../expression/DependencyContext.ts';
-import type { BodyElementParentContext } from './BodyDefinition.ts';
-import type { HintDefinition } from './text/HintDefinition.ts';
-import type { LabelDefinition } from './text/LabelDefinition.ts';
+import { BodyElementParentContext } from './BodyDefinition.ts';
+import { HintDefinition } from './text/HintDefinition.ts';
+import { LabelDefinition } from './text/LabelDefinition.ts';
+
 /**
  * These category names roughly correspond to each of the ODK XForms spec's
  * {@link https://getodk.github.io/xforms-spec/#body-elements | Body Elements}

package/dist/body/RepeatElementDefinition.d.ts

@@ -0,0 +1,19 @@
+import { XFormDefinition } from '../XFormDefinition.ts';
+import { BodyElementDefinitionArray, BodyElementParentContext } from './BodyDefinition.ts';
+import { BodyElementDefinition } from './BodyElementDefinition.ts';
+import { StructureElementAppearanceDefinition } from './appearance/structureElementAppearanceParser.ts';
+import { LabelDefinition } from './text/LabelDefinition.ts';
+
+export declare class RepeatElementDefinition extends BodyElementDefinition<'repeat'> {
+    static isCompatible(localName: string): boolean;
+    readonly category = "structure";
+    readonly type = "repeat";
+    readonly reference: string;
+    readonly appearances: StructureElementAppearanceDefinition;
+    readonly label: LabelDefinition | null;
+    readonly countExpression: string | null;
+    readonly isFixedCount: boolean;
+    readonly children: BodyElementDefinitionArray;
+    constructor(form: XFormDefinition, parent: BodyElementParentContext, element: Element);
+    toJSON(): Omit<this, "toJSON" | "form" | "parent" | "isTranslated" | "registerDependentExpression" | "dependencyExpressions">;
+}

package/dist/body/UnsupportedBodyElementDefinition.d.ts

@@ -1,6 +1,7 @@
-import type { XFormDefinition } from '../XFormDefinition.ts';
-import type { BodyElementParentContext } from './BodyDefinition.ts';
+import { XFormDefinition } from '../XFormDefinition.ts';
+import { BodyElementParentContext } from './BodyDefinition.ts';
 import { BodyElementDefinition } from './BodyElementDefinition.ts';
+
 export declare class UnsupportedBodyElementDefinition extends BodyElementDefinition<'UNSUPPORTED'> {
     static isCompatible(): boolean;
     readonly category = "UNSUPPORTED";

package/dist/body/appearance/inputAppearanceParser.d.ts

@@ -0,0 +1,4 @@
+import { TokenListParser, ParsedTokenList } from '../../lib/TokenListParser.ts';
+
+export declare const inputAppearanceParser: TokenListParser<"multiline" | "numbers" | "url" | "thousand-sep" | "no-calendar" | "month-year" | "year" | "ethiopian" | "coptic" | "islamic" | "bikram-sambat" | "myanmar" | "persian" | "placement-map" | "maps" | "hidden-answer" | "annotate" | "draw" | "signature" | "new-front" | "new" | "front" | "printer" | "masked", "multiline" | "numbers" | "url" | "thousand-sep" | "no-calendar" | "month-year" | "year" | "ethiopian" | "coptic" | "islamic" | "bikram-sambat" | "myanmar" | "persian" | "placement-map" | "maps" | "hidden-answer" | "annotate" | "draw" | "signature" | "new-front" | "new" | "front" | "printer" | "masked">;
+export type InputAppearanceDefinition = ParsedTokenList<typeof inputAppearanceParser>;

package/dist/body/appearance/selectAppearanceParser.d.ts

@@ -0,0 +1,4 @@
+import { TokenListParser, ParsedTokenList } from '../../lib/TokenListParser.ts';
+
+export declare const selectAppearanceParser: TokenListParser<"map" | "label" | "compact" | "horizontal" | "horizontal-compact" | "list-nolabel" | "minimal" | "columns" | "columns-1" | "columns-2" | "columns-3" | "columns-4" | "columns-5" | "columns-pack" | "autocomplete" | "likert" | "quick" | "quickcompact", "autocomplete">;
+export type SelectAppearanceDefinition = ParsedTokenList<typeof selectAppearanceParser>;

package/dist/body/appearance/structureElementAppearanceParser.d.ts

@@ -0,0 +1,4 @@
+import { TokenListParser, ParsedTokenList } from '../../lib/TokenListParser.ts';
+
+export declare const structureElementAppearanceParser: TokenListParser<"field-list" | "table-list", "field-list" | "table-list">;
+export type StructureElementAppearanceDefinition = ParsedTokenList<typeof structureElementAppearanceParser>;

package/dist/body/control/ControlDefinition.d.ts

@@ -1,8 +1,10 @@
-import type { XFormDefinition } from '../../XFormDefinition.ts';
-import type { BodyElementParentContext } from '../BodyDefinition.ts';
+import { XFormDefinition } from '../../XFormDefinition.ts';
+import { ParsedTokenList } from '../../lib/TokenListParser.ts';
+import { BodyElementParentContext } from '../BodyDefinition.ts';
 import { BodyElementDefinition } from '../BodyElementDefinition.ts';
 import { HintDefinition } from '../text/HintDefinition.ts';
 import { LabelDefinition } from '../text/LabelDefinition.ts';
+
 type ControlType = 'input' | 'range' | 'rank' | 'select' | 'select1' | 'trigger' | 'upload';
 export declare abstract class ControlDefinition<Type extends ControlType> extends BodyElementDefinition<Type> {
     readonly category = "control";
@@ -10,6 +12,7 @@ export declare abstract class ControlDefinition<Type extends ControlType> extend
     readonly reference: string;
     readonly label: LabelDefinition | null;
     readonly hint: HintDefinition | null;
+    abstract readonly appearances: ParsedTokenList<any>;
     constructor(form: XFormDefinition, parent: BodyElementParentContext, element: Element);
 }
 export type AnyControlDefinition = ControlDefinition<any>;

package/dist/body/control/InputDefinition.d.ts

@@ -1,5 +1,11 @@
+import { XFormDefinition } from '../../XFormDefinition.ts';
+import { BodyElementParentContext } from '../BodyDefinition.ts';
+import { InputAppearanceDefinition } from '../appearance/inputAppearanceParser.ts';
 import { ControlDefinition } from './ControlDefinition.ts';
+
 export declare class InputDefinition extends ControlDefinition<'input'> {
     static isCompatible(localName: string): boolean;
     readonly type = "input";
+    readonly appearances: InputAppearanceDefinition;
+    constructor(form: XFormDefinition, parent: BodyElementParentContext, element: Element);
 }

package/dist/body/control/select/ItemDefinition.d.ts

@@ -1,8 +1,9 @@
-import { type ItemElement } from '../../../lib/dom/query.ts';
-import type { XFormDefinition } from '../../../XFormDefinition.ts';
+import { ItemElement } from '../../../lib/dom/query.ts';
+import { XFormDefinition } from '../../../XFormDefinition.ts';
 import { BodyElementDefinition } from '../../BodyElementDefinition.ts';
 import { LabelDefinition } from '../../text/LabelDefinition.ts';
-import type { AnySelectDefinition } from './SelectDefinition.ts';
+import { AnySelectDefinition } from './SelectDefinition.ts';
+
 export declare class ItemDefinition extends BodyElementDefinition<'item'> {
     readonly parent: AnySelectDefinition;
     readonly category = "support";

package/dist/body/control/select/ItemsetDefinition.d.ts

@@ -1,10 +1,11 @@
-import { type ItemsetElement } from '../../../lib/dom/query.ts';
-import type { XFormDefinition } from '../../../XFormDefinition.ts';
+import { ItemsetElement } from '../../../lib/dom/query.ts';
+import { XFormDefinition } from '../../../XFormDefinition.ts';
 import { BodyElementDefinition } from '../../BodyElementDefinition.ts';
 import { LabelDefinition } from '../../text/LabelDefinition.ts';
 import { ItemsetNodesetExpression } from './ItemsetNodesetExpression.ts';
 import { ItemsetValueExpression } from './ItemsetValueExpression.ts';
-import type { AnySelectDefinition } from './SelectDefinition.ts';
+import { AnySelectDefinition } from './SelectDefinition.ts';
+
 export declare class ItemsetDefinition extends BodyElementDefinition<'itemset'> {
     readonly category = "support";
     readonly type = "itemset";

package/dist/body/control/select/ItemsetNodesetContext.d.ts

@@ -1,6 +1,7 @@
 import { DependencyContext } from '../../../expression/DependencyContext.ts';
-import type { AnyDependentExpression } from '../../../expression/DependentExpression.ts';
-import type { ItemsetDefinition } from './ItemsetDefinition.ts';
+import { AnyDependentExpression } from '../../../expression/DependentExpression.ts';
+import { ItemsetDefinition } from './ItemsetDefinition.ts';
+
 export declare class ItemsetNodesetContext extends DependencyContext {
     protected readonly itemset: ItemsetDefinition;
     readonly parentReference: null;

package/dist/body/control/select/ItemsetNodesetExpression.d.ts

@@ -1,5 +1,6 @@
 import { DependentExpression } from '../../../expression/DependentExpression.ts';
-import type { ItemsetDefinition } from './ItemsetDefinition.ts';
+import { ItemsetDefinition } from './ItemsetDefinition.ts';
+
 export declare class ItemsetNodesetExpression extends DependentExpression<'nodes'> {
     constructor(itemset: ItemsetDefinition, nodesetExpression: string);
 }

package/dist/body/control/select/ItemsetValueExpression.d.ts

@@ -1,5 +1,6 @@
 import { DependentExpression } from '../../../expression/DependentExpression.ts';
-import type { ItemsetDefinition } from './ItemsetDefinition.ts';
+import { ItemsetDefinition } from './ItemsetDefinition.ts';
+
 export declare class ItemsetValueExpression extends DependentExpression<'string'> {
     readonly itemset: ItemsetDefinition;
     constructor(itemset: ItemsetDefinition, expression: string);

package/dist/body/control/select/SelectDefinition.d.ts

@@ -1,11 +1,21 @@
-import type { CollectionValues } from '../../../../../common/types/collections/CollectionValues.ts';
-import type { LocalNamedElement } from '../../../../../common/types/dom.ts';
-import type { XFormDefinition } from '../../../XFormDefinition.ts';
-import type { AnyBodyElementDefinition, BodyElementParentContext } from '../../BodyDefinition.ts';
+import { CollectionValues } from '../../../../../common/types/collections/CollectionValues.ts';
+import { LocalNamedElement } from '../../../../../common/types/dom.ts';
+import { XFormDefinition } from '../../../XFormDefinition.ts';
+import { AnyBodyElementDefinition, BodyElementParentContext } from '../../BodyDefinition.ts';
+import { SelectAppearanceDefinition } from '../../appearance/selectAppearanceParser.ts';
 import { ControlDefinition } from '../ControlDefinition.ts';
 import { ItemDefinition } from './ItemDefinition.ts';
 import { ItemsetDefinition } from './ItemsetDefinition.ts';
-declare const selectLocalNames: Set<"select" | "rank" | "select1">;
+
+/**
+ * @todo We were previously a bit overzealous about introducing `<rank>` support
+ * here. It'll likely still fit, but we should approach it with more intention.
+ *
+ * @todo `<trigger>` is *almost* reasonable to support here too. The main
+ * hesitation is that its single, implicit "item" does not have a distinct
+ * <label>, and presumably has different UX **and translation** considerations.
+ */
+declare const selectLocalNames: Set<"select" | "select1">;
 export type SelectType = CollectionValues<typeof selectLocalNames>;
 export interface SelectElement extends LocalNamedElement<SelectType> {
 }
@@ -14,6 +24,7 @@ export declare class SelectDefinition<Type extends SelectType> extends ControlDe
     static isSelect(element: AnyBodyElementDefinition): element is AnySelectDefinition;
     readonly type: Type;
     readonly element: SelectElement;
+    readonly appearances: SelectAppearanceDefinition;
     readonly itemset: ItemsetDefinition | null;
     readonly items: readonly ItemDefinition[];
     constructor(form: XFormDefinition, parent: BodyElementParentContext, element: Element);

package/dist/body/group/BaseGroupDefinition.d.ts

@@ -1,7 +1,9 @@
-import type { XFormDefinition } from '../../XFormDefinition.ts';
-import { type BodyElementDefinitionArray, type BodyElementParentContext } from '../BodyDefinition.ts';
+import { XFormDefinition } from '../../XFormDefinition.ts';
+import { BodyElementDefinitionArray, BodyElementParentContext } from '../BodyDefinition.ts';
 import { BodyElementDefinition } from '../BodyElementDefinition.ts';
+import { StructureElementAppearanceDefinition } from '../appearance/structureElementAppearanceParser.ts';
 import { LabelDefinition } from '../text/LabelDefinition.ts';
+
 /**
  * These type names are derived from **and expand upon** the language used in
  * the ODK XForms spec to describe various group usage. Whereas the spec
@@ -15,10 +17,6 @@ import { LabelDefinition } from '../text/LabelDefinition.ts';
  * - `presentation-group` is a group with a `<label>` child; its usage here
  *   differs from the spec language in that `presentation-group` does **not**
  *   have a `ref`
- * - `repeat-group` is not mentioned by the spec; it is an extension of
- *   `logical-group`, wherein its `ref` is the same as its immediate `<repeat>`
- *   child's `nodeset` (usage of each attribute is normalized during
- *   initialization, in {@link XFormDOM})
  * - `structural-group` is any `<group>` element which does not satisfy any of
  *   the other usage scenarios; this isn't exactly the terminology used, but is
  *   the most closely fitting name for the concept where the other sceanarios
@@ -26,21 +24,19 @@ import { LabelDefinition } from '../text/LabelDefinition.ts';
  *
  * A more succinct decision tree:
  *
- * - `<group ref="$ref"><repeat nodeset="$ref">` -> `repeat-group`, else
  * - `<group ref="$ref">` -> `logical-group`, else
  * - `<group><label>` -> `presentation-group`, else
  * - `<group>` -> `structural-group`
  */
-export type GroupType = 'logical-group' | 'presentation-group' | 'repeat-group' | 'structural-group';
+export type GroupType = 'logical-group' | 'presentation-group' | 'structural-group';
 export declare abstract class BaseGroupDefinition<Type extends GroupType> extends BodyElementDefinition<Type> {
     private static groupTypes;
     protected static getGroupType(localName: string, element: Element): GroupType | null;
     readonly category = "structure";
     readonly children: BodyElementDefinitionArray;
     readonly reference: string | null;
+    readonly appearances: StructureElementAppearanceDefinition;
     readonly label: LabelDefinition | null;
     constructor(form: XFormDefinition, parent: BodyElementParentContext, element: Element, children?: BodyElementDefinitionArray);
     getChildren(element: Element): BodyElementDefinitionArray;
 }
-export declare const repeatGroup: <T extends BaseGroupDefinition<any>>(groupDefinition: T) => Extract<T, BaseGroupDefinition<"repeat-group">> | null;
-export declare const nonRepeatGroup: <T extends BaseGroupDefinition<any>>(groupDefinition: T) => Exclude<T, BaseGroupDefinition<"repeat-group">> | null;

package/dist/body/group/LogicalGroupDefinition.d.ts

@@ -1,4 +1,5 @@
 import { BaseGroupDefinition } from './BaseGroupDefinition.ts';
+
 export declare class LogicalGroupDefinition extends BaseGroupDefinition<'logical-group'> {
     static isCompatible(localName: string, element: Element): boolean;
     readonly type = "logical-group";

package/dist/body/group/PresentationGroupDefinition.d.ts

@@ -1,7 +1,8 @@
-import type { XFormDefinition } from '../../XFormDefinition.ts';
-import type { BodyElementParentContext } from '../BodyDefinition.ts';
+import { XFormDefinition } from '../../XFormDefinition.ts';
+import { BodyElementParentContext } from '../BodyDefinition.ts';
 import { LabelDefinition } from '../text/LabelDefinition.ts';
 import { BaseGroupDefinition } from './BaseGroupDefinition.ts';
+
 export declare class PresentationGroupDefinition extends BaseGroupDefinition<'presentation-group'> {
     static isCompatible(localName: string, element: Element): boolean;
     readonly type = "presentation-group";

package/dist/body/group/StructuralGroupDefinition.d.ts

@@ -1,4 +1,5 @@
 import { BaseGroupDefinition } from './BaseGroupDefinition.ts';
+
 export declare class StructuralGroupDefinition extends BaseGroupDefinition<'structural-group'> {
     static isCompatible(localName: string, element: Element): boolean;
     readonly type = "structural-group";

package/dist/body/text/HintDefinition.d.ts

@@ -1,7 +1,7 @@
-import type { XFormDefinition } from '../../XFormDefinition.ts';
-import type { AnyControlDefinition } from '../control/ControlDefinition.ts';
-import type { TextElement } from './TextElementDefinition.ts';
-import { TextElementDefinition } from './TextElementDefinition.ts';
+import { XFormDefinition } from '../../XFormDefinition.ts';
+import { AnyControlDefinition } from '../control/ControlDefinition.ts';
+import { TextElement, TextElementDefinition } from './TextElementDefinition.ts';
+
 export interface HintElement extends TextElement {
     readonly localName: 'hint';
 }

package/dist/body/text/LabelDefinition.d.ts

@@ -1,10 +1,11 @@
-import type { XFormDefinition } from '../../XFormDefinition.ts';
-import type { AnyControlDefinition } from '../control/ControlDefinition.ts';
-import type { ItemDefinition } from '../control/select/ItemDefinition.ts';
-import type { ItemsetDefinition } from '../control/select/ItemsetDefinition.ts';
-import type { BaseGroupDefinition } from '../group/BaseGroupDefinition.ts';
-import type { TextElement, TextElementOwner } from './TextElementDefinition.ts';
-import { TextElementDefinition } from './TextElementDefinition.ts';
+import { XFormDefinition } from '../../XFormDefinition.ts';
+import { AnyControlDefinition } from '../control/ControlDefinition.ts';
+import { ItemDefinition } from '../control/select/ItemDefinition.ts';
+import { ItemsetDefinition } from '../control/select/ItemsetDefinition.ts';
+import { BaseGroupDefinition } from '../group/BaseGroupDefinition.ts';
+import { RepeatElementDefinition } from '../RepeatElementDefinition.ts';
+import { TextElement, TextElementOwner, TextElementDefinition } from './TextElementDefinition.ts';
+
 export interface LabelElement extends TextElement {
     readonly localName: 'label';
 }
@@ -12,6 +13,7 @@ type StaticLabelContext = Exclude<TextElementOwner, ItemsetDefinition>;
 export declare class LabelDefinition extends TextElementDefinition<'label'> {
     protected static staticDefinition(form: XFormDefinition, definition: StaticLabelContext): LabelDefinition | null;
     static forControl(form: XFormDefinition, control: AnyControlDefinition): LabelDefinition | null;
+    static forRepeatGroup(form: XFormDefinition, repeat: RepeatElementDefinition): LabelDefinition | null;
     static forGroup(form: XFormDefinition, group: BaseGroupDefinition<any>): LabelDefinition | null;
     static forItem(form: XFormDefinition, item: ItemDefinition): LabelDefinition | null;
     static forItemset(form: XFormDefinition, itemset: ItemsetDefinition): LabelDefinition | null;

package/dist/body/text/TextElementDefinition.d.ts

@@ -1,19 +1,20 @@
-import type { XFormDefinition } from '../../XFormDefinition.ts';
-import { type AnyDependentExpression } from '../../expression/DependentExpression.ts';
-import type { AnyGroupElementDefinition } from '../BodyDefinition.ts';
+import { XFormDefinition } from '../../XFormDefinition.ts';
+import { AnyDependentExpression } from '../../expression/DependentExpression.ts';
+import { AnyGroupElementDefinition } from '../BodyDefinition.ts';
 import { BodyElementDefinition } from '../BodyElementDefinition.ts';
-import type { InputDefinition } from '../control/InputDefinition.ts';
-import type { ItemDefinition } from '../control/select/ItemDefinition.ts';
-import type { ItemsetDefinition } from '../control/select/ItemsetDefinition.ts';
-import type { AnySelectDefinition } from '../control/select/SelectDefinition.ts';
+import { RepeatElementDefinition } from '../RepeatElementDefinition.ts';
+import { AnyControlDefinition } from '../control/ControlDefinition.ts';
+import { ItemDefinition } from '../control/select/ItemDefinition.ts';
+import { ItemsetDefinition } from '../control/select/ItemsetDefinition.ts';
 import { TextElementOutputPart } from './TextElementOutputPart.ts';
 import { TextElementReferencePart } from './TextElementReferencePart.ts';
 import { TextElementStaticPart } from './TextElementStaticPart.ts';
+
 export type TextElementType = 'hint' | 'label';
 export interface TextElement extends Element {
     readonly localName: TextElementType;
 }
-export type TextElementOwner = AnyGroupElementDefinition | AnySelectDefinition | InputDefinition | ItemDefinition | ItemsetDefinition;
+export type TextElementOwner = AnyControlDefinition | AnyGroupElementDefinition | ItemDefinition | ItemsetDefinition | RepeatElementDefinition;
 export type TextElementChild = TextElementOutputPart | TextElementStaticPart;
 export declare abstract class TextElementDefinition<Type extends TextElementType> extends BodyElementDefinition<Type> {
     readonly owner: TextElementOwner;

package/dist/body/text/TextElementOutputPart.d.ts

@@ -1,5 +1,6 @@
-import type { AnyTextElementDefinition } from './TextElementDefinition.ts';
+import { AnyTextElementDefinition } from './TextElementDefinition.ts';
 import { TextElementPart } from './TextElementPart.ts';
+
 interface OutputElement extends Element {
     readonly localName: 'output';
     getAttribute(name: 'value'): string;

package/dist/body/text/TextElementPart.d.ts

@@ -1,8 +1,9 @@
 import { DependentExpression } from '../../expression/DependentExpression.ts';
-import type { AnyTextElementDefinition } from './TextElementDefinition.ts';
-import type { TextElementOutputPart } from './TextElementOutputPart.ts';
-import type { TextElementReferencePart } from './TextElementReferencePart.ts';
-import type { TextElementStaticPart } from './TextElementStaticPart.ts';
+import { AnyTextElementDefinition } from './TextElementDefinition.ts';
+import { TextElementOutputPart } from './TextElementOutputPart.ts';
+import { TextElementReferencePart } from './TextElementReferencePart.ts';
+import { TextElementStaticPart } from './TextElementStaticPart.ts';
+
 export type TextElementPartType = 'output' | 'reference' | 'static';
 export declare abstract class TextElementPart<Type extends TextElementPartType> extends DependentExpression<'string'> {
     readonly type: Type;

package/dist/body/text/TextElementReferencePart.d.ts

@@ -1,5 +1,6 @@
-import type { AnyTextElementDefinition, TextElement } from './TextElementDefinition.ts';
+import { AnyTextElementDefinition, TextElement } from './TextElementDefinition.ts';
 import { TextElementPart } from './TextElementPart.ts';
+
 export declare class TextElementReferencePart extends TextElementPart<'reference'> {
     static from(context: AnyTextElementDefinition, element: TextElement): TextElementReferencePart | null;
     protected constructor(context: AnyTextElementDefinition, expression: string);

package/dist/body/text/TextElementStaticPart.d.ts

@@ -1,5 +1,6 @@
-import type { AnyTextElementDefinition } from './TextElementDefinition.ts';
+import { AnyTextElementDefinition } from './TextElementDefinition.ts';
 import { TextElementPart } from './TextElementPart.ts';
+
 export declare class TextElementStaticPart extends TextElementPart<'static'> {
     readonly stringValue: string;
     constructor(context: AnyTextElementDefinition, node: Text);

package/dist/client/BaseNode.d.ts

@@ -1,6 +1,8 @@
-import type { AnyNodeDefinition } from '../model/NodeDefinition.ts';
-import type { InstanceNodeType } from './node-types.js';
-import type { TextRange } from './TextRange.ts';
+import { AnyNodeDefinition } from '../model/NodeDefinition.ts';
+import { NodeAppearances } from './NodeAppearances.ts';
+import { TextRange } from './TextRange.ts';
+import { InstanceNodeType } from './node-types.ts';
+
 export interface BaseNodeState {
     /**
      * Location path reference to the node's primary instance state. This property
@@ -107,6 +109,10 @@ export interface BaseNode {
      * the lifetime of an active session filling a form.
      */
     readonly nodeId: FormNodeID;
+    /**
+     * @see {@link TokenListParser} for details.
+     */
+    readonly appearances: NodeAppearances<any> | null;
     /**
      * Each node has a definition which specifies aspects of the node defined in
      * the form. These aspects include (but are not limited to) the node's data

package/dist/client/EngineConfig.d.ts

@@ -1,4 +1,5 @@
-import type { OpaqueReactiveObjectFactory } from './OpaqueReactiveObjectFactory.ts';
+import { OpaqueReactiveObjectFactory } from './OpaqueReactiveObjectFactory.ts';
+
 /**
  * @todo this is currently a strict subset of the web standard `Response`. Is it
  * sufficient? Ways it might not be:

package/dist/client/GroupNode.d.ts

@@ -1,8 +1,10 @@
-import type { NonRepeatGroupElementDefinition } from '../body/BodyDefinition.ts';
-import type { SubtreeDefinition } from '../model/SubtreeDefinition.ts';
-import type { BaseNode, BaseNodeState } from './BaseNode.ts';
-import type { RootNode } from './RootNode.ts';
-import type { GeneralChildNode, GeneralParentNode } from './hierarchy.ts';
+import { AnyGroupElementDefinition } from '../body/BodyDefinition.ts';
+import { SubtreeDefinition } from '../model/SubtreeDefinition.ts';
+import { BaseNode, BaseNodeState } from './BaseNode.ts';
+import { NodeAppearances } from './NodeAppearances.ts';
+import { RootNode } from './RootNode.ts';
+import { GeneralChildNode, GeneralParentNode } from './hierarchy.ts';
+
 export interface GroupNodeState extends BaseNodeState {
     get hint(): null;
     get children(): readonly GeneralChildNode[];
@@ -10,13 +12,15 @@ export interface GroupNodeState extends BaseNodeState {
     get value(): null;
 }
 export interface GroupDefinition extends SubtreeDefinition {
-    readonly bodyElement: NonRepeatGroupElementDefinition;
+    readonly bodyElement: AnyGroupElementDefinition;
 }
+export type GroupNodeAppearances = NodeAppearances<GroupDefinition>;
 /**
  * A node corresponding to an XForms `<group>`.
  */
 export interface GroupNode extends BaseNode {
     readonly nodeType: 'group';
+    readonly appearances: GroupNodeAppearances;
     readonly definition: GroupDefinition;
     readonly root: RootNode;
     readonly parent: GeneralParentNode;

package/dist/client/NodeAppearances.d.ts

@@ -0,0 +1,15 @@
+import { ParsedTokenList } from '../lib/TokenListParser.ts';
+import { NodeDefinition } from '../model/NodeDefinition.ts';
+
+/**
+ * - Provides a means to distinguish between internal and client-facing names
+ *   for the same {@link ParsedTokenList} types.
+ *
+ * - Anticipates some iteration on both parsed ("definition") types and
+ *   client-facing node types, which may not happen in tandem.
+ */
+export type NodeAppearances<Definition extends NodeDefinition<any>> = Definition extends {
+    readonly bodyElement: {
+        readonly appearances: infer Appearances extends ParsedTokenList<any>;
+    };
+} ? Appearances : null;

package/dist/client/RepeatInstanceNode.d.ts

@@ -1,9 +1,11 @@
-import type { RepeatInstanceDefinition } from '../model/RepeatInstanceDefinition.ts';
-import type { RepeatTemplateDefinition } from '../model/RepeatTemplateDefinition.ts';
-import type { BaseNode, BaseNodeState } from './BaseNode.ts';
-import type { RepeatRangeNode } from './RepeatRangeNode.ts';
-import type { RootNode } from './RootNode.ts';
-import type { GeneralChildNode } from './hierarchy.ts';
+import { RepeatInstanceDefinition } from '../model/RepeatInstanceDefinition.ts';
+import { RepeatTemplateDefinition } from '../model/RepeatTemplateDefinition.ts';
+import { BaseNode, BaseNodeState } from './BaseNode.ts';
+import { NodeAppearances } from './NodeAppearances.ts';
+import { RepeatRangeNode } from './RepeatRangeNode.ts';
+import { RootNode } from './RootNode.ts';
+import { GeneralChildNode } from './hierarchy.ts';
+
 export interface RepeatInstanceNodeState extends BaseNodeState {
     get hint(): null;
     get children(): readonly GeneralChildNode[];
@@ -11,8 +13,10 @@ export interface RepeatInstanceNodeState extends BaseNodeState {
     get value(): null;
 }
 export type RepeatDefinition = RepeatInstanceDefinition | RepeatTemplateDefinition;
+export type RepeatInstanceNodeAppearances = NodeAppearances<RepeatDefinition>;
 export interface RepeatInstanceNode extends BaseNode {
     readonly nodeType: 'repeat-instance';
+    readonly appearances: RepeatInstanceNodeAppearances;
     readonly definition: RepeatDefinition;
     readonly root: RootNode;
     /**