@getodk/xforms-engine 0.5.0 → 0.7.0

package/src/entrypoints/FormResult/FormFailureResult.ts

@@ -0,0 +1,44 @@
+import type { AnyFunction } from '@getodk/common/types/helpers.js';
+import type { CreateFormInstance } from '../../client/form/CreateFormInstance.ts';
+import type { EditFormInstance } from '../../client/form/EditFormInstance.ts';
+import type {
+	FailedLoadFormResultMethod,
+	LoadFormFailureResult,
+	LoadFormWarnings,
+} from '../../client/form/LoadFormResult.ts';
+import type { RestoreFormInstance } from '../../client/form/RestoreFormInstance.ts';
+import { LoadFormFailureError } from '../../error/LoadFormFailureError.ts';
+import { BaseFormResult } from './BaseFormResult.ts';
+
+interface FormFailureOptions {
+	readonly error: LoadFormFailureError;
+	readonly warnings: LoadFormWarnings | null;
+}
+
+const failedFormResultMethodFactory = <T extends AnyFunction>(
+	cause: LoadFormFailureError
+): FailedLoadFormResultMethod<T> => {
+	return () => {
+		throw new Error(cause.message, { cause });
+	};
+};
+
+export class FormFailureResult extends BaseFormResult<'failure'> implements LoadFormFailureResult {
+	readonly createInstance: FailedLoadFormResultMethod<CreateFormInstance>;
+	readonly editInstance: FailedLoadFormResultMethod<EditFormInstance>;
+	readonly restoreInstance: FailedLoadFormResultMethod<RestoreFormInstance>;
+
+	constructor(options: FormFailureOptions) {
+		const { error, warnings } = options;
+
+		super({
+			status: 'failure',
+			warnings,
+			error,
+		});
+
+		this.createInstance = failedFormResultMethodFactory(error);
+		this.editInstance = failedFormResultMethodFactory(error);
+		this.restoreInstance = failedFormResultMethodFactory(error);
+	}
+}

package/src/entrypoints/FormResult/FormSuccessResult.ts

@@ -0,0 +1,25 @@
+import type { LoadFormSuccessResult } from '../../client/index.ts';
+import type { BasePrimaryInstanceOptions } from '../../instance/PrimaryInstance.ts';
+import type { FormResource } from '../../instance/resource.ts';
+import type { ReactiveScope } from '../../lib/reactivity/scope.ts';
+import { BaseInstantiableFormResult } from './BaseInstantiableFormResult.ts';
+
+export interface FormSuccessResultOptions {
+	readonly warnings: null;
+	readonly error: null;
+	readonly scope: ReactiveScope;
+	readonly formResource: FormResource;
+	readonly instanceOptions: BasePrimaryInstanceOptions;
+}
+
+export class FormSuccessResult
+	extends BaseInstantiableFormResult<'success'>
+	implements LoadFormSuccessResult
+{
+	constructor(options: FormSuccessResultOptions) {
+		super({
+			status: 'success',
+			...options,
+		});
+	}
+}

package/src/entrypoints/FormResult/FormWarningResult.ts

@@ -0,0 +1,25 @@
+import type { LoadFormWarningResult, LoadFormWarnings } from '../../client/form/LoadFormResult.ts';
+import type { BasePrimaryInstanceOptions } from '../../instance/PrimaryInstance.ts';
+import type { FormResource } from '../../instance/resource.ts';
+import type { ReactiveScope } from '../../lib/reactivity/scope.ts';
+import { BaseInstantiableFormResult } from './BaseInstantiableFormResult.ts';
+
+export interface FormWarningResultOptions {
+	readonly warnings: LoadFormWarnings;
+	readonly error: null;
+	readonly scope: ReactiveScope;
+	readonly formResource: FormResource;
+	readonly instanceOptions: BasePrimaryInstanceOptions;
+}
+
+export class FormWarningResult
+	extends BaseInstantiableFormResult<'warning'>
+	implements LoadFormWarningResult
+{
+	constructor(options: FormWarningResultOptions) {
+		super({
+			status: 'warning',
+			...options,
+		});
+	}
+}

package/src/entrypoints/createInstance.ts

@@ -0,0 +1,23 @@
+import type { CreatedFormInstance } from '../client/form/CreateFormInstance.ts';
+import type { FormInstanceConfig } from '../client/form/FormInstanceConfig.ts';
+import type { LoadFormOptions } from '../client/form/LoadForm.ts';
+import type { FormResource } from '../instance/resource.ts';
+import { loadForm } from './loadForm.ts';
+
+export interface CreateInstanceOptions {
+	readonly form?: LoadFormOptions;
+	readonly instance?: FormInstanceConfig;
+}
+
+export const createInstance = async (
+	formResource: FormResource,
+	options?: CreateInstanceOptions
+): Promise<CreatedFormInstance> => {
+	const form = await loadForm(formResource, options?.form);
+
+	if (form.status === 'failure') {
+		throw form.error;
+	}
+
+	return form.createInstance(options?.instance);
+};

package/src/entrypoints/editInstance.ts

@@ -0,0 +1,24 @@
+import type { EditedFormInstance, EditFormInstanceInput } from '../client/form/EditFormInstance.ts';
+import type { FormInstanceConfig } from '../client/form/FormInstanceConfig.ts';
+import type { LoadFormOptions } from '../client/form/LoadForm.ts';
+import type { FormResource } from '../instance/resource.ts';
+import { loadForm } from './loadForm.ts';
+
+export interface EditInstanceOptions {
+	readonly form?: LoadFormOptions;
+	readonly instance?: FormInstanceConfig;
+}
+
+export const editInstance = async (
+	formResource: FormResource,
+	input: EditFormInstanceInput,
+	options?: EditInstanceOptions
+): Promise<EditedFormInstance> => {
+	const form = await loadForm(formResource, options?.form);
+
+	if (form.status === 'failure') {
+		throw form.error;
+	}
+
+	return form.editInstance(input, options?.instance);
+};

package/src/entrypoints/index.ts

@@ -0,0 +1,4 @@
+export * from './createInstance.ts';
+export * from './editInstance.ts';
+export * from './loadForm.ts';
+export * from './restoreInstance.ts';

package/src/entrypoints/loadForm.ts

@@ -0,0 +1,154 @@
+import type { Owner } from 'solid-js';
+import { getOwner } from 'solid-js';
+import { MISSING_RESOURCE_BEHAVIOR } from '../client/constants.ts';
+import type { FormResource } from '../client/form/FormResource.ts';
+import type { LoadForm, LoadFormOptions } from '../client/form/LoadForm.ts';
+import type { LoadFormResult } from '../client/form/LoadFormResult.ts';
+import { LoadFormFailureError } from '../error/LoadFormFailureError.ts';
+import { retrieveFormDefinition } from '../instance/resource.ts';
+import type { ReactiveScope } from '../lib/reactivity/scope.ts';
+import { createReactiveScope } from '../lib/reactivity/scope.ts';
+import { XFormDOM } from '../parse/XFormDOM.ts';
+import { XFormDefinition } from '../parse/XFormDefinition.ts';
+import { SecondaryInstancesDefinition } from '../parse/model/SecondaryInstance/SecondaryInstancesDefinition.ts';
+import { FormFailureResult } from './FormResult/FormFailureResult.ts';
+import { FormSuccessResult } from './FormResult/FormSuccessResult.ts';
+
+/**
+ * Creates a {@link ReactiveScope | reactive scope} from which all form
+ * instances derive, and:
+ *
+ * - if a client loads a form within a Solid reactive context, the scope will be
+ *   disposed along with the client's reactive context; OR
+ * - if a client loads a form outside a Solid reactive context (typically: if a
+ *   client does not use Solid reactivity), the scope will disposed if and when
+ *   the engine drops access to the loaded form
+ *
+ * **IMPORTANT:** this **MUST** be called synchronously. If it is called in an
+ * `async` function, it **MUST** be called before any `await` expression; if it
+ * is called in any other flow with mixed synchrony, it must be called before
+ * yielding to the event loop. Failing to do this will cause the engine to lose
+ * access to a client's Solid reactive context, potentially leaking form
+ * reactivity indefinitely.
+ */
+const createPotentiallyClientOwnedReactiveScope = (): ReactiveScope => {
+	/**
+	 * A {@link clientOwner | client owner} is the owner of a client's Solid
+	 * reactive context, if one exists. If none exists, the {@link ReactiveScope}
+	 * is fully owned by the engine.
+	 */
+	const clientOwner: Owner | null = getOwner();
+
+	return createReactiveScope({ owner: clientOwner });
+};
+
+type GlobalFetch = typeof globalThis.fetch;
+
+type UnboundGlobalFetch = (this: void, ...args: Parameters<GlobalFetch>) => ReturnType<GlobalFetch>;
+
+/**
+ * @see {@link https://github.com/getodk/web-forms/pull/281}
+ */
+let unboundGlobalFetch: UnboundGlobalFetch;
+
+if (typeof globalThis.fetch === 'function') {
+	unboundGlobalFetch = (...args) => {
+		return globalThis.fetch(...args);
+	};
+} else {
+	unboundGlobalFetch = () => {
+		throw new Error('fetch is not supported in this environment');
+	};
+}
+
+interface ResolvedOptions extends Required<LoadFormOptions> {}
+
+/**
+ * Resolves {@link FormResultLoadOptions} from options directly passed by a
+ * client (if passed at all).
+ *
+ * Note that this function exists to be more resilient than the static types
+ * would technically require, i.e. anticipating any kind of nullish value where
+ * option properties are typed only as optional. This is an acknowledgement that
+ * the nuances of nullishness are a footgun in untyped JavaScript, and
+ * nested-optional semantics are a particularly likely source of mistakes in
+ * client, and especially host application, integrations.
+ */
+const resolveOptions = (options?: LoadFormOptions): ResolvedOptions => {
+	return {
+		fetchFormDefinition: options?.fetchFormDefinition ?? unboundGlobalFetch,
+		fetchFormAttachment: options?.fetchFormAttachment ?? unboundGlobalFetch,
+		missingResourceBehavior: options?.missingResourceBehavior ?? MISSING_RESOURCE_BEHAVIOR.DEFAULT,
+	};
+};
+
+/**
+ * **IMPORTANT:** This function is defined separately from, and to be called by,
+ * the {@link loadForm} entrypoint to ensure we satisfy the synchrony
+ * requirements of {@link createPotentiallyClientOwnedReactiveScope}.
+ */
+const loadFormResult = async (
+	scope: ReactiveScope,
+	formResource: FormResource,
+	options: ResolvedOptions
+): Promise<LoadFormResult> => {
+	const { fetchFormDefinition, fetchFormAttachment, missingResourceBehavior } = options;
+
+	// TODO: Currently, **all** of the intermediate calls in this `try` block
+	// may throw! Handling that fact at the source would provide a much more
+	// specific `LoadFormFailureResult`, and address performance regressions
+	// inherent to such a broad/mixed use of `try`/`catch`.
+	//
+	// Addressing this is deferred for now, to limit scope.
+	try {
+		const sourceXML = await retrieveFormDefinition(formResource, {
+			fetchFormDefinition,
+		});
+		const xformDOM = XFormDOM.from(sourceXML);
+		const { model } = new XFormDefinition(xformDOM);
+		const secondaryInstances = await SecondaryInstancesDefinition.load(xformDOM, {
+			fetchResource: fetchFormAttachment,
+			missingResourceBehavior,
+		});
+		const instanceOptions = {
+			scope,
+			model,
+			secondaryInstances,
+		};
+
+		return new FormSuccessResult({
+			warnings: null,
+			error: null,
+			scope,
+			formResource,
+			instanceOptions,
+		});
+	} catch (caught) {
+		let cause: Error;
+
+		if (caught instanceof Error) {
+			cause = caught;
+		} else {
+			cause = new Error('Unknown form load error', { cause: caught });
+		}
+
+		const error = new LoadFormFailureError(formResource, [cause]);
+
+		return new FormFailureResult({
+			warnings: null,
+			error,
+		});
+	}
+};
+
+export const loadForm = (
+	formResource: FormResource,
+	options?: LoadFormOptions
+): Promise<LoadFormResult> => {
+	const scope = createPotentiallyClientOwnedReactiveScope();
+	const resolvedOptions = resolveOptions(options);
+
+	return loadFormResult(scope, formResource, resolvedOptions);
+};
+
+loadForm satisfies LoadForm;

package/src/entrypoints/restoreInstance.ts

@@ -0,0 +1,27 @@
+import type { FormInstanceConfig } from '../client/form/FormInstanceConfig.ts';
+import type { LoadFormOptions } from '../client/form/LoadForm.ts';
+import type {
+	RestoredFormInstance,
+	RestoreFormInstanceInput,
+} from '../client/form/RestoreFormInstance.ts';
+import type { FormResource } from '../instance/resource.ts';
+import { loadForm } from './loadForm.ts';
+
+export interface RestoreInstanceOptions {
+	readonly form?: LoadFormOptions;
+	readonly instance?: FormInstanceConfig;
+}
+
+export const restoreInstance = async (
+	formResource: FormResource,
+	input: RestoreFormInstanceInput,
+	options?: RestoreInstanceOptions
+): Promise<RestoredFormInstance> => {
+	const form = await loadForm(formResource, options?.form);
+
+	if (form.status === 'failure') {
+		throw form.error;
+	}
+
+	return form.restoreInstance(input, options?.instance);
+};

package/src/error/LoadFormFailureError.ts

@@ -0,0 +1,114 @@
+import type { UnknownObject } from '@getodk/common/lib/type-assertions/assertUnknownObject.ts';
+import type { Primitive } from '@getodk/common/types/Primitive.ts';
+import type { FormResource } from '../client/form/FormResource.ts';
+
+// prettier-ignore
+type PartiallyKnownType<T> =
+	// eslint-disable-next-line @typescript-eslint/sort-type-constituents
+	| T
+	| UnknownObject
+	| Primitive;
+
+/**
+ * A {@link Blob}, which _may be_ a {@link File}.
+ *
+ * Extends {@link Blob} with optional properties corresponding to {@link File}'s
+ * own extensions of the same interface, allowing inspection without an
+ * unnecessary type cast, and without unnecessary runtime/type reconciliation.
+ *
+ * @todo There's almost certainly no reason that this couldn't be a part of the
+ * client-facing {@link FormResource} union type. It's kept internal here for
+ * now, in case that could cause confusion in client integrations.
+ */
+interface MaybeFile extends Blob {
+	readonly lastModified?: PartiallyKnownType<number>;
+	readonly name?: PartiallyKnownType<string>;
+	readonly webkitRelativePath?: PartiallyKnownType<string>;
+}
+
+const blobDescription = (resource: MaybeFile): string => {
+	const { name } = resource;
+
+	if (typeof name === 'string') {
+		return name;
+	}
+
+	let commonConstructorName: 'Blob' | 'File';
+
+	if (resource instanceof File) {
+		commonConstructorName = 'File';
+	} else {
+		commonConstructorName = 'Blob';
+	}
+
+	return `Unknown ${commonConstructorName} data`;
+};
+
+interface FormResourceMetadata {
+	readonly description: string;
+	readonly rawData: string | null;
+}
+
+const formResourceMetadata = (resource: FormResource): FormResourceMetadata => {
+	if (resource instanceof Blob) {
+		return {
+			description: blobDescription(resource),
+			rawData: null,
+		};
+	}
+
+	if (resource instanceof URL) {
+		return {
+			description: resource.href,
+			rawData: null,
+		};
+	}
+
+	return {
+		description: 'Raw string data',
+		rawData: resource,
+	};
+};
+
+/**
+ * @todo This is a placeholder class, given a name so it can be referenced in
+ * client interfaces for form loading. It is pending design of errors (broadly)
+ * and modeling of form loading errors (specifically).
+ */
+export class LoadFormFailureError extends AggregateError {
+	constructor(resource: FormResource, errors: readonly Error[]) {
+		const { description, rawData } = formResourceMetadata(resource);
+		const messageLines: string[] = [
+			`Failed to load form resource: ${description}`,
+			'\n',
+
+			...errors.map((error) => {
+				const aggregatedMessage = error.message;
+
+				if (aggregatedMessage == null) {
+					return '- Unknown error';
+				}
+
+				return `- ${aggregatedMessage}`;
+			}),
+		];
+
+		if (rawData != null) {
+			messageLines.push('\n- - -\n', 'Raw resource data:', rawData);
+		}
+
+		const message = messageLines.join('\n');
+
+		super(errors, message);
+
+		const [head, ...tail] = errors;
+
+		if (head != null && tail.length === 0) {
+			const { stack } = head;
+
+			if (typeof stack === 'string') {
+				this.stack = stack;
+			}
+		}
+	}
+}

package/src/error/MalformedInstanceDataError.ts

@@ -0,0 +1,3 @@
+import { ErrorProductionDesignPendingError } from './ErrorProductionDesignPendingError.ts';
+
+export class MalformedInstanceDataError extends ErrorProductionDesignPendingError {}

package/src/error/RankMissingValueError.ts

@@ -0,0 +1,5 @@
+export class RankMissingValueError extends Error {
+	constructor(message: string) {
+		super(message);
+	}
+}

package/src/error/RankValueTypeError.ts

@@ -0,0 +1,13 @@
+import { XFormsSpecViolationError } from './XFormsSpecViolationError.ts';
+import type { RankDefinition } from '../client/RankNode.ts';
+import type { UnsupportedBaseItemValueType } from '../lib/codecs/items/BaseItemCodec.ts';
+
+export class RankValueTypeError extends XFormsSpecViolationError {
+	constructor(definition: RankDefinition<UnsupportedBaseItemValueType>) {
+		const { valueType } = definition;
+
+		super(
+			`Ranks of type ${valueType} are not currently supported. If this functionality would be useful for your form, your feedback is welcome!`
+		);
+	}
+}

package/src/error/SelectValueTypeError.ts

@@ -0,0 +1,22 @@
+import type { SelectDefinition } from '../client/SelectNode.ts';
+import type { UnsupportedBaseItemValueType } from '../lib/codecs/items/BaseItemCodec.ts';
+import { XFormsSpecViolationError } from './XFormsSpecViolationError.ts';
+
+/**
+ * @todo It would be good to have a standardized way to use specific types of
+ * errors as a prompt for feedback. There is currently a feedback link presented
+ * by `@getodk/web-forms`, which is conditionally displayed (condition is
+ * evidently controlled by a
+ * {@link https://vuejs.org/api/sfc-script-setup#defineoptions | Vue component option}).
+ *
+ * @see {@link https://github.com/getodk/web-forms/issues/276}
+ */
+export class SelectValueTypeError extends XFormsSpecViolationError {
+	constructor(definition: SelectDefinition<UnsupportedBaseItemValueType>) {
+		const { valueType } = definition;
+
+		super(
+			`Selects of type ${valueType} are not currently supported. If this functionality would be useful for your form, your feedback is welcome!`
+		);
+	}
+}

package/src/error/TemplatedNodeAttributeSerializationError.ts

@@ -0,0 +1,24 @@
+/**
+ * This error class is intended as a common point of reference for all of the
+ * related interfaces and implementation where we've deferred two concerns:
+ *
+ * 1. Support for attributes on instance nodes (which may be bound in a form's
+ *    model and/or may be expected to preserve model-defined defaults)
+ * 2. Present lack of logic to treat a `jr:template` attribute as a special
+ *    case: whereas in the general case we would expect to pass through a
+ *    form/model-defined attribute, we expect to specifically **omit**
+ *    `jr:template` from repeat instances derived from any of form's
+ *    explicitly-defined repeat templates
+ *
+ * Addressing #1 is (now) a prerequisite to addressing #2, and it is also a
+ * prerequisite for #2's unaddressed status to _become meaningfully observable
+ * and problematic_.
+ *
+ * By introducing this error at a point where a change in #1's status is likely
+ * to be implicated, we're also likely to be reminded to address #2 in tandem.
+ */
+export class TemplatedNodeAttributeSerializationError extends Error {
+	constructor() {
+		super('Template attribute omission not implemented');
+	}
+}

package/src/error/XFormsSpecViolationError.ts

@@ -0,0 +1 @@
+export abstract class XFormsSpecViolationError extends Error {}

package/src/index.ts

@@ -1,56 +1,2 @@
-import type { InitializeForm } from './index.ts';
-import { initializeForm as engine__initializeForm } from './instance/index.ts';
-
-export const initializeForm: InitializeForm = engine__initializeForm;
-
-export type * from './client/constants.ts';
-export * as constants from './client/constants.ts';
-export type * from './client/EngineConfig.ts';
-export type * from './client/FormLanguage.ts';
-export type * from './client/GroupNode.ts';
-export type {
-	AnyChildNode,
-	AnyControlNode,
-	AnyLeafNode,
-	AnyNode,
-	AnyParentNode,
-	AnyUnsupportedControlNode,
-	GeneralChildNode,
-	GeneralParentNode,
-	RepeatRangeNode,
-} from './client/hierarchy.ts';
-export type * from './client/index.ts';
-export type * from './client/InputNode.ts';
-export type * from './client/ModelValueNode.ts';
-export type * from './client/NoteNode.ts';
-export type * from './client/OpaqueReactiveObjectFactory.ts';
-export type * from './client/repeat/RepeatInstanceNode.ts';
-export type * from './client/repeat/RepeatRangeControlledNode.ts';
-export type * from './client/repeat/RepeatRangeUncontrolledNode.ts';
-export type * from './client/resources.ts';
-export type * from './client/RootNode.ts';
-export type * from './client/SelectNode.ts';
-export type * from './client/submission/SubmissionData.ts';
-export type * from './client/submission/SubmissionDefinition.ts';
-export type * from './client/submission/SubmissionInstanceFile.ts';
-export type * from './client/submission/SubmissionOptions.ts';
-export type * from './client/submission/SubmissionResult.ts';
-export type * from './client/submission/SubmissionState.ts';
-export type * from './client/SubtreeNode.ts';
-export type * from './client/TextRange.ts';
-export type * from './client/TriggerNode.ts';
-export type * from './client/unsupported/RangeNode.ts';
-export type * from './client/unsupported/RankNode.ts';
-export type * from './client/unsupported/UploadNode.ts';
-export type * from './client/validation.ts';
-export type * from './client/ValueType.ts';
-
-// TODO: notwithstanding potential conflicts with parallel work on `web-forms`
-// (former `ui-vue`), these are the last remaining references **outside of
-// `xforms-engine`** to anything besides /client/* and the `initializeForm`
-// entrypoint implementation. We'll refine the various `definition` types in due
-// time.
-export type {
-	AnySelectDefinition,
-	SelectDefinition,
-} from './parse/body/control/select/SelectDefinition.ts';
+export * from './client/index.ts';
+export * from './entrypoints/index.ts';

package/src/instance/Group.ts

@@ -2,11 +2,12 @@ import { XPathNodeKindKey } from '@getodk/xpath';
 import type { Accessor } from 'solid-js';
 import type { GroupDefinition, GroupNode, GroupNodeAppearances } from '../client/GroupNode.ts';
 import type { FormNodeID } from '../client/identity.ts';
-import type { SubmissionState } from '../client/submission/SubmissionState.ts';
+import type { InstanceState } from '../client/serialization/InstanceState.ts';
 import type { TextRange } from '../client/TextRange.ts';
 import type { AncestorNodeValidationState } from '../client/validation.ts';
 import type { XFormsXPathElement } from '../integration/xpath/adapter/XFormsXPathNode.ts';
-import { createParentNodeSubmissionState } from '../lib/client-reactivity/submission/createParentNodeSubmissionState.ts';
+import type { StaticElement } from '../integration/xpath/static-dom/StaticElement.ts';
+import { createParentNodeInstanceState } from '../lib/client-reactivity/instance-state/createParentNodeInstanceState.ts';
 import type { ChildrenState } from '../lib/reactivity/createChildrenState.ts';
 import { createChildrenState } from '../lib/reactivity/createChildrenState.ts';
 import type { MaterializedChildren } from '../lib/reactivity/materializeCurrentStateChildren.ts';
@@ -19,10 +20,10 @@ import { createNodeLabel } from '../lib/reactivity/text/createNodeLabel.ts';
 import { createAggregatedViolations } from '../lib/reactivity/validation/createAggregatedViolations.ts';
 import type { DescendantNodeSharedStateSpec } from './abstract/DescendantNode.ts';
 import { DescendantNode } from './abstract/DescendantNode.ts';
-import { buildChildren } from './children.ts';
+import { buildChildren } from './children/buildChildren.ts';
 import type { GeneralChildNode, GeneralParentNode } from './hierarchy.ts';
 import type { EvaluationContext } from './internal-api/EvaluationContext.ts';
-import type { ClientReactiveSubmittableParentNode } from './internal-api/submission/ClientReactiveSubmittableParentNode.ts';
+import type { ClientReactiveSerializableParentNode } from './internal-api/serialization/ClientReactiveSerializableParentNode.ts';
 
 // prettier-ignore
 interface GroupStateSpec extends DescendantNodeSharedStateSpec {
@@ -39,7 +40,7 @@ export class Group
 		GroupNode,
 		XFormsXPathElement,
 		EvaluationContext,
-		ClientReactiveSubmittableParentNode<GeneralChildNode>
+		ClientReactiveSerializableParentNode<GeneralChildNode>
 {
 	private readonly childrenState: ChildrenState<GeneralChildNode>;
 
@@ -52,12 +53,17 @@ export class Group
 	// GroupNode
 	readonly nodeType = 'group';
 	readonly appearances: GroupNodeAppearances;
+	readonly nodeOptions = null;
 	readonly currentState: MaterializedChildren<CurrentState<GroupStateSpec>, GeneralChildNode>;
 	readonly validationState: AncestorNodeValidationState;
-	readonly submissionState: SubmissionState;
+	readonly instanceState: InstanceState;
 
-	constructor(parent: GeneralParentNode, definition: GroupDefinition) {
-		super(parent, definition);
+	constructor(
+		parent: GeneralParentNode,
+		instanceNode: StaticElement | null,
+		definition: GroupDefinition
+	) {
+		super(parent, instanceNode, definition);
 
 		this.appearances = definition.bodyElement.appearances;
 
@@ -65,10 +71,6 @@ export class Group
 
 		this.childrenState = childrenState;
 
-		const sharedStateOptions = {
-			clientStateFactory: this.engineConfig.stateFactory,
-		};
-
 		const state = createSharedNodeState(
 			this.scope,
 			{
@@ -83,7 +85,7 @@ export class Group
 				valueOptions: null,
 				value: null,
 			},
-			sharedStateOptions
+			this.instanceConfig
 		);
 
 		this.state = state;
@@ -95,8 +97,8 @@ export class Group
 		);
 
 		childrenState.setChildren(buildChildren(this));
-		this.validationState = createAggregatedViolations(this, sharedStateOptions);
-		this.submissionState = createParentNodeSubmissionState(this);
+		this.validationState = createAggregatedViolations(this, this.instanceConfig);
+		this.instanceState = createParentNodeInstanceState(this);
 	}
 
 	getChildren(): readonly GeneralChildNode[] {