@getodk/xforms-engine 0.5.0 → 0.7.0

package/src/instance/InputControl.ts

@@ -5,10 +5,12 @@ import type {
 	InputNode,
 	InputNodeAppearances,
 	InputNodeInputValue,
+	InputNodeOptions,
 } from '../client/InputNode.ts';
 import type { TextRange } from '../client/TextRange.ts';
 import type { ValueType } from '../client/ValueType.ts';
 import type { XFormsXPathElement } from '../integration/xpath/adapter/XFormsXPathNode.ts';
+import type { StaticLeafElement } from '../integration/xpath/static-dom/StaticElement.ts';
 import type { RuntimeInputValue, RuntimeValue } from '../lib/codecs/getSharedValueCodec.ts';
 import { getSharedValueCodec } from '../lib/codecs/getSharedValueCodec.ts';
 import type { CurrentState } from '../lib/reactivity/node-state/createCurrentState.ts';
@@ -17,20 +19,57 @@ import type { SharedNodeState } from '../lib/reactivity/node-state/createSharedN
 import { createSharedNodeState } from '../lib/reactivity/node-state/createSharedNodeState.ts';
 import { createFieldHint } from '../lib/reactivity/text/createFieldHint.ts';
 import { createNodeLabel } from '../lib/reactivity/text/createNodeLabel.ts';
-import type { Root } from './Root.ts';
+import type { InputControlDefinition } from '../parse/body/control/InputControlDefinition.ts';
 import { ValueNode, type ValueNodeStateSpec } from './abstract/ValueNode.ts';
 import type { GeneralParentNode } from './hierarchy.ts';
 import type { EvaluationContext } from './internal-api/EvaluationContext.ts';
+import type { ClientReactiveSerializableValueNode } from './internal-api/serialization/ClientReactiveSerializableValueNode.ts';
 import type { ValidationContext } from './internal-api/ValidationContext.ts';
-import type { ClientReactiveSubmittableValueNode } from './internal-api/submission/ClientReactiveSubmittableValueNode.ts';
+import type { Root } from './Root.ts';
 
 export type AnyInputDefinition = {
 	[V in ValueType]: InputDefinition<V>;
 }[ValueType];
 
+const stringInputNodeOptions = (control: InputControlDefinition): InputNodeOptions<'string'> => ({
+	rows: control.rows,
+});
+
+const geoInputNodeOptions = (
+	control: InputControlDefinition
+): InputNodeOptions<'geopoint' | 'geoshape' | 'geotrace'> => ({
+	accuracyThreshold: control.accuracyThreshold,
+	unacceptableAccuracyThreshold: control.unacceptableAccuracyThreshold,
+});
+
+type NodeOptionsFactory<V extends ValueType> = (
+	controlDefinition: InputControlDefinition
+) => InputNodeOptions<V>;
+
+type NodeOptionsFactoryByType = {
+	[V in ValueType]: NodeOptionsFactory<V>;
+};
+
+const nodeOptionsFactoryByType: NodeOptionsFactoryByType = {
+	string: stringInputNodeOptions,
+	int: () => null,
+	boolean: () => null,
+	decimal: () => null,
+	date: () => null,
+	time: () => null,
+	dateTime: () => null,
+	geopoint: geoInputNodeOptions,
+	geotrace: geoInputNodeOptions,
+	geoshape: geoInputNodeOptions,
+	binary: () => null,
+	barcode: () => null,
+	intent: () => null,
+};
+
 interface InputControlStateSpec<V extends ValueType> extends ValueNodeStateSpec<RuntimeValue<V>> {
 	readonly label: Accessor<TextRange<'label'> | null>;
 	readonly hint: Accessor<TextRange<'hint'> | null>;
+	readonly valueOptions: null;
 }
 
 export class InputControl<V extends ValueType = ValueType>
@@ -40,14 +79,19 @@ export class InputControl<V extends ValueType = ValueType>
 		XFormsXPathElement,
 		EvaluationContext,
 		ValidationContext,
-		ClientReactiveSubmittableValueNode
+		ClientReactiveSerializableValueNode
 {
-	static from(parent: GeneralParentNode, definition: InputDefinition): AnyInputControl;
+	static from(
+		parent: GeneralParentNode,
+		instanceNode: StaticLeafElement | null,
+		definition: InputDefinition
+	): AnyInputControl;
 	static from<V extends ValueType>(
 		parent: GeneralParentNode,
+		instanceNode: StaticLeafElement | null,
 		definition: InputDefinition<V>
 	): InputControl<V> {
-		return new this(parent, definition);
+		return new this(parent, instanceNode, definition);
 	}
 
 	// XFormsXPathElement
@@ -60,18 +104,20 @@ export class InputControl<V extends ValueType = ValueType>
 	// InputNode
 	readonly nodeType = 'input';
 	readonly appearances: InputNodeAppearances;
+	readonly nodeOptions: InputNodeOptions<V>;
 	readonly currentState: CurrentState<InputControlStateSpec<V>>;
 
-	constructor(parent: GeneralParentNode, definition: InputDefinition<V>) {
+	constructor(
+		parent: GeneralParentNode,
+		instanceNode: StaticLeafElement | null,
+		definition: InputDefinition<V>
+	) {
 		const codec = getSharedValueCodec(definition.valueType);
 
-		super(parent, definition, codec);
+		super(parent, instanceNode, definition, codec);
 
 		this.appearances = definition.bodyElement.appearances;
-
-		const sharedStateOptions = {
-			clientStateFactory: this.engineConfig.stateFactory,
-		};
+		this.nodeOptions = nodeOptionsFactoryByType[definition.valueType](definition.bodyElement);
 
 		const state = createSharedNodeState(
 			this.scope,
@@ -88,7 +134,7 @@ export class InputControl<V extends ValueType = ValueType>
 				value: this.valueState,
 				instanceValue: this.getInstanceValue,
 			},
-			sharedStateOptions
+			this.instanceConfig
 		);
 
 		this.state = state;

package/src/instance/ModelValue.ts

@@ -2,6 +2,7 @@ import { XPathNodeKindKey } from '@getodk/xpath';
 import type { ModelValueDefinition, ModelValueNode } from '../client/ModelValueNode.ts';
 import type { ValueType } from '../client/ValueType.ts';
 import type { XFormsXPathElement } from '../integration/xpath/adapter/XFormsXPathNode.ts';
+import type { StaticLeafElement } from '../integration/xpath/static-dom/StaticElement.ts';
 import type { RuntimeInputValue, RuntimeValue } from '../lib/codecs/getSharedValueCodec.ts';
 import { getSharedValueCodec } from '../lib/codecs/getSharedValueCodec.ts';
 import type { CurrentState } from '../lib/reactivity/node-state/createCurrentState.ts';
@@ -12,11 +13,12 @@ import { ValueNode, type ValueNodeStateSpec } from './abstract/ValueNode.ts';
 import type { GeneralParentNode } from './hierarchy.ts';
 import type { EvaluationContext } from './internal-api/EvaluationContext.ts';
 import type { ValidationContext } from './internal-api/ValidationContext.ts';
-import type { ClientReactiveSubmittableValueNode } from './internal-api/submission/ClientReactiveSubmittableValueNode.ts';
+import type { ClientReactiveSerializableValueNode } from './internal-api/serialization/ClientReactiveSerializableValueNode.ts';
 
 interface ModelValueStateSpec<V extends ValueType> extends ValueNodeStateSpec<RuntimeValue<V>> {
 	readonly label: null;
 	readonly hint: null;
+	readonly valueOptions: null;
 }
 
 export class ModelValue<V extends ValueType = ValueType>
@@ -26,14 +28,19 @@ export class ModelValue<V extends ValueType = ValueType>
 		XFormsXPathElement,
 		EvaluationContext,
 		ValidationContext,
-		ClientReactiveSubmittableValueNode
+		ClientReactiveSerializableValueNode
 {
-	static from(parent: GeneralParentNode, definition: ModelValueDefinition): AnyModelValue;
+	static from(
+		parent: GeneralParentNode,
+		instanceNode: StaticLeafElement | null,
+		definition: ModelValueDefinition
+	): AnyModelValue;
 	static from<V extends ValueType>(
 		parent: GeneralParentNode,
+		instanceNode: StaticLeafElement | null,
 		definition: ModelValueDefinition<V>
 	): ModelValue<V> {
-		return new this(parent, definition);
+		return new this(parent, instanceNode, definition);
 	}
 
 	// XFormsXPathElement
@@ -46,16 +53,17 @@ export class ModelValue<V extends ValueType = ValueType>
 	// ModelValueNode
 	readonly nodeType = 'model-value';
 	readonly appearances = null;
+	readonly nodeOptions = null;
 	readonly currentState: CurrentState<ModelValueStateSpec<V>>;
 
-	constructor(parent: GeneralParentNode, definition: ModelValueDefinition<V>) {
+	constructor(
+		parent: GeneralParentNode,
+		instanceNode: StaticLeafElement | null,
+		definition: ModelValueDefinition<V>
+	) {
 		const codec = getSharedValueCodec(definition.valueType);
 
-		super(parent, definition, codec);
-
-		const sharedStateOptions = {
-			clientStateFactory: this.engineConfig.stateFactory,
-		};
+		super(parent, instanceNode, definition, codec);
 
 		const state = createSharedNodeState(
 			this.scope,
@@ -72,7 +80,7 @@ export class ModelValue<V extends ValueType = ValueType>
 				value: this.valueState,
 				instanceValue: this.getInstanceValue,
 			},
-			sharedStateOptions
+			this.instanceConfig
 		);
 
 		this.state = state;

package/src/instance/Note.ts

@@ -1,15 +1,14 @@
 import { UnreachableError } from '@getodk/common/lib/error/UnreachableError.ts';
-import { identity } from '@getodk/common/lib/identity.ts';
 import { XPathNodeKindKey } from '@getodk/xpath';
 import type { Accessor } from 'solid-js';
-import type { NoteNode, NoteNodeAppearances } from '../client/NoteNode.ts';
-import type { SubmissionState } from '../client/submission/SubmissionState.ts';
+import type { NoteNode, NoteNodeAppearances, NoteValue } from '../client/NoteNode.ts';
 import type { TextRange } from '../client/TextRange.ts';
-import type { AnyViolation, LeafNodeValidationState } from '../client/validation.ts';
+import type { ValueType } from '../client/ValueType.ts';
 import type { XFormsXPathElement } from '../integration/xpath/adapter/XFormsXPathNode.ts';
-import { createLeafNodeSubmissionState } from '../lib/client-reactivity/submission/createLeafNodeSubmissionState.ts';
+import type { StaticLeafElement } from '../integration/xpath/static-dom/StaticElement.ts';
+import { getNoteCodec } from '../lib/codecs/getNoteCodec.ts';
+import type { NoteInputValue, NoteRuntimeValue } from '../lib/codecs/NoteCodec.ts';
 import { createNoteReadonlyThunk } from '../lib/reactivity/createNoteReadonlyThunk.ts';
-import { createValueState } from '../lib/reactivity/createValueState.ts';
 import type { CurrentState } from '../lib/reactivity/node-state/createCurrentState.ts';
 import type { EngineState } from '../lib/reactivity/node-state/createEngineState.ts';
 import type { SharedNodeState } from '../lib/reactivity/node-state/createSharedNodeState.ts';
@@ -17,72 +16,54 @@ import { createSharedNodeState } from '../lib/reactivity/node-state/createShared
 import { createFieldHint } from '../lib/reactivity/text/createFieldHint.ts';
 import { createNodeLabel } from '../lib/reactivity/text/createNodeLabel.ts';
 import { createNoteText, type ComputedNoteText } from '../lib/reactivity/text/createNoteText.ts';
-import type { SimpleAtomicState } from '../lib/reactivity/types.ts';
-import type { SharedValidationState } from '../lib/reactivity/validation/createValidation.ts';
-import { createValidationState } from '../lib/reactivity/validation/createValidation.ts';
 import type { NoteNodeDefinition } from '../parse/model/NoteNodeDefinition.ts';
-import type { DescendantNodeStateSpec } from './abstract/DescendantNode.ts';
-import { DescendantNode } from './abstract/DescendantNode.ts';
+import { ValueNode, type ValueNodeStateSpec } from './abstract/ValueNode.ts';
 import type { GeneralParentNode } from './hierarchy.ts';
 import type { EvaluationContext } from './internal-api/EvaluationContext.ts';
-import type { ClientReactiveSubmittableLeafNode } from './internal-api/submission/ClientReactiveSubmittableLeafNode.ts';
+import type { ClientReactiveSerializableValueNode } from './internal-api/serialization/ClientReactiveSerializableValueNode.ts';
 import type { ValidationContext } from './internal-api/ValidationContext.ts';
-import type { ValueContext } from './internal-api/ValueContext.ts';
 
-interface NoteStateSpec extends DescendantNodeStateSpec<string> {
+interface NoteStateSpec<V extends ValueType> extends ValueNodeStateSpec<NoteValue<V>> {
 	readonly readonly: Accessor<true>;
 	readonly noteText: ComputedNoteText;
 	readonly label: Accessor<TextRange<'label', 'form'> | null>;
 	readonly hint: Accessor<TextRange<'hint', 'form'> | null>;
-	readonly children: null;
-	readonly value: SimpleAtomicState<string>;
 	readonly valueOptions: null;
 }
 
-export class Note
-	extends DescendantNode<NoteNodeDefinition, NoteStateSpec, GeneralParentNode, null>
+export class Note<V extends ValueType = ValueType>
+	extends ValueNode<V, NoteNodeDefinition<V>, NoteRuntimeValue<V>, NoteInputValue<V>>
 	implements
 		NoteNode,
 		XFormsXPathElement,
 		EvaluationContext,
 		ValidationContext,
-		ValueContext<string>,
-		ClientReactiveSubmittableLeafNode<string>
+		ClientReactiveSerializableValueNode
 {
-	private readonly validation: SharedValidationState;
-
 	// XFormsXPathElement
 	override readonly [XPathNodeKindKey] = 'element';
 
 	// InstanceNode
-	protected readonly state: SharedNodeState<NoteStateSpec>;
-	protected readonly engineState: EngineState<NoteStateSpec>;
+	protected readonly state: SharedNodeState<NoteStateSpec<V>>;
+	protected readonly engineState: EngineState<NoteStateSpec<V>>;
 
 	// NoteNode
 	readonly nodeType = 'note';
 	readonly appearances: NoteNodeAppearances;
-	readonly currentState: CurrentState<NoteStateSpec>;
-
-	get validationState(): LeafNodeValidationState {
-		return this.validation.currentState;
-	}
-
-	readonly submissionState: SubmissionState;
+	readonly nodeOptions = null;
+	readonly currentState: CurrentState<NoteStateSpec<V>>;
 
-	// ValueContext
-	override readonly contextNode = this;
-	readonly encodeValue = identity<string>;
-	readonly decodeValue = identity<string>;
+	constructor(
+		parent: GeneralParentNode,
+		instanceNode: StaticLeafElement | null,
+		definition: NoteNodeDefinition<V>
+	) {
+		const codec = getNoteCodec(definition.valueType);
 
-	constructor(parent: GeneralParentNode, definition: NoteNodeDefinition) {
-		super(parent, definition);
+		super(parent, instanceNode, definition, codec);
 
 		this.appearances = definition.bodyElement.appearances;
 
-		const sharedStateOptions = {
-			clientStateFactory: this.engineConfig.stateFactory,
-		};
-
 		const isReadonly = createNoteReadonlyThunk(this, definition);
 		const noteTextComputation = createNoteText(this, definition.noteTextDefinition);
 
@@ -125,34 +106,29 @@ export class Note
 
 				children: null,
 				valueOptions: null,
-				value: createValueState(this),
+				value: this.valueState,
+				instanceValue: this.getInstanceValue,
 			},
-			sharedStateOptions
+			this.instanceConfig
 		);
 
 		this.state = state;
 		this.engineState = state.engineState;
 		this.currentState = state.currentState;
-		this.validation = createValidationState(this, sharedStateOptions);
-		this.submissionState = createLeafNodeSubmissionState(this);
-	}
-
-	// XFormsXPathElement
-	override getXPathValue(): string {
-		return this.engineState.value;
-	}
-
-	// ValidationContext
-	getViolation(): AnyViolation | null {
-		return this.validation.engineState.violation;
-	}
-
-	isBlank(): boolean {
-		return this.engineState.value === '';
-	}
-
-	// InstanceNode
-	getChildren(): readonly [] {
-		return [];
 	}
 }
+
+export type AnyNote =
+	| Note<'barcode'>
+	| Note<'binary'>
+	| Note<'boolean'>
+	| Note<'date'>
+	| Note<'dateTime'>
+	| Note<'decimal'>
+	| Note<'geopoint'>
+	| Note<'geoshape'>
+	| Note<'geotrace'>
+	| Note<'int'>
+	| Note<'intent'>
+	| Note<'string'>
+	| Note<'time'>;

package/src/instance/PrimaryInstance.ts

@@ -1,20 +1,22 @@
 import { XPathNodeKindKey } from '@getodk/xpath';
 import type { Accessor } from 'solid-js';
 import { createSignal } from 'solid-js';
+import type { FormInstanceInitializationMode } from '../client/form/FormInstance.ts';
 import type { ActiveLanguage, FormLanguage, FormLanguages } from '../client/FormLanguage.ts';
 import type { FormNodeID } from '../client/identity.ts';
 import type { RootNode } from '../client/RootNode.ts';
+import type { InstancePayload } from '../client/serialization/InstancePayload.ts';
 import type {
-	SubmissionChunkedType,
-	SubmissionOptions,
-} from '../client/submission/SubmissionOptions.ts';
-import type { SubmissionResult } from '../client/submission/SubmissionResult.ts';
-import type { SubmissionState } from '../client/submission/SubmissionState.ts';
+	InstancePayloadOptions,
+	InstancePayloadType,
+} from '../client/serialization/InstancePayloadOptions.ts';
+import type { InstanceState } from '../client/serialization/InstanceState.ts';
 import type { AncestorNodeValidationState } from '../client/validation.ts';
 import type { XFormsXPathDocument } from '../integration/xpath/adapter/XFormsXPathNode.ts';
 import { EngineXPathEvaluator } from '../integration/xpath/EngineXPathEvaluator.ts';
-import { createInstanceSubmissionState } from '../lib/client-reactivity/submission/createInstanceSubmissionState.ts';
-import { prepareSubmission } from '../lib/client-reactivity/submission/prepareSubmission.ts';
+import type { StaticDocument } from '../integration/xpath/static-dom/StaticDocument.ts';
+import { createPrimaryInstanceState } from '../lib/client-reactivity/instance-state/createPrimaryInstanceState.ts';
+import { prepareInstancePayload } from '../lib/client-reactivity/instance-state/prepareInstancePayload.ts';
 import { createChildrenState } from '../lib/reactivity/createChildrenState.ts';
 import { createTranslationState } from '../lib/reactivity/createTranslationState.ts';
 import type { MaterializedChildren } from '../lib/reactivity/materializeCurrentStateChildren.ts';
@@ -30,10 +32,11 @@ import type { ModelDefinition } from '../parse/model/ModelDefinition.ts';
 import type { RootDefinition } from '../parse/model/RootDefinition.ts';
 import type { SecondaryInstancesDefinition } from '../parse/model/SecondaryInstance/SecondaryInstancesDefinition.ts';
 import { InstanceNode } from './abstract/InstanceNode.ts';
+import type { InitialInstanceState } from './input/InitialInstanceState.ts';
 import type { EvaluationContext } from './internal-api/EvaluationContext.ts';
 import type { InstanceConfig } from './internal-api/InstanceConfig.ts';
 import type { PrimaryInstanceDocument } from './internal-api/PrimaryInstanceDocument.ts';
-import type { ClientReactiveSubmittableInstance } from './internal-api/submission/ClientReactiveSubmittableInstance.ts';
+import type { ClientReactiveSerializableInstance } from './internal-api/serialization/ClientReactiveSerializableInstance.ts';
 import type { TranslationContext } from './internal-api/TranslationContext.ts';
 import { Root } from './Root.ts';
 
@@ -74,20 +77,55 @@ interface PrimaryInstanceStateSpec {
 	readonly activeLanguage: Accessor<ActiveLanguage>;
 }
 
-export class PrimaryInstance
+interface PrimaryInstanceStateInputByMode {
+	readonly create: null;
+	readonly edit: InitialInstanceState;
+	readonly restore: InitialInstanceState;
+}
+
+export type PrimaryInstanceInitialState<Mode extends FormInstanceInitializationMode> =
+	PrimaryInstanceStateInputByMode[Mode];
+
+export interface BasePrimaryInstanceOptions {
+	readonly scope: ReactiveScope;
+	readonly model: ModelDefinition;
+	readonly secondaryInstances: SecondaryInstancesDefinition;
+}
+
+export interface ModelessPrimaryInstanceOptions extends BasePrimaryInstanceOptions {
+	readonly config: InstanceConfig;
+}
+
+export interface PrimaryInstanceOptions<Mode extends FormInstanceInitializationMode>
+	extends ModelessPrimaryInstanceOptions {
+	readonly mode: Mode;
+	readonly initialState: PrimaryInstanceInitialState<Mode>;
+}
+
+export class PrimaryInstance<
+		Mode extends FormInstanceInitializationMode = FormInstanceInitializationMode,
+	>
 	extends InstanceNode<RootDefinition, PrimaryInstanceStateSpec, null, Root>
 	implements
 		PrimaryInstanceDocument,
 		XFormsXPathDocument,
 		TranslationContext,
 		EvaluationContext,
-		ClientReactiveSubmittableInstance
+		ClientReactiveSerializableInstance
 {
+	/**
+	 * @todo this will be populated as we introduce other initialization modes!
+	 */
+	readonly initializationMode: FormInstanceInitializationMode = 'create';
+
+	readonly model: ModelDefinition;
+
 	// InstanceNode
 	protected readonly state: SharedNodeState<PrimaryInstanceStateSpec>;
 	protected readonly engineState: EngineState<PrimaryInstanceStateSpec>;
-	readonly getChildren: Accessor<readonly Root[]>;
 
+	override readonly instanceNode: StaticDocument;
+	readonly getChildren: Accessor<readonly Root[]>;
 	readonly hasReadonlyAncestor = () => false;
 	readonly isReadonly = () => false;
 	readonly hasNonRelevantAncestor = () => false;
@@ -99,14 +137,15 @@ export class PrimaryInstance
 	// XFormsXPathDocument
 	readonly [XPathNodeKindKey] = 'document';
 
-	// PrimaryInstanceDocument, ClientReactiveSubmittableInstance
+	// PrimaryInstanceDocument, ClientReactiveSerializableInstance
 	readonly nodeType = 'primary-instance';
 	readonly appearances = null;
+	readonly nodeOptions = null;
 	readonly classes: BodyClassList;
 	readonly root: Root;
 	readonly currentState: MaterializedChildren<CurrentState<PrimaryInstanceStateSpec>, Root>;
 	readonly validationState: AncestorNodeValidationState;
-	readonly submissionState: SubmissionState;
+	readonly instanceState: InstanceState;
 	readonly languages: FormLanguages;
 
 	// TranslationContext (+ EvaluationContext)
@@ -117,19 +156,21 @@ export class PrimaryInstance
 	readonly evaluator: EngineXPathEvaluator;
 	override readonly contextNode = this;
 
-	constructor(
-		scope: ReactiveScope,
-		model: ModelDefinition,
-		secondaryInstances: SecondaryInstancesDefinition,
-		engineConfig: InstanceConfig
-	) {
-		const { root: definition } = model;
+	constructor(options: PrimaryInstanceOptions<Mode>) {
+		const { mode, initialState, scope, model, secondaryInstances, config } = options;
+		const { instance: modelInstance } = model;
+		const activeInstance = initialState?.document ?? modelInstance;
+		const definition = model.getRootDefinition(activeInstance);
 
-		super(engineConfig, null, definition, {
+		super(config, null, activeInstance, definition, {
 			scope,
 			computeReference: () => PRIMARY_INSTANCE_REFERENCE,
 		});
 
+		this.initializationMode = mode;
+		this.model = model;
+		this.instanceNode = activeInstance;
+
 		const [isAttached, setIsAttached] = createSignal(false);
 
 		this.isAttached = isAttached;
@@ -169,9 +210,7 @@ export class PrimaryInstance
 			children: childrenState.childIds,
 		};
 
-		const state = createSharedNodeState(scope, stateSpec, {
-			clientStateFactory: engineConfig.stateFactory,
-		});
+		const state = createSharedNodeState(scope, stateSpec, config);
 
 		this.state = state;
 		this.engineState = state.engineState;
@@ -186,7 +225,7 @@ export class PrimaryInstance
 				return root.validationState.violations;
 			},
 		};
-		this.submissionState = createInstanceSubmissionState(this);
+		this.instanceState = createPrimaryInstanceState(this);
 
 		childrenState.setChildren([root]);
 		setIsAttached(true);
@@ -230,12 +269,12 @@ export class PrimaryInstance
 		return this.setActiveLanguage(availableFormLanguage);
 	}
 
-	// PrimaryInstanceDocument, ClientReactiveSubmittableInstance
-	prepareSubmission<ChunkedType extends SubmissionChunkedType = 'monolithic'>(
-		options?: SubmissionOptions<ChunkedType>
-	): Promise<SubmissionResult<ChunkedType>> {
-		const result = prepareSubmission(this, {
-			chunked: (options?.chunked ?? 'monolithic') as ChunkedType,
+	// PrimaryInstanceDocument
+	prepareInstancePayload<PayloadType extends InstancePayloadType = 'monolithic'>(
+		options?: InstancePayloadOptions<PayloadType>
+	): Promise<InstancePayload<PayloadType>> {
+		const result = prepareInstancePayload(this, {
+			payloadType: (options?.payloadType ?? 'monolithic') as PayloadType,
 			maxSize: options?.maxSize ?? Infinity,
 		});