@getodk/xforms-engine 0.5.0 → 0.7.0

package/dist/instance/resource.d.ts

@@ -1,4 +1,4 @@
-import { FormResource } from '../client/index.ts';
+import { FormResource } from '../client/form/FormResource.ts';
 import { FetchResource, FetchResourceResponse } from '../client/resources.ts';
 export type { FetchResource, FetchResourceResponse, FormResource };
 export interface ResourceOptions {
@@ -8,3 +8,7 @@ declare const resourceXMLPrefix = "<";
 type ResourceXMLPrefix = typeof resourceXMLPrefix;
 type ResourceXML = `${ResourceXMLPrefix}${string}`;
 export declare const retrieveSourceXMLResource: (resource: FormResource, options: ResourceOptions) => Promise<ResourceXML>;
+interface RetrieveFormDefinitionOptions {
+    readonly fetchFormDefinition: FetchResource;
+}
+export declare const retrieveFormDefinition: (resource: FormResource, options: RetrieveFormDefinitionOptions) => Promise<ResourceXML>;

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

@@ -1,6 +1,34 @@
-import { UnsupportedControl } from '../abstract/UnsupportedControl.ts';
-import { ValueContext } from '../internal-api/ValueContext.ts';
-export declare class UploadControl extends UnsupportedControl<'upload'> implements ValueContext<unknown> {
+import { XPathNodeKindKey } from '@getodk/xpath';
+import { Accessor } from 'solid-js';
+import { TextRange } from '../../client/TextRange.ts';
+import { ValueType } from '../../client/ValueType.ts';
+import { UploadNode, UploadNodeDefinition } from '../../client/unsupported/UploadNode.ts';
+import { XFormsXPathElement } from '../../integration/xpath/adapter/XFormsXPathNode.ts';
+import { StaticLeafElement } from '../../integration/xpath/static-dom/StaticElement.ts';
+import { TempUnsupportedInputValue, TempUnsupportedRuntimeValue } from '../../lib/codecs/TempUnsupportedControlCodec.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 { UnknownAppearanceDefinition } from '../../parse/body/appearance/unknownAppearanceParser.ts';
+import { ValueNode, ValueNodeStateSpec } from '../abstract/ValueNode.ts';
+import { GeneralParentNode } from '../hierarchy.ts';
+import { EvaluationContext } from '../internal-api/EvaluationContext.ts';
+import { ValidationContext } from '../internal-api/ValidationContext.ts';
+import { ClientReactiveSerializableValueNode } from '../internal-api/serialization/ClientReactiveSerializableValueNode.ts';
+interface UploadControlStateSpec extends ValueNodeStateSpec<TempUnsupportedRuntimeValue> {
+    readonly label: Accessor<TextRange<'label'> | null>;
+    readonly hint: Accessor<TextRange<'hint'> | null>;
+    readonly valueOptions: null;
+}
+export declare class UploadControl extends ValueNode<ValueType, UploadNodeDefinition, TempUnsupportedRuntimeValue, TempUnsupportedInputValue> implements UploadNode, XFormsXPathElement, EvaluationContext, ValidationContext, ClientReactiveSerializableValueNode {
+    readonly [XPathNodeKindKey] = "element";
+    protected readonly state: SharedNodeState<UploadControlStateSpec>;
+    protected readonly engineState: EngineState<UploadControlStateSpec>;
     readonly nodeType = "upload";
-    readonly contextNode: this;
+    readonly appearances: UnknownAppearanceDefinition;
+    readonly nodeOptions: null;
+    readonly currentState: CurrentState<UploadControlStateSpec>;
+    constructor(parent: GeneralParentNode, instanceNode: StaticLeafElement | null, definition: UploadNodeDefinition);
+    setValue(_: never): never;
 }
+export {};

package/dist/integration/xpath/EngineXPathEvaluator.d.ts

@@ -1,7 +1,7 @@
 import { XFormsItextTranslationMap, XFormsSecondaryInstanceMap, XFormsXPathEvaluator } from '@getodk/xpath';
 import { PrimaryInstance } from '../../instance/PrimaryInstance.ts';
-import { ItextTranslationRootDefinition } from '../../parse/model/ItextTranslation/ItextTranslationRootDefinition.ts';
-import { SecondaryInstanceRootDefinition } from '../../parse/model/SecondaryInstance/SecondaryInstanceRootDefinition.ts';
+import { ItextTranslationRootDefinition } from '../../parse/model/ItextTranslationsDefinition.ts';
+import { SecondaryInstanceRootDefinition } from '../../parse/model/SecondaryInstance/SecondaryInstancesDefinition.ts';
 import { EngineXPathNode } from './adapter/kind.ts';
 interface EngineXPathEvaluatorOptions {
     readonly rootNode: PrimaryInstance;

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

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

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

@@ -1,16 +1,6 @@
 import { EngineXPathNode } from './kind.ts';
 export declare const getEngineXPathNodeNamespaceURI: (node: EngineXPathNode) => string | null;
-/**
- * @todo currently, neither {@link InstanceNode} nor {@link StaticNode} account
- * for prefixes in qualified names. This was already a general enough gap that
- * it makes sense to defer to a broader solution as it becomes a priority
- * (likely prompted by a bug report about unexpected behavior of the XPath
- * `name` function).
- */
 export declare const getEngineXPathNodeQualifiedName: (node: EngineXPathNode) => string;
 export declare const getEngineXPathNodeLocalName: (node: EngineXPathNode) => string;
 export declare const getEngineProcessingInstructionName: () => never;
-/**
- * @todo @see {@link getNamespaceDeclarations}
- */
-export declare const resolveEngineXPathNodeNamespaceURI: (_: EngineXPathNode, prefix: string | null) => "http://www.w3.org/1999/xhtml" | "http://www.w3.org/2005/xpath-functions" | "http://openrosa.org/javarosa" | "http://www.opendatakit.org/xforms" | "http://openrosa.org/xforms" | "http://www.w3.org/2002/xforms" | "http://enketo.org/xforms" | null;
+export declare const resolveEngineXPathNodeNamespaceURI: (node: EngineXPathNode, prefix: string | null) => string | null;

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

@@ -2,16 +2,17 @@ import { EngineXPathAttribute, EngineXPathDocument, EngineXPathElement, EngineXP
 export declare const getContainingEngineXPathDocument: (node: EngineXPathNode) => EngineXPathDocument;
 export declare const getEngineXPathAttributes: (node: EngineXPathNode) => Iterable<EngineXPathAttribute>;
 /**
- * @todo XML XForms may actually define explicit namespace declarations on
- * non-root elements (i.e. elements other than the form definition's `h:html`,
- * itext `translation`, secondary `instance`). Expressions defined in such forms
- * may also expect to use those namespace declarations. It would even seem
- * likely! Why declare namespaces on a subtree if you don't intend to use them?
- * We don't currently capture namespace declarations below `h:html` in the parse
- * stage (which, if we intend to support the use case, is where we should
- * start).
+ * @todo We've now laid most of the groundwork necessary to implement this
+ * properly. At time of writing it has still been deferred because:
  *
- * @todo At the very least, we should probably produce a set of default namespace declarations. At least for `h:html`, maybe for other "root" nodes.
+ * 1. The scope of changes enabling it is already a fairly large yak shave.
+ * 2. It is only used to support XPath LocationPath Steps whose AxisName is
+ *    `namespace`. If we _ever_ support this, it would probably be for extremely
+ *    niche use cases!
+ *
+ * @todo Since we've consciously deferred implementing this (twice now!), should
+ * it throw? It might be nice to be alerted if the assumptions in point 2 above
+ * are somehow wrong (or become wrong).
  */
 export declare const getNamespaceDeclarations: () => Iterable<never>;
 export declare const getParentNode: (node: EngineXPathNode) => EngineXPathParentNode | null;

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

@@ -1,19 +1,25 @@
 import { XPathNodeKindKey } from '@getodk/xpath';
+import { QualifiedName } from '../../../lib/names/QualifiedName.ts';
 import { XFormsXPathAttribute } from '../adapter/XFormsXPathNode.ts';
+import { StaticDocument } from './StaticDocument.ts';
 import { StaticElement } from './StaticElement.ts';
-import { StaticNamedNodeOptions, StaticNamedNode } from './StaticNamedNode.ts';
-interface StaticAttributeOptions extends StaticNamedNodeOptions {
+import { StaticNode } from './StaticNode.ts';
+import { StaticNodeNameSource } from './staticNodeName.ts';
+export interface StaticAttributeOptions {
+    readonly name: StaticNodeNameSource;
     readonly value: string;
 }
-export declare class StaticAttribute extends StaticNamedNode<'attribute'> implements XFormsXPathAttribute {
+export declare class StaticAttribute extends StaticNode<'attribute'> implements XFormsXPathAttribute {
     readonly parent: StaticElement;
     readonly [XPathNodeKindKey] = "attribute";
     readonly nodeType = "static-attribute";
+    readonly rootDocument: StaticDocument;
     readonly root: StaticElement;
+    readonly qualifiedName: QualifiedName;
+    readonly nodeset: string;
     readonly attributes: readonly [];
     readonly children: null;
     readonly value: string;
     constructor(parent: StaticElement, options: StaticAttributeOptions);
     getXPathValue(): string;
 }
-export {};

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

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

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

@@ -1,24 +1,29 @@
-import { XFORMS_KNOWN_ATTRIBUTE, XFORMS_LOCAL_NAME, XPathNodeKindKey } from '@getodk/xpath';
+import { QualifiedNameSource, QualifiedName } from '../../../lib/names/QualifiedName.ts';
 import { XFormsXPathElement } from '../adapter/XFormsXPathNode.ts';
-import { StaticAttribute } from './StaticAttribute.ts';
-import { StaticNamedNodeOptions, StaticNamedNode } from './StaticNamedNode.ts';
-import { StaticChildNode, StaticParentNode } from './StaticNode.ts';
-export type StaticElementAttributesFactory = (element: StaticElement) => readonly StaticAttribute[];
-export type StaticElementChildNodesFactory = (element: StaticElement) => readonly StaticChildNode[];
-export interface StaticElementOptions extends StaticNamedNodeOptions {
+import { StaticAttributeOptions, StaticAttribute } from './StaticAttribute.ts';
+import { StaticDocument } from './StaticDocument.ts';
+import { StaticChildNode } from './StaticNode.ts';
+import { StaticParentNode } from './StaticParentNode.ts';
+export type StaticElementChildOption = StaticElementOptions | string;
+export interface StaticElementOptions {
+    readonly name: QualifiedNameSource | string;
+    readonly attributes?: readonly StaticAttributeOptions[];
+    readonly children?: readonly StaticElementChildOption[];
 }
-type StaticElementKnownAttributeValue<T extends StaticElement, LocalName extends string> = T extends {
-    readonly [XFORMS_KNOWN_ATTRIBUTE]: LocalName;
-} ? string : string | null;
-export declare class StaticElement<Parent extends StaticParentNode = StaticParentNode> extends StaticNamedNode<'element'> implements XFormsXPathElement {
-    readonly [XFORMS_LOCAL_NAME]?: string;
-    readonly [XFORMS_KNOWN_ATTRIBUTE]?: string;
-    readonly [XPathNodeKindKey] = "element";
-    readonly nodeType = "static-element";
+export declare class StaticElement extends StaticParentNode<'element'> implements XFormsXPathElement {
+    readonly parent: StaticDocument | StaticElement;
+    private computedValue;
+    readonly rootDocument: StaticDocument;
     readonly root: StaticElement;
+    readonly qualifiedName: QualifiedName;
+    readonly nodeset: string;
     readonly attributes: readonly StaticAttribute[];
     readonly children: readonly StaticChildNode[];
-    constructor(parent: Parent, attributesFactory: StaticElementAttributesFactory, childNodesFactory: StaticElementChildNodesFactory, options: StaticElementOptions);
+    readonly childElements: readonly StaticElement[];
+    readonly value: string | null;
+    constructor(parent: StaticDocument | StaticElement, options: StaticElementOptions);
+    isLeafElement(): this is StaticLeafElement;
+    assertLeafElement(): asserts this is StaticLeafElement;
     /**
      * @todo Generalize this, incorporate into {@link EngineDOMAdapter}
      * @todo Namespaced lookup
@@ -34,7 +39,9 @@ export declare class StaticElement<Parent extends StaticParentNode = StaticParen
      * up. (This was put off because the types are already plenty complex as it
      * is.)
      */
-    getAttributeValue<This extends StaticElement, LocalName extends string>(this: This, localName: LocalName): StaticElementKnownAttributeValue<This, LocalName>;
+    getAttributeValue(localName: string): string | null;
     getXPathValue(): string;
 }
-export {};
+export interface StaticLeafElement extends StaticElement {
+    readonly value: string;
+}

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

@@ -29,5 +29,5 @@ export declare abstract class StaticNode<Kind extends StaticNodeKind> implements
     abstract getXPathValue(): string;
 }
 export type AnyStaticNode = StaticDocument | StaticElement | StaticAttribute | StaticText;
-export type StaticParentNode = StaticDocument | StaticElement;
+export type StaticNodeParent = StaticDocument | StaticElement;
 export type StaticChildNode = StaticElement | StaticText;

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

@@ -0,0 +1,13 @@
+import { XPathNodeKindKey } from '@getodk/xpath';
+import { StaticElement } from './StaticElement.ts';
+import { StaticNode, StaticChildNode } from './StaticNode.ts';
+type StaticParentNodeKind = 'document' | 'element';
+type StaticParentNodeType<Kind extends StaticParentNodeKind> = `static-${Kind}`;
+export declare abstract class StaticParentNode<Kind extends StaticParentNodeKind> extends StaticNode<Kind> {
+    abstract readonly children: readonly StaticChildNode[];
+    abstract readonly childElements: readonly StaticElement[];
+    readonly [XPathNodeKindKey]: Kind;
+    readonly nodeType: StaticParentNodeType<Kind>;
+    constructor(kind: Kind);
+}
+export {};

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

@@ -0,0 +1,3 @@
+import { QualifiedName, QualifiedNameSource } from '../../../lib/names/QualifiedName.ts';
+export type StaticNodeNameSource = QualifiedName | QualifiedNameSource | string;
+export declare const staticNodeName: (source: StaticNodeNameSource) => QualifiedName;

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

@@ -0,0 +1,4 @@
+import { InstanceState } from '../../../client/serialization/InstanceState.ts';
+import { ClientReactiveSerializableParentNode } from '../../../instance/internal-api/serialization/ClientReactiveSerializableParentNode.ts';
+import { RepeatInstance } from '../../../instance/repeat/RepeatInstance.ts';
+export declare const createNodeRangeInstanceState: (node: ClientReactiveSerializableParentNode<RepeatInstance>) => InstanceState;

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

@@ -0,0 +1,4 @@
+import { InstanceState } from '../../../client/serialization/InstanceState.ts';
+import { GeneralChildNode } from '../../../instance/hierarchy.ts';
+import { ClientReactiveSerializableParentNode } from '../../../instance/internal-api/serialization/ClientReactiveSerializableParentNode.ts';
+export declare const createParentNodeInstanceState: (node: ClientReactiveSerializableParentNode<GeneralChildNode>) => InstanceState;

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

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

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

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

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

@@ -0,0 +1,6 @@
+import { InstanceState } from '../../../client/serialization/InstanceState.ts';
+import { ClientReactiveSerializableTemplatedNode } from '../../../instance/internal-api/serialization/ClientReactiveSerializableTemplatedNode.ts';
+/**
+ * @see {@link TemplatedNodeAttributeSerializationError}
+ */
+export declare const createTemplatedNodeInstanceState: (node: ClientReactiveSerializableTemplatedNode) => InstanceState;

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

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

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

@@ -0,0 +1,8 @@
+import { InstancePayload } from '../../../client/serialization/InstancePayload.ts';
+import { InstancePayloadType } from '../../../client/serialization/InstancePayloadOptions.ts';
+import { ClientReactiveSerializableInstance } from '../../../instance/internal-api/serialization/ClientReactiveSerializableInstance.ts';
+export interface PrepareInstancePayloadOptions<PayloadType extends InstancePayloadType> {
+    readonly payloadType: PayloadType;
+    readonly maxSize: number;
+}
+export declare const prepareInstancePayload: <PayloadType extends InstancePayloadType>(instanceRoot: ClientReactiveSerializableInstance, options: PrepareInstancePayloadOptions<PayloadType>) => InstancePayload<PayloadType>;

package/dist/lib/codecs/Geopoint/Geopoint.d.ts

@@ -0,0 +1,48 @@
+/**
+ * This abstract class defines the minimal behavior for a default geopoint.
+ * It can be expanded later to support units (e.g., degrees or meters),
+ * which would also serve as documentation to clarify what each value represents.
+ */
+declare abstract class SemanticValue<Semantic extends string, Value extends number | null> {
+    readonly value: Value;
+    abstract readonly semantic: Semantic;
+    constructor(value: Value);
+}
+declare class Latitude extends SemanticValue<'latitude', number> {
+    readonly semantic = "latitude";
+}
+declare class Longitude extends SemanticValue<'longitude', number> {
+    readonly semantic = "longitude";
+}
+declare class Altitude<Value extends number | null = number> extends SemanticValue<'altitude', Value> {
+    readonly semantic = "altitude";
+}
+declare class Accuracy<Value extends number | null = number> extends SemanticValue<'accuracy', Value> {
+    readonly semantic = "accuracy";
+}
+export interface GeopointValue {
+    readonly latitude: number;
+    readonly longitude: number;
+    readonly altitude: number | null;
+    readonly accuracy: number | null;
+}
+export type GeopointRuntimeValue = GeopointValue | null;
+export type GeopointInputValue = GeopointRuntimeValue | string;
+type GeopointTuple = readonly [
+    latitude: Latitude,
+    longitude: Longitude,
+    altitude: Altitude<null> | Altitude<number>,
+    accuracy: Accuracy
+] | readonly [latitude: Latitude, longitude: Longitude, altitude: Altitude] | readonly [latitude: Latitude, longitude: Longitude];
+export declare class Geopoint {
+    private readonly internalValue;
+    constructor(coordinates: GeopointValue);
+    getTuple(): GeopointTuple;
+    getRuntimeValue(): GeopointRuntimeValue;
+    private isValidDegrees;
+    private isValidNumber;
+    private static isNullLocation;
+    static parseString(value: string): GeopointRuntimeValue;
+    static toCoordinatesString(value: GeopointInputValue): string;
+}
+export {};

package/dist/lib/codecs/Geopoint/GeopointValueCodec.d.ts

@@ -0,0 +1,5 @@
+import { ValueCodec } from '../ValueCodec.ts';
+import { GeopointInputValue, GeopointRuntimeValue } from './Geopoint.ts';
+export declare class GeopointValueCodec extends ValueCodec<'geopoint', GeopointRuntimeValue, GeopointInputValue> {
+    constructor();
+}

package/dist/lib/codecs/NoteCodec.d.ts

@@ -0,0 +1,8 @@
+import { ValueType } from '../../client/ValueType.ts';
+import { RuntimeInputValue, RuntimeValue, SharedValueCodec } from './getSharedValueCodec.ts';
+import { ValueCodec } from './ValueCodec.ts';
+export type NoteRuntimeValue<V extends ValueType> = RuntimeValue<V> | null;
+export type NoteInputValue<V extends ValueType> = RuntimeInputValue<V> | RuntimeValue<V> | null;
+export declare class NoteCodec<V extends ValueType> extends ValueCodec<V, NoteRuntimeValue<V>, NoteInputValue<V>> {
+    constructor(baseCodec: SharedValueCodec<V>);
+}

package/dist/lib/codecs/RangeCodec.d.ts

@@ -0,0 +1,8 @@
+import { RangeNodeDefinition, RangeValueType } from '../../parse/model/RangeNodeDefinition.ts';
+import { RuntimeInputValue, RuntimeValue, SharedValueCodec } from './getSharedValueCodec.ts';
+import { ValueCodec } from './ValueCodec.ts';
+export type RangeRuntimeValue<V extends RangeValueType> = RuntimeValue<V>;
+export type RangeInputValue<V extends RangeValueType> = RuntimeInputValue<V>;
+export declare class RangeCodec<V extends RangeValueType> extends ValueCodec<V, RangeRuntimeValue<V>, RangeInputValue<V>> {
+    constructor(baseCodec: SharedValueCodec<V>, definition: RangeNodeDefinition<V>);
+}

package/dist/lib/codecs/TempUnsupportedControlCodec.d.ts

@@ -0,0 +1,7 @@
+import { ValueType } from '../../client/ValueType.ts';
+import { ValueCodec } from './ValueCodec.ts';
+export type TempUnsupportedRuntimeValue = unknown;
+export type TempUnsupportedInputValue = unknown;
+export declare class TempUnsupportedControlCodec<V extends ValueType> extends ValueCodec<V, TempUnsupportedRuntimeValue, TempUnsupportedInputValue> {
+    constructor(valueType: V);
+}

package/dist/lib/codecs/TriggerCodec.d.ts

@@ -0,0 +1,7 @@
+import { ValueCodec } from './ValueCodec.ts';
+export type TriggerValueType = 'string';
+export type TriggerRuntimeValue = boolean;
+export type TriggerInputValue = boolean | '' | null;
+export declare class TriggerCodec extends ValueCodec<TriggerValueType, TriggerRuntimeValue, TriggerInputValue> {
+    constructor();
+}

package/dist/lib/codecs/ValueArrayCodec.d.ts

@@ -0,0 +1,11 @@
+import { ValueType } from '../../client/ValueType.ts';
+import { RuntimeValue, SharedValueCodec } from './getSharedValueCodec.ts';
+import { CodecDecoder, CodecEncoder, ValueCodec } from './ValueCodec.ts';
+export type SplitInstanceValues = (value: string) => readonly string[];
+export type JoinInstnaceValues = (values: readonly string[]) => string;
+export type RuntimeItemValue<V extends ValueType> = NonNullable<RuntimeValue<V>>;
+export type RuntimeValues<V extends ValueType> = ReadonlyArray<RuntimeItemValue<V>>;
+export declare abstract class ValueArrayCodec<V extends ValueType, Values extends RuntimeValues<V> = RuntimeValues<V>> extends ValueCodec<V, Values, Values> {
+    readonly decodeItemValue: CodecDecoder<RuntimeItemValue<V>>;
+    constructor(baseCodec: SharedValueCodec<V>, encodeValue: CodecEncoder<Values>, decodeValue: CodecDecoder<Values>);
+}

package/dist/lib/codecs/ValueCodec.d.ts

@@ -2,8 +2,8 @@ import { Accessor } from 'solid-js';
 import { ValueType } from '../../client/ValueType.ts';
 import { DecodeInstanceValue } from '../../instance/internal-api/InstanceValueContext.ts';
 import { SimpleAtomicState } from '../reactivity/types.ts';
-type CodecEncoder<RuntimeInputValue> = (input: RuntimeInputValue) => string;
-type CodecDecoder<RuntimeValue> = (value: string) => RuntimeValue;
+export type CodecEncoder<RuntimeInputValue> = (input: RuntimeInputValue) => string;
+export type CodecDecoder<RuntimeValue> = (value: string) => RuntimeValue;
 type RuntimeValueAccessor<RuntimeValue> = Accessor<RuntimeValue>;
 export type RuntimeValueSetter<RuntimeValue extends RuntimeInputValue, RuntimeInputValue = RuntimeValue> = (input: RuntimeInputValue) => RuntimeValue;
 export type RuntimeValueState<RuntimeValue extends RuntimeInputValue, RuntimeInputValue = RuntimeValue> = readonly [

package/dist/lib/codecs/getNoteCodec.d.ts

@@ -0,0 +1,3 @@
+import { ValueType } from '../../client/ValueType.ts';
+import { NoteCodec } from './NoteCodec.ts';
+export declare const getNoteCodec: <V extends ValueType>(valueType: V) => NoteCodec<V>;

package/dist/lib/codecs/getSelectCodec.d.ts

@@ -0,0 +1,5 @@
+import { SelectDefinition } from '../../client/SelectNode.ts';
+import { MultipleValueItemCodec } from './items/MultipleValueItemCodec.ts';
+import { SingleValueItemCodec } from './items/SingleValueItemCodec.ts';
+export type SelectCodec = MultipleValueItemCodec | SingleValueItemCodec;
+export declare const getSelectCodec: (definition: SelectDefinition<"string">) => SelectCodec;

package/dist/lib/codecs/getSharedValueCodec.d.ts

@@ -1,5 +1,6 @@
 import { ValueType } from '../../client/ValueType.ts';
 import { DecimalInputValue, DecimalRuntimeValue } from './DecimalValueCodec.ts';
+import { GeopointInputValue, GeopointRuntimeValue } from './Geopoint/Geopoint.ts';
 import { IntInputValue, IntRuntimeValue } from './IntValueCodec.ts';
 import { ValueCodec } from './ValueCodec.ts';
 interface RuntimeValuesByType {
@@ -10,7 +11,7 @@ interface RuntimeValuesByType {
     readonly date: string;
     readonly time: string;
     readonly dateTime: string;
-    readonly geopoint: string;
+    readonly geopoint: GeopointRuntimeValue;
     readonly geotrace: string;
     readonly geoshape: string;
     readonly binary: string;
@@ -26,7 +27,7 @@ interface RuntimeInputValuesByType {
     readonly date: string;
     readonly time: string;
     readonly dateTime: string;
-    readonly geopoint: string;
+    readonly geopoint: GeopointInputValue;
     readonly geotrace: string;
     readonly geoshape: string;
     readonly binary: string;

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

@@ -0,0 +1,9 @@
+import { ValueType } from '../../../client/ValueType.ts';
+import { SharedValueCodec } from '../getSharedValueCodec.ts';
+import { ValueArrayCodec } from '../ValueArrayCodec.ts';
+import { CodecDecoder, CodecEncoder } from '../ValueCodec.ts';
+export type BaseItemValueType = 'string';
+export type UnsupportedBaseItemValueType = Exclude<ValueType, BaseItemValueType>;
+export declare abstract class BaseItemCodec<Values extends readonly string[] = readonly string[]> extends ValueArrayCodec<BaseItemValueType, Values> {
+    constructor(baseCodec: SharedValueCodec<'string'>, encodeValue: CodecEncoder<Values>, decodeValue: CodecDecoder<Values>);
+}

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

@@ -0,0 +1,14 @@
+import { SharedValueCodec } from '../getSharedValueCodec.ts';
+import { BaseItemCodec } from './BaseItemCodec.ts';
+/**
+ * Value codec implementation for `<select>` and `<odk:rank>` controls.
+ *
+ * This generalizes the application of a {@link SharedValueCodec} implementation
+ * over individual select and rank values, where those values are serialized as a
+ * whitespace-separated list. All other encoding and decoding logic is deferred
+ * to the provided {@link baseCodec}, ensuring that select and rank value types are
+ * treated consistently with the same underlying data types for other controls.
+ */
+export declare class MultipleValueItemCodec extends BaseItemCodec<readonly string[]> {
+    constructor(baseCodec: SharedValueCodec<'string'>);
+}

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

@@ -0,0 +1,24 @@
+import { SharedValueCodec } from '../getSharedValueCodec.ts';
+import { BaseItemCodec } from './BaseItemCodec.ts';
+export type SingleValueSelectRuntimeValues = readonly [] | readonly [string];
+/**
+ * @see {@link encodeValueFactory}
+ */
+type SingleValueSelectCodecValues = SingleValueSelectRuntimeValues | readonly string[];
+/**
+ * Value codec implementation for `<select1>` controls.
+ *
+ * Note: this implementation is a specialization of the same principles
+ * underlying {@link MultipleValueItemCodec}. It is implemented separately:
+ *
+ * 1. to address a semantic difference between `<select>` and `<select1>`
+ *    values: the former are serialized as a space-separated list, but that does
+ *    not apply to the latter;
+ *
+ * 2. as an optimization, as the more general implementation performs poorly on
+ *    forms which we monitor for performance.
+ */
+export declare class SingleValueItemCodec extends BaseItemCodec<SingleValueSelectCodecValues> {
+    constructor(baseCodec: SharedValueCodec<'string'>);
+}
+export {};

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

@@ -1,5 +1,4 @@
 import { KnownAttributeLocalNamedElement, LocalNamedElement } from '../../../../common/types/dom.ts';
-import { SelectElement } from '../../parse/body/control/select/SelectDefinition';
 export interface HintElement extends LocalNamedElement<'hint'> {
 }
 export interface ItemElement extends LocalNamedElement<'item'> {
@@ -17,7 +16,7 @@ export interface RepeatElement extends KnownAttributeLocalNamedElement<'repeat',
 export interface ValueElement extends LocalNamedElement<'value'> {
 }
 export declare const getHintElement: (parent: Element) => HintElement | null;
-export declare const getItemElements: (parent: SelectElement) => readonly ItemElement[];
+export declare const getItemElements: (parent: Element) => readonly ItemElement[];
 export declare const getItemsetElement: (parent: Element) => ItemsetElement | null;
 export declare const getLabelElement: (parent: Element) => LabelElement | null;
 export declare const getRepeatGroupLabelElement: (parent: Element) => RepeatGroupLabelElement | null;

package/dist/lib/names/NamespaceDeclaration.d.ts

@@ -0,0 +1,45 @@
+import { NamespaceURI } from './QualifiedName.ts';
+interface NamespaceDeclarationXMLSerializationOptions {
+    readonly omitDefaultNamespace?: boolean;
+}
+export interface NamespaceDeclarationOptions {
+    readonly declaredPrefix: string | null;
+    readonly declaredURI: NamespaceURI;
+}
+/**
+ * Provides a generalized representation of an XML namespace declaration, which
+ * can be used for:
+ *
+ * - Resolution of a declared namespace URI, by its declared prefix
+ * - Resolution of a declared namespace prefix associated with its namespace URI
+ * - Scoped resolution of same in an arbitrary DOM-like tree of nodes (or
+ *   representations thereof)
+ * - Serialization of the namespace declaration as an XML representation, as
+ *   part of broader XML serialization logic from an arbitrary DOM-like tree of
+ *   nodes (or representations thereof)
+ *
+ * @see {@link NamespaceDeclarationMap} for details on scoped usage
+ */
+export declare class NamespaceDeclaration {
+    private readonly serializedXML;
+    /**
+     * A namespace is declared as either:
+     *
+     * - a "default" namespace (for which no prefix is declared, in which case
+     *   this value will be `null`)
+     *
+     * - a namespace prefix (for which the prefix can be used to reference the
+     *   declared namespace, in which case this value will be a `string`)
+     */
+    readonly declaredPrefix: string | null;
+    /**
+     * A namespace is declared for a {@link NamespaceURI}, i.e. either a
+     * {@link URL} or `null`, where `null` corresponds to the "null namespace"
+     * (i.e. `xmlns=""` or `xmlns:prefix=""`, in serialized XML).
+     */
+    readonly declaredURI: NamespaceURI;
+    constructor(options: NamespaceDeclarationOptions);
+    declaresNamespaceURI(namespaceURI: NamespaceURI): boolean;
+    serializeNamespaceDeclarationXML(options?: NamespaceDeclarationXMLSerializationOptions): string;
+}
+export {};