@getodk/xforms-engine 0.6.0 → 0.7.0

package/src/integration/xpath/static-dom/StaticNode.ts

@@ -58,7 +58,7 @@ export type AnyStaticNode =
 	| StaticText;
 
 // prettier-ignore
-export type StaticParentNode =
+export type StaticNodeParent =
 	| StaticDocument
 	| StaticElement;
 

package/src/integration/xpath/static-dom/StaticParentNode.ts

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

package/src/integration/xpath/static-dom/staticNodeName.ts

@@ -0,0 +1,20 @@
+import { QualifiedName, type QualifiedNameSource } from '../../../lib/names/QualifiedName.ts';
+import { UnprefixedXFormsName } from '../../../lib/names/UnprefixedXFormsName.ts';
+
+// prettier-ignore
+export type StaticNodeNameSource =
+	| QualifiedName
+	| QualifiedNameSource
+	| string;
+
+export const staticNodeName = (source: StaticNodeNameSource): QualifiedName => {
+	if (source instanceof QualifiedName) {
+		return source;
+	}
+
+	if (typeof source === 'string') {
+		return new UnprefixedXFormsName(source);
+	}
+
+	return new QualifiedName(source);
+};

package/src/lib/client-reactivity/instance-state/createNodeRangeInstanceState.ts

@@ -0,0 +1,17 @@
+import type { InstanceState } from '../../../client/serialization/InstanceState.ts';
+import type { ClientReactiveSerializableParentNode } from '../../../instance/internal-api/serialization/ClientReactiveSerializableParentNode.ts';
+import type { RepeatInstance } from '../../../instance/repeat/RepeatInstance.ts';
+
+export const createNodeRangeInstanceState = (
+	node: ClientReactiveSerializableParentNode<RepeatInstance>
+): InstanceState => {
+	return {
+		get instanceXML() {
+			const serializedChildren = node.currentState.children.map((child) => {
+				return child.instanceState.instanceXML;
+			});
+
+			return serializedChildren.join('');
+		},
+	};
+};

package/src/lib/client-reactivity/instance-state/createParentNodeInstanceState.ts

@@ -0,0 +1,22 @@
+import type { InstanceState } from '../../../client/serialization/InstanceState.ts';
+import type { GeneralChildNode } from '../../../instance/hierarchy.ts';
+import type { ClientReactiveSerializableParentNode } from '../../../instance/internal-api/serialization/ClientReactiveSerializableParentNode.ts';
+import { serializeParentElementXML } from '../../xml-serialization.ts';
+
+export const createParentNodeInstanceState = (
+	node: ClientReactiveSerializableParentNode<GeneralChildNode>
+): InstanceState => {
+	return {
+		get instanceXML() {
+			if (!node.currentState.relevant) {
+				return '';
+			}
+
+			const serializedChildren = node.currentState.children.map((child) => {
+				return child.instanceState.instanceXML;
+			});
+
+			return serializeParentElementXML(node.definition.qualifiedName, serializedChildren);
+		},
+	};
+};

package/src/lib/client-reactivity/instance-state/createPrimaryInstanceState.ts

@@ -0,0 +1,12 @@
+import type { InstanceState } from '../../../client/serialization/InstanceState.ts';
+import type { ClientReactiveSerializableInstance } from '../../../instance/internal-api/serialization/ClientReactiveSerializableInstance.ts';
+
+export const createPrimaryInstanceState = (
+	node: ClientReactiveSerializableInstance
+): InstanceState => {
+	return {
+		get instanceXML(): string {
+			return node.root.instanceState.instanceXML;
+		},
+	};
+};

package/src/lib/client-reactivity/{submission/createRootSubmissionState.ts → instance-state/createRootInstanceState.ts}

@@ -1,13 +1,13 @@
-import type { SubmissionState } from '../../../client/submission/SubmissionState.ts';
+import type { InstanceState } from '../../../client/serialization/InstanceState.ts';
 import type { Root } from '../../../instance/Root.ts';
 import { serializeParentElementXML } from '../../xml-serialization.ts';
 
-export const createRootSubmissionState = (node: Root): SubmissionState => {
+export const createRootInstanceState = (node: Root): InstanceState => {
 	return {
-		get submissionXML() {
+		get instanceXML() {
 			const { namespaceDeclarations, attributes } = node.definition;
 			const serializedChildren = node.currentState.children.map((child) => {
-				return child.submissionState.submissionXML;
+				return child.instanceState.instanceXML;
 			});
 
 			return serializeParentElementXML(node.definition.qualifiedName, serializedChildren, {

package/src/lib/client-reactivity/instance-state/createTemplatedNodeInstanceState.ts

@@ -0,0 +1,31 @@
+import type { InstanceState } from '../../../client/serialization/InstanceState.ts';
+import { TemplatedNodeAttributeSerializationError } from '../../../error/TemplatedNodeAttributeSerializationError.ts';
+import type { ClientReactiveSerializableTemplatedNode } from '../../../instance/internal-api/serialization/ClientReactiveSerializableTemplatedNode.ts';
+import { serializeParentElementXML } from '../../xml-serialization.ts';
+
+/**
+ * @see {@link TemplatedNodeAttributeSerializationError}
+ */
+export const createTemplatedNodeInstanceState = (
+	node: ClientReactiveSerializableTemplatedNode
+): InstanceState => {
+	return {
+		get instanceXML() {
+			if (!node.currentState.relevant) {
+				return '';
+			}
+
+			const serializedChildren = node.currentState.children.map((child) => {
+				return child.instanceState.instanceXML;
+			});
+
+			const { attributes } = node.currentState;
+
+			if (attributes != null) {
+				throw new TemplatedNodeAttributeSerializationError();
+			}
+
+			return serializeParentElementXML(node.definition.qualifiedName, serializedChildren);
+		},
+	};
+};

package/src/lib/client-reactivity/instance-state/createValueNodeInstanceState.ts

@@ -0,0 +1,21 @@
+import type { InstanceState } from '../../../client/serialization/InstanceState.ts';
+import type { ClientReactiveSerializableValueNode } from '../../../instance/internal-api/serialization/ClientReactiveSerializableValueNode.ts';
+import { escapeXMLText, serializeLeafElementXML } from '../../xml-serialization.ts';
+
+export const createValueNodeInstanceState = (
+	node: ClientReactiveSerializableValueNode
+): InstanceState => {
+	const { qualifiedName } = node.definition;
+
+	return {
+		get instanceXML() {
+			if (!node.currentState.relevant) {
+				return '';
+			}
+
+			const xmlValue = escapeXMLText(node.currentState.instanceValue);
+
+			return serializeLeafElementXML(qualifiedName, xmlValue);
+		},
+	};
+};

package/src/lib/client-reactivity/instance-state/prepareInstancePayload.ts

@@ -0,0 +1,173 @@
+import { UnreachableError } from '@getodk/common/lib/error/UnreachableError.ts';
+import { INSTANCE_FILE_NAME, INSTANCE_FILE_TYPE } from '../../../client/constants.ts';
+import type { InstanceData as ClientInstanceData } from '../../../client/serialization/InstanceData.ts';
+import type { InstanceFile as ClientInstanceFile } from '../../../client/serialization/InstanceFile.ts';
+import type {
+	ChunkedInstancePayload,
+	InstancePayload,
+	MonolithicInstancePayload,
+} from '../../../client/serialization/InstancePayload.ts';
+import type { InstancePayloadType } from '../../../client/serialization/InstancePayloadOptions.ts';
+import type { SubmissionMeta } from '../../../client/submission/SubmissionMeta.ts';
+import type { DescendantNodeViolationReference } from '../../../client/validation.ts';
+import type { ClientReactiveSerializableInstance } from '../../../instance/internal-api/serialization/ClientReactiveSerializableInstance.ts';
+
+class InstanceFile extends File implements ClientInstanceFile {
+	override readonly name = INSTANCE_FILE_NAME;
+	override readonly type = INSTANCE_FILE_TYPE;
+
+	constructor(instanceRoot: ClientReactiveSerializableInstance) {
+		const { instanceXML } = instanceRoot.instanceState;
+
+		super([instanceXML], INSTANCE_FILE_NAME, {
+			type: INSTANCE_FILE_TYPE,
+		});
+	}
+}
+
+type AssertInstanceData = (data: FormData) => asserts data is ClientInstanceData;
+
+const assertInstanceData: AssertInstanceData = (data) => {
+	const instanceFile = data.get(INSTANCE_FILE_NAME);
+
+	if (!(instanceFile instanceof InstanceFile)) {
+		throw new Error(`Invalid InstanceData`);
+	}
+};
+
+class InstanceData extends FormData {
+	static from(instanceFile: InstanceFile, attachments: readonly File[]): ClientInstanceData {
+		const data = new this(instanceFile, attachments);
+
+		assertInstanceData(data);
+
+		return data;
+	}
+
+	private constructor(
+		readonly instanceFile: InstanceFile,
+		readonly attachments: readonly File[]
+	) {
+		super();
+
+		this.set(INSTANCE_FILE_NAME, instanceFile);
+
+		attachments.forEach((attachment) => {
+			const { name } = attachment;
+
+			if (name === INSTANCE_FILE_NAME && attachment !== instanceFile) {
+				throw new Error(`Failed to add conflicting attachment with name ${INSTANCE_FILE_NAME}`);
+			}
+
+			this.set(name, attachment);
+		});
+	}
+}
+
+interface PendingValidation {
+	readonly status: 'pending';
+	readonly violations: readonly DescendantNodeViolationReference[];
+}
+
+interface ReadyValidation {
+	readonly status: 'ready';
+	readonly violations: null;
+}
+
+type InstanceStateValidation = PendingValidation | ReadyValidation;
+
+const validateInstance = (
+	instanceRoot: ClientReactiveSerializableInstance
+): InstanceStateValidation => {
+	const { violations } = instanceRoot.validationState;
+
+	if (violations.length === 0) {
+		return {
+			status: 'ready',
+			violations: null,
+		};
+	}
+
+	return {
+		status: 'pending',
+		violations,
+	};
+};
+
+const monolithicInstancePayload = (
+	validation: InstanceStateValidation,
+	submissionMeta: SubmissionMeta,
+	instanceFile: InstanceFile,
+	attachments: readonly File[]
+): MonolithicInstancePayload => {
+	const data = InstanceData.from(instanceFile, attachments);
+
+	return {
+		payloadType: 'monolithic',
+		...validation,
+		submissionMeta,
+		data: [data],
+	};
+};
+
+interface ChunkedInstancePayloadOptions {
+	readonly maxSize: number;
+}
+
+const chunkedInstancePayload = (
+	validation: InstanceStateValidation,
+	submissionMeta: SubmissionMeta,
+	instanceFile: InstanceFile,
+	attachments: readonly File[],
+	options: ChunkedInstancePayloadOptions
+): ChunkedInstancePayload => {
+	if (attachments.length > 0 || options.maxSize !== Infinity) {
+		throw new Error('InstancePayload chunking pending implementation');
+	}
+
+	const data = InstanceData.from(instanceFile, attachments);
+
+	return {
+		payloadType: 'chunked',
+		...validation,
+		submissionMeta,
+		data: [data],
+	};
+};
+
+export interface PrepareInstancePayloadOptions<PayloadType extends InstancePayloadType> {
+	readonly payloadType: PayloadType;
+	readonly maxSize: number;
+}
+
+export const prepareInstancePayload = <PayloadType extends InstancePayloadType>(
+	instanceRoot: ClientReactiveSerializableInstance,
+	options: PrepareInstancePayloadOptions<PayloadType>
+): InstancePayload<PayloadType> => {
+	const validation = validateInstance(instanceRoot);
+	const submissionMeta = instanceRoot.definition.submission;
+	const instanceFile = new InstanceFile(instanceRoot);
+	const attachments: readonly File[] = [];
+
+	switch (options.payloadType) {
+		case 'chunked':
+			return chunkedInstancePayload(
+				validation,
+				submissionMeta,
+				instanceFile,
+				attachments,
+				options
+			) satisfies ChunkedInstancePayload as InstancePayload<PayloadType>;
+
+		case 'monolithic':
+			return monolithicInstancePayload(
+				validation,
+				submissionMeta,
+				instanceFile,
+				attachments
+			) satisfies MonolithicInstancePayload as InstancePayload<PayloadType>;
+
+		default:
+			throw new UnreachableError(options.payloadType);
+	}
+};

package/src/lib/codecs/TempUnsupportedControlCodec.ts

@@ -0,0 +1,32 @@
+import { identity } from '@getodk/common/lib/identity.ts';
+import type { ValueType } from '../../client/ValueType.ts';
+import { ValueCodec, type CodecDecoder, type CodecEncoder } from './ValueCodec.ts';
+
+class TempUnsupportedControlEncodeError extends Error {
+	constructor() {
+		super(`Cannot encode state: not implemented`);
+	}
+}
+
+export type TempUnsupportedRuntimeValue = unknown;
+export type TempUnsupportedInputValue = unknown;
+
+export class TempUnsupportedControlCodec<V extends ValueType> extends ValueCodec<
+	V,
+	TempUnsupportedRuntimeValue,
+	TempUnsupportedInputValue
+> {
+	constructor(valueType: V) {
+		const encodeValue: CodecEncoder<TempUnsupportedRuntimeValue> = (input): string => {
+			if (typeof input === 'string') {
+				return input;
+			}
+
+			throw new TempUnsupportedControlEncodeError();
+		};
+
+		const decodeValue: CodecDecoder<TempUnsupportedInputValue> = identity;
+
+		super(valueType, encodeValue, decodeValue);
+	}
+}

package/src/lib/names/UnprefixedXFormsName.ts

@@ -0,0 +1,12 @@
+import { XFORMS_NAMESPACE_URI } from '@getodk/common/constants/xmlns.ts';
+import { QualifiedName } from './QualifiedName.ts';
+
+export class UnprefixedXFormsName extends QualifiedName {
+	constructor(localName: string) {
+		super({
+			namespaceURI: XFORMS_NAMESPACE_URI,
+			prefix: null,
+			localName,
+		});
+	}
+}

package/src/lib/reactivity/createInstanceValueState.ts

@@ -1,57 +1,27 @@
 import type { Signal } from 'solid-js';
 import { createComputed, createMemo, createSignal, untrack } from 'solid-js';
-import { ErrorProductionDesignPendingError } from '../../error/ErrorProductionDesignPendingError.ts';
 import type { InstanceValueContext } from '../../instance/internal-api/InstanceValueContext.ts';
 import type { BindComputationExpression } from '../../parse/expression/BindComputationExpression.ts';
 import { createComputedExpression } from './createComputedExpression.ts';
 import type { SimpleAtomicState, SimpleAtomicStateSetter } from './types.ts';
 
-type InitialValueSource = 'FORM_DEFAULT' | 'PRIMARY_INSTANCE';
+const isInstanceFirstLoad = (context: InstanceValueContext) => {
+	return context.rootDocument.initializationMode === 'create';
+};
 
 /**
- * @todo {@link InitialValueSource} naming leaves a lot to be desired. As described in {@link InstanceValueStateOptions.initialValueSource}, this check (for now) will effectively answer the question: "are we **NOT** editing instance state (e.g. a submission)?". This answer, in turn, determines whether to {@link setPreloadUIDValue}
+ * Special case, does not correspond to any event.
+ *
+ * @see {@link shouldPreloadUID}
  */
-const isInstanceFirstLoad = (valueSource?: InitialValueSource) => {
-	return valueSource === 'FORM_DEFAULT';
+const isEditInitialLoad = (context: InstanceValueContext) => {
+	return context.rootDocument.initializationMode === 'edit';
 };
 
-export interface InstanceValueStateOptions {
-	/**
-	 * Specifies the source of a {@link createInstanceValueState} signal's initial
-	 * value state, where:
-	 *
-	 * - 'FORM_DEFAULT': Derives the initial state from the form's definition of
-	 *   the node itself. This is the default option, appropriate when
-	 *   initializing a form without additional primary instance data. In other
-	 *   words, this value should not be used for edits.
-	 *
-	 * - 'PRIMARY_INSTANCE': Derives the initial state from the current text
-	 *   content of the {@link ValueNode.contextNode}. This option should be
-	 *   specified when initializing a form with existing primary instance data,
-	 *   such as when editing a previous submission.
-	 *
-	 * @default 'FORM_DEFAULT'
-	 *
-	 * Specifies whether a {@link createInstanceValueState} signal's initial state
-	 * should be derived from the current text content of the
-	 * {@link ValueNode.contextNode | primary instance DOM state}.
-	 */
-	readonly initialValueSource?: InitialValueSource;
-}
-
-const getInitialValue = (
-	context: InstanceValueContext,
-	options: InstanceValueStateOptions
-): string => {
-	const { initialValueSource = 'FORM_DEFAULT' } = options;
-
-	if (initialValueSource === 'FORM_DEFAULT') {
-		const { defaultValue } = context.definition;
-
-		return context.decodeInstanceValue(defaultValue);
-	}
+const getInitialValue = (context: InstanceValueContext): string => {
+	const sourceNode = context.instanceNode ?? context.definition.template;
 
-	throw new ErrorProductionDesignPendingError('Edit implementation pending');
+	return context.decodeInstanceValue(sourceNode.value);
 };
 
 type BaseValueState = Signal<string>;
@@ -118,6 +88,16 @@ const guardDownstreamReadonlyWrites = (
  */
 const PRELOAD_UID_EXPRESSION = 'concat("uuid:", uuid())';
 
+/**
+ * @todo It feels increasingly awkward to keep piling up preload stuff here, but it won't stay that way for long. In the meantime, this seems like the best way to express the cases where `preload="uid"` should be effective, i.e.:
+ *
+ * - When an instance is first loaded ({@link isInstanceFirstLoad})
+ * - When an instance is initially loaded for editing ({@link isEditInitialLoad})
+ */
+const shouldPreloadUID = (context: InstanceValueContext) => {
+	return isInstanceFirstLoad(context) || isEditInitialLoad(context);
+};
+
 /**
  * @todo This is a temporary one-off, until we support the full range of
  * {@link https://getodk.github.io/xforms-spec/#preload-attributes | preloads}.
@@ -129,12 +109,11 @@ const PRELOAD_UID_EXPRESSION = 'concat("uuid:", uuid())';
  */
 const setPreloadUIDValue = (
 	context: InstanceValueContext,
-	valueState: RelevantValueState,
-	options: InstanceValueStateOptions
+	valueState: RelevantValueState
 ): void => {
 	const { preload } = context.definition.bind;
 
-	if (preload?.type !== 'uid' || !isInstanceFirstLoad(options?.initialValueSource)) {
+	if (preload?.type !== 'uid' || !shouldPreloadUID(context)) {
 		return;
 	}
 
@@ -182,26 +161,23 @@ 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 submission)
+ *   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 const createInstanceValueState = (
-	context: InstanceValueContext,
-	options: InstanceValueStateOptions = {}
-): InstanceValueState => {
+export const createInstanceValueState = (context: InstanceValueContext): InstanceValueState => {
 	return context.scope.runTask(() => {
-		const initialValue = getInitialValue(context, options);
+		const initialValue = getInitialValue(context);
 		const baseValueState = createSignal(initialValue);
 		const relevantValueState = createRelevantValueState(context, baseValueState);
 
 		/**
 		 * @see {@link setPreloadUIDValue} for important details about spec ordering of events and computations.
 		 */
-		setPreloadUIDValue(context, relevantValueState, options);
+		setPreloadUIDValue(context, relevantValueState);
 
 		const { calculate } = context.definition.bind;
 

package/src/parse/model/ItextTranslationsDefinition.ts

@@ -0,0 +1,79 @@
+import type {
+	XFORMS_KNOWN_ATTRIBUTE,
+	XFORMS_LOCAL_NAME,
+	XFormsItextTranslationMap,
+} from '@getodk/xpath';
+import { StaticDocument } from '../../integration/xpath/static-dom/StaticDocument.ts';
+import type { StaticElement } from '../../integration/xpath/static-dom/StaticElement.ts';
+import type { XFormDOM } from '../XFormDOM.ts';
+import { parseStaticDocumentFromDOMSubtree } from '../shared/parseStaticDocumentFromDOMSubtree.ts';
+
+export interface ItextTranslationDefinition extends StaticDocument {
+	readonly rootDocument: ItextTranslationDefinition;
+	readonly root: ItextTranslationRootDefinition;
+}
+
+export interface ItextTranslationRootDefinition extends StaticElement {
+	readonly [XFORMS_LOCAL_NAME]: 'translation';
+	readonly [XFORMS_KNOWN_ATTRIBUTE]: 'lang';
+
+	readonly root: ItextTranslationRootDefinition;
+	readonly rootDocument: ItextTranslationDefinition;
+}
+
+type ItextTranslationsDefinitionEntry = readonly [
+	key: string,
+	value: ItextTranslationRootDefinition,
+];
+
+type AssertItextTranslationsDefinitionEntry = (
+	entry: readonly [key: string | null, value: StaticElement]
+) => asserts entry is ItextTranslationsDefinitionEntry;
+
+const assertItextTranslationsDefinitionEntry: AssertItextTranslationsDefinitionEntry = ([
+	key,
+	root,
+]) => {
+	if (key == null || root.qualifiedName.localName !== 'translation') {
+		throw new Error();
+	}
+};
+
+/**
+ * @todo At time of writing, this shouldn't have any observable
+ * consequence—apart from preventing the potential mistake of using an
+ * {@link ItextTranslationDefinition} where an
+ * **instance**-as-{@link StaticDocument} would be expected (i.e. anything
+ * expecting an instance's {@link StaticDocument.nodeset} to be '/', or an its
+ * descendant elements' {@link StaticElement.nodeset} to start with '/'). The
+ * main intent, however, is to leave a breadcrumb back to ideas discussed in
+ * {@link https://github.com/getodk/web-forms/issues/22#issuecomment-2669228571 | Allow output in translation text (#22)}.
+ */
+const itextTranslationNodesetPrefix = (lang: string) => {
+	return `wf:translation('${lang}')`;
+};
+
+export class ItextTranslationsDefinition
+	extends Map<string, ItextTranslationRootDefinition>
+	implements XFormsItextTranslationMap<ItextTranslationRootDefinition>
+{
+	static from(xformDOM: XFormDOM): ItextTranslationsDefinition {
+		const entries = xformDOM.itextTranslationElements.map((element) => {
+			const lang = element.getAttribute('lang');
+			const { root } = parseStaticDocumentFromDOMSubtree(element, {
+				nodesetPrefix: itextTranslationNodesetPrefix(lang),
+			});
+			const entry = [lang, root] as const;
+
+			assertItextTranslationsDefinitionEntry(entry);
+
+			return entry;
+		});
+
+		return new this(entries);
+	}
+
+	private constructor(entries: readonly ItextTranslationsDefinitionEntry[]) {
+		super(entries);
+	}
+}

package/src/parse/model/LeafNodeDefinition.ts

@@ -1,4 +1,5 @@
 import type { ValueType } from '../../client/ValueType.ts';
+import type { StaticLeafElement } from '../../integration/xpath/static-dom/StaticElement.ts';
 import {
 	NamespaceDeclarationMap,
 	type NamedSubtreeDefinition,
@@ -19,14 +20,12 @@ export class LeafNodeDefinition<V extends ValueType = ValueType>
 	readonly namespaceDeclarations: NamespaceDeclarationMap;
 	readonly qualifiedName: QualifiedName;
 	readonly children = null;
-	readonly instances = null;
-	readonly defaultValue: string;
 
 	constructor(
 		parent: ParentNodeDefinition,
 		bind: BindDefinition,
 		bodyElement: AnyBodyElementDefinition | null,
-		readonly node: Element
+		readonly template: StaticLeafElement
 	) {
 		if (bodyElement != null && bodyElement.category !== 'control') {
 			throw new Error(`Unexpected body element for nodeset ${bind.nodeset}`);
@@ -35,9 +34,8 @@ export class LeafNodeDefinition<V extends ValueType = ValueType>
 		super(parent, bind, bodyElement);
 
 		this.valueType = bind.type.resolved satisfies ValueType as V;
-		this.qualifiedName = new QualifiedName(node);
+		this.qualifiedName = template.qualifiedName;
 		this.namespaceDeclarations = new NamespaceDeclarationMap(this);
-		this.defaultValue = node.textContent ?? '';
 	}
 
 	toJSON() {